Pour commencer avec Oracle NoSQL Database Cloud Service

Oracle NoSQL Database Cloud Service est un service en nuage de base de données entièrement géré qui est conçu pour les opérations de base de données nécessitant des réponses prévisibles à la milliseconde près pour des interrogations simples.

Le service NoSQL Database Cloud permet aux développeurs de se concentrer sur le développement d'applications plutôt que sur la configuration des serveurs de grappe, ou d'effectuer la surveillance, le réglage, le diagnostic et la mise à l'échelle du système. Le service NoSQL Database Cloud convient à des applications telles que Internet of Things, la personnalisation de l'expérience utilisateur, la détection instantanée des fraudes et la publicité sur l'affichage en ligne.

Après avoir été authentifié par rapport à votre compte Oracle Cloud, vous pouvez créer une table NoSQL et spécifier les besoins en matière de débit et de stockage pour la table. Oracle réserve et gère les ressources pour répondre à vos besoins et provisionne la capacité pour vous. La capacité est spécifiée en unités de lecture et d'écriture pour le débit et en Go pour les unités de stockage.

Cet article contient les rubriques suivantes :

Rubriques connexes

Liens rapides

Vous pouvez démarrer avec le service Oracle NoSQL Database à partir de l'un des liens rapides ci-dessous :

Table - Liens rapides

     

Introduction

Connecter

Environnement de développement intégré et trousses SDK

Create Tables

Placer et explorer des données

Gérer les tables

Gérer la sécurité

Surveiller le service

Utilitaires

Référence SQL

Guide de référence

Configuration du service

Si vous configurez Oracle NoSQL Database Cloud Service pour la première fois, effectuez les tâches suivantes.

Tâche Informations de référence Informations connexes
Commandez Oracle NoSQL Database Cloud Service ou inscrivez-vous à l'essai gratuit d'Oracle. Inscription à Oracle Cloud Infrastructure dans la documentation sur Oracle Cloud Infrastructure.

Pour savoir comment estimer le coût mensuel de votre abonnement Oracle NoSQL Database Cloud Service, voir Estimation du coût mensuel.

Pour mettre à niveau votre compte gratuit ou pour modifier votre mode de paiement, voir Modification du mode de paiement dans la documentation sur Oracle Cloud Infrastructure.

Activer votre compte Oracle Cloud et vous connecter pour la première fois. Connexion à la console dans la documentation sur Oracle Cloud Infrastructure.

Pour vous familiariser avec la console Oracle Cloud Infrastructure, voir Utilisation de la console dans la documentation sur Oracle Cloud Infrastructure.

(Recommandé) Créer un compartiment pour votre service. Création d'un compartiment

Si vous n'êtes pas familier avec les compartiments, voir Présentation des compartiment dans la documentation sur Oracle Cloud Infrastructure.

Gérer la sécurité de votre service. À propos du modèle de sécurité d'Oracle NoSQL Database Cloud Service Pour vous familiariser avec le modèle de sécurité du service NoSQL Database Cloud, voir À propos du modèle de sécurité d'Oracle NoSQL Database Cloud Service.

Accès au service à partir de la console Infrastructure

Voyez comment accéder au service Oracle NoSQL Database Cloud Service à partir de la console Infrastructure.

  1. Localisez l'URL du service dans le courriel de bienvenue, puis connectez-vous à votre service Oracle NoSQL Database Cloud Service.
  2. Ouvrez le menu de navigation, cliquez sur Bases de données, puis sur NoSQL Base de données.
  3. Sélectionnez le compartiment créé pour vos tables par l'administrateur du service.
Pour afficher l'aide correspondant à la page courante, cliquez sur Tiroir 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 qui contient toutes vos ressources en nuage. Vous créez ensuite des compartiments supplémentaires au sein de la location (compartiment racine), ainsi que des politiques 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.

Vous créez des compartiments dans le service Oracle Cloud Infrastructure Identity and Access Management (IAM). Voir 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 au service Oracle NoSQL Database Cloud Service.

Si vous ne disposez pas déjà d'un compte Oracle Cloud, vous pouvez commencer avec Oracle Cloud. Vous devez vous authentifier lors de la connexion à Oracle NoSQL Database. Vous pouvez être authentifié de l'une des façons suivantes :

Méthode d'authentification #1 : Principaux d'utilisateur

Ici, vous utilisez un utilisateur OCI et une clé d'API pour l'authentification. Les données d'identification utilisées pour la connexion de votre application sont associées à un utilisateur spécifique. Pour créer un utilisateur pour votre application, voir Configuration d'utilisateurs, de groupes et de politiques à l'aide de la gestion des identités et des accès.

Vous pouvez fournir vos données d'identification pour cette méthode d'authentification de l'une des façons suivantes :
  • À l'aide d'un fichier sur un disque local, le fichier contient des détails tels que l'OCID de l'utilisateur, l'OCID de la location, la région, le chemin de la clé privée et l'empreinte numérique. Vous pouvez l'utiliser si vous travaillez à partir d'un réseau sécurisé et que le stockage local de clés et de configurations privées est conforme à vos politiques de sécurité.
  • Fourniture des données d'identification au moyen d'une API.
  • Stockage des données d'identification dans une chambre forte quelque part.

Informations comprises dans les données d'identification :

Table - Données d'identification

C'est quoi? Emplacement
ID location et ID utilisateur (les deux sont OCID) Voir Où obtenir l'OCID de la location et l'OCID de l'utilisateur dans la documentation sur 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 chargée. Si cela a déjà été fait, cette étape peut être ignorée.

Pour en savoir plus, consultez les ressources suivantes dans la documentation sur Oracle Cloud Infrastructure :
Empreinte numérique de la clé de signature et (facultatif) phrase secrète de la clé de signature L'empreinte numérique et la mot de passe de la clé de signature sont créées lors de la génération et du chargement de la clé de signature d'API. Voir Comment obtenir l'empreinte numérique de la clé dans la documentation sur Oracle Cloud Infrastructure.

Conseil :

Notez l'emplacement de la clé privée, de la phrase secrète facultative et de l'empreinte numérique de la clé publique lors de la génération et du chargement de la clé de signature d'API.

Après l'exécution des tâches ci-dessus, collectez les données d'identification et fournissez-les à votre application.

Fournir les données d'identification à votre application :

Les SDK d'Oracle NoSQL Database vous permettent de fournir les données d'identification à une application de plusieurs façons. Les SDK prennent en charge un fichier de configuration ainsi qu'une ou plusieurs interfaces qui permettent de spécifier directement les informations. Consultez la documentation relative au pilote du langage de programmation que vous utilisez pour en savoir plus sur les interfaces de données d'identification spécifiques.

Si vous utilisez un fichier de configuration, l'emplacement par défaut est ~/.oci/config. Les trousses SDK autorisent que ce fichier réside dans d'autres emplacements. Son contenu se présente comme suit :
[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 suivantes spécifient le profil Par défaut. Un fichier de configuration peut comprendre plusieurs profils, précédés de [PROFILE_NAME]. Par 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 #2 : Principaux d'instance

Instance Principals est une fonction du service 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 données d'identification d'utilisateur pour les services exécutés sur vos instances de calcul ni de faire pivoter les données d'identification. Les instances elles-mêmes sont maintenant un type de principal dans le service IAM. Chaque instance de calcul possède sa propre identité et s'authentifie à l'aide des certificats ajoutés à l'instance. Ces certificats sont automatiquement créés, affectés aux instances et soumis à une rotation.

À l'aide de l'authentification des principaux d'instance, vous pouvez autoriser une instance à appeler des API sur les services Oracle Cloud Infrastructure. Après avoir configuré les ressources et politiques requises, une application s'exécutant sur une instance peut appeler les services publics Oracle Cloud Infrastructure, ce qui supprime la nécessité de configurer les données d'identification d'utilisateur ou de définir un fichier de configuration. L'authentification du principal d'instance peut être utilisée à partir d'une instance où vous ne voulez pas stocker de fichier de configuration.

Méthode d'authentification #3 : Principaux de ressource

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

Un 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'authentification à l'aide des certificats qui y sont ajoutés. Ces certificats sont créés, affectés aux ressources et soumis à une rotation, ce qui vous évite d'avoir à créer et à gérer vos propres données d'identification pour accéder à la ressource. Lorsque vous effectuez l'authentification à l'aide d'un principal de ressource, il n'est pas nécessaire de créer et de gérer des données 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 de détails, voir Configuration d'utilisateurs, de groupes et de politiques à l'aide de la gestion des identités et des accès.

Méthode d'authentification #4 : Authentification basée sur un jeton :

L'authentification basée sur un jeton vous permet de créer et d'utiliser un jeton de session temporaire pour l'authentification et l'accès aux ressources Oracle Cloud Infrastructure. À l'aide de l'authentification basée sur un jeton, vous créez un fichier de configuration local contenant des informations, notamment l'OCID de l'utilisateur, l'OCID de la location, la région, le chemin d'accès de la clé privée et le chemin d'accès d'un 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). L'authentification basée sur un jeton de session peut être utilisée lorsque vous avez besoin d'une authentification temporaire et rapide.

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

Avec un navigateur :

Pour utiliser l'authentification basée sur un jeton pour l'interface de ligne de commande sur un ordinateur doté d'un navigateur Web :
  1. Dans le terminal, exécutez la commande suivante : 
    oci session authenticate
  2. Sélectionner une région.
  3. Dans le navigateur, entrez vos données d'identification d'utilisateur.
  4. Après l'authentification réussie, fermez le navigateur et suivez l'invite interactive sur le terminal. Vous devez fournir le nom du profil que vous souhaitez 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 présenté 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 basée sur un 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 demande d'entrer les informations requises pour créer le fichier de configuration et 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 fournir le nom du profil que vous souhaitez 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 présenté 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 #5 : Authentification basée sur l'identité de charge de travail OKE :

Les fonctions de gestion des identités et des accès d'Oracle Container Engine for Kubernetes (OKE) fournissent un contrôle détaillé de la gestion des identités et des accès. Une charge de travail est une application s'exécutant sur Kubernetes. Il peut être composé d'un seul composant ou de plusieurs composants qui fonctionnent ensemble en s'exécutant dans un ensemble de pods. Une ressource de charge de travail est identifiée par la combinaison unique de grappe, d'espace de noms et de compte de service. Cette combinaison unique est appelée identité de charge de travail. OKE Workload Identity vous permet d'accorder aux pods K8s un accès basé sur des politiques aux ressources Oracle Cloud Infrastructure (OCI) à l'aide du service de gestion des identités et des accès (IAM) d'OCI.

Avec l'identité de charge de travail, vous n'avez plus besoin de stocker les données d'identification en tant que clés secrètes dans votre grappe Kubernetes ou de vous fier à des groupes dynamiques OCI pour l'accès aux ressources OCI basé sur une politique de noeud de travail et, plus précisément, à vos tables NoSQL. Lorsque les applications nécessitent l'accès aux ressources OCI, Workload Identity vous permet d'écrire des politiques OCI IAM dont la portée est définie pour le compte de service Kubernetes associé aux pods d'application. Cette fonction permet aux applications exécutées dans ces pods d'accéder directement à l'API OCI en fonction des autorisations fournies par les politiques.

Pour accorder à tous les pods d'une charge de travail l'accès à n'importe quelle ressource OCI :
  • Créez un espace de noms pour un compte de service.
  • Créez un compte de service pour l'application à utiliser.
  • Définissez une politique IAM pour accorder à la ressource de charge de travail l'accès à d'autres ressources OCI.
  • Téléchargez et configurez la trousse SDK appropriée pour le langage dans lequel l'application est écrite.
  • Modifiez l'application pour spécifier :
    • que les demandes de charge de travail doivent être authentifiées à l'aide du fournisseur d'identités de charge de travail Kubernetes Engine
    • les ressources OCI auxquelles on doit accéder
  • Mettez à jour la spécification de déploiement de l'application pour spécifier que chaque pod de la charge de travail doit utiliser le compte de service.
Autorisation d'activer la charge de travail pour 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 Politiques.
  • Cliquez sur Créer une politique et donnez un nom à la politique.
  • Entrez un énoncé de politique pour permettre à la charge de travail d'accéder aux ressources OCI nécessaires, dans le 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 de la grappe que vous avez obtenu précédemment.

Cliquez sur Créer pour créer la politique.

Connexion de votre application à NDCS

Voyez comment connecter 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 en utilisant l'une des méthodes suivantes :
  • Clé de signature d'API
    • À 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
    • Un fichier de configuration avec un profil non par défaut
  • Principaux d'instance avec jetons d'authentification
  • Principaux de ressources
  • Jeton de session
  • Identité de charge de travail OKE

Voir Authentification pour la connexion à Oracle NoSQL Database pour plus de détails sur les options d'authentification.

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

  • Fournir directement les 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 indiqué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 fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentification à l'aide des certificats ajoutés à celle-ci. 
    SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();

  • Connexion à l'aide d'un principal de ressource :

    Le principal de ressource est une fonction de service IAM qui permet aux ressources de être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service.
    SignatureProvider authProvider = SignatureProvider.createWithResourcePrincipal();

  • Connexion à l'aide d'un jeton de session :

    Vous utilisez la méthode createWithSessionToken() pour créer un 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 non 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 de travail OKE :

    Vous pouvez créer une adresse SignatureProvider avec l'identité de charge de travail Container Engine pour Kubernetes (OKE) à l'aide du jeton de compte de service Kubernetes au chemin d'accès par défaut /var/run/secrets/kubernetes.io/serviceaccount/token. Ce fournisseur ne peut être utilisé que dans les pods Kubernetes.
    SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity();
    Vous pouvez également spécifier le jeton de compte de service Kubernetes spécifique à utiliser, comme indiqué ci-dessous.
    SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken>);
    Vous pouvez également spécifier l'emplacement du jeton de compte de service Kubernetes à utiliser, comme indiqué ci-dessous.
    SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken_location>);

Voir SignatureProvider pour plus de détails sur les classes Java utilisées.

Vous pouvez vous connecter à NDCS à l'aide d'une des méthodes suivantes :
  • Fournir directement les 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 non 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 fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentification à l'aide des certificats ajoutés à celle-ci. 
    at_provider =
SignatureProvider.create_with_instance_principal(region=my_region)

  • Connexion à l'aide d'un principal de ressource :

    Le principal de ressource est une fonction de service IAM qui permet aux ressources de être des acteurs (ou principaux) autorisés à 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 la trousse 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 de travail OKE :

    Le signataire d'authentification de charge de travail OKE est un signataire qui accorde à une charge de travail entière (une application exécutée sur des grappes Kubernetes) l'accès aux tables NoSQL à l'aide de l'identité de charge de travail OKE. Il peut être extrait par oci.auth.signers.get_oke_workload_identity_resource_principal_signer. Le signataire extrait 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 le chemin du jeton du compte de service Kubernetes est différent du chemin par défaut, vous pouvez spécifier 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 du 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 les 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 non 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 fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentification à l'aide des certificats ajoutés à celle-ci. 
    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 fonction de service IAM qui permet aux ressources de être des acteurs (ou principaux) autorisés à 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 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. Lors de l'utilisation de 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 non 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 SignatureProvider à l'aide d'un jeton de session temporaire lu à partir d'un fichier de jeton, à l'aide du ociProfile spécifié 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 secrète et qu'elle n'est pas spécifiée dans le champ pass_phrase du fichier de configuration OCI. Lors de l'utilisation de 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 de travail OKE :

    La trousse SDK Oracle NoSQL go prend en charge l'exécution de programmes dans les conteneurs OKE Workload dans OCI. Dans le code qui crée une valeur SignatureProvider à utiliser avec NoSQL, ajoutez le code suivant pour utiliser l'identité de charge de travail 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 d'une des méthodes suivantes :

  • Fournir directement les informations d'identification dans le code :

    Vous pouvez spécifier des données 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 données 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 de base de l'utilisateur. Sous Windows, ~ est une valeur de variable d'environnement USERPROFILE. Le fichier peut contenir plusieurs profils. Par défaut, la trousse SDK utilise le profil DEFAULT pour stocker les données 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>
    Notez que vous pouvez également spécifier l'identificateur de votre région avec les données d'identification dans le fichier de configuration OCI. Le pilote examinera l'emplacement ci-dessus par défaut, et si une région est fournie avec des données d'identification, vous n'avez pas besoin de fournir la configuration initiale et vous pouvez utiliser le constructeur sans argument :
    import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient();
    Vous pouvez également choisir de spécifier 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 non 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 d'accès au fichier de configuration OCI est ~/myapp/.oci/config et que vous stockez vos données 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 fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentification à l'aide des certificats ajoutés à celle-ci.

    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 un fichier de configuration JSON avec la même configuration que celle décrite ci-dessus. Notez que lorsque vous utilisez le principal d'instance, vous devez spécifier l'ID compartiment (OCID) comme propriété de compartiment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Notez que vous devez utiliser l'ID compartiment et non le nom ou le chemin du compartiment. En outre, lors de l'utilisation du principal d'instance, vous ne pouvez pas ajouter de préfixe au nom de la 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 fonction de service IAM qui permet aux ressources de être des acteurs (ou principaux) autorisés à 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 un fichier de configuration JSON avec la même configuration que celle décrite ci-dessus. Notez que lorsque vous utilisez un principal de ressource, vous devez spécifier l'ID compartiment (OCID) comme propriété de compartiment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Notez que vous devez utiliser l'ID compartiment et non le nom ou le chemin du compartiment. En outre, lors de l'utilisation du principal de ressource, vous ne pouvez pas ajouter de préfixe au nom de la table avec le nom ou le chemin du compartiment lors de l'appel des API NoSQLClient.

  • Connexion à l'aide d'un jeton de session :

    À l'aide de l'authentification basée sur un jeton de session, vous créez un fichier de configuration local contenant des informations, notamment l'OCID de l'utilisateur, l'OCID de la location, la région, le chemin d'accès de la clé privée et le chemin d'accès d'un 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 non par défaut (autre que ~/.oci/config), vous pouvez spécifier 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 de travail OKE :

    La trousse SDK Oracle NoSQL Node.js prend en charge l'exécution de programmes dans les conteneurs de charge de travail 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 ne peut être utilisé que dans une identité de charge de travail OKE Kubernetes pods.Using nécessitant un jeton de compte de service. Par défaut, le fournisseur charge le jeton de compte de service à partir du chemin d'accès au fichier par défaut /var/run/secrets/kubernetes.io/serviceaccount/token. Vous pouvez remplacer cette valeur et fournir votre jeton de compte de service en spécifiant 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 d'accès au fichier de jeton du compte de service.
    • serviceAccountTokenProvider pour fournir un fournisseur personnalisé pour charger les jetons de compte de service.

Voir Fichier de configuration de trousse SDK pour plus de détails sur le contenu et le format du fichier.

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

  • Fournir directement les informations d'identification dans le code :

    Vous pouvez spécifier des données d'identification directement en tant que 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 données 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 de base de l'utilisateur. Sous Windows, ~ est une valeur de variable d'environnement USERPROFILE. Le fichier peut contenir plusieurs profils. Par défaut, la trousse SDK utilise le profil DEFAULT pour stocker les données 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>
    Notez que vous pouvez également spécifier l'identificateur de votre région avec les données d'identification dans le fichier de configuration OCI. Par défaut, le pilote recherche les données d'identification et une région dans le fichier de configuration OCI dans le chemin par défaut et dans le profil par défaut. Ainsi, si vous fournissez la région avec les données d'identification comme indiqué ci-dessus, vous pouvez créer une instance NoSQLClient sans transmettre de configuration :
    var client = new NoSQLClient();
    Vous pouvez également spécifier 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 non 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 d'accès au fichier de configuration OCI est ~/myapp/.oci/config et que vous stockez vos données 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 fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentification à l'aide des certificats ajoutés à celle-ci. 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.............................",
}

    Notez que lorsque vous utilisez le principal d'instance, vous devez spécifier l'ID 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. Notez que vous devez utiliser l'ID compartiment et non le nom ou le chemin du compartiment. En outre, lors de l'utilisation du principal d'instance, vous ne pouvez pas ajouter de préfixe au nom de la 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 fonction de service IAM qui permet aux ressources de être des acteurs (ou principaux) autorisés à 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.............................",
}

    Notez que lors de l'utilisation du principal de ressource, vous devez spécifier l'ID 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. Notez que vous devez utiliser l'ID compartiment et non le nom ou le chemin du compartiment. En outre, lors de l'utilisation du principal de ressource, vous ne pouvez pas ajouter de préfixe au nom de la table avec le nom ou le chemin du compartiment lors de l'appel des API NoSQLClient.

  • Connexion à l'aide d'un jeton de session :

    À l'aide de l'authentification basée sur un jeton de session, vous créez un fichier de configuration local contenant des informations, notamment l'OCID de l'utilisateur, l'OCID de la location, la région, le chemin d'accès de la clé privée et le chemin d'accès d'un 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 indiquées ci-dessous.

    Option 1 : Cela crée une nouvelle instance de IAMAuthorizationProvider à l'aide de l'authentification basée sur un 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 : Cela crée une nouvelle instance de IAMAuthorizationProvider à l'aide de l'authentification basée sur un jeton de session avec le fichier de configuration OCI par défaut et le nom de profil spécifié.
    var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<profileName>)
});
    Option 3 : Cela crée une nouvelle instance de IAMAuthorizationProvider à l'aide de l'authentification basée sur un jeton de session avec le fichier de configuration et le nom de profil OCI spécifié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 de travail OKE :

    La trousse SDK Dotnet d'Oracle NoSQL prend en charge l'exécution de programmes dans des conteneurs OKE Workload dans OCI.

    L'exemple ci-dessous crée une nouvelle instance de IAMAuthorizationProvider à l'aide de l'identité de charge de travail OKE. Cette méthode vous permet de spécifier une chaîne de jeton de compte de service facultative. S'il n'est pas spécifié, le jeton de compte de service est lu à partir du chemin d'accès au 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 nouvelle instance de IAMAuthorizationProvider à l'aide de l'identité de charge de travail OKE et du fichier de jeton de compte de service spécifié, 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 données 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 de base de l'utilisateur. Sous Windows, ~ est une valeur de variable d'environnement USERPROFILE. Le fichier peut contenir plusieurs profils. Par défaut, la trousse SDK utilise le profil DEFAULT pour stocker les données 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>

    Notez que vous pouvez également spécifier votre identificateur de région ainsi que les données d'identification dans le fichier de configuration OCI. Par défaut, le pilote recherche les données d'identification et une région dans le fichier de configuration OCI dans le 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é 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 du 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 en nuage à l'aide d'un fichier de configuration d'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 fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentifie à l'aide des certificats qui y 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 fonction de service IAM qui permet aux ressources d'être des acteurs (ou principaux) autorisés à 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?;

Flux de travail type

Séquence typique de tâches à utiliser avec Oracle NoSQL Database Cloud Service.

Si vous développez des applications à l'aide d'Oracle NoSQL Database Cloud Service pour la première fois, effectuez les tâches suivantes.

Tâche Description Informations supplémentaires
Connecter votre application Connectez votre application pour utiliser des tables Oracle NoSQL Database Cloud Service. Connexion de votre application à NDCS
Développer votre application Développez votre application après vous être connecté 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, voir Configuration de votre service.

Didacticiels pour démarrage rapide

Accédez aux tutoriels de démarrage rapide et commencez à utiliser le service.

  1. Accédez au service.

    Inscrivez-vous à une promotion en nuage ou achetez un abonnement à Oracle Cloud. Activez votre commande, créez des utilisateurs (facultatif). Voir Configuration de votre service.

  2. Obtenez des données d'identification pour connecter l'application. Voir Authentification pour la connexion à Oracle NoSQL Database.

  3. Créez une table dans Oracle NoSQL Database Cloud Service.