Introducción a Oracle NoSQL Database Cloud Service

Enlaces Rápidos

Puede empezar a utilizar Oracle NoSQL Database Service desde uno de los siguientes enlaces rápidos:

Tabla - Enlaces rápidos


Introducción Inicio rápido: Introducción Funciones clave Conceptos de la nube Precios	Conectar Obtenga sus credenciales Autenticación para conectarse a NDCS Conexión de la aplicación a NDCS Regiones de datos y puntos finales de servicio asociados	IDE y SDK Uso del plugin IntelliJ para desarrollo Uso de la extensión de código de Visual Studio para el desarrollo Oracle NoSQL Java SDK SDK de Python NoSQL de Oracle Oracle NoSQL GO SDK SDK de Oracle NoSQL Node.js SDK de Dotnet de Oracle NoSQL SDK de Rust de Oracle NoSQL
Create Tables Diseño de una Tabla Uso de la Consola para Crear Tablas Singleton Uso de API para Crear Tablas Singleton Tablas activas globales Uso de la consola para crear una tabla activa global Uso de API para crear una tabla activa global Uso de la CLI de OCI para crear una tabla	Colocar y explorar datos Uso de la consola para agregar datos Uso de API para agregar datos Uso de la consola para recuperar datos Uso de la API Get para recuperar datos Uso de la API de Consulta para Recuperar Datos Consulta de tablas principal-secundario	Manage Tables Modificación de Tablas Singleton mediante API Modificación de tablas activas globales mediante API Borrado de tablas e índices Gestión de tablas e índices mediante la consola
Gestionar Seguridad Configuración de políticas y grupos de usuarios Cómo otorgar permiso a otro usuario para gestionar tablas NoSQL Referencia de política	Supervisión del servicio Eventos de servicio Cuotas de servicio Métricas Creación y gestión de alarmas	Utilidades Descargar Oracle NoSQL Database Cloud Simulator Desarrollo en el simulador de Oracle NoSQL Database Cloud Uso de Oracle NoSQL Database Migrator Uso de Oracle NoSQL Database Analytics Integrator
Referencia SQL Uso de los operadores en SQL Ordenación de la agrupación y limitación de datos Uso de Expresiones Primarias en SQL Uso de Funciones de Registro de Hora en Consultas Uso de Funciones de Cadena en Consultas	Guías de Referencia Referencia de integrador de análisis Casos de uso de ejemplo para NDCS Solución de problemas con GAT

Configuración del servicio

Si está configurando Oracle NoSQL Database Cloud Service por primera vez, siga estas tareas como guía.

Tarea	Referencia	Información relacionada
Realizar un pedido de Oracle NoSQL Database Cloud Service o registrarse para la Oracle Free Trial.	Registro en Oracle Cloud Infrastructure en la documentación de Oracle Cloud Infrastructure.	Para obtener más información sobre cómo calcular el coste mensual de la suscripción de Oracle NoSQL Database Cloud Service, consulte Estimación del coste mensual. Para cambiar la versión de la cuenta gratuita o el método de pago, consulte Cambio del método de pago en la documentación de Oracle Cloud Infrastructure.
Activación de la cuenta de Oracle Cloud y conectarse por primera vez.	Conexión a la consola en la documentación de Oracle Cloud Infrastructure.	Para familiarizarse con la Oracle Cloud Consola de infraestructura, consulte Uso de la consola en la documentación de Oracle Cloud Infrastructure.
(Recomendado) Creación de un compartimento para el servicio.	Creación de un compartimento	Si no está familiarizado con los compartimentos, consulte Descripción de los compartimentos en la documentación de Oracle Cloud Infrastructure.
Gestione la seguridad del servicio.	Acerca del modelo de seguridad de Oracle NoSQL Database Cloud Service	Para familiarizarse con el modelo de seguridad de NoSQL Database Cloud, consulte Acerca del modelo de seguridad de Oracle NoSQL Database Cloud Service.

Acceso al servicio desde la consola de Infrastructure

Aprenda a acceder al servicio Oracle NoSQL Database Cloud Service desde la consola de Infrastructure.

Busque la URL de servicio en el correo electrónico de bienvenida y, a continuación, conéctese a Oracle NoSQL Database Cloud Service.
Haga clic en Bases de datos y, a continuación, en NoSQL Base de datos.
Seleccione el compartimento creado para las tablas por el administrador de servicio.

Para ver la ayuda de la página actual, haga clic en el icono de ayuda

en la parte superior de la página.

Creación de un compartimento

Al registrarse en Oracle Cloud Infrastructure, Oracle crea el arrendamiento con un compartimento raíz que contiene todos los recursos en la nube. A continuación, puede crear compartimentos adicionales en el arrendamiento (compartimento raíz) y las políticas correspondientes para controlar el acceso a los recursos de cada compartimento. Antes de crear una tabla de Oracle NoSQL Database Cloud Service, Oracle recomienda configurar el compartimento al que desea pertenecer a la tabla.

Cree compartimentos en Oracle Cloud Infrastructure Identity and Access Management (IAM). Consulte Configuración de arrendamiento y Gestión de compartimentos en la documentación de Oracle Cloud Infrastructure.

Autenticación para conectarse a Oracle NoSQL Database

necesita una cuenta de Oracle Cloud para conectar su aplicación a Oracle NoSQL Database Cloud Service.

Si aún no tiene una cuenta de Oracle Cloud, puede empezar con Oracle Cloud. Debe autenticarse cuando se conecta a Oracle NoSQL Database. Puede autenticarse de una de las siguientes maneras:

Método de autenticación n.o 1: principales de usuario

Aquí puede utilizar un usuario de OCI y una clave de API para la autenticación. Las credenciales que se utilizan para conectar la aplicación se asocian a un usuario específico. Si desea crear un usuario para la aplicación, consulte Configuración de usuarios, grupos y políticas mediante Identity and Access Management.

Puede proporcionar sus credenciales para este método de autenticación mediante una de las siguientes formas:

Mediante un archivo de un disco local, el archivo contiene detalles como el OCID de usuario, el OCID de arrendamiento, la región, la ruta de clave privada y la huella. Puede utilizarlo si trabaja desde una red segura y el almacenamiento local de claves y configuraciones privadas cumple las políticas de seguridad.
Proporcionar las credenciales a través de una API.
Almacenamiento de las credenciales en un almacén en algún lugar.

Información que contienen las credenciales:

Tabla - Credenciales

¿Qué Es Esto?	¿Dónde encontrarlo?
ID de arrendamiento e ID de usuario (ambos son OCID)	Consulte Dónde obtener el OCID del arrendamiento y el OCID del usuario en la documentación de Oracle Cloud Infrastructure.
Clave de firma de API	Para el usuario de la aplicación, se debe generar y cargar una clave de firma de API. Si ya se ha realizado, este paso se puede omitir. Para obtener más información, consulte los siguientes recursos en la documentación de Oracle Cloud Infrastructure: Cómo generar una clave de firma de API para generar la clave de firma con una contraseña opcional. Cómo cargar la clave pública para cargar la clave de firma de API en la cuenta del usuario.
Huella para la clave de firma y frase de contraseña (opcional) para la clave de firma	Al generar y cargar la clave de conexión de API, se crean la huella y contraseña de la clave de conexión. Consulte Cómo obtener la huella de la clave en la documentación de Oracle Cloud Infrastructure.

Sugerencia:

Tome nota de la ubicación de su clave privada, contraseña opcional y huella de la clave pública al generar y cargar la clave de firma de API.

Después de realizar las tareas descritas anteriormente, recopile la información de las credenciales y proporciónela a la aplicación.

Proporcionar las credenciales a la aplicación:

Los SDK de Oracle NoSQL Database permiten proporcionar las credenciales a una aplicación de varias formas. Los SDK admiten un archivo de configuración, así como una o más interfaces que permiten la especificación directa de la información. Consulte la documentación del controlador de lenguaje de programación que utiliza para conocer las interfaces de credenciales específicas.

Si utiliza un archivo de configuración, la ubicación por defecto es ~/.oci/config. Los SDK permiten que el archivo resida en ubicaciones alternativas. Su contenido tiene el aspecto siguiente:

[DEFAULT]
user=ocid1.user.oc1..aaaaaaaas...7ap
fingerprint=d1:b2:32:53:d3:5f:cf:68:2d:6f:8b:5f:77:8f:07:13
key_file=~/.oci/oci_api_key_private.pem
tenancy=ocid1.tenancy.oc1..aaaaaaaap...keq
pass_phrase=mysecretphrase

La línea [DEFAULT] indica que las líneas que siguen especifican el perfil DEFAULT. Un archivo de configuración puede incluir varios perfiles con el prefijo [PROFILE_NAME]. Por ejemplo:

[DEFAULT]
user=ocid1.user.oc1..aaaaaaaas...7us
fingerprint=d1:b2:32:53:d3:5f:cf:68:2d:6f:8b:5f:77:8f:07:15
key_file=~/.oci/oci_api_key_private.pem
tenancy=ocid1.tenancy.oc1..aaaaabbap...keq
pass_phrase=mysecretphrase

[MYPROFILE]
user=ocid1.user.oc1..aaaaaaaas...7ap
fingerprint=d1:b2:32:53:d3:5f:cf:68:2d:6f:8b:5f:77:8f:07:13
key_file=~/.oci/oci_api_key_private.pem
tenancy=ocid1.tenancy.oc1..aaaaaaaap...keq
pass_phrase=mysecretphrase

Método de autenticación n.o 2: principales de instancia

Instance Principals es una capacidad de Oracle Cloud Infrastructure Identity and Access Management (IAM) que permite realizar llamadas de servicio desde una instancia. Con los principales de instancia, no necesita configurar credenciales de usuario para los servicios que se ejecutan en sus instancias informáticas ni rotar las credenciales. Las propias instancias ahora son un tipo de principal en IAM. Todas las instancias informáticas tienen su propia identidad y se autentican mediante los certificados que se agregan a la instancia. Estos certificados se crean automáticamente, se asignan a instancias y se rotan.

Mediante la autenticación de principales de instancia, puede autorizar a una instancia para que realice llamadas a la API en servicios de Oracle Cloud Infrastructure. Después de configurar los recursos y las políticas necesarios, una aplicación que se ejecuta en una instancia puede llamar a los servicios públicos de Oracle Cloud Infrastructure, eliminando la necesidad de configurar las credenciales de usuario o un archivo de configuración. La autenticación de principal de instancia se puede utilizar desde una instancia en la que no desea almacenar un archivo de configuración.

Método de autenticación n.o 3: entidades de recurso

Puede utilizar una entidad de recurso para autenticar los recursos de Oracle Cloud Infrastructure y acceder a ellos. La entidad de recurso consta de un token de sesión temporal y credenciales seguras que permiten a otros servicios de Oracle Cloud autenticarse en Oracle NoSQL Database. La autenticación de entidad de recurso es muy similar a la autenticación de principal de instancia, pero está destinada a recursos que no son instancias, como las funciones sin servidor.

Una entidad de recurso permite que los recursos estén autorizados para realizar acciones en los servicios de Oracle Cloud Infrastructure. Todos los recursos tienen su propia identidad y se autentican con los certificados que tiene agregados. Estos certificados se crean automáticamente, se asignan a recursos y se rotan, lo que evita la necesidad de crear y gestionar sus propias credenciales para acceder al recurso. Al autenticarse mediante una principal de recurso, no necesita crear ni gestionar credenciales para acceder a los recursos de Oracle Cloud Infrastructure.

Una vez autenticado, necesita estar autorizado para acceder a los recursos de Oracle Cloud Infrastructure. Consulte Configuración de usuarios, grupos y políticas mediante Identity and Access Management para obtener más información.

Método de autenticación n.o 4: Autenticación por token:

La autenticación basada en token permite crear y utilizar un token de sesión temporal para autenticar y acceder a los recursos de Oracle Cloud Infrastructure. Mediante la autenticación basada en token, cree un archivo de configuración local que contenga información como el OCID de usuario, el OCID de arrendamiento, la región, la ruta de acceso de clave privada y una ruta de acceso de archivo de token de sesión temporal. Este método utiliza esta información junto con el token de sesión temporal, que caduca en una hora (valor por defecto). La autenticación basada en token de sesión se puede utilizar cuando necesite autenticación rápida y temporal.

Creación de un token de sesión: puede generar un token de sesión con o sin un explorador web.

Con un explorador:

Para utilizar la autenticación basada en token para CLI en una computadora con un explorador web:

En el terminal, ejecute el siguiente comando:
```
oci session authenticate
```
Seleccionar una región.
En el explorador, introduzca sus credenciales de usuario.
Después de la autenticación correcta, cierre el explorador y siga el indicador interactivo en el terminal. Debe proporcionar el nombre del perfil que desea crear en el archivo de configuración. La nueva configuración de perfil se escribe en el archivo ~/.oci/config. A continuación se muestra un ejemplo del archivo de configuración donde se actualiza el nuevo perfil (por ejemplo, TEST).
```
[TEST]
user=<ocid1.user.oc1.........>
fingerprint=<XX:XX:...........>
key_file=<C:\Users\XXXXXX\.oci\oci_api_key_private.pem>
tenancy=<ocid1.tenancy.oc1.....>
region=us-ashburn-1
security_token_file=<C:\Users\XXXXXX\.oci\sessions\TEST\token>
```

Sin un explorador:

Para utilizar la autenticación basada en token para la CLI sin un explorador web, primero debe autenticarse mediante la autenticación basada en clave de API.

oci setup config

Este comando le solicita la información necesaria para crear el archivo de configuración y las claves públicas y privadas de API. El cuadro de diálogo de configuración utiliza esta información para generar un par de claves de API y crea el archivo de configuración. Para utilizar la autenticación basada en token para CLI sin un explorador web, ejecute el siguiente comando:

oci session authenticate --no-browser

Debe proporcionar el nombre del perfil que desea crear en el archivo de configuración. La nueva configuración de perfil se escribe en el archivo ~/.oci/config. A continuación se muestra un ejemplo del archivo de configuración donde se actualiza el nuevo perfil (por ejemplo, TEST).

[TEST]
user=<ocid1.user.oc1.........>
fingerprint=<XX:XX:...........>
key_file=<full_directory_path_oci_api_key_private.pem>
tenancy=<ocid1.tenancy.oc1.....>
region=us-ashburn-1
security_token_file=<full_directory_path_token>

Método de autenticación n.o 5: Autenticación basada en identidad de carga de trabajo de OKE:

La identidad de carga de trabajo de Oracle Container Engine for Kubernetes (OKE) proporciona un control detallado de la gestión de identidad y acceso. Una carga de trabajo es una aplicación que se ejecuta en Kubernetes. Se puede componer de un único componente o de varios componentes que funcionan juntos dentro de un juego de pods. Un recurso de carga de trabajo se identifica mediante la combinación única de cluster, espacio de nombres y cuenta de servicio. Esta combinación única se denomina identidad de carga de trabajo. La identidad de carga de trabajo de OKE permite otorgar acceso controlado por política de pods K8s a recursos de Oracle Cloud Infrastructure (OCI) mediante OCI Identity and Access Management (IAM).

Con Workload Identity, ya no es necesario almacenar credenciales como secretos en el cluster de Kubernetes ni depender de grupos dinámicos de OCI para el acceso basado en políticas de nodos de trabajador a los recursos de OCI y, más específicamente, el acceso a las tablas NoSQL. Cuando las aplicaciones requieren acceso a los recursos de OCI, Workload Identity le permite escribir políticas de OCI IAM con ámbito en la cuenta de servicio de Kubernetes asociada a los pods de aplicaciones. Esta función permite a las aplicaciones que se ejecutan dentro de estos pods acceder directamente a la API de OCI en función de los permisos proporcionados por las políticas.

Para otorgar a todos los pods de una carga de trabajo acceso a cualquier recurso de OCI:

Cree un espacio de nombres para una cuenta de servicio.
Cree una cuenta de servicio para que la aplicación la utilice.
Defina una política de IAM para otorgar acceso al recurso de carga de trabajo a otros recursos de OCI.
Descargue y configure el SDK adecuado para el idioma en el que está escrita la aplicación.
Edite la aplicación para especificar:
- que las solicitudes de carga de trabajo se deben autenticar mediante el proveedor de identidad de carga de trabajo de Kubernetes Engine
- los recursos de OCI a los que se va a acceder
Actualice la especificación de despliegue de la aplicación para especificar que cada pod de la carga de trabajo utilice la cuenta de servicio.

Autorización para permitir que la carga de trabajo acceda a los recursos de OCI necesarios:

En la consola de OCI, abra el menú de navegación y haga clic en Identidad y seguridad. En Identidad, haga clic en Políticas.
Haga clic en Crear política y asigne un nombre a la política.

Introduzca una sentencia de política para permitir que la carga de trabajo acceda a los recursos de OCI necesarios, con el formato que se muestra a continuación:

Allow any-user to <verb> <resource> in <location> where all
{
request.principal.type = 'workload', 
request.principal.namespace = '<namespace-name>', 
request.principal.service_account = '<service-account-name>', 
request.principal.cluster_id = '<cluster-ocid>'
}

donde:

<namespace-name> es el nombre del espacio de nombres que ha creado anteriormente.
<service-account-name> es el nombre de la cuenta de servicio que ha creado anteriormente.
<cluster-OCID> es el OCID del cluster que ha obtenido anteriormente.

Haga clic en Crear para crear la nueva política.

Conexión de la aplicación a NDCS

Descubra cómo conectar su aplicación a Oracle NoSQL Database Cloud Service.

La aplicación se conecta a Oracle NoSQL Database Cloud Service después de autenticarse mediante uno de los muchos métodos disponibles.

Puede autenticarse mediante una de las siguientes opciones:

clave de firma de API
- Desde cualquier programa SDK (Java, Python, C#, GO, Node.js, Rust) codificado directamente
- Un archivo de configuración con un perfil por defecto
- Un archivo de configuración con un perfil no predeterminado
Entidades de seguridad de instancia con tokens de autenticación
Principales de recursos
Token de sesión
Identidad de carga de trabajo de OKE

Consulte Autenticación para conectarse a Oracle NoSQL Database para obtener más información sobre las opciones de autenticación.

Puede conectarse a NDCS mediante uno de los siguientes métodos:

Proporcionar credenciales directamente en el código:

/* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * By default, the SignatureProvider will read your OCI configuration file 
 * from the default location, ~/.oci/config. See SignatureProvider for 
 * additional options for reading configurations in other ways.*/
SignatureProvider sp = new SignatureProvider(
 tenantId,     // a string, OCID
 userId,       // a string, OCID
 fingerprint , // a string
 privateKey,   // a string, content of private key
 passPhrase    // optional, char[]
);
//Create an handle to access the cloud service in your service region.
NoSQLHandleConfig config = new NoSQLHandleConfig(Region.<your-service-region>);
config.setAuthorizationProvider(sp);
NoSQLHandle handle = NoSQLHandleFactory.createNoSQLHandle(config);

//At this point, your handle is set up to perform data operations.

Conexión mediante el archivo de configuración por defecto con un perfil por defecto:

/* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * By default, the SignatureProvider will read your OCI configuration file 
 * from the default location, ~/.oci/config. See SignatureProvider for 
 * additional options for reading configurations in other ways. */
SignatureProvider sp = new SignatureProvider();

Conexión mediante el archivo de configuración por defecto con un perfil no por defecto:

/* Use the SignatureProvider to supply your credentials to NoSQL Database. 
* Specify the name of the non-default profile in the construtor for SignatureProvider. 
*/
final String profile_name = "<name_of_the_profile>";
SignatureProvider sp = new SignatureProvider(profile_name);

Conectando mediante el perfil y el archivo de configuración especificados:

/* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * You specify the full path of the non-default config file and also the name 
 * of the profile
 */
final String config_filepath = "<full_path_of_config_file>";
final String profile_name = "<name_of_the_profile>";
SignatureProvider sp = new SignatureProvider(config_filepath, profile_name);

Conexión mediante un principal de instancia:
El principal de instancia es una función del servicio IAM que permite que las instancias sean actores (o principales) autorizados para realizar acciones en recursos del servicio. Cada una de las instancias informáticas tiene su propia identidad y se autentica con los certificados que tiene agregados.
```
SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();
```
Conexión mediante una entidad de recurso:
La entidad de recurso es una función de servicio IAM que permite que los recursos sean actores (o principales) autorizados para realizar acciones en recursos de servicio.
```
SignatureProvider authProvider = SignatureProvider.createWithResourcePrincipal();
```
Conexión mediante token de sesión:
Utilice el método createWithSessionToken() para crear un SignatureProvider mediante una lectura de token de sesión temporal de un archivo de token. La ruta del archivo de token se lee desde el perfil por defecto en el archivo de configuración en la ubicación por defecto. El archivo de configuración utilizado es ~/.oci/config.
```
SignatureProvider authProvider = 
SignatureProvider.createWithSessionToken();
```
También puede proporcionar la ruta del archivo de token en el perfil no por defecto en el archivo de configuración, como se muestra a continuación. La ruta del archivo de token se lee desde el perfil especificado en el archivo de configuración en la ubicación por defecto.
```
SignatureProvider authProvider = 
SignatureProvider.createWithSessionToken(<profile_name>);
```
Conexión mediante la identidad de carga de trabajo de OKE:
Puede crear un SignatureProvider con identidad de carga de trabajo de Container Engine for Kubernetes (OKE) mediante el token de cuenta de servicio de Kubernetes en la ruta por defecto /var/run/secrets/kubernetes.io/serviceaccount/token. Este proveedor solo se puede utilizar dentro de pods de Kubernetes.
```
SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity();
```
También puede especificar el token de cuenta de servicio de Kubernetes específico que se utilizará como se muestra a continuación.
```
SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken>);
```
También puede especificar la ubicación del token de cuenta de servicio de Kubernetes específico que se utilizará como se muestra a continuación.
```
SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken_location>);
```

Consulte SignatureProvider para obtener más información sobre las clases Java utilizadas.

Puede conectarse a NDCS mediante uno de los siguientes métodos:

Proporcionar credenciales directamente en el código:

from borneo.iam import SignatureProvider
#
# Use SignatureProvider directly via API. Note that the
# private_key argument can either point to a key file or be the
# string content of the private key itself.
#
at_provider = SignatureProvider(tenant_id='ocid1.tenancy.oc1..tenancy',
                                user_id='ocid1.user.oc1..user',
                                private_key=key_file_or_key, 
                                fingerprint='fingerprint',   
                                pass_phrase='mypassphrase')

Conexión mediante el archivo de configuración por defecto con un perfil por defecto:

from borneo.iam import SignatureProvider
#
# Use SignatureProvider with a default credentials file and
# profile in $HOME/.oci/config
#
at_provider = SignatureProvider()

Conectando mediante el archivo de configuración especificado con un perfil no predeterminado:

from borneo.iam import SignatureProvider
#
# Use SignatureProvider with a non-default credentials file and profile
#
at_provider = SignatureProvider(config_file='myconfigfile', 
                                profile_name='myprofile')

Conexión mediante un principal de instancia:
El principal de instancia es una función del servicio IAM que permite que las instancias sean actores (o principales) autorizados para realizar acciones en recursos del servicio. Cada una de las instancias informáticas tiene su propia identidad y se autentica con los certificados que tiene agregados.
```
at_provider =
SignatureProvider.create_with_instance_principal(region=my_region)
```
Conexión mediante una entidad de recurso:
La entidad de recurso es una función de servicio IAM que permite que los recursos sean actores (o principales) autorizados para realizar acciones en recursos de servicio.
```
at_provider = SignatureProvider.create_with_resource_principal()
```

Conexión mediante token de sesión:

Borneo utiliza el SDK de OCI para la autenticación mediante tokens de sesión. El firmante de OCI se transfiere como parámetro al constructor SignatureProvider, como se muestra a continuación.

from borneo.iam import SignatureProvider 
# Use SignatureProvider with a provider argument which is an instance of  
# oci.auth.signers.SecurityTokenSigner
at_provider = SignatureProvider(<instance of oci.auth.signers.SecurityTokenSigner>)

Conexión mediante la identidad de carga de trabajo de OKE:
El firmante de autenticación de carga de trabajo de OKE es un firmante que otorga a toda una carga de trabajo (una aplicación que se ejecuta en clusters de Kubernetes) acceso a las tablas NoSQL mediante la identidad de carga de trabajo de OKE. Se puede recuperar mediante oci.auth.signers.get_oke_workload_identity_resource_principal_signer. El firmante recuperado se puede utilizar al inicializar un cliente.
```
from borneo.iam import SignatureProvider
oke_workload_signer = oci.auth.signers.get_oke_workload_identity_resource_principal_signer()
```
Si tiene una ruta de token de cuenta de servicio de Kubernetes diferente de la ruta por defecto, puede especificar la ruta como se muestra a continuación:
```
token_path = "path_to_your_token_file"
oke_workload_signer  = oci.auth.signers.get_oke_workload_identity_resource_principal_signer(service_account_token_path=token_path)
at_provider = SignatureProvider(oke_workload_signer)
```
También puede transferir directamente el token de cuenta de servicio de Kubernetes como se muestra a continuación:
```
#token_string = "your_token_string"
#oke_workload_signer = oci.auth.signers.get_oke_workload_identity_resource_principal_signer(service_account_token=token_string)
at_provider = SignatureProvider(oke_workload_signer)
```

Puede conectar la aplicación a NDCS mediante cualquiera de los siguientes métodos:

Proporcionar credenciales directamente en el código:

privateKeyFile := "/path/to/privateKeyFile"
passphrase := "examplepassphrase"
sp, err := iam.NewRawSignatureProvider("ocid1.tenancy.oc1..tenancy",
                                       "ocid1.user.oc1..user",
                                       "<your-service-region>", 
                                       "fingerprint", 
                                       "compartmentID", 
                                       privateKeyFile ,
                                       &passphrase )
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    // This is only required if the "region" property is not 
    //specified in the config file.
    Region: "<your-service-region>",
}

Conexión mediante el archivo de configuración por defecto con un perfil por defecto:

cfg := nosqldb.Config{
// This is only required if the "region" property is not 
//specified in ~/.oci/config.
// This takes precedence over the "region" property when both are specified.
    Region: "<your-service-region>", 
}
client, err := nosqldb.NewClient(cfg)

Conectando mediante el archivo de configuración especificado con un perfil no predeterminado:

sp, err := iam.NewSignatureProviderFromFile("your_config_file_path", 
           "your_profile_name", "", "compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    // This is only required if the "region" property is not specified in the config file.
    Region: "us-ashburn-1",
}
client, err := nosqldb.NewClient(cfg)

Conexión mediante un principal de instancia:
El principal de instancia es una función del servicio IAM que permite que las instancias sean actores (o principales) autorizados para realizar acciones en recursos del servicio. Cada una de las instancias informáticas tiene su propia identidad y se autentica con los certificados que tiene agregados.
```
sp, err := iam.NewSignatureProviderWithInstancePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)
```

Conexión mediante una entidad de recurso:

La entidad de recurso es una función de servicio IAM que permite que los recursos sean actores (o principales) autorizados para realizar acciones en recursos de servicio.

sp, err := iam.NewSignatureProviderWithResourcePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)

Conexión mediante token de sesión:
La función NewSessionTokenSignatureProvider crea un SignatureProvider mediante una lectura de token de sesión temporal de un archivo de token.
```
func NewSessionTokenSignatureProvider() (*SignatureProvider, error)
```
El archivo de configuración utilizado es ~/.oci/config. Se utiliza el perfil DEFAULT. La ruta del archivo de token se lee desde la configuración, utilizando el valor del campo security_token_file. Al utilizar este constructor, el usuario tiene un compartimento por defecto para todas las tablas. Es el compartimento raíz del arrendamiento del usuario.
Para utilizar un archivo de configuración no por defecto (que no sea ~/.oci/config), puede utilizar la función NewSessionTokenSignatureProviderFromFile.
```
func NewSessionTokenSignatureProviderFromFile(configFilePath, 
ociProfile, privateKeyPassphrase string) (*SignatureProvider, error)
```
Esta función crea un SignatureProvider mediante una lectura de token de sesión temporal de un archivo de token, mediante el ociProfile especificado en el archivo de configuración de OCI configFilePath. La ruta del archivo de token se lee desde la configuración, utilizando el valor del campo security_token_file. El campo privateKeyPassphrase solo es necesario si la clave privada utiliza una frase de contraseña y no se especifica en el campo pass_phrase del archivo de configuración de OCI. Al utilizar este constructor, el usuario tiene un compartimento por defecto para todas las tablas. Es el compartimento raíz del arrendamiento del usuario.

Conexión mediante la identidad de carga de trabajo de OKE:

El SDK de Oracle NoSQL go soporta la ejecución de programas dentro de contenedores de carga de trabajo de OKE en OCI. En el código que crea un SignatureProvider para utilizarlo con NoSQL, agregue el siguiente código para utilizar la identidad de carga de trabajo de OKE:

conf, err := ociauth.OkeWorkloadIdentityConfigurationProvider()
if err != nil {
   return nil, fmt.Errorf("cannot create an Oke Provider: %v", err)
}
myconf := &myConfigProvider{conf}
sp, err := iam.NewSignatureProviderWithConfiguration(myconf, compartmentID)
if err != nil {
  return nil, fmt.Errorf("cannot create a Signature Provider: %v", err)
}

Puede conectarse a NDCS mediante uno de los siguientes métodos:

Proporcionar credenciales directamente en el código:

Puede especificar las credenciales directamente como parte de la propiedad auth.iam en la configuración inicial. Cree la instancia NoSQLClient de la siguiente forma:

import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({
    region: <your-service-region>
    auth: {
        iam: {
            tenantId: myTenancyOCID,
            userId: myUserOCID,
            fingerprint: myPublicKeyFingerprint,
            privateKeyFile: myPrivateKeyFile,
            passphrase: myPrivateKeyPassphrase
        }
    }
});

Conexión mediante el archivo de configuración por defecto con un perfil por defecto:

Puede almacenar las credenciales en un archivo de configuración de Oracle Cloud Infrastructure. La ruta de acceso por defecto para el archivo de configuración es ~/.oci/config, donde ~ significa el directorio principal del usuario. En Windows, ~ es un valor de variable de entorno USERPROFILE. El archivo puede contener varios perfiles. Por defecto, el SDK utiliza el perfil denominado DEFAULT para almacenar las credenciales.
Para utilizar estos valores por defecto, cree un archivo denominado config en el directorio ~/.oci con el siguiente contenido:
```
[DEFAULT]
tenancy=<your-tenancy-ocid>
user=<your-user-ocid>
fingerprint=<fingerprint-of-your-public-key>
key_file=<path-to-your-private-key-file>
pass_phrase=<your-private-key-passphrase>
region=<your-region-identifier>
```
Tenga en cuenta que también puede especificar el identificador de región junto con las credenciales en el archivo de configuración de OCI. El controlador observará la ubicación anterior por defecto y, si se proporciona una región junto con las credenciales, no es necesario proporcionar la configuración inicial y puede utilizar el constructor sin argumentos:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient();
```
También puede especificar la región en la configuración:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({ region: Region.<your-service-region> });
```
Conectando mediante el archivo de configuración especificado con un perfil no predeterminado:

Puede utilizar una ruta de acceso diferente para el archivo de configuración de OCI, así como un perfil diferente dentro del archivo de configuración. En este caso, especifíquelos dentro de la propiedad auth.iam de la configuración inicial. Por ejemplo, si la ruta de acceso del archivo de configuración de OCI es ~/myapp/.oci/config y almacena sus credenciales en el perfil Jane:
A continuación, cree la instancia NoSQLClient de la siguiente forma:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({
    region: Region.<your-service-region>,
    auth: {
        iam: {
            configFile: '<your_config_file>',
            profileName: '<name_of_your_profile>'
        }
    }
});
```
Conexión mediante un principal de instancia:

El principal de instancia es una función del servicio IAM que permite que las instancias sean actores (o principales) autorizados para realizar acciones en recursos del servicio. Cada una de las instancias informáticas tiene su propia identidad y se autentica con los certificados que tiene agregados.
Una vez configurada, cree la instancia NoSQLClient de la siguiente forma:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............'
    auth: {
        iam: {
            useInstancePrincipal: true
        }
    }
});
```
También puede utilizar el archivo de configuración JSON con la misma configuración que se ha descrito anteriormente. Tenga en cuenta que al utilizar el principal de instancia, debe especificar el ID de compartimento (OCID) como propiedad de compartimento. Esto es necesario incluso si desea utilizar el compartimento por defecto. Tenga en cuenta que debe utilizar el ID de compartimento y no el nombre o la ruta de acceso del compartimento. Además, al utilizar el principal de instancia, no puede prefijar el nombre de tabla con el nombre de compartimento o la ruta de acceso al llamar a las API de NoSQLClient.
Conexión mediante una entidad de recurso:

La entidad de recurso es una función de servicio IAM que permite que los recursos sean actores (o principales) autorizados para realizar acciones en recursos de servicio.
Una vez configurada, cree la instancia NoSQLClient de la siguiente forma:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    auth: {
        iam: {
            useResourcePrincipal: true
        }
    }
});
```
También puede utilizar el archivo de configuración JSON con la misma configuración que se ha descrito anteriormente. Tenga en cuenta que al utilizar la entidad de recurso, debe especificar el ID de compartimento (OCID) como propiedad de compartimento. Esto es necesario incluso si desea utilizar el compartimento por defecto. Tenga en cuenta que debe utilizar el ID de compartimento y no el nombre o la ruta de acceso del compartimento. Además, al utilizar la entidad de recurso, no puede prefijar el nombre de tabla con el nombre de compartimento o la ruta de acceso al llamar a las API NoSQLClient.
Conexión mediante token de sesión:
Mediante la autenticación basada en token de sesión, cree un archivo de configuración local que contenga información como el OCID de usuario, el OCID de arrendamiento, la región, la ruta de acceso de clave privada y una ruta de acceso de archivo de token de sesión temporal.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............
   ' auth: {
       iam: { useSessionToken: true }  
  }
}); 
```
Este método utiliza una lectura de token de sesión temporal de un archivo de token. La ruta del archivo de token se lee desde el perfil por defecto en el archivo de configuración de OCI como valor del campo security_token_file.
Para utilizar un archivo de configuración no por defecto (que no sea ~/.oci/config), puede especificar la ruta del archivo de configuración y el nombre del perfil, como se muestra a continuación.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
  region: Region.<your-service-region>,
  compartment: 'ocid1.compartment.oc1..............
  ' auth: {
    iam: {  useSessionToken: true,
      "configFile": "<path_to_config_file>",
      "profileName": "<profile_name>"
    }  
  }
});
```
Conexión mediante la identidad de carga de trabajo de OKE:
El SDK de Oracle NoSQL Node.js soporta la ejecución de programas dentro de contenedores de carga de trabajo de OKE en OCI.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    ' auth: {
        iam: { useOKEWorkloadIdentity: true }
    }'
  }
);
```
Este esquema de autorización solo se puede utilizar dentro de la identidad de carga de trabajo de OKE pods.Using de Kubernetes que requiere un token de cuenta de servicio. Por defecto, el proveedor cargará el token de cuenta de servicio desde la ruta de archivo por defecto /var/run/secrets/kubernetes.io/serviceaccount/token . Puede sustituir esto y proporcionar el token de cuenta de servicio especificando una de las 3 propiedades:
- serviceAccountToken para proporcionar una cadena de token de cuenta de servicio.
- serviceAccountTokenFile para proporcionar una ruta al archivo de token de cuenta de servicio.
- serviceAccountTokenProvider para proporcionar un proveedor personalizado para cargar tokens de cuenta de servicio.

Consulte SDK Configuration File para obtener detalles sobre el contenido y el formato del archivo.

Puede conectarse a NDCS mediante uno de los siguientes métodos:

Proporcionar credenciales directamente en el código:

Puede especificar las credenciales directamente como IAMCredentials al crear IAMAuthorizationProvider. Cree NoSQLClient de la siguiente manera:

var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            new IAMCredentials
            {
                TenantId=myTenancyOCID,
                UserId=myUserOCID,
                Fingerprint=myPublicKeyFingerprint,
                PrivateKeyFile=myPrivateKeyFile
            })
    });

Conexión mediante el archivo de configuración por defecto con un perfil por defecto:

Puede almacenar las credenciales en un archivo de configuración de Oracle Cloud Infrastructure. La ruta de acceso por defecto para el archivo de configuración es ~/.oci/config, donde ~ significa el directorio principal del usuario. En Windows, ~ es un valor de variable de entorno USERPROFILE. El archivo puede contener varios perfiles. Por defecto, el SDK utiliza el perfil denominado DEFAULT para almacenar las credenciales
Para utilizar estos valores por defecto, cree un archivo denominado config en el directorio ~/.oci con el siguiente contenido:
```
[DEFAULT]
tenancy=<your-tenancy-ocid>
user=<your-user-ocid>
fingerprint=<fingerprint-of-your-public-key>
key_file=<path-to-your-private-key-file>
pass_phrase=<your-private-key-passphrase>
region=<your-region-identifier>
```
Tenga en cuenta que también puede especificar el identificador de región junto con las credenciales en el archivo de configuración de OCI. Por defecto, el controlador buscará credenciales y una región en el archivo de configuración de OCI en la ruta de acceso por defecto y en el perfil por defecto. Por lo tanto, si proporciona una región junto con las credenciales como se muestra anteriormente, puede crear una instancia NoSQLClient sin transferir ninguna configuración:
```
var client = new NoSQLClient();
```
También puede especificar la región (así como otras propiedades) en NoSQLConfig:
```
var client = new NoSQLClient(
    new NoSQLConfig(
    {
        Region = Region.<your-service-region>,
        Timeout = TimeSpan.FromSeconds(10),
    });
```
Conectando mediante el archivo de configuración especificado con un perfil no predeterminado:

Puede utilizar una ruta de acceso diferente para el archivo de configuración de OCI, así como un perfil diferente dentro del archivo de configuración. En este caso, especifíquelos dentro de la propiedad auth.iam de la configuración inicial. Por ejemplo, si la ruta de acceso del archivo de configuración de OCI es ~/myapp/.oci/config y almacena sus credenciales en el perfil Jane:
A continuación, cree la instancia NoSQLClient de la siguiente forma:
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = Region.<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            "<your_config_file>", "<your_profile_name>")
    });
```
Conexión mediante un principal de instancia:
El principal de instancia es una función del servicio IAM que permite que las instancias sean actores (o principales) autorizados para realizar acciones en recursos del servicio. Cada una de las instancias informáticas tiene su propia identidad y se autentica con los certificados que tiene agregados. Una vez configurada, cree la instancia NoSQLClient de la siguiente forma:
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        Compartment="ocid1.compartment.oc1.............................",
        AuthorizationProvider=IAMAuthorizationProvider.CreateWithInstancePrincipal()
    });
```
También puede representar la misma configuración en JSON de la siguiente manera:
```
{
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseInstancePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}
```
Tenga en cuenta que al utilizar el principal de instancia, debe especificar el ID de compartimento (OCID) como propiedad compartment. Esto es necesario incluso si desea utilizar el compartimento por defecto. Tenga en cuenta que debe utilizar el ID de compartimento y no el nombre o la ruta de acceso del compartimento. Además, al utilizar el principal de instancia, no puede prefijar el nombre de tabla con el nombre de compartimento o la ruta de acceso al llamar a las API de NoSQLClient.
Conexión mediante una entidad de recurso:
La entidad de recurso es una función de servicio IAM que permite que los recursos sean actores (o principales) autorizados para realizar acciones en recursos de servicio. Una vez configurada, cree la instancia NoSQLClient de la siguiente forma:
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = <your-service-region>,
        Compartment =
            "ocid1.compartment.oc1.............................",
        AuthorizationProvider =
            IAMAuthorizationProvider.CreateWithResourcePrincipal()
    });
```
También puede representar la misma configuración en JSON de la siguiente manera:
```
{
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseResourcePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}
```
Tenga en cuenta que al utilizar la entidad de recurso, debe especificar el ID de compartimento (OCID) como propiedad compartment. Esto es necesario incluso si desea utilizar el compartimento por defecto. Tenga en cuenta que debe utilizar el ID de compartimento y no el nombre o la ruta de acceso del compartimento. Además, al utilizar la entidad de recurso, no puede prefijar el nombre de tabla con el nombre de compartimento o la ruta de acceso al llamar a las API NoSQLClient.
Conexión mediante token de sesión:

Mediante la autenticación basada en token de sesión, cree un archivo de configuración local que contenga información como el OCID de usuario, el OCID de arrendamiento, la región, la ruta de acceso de clave privada y una ruta de acceso de archivo de token de sesión temporal.

Puede utilizar la autenticación basada en token de sesión mediante uno de los tres métodos que se muestran a continuación.
Opción 1: crea una nueva instancia de IAMAuthorizationProvider mediante la autenticación basada en token de sesión con el archivo de configuración de OCI por defecto y el nombre de perfil por defecto.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken()
});
```
Opción 2: crea una nueva instancia de IAMAuthorizationProvider mediante la autenticación basada en token de sesión con el archivo de configuración de OCI por defecto y el nombre de perfil especificado.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<profileName>)
});
```
Opción 3: crea una nueva instancia de IAMAuthorizationProvider mediante la autenticación basada en token de sesión con el nombre de perfil y el archivo de configuración de OCI especificados.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<configFile>,<profileName>)
});
```
También puede representar la misma configuración en JSON de la siguiente manera:
```
{
  "Region": "<your-service-region>",
  "AuthorizationProvider": {
    "AuthorizationType": "IAM",
    "UseSessionToken": true
  },
  "Compartment": "ocid1.compartment.oc1............................."
}
```
Conexión mediante la identidad de carga de trabajo de OKE:

El SDK de Dotnet NoSQL de Oracle soporta la ejecución de programas dentro de contenedores de carga de trabajo de OKE en OCI.
En el siguiente ejemplo, se crea una nueva instancia de IAMAuthorizationProvider mediante la identidad de carga de trabajo de OKE. Este método permite especificar una cadena de token de cuenta de servicio opcional. Si no se especifica, el token de cuenta de servicio se leerá desde la ruta de archivo por defecto /var/run/secrets/kubernetes.io/serviceaccount/token.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithOKEWorkloadIdentity()
});
```
También puede crear una nueva instancia de IAMAuthorizationProvider mediante la identidad de carga de trabajo de OKE y el archivo de token de cuenta de servicio especificado, como se muestra a continuación.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = 
    IAMAuthorizationProvider.CreateWithOKEWorkloadIdentityAndTokenFile(<serviceAccountTokenFile>)
});
```
También puede representar la misma configuración en JSON de la siguiente manera:
```
{ "Region": "<your-service-region>",  
 "AuthorizationProvider":  {
   "AuthorizationType": "IAM",
   "UseOKEWorkLoadIdentity": true 
 },
 "Compartment": "ocid1.compartment.oc1.............................",
}
```

Puede conectarse a NDCS mediante uno de los siguientes métodos:

Conexión mediante el archivo de configuración por defecto con un perfil por defecto:

Puede almacenar las credenciales en un archivo de configuración de Oracle Cloud Infrastructure. La ruta predeterminada para el archivo de configuración es ~/.oci/config, donde ~ representa el directorio raíz del usuario. En Windows, ~ es un valor de variable de entorno USERPROFILE. El archivo puede contener varios perfiles. Por defecto, el SDK utiliza el perfil denominado DEFAULT para almacenar las credenciales
Para utilizar estos valores por defecto, cree el archivo denominado config en el directorio ~/.oci con el siguiente contenido:
```
[DEFAULT]
tenancy=<your-tenancy-ocid>
user=<your-user-ocid>
fingerprint=<fingerprint-of-your-public-key>
key_file=<path-to-your-private-key-file>
pass_phrase=<your-private-key-passphrase>
region=<your-region-identifier>
```
Tenga en cuenta que también puede especificar el identificador de región junto con las credenciales en el archivo de configuración de OCI. Por defecto, el controlador buscará credenciales y una región en el archivo de configuración de OCI en la ruta por defecto y en el perfil por defecto. La región solo es necesaria si no se utiliza HandleBuilder::cloud_region(). pass_phrase solo es necesario si el archivo de claves RSA requiere uno.
El primer paso en cualquier aplicación Oracle NoSQL Database Cloud Service Rust es crear un identificador que se utilice para enviar solicitudes al servicio, según la configuración proporcionada en una estructura HandleBuilder. Las instancias del manejador son seguras para el uso simultáneo y están destinadas a ser compartidas en una aplicación multithread o asíncrona. El siguiente ejemplo de código muestra cómo conectarse al servicio en la nube mediante un archivo de configuración de usuario:
```
let handle = Handle::builder()
.cloud_auth_from_file("~/.oci/config")?
.build().await?;
```
Conexión mediante un principal de instancia
El principal de instancia es una función del servicio IAM que permite que las instancias sean actores autorizados (o principales) para realizar acciones en recursos del servicio. Cada instancia informática tiene su propia identidad y se autentica con los certificados que tiene agregados. Para configurar NoSQL en este modo, utilice el siguiente código:
```
let handle = Handle::builder()
.cloud_auth_from_instance()?
.build().await?;
```
Conexión mediante una entidad de recurso
La entidad de recurso es una función del servicio IAM que permite que los recursos sean actores (o principales) autorizados para realizar acciones en recursos del servicio. Para configurar NoSQL en este modo, utilice el siguiente código:
```
let handle = Handle::builder()
.cloud_auth_from_resource()?
.build().await?;
```

Flujo de trabajo típico

secuencia típica de tareas para trabajar con Oracle NoSQL Database Cloud Service.

Si está desarrollando aplicaciones con Oracle NoSQL Database Cloud Service, siga estas tareas como guía.

Tarea	Descripción	Más información
Conecte su aplicación	Conecte su aplicación para usar tablas de Oracle NoSQL Database Cloud Service.	Conexión de la aplicación a NDCS
Desarrollar una aplicación	Desarrolle la aplicación después de conectar las tablas de Oracle NoSQL Database Cloud Service.	Desarrollo en Oracle Cloud Desarrollo en el simulador de Oracle NoSQL Database Cloud

Si es la primera vez que configura Oracle NoSQL Database Cloud Service, consulte Configuración del servicio.

tutoriales de inicio rápido

Acceda a los tutoriales de inicio rápido y comience a usar el servicio.

Obtenga acceso al servicio.

Registre una promoción de Cloud o compre una suscripción a Oracle Cloud. Active su pedido y cree usuarios (opcional). Consulte Configuración del servicio.
Adquiera credenciales para conectar su aplicación. Consulte Autenticación para conectarse a Oracle NoSQL Database.
Cree una tabla en Oracle NoSQL Database Cloud Service.
- Para empezar, consulte Introducción a las tablas en Oracle NoSQL Database Cloud Service.