Introduzione a Oracle NoSQL Database Cloud Service

Collegamenti rapidi

Puoi iniziare a usare Oracle NoSQL Database Service da uno dei collegamenti rapidi riportati di seguito.

Tabella - collegamenti rapidi


Introduzione Avvio rapido: Introduzione Caratteristiche principali Concetti del cloud Determinazione prezzi	Connetti Acquisisci le tue credenziali Autenticazione per la connessione a NDCS Connessione dell'applicazione a NDCS Aree dati ed endpoint dei servizi associati	IDE e SDK Utilizzo del plugin IntelliJ per lo sviluppo Uso dell'estensione Visual Studio Code per lo sviluppo Oracle NoSQL SDK Java SDK Python NoSQL Oracle Oracle NoSQL VAI SU SDK Oracle NoSQL Node.js SDK SDK Dotnet NoSQL di Oracle Oracle NoSQL SDK Rust
Create Tables Progettazione di una tabella Uso della console per creare le tabelle Singleton Utilizzo delle API per creare tabelle Singleton Tabelle attive globali Utilizzo della console per creare una tabella attiva globale Utilizzo delle API per creare una tabella attiva globale Utilizzo di OCI cli per creare una tabella	Inserisci ed esplora dati Utilizzo della console per aggiungere dati Utilizzo delle API per aggiungere dati Uso della console per recuperare i dati Utilizzo dell'API Get per recuperare i dati Utilizzo dell'interfaccia API delle query per recuperare i dati Esecuzione di query sulle tabelle padre-figlio	Manage Tables Modifica delle tabelle Singleton mediante le API Modifica delle tabelle attive globali mediante le interfacce API Eliminazione di tabelle e indici Gestione delle tabelle e degli indici mediante la console
Gestisci sicurezza Impostare gruppi di utenti e criteri Autorizzazione di un altro utente per la gestione delle tabelle NoSQL Riferimento ai criteri	Monitorare il servizio Eventi di servizio Quote del servizio Metriche Creare e gestire gli allarmi	Utility Scarica il simulatore per Oracle NoSQL Database Cloud Sviluppo in Oracle NoSQL Database Cloud Simulator Uso di Oracle NoSQL Database Migrator Uso di Oracle NoSQL Database Analytics Integrator
SQL Reference Uso degli operatori in SQL Ordinamento dei raggruppamenti e limitazione dei dati Utilizzo delle espressioni primarie in SQL Uso delle funzioni Timestamp nelle query Utilizzo delle funzioni stringa nelle query	Guide di riferimento Riferimento ad Analytics Integrator Esempi di casi d'uso per NDCS Risolvere i problemi con GAT

Impostazione del servizio

Se si sta impostando Oracle NoSQL Database Cloud Service per la prima volta, seguire questi task come guida.

Task	Di riferimento	Informazioni correlate
Emetti un ordine per Oracle NoSQL Database Cloud Service o registrati per la prova gratuita di Oracle.	Iscrizione a Oracle Cloud Infrastructure nella documentazione di Oracle Cloud Infrastructure.	Per informazioni su come stimare il costo mensile della sottoscrizione a Oracle NoSQL Database Cloud Service, vedere Stima del costo mensile. Per aggiornare il tuo account gratuito o modificare il tuo metodo di pagamento, consulta la sezione relativa alla modifica del metodo di pagamento nella documentazione di Oracle Cloud Infrastructure.
Attiva il tuo account Oracle Cloud e accedi per la prima volta.	Accesso alla console nella documentazione di Oracle Cloud Infrastructure.	Per acquisire familiarità con la console dell'infrastruttura di Oracle Cloud, vedere Uso della console nella documentazione di Oracle Cloud Infrastructure.
(Consigliato) Creare un compartimento per il servizio.	Creazione di un compartimento	Se non si ha familiarità con i compartimenti, vedere Understanding Compartments nella documentazione di Oracle Cloud Infrastructure.
Gestire la sicurezza per il servizio.	Informazioni sul modello di sicurezza di Oracle NoSQL Database Cloud Service	Per acquisire familiarità con il modello di sicurezza NoSQL Database Cloud Service, vedere Informazioni su Oracle NoSQL Database Cloud Service Security Model.

Accesso al servizio dalla console dell'infrastruttura

Scopri come accedere al servizio Oracle NoSQL Database Cloud Service dalla console dell'infrastruttura.

Individuare l'URL del servizio dal messaggio di posta elettronica di benvenuto, quindi collegarsi a Oracle NoSQL Database Cloud Service.
Aprire il menu di navigazione, fare clic su Database, quindi su NoSQL Database.
Selezionare il compartimento creato per le tabelle dall'amministratore del servizio.

Per visualizzare la Guida per la pagina corrente, fare clic sull'icona della Guida

nella parte superiore della pagina.

Creazione di un compartimento

Quando ti iscrivi a Oracle Cloud Infrastructure, Oracle crea la tua tenancy con un compartimento radice che contiene tutte le tue risorse cloud. Successivamente, creerai compartimenti aggiuntivi all'interno della tenancy (compartimento radice) e i criteri corrispondenti per controllare l'accesso alle risorse in ciascun compartimento. Prima di creare una tabella Oracle NoSQL Database Cloud Service, Oracle consiglia di impostare il compartimento a cui si desidera appartenga la tabella.

Puoi creare compartimenti in Oracle Cloud Infrastructure Identity and Access Management (IAM). Vedere Impostazione della tenancy e Gestione dei compartimenti nella documentazione di Oracle Cloud Infrastructure.

Autenticazione per connettersi a Oracle NoSQL Database

Per connettere l'applicazione a Oracle NoSQL Database Cloud Service, è necessario un account Oracle Cloud.

Se non disponi già di un account Oracle Cloud, puoi iniziare con Oracle Cloud. Quando ti connetti a Oracle NoSQL Database, devi autenticarti. L'autenticazione può essere eseguita in uno dei seguenti modi:

Metodo di autenticazione n. 1: principal utente

Qui puoi utilizzare un utente OCI e una chiave API per l'autenticazione. Le credenziali utilizzate per la connessione dell'applicazione vengono associate a un utente specifico. Per creare un utente per l'applicazione, vedere Impostazione di utenti, gruppi e criteri mediante Identity and Access Management.

È possibile fornire le credenziali per questo metodo di autenticazione utilizzando uno dei seguenti metodi:

Utilizzando un file su un disco locale, il file contiene dettagli quali l'OCID utente, l'OCID tenancy, l'area, il percorso della chiave privata e l'impronta digitale. È possibile utilizzarlo se si lavora da una rete sicura e la memorizzazione locale di chiavi private e configurazioni è conforme ai criteri di sicurezza.
Fornire le credenziali tramite un'API.
Memorizzazione delle credenziali in un vault da qualche parte.

Informazioni sulle credenziali:

Tabella - Credenziali

Introduzione	Dove trovarlo?
ID tenancy e ID utente (entrambi OCID)	Vedere Where to Get the Tenancy's OCID and User's OCID nella Documentazione di Oracle Cloud Infrastructure.
Chiave di firma API	Per l'utente dell'applicazione, è necessario generare e caricare una chiave di firma API. Se questo è già stato fatto, questo passo può essere saltato. Per saperne di più, consulta le seguenti risorse nella documentazione di Oracle Cloud Infrastructure: Come generare una chiave di firma API per generare la chiave di firma con una passphrase facoltativa. Come caricare la chiave pubblica per caricare la chiave di firma API nell'account dell'utente.
Impronta digitale per la chiave di firma e (facoltativa) passphrase per la chiave di firma	L'impronta digitale e la passphrase della chiave di firma vengono create durante la generazione e il caricamento della chiave di firma API. Vedere How to Get the Key's Fingerprint nella documentazione di Oracle Cloud Infrastructure.

Suggerimento

Prendi nota della posizione della tua chiave privata, della passphrase opzionale e dell'impronta digitale della chiave pubblica durante la generazione e il caricamento della chiave di firma API.

Dopo aver eseguito i task descritti in precedenza, raccogliere le informazioni sulle credenziali e fornirle all'applicazione.

Fornire le credenziali all'applicazione:

Gli SDK di Oracle NoSQL Database ti consentono di fornire le credenziali a un'applicazione in più modi. Gli SDK supportano un file di configurazione e una o più interfacce che consentono la specifica diretta delle informazioni. Consultare la documentazione relativa al driver del linguaggio di programmazione utilizzato per informazioni sulle interfacce delle credenziali specifiche.

Se si utilizza un file di configurazione, la posizione predefinita è ~/.oci/config. Gli SDK consentono al file di risiedere in posizioni alternative. Il contenuto è simile al seguente:

[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 riga [DEFAULT] indica che le righe successive specificano il profilo DEFAULT. Un file di configurazione può includere più profili con il prefisso [PROFILE_NAME]. Ad esempio:

[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

Metodo di autenticazione n. 2: principal dell'istanza

I principal delle istanze sono una funzionalità di Oracle Cloud Infrastructure Identity and Access Management (IAM) che consente di effettuare chiamate di servizio da un'istanza. Con i principal delle istanze, non è necessario configurare le credenziali utente per i servizi in esecuzione nelle istanze di computazione o ruotare le credenziali. Le istanze stesse sono ora un tipo di principal in IAM. Ogni istanza di computazione dispone di una propria identità ed esegue l'autenticazione utilizzando i certificati aggiunti all'istanza. Questi certificati vengono creati automaticamente, assegnati a istanze e ruotati.

Utilizzando l'autenticazione dei principal delle istanze, puoi autorizzare un'istanza a effettuare chiamate API sui servizi Oracle Cloud Infrastructure. Dopo aver impostato le risorse e i criteri necessari, un'applicazione in esecuzione su un'istanza può chiamare i servizi pubblici di Oracle Cloud Infrastructure, eliminando la necessità di configurare le credenziali utente o un file di configurazione. L'autenticazione del principal dell'istanza può essere utilizzata da un'istanza in cui non si desidera memorizzare un file di configurazione.

Metodo di autenticazione n. 3: principal risorsa

Puoi utilizzare un principal risorsa per autenticare e accedere alle risorse di Oracle Cloud Infrastructure. Il principal risorsa è costituito da un token di sessione temporaneo e da credenziali sicure che consentono ad altri servizi Oracle Cloud di autenticarsi in Oracle NoSQL Database. L'autenticazione del principal risorsa è molto simile all'autenticazione del principal dell'istanza, ma è destinata a essere utilizzata per le risorse che non sono istanze, come le funzioni server-less.

Un principal risorsa consente alle risorse di essere autorizzate a eseguire azioni sui servizi Oracle Cloud Infrastructure. Ogni risorsa ha la propria identità e la risorsa esegue l'autenticazione utilizzando i certificati aggiunti. Questi certificati vengono creati, assegnati alle risorse e ruotati in modo automatico, evitando di dover creare e gestire le proprie credenziali per accedere alla risorsa. Quando esegui l'autenticazione utilizzando un principal risorsa, non è necessario creare e gestire le credenziali per accedere alle risorse di Oracle Cloud Infrastructure.

Una volta autenticato, devi essere autorizzato ad accedere alle risorse di Oracle Cloud Infrastructure. Per ulteriori dettagli, vedere Impostazione di utenti, gruppi e criteri mediante Identity and Access Management.

Metodo di autenticazione n. 4: autenticazione basata su token:

L'autenticazione basata su token ti consente di creare e utilizzare un token di sessione temporaneo per autenticare e accedere alle risorse Oracle Cloud Infrastructure. Utilizzando l'autenticazione basata su token, si crea un file di configurazione locale che contiene informazioni tra cui l'OCID utente, l'OCID tenancy, l'area, il percorso della chiave privata e un percorso file di token sessione temporaneo. Questo metodo utilizza queste informazioni insieme al token della sessione temporanea, che scade tra un'ora (per impostazione predefinita). L'autenticazione basata su token di sessione può essere utilizzata quando è necessaria un'autenticazione rapida e temporanea.

Creazione di un token di sessione: è possibile generare un token di sessione con o senza l'utilizzo di un browser Web.

Con un browser:

Per utilizzare l'autenticazione basata su token per l'interfaccia CLI in un computer con un browser Web, effettuare le operazioni riportate di seguito.

Nel terminale, eseguire il comando seguente:
```
oci session authenticate
```
Selezionare un'area.
Nel browser, immettere le credenziali utente.
Dopo avere autenticato correttamente, chiudere il browser e seguire il prompt interattivo sul terminale. È necessario specificare il nome del profilo che si desidera creare nel file di configurazione. La nuova configurazione del profilo viene scritta nel file ~/.oci/config. Di seguito è riportato un esempio del file di configurazione in cui viene aggiornato il nuovo profilo (ad esempio 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>
```

Senza browser:

Per utilizzare l'autenticazione basata su token per l'interfaccia CLI senza un browser Web, è prima necessario eseguire l'autenticazione mediante l'autenticazione basata su chiave API.

oci setup config

Questo comando richiede le informazioni necessarie per creare il file di configurazione e le chiavi pubbliche e private dell'API. La finestra di dialogo di impostazione utilizza queste informazioni per generare una coppia di chiavi API e creare il file di configurazione. Per utilizzare l'autenticazione basata su token per l'interfaccia CLI senza un browser Web, eseguire il comando seguente:

oci session authenticate --no-browser

È necessario specificare il nome del profilo che si desidera creare nel file di configurazione. La nuova configurazione del profilo viene scritta nel file ~/.oci/config. Di seguito è riportato un esempio del file di configurazione in cui viene aggiornato il nuovo profilo (ad esempio 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>

Metodo di autenticazione n. 5: autenticazione basata su identità del carico di lavoro OKE:

L'identità del carico di lavoro Oracle Container Engine for Kubernetes (OKE) fornisce un controllo dettagliato della gestione delle identità e degli accessi. Un carico di lavoro è un'applicazione in esecuzione su Kubernetes. Può essere composto da un singolo componente o da più componenti che lavorano insieme all'interno di un set di pod. Una risorsa di carico di lavoro è identificata dalla combinazione univoca di cluster, spazio di nomi e account di servizio. Questa combinazione univoca viene definita identità del carico di lavoro. L'identità del carico di lavoro OKE consente di concedere l'accesso basato sui criteri dei pod K8s alle risorse Oracle Cloud Infrastructure (OCI) utilizzando OCI Identity and Access Management (IAM).

Con Identità carico di lavoro, non è più necessario memorizzare le credenziali come segreti nel cluster Kubernetes o fare affidamento sui gruppi dinamici OCI per l'accesso alle risorse OCI basato sui criteri dei nodi di lavoro e, più specificamente, per l'accesso alle tabelle NoSQL. Quando le applicazioni richiedono l'accesso alle risorse OCI, Workload Identity consente di scrivere i criteri IAM OCI definiti nell'account di servizio Kubernetes associato ai pod dell'applicazione. Questa funzione consente alle applicazioni in esecuzione all'interno di questi pod di accedere direttamente all'API OCI in base alle autorizzazioni fornite dai criteri.

Per concedere a tutti i pod in un carico di lavoro l'accesso a qualsiasi risorsa OCI:

Creare uno spazio di nomi per un account di servizio.
Creare un account di servizio per l'applicazione da utilizzare.
Definire un criterio IAM per concedere l'accesso alle risorse del carico di lavoro ad altre risorse OCI.
Scaricare e configurare l'SDK appropriato per la lingua in cui viene scritta l'applicazione.
Modificare l'applicazione per specificare:
- che le richieste di carico di lavoro devono essere autenticate utilizzando il provider di identità del carico di lavoro del motore Kubernetes
- le risorse OCI a cui accedere
Aggiornare la specifica di distribuzione dell'applicazione per specificare che ogni pod nel carico di lavoro deve utilizzare l'account di servizio.

Autorizzazione per consentire al carico di lavoro di accedere alle risorse OCI necessarie:

Nella console OCI, aprire il menu di navigazione e fare clic su Identità e sicurezza. In Identità fare clic su Criteri.
Fare clic su Crea criterio e assegnare un nome al criterio.

Immettere un'istruzione criterio per consentire al carico di lavoro di accedere alle risorse OCI necessarie, nel formato mostrato di seguito:

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>'
}

dove:

<namespace-name> è il nome dello spazio di nomi creato in precedenza.
<service-account-name> è il nome dell'account di servizio creato in precedenza.
<cluster-OCID> è l'OCID del cluster ottenuto in precedenza.

Fare clic su Crea per creare il nuovo criterio.

Connessione dell'applicazione a NDCS

Scopri come connettere la tua applicazione a Oracle NoSQL Database Cloud Service.

L'applicazione si connette a Oracle NoSQL Database Cloud Service dopo essere stata autenticata utilizzando uno dei numerosi metodi disponibili.

Puoi autenticarti utilizzando uno dei seguenti metodi:

la chiave di firma API
- Da qualsiasi programma SDK (Java, Python, C#, GO, Node.js, Rust) codificato direttamente
- Un file di configurazione con un profilo predefinito
- File di configurazione con un profilo non predefinito
Principal istanza con token di autenticazione
Principi risorsa
Sessione-token
Identità carico di lavoro OKE

Per ulteriori dettagli sulle opzioni di autenticazione, vedere Autenticazione per la connessione a Oracle NoSQL Database.

È possibile connettersi a NDCS utilizzando uno dei metodi seguenti:

Fornendo direttamente le credenziali nel codice:

/* 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.

Connessione mediante il file di configurazione predefinito con un profilo predefinito:

/* 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();

Connessione mediante il file di configurazione predefinito con il profilo non predefinito:

/* 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);

Connessione mediante il file di configurazione e il profilo specificati:

/* 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);

Connessione mediante un principal istanza:
Principal istanza è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle istanze di eseguire azioni sulle risorse del servizio. Ogni istanza di computazione dispone di una propria identità ed esegue l'autenticazione utilizzando i certificati aggiunti.
```
SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();
```
Connessione mediante un principal risorsa:
Resource Principal è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle risorse di eseguire azioni sulle risorse del servizio.
```
SignatureProvider authProvider = SignatureProvider.createWithResourcePrincipal();
```
Connessione mediante session-token:
Il metodo createWithSessionToken() consente di creare un SignatureProvider utilizzando un token di sessione temporaneo letto da un file di token. Il percorso del file token viene letto dal profilo predefinito nel file di configurazione nella posizione predefinita. Il file di configurazione utilizzato è ~/.oci/config.
```
SignatureProvider authProvider = 
SignatureProvider.createWithSessionToken();
```
È anche possibile fornire il percorso del file del token nel profilo non predefinito nel file di configurazione, come mostrato di seguito. Il percorso del file token viene letto dal profilo specificato nel file di configurazione nella posizione predefinita.
```
SignatureProvider authProvider = 
SignatureProvider.createWithSessionToken(<profile_name>);
```
Connessione mediante l'identità del carico di lavoro OKE:
Puoi creare un'identità di carico di lavoro SignatureProvider con Container Engine for Kubernetes (OKE) utilizzando il token dell'account di servizio Kubernetes nel percorso predefinito /var/run/secrets/kubernetes.io/serviceaccount/token. Questo provider può essere utilizzato solo all'interno dei pod Kubernetes.
```
SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity();
```
È inoltre possibile specificare il token account del servizio Kubernetes specifico da utilizzare come mostrato di seguito.
```
SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken>);
```
In alternativa, puoi anche specificare la posizione del token di account del servizio Kubernetes specifico da utilizzare come mostrato di seguito.
```
SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken_location>);
```

Per ulteriori dettagli sulle classi Java utilizzate, vedere SignatureProvider.

È possibile connettersi a NDCS utilizzando uno dei metodi seguenti:

Fornendo direttamente le credenziali nel codice:

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')

Connessione mediante il file di configurazione predefinito con un profilo predefinito:

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

Connessione mediante il file di configurazione specificato con il profilo non predefinito:

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

Connessione mediante un principal istanza:
Principal istanza è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle istanze di eseguire azioni sulle risorse del servizio. Ogni istanza di computazione dispone di una propria identità ed esegue l'autenticazione utilizzando i certificati aggiunti.
```
at_provider =
SignatureProvider.create_with_instance_principal(region=my_region)
```
Connessione mediante un principal risorsa:
Resource Principal è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle risorse di eseguire azioni sulle risorse del servizio.
```
at_provider = SignatureProvider.create_with_resource_principal()
```

Connessione mediante session-token:

Il Borneo utilizza l'SDK OCI per l'autenticazione utilizzando i token di sessione. Il firmatario OCI viene passato come parametro al costruttore SignatureProvider, come mostrato di seguito.

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>)

Connessione mediante l'identità del carico di lavoro OKE:
Il firmatario dell'autenticazione del carico di lavoro OKE è un firmatario che concede a un intero carico di lavoro (un'applicazione in esecuzione nei cluster Kubernetes) l'accesso alle tabelle NoSQL utilizzando l'identità del carico di lavoro OKE. Può essere recuperato da oci.auth.signers.get_oke_workload_identity_resource_principal_signer. Il firmatario recuperato può quindi essere utilizzato durante l'inizializzazione di un client.
```
from borneo.iam import SignatureProvider
oke_workload_signer = oci.auth.signers.get_oke_workload_identity_resource_principal_signer()
```
Se si dispone di un percorso token account di servizio Kubernetes diverso da quello predefinito, è possibile specificare il percorso come indicato di seguito.
```
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)
```
Puoi anche passare direttamente il token account del servizio Kubernetes come mostrato di seguito:
```
#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)
```

È possibile connettere l'applicazione a NDCS utilizzando uno dei metodi riportati di seguito.

Fornendo direttamente le credenziali nel codice:

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>",
}

Connessione mediante il file di configurazione predefinito con un profilo predefinito:

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)

Connessione mediante il file di configurazione specificato con il profilo non predefinito:

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)

Connessione mediante un principal istanza:
Principal istanza è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle istanze di eseguire azioni sulle risorse del servizio. Ogni istanza di computazione dispone di una propria identità ed esegue l'autenticazione utilizzando i certificati aggiunti.
```
sp, err := iam.NewSignatureProviderWithInstancePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)
```

Connessione mediante un principal risorsa:

Resource Principal è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle risorse di eseguire azioni sulle risorse del servizio.

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

Connessione mediante session-token:
La funzione NewSessionTokenSignatureProvider crea un SignatureProvider utilizzando un token di sessione temporaneo letto da un file di token.
```
func NewSessionTokenSignatureProvider() (*SignatureProvider, error)
```
Il file di configurazione utilizzato è ~/.oci/config. Viene utilizzato il profilo DEFAULT. Il percorso del file del token viene letto dalla configurazione, utilizzando il valore del campo security_token_file. Quando si utilizza questo costruttore, l'utente dispone di un compartimento predefinito per tutte le tabelle. È il compartimento radice della tenancy dell'utente.
Per utilizzare un file di configurazione non predefinito (diverso da ~/.oci/config), è possibile utilizzare la funzione NewSessionTokenSignatureProviderFromFile.
```
func NewSessionTokenSignatureProviderFromFile(configFilePath, 
ociProfile, privateKeyPassphrase string) (*SignatureProvider, error)
```
Questa funzione crea un SignatureProvider utilizzando un token di sessione temporaneo letto da un file di token, utilizzando il ociProfile specificato nel file di configurazione OCI configFilePath. Il percorso del file del token viene letto dalla configurazione, utilizzando il valore del campo security_token_file. Il campo privateKeyPassphrase è obbligatorio solo se la chiave privata utilizza una passphrase e non è specificata nel campo pass_phrase nel file di configurazione OCI. Quando si utilizza questo costruttore, l'utente dispone di un compartimento predefinito per tutte le tabelle. È il compartimento radice della tenancy dell'utente.

Connessione mediante l'identità del carico di lavoro OKE:

Oracle NoSQL go SDK supporta l'esecuzione di programmi all'interno dei container del carico di lavoro OKE in OCI. Nel codice che crea un SignatureProvider da utilizzare con NoSQL, aggiungere il codice seguente per utilizzare l'identità del carico di lavoro 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)
}

È possibile connettersi a NDCS utilizzando uno dei metodi seguenti:

Fornendo direttamente le credenziali nel codice:

È possibile specificare le credenziali direttamente come parte della proprietà auth.iam nella configurazione iniziale. Creare l'istanza NoSQLClient come indicato di seguito.

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
        }
    }
});

Connessione mediante il file di configurazione predefinito con un profilo predefinito:

È possibile memorizzare le credenziali in un file di configurazione di Oracle Cloud Infrastructure. Il percorso predefinito per il file di configurazione è ~/.oci/config, dove ~ indica la directory home dell'utente. In Windows, ~ è un valore della variabile di ambiente USERPROFILE. Il file può contenere più profili. Per impostazione predefinita, il kit SDK utilizza il profilo denominato DEFAULT per memorizzare le credenziali.
Per utilizzare questi valori predefiniti, creare un file denominato config nella directory ~/.oci con i seguenti contenuti:
```
[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>
```
Tenere presente che è anche possibile specificare l'identificativo dell'area insieme alle credenziali nel file di configurazione OCI. Il driver esaminerà la posizione precedente per impostazione predefinita e se un'area viene fornita insieme alle credenziali, non è necessario fornire la configurazione iniziale e può utilizzare il costruttore senza argomenti:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient();
```
In alternativa, è possibile scegliere di specificare l'area nella configurazione:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({ region: Region.<your-service-region> });
```
Connessione mediante il file di configurazione specificato con il profilo non predefinito:

È possibile scegliere di utilizzare un percorso diverso per il file di configurazione OCI e un profilo diverso all'interno del file di configurazione. In questo caso, specificare questi valori nella proprietà auth.iam della configurazione iniziale. Ad esempio, se il percorso del file di configurazione OCI è ~/myapp/.oci/config e si memorizzano le credenziali nel profilo Jane:
Creare quindi l'istanza NoSQLClient come indicato di seguito.
```
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>'
        }
    }
});
```
Connessione mediante un principal istanza:

Principal istanza è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle istanze di eseguire azioni sulle risorse del servizio. Ogni istanza di computazione dispone di una propria identità ed esegue l'autenticazione utilizzando i certificati aggiunti.
Una volta impostata, creare l'istanza NoSQLClient come indicato di seguito.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............'
    auth: {
        iam: {
            useInstancePrincipal: true
        }
    }
});
```
È inoltre possibile utilizzare il file di configurazione JSON con la stessa configurazione descritta in precedenza. Tenere presente che quando si utilizza l'istanza principale, è necessario specificare l'ID compartimento (OCID) come proprietà del compartimento. Questa operazione è necessaria anche se si desidera utilizzare il compartimento predefinito. Tenere presente che è necessario utilizzare l'ID compartimento e non il nome o il percorso del compartimento. Inoltre, quando si utilizza il principal dell'istanza, non è possibile anteporre al nome della tabella il nome o il percorso del compartimento quando si chiamano le API NoSQLClient.
Connessione mediante un principal risorsa:

Resource Principal è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle risorse di eseguire azioni sulle risorse del servizio.
Una volta impostata, creare l'istanza NoSQLClient come indicato di seguito.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    auth: {
        iam: {
            useResourcePrincipal: true
        }
    }
});
```
È inoltre possibile utilizzare il file di configurazione JSON con la stessa configurazione descritta in precedenza. Tenere presente che quando si utilizza il principal risorsa è necessario specificare l'ID compartimento (OCID) come proprietà del compartimento. Questa operazione è necessaria anche se si desidera utilizzare il compartimento predefinito. Tenere presente che è necessario utilizzare l'ID compartimento e non il nome o il percorso del compartimento. Inoltre, quando si utilizza il principal risorsa, non è possibile anteporre al nome della tabella il nome o il percorso del compartimento quando si chiamano le API NoSQLClient.
Connessione mediante session-token:
L'autenticazione basata su token di sessione consente di creare un file di configurazione locale che contiene informazioni tra cui l'OCID utente, l'OCID tenancy, l'area, il percorso della chiave privata e il percorso di un file token di sessione temporaneo.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............
   ' auth: {
       iam: { useSessionToken: true }  
  }
}); 
```
Questo metodo utilizza un token di sessione temporaneo letto da un file di token. Il percorso del file del token viene letto dal profilo predefinito nel file di configurazione OCI come valore del campo security_token_file.
Per utilizzare un file di configurazione non predefinito (diverso da ~/.oci/config), è possibile specificare il percorso del file di configurazione e il nome del profilo, come mostrato di seguito.
```
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>"
    }  
  }
});
```
Connessione mediante l'identità del carico di lavoro OKE:
L'SDK Oracle NoSQL Node.js supporta l'esecuzione di programmi all'interno dei container del carico di lavoro OKE in OCI.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    ' auth: {
        iam: { useOKEWorkloadIdentity: true }
    }'
  }
);
```
Questo schema di autorizzazione può essere utilizzato solo all'interno dell'identità del carico di lavoro OKE pods.Using di Kubernetes richiede un token dell'account di servizio. Per impostazione predefinita, il provider caricherà il token dell'account di servizio dal percorso file predefinito /var/run/secrets/kubernetes.io/serviceaccount/token. È possibile eseguire l'override e fornire il token dell'account di servizio specificando una delle 3 proprietà riportate di seguito.
- serviceAccountToken per fornire una stringa di token dell'account di servizio.
- serviceAccountTokenFile per fornire un percorso al file token dell'account di servizio.
- serviceAccountTokenProvider per fornire un provider personalizzato per caricare i token di account di servizio.

Per informazioni dettagliate sul contenuto e sul formato del file, vedere File di configurazione SDK.

È possibile connettersi a NDCS utilizzando uno dei metodi seguenti:

Fornendo direttamente le credenziali nel codice:

È possibile specificare le credenziali direttamente come IAMCredentials quando si crea IAMAuthorizationProvider. Creare NoSQLClient come indicato di seguito.

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

Connessione mediante il file di configurazione predefinito con un profilo predefinito:

È possibile memorizzare le credenziali in un file di configurazione di Oracle Cloud Infrastructure. Il percorso predefinito per il file di configurazione è ~/.oci/config, dove ~ indica la directory home dell'utente. In Windows, ~ è un valore della variabile di ambiente USERPROFILE. Il file può contenere più profili. Per impostazione predefinita, l'SDK utilizza il profilo denominato DEFAULT per memorizzare le credenziali
Per utilizzare questi valori predefiniti, creare il file denominato config nella directory ~/.oci con i seguenti contenuti:
```
[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>
```
Tenere presente che è anche possibile specificare l'identificativo dell'area insieme alle credenziali nel file di configurazione OCI. Per impostazione predefinita, il driver cercherà le credenziali e un'area nel file di configurazione OCI nel percorso predefinito e nel profilo predefinito. Pertanto, se si fornisce l'area insieme alle credenziali come illustrato in precedenza, è possibile creare un'istanza NoSQLClient senza passare alcuna configurazione:
```
var client = new NoSQLClient();
```
In alternativa, è possibile specificare l'area (e altre proprietà) in NoSQLConfig:
```
var client = new NoSQLClient(
    new NoSQLConfig(
    {
        Region = Region.<your-service-region>,
        Timeout = TimeSpan.FromSeconds(10),
    });
```
Connessione mediante il file di configurazione specificato con il profilo non predefinito:

È possibile scegliere di utilizzare un percorso diverso per il file di configurazione OCI e un profilo diverso all'interno del file di configurazione. In questo caso, specificare questi valori nella proprietà auth.iam della configurazione iniziale. Ad esempio, se il percorso del file di configurazione OCI è ~/myapp/.oci/config e si memorizzano le credenziali nel profilo Jane:
Creare quindi l'istanza NoSQLClient come indicato di seguito.
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = Region.<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            "<your_config_file>", "<your_profile_name>")
    });
```
Connessione mediante un principal istanza:
Principal istanza è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle istanze di eseguire azioni sulle risorse del servizio. Ogni istanza di computazione dispone di una propria identità ed esegue l'autenticazione utilizzando i certificati aggiunti. Una volta impostata, creare l'istanza NoSQLClient come indicato di seguito.
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        Compartment="ocid1.compartment.oc1.............................",
        AuthorizationProvider=IAMAuthorizationProvider.CreateWithInstancePrincipal()
    });
```
È inoltre possibile rappresentare la stessa configurazione in JSON come indicato di seguito.
```
{
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseInstancePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}
```
Quando si utilizza il principal dell'istanza, è necessario specificare l'ID compartimento (OCID) come proprietà del compartimento. Questa operazione è necessaria anche se si desidera utilizzare il compartimento predefinito. Tenere presente che è necessario utilizzare l'ID compartimento e non il nome o il percorso del compartimento. Inoltre, quando si utilizza il principal dell'istanza, non è possibile anteporre al nome della tabella il nome o il percorso del compartimento quando si chiamano le API NoSQLClient.
Connessione mediante un principal risorsa:
Resource Principal è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle risorse di eseguire azioni sulle risorse del servizio. Una volta impostata, creare l'istanza NoSQLClient come indicato di seguito.
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = <your-service-region>,
        Compartment =
            "ocid1.compartment.oc1.............................",
        AuthorizationProvider =
            IAMAuthorizationProvider.CreateWithResourcePrincipal()
    });
```
È inoltre possibile rappresentare la stessa configurazione in JSON come indicato di seguito.
```
{
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseResourcePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}
```
Quando si utilizza il principal risorsa, è necessario specificare l'ID compartimento (OCID) come proprietà del compartimento. Questa operazione è necessaria anche se si desidera utilizzare il compartimento predefinito. Tenere presente che è necessario utilizzare l'ID compartimento e non il nome o il percorso del compartimento. Inoltre, quando si utilizza il principal risorsa, non è possibile anteporre al nome della tabella il nome o il percorso del compartimento quando si chiamano le API NoSQLClient.
Connessione mediante session-token:

L'autenticazione basata su token di sessione consente di creare un file di configurazione locale che contiene informazioni tra cui l'OCID utente, l'OCID tenancy, l'area, il percorso della chiave privata e il percorso di un file token di sessione temporaneo.

È possibile utilizzare l'autenticazione basata su token di sessione utilizzando uno dei tre metodi riportati di seguito.
Opzione 1: crea una nuova istanza di IAMAuthorizationProvider utilizzando l'autenticazione basata su token di sessione con il file di configurazione OCI predefinito e il nome del profilo predefinito.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken()
});
```
Opzione 2: crea una nuova istanza di IAMAuthorizationProvider utilizzando l'autenticazione basata su token di sessione con il file di configurazione OCI predefinito e il nome del profilo specificato.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<profileName>)
});
```
Opzione 3: crea una nuova istanza di IAMAuthorizationProvider utilizzando l'autenticazione basata su token di sessione con il file di configurazione e il nome profilo OCI specificati.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<configFile>,<profileName>)
});
```
È inoltre possibile rappresentare la stessa configurazione in JSON come indicato di seguito.
```
{
  "Region": "<your-service-region>",
  "AuthorizationProvider": {
    "AuthorizationType": "IAM",
    "UseSessionToken": true
  },
  "Compartment": "ocid1.compartment.oc1............................."
}
```
Connessione mediante l'identità del carico di lavoro OKE:

L'SDK Dotnet NoSQL Oracle supporta l'esecuzione di programmi all'interno dei container del carico di lavoro OKE in OCI.
L'esempio riportato di seguito crea una nuova istanza di IAMAuthorizationProvider utilizzando l'identità del carico di lavoro OKE. Questo metodo consente di specificare una stringa di token di account di servizio opzionale. Se non specificato, il token dell'account di servizio verrà letto dal percorso file predefinito /var/run/secrets/kubernetes.io/serviceaccount/token.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithOKEWorkloadIdentity()
});
```
È inoltre possibile creare una nuova istanza di IAMAuthorizationProvider utilizzando l'identità del carico di lavoro OKE e il file token dell'account di servizio specificato, come mostrato di seguito.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = 
    IAMAuthorizationProvider.CreateWithOKEWorkloadIdentityAndTokenFile(<serviceAccountTokenFile>)
});
```
È inoltre possibile rappresentare la stessa configurazione in JSON come indicato di seguito.
```
{ "Region": "<your-service-region>",  
 "AuthorizationProvider":  {
   "AuthorizationType": "IAM",
   "UseOKEWorkLoadIdentity": true 
 },
 "Compartment": "ocid1.compartment.oc1.............................",
}
```

È possibile connettersi a NDCS utilizzando uno dei seguenti metodi:

Connessione mediante il file di configurazione predefinito con un profilo predefinito:

È possibile memorizzare le credenziali in un file di configurazione di Oracle Cloud Infrastructure. Il percorso predefinito per il file di configurazione è ~/.oci/config, dove ~ indica la directory home dell'utente. In Windows, ~ è un valore della variabile di ambiente USERPROFILE. Il file può contenere più profili. Per impostazione predefinita, l'SDK utilizza il profilo denominato DEFAULT per memorizzare le credenziali
Per utilizzare questi valori predefiniti, creare il file denominato config nella directory ~/.oci con i seguenti contenuti:
```
[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>
```
Tenere presente che è anche possibile specificare l'identificativo dell'area insieme alle credenziali nel file di configurazione OCI. Per impostazione predefinita, il driver cercherà le credenziali e un'area nel file di configurazione OCI nel percorso predefinito e nel profilo predefinito. L'area è obbligatoria solo se non si utilizza HandleBuilder::cloud_region(). pass_phrase è richiesto solo se il file chiave RSA ne richiede uno.
Il primo passo di qualsiasi applicazione Oracle NoSQL Database Cloud Service Rust è creare un handle utilizzato per inviare le richieste al servizio, in base alla configurazione fornita in una struttura HandleBuilder. Le istanze dell'handle sono sicure per l'uso concorrente e destinate a essere condivise in un'applicazione multi-threaded o asincrona. L'esempio di codice riportato di seguito mostra come connettersi al servizio cloud utilizzando un file di configurazione utente.
```
let handle = Handle::builder()
.cloud_auth_from_file("~/.oci/config")?
.build().await?;
```
Connessione mediante un principal dell'istanza
Principal istanza è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle istanze di eseguire azioni sulle risorse del servizio. Ogni istanza di computazione dispone di una propria identità ed esegue l'autenticazione utilizzando i certificati aggiunti. Per configurare NoSQL in questa modalità, utilizzare il codice seguente:
```
let handle = Handle::builder()
.cloud_auth_from_instance()?
.build().await?;
```
Connessione mediante un principal risorsa
Resource Principal è una funzione del servizio IAM che consente agli attori (o principal) autorizzati delle risorse di eseguire azioni sulle risorse del servizio. Per configurare NoSQL in questa modalità, utilizzare il codice seguente:
```
let handle = Handle::builder()
.cloud_auth_from_resource()?
.build().await?;
```

Workflow tipico

Sequenza tipica di task da utilizzare con Oracle NoSQL Database Cloud Service.

Se si stanno sviluppando applicazioni utilizzando Oracle NoSQL Database Cloud Service per la prima volta, seguire questi task come guida.

Task	Descrizione	Ulteriori informazioni
Connetti l'applicazione	Connettere l'applicazione per utilizzare le tabelle di Oracle NoSQL Database Cloud Service.	Connessione dell'applicazione a NDCS
Sviluppare un'applicazione	Sviluppa la tua applicazione dopo aver effettuato la connessione alle tabelle di Oracle NoSQL Database Cloud Service.	Sviluppo in Oracle Cloud Sviluppo in Oracle NoSQL Database Cloud Simulator

Se si sta impostando Oracle NoSQL Database Cloud Service per la prima volta, vedere Impostazione del servizio.

Esercitazioni di avvio rapido

Accedi alle esercitazioni di avvio rapido e inizia a utilizzare il servizio.

Ottenere l'accesso al servizio.

Iscrizione a una promozione cloud o acquisto di una sottoscrizione a Oracle Cloud. Attiva il tuo ordine, crea utenti (facoltativo). Vedere Impostazione del servizio.
Acquisire le credenziali per connettere l'applicazione. Vedere Autenticazione per la connessione a Oracle NoSQL Database.
Creare una tabella in Oracle NoSQL Database Cloud Service.
- Per iniziare, vedere Introduzione alle tabelle in Oracle NoSQL Database Cloud Service.