Guida introduttiva a Oracle NoSQL Database Cloud Service

Oracle NoSQL Database Cloud Service è un servizio cloud di database completamente gestito progettato per le operazioni del database che richiedono risposte prevedibili a latenza in millisecondi a singola cifra a query semplici.

NoSQL Database Cloud Service consente agli sviluppatori di concentrarsi sullo sviluppo delle applicazioni piuttosto che sull'impostazione dei server cluster o sull'esecuzione di monitoraggio, tuning, diagnostica e scalabilità del sistema. NoSQL Database Cloud Service è adatto per applicazioni quali Internet of Things, personalizzazione dell'esperienza utente, rilevamento immediato delle frodi e pubblicità display online.

Una volta eseguita l'autenticazione sull'account Oracle Cloud, puoi creare una tabella NoSQL e specificare i requisiti di throughput e storage per la tabella. Oracle riserva e gestisce le risorse per soddisfare le tue esigenze e mette a disposizione la capacità per te. La capacità viene specificata utilizzando unità di lettura e scrittura per il throughput e GB per le unità di storage.

Questo articolo contiene i seguenti argomenti:

Collegamenti rapidi

Puoi iniziare a utilizzare Oracle NoSQL Database Service da uno dei collegamenti rapidi riportati di seguito:

Tabella - collegamenti rapidi


Per iniziare - Avvio rapido: Per iniziare - Funzioni chiave - Concetti cloud - Prezzi	Connetti - Acquisisci le tue credenziali - Autenticazione per la connessione a NDCS - Connessione dell'applicazione a NDCS - Aree dati e endpoint del servizio associati	IDE and SDKs - Using IntelliJ Plugin for Development - Using Visual Studio Code Extension for Development - Oracle NoSQL Java SDK - Oracle NoSQL Python SDK - Oracle NoSQL GO SDK - Oracle NoSQL Node.js SDK - Oracle NoSQL Dotnet SDK - Oracle NoSQL Rust SDK
Crea tabelle - Progettazione di una tabella - Uso della console per creare tabelle singleton - Uso delle interfacce API per creare tabelle singleton - Tabelle attive globali - Uso della console per creare una tabella attiva globale - Uso delle interfacce API per creare una tabella attiva globale - Uso della clip OCI per creare una tabella	Inserisci ed esplora dati - Uso della console per aggiungere dati - Uso delle API per aggiungere dati - Uso della console per recuperare i dati - Uso dell'API di recupero per recuperare i dati - Uso dell'API di query per recuperare i dati - Esecuzione di query sulle tabelle padre-figlio	Gestire le tabelle - Modifica delle tabelle singleton mediante le API - Modifica delle tabelle attive globali mediante le API - Eliminazione di tabelle e indici - Gestione di tabelle e indici mediante la console
Gestisci sicurezza - Imposta gruppi di utenti e criteri - Offrire a un altro utente l'autorizzazione per gestire le tabelle NoSQL - Riferimento criteri	Monitorare il servizio - Eventi di servizio - Quote di servizio - Metriche - Creazione e gestione di allarmi	Servizi di pubblica utilità - Scarica Oracle NoSQL Database Cloud Simulator - Sviluppo in Oracle NoSQL Database Cloud Simulator - Uso di Oracle NoSQL Database Migrator - Uso di Oracle NoSQL Database Analytics Integrator
Riferimento SQL - Uso degli operatori in SQL - Ordinamento dei dati di raggruppamento e limitazione - Uso delle espressioni primarie in SQL - Uso delle funzioni Timestamp nelle query - Uso delle funzioni String nelle query	Guide di riferimento - Informazioni di riferimento su Analytics Integrator - Casi d'uso di esempio per NDCS - Risolvere i problemi con GAT

Impostazione del servizio

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

Task	Di riferimento	Informazioni correlate
Inserisci un ordine per Oracle NoSQL Database Cloud Service o iscriviti alla 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, consulta la sezione Stima del costo mensile. Per eseguire l'upgrade dell'account gratuito o modificare il metodo di pagamento, vedere 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 Oracle Cloud Infrastructure Console, vedere Uso della console in Documentazione di Oracle Cloud Infrastructure.
(Consigliato) Creare un compartimento per il servizio.	Creazione di un compartimenti	Se non hai familiarità con i compartimenti, consulta la Introduzione ai compartimenti nella Documentazione di Oracle Cloud Infrastructure.
Gestisci la sicurezza per il tuo servizio.	Informazioni sul modello di sicurezza di Oracle NoSQL Database Cloud Service	Per acquisire familiarità con il modello di sicurezza di NoSQL Database Cloud Service, vedere Informazioni sul modello di sicurezza di Oracle NoSQL Database Cloud Service.

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 fare clic su Database NoSQL.
Selezionare il compartimento creato per le tabelle dall'amministratore dei servizi.

Per visualizzare la Guida per la pagina corrente, fare clic sull'icona della Guida Icona Cassetto della Guida nella parte superiore della pagina.

Creazione di un compartimenti

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 criteri corrispondenti per controllare l'accesso alle risorse in ogni compartimento. Prima di creare una tabella di Oracle NoSQL Database Cloud Service, Oracle consiglia di impostare il compartimento in cui si desidera che la tabella appartenga.

Puoi creare compartimenti in Oracle Cloud Infrastructure Identity and Access Management (IAM). Vedere Setting Up Your Tenancy e Managing Compartments in Oracle Cloud Infrastructure Documentation.

Autenticazione per la connessione a Oracle NoSQL Database

Hai bisogno di un account Oracle Cloud per connettere la tua applicazione a Oracle NoSQL Database Cloud Service.

Se non disponi già di un account Oracle Cloud, puoi iniziare con Oracle Cloud. È necessario autenticarsi quando ci si connette a Oracle NoSQL Database. È possibile eseguire l'autenticazione utilizzando uno dei metodi riportati di seguito.

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 sono associate a un utente specifico. Se si desidera 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 metodi riportati di seguito.

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.
Fornitura delle credenziali tramite un'API.
Memorizzazione delle credenziali in un vault da qualche parte.

Informazioni che costituiscono le credenziali:

Tabella - Credenziali

Che cos'è?	Dove trovarlo?
ID tenancy e ID utente (entrambi sono OCID)	Vedere Dove ottenere l'OCID della tenancy e l'OCID dell'utente 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 questa operazione è già stata eseguita, 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 passphrase (facoltativo) 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 in Oracle Cloud Infrastructure Documentation.

Che cos'è?

Dove trovarlo?

ID tenancy e ID utente (entrambi sono OCID)

Vedere Dove ottenere l'OCID della tenancy e l'OCID dell'utente 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 questa operazione è già stata eseguita, 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 passphrase (facoltativo) 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 in Oracle Cloud Infrastructure Documentation.

Nota: prendere nota della posizione della chiave privata, della passphrase facoltativa 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 per l'applicazione:

Gli SDK di Oracle NoSQL Database consentono di fornire le credenziali a un'applicazione in vari modi. Gli SDK supportano un file di configurazione e una o più interfacce che consentono la specifica diretta delle informazioni. Per informazioni sulle interfacce credenziali specifiche, vedere la documentazione del driver del linguaggio di programmazione in uso.

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 istanza

Instance Principals è 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 ha la propria identità e viene autenticata utilizzando i certificati aggiunti all'istanza. Questi certificati vengono creati automaticamente, assegnati alle 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, ad esempio le funzioni serverless.

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 automaticamente, assegnati alle risorse e ruotati, evitando la necessità di 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 Oracle Cloud Infrastructure.

Una volta eseguita l'autenticazione, devi essere autorizzato ad accedere alle risorse 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 consente di creare e utilizzare un token di sessione temporaneo per autenticare e accedere alle risorse di Oracle Cloud Infrastructure. Utilizzando l'autenticazione basata su token, è possibile creare un file di configurazione locale contenente informazioni quali l'OCID utente, l'OCID tenancy, l'area, il percorso della chiave privata e un percorso del file di token della sessione temporanea. Questo metodo utilizza queste informazioni insieme al token di 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 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 aver eseguito correttamente l'autenticazione, 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 di 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 un browser:

Per utilizzare l'autenticazione basata su token per l'interfaccia CLI senza un browser Web, è prima necessario eseguire l'autenticazione utilizzando 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 di 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 funzionano insieme all'interno di un set di pod. Una risorsa del 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 ti consente di concedere l'accesso basato su criteri dei pod K8s alle risorse Oracle Cloud Infrastructure (OCI) utilizzando OCI Identity and Access Management (IAM).

Con l'identità del carico di lavoro, non è più necessario memorizzare le credenziali come segreti nel cluster Kubernetes o fare affidamento su gruppi dinamici OCI per l'accesso basato sui criteri dei nodi di lavoro alle risorse OCI e, in particolare, l'accesso alle tabelle NoSQL. Quando le applicazioni richiedono l'accesso alle risorse OCI, Workload Identity ti consente di scrivere i criteri IAM OCI definiti nell'account del servizio Kubernetes associato ai pod delle applicazioni. 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 da utilizzare per l'applicazione.
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 quanto riportato di seguito.
- che le richieste dei carichi di lavoro devono essere autenticate utilizzando il provider di identità del carico di lavoro di Kubernetes Engine
- 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 abilitare il carico di lavoro per accedere alle risorse OCI necessarie:

Nella console OCI, aprire il menu di navigazione e fare clic su Id entità 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.

È possibile ottenere l'autenticazione utilizzando uno dei seguenti metodi:

la chiave di firma API
- Da qualsiasi programma SDK (Java, Python, C#, GO, Node.js, Rust) codificato direttamente
- File di configurazione con un profilo predefinito
- File di configurazione con un profilo non predefinito
Principal dell'istanza con token di autenticazione
Principal risorsa
Token di sessione
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:

Fornire 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 profilo non predefinito:

/* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * Specify the name of the non-default profile in the constructor 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:

Instance Principal è una funzione di servizio IAM che consente alle istanze di essere attori autorizzati (o principal) per eseguire azioni sulle risorse di servizio. Ogni istanza di computazione ha la propria identità e viene autenticata utilizzando i certificati aggiunti.
```
SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();
```
Connessione mediante un principal risorsa:

Resource Principal è una funzione del servizio IAM che consente alle risorse di essere attori (o principal) autorizzati a eseguire azioni sulle risorse del servizio.
```
SignatureProvider authProvider = SignatureProvider.createWithResourcePrincipal();
```
Connessione mediante session-token:

Utilizzare il metodo createWithSessionToken() per 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();
```
È inoltre possibile fornire il percorso del file 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 SignatureProvider con l'identità del carico di lavoro Container Engine for Kubernetes (OKE) utilizzando il token dell'account del 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 dell'account di servizio Kubernetes specifico da utilizzare come mostrato di seguito.
```
SignatureProvider authProvider =
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken>);
```
In alternativa, puoi anche specificare la posizione del token dell'account di 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:

Fornire 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:

Instance Principal è una funzione di servizio IAM che consente alle istanze di essere attori autorizzati (o principal) per eseguire azioni sulle risorse di servizio. Ogni istanza di computazione ha la propria identità e viene autenticata 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 alle risorse di essere attori (o principal) autorizzati a 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 di autenticazione del carico di lavoro OKE è un firmatario che concede a un intero carico di lavoro (un'applicazione in esecuzione sui 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 del token dell'account di servizio Kubernetes diverso dal percorso predefinito, è possibile specificare il percorso come mostrato 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 dell'account di 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)
```

Puoi connettere la tua applicazione a NDCS utilizzando uno dei seguenti metodi:

Fornire 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:

Instance Principal è una funzione di servizio IAM che consente alle istanze di essere attori autorizzati (o principal) per eseguire azioni sulle risorse di servizio. Ogni istanza di computazione ha la propria identità e viene autenticata 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 alle risorse di essere attori (o principal) autorizzati a 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 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. Si tratta del 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 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 è specificato 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. Si tratta del compartimento radice della tenancy dell'utente.

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

L'SDK Oracle NoSQL go supporta l'esecuzione di programmi all'interno dei container OKE Workload 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:

Fornire direttamente le credenziali nel codice:

È possibile specificare le credenziali direttamente nell'ambito 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 ~ sta per home directory dell'utente. In Windows, il valore ~ è una 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 esaminerà la posizione precedente 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, specificarle all'interno della 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:

Instance Principal è una funzione di servizio IAM che consente alle istanze di essere attori autorizzati (o principal) per eseguire azioni sulle risorse di servizio. Ogni istanza di computazione ha la propria identità e viene autenticata utilizzando i certificati aggiunti.

Dopo l'impostazione, 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 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 il nome della tabella al nome o al percorso del compartimento durante la chiamata delle API NoSQLClient.
Connessione mediante un principal risorsa:

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

Dopo l'impostazione, 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 Resource Principal è 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 Resource Principal, non è possibile anteporre il nome della tabella al nome o al percorso del compartimento quando si chiamano le API NoSQLClient.
Connessione mediante session-token:

Utilizzando l'autenticazione basata su token di sessione, è possibile creare un file di configurazione locale contenente informazioni quali l'OCID utente, l'OCID tenancy, l'area, il percorso della chiave privata e un percorso del file del token di sessione temporanea.
```
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 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 Node.js Oracle NoSQL 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 dei pod Kubernetes. L'uso dell'identità del carico di lavoro OKE 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 di questa impostazione 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 il caricamento dei token dell'account di servizio.

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

È possibile connettersi a NDCS utilizzando uno dei metodi seguenti:

Fornire direttamente le credenziali nel codice:

È possibile specificare le credenziali direttamente come IAMCredentials durante la creazione di 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 ~ sta per home directory dell'utente. In Windows, il valore ~ è una 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 ~/.oci directory con il seguente contenuto:
```
[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 mostrato in precedenza, è possibile creare un'istanza NoSQLClient senza passare alcuna configurazione:
```
var client = new NoSQLClient();
```
In alternativa, è possibile specificare l'area (così come 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, specificarli all'interno della 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:

Instance Principal è una funzione di servizio IAM che consente alle istanze di essere attori autorizzati (o principal) per eseguire azioni sulle risorse di servizio. Ogni istanza di computazione ha la propria identità e viene autenticata utilizzando i certificati aggiunti. Dopo l'impostazione, 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()
    });
```
Puoi anche rappresentare la stessa configurazione in JSON come segue:
```
{
    "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à 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 il nome della tabella al nome o al percorso del compartimento durante la chiamata delle API NoSQLClient.
Connessione mediante un principal risorsa:

Resource Principal è una funzione del servizio IAM che consente alle risorse di essere attori (o principal) autorizzati a eseguire azioni sulle risorse del servizio. Dopo l'impostazione, 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()
    });
```
Puoi anche rappresentare la stessa configurazione in JSON come segue:
```
{
    "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à 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 Resource Principal, non è possibile anteporre il nome della tabella al nome o al percorso del compartimento quando si chiamano le API NoSQLClient.
Connessione mediante session-token:

Utilizzando l'autenticazione basata su token di sessione, è possibile creare un file di configurazione locale contenente informazioni quali l'OCID utente, l'OCID tenancy, l'area, il percorso della chiave privata e un percorso del file del token di sessione temporanea.

È 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 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 OCI e il nome profilo specificati.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<configFile>,<profileName>)
});
```
Puoi anche rappresentare la stessa configurazione in JSON come segue:
```
{
  "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 Oracle NoSQL supporta l'esecuzione di programmi all'interno dei container OKE Workload in OCI.

Nell'esempio riportato di seguito viene creata una nuova istanza di IAMAuthorizationProvider utilizzando l'identità del carico di lavoro OKE. Questo metodo consente di specificare una stringa facoltativa per il token dell'account di servizio. 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 di 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>)
});
```
Puoi anche rappresentare la stessa configurazione in JSON come segue:
```
{ "Region": "<your-service-region>",
 "AuthorizationProvider":  {
   "AuthorizationType": "IAM",
   "UseOKEWorkLoadIdentity": true
 },
 "Compartment": "ocid1.compartment.oc1.............................",
}
```

È possibile connettersi a NDCS utilizzando uno dei metodi seguenti:

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 ~ sta per home directory dell'utente. In Windows, il valore ~ è una 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 ~/.oci directory con il seguente contenuto:
```
[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 della chiave RSA ne richiede uno.

Il primo passo in qualsiasi applicazione Oracle NoSQL Database Cloud Service Rust consiste nel creare un Handle utilizzato per inviare richieste al servizio, in base alla configurazione fornita in una struttura HandleBuilder. Le istanze della maniglia sono sicure per l'uso concorrente e destinate a essere condivise in un'applicazione multi-thread 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 istanza

Instance Principal è una funzione di servizio IAM che consente alle istanze di essere attori autorizzati (o principal) per eseguire azioni sulle risorse di servizio. Ogni istanza di computazione ha la propria identità e viene autenticata utilizzando i certificati aggiunti. Per configurare NoSQL in questa modalità, utilizzare il codice seguente:
```
let handle = Handle::builder()
.cloud_auth_from_instance()?
.compartment_id ("ocid1.compartment.oc1.............................")?
.build().await?;
```

Flusso di lavoro tipico

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

Se stai sviluppando applicazioni utilizzando Oracle NoSQL Database Cloud Service per la prima volta, segui 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
Sviluppa la tua applicazione	Sviluppare l'applicazione dopo la connessione alle tabelle di Oracle NoSQL Database Cloud Service.	Sviluppo in Oracle Cloud Sviluppo in Oracle NoSQL Database Cloud Simulator</p>

Se si imposta 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.

Accedi al servizio.

Iscriviti a una promozione Cloud o acquista una sottoscrizione a Oracle Cloud. Attivare l'ordine, creare 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.

Guida introduttiva a Oracle NoSQL Database Cloud Service

Collegamenti rapidi

Impostazione del servizio

Accesso al servizio dalla console dell'infrastruttura

Creazione di un compartimenti

Autenticazione per la connessione a Oracle NoSQL Database

Connessione dell'applicazione a NDCS

Flusso di lavoro tipico

Esercitazioni di avvio rapido

Argomenti correlati