Introduction à Oracle NoSQL Database Cloud Service

Liens express

Vous pouvez commencer à utiliser Oracle NoSQL Database Service à partir de l'un des liens rapides ci-dessous :

Tableau - Liens rapides


Initiation Démarrage rapide : Introduction Fonctionnalités principales Concepts cloud Tarifs	Connexion Obtenez vos identifiants Authentification pour la connexion à NDCS Connexion de l'application à NDCS Régions de données et adresses de service associées	IDE et SDK Utilisation du module d'extension IntelliJ pour le développement Utilisation de l'extension de code Visual Studio pour le développement Kit SDK Java Oracle NoSQL Kit SDK Python Oracle NoSQL Oracle NoSQL GO SDK Kit SDK Oracle NoSQL Node.js Kit SDK Dotnet Oracle NoSQL SDK Rust Oracle NoSQL
Create Tables conception d'une table Utilisation de la console pour créer des tables singleton Utilisation d'API pour créer des tables singleton Tables actives globales Utiliser la console pour créer une table active globale Utiliser des API pour créer une table active globale Utiliser un cli OCI pour créer une table	Mettre en place et explorer des données Utiliser la console pour ajouter des données Utiliser des API pour ajouter des données Utiliser la console pour extraire des données Utilisation de l'API Get pour extraire des données Utilisation de l'API de requête pour extraire des données Interroger des tables parent-enfant	Manage Tables Modifier des tables singletons à l'aide d'API Modifier des tables actives globales à l'aide d'API Suppression de tables et d'index Gestion des tables et des index à l'aide de la console
Gérer la sécurité Configurer des groupes d'utilisateurs et des stratégies Octroi de droits d'accès à un autre utilisateur pour gérer des tables NoSQL Référence de stratégie	Surveillance du service Evénements de service Quotas de service Mesures Création et gestion d'alarmes	Utilitaires Téléchargement du simulateur Oracle NoSQL Database Cloud Développement dans le simulateur Oracle NoSQL Database Cloud Utilisation d'Oracle NoSQL Database Migrator Utilisation d'Oracle NoSQL Database Analytics Integrator
Référence SQL Utiliser des opérateurs dans SQL Trier les données de regroupement et de limitation Utilisation d'expressions principales en SQL Utiliser des fonctions d'horodatage dans les requêtes Utiliser des fonctions String dans les requêtes	Guides de référence Référence Analytics Integrator Exemples de cas d'emploi pour NDCS Résolution des problèmes avec GAT

Configuration du service

Si vous configurez Oracle NoSQL Database Cloud Service pour la première fois, suivez ces tâches comme guide.

Tâche	Référence	Informations connexes
Passez une commande pour Oracle NoSQL Database Cloud Service ou inscrivez-vous pour obtenir la version d'évaluation gratuite Oracle.	Inscription à Oracle Cloud Infrastructure dans la documentation Oracle Cloud Infrastructure.	Pour en savoir plus sur l'estimation du coût mensuel de votre abonnement Oracle NoSQL Database Cloud Service, reportez-vous à estimation du coût mensuel. Pour mettre à niveau votre compte gratuit ou modifier le mode de paiement, reportez-vous à Modification du mode de paiement dans la documentation Oracle Cloud Infrastructure.
Activer le compte Oracle Cloud et se connecter pour la première fois.	Connexion à la console dans la documentation Oracle Cloud Infrastructure.	Pour vous familiariser avec la console Oracle Cloud Infrastructure, reportez-vous à Utilisation de la console dans la documentation Oracle Cloud Infrastructure.
(Recommandé) Créer un compartiment pour le service.	Création d'un compartiment	Si vous ne connaissez pas bien les compartiments, reportez-vous à Présentation des compartiments dans la documentation Oracle Cloud Infrastructure.
Gestion de la sécurité du service.	Modèle de sécurité d'Oracle NoSQL Database Cloud Service	Pour vous familiariser avec le modèle de sécurité NoSQL Database Cloud Service, reportez-vous à A propos du modèle de sécurité d'Oracle NoSQL Database Cloud Service.

Accès au service à partir de la console d'infrastructure

Découvrez comment accéder au service Oracle NoSQL Database Cloud Service à partir de la console d'infrastructure.

Recherchez l'URL du service dans le courriel de bienvenue, puis connectez-vous à Oracle NoSQL Database Cloud Service.
Ouvrez le menu de navigation, cliquez sur Bases de données, puis sur NoSQL Database.
Sélectionnez le compartiment créé pour les tables par l'administrateur de service.

Pour afficher l'aide de la page en cours, cliquez sur l'icône d'aide

en haut de la page.

Création d'un compartiment

Lorsque vous vous inscrivez à Oracle Cloud Infrastructure, Oracle crée votre location avec un compartiment racine contenant toutes vos ressources cloud. Vous créez ensuite des compartiments supplémentaires dans la location (compartiment racine) et des stratégies correspondantes pour contrôler l'accès aux ressources dans chaque compartiment. Avant de créer une table Oracle NoSQL Database Cloud Service, Oracle recommande de configurer le compartiment auquel la table doit appartenir.

Créez des compartiments dans Oracle Cloud Infrastructure Identity and Access Management (IAM). Reportez-vous à Configuration de votre location et à Gestion des compartiments dans la documentation Oracle Cloud Infrastructure.

Authentification pour la connexion à Oracle NoSQL Database

Vous avez besoin d'un compte Oracle Cloud pour connecter votre application à Oracle NoSQL Database Cloud Service.

Si vous n'avez pas encore de compte Oracle Cloud, vous pouvez commencer par Oracle Cloud. Vous devez vous authentifier lors de la connexion à Oracle NoSQL Database. Vous pouvez être authentifié à l'aide de l'une des méthodes suivantes :

Méthode d'authentification n° 1 : ID utilisateur

Ici, vous utilisez un utilisateur OCI et une clé d'API pour l'authentification. Les informations d'identification utilisées pour la connexion de l'application sont associées à un utilisateur spécifique. Si vous souhaitez créer un utilisateur pour votre application, reportez-vous à Configuration d'utilisateurs, de groupes et de stratégies à l'aide d'Identity and Access Management.

Vous pouvez fournir vos informations d'identification pour cette méthode d'authentification de l'une des manières suivantes :

A l'aide d'un fichier sur un disque local, le fichier contient des détails tels que l'OCID utilisateur, l'OCID de location, la région, le chemin de clé privée et l'empreinte. Vous pouvez l'utiliser si vous travaillez à partir d'un réseau sécurisé et que le stockage local de clés privées et de configurations est conforme à vos stratégies de sécurité.
Fourniture des informations d'identification via une API.
Stockage des informations d'identification dans un coffre quelque part.

Informations composant les informations d'identification :

Table - Informations d'identification

Définition	Emplacement
ID de location et ID utilisateur (les deux sont OCID)	Reportez-vous à Emplacement de l'OCID de la location et de l'OCID de l'utilisateur dans la documentation Oracle Cloud Infrastructure.
Clé de signature d'API	Pour l'utilisateur de l'application, une clé de signature d'API doit être générée et téléchargée. Si cette opération a déjà été effectuée, vous pouvez ignorer cette étape. Pour en savoir plus, reportez-vous aux ressources suivantes dans la documentation Oracle Cloud Infrastructure : How to Generate an API Signing Key pour générer la clé de signature avec une phrase de passe facultative. How to Upload the Public Key pour télécharger la clé de signature d'API vers le compte de l'utilisateur.
Empreinte pour la clé de signature et phrase de passe (facultatif) pour la clé de signature	L'empreinte et la phrase de passe de la clé de signature sont créées lors de la génération et du téléchargement de la clé de signature d'API. Reportez-vous à Procédure d'obtention de l'empreinte de la clé dans la documentation Oracle Cloud Infrastructure.

Conseil :

Notez l'emplacement de la clé privée, de la phrase de passe facultative et de l'empreinte de la clé publique lors de la génération et du téléchargement de la clé de signature d'API.

Après avoir effectué les tâches décrites ci-dessus, collectez les informations d'identification et fournissez-les à votre application.

Fourniture des informations d'identification à l'application :

Les kits SDK Oracle NoSQL Database permettent de fournir les informations d'identification à une application de différentes manières. Les kits SDK prennent en charge un fichier de configuration ainsi que des interfaces permettant la spécification directe des informations. Reportez-vous à la documentation sur le pilote de langage de programmation que vous utilisez pour connaître les interfaces d'informations d'identification spécifiques.

Si vous utilisez un fichier de configuration, l'emplacement par défaut est ~/.oci/config. Les kits SDK permettent au fichier de résider dans d'autres emplacements. Il se présente de cette façon :

[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 ligne [DEFAULT] indique que les lignes qui suivent spécifient le profil par défaut. Un fichier de configuration peut inclure plusieurs profils, avec le préfixe [PROFILE_NAME]. Exemple :

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

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

Méthode d'authentification n° 2 : ID instance

Les ID instance sont une fonctionnalité d'Oracle Cloud Infrastructure Identity and Access Management (IAM) qui vous permet d'effectuer des appels de service à partir d'une instance. Avec les principaux d'instance, vous n'avez pas besoin de configurer les informations d'identification utilisateur pour les services exécutés sur vos instances de calcul ni d'effectuer une rotation des informations d'identification. Les instances elles-mêmes sont désormais un type de principal dans IAM. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide de certificats ajoutés à l'instance. Ces certificats sont automatiquement créés, affectés à des instances et faisant l'objet d'une rotation.

Avec l'authentification par principaux d'instance, vous pouvez autoriser une instance à effectuer des appels d'API sur les services Oracle Cloud Infrastructure. Après avoir configuré les ressources et les stratégies requises, une application exécutée sur une instance peut appeler des services publics Oracle Cloud Infrastructure. Ainsi, vous n'avez pas besoin de configurer des informations d'identification utilisateur ou un fichier de configuration. Vous pouvez recourir à l'authentification par principal d'instance à partir d'une instance sur laquelle vous ne voulez pas stocker de fichier de configuration.

Méthode d'authentification n° 3 : principaux de ressource

Vous pouvez utiliser un principal de ressource pour authentification et accès aux ressources Oracle Cloud Infrastructure. Le principal de ressource est constitué d'un jeton de session temporaire et d'informations d'identification sécurisées qui permettent aux autres services Oracle Cloud de s'authentifier sur Oracle NoSQL Database. L'authentification par principal de ressource est très semblable à l'authentification par principal d'instance, mais elle est destinée à être utilisée pour les ressources qui ne sont pas des instances, telles que les fonctions sans serveur.

Le principal de ressource permet aux ressources d'être autorisées à effectuer des actions sur les services Oracle Cloud Infrastructure. Chaque ressource possède sa propre identité et s'authentifie à l'aide des certificats qui lui sont ajoutés. Ces certificats sont créés, affectés aux ressources et font l'objet d'une rotation automatiquement, ce qui vous évite de devoir créer et gérer vos propres informations d'identification pour accéder à la ressource. Lorsque vous effectuez une authentification à l'aide d'un principal de ressource, vous n'avez pas besoin de créer et de gérer des informations d'identification pour accéder aux ressources Oracle Cloud Infrastructure.

Une fois authentifié, vous devez être autorisé à accéder aux ressources Oracle Cloud Infrastructure. Pour plus d'informations, reportez-vous à Configuration d'utilisateurs, de groupes et de stratégies à l'aide d'Identity and Access Management.

Méthode d'authentification n°4 : Authentification par jeton :

L'authentification par jeton vous permet de créer et d'utiliser un jeton de session temporaire pour authentifier les ressources Oracle Cloud Infrastructure et y accéder. A l'aide de l'authentification basée sur un jeton, vous créez un fichier de configuration local contenant des informations, y compris l'OCID utilisateur, l'OCID de location, la région, le chemin de clé privée et un chemin de fichier de fichier de fichier de jeton de session temporaire. Cette méthode utilise ces informations avec le jeton de session temporaire, qui expire au bout d'une heure (par défaut). Vous pouvez recourir à l'authentification basée sur un jeton de session lorsque vous avez besoin d'une authentification rapide et temporaire.

Création d'un jeton de session : vous pouvez générer un jeton de session avec ou sans navigateur Web.

Avec un navigateur :

Afin d'utiliser l'authentification basée sur un jeton pour l'interface de ligne de commande sur un ordinateur avec un navigateur Web, procédez comme suit :

Dans le terminal, exécutez la commande suivante :
```
oci session authenticate
```
Sélectionner une région.
Dans le navigateur, entrez vos informations d'identification utilisateur.
Une fois l'authentification réussie, fermez le navigateur et suivez l'invite interactive sur le terminal. Vous devez indiquer le nom du profil à créer dans le fichier de configuration. La nouvelle configuration de profil est écrite dans le fichier ~/.oci/config. Un exemple du fichier de configuration dans lequel le nouveau profil (par exemple TEST) est mis à jour est affiché ci-dessous.
```
[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>
```

Sans navigateur :

Pour utiliser l'authentification par jeton pour l'interface de ligne de commande sans navigateur Web, vous devez d'abord vous authentifier à l'aide de l'authentification basée sur une clé d'API.

oci setup config

Cette commande vous invite à entrer les informations requises pour créer le fichier de configuration ainsi que les clés publiques et privées d'API. La boîte de dialogue de configuration utilise ces informations pour générer une paire de clés d'API et créer le fichier de configuration. Pour utiliser l'authentification basée sur un jeton pour l'interface de ligne de commande sans navigateur Web, exécutez la commande suivante :

oci session authenticate --no-browser

Vous devez indiquer le nom du profil à créer dans le fichier de configuration. La nouvelle configuration de profil est écrite dans le fichier ~/.oci/config. Un exemple du fichier de configuration dans lequel le nouveau profil (par exemple TEST) est mis à jour est affiché ci-dessous.

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

Méthode d'authentification n° 5 : Authentification basée sur l'identité de charge globale OKE :

L'identité de charge globale d'Oracle Container Engine for Kubernetes (OKE) fournit un contrôle affiné des identités et de la gestion des accès. Une charge globale est une application exécutée sur Kubernetes. Il peut être composé d'un seul composant ou de plusieurs composants qui fonctionnent ensemble à l'intérieur d'un ensemble de pods. Une ressource de charge globale est identifiée par la combinaison unique de cluster, d'espace de noms et de compte de service. Cette combinaison unique est appelée identité de charge globale. L'identité de charge globale OKE vous permet d'accorder aux pods K8s un accès basé sur des stratégies aux ressources Oracle Cloud Infrastructure (OCI) à l'aide d'OCI Identity and Access Management (IAM).

Avec l'identité de charge globale, vous n'avez plus besoin de stocker les informations d'identification en tant que clés secrètes dans votre cluster Kubernetes ou de vous fier aux groupes dynamiques OCI pour un accès basé sur des stratégies de noeud de processus actif aux ressources OCI et, plus précisément, à vos tables NoSQL. Lorsque les applications nécessitent un accès aux ressources OCI, Workload Identity vous permet d'écrire des stratégies OCI IAM ciblées sur le compte de service Kubernetes associé aux pods d'application. Cette fonctionnalité permet aux applications exécutées dans ces pods d'accéder directement à l'API OCI en fonction des droits d'accès fournis par les stratégies.

Pour accorder à tous les pods d'une charge globale l'accès à n'importe quelle ressource OCI, procédez comme suit :

Créez un espace de noms pour un compte de service.
Créez un compte de service pour l'application à utiliser.
Définissez une stratégie IAM pour accorder à la ressource de charge globale l'accès à d'autres ressources OCI.
Téléchargez et configurez le kit SDK approprié pour la langue dans laquelle l'application est écrite.
Modifiez l'application pour indiquer les éléments suivants :
- que les demandes de charge globale doivent être authentifiées à l'aide du fournisseur d'identités de charge globale Kubernetes Engine
- les ressources OCI auxquelles accéder
Mettez à jour la spécification de déploiement de l'application pour indiquer que chaque pod de la charge globale doit utiliser le compte de service.

Autorisez la charge globale à accéder aux ressources OCI nécessaires :

Dans la console OCI, ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Stratégies.
Cliquez sur Créer une stratégie et nommez la stratégie.

Entrez une instruction de stratégie pour permettre à la charge globale d'accéder aux ressources OCI nécessaires, au format indiqué ci-dessous :

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

où :

<namespace-name> est le nom de l'espace de noms que vous avez créé précédemment.
<service-account-name> est le nom du compte de service que vous avez créé précédemment.
<cluster-ocid> est l'OCID du cluster que vous avez obtenu précédemment.

Cliquez sur Créer pour créer une stratégie.

Connexion de l'application à NDCS

En savoir plus sur la connexion de votre application à Oracle NoSQL Database Cloud Service.

Votre application se connecte à Oracle NoSQL Database Cloud Service après avoir été authentifiée à l'aide de l'une des nombreuses méthodes disponibles.

Vous pouvez vous authentifier à l'aide de l'une des méthodes suivantes :

clé de signature d'API
- A partir de n'importe quel programme SDK (Java, Python, C#, GO, Node.js, Rust) codé en dur directement
- Un fichier de configuration avec un profil par défaut
- Fichier de configuration avec un profil autre que celui par défaut
ID instance avec jetons d'authentification
Principaux de ressource
Jeton de session
Identité de charge globale OKE

Pour plus d'informations sur les options d'authentification, reportez-vous à Authentification pour la connexion à Oracle NoSQL Database.

Vous pouvez vous connecter à NDCS à l'aide de l'une des méthodes suivantes :

Fournir directement des informations d'identification dans le code :

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

Connexion à l'aide du fichier de configuration par défaut avec un profil par défaut :

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

Connexion à l'aide du fichier de configuration par défaut avec un profil autre que celui par défaut :

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

Connexion à l'aide du fichier de configuration et du profil spécifiés :

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

Connexion à l'aide d'un principal d'instance :
Le principal d'instance est une fonctionnalité de service IAM qui permet aux instances d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats qui lui sont ajoutés.
```
SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();
```
Connexion à l'aide d'un principal de ressource :
Le principal de ressource est une fonctionnalité de service IAM qui permet aux ressources d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service.
```
SignatureProvider authProvider = SignatureProvider.createWithResourcePrincipal();
```
Connexion à l'aide d'un jeton de session :
Utilisez la méthode createWithSessionToken() pour créer un fichier SignatureProvider à l'aide d'un jeton de session temporaire lu à partir d'un fichier de jeton. Le chemin du fichier de jeton est lu à partir du profil par défaut dans le fichier de configuration à l'emplacement par défaut. Le fichier de configuration utilisé est ~/.oci/config.
```
SignatureProvider authProvider = 
SignatureProvider.createWithSessionToken();
```
Vous pouvez également indiquer le chemin du fichier de jeton dans le profil autre que celui par défaut du fichier de configuration, comme indiqué ci-dessous. Le chemin du fichier de jeton est lu à partir du profil spécifié dans le fichier de configuration à l'emplacement par défaut.
```
SignatureProvider authProvider = 
SignatureProvider.createWithSessionToken(<profile_name>);
```
Connexion à l'aide de l'identité de charge globale OKE :
Vous pouvez créer une identité de charge globale SignatureProvider avec Container Engine for Kubernetes (OKE) à l'aide du jeton de compte de service Kubernetes sur le chemin par défaut /var/run/secrets/kubernetes.io/serviceaccount/token. Ce fournisseur peut uniquement être utilisé dans les pods Kubernetes.
```
SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity();
```
Vous pouvez également indiquer le jeton de compte de service Kubernetes spécifique à utiliser, comme indiqué ci-dessous.
```
SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken>);
```
Vous pouvez également indiquer l'emplacement du jeton de compte de service Kubernetes spécifique à utiliser, comme indiqué ci-dessous.
```
SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken_location>);
```

Pour plus d'informations sur les classes Java utilisées, reportez-vous à SignatureProvider.

Vous pouvez vous connecter à NDCS à l'aide de l'une des méthodes suivantes :

Fournir directement des informations d'identification dans le code :

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

Connexion à l'aide du fichier de configuration par défaut avec un profil par défaut :

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

Connexion à l'aide du fichier de configuration spécifié avec un profil autre que celui par défaut :

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

Connexion à l'aide d'un principal d'instance :
Le principal d'instance est une fonctionnalité de service IAM qui permet aux instances d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats qui lui sont ajoutés.
```
at_provider =
SignatureProvider.create_with_instance_principal(region=my_region)
```
Connexion à l'aide d'un principal de ressource :
Le principal de ressource est une fonctionnalité de service IAM qui permet aux ressources d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service.
```
at_provider = SignatureProvider.create_with_resource_principal()
```
Connexion à l'aide d'un jeton de session :
Bornéo utilise le kit SDK OCI pour l'authentification à l'aide de jetons de session. Le signataire OCI est transmis en tant que paramètre au constructeur SignatureProvider, comme indiqué ci-dessous.
```
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>)
```
Connexion à l'aide de l'identité de charge globale OKE :
Le signataire d'authentification de charge globale OKE est un signataire qui accorde à l'ensemble de la charge globale (une application exécutée sur des clusters Kubernetes) un accès aux tables NoSQL à l'aide de l'identité de charge globale OKE. Il peut être extrait par oci.auth.signers.get_oke_workload_identity_resource_principal_signer. Le signataire récupéré peut ensuite être utilisé lors de l'initialisation d'un client.
```
from borneo.iam import SignatureProvider
oke_workload_signer = oci.auth.signers.get_oke_workload_identity_resource_principal_signer()
```
Si vous disposez d'un chemin de jeton de compte de service Kubernetes différent du chemin par défaut, vous pouvez indiquer le chemin comme indiqué ci-dessous :
```
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)
```
Vous pouvez également transmettre directement le jeton de compte de service Kubernetes, comme indiqué ci-dessous :
```
#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)
```

Vous pouvez connecter votre application à NDCS à l'aide de l'une des méthodes suivantes :

Fournir directement des informations d'identification dans le code :

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

Connexion à l'aide du fichier de configuration par défaut avec un profil par défaut :

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)

Connexion à l'aide du fichier de configuration spécifié avec un profil autre que celui par défaut :

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)

Connexion à l'aide d'un principal d'instance :
Le principal d'instance est une fonctionnalité de service IAM qui permet aux instances d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats qui lui sont ajoutés.
```
sp, err := iam.NewSignatureProviderWithInstancePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)
```
Connexion à l'aide d'un principal de ressource :
Le principal de ressource est une fonctionnalité de service IAM qui permet aux ressources d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service.
```
sp, err := iam.NewSignatureProviderWithResourcePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)
```
Connexion à l'aide d'un jeton de session :
La fonction NewSessionTokenSignatureProvider crée un élément SignatureProvider à l'aide d'un jeton de session temporaire lu à partir d'un fichier de jeton.
```
func NewSessionTokenSignatureProvider() (*SignatureProvider, error)
```
Le fichier de configuration utilisé est ~/.oci/config. Le profil DEFAULT est utilisé. Le chemin du fichier de jeton est lu à partir de la configuration, à l'aide de la valeur du champ security_token_file. Lorsque vous utilisez ce constructeur, l'utilisateur dispose d'un compartiment par défaut pour toutes les tables. Il s'agit du compartiment racine de la location de l'utilisateur.
Pour utiliser un fichier de configuration autre que celui par défaut (autre que ~/.oci/config), vous pouvez utiliser la fonction NewSessionTokenSignatureProviderFromFile.
```
func NewSessionTokenSignatureProviderFromFile(configFilePath, 
ociProfile, privateKeyPassphrase string) (*SignatureProvider, error)
```
Cette fonction crée un élément SignatureProvider à l'aide d'un jeton de session temporaire lu à partir d'un fichier de jeton, à l'aide de l'élément ociProfile indiqué dans le fichier de configuration OCI configFilePath. Le chemin du fichier de jeton est lu à partir de la configuration, à l'aide de la valeur du champ security_token_file. Le champ privateKeyPassphrase n'est requis que si la clé privée utilise une phrase de passe et qu'elle n'est pas indiquée dans le champ pass_phrase du fichier de configuration OCI. Lorsque vous utilisez ce constructeur, l'utilisateur dispose d'un compartiment par défaut pour toutes les tables. Il s'agit du compartiment racine de la location de l'utilisateur.

Connexion à l'aide de l'identité de charge globale OKE :

Le kit SDK Oracle NoSQL go prend en charge l'exécution de programmes dans des conteneurs de charge globale OKE dans OCI. Dans le code qui crée un élément SignatureProvider à utiliser avec NoSQL, ajoutez le code suivant pour utiliser l'identité de charge globale 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)
}

Vous pouvez vous connecter à NDCS à l'aide de l'une des méthodes suivantes :

Fournir directement des informations d'identification dans le code :

Vous pouvez spécifier des informations d'identification directement dans le cadre de la propriété auth.iam dans la configuration initiale. Créez l'instance NoSQLClient comme suit :

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

Connexion à l'aide du fichier de configuration par défaut avec un profil par défaut :

Vous pouvez stocker les informations d'identification dans un fichier de configuration Oracle Cloud Infrastructure. Le chemin par défaut du fichier de configuration est ~/.oci/config, où ~ représente le répertoire personnel de l'utilisateur. Sous Windows, ~ est la valeur de la variable d'environnement USERPROFILE. Le fichier peut contenir plusieurs profils. Par défaut, le kit SDK utilise le profil nommé DEFAULT pour stocker les informations d'identification.
Pour utiliser ces valeurs par défaut, créez un fichier nommé config dans le répertoire ~/.oci avec le contenu suivant :
```
[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>
```
Vous pouvez également indiquer l'identificateur de région avec les informations d'identification dans le fichier de configuration OCI. Par défaut, le pilote examine l'emplacement ci-dessus. Si une région est fournie avec des informations d'identification, vous n'avez pas besoin de fournir la configuration initiale et pouvez utiliser le constructeur sans argument :
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient();
```
Vous pouvez également choisir d'indiquer la région dans la configuration :
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({ region: Region.<your-service-region> });
```
Connexion à l'aide du fichier de configuration spécifié avec un profil autre que celui par défaut :

Vous pouvez choisir d'utiliser un chemin différent pour le fichier de configuration OCI ainsi qu'un profil différent dans le fichier de configuration. Dans ce cas, spécifiez-les dans la propriété auth.iam de la configuration initiale. Par exemple, si le chemin du fichier de configuration OCI est ~/myapp/.oci/config et que vous stockez vos informations d'identification sous le profil Jane :
Créez ensuite l'instance NoSQLClient comme suit :
```
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>'
        }
    }
});
```
Connexion à l'aide d'un principal d'instance :

Le principal d'instance est une fonctionnalité de service IAM qui permet aux instances d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats qui lui sont ajoutés.
Une fois configurée, créez l'instance NoSQLClient comme suit :
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............'
    auth: {
        iam: {
            useInstancePrincipal: true
        }
    }
});
```
Vous pouvez également utiliser le fichier de configuration JSON avec la même configuration que celle décrite ci-dessus. Lorsque vous utilisez le principal d'instance, vous devez indiquer l'ID de compartiment (OCID) en tant que propriété de compartiment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Vous devez utiliser l'ID de compartiment et non le nom ou le chemin du compartiment. En outre, lorsque vous utilisez le principal d'instance, vous ne pouvez pas préfixer le nom de table avec le nom ou le chemin du compartiment lors de l'appel des API NoSQLClient.
Connexion à l'aide d'un principal de ressource :

Le principal de ressource est une fonctionnalité de service IAM qui permet aux ressources d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service.
Une fois configurée, créez l'instance NoSQLClient comme suit :
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    auth: {
        iam: {
            useResourcePrincipal: true
        }
    }
});
```
Vous pouvez également utiliser le fichier de configuration JSON avec la même configuration que celle décrite ci-dessus. Lorsque vous utilisez le principal de ressource, vous devez indiquer l'ID de compartiment (OCID) en tant que propriété de compartiment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Vous devez utiliser l'ID de compartiment et non le nom ou le chemin du compartiment. En outre, lorsque vous utilisez le principal de ressource, vous ne pouvez pas ajouter de préfixe de nom de table avec un chemin ou un nom de compartiment lors de l'appel des API NoSQLClient.
Connexion à l'aide d'un jeton de session :
A l'aide de l'authentification basée sur un jeton de session, vous créez un fichier de configuration local contenant des informations, y compris l'OCID utilisateur, l'OCID de location, la région, le chemin de clé privée et un chemin de fichier de fichier de jeton de session temporaire.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............
   ' auth: {
       iam: { useSessionToken: true }  
  }
}); 
```
Cette méthode utilise un jeton de session temporaire lu à partir d'un fichier de jeton. Le chemin du fichier de jeton est lu à partir du profil par défaut dans le fichier de configuration OCI en tant que valeur du champ security_token_file.
Pour utiliser un fichier de configuration autre que celui par défaut (autre que ~/.oci/config), vous pouvez indiquer le chemin du fichier de configuration et le nom du profil, comme indiqué ci-dessous.
```
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>"
    }  
  }
});
```
Connexion à l'aide de l'identité de charge globale OKE :
Le kit SDK Oracle NoSQL Node.js prend en charge l'exécution de programmes dans des conteneurs de charge globale OKE dans OCI.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    ' auth: {
        iam: { useOKEWorkloadIdentity: true }
    }'
  }
);
```
Ce modèle d'autorisation peut uniquement être utilisé dans l'identité de charge globale OKE pods.Using Kubernetes requiert un jeton de compte de service. Par défaut, le fournisseur charge le jeton de compte de service à partir du chemin de fichier par défaut /var/run/secrets/kubernetes.io/serviceaccount/token. Vous pouvez remplacer cette valeur et fournir le jeton de votre compte de service en indiquant l'une des 3 propriétés suivantes :
- serviceAccountToken pour fournir une chaîne de jeton de compte de service.
- serviceAccountTokenFile pour fournir un chemin vers le fichier de jeton de compte de service.
- serviceAccountTokenProvider pour fournir un fournisseur personnalisé afin de charger les jetons de compte de service.

Pour plus d'informations sur le contenu et le format du fichier, reportez-vous à Fichier de configuration du kit SDK.

Vous pouvez vous connecter à NDCS à l'aide de l'une des méthodes suivantes :

Fournir directement des informations d'identification dans le code :

Vous pouvez indiquer directement les informations d'identification sous la forme IAMCredentials lors de la création de IAMAuthorizationProvider. Créez NoSQLClient comme suit :

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

Connexion à l'aide du fichier de configuration par défaut avec un profil par défaut :

Vous pouvez stocker les informations d'identification dans un fichier de configuration Oracle Cloud Infrastructure. Le chemin par défaut du fichier de configuration est ~/.oci/config, où ~ représente le répertoire personnel de l'utilisateur. Sous Windows, ~ est la valeur de la variable d'environnement USERPROFILE. Le fichier peut contenir plusieurs profils. Par défaut, le kit SDK utilise le profil nommé DEFAULT pour stocker les informations d'identification.
Pour utiliser ces valeurs par défaut, créez le fichier nommé config dans le répertoire ~/.oci avec le contenu suivant :
```
[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>
```
Vous pouvez également indiquer l'identificateur de région avec les informations d'identification dans le fichier de configuration OCI. Par défaut, le pilote recherche les informations d'identification et une région dans le fichier de configuration OCI au niveau du chemin par défaut et du profil par défaut. Par conséquent, si vous fournissez une région avec des informations d'identification comme indiqué ci-dessus, vous pouvez créer une instance NoSQLClient sans transmettre de configuration :
```
var client = new NoSQLClient();
```
Vous pouvez également indiquer la région (ainsi que d'autres propriétés) dans NoSQLConfig :
```
var client = new NoSQLClient(
    new NoSQLConfig(
    {
        Region = Region.<your-service-region>,
        Timeout = TimeSpan.FromSeconds(10),
    });
```
Connexion à l'aide du fichier de configuration spécifié avec un profil autre que celui par défaut :

Vous pouvez choisir d'utiliser un chemin différent pour le fichier de configuration OCI ainsi qu'un profil différent dans le fichier de configuration. Dans ce cas, spécifiez-les dans la propriété auth.iam de la configuration initiale. Par exemple, si le chemin du fichier de configuration OCI est ~/myapp/.oci/config et que vous stockez vos informations d'identification sous le profil Jane :
Créez ensuite l'instance NoSQLClient comme suit :
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = Region.<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            "<your_config_file>", "<your_profile_name>")
    });
```
Connexion à l'aide d'un principal d'instance :
Le principal d'instance est une fonctionnalité de service IAM qui permet aux instances d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats qui lui sont ajoutés. Une fois configurée, créez l'instance NoSQLClient comme suit :
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        Compartment="ocid1.compartment.oc1.............................",
        AuthorizationProvider=IAMAuthorizationProvider.CreateWithInstancePrincipal()
    });
```
Vous pouvez également représenter la même configuration dans JSON comme suit :
```
{
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseInstancePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}
```
Lorsque vous utilisez le principal d'instance, vous devez indiquer l'ID de compartiment (OCID) en tant que propriété compartment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Vous devez utiliser l'ID de compartiment et non le nom ou le chemin du compartiment. En outre, lorsque vous utilisez le principal d'instance, vous ne pouvez pas préfixer le nom de table avec le nom ou le chemin du compartiment lors de l'appel des API NoSQLClient.
Connexion à l'aide d'un principal de ressource :
Le principal de ressource est une fonctionnalité de service IAM qui permet aux ressources d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service. Une fois configurée, créez l'instance NoSQLClient comme suit :
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = <your-service-region>,
        Compartment =
            "ocid1.compartment.oc1.............................",
        AuthorizationProvider =
            IAMAuthorizationProvider.CreateWithResourcePrincipal()
    });
```
Vous pouvez également représenter la même configuration dans JSON comme suit :
```
{
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseResourcePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}
```
Lorsque vous utilisez le principal de ressource, vous devez indiquer l'ID de compartiment (OCID) en tant que propriété compartment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Vous devez utiliser l'ID de compartiment et non le nom ou le chemin du compartiment. En outre, lorsque vous utilisez le principal de ressource, vous ne pouvez pas ajouter de préfixe de nom de table avec un chemin ou un nom de compartiment lors de l'appel des API NoSQLClient.
Connexion à l'aide d'un jeton de session :

A l'aide de l'authentification basée sur un jeton de session, vous créez un fichier de configuration local contenant des informations, y compris l'OCID utilisateur, l'OCID de location, la région, le chemin de clé privée et un chemin de fichier de fichier de jeton de session temporaire.

Vous pouvez utiliser l'authentification basée sur un jeton de session à l'aide de l'une des trois méthodes ci-dessous.
Option 1 : permet de créer une instance de IAMAuthorizationProvider à l'aide de l'authentification par jeton de session avec le fichier de configuration OCI par défaut et le nom de profil par défaut.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken()
});
```
Option 2 : permet de créer une instance de IAMAuthorizationProvider à l'aide de l'authentification par jeton de session avec le fichier de configuration OCI par défaut et le nom de profil indiqué.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<profileName>)
});
```
Option 3 : permet de créer une instance de IAMAuthorizationProvider à l'aide de l'authentification par jeton de session avec le fichier de configuration OCI et le nom de profil indiqués.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<configFile>,<profileName>)
});
```
Vous pouvez également représenter la même configuration dans JSON comme suit :
```
{
  "Region": "<your-service-region>",
  "AuthorizationProvider": {
    "AuthorizationType": "IAM",
    "UseSessionToken": true
  },
  "Compartment": "ocid1.compartment.oc1............................."
}
```
Connexion à l'aide de l'identité de charge globale OKE :

Le kit SDK Oracle NoSQL Dotnet prend en charge l'exécution de programmes dans des conteneurs de charge globale OKE dans OCI.
L'exemple ci-dessous crée une instance de IAMAuthorizationProvider à l'aide de l'identité de charge globale OKE. Cette méthode vous permet de spécifier une chaîne de jeton de compte de service facultative. S'il n'est pas indiqué, le jeton de compte de service est lu à partir du chemin de fichier par défaut /var/run/secrets/kubernetes.io/serviceaccount/token.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithOKEWorkloadIdentity()
});
```
Vous pouvez également créer une instance de IAMAuthorizationProvider à l'aide de l'identité de charge globale OKE et du fichier de jeton de compte de service indiqué, comme indiqué ci-dessous.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = 
    IAMAuthorizationProvider.CreateWithOKEWorkloadIdentityAndTokenFile(<serviceAccountTokenFile>)
});
```
Vous pouvez également représenter la même configuration dans JSON comme suit :
```
{ "Region": "<your-service-region>",  
 "AuthorizationProvider":  {
   "AuthorizationType": "IAM",
   "UseOKEWorkLoadIdentity": true 
 },
 "Compartment": "ocid1.compartment.oc1.............................",
}
```

Vous pouvez vous connecter à NDCS à l'aide de l'une des méthodes suivantes :

Connexion à l'aide du fichier de configuration par défaut avec un profil par défaut :

Vous pouvez stocker les informations d'identification dans un fichier de configuration Oracle Cloud Infrastructure. Le chemin par défaut du fichier de configuration est ~/.oci/config, où ~ représente le répertoire personnel de l'utilisateur. Sous Windows, ~ est la valeur de la variable d'environnement USERPROFILE. Le fichier peut contenir plusieurs profils. Par défaut, le kit SDK utilise le profil nommé DEFAULT pour stocker les informations d'identification.
Pour utiliser ces valeurs par défaut, créez le fichier nommé config dans le répertoire ~/.oci avec le contenu suivant :
```
[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>
```
Vous pouvez également indiquer l'identificateur de région avec les informations d'identification dans le fichier de configuration OCI. Par défaut, le pilote recherche les informations d'identification et une région dans le fichier de configuration OCI au niveau du chemin par défaut et dans le profil par défaut. La région n'est requise que si HandleBuilder::cloud_region() n'est pas utilisé. pass_phrase n'est requis que si le fichier de clés RSA en requiert un.
La première étape d'une application Oracle NoSQL Database Cloud Service Rust consiste à créer un descripteur utilisé pour envoyer des demandes au service, en fonction de la configuration indiquée dans une structure HandleBuilder. Les instances de la poignée sont sûres pour une utilisation simultanée et destinées à être partagées dans une application multithread ou asynchrone. L'exemple de code suivant montre comment se connecter au service cloud à l'aide d'un fichier de configuration utilisateur :
```
let handle = Handle::builder()
.cloud_auth_from_file("~/.oci/config")?
.build().await?;
```
Connexion à l'aide d'un principal d'instance
Le principal d'instance est une fonctionnalité de service IAM qui permet aux instances d'être des acteurs autorisés (ou principaux) afin d'effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats qui lui sont ajoutés. Pour configurer NoSQL dans ce mode, utilisez le code suivant :
```
let handle = Handle::builder()
.cloud_auth_from_instance()?
.build().await?;
```
Connexion à l'aide d'un principal de ressource
Le principal de ressource est une fonctionnalité de service IAM qui permet aux ressources d'être des acteurs autorisés (ou des principaux) pour effectuer des actions sur les ressources de service. Pour configurer NoSQL dans ce mode, utilisez le code suivant :
```
let handle = Handle::builder()
.cloud_auth_from_resource()?
.build().await?;
```

Workflow standard

Séquence standard de tâches à effectuer pour utiliser Oracle NoSQL Database Cloud Service.

Si vous développez des applications à l'aide d'Oracle NoSQL Database Cloud Service pour la première fois, suivez ces tâches comme guide.

Tâche	Description	En savoir plus
Connectez votre application	Connectez votre application pour utiliser Oracle NoSQL Database Cloud Service.	Connexion de l'application à NDCS
Développement de l'application	Pour développer l'application, connectez-vous aux tables Oracle NoSQL Database Cloud Service.	Développement dans Oracle Cloud Développement dans le simulateur Oracle NoSQL Database Cloud

Si vous configurez Oracle NoSQL Database Cloud Service pour la première fois, reportez-vous à Configuration du service.

Didacticiels de démarrage rapide

Accédez aux tutoriels de démarrage rapide et familiarisez-vous avec le service.

Obtenez l'accès au service.

Inscrivez-vous à une promotion cloud ou souscrivez un abonnement Oracle Cloud. Activez votre prescription, créez des utilisateurs (facultatif). Reportez-vous à Configuration du service.
Obtenez des informations d'identification permettant de connecter l'application. Reportez-vous à Authentification pour la connexion à Oracle NoSQL Database.
Créez une table dans Oracle NoSQL Database Cloud Service.
- Pour commencer, reportez-vous à Introduction aux tables dans Oracle NoSQL Database Cloud Service.