Introduction à Oracle NoSQL Database Cloud Service

Oracle NoSQL Database Cloud Service est un service Cloud de base de données entièrement géré conçu pour les opérations de base de données qui nécessitent une réponse à une latence prévisible de l'ordre de la milliseconde à une seule requête.

NoSQL Database Cloud Service permet aux développeurs d'effectuer la surveillance, le réglage, le diagnostic et la mise à l'échelle des systèmes, plutôt que de configurer les serveurs du cluster. NoSQL Database Cloud Service est adapté aux applications telles qu'Internet of Things, la personnalisation d'une expérience utilisateur, la détection de fraudes instantanées et de la publicité en ligne.

Une fois votre compte Oracle Cloud authentifié, vous pouvez créer une table NoSQL, et indiquer les exigences de débit et de stockage de la table. Oracle réserve et gère les ressources afin qu'elles répondent à vos exigences, et provisionnent la capacité pour vous. La capacité est spécifiée à l'aide d'unités de lecture et d'écriture pour le débit et de Go pour les unités de stockage.

Cet article comprend les rubriques suivantes :

Liens rapides

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

Table - Liens rapides

     
Introduction

- Démarrage rapide : Introduction
- Caractéristiques clés
- Concepts du cloud
- Tarification		 Connexion

- Acquérir vos informations d'identification
- Authentification de connexion à NDCS
- Connexion de votre application à NDCS
- Régions de données et adresses de service associées		 IDE and SDKs

- Using IntelliJ Plugin for Development
- Using Visual Studio Code Extension for Development
- Oracle NoSQL Java SDK
- Oracle NoSQL Python SDK
- Oracle NoSQL GO SDK
- Oracle NoSQL Node.js SDK
- Oracle NoSQL Dotnet SDK
- Oracle NoSQL Rust SDK
Création de 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
- Utilisation de la console pour créer une table active globale
- Utilisation d'API pour créer une table active globale
- Utilisation de l'interface de ligne de commande OCI pour créer une table		 Transfert et exploration de données

- Utilisation de la console pour ajouter des données
- Utilisation d'API pour ajouter des données
- Utilisation de la console pour extraire des données
- Utilisation de l'API pour extraire des données
- Utilisation de l'API de requête pour extraire des données
- Interrogation des tables parent-enfant		 Gestion de tables

- Modification de tables singleton à l'aide d'API
- Modification de tables actives globales à l'aide d'API
- Suppression de tables et d'index
- Gestion de tables et d'index à l'aide de la console
Gestion de la sécurité

- Configuration de stratégies et de groupes d'utilisateurs
- Autorisation d'un autre utilisateur à 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écharger le simulateur Oracle NoSQL Database Cloud
- Développement dans le simulateur d'Oracle NoSQL Database Cloud
- Utilisation d'Oracle NoSQL Database Migrator
- Utilisation d'Oracle NoSQL Database Analytics Integrator
Référence SQL

- Utilisation d'opérateurs dans SQL
- Tri des données de regroupement et de limitation
- Utilisation d'expressions principales dans SQL
- Utilisation de fonctions d'horodatage dans les requêtes
- Utilisation de fonctions String dans les requêtes		 Guides de référence

- Référence Analytics Integrator
- Exemples de cas d'utilisation pour NDCS
- Résoudre les problèmes liés à 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
Passage d'une commande pour Oracle NoSQL Database Cloud Service ou inscription pour bénéficier de la version d'évaluation gratuite Oracle. Inscription à Oracle Cloud Infrastructure dans la documentation Oracle Cloud Infrastructure. Pour savoir comment estimer le coût mensuel de votre abonnement Oracle NoSQL Database Cloud Service, reportez-vous à Estimation des coûts mensuels.

Pour mettre à niveau votre compte gratuit ou modifier votre 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. Signing In to the Console in Oracle Cloud Infrastructure Documentation. Pour vous familiariser avec Oracle Cloud Infrastructure Console, 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 les compartiments, reportez-vous à Présentation des compartiments dans la documentation Oracle Cloud Infrastructure.
Gestion de la sécurité du service. A propos du modèle de sécurité d'Oracle NoSQL Database Cloud Service Pour vous familiariser avec le modèle d'accès sécurisé NoSQL Database Cloud Service, reportez-vous à A propos d'Oracle NoSQL Database Cloud Service Security Model.

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.

  1. Localisez l'URL du service dans le courriel de bienvenue, puis connectez-Vous à Oracle NoSQL Database Cloud Service.

  2. Ouvrez le menu de navigation, cliquez sur Bases de données, puis sur Base de données NoSQL.

  3. 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 Icône du volet 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 vous recommande de configurer le compartiment dont la table doit appartenir.

Vous créez des compartiments dans Oracle Cloud Infrastructure Identity and Access Management (IAM). Reportez-vous à Configuration de votre location et à la 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 déjà de compte Oracle Cloud, vous pouvez commencer par Oracle Cloud. Vous devez vous authentifier lorsque vous êtes connecté à Oracle NoSQL Database. Vous pouvez être authentifié de l'une des manières 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 :

Informations composant les informations d'identification :

Table - Informations d'identification

De quoi s'agit-il ? 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 :
Empreinte de la clé de signature et phrase de passe (facultatif) de 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 à Obtention de l'empreinte de la clé dans la documentation Oracle Cloud Infrastructure.

Remarque : notez l'emplacement de votre clé privée, de l'empreinte de clé publique facultative et de l'empreinte de votre clé de signature d'API lors de sa génération et son téléchargement.

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 SDK Oracle NoSQL Database vous 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 du pilote du 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. Son contenu ressemble à ce qui 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 qui suivent spécifient le profil DEFAULT. 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 de les faire pivoter. Les instances elles-mêmes sont désormais un type de principal dans IAM. Chaque instance de calcul possède sa propre identité et s'authentifie à l'aide des certificats qui elle sont ajoutés. Ces certificats sont automatiquement créés, affectés aux 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 du principal d'instance à partir d'une instance ou 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 authentifier les ressources Oracle Cloud Infrastructure et y accéder. Le principal de ressource se compose d'un jeton de session temporaire et d'informations d'identification sécurisées qui permettent aux autres services Oracle Cloud de s'authentifier auprès d'Oracle NoSQL Database. L'authentification par principal de ressource est très semblable à l'authentification de 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.

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 elle est authentifiée à l'aide des certificats qui lui sont ajoutés. Ces certificats sont automatiquement créés, affectés aux ressources et faisant l'objet d'une rotation, ce qui vous évite de créer et de 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 des 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. Avec l'authentification basée sur un jeton, vous créez un fichier d'installation local contenant des informations, notamment l'OCID utilisateur, l'OCID de location, la région, le chemin de clé privée et un chemin de fichier du jeton d'une 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 :

  1. Dans le terminal, exécutez la commande suivante :

    oci session authenticate

  2. Sélectionner une région.

  3. Dans le navigateur, entrez vos informations d'identification utilisateur.

  4. 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 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 par jeton pour la CLI 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 à saisir 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 par 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 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 n°5 : authentification basée sur l'identité de la charge globale OKE

L'identité de charge globale Oracle Container Engine for Kubernetes (OKE) fournit un contrôle affiné de gestion des identités et 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 une stratégie aux ressources Oracle Cloud Infrastructure (OCI) à l'aide d'OCI Identity and Access Management (IAM).

Avec Workload Identity, vous n'avez plus besoin de stocker des informations d'identification en tant que clés secrètes dans votre cluster Kubernetes ou de vous appuyer sur des groupes dynamiques OCI pour accéder aux ressources OCI via une stratégie de noeud de processus actif et, plus précisément, à vos tables NoSQL. Lorsque les applications nécessitent un accès aux ressources OCI, l'identité de charge globale 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 :

Autorisation permettant à la charge globale d'accéder aux ressources OCI nécessaires :

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

Connexion de l'application à NDCS

Découvrez 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 à l'aide de l'une des méthodes suivantes :

Pour plus de détails sur les options d'authentification, reportez-vous à Authentification de connexion à Oracle NoSQL Database.

Vous pouvez vous connecter à NDCS de l'une des manières suivantes :

  • Fourniture directe d'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 constructor for SignatureProvider. */

 final String profile_name = "<name_of_the_profile>";
 SignatureProvider sp = new  SignatureProvider(profile_name);

  • Connexion à l'aide du profil et du fichier de configuration 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 via un principal d'instance :

    Instance Principal est une fonctionnalité du service IAM permettant aux instances d'être des acteurs autorisés (ou un des principaux) afin d'effectuer des actions sur des 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 permettant aux ressources d'être des acteurs autorisés (ou des principaux) pour 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 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 un fournisseur de signature avec l'identité de charge globale 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 ne peut être utilisé que 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 de détails sur les classes Java utilisées, reportez-vous à SignatureProvider.

Vous pouvez vous connecter à NDCS de l'une des manières suivantes :

  • Fourniture directe d'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 :

    Instance Principal est une fonctionnalité du service IAM permettant aux instances d'être des acteurs autorisés (ou un des principaux) afin d'effectuer des actions sur des 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 permettant aux ressources d'être des acteurs autorisés (ou des principaux) pour 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 à une charge globale entière (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 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 vous avez 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 de l'une des manières suivantes :

  • Fourniture directe d'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 :

    Instance Principal est une fonctionnalité du service IAM permettant aux instances d'être des acteurs autorisés (ou un des principaux) afin d'effectuer des actions sur des 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 permettant aux ressources d'être des acteurs autorisés (ou des principaux) pour 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 une valeur 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. C'est le compartiment racine de la location de l'utilisateur.

    Pour utiliser un fichier de configuration autre que 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 une valeur SignatureProvider à l'aide d'un jeton de session temporaire lu à partir d'un fichier de jeton, à l'aide de la valeur ociProfile indiquée 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. C'est le compartiment racine de la location de l'utilisateur.

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

    Le kit SDK Go Oracle NoSQL prend en charge l'exécution de programmes dans les conteneurs de charge globale OKE dans OCI. Dans le code qui crée un fournisseur de signature à 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 de l'une des manières suivantes :

  • Fourniture directe d'informations d'identification dans le code :

    Vous pouvez indiquer les informations d'identification directement dans la propriété auth.iam de la configuration initiale. Créez une 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 une 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 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 autre que celui par défaut :

    Vous pouvez choisir d'utiliser un autre chemin pour le fichier de configuration OCI ainsi qu'un autre profil 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 :

    Instance Principal est une fonctionnalité du service IAM permettant aux instances d'être des acteurs autorisés (ou un des principaux) afin d'effectuer des actions sur des 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 l'instance NoSQLClient configurée, créez-la 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 un 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 un ID de compartiment et non un chemin ou un nom de 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 permettant aux ressources d'être des acteurs autorisés (ou des principaux) pour effectuer des actions sur les ressources de service

    Une fois l'instance NoSQLClient configurée, créez-la 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 un 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 un ID de compartiment et non un chemin ou un nom de compartiment. En outre, lorsque vous utilisez le principal de ressource, 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 jeton de session :

    Avec l'authentification basée sur un jeton d'accès de session, vous créez un fichier d'installation local contenant des informations, notamment l'OCID utilisateur, l'OCID de location, la région, le chemin de clé privée et un chemin de fichier du jeton d'accès 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 Node.js Oracle NoSQL 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 ne peut être utilisé que dans les pods Kubernetes. L'utilisation de l'identité de charge globale OKE nécessite 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 d'accès au fichier de jeton de compte de service.

    • serviceAccountTokenProvider pour fournir un fournisseur personnalisé pour charger les jetons de compte de service.

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

Vous pouvez vous connecter à NDCS de l'une des manières suivantes :

  • Fourniture directe d'informations d'identification dans le code :

    Vous pouvez spécifier des informations d'identification directement en tant qu'IAMCredentials lors de la création d'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 une 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 chemin par défaut et dans le 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 autre chemin pour le fichier de configuration OCI ainsi qu'un autre profil 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 :

    Instance Principal est une fonctionnalité du service IAM permettant aux instances d'être des acteurs autorisés (ou un des principaux) afin d'effectuer des actions sur des 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 l'instance NoSQLClient configurée, créez-la 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 au format 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 un 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 un ID de compartiment et non un chemin ou un nom de 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 permettant aux ressources d'être des acteurs autorisés (ou des principaux) pour effectuer des actions sur les ressources de service Une fois l'instance NoSQLClient configurée, créez-la 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 au format 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 un 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 un ID de compartiment et non un chemin ou un nom de compartiment. En outre, lorsque vous utilisez le principal de ressource, 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 jeton de session :

    Avec l'authentification basée sur un jeton d'accès de session, vous créez un fichier d'installation local contenant des informations, notamment l'OCID utilisateur, l'OCID de location, la région, le chemin de clé privée et un chemin de fichier du jeton d'accès 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 d'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 d'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 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 d'IAMAuthorizationProvider à l'aide de l'authentification basée sur un 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 au format 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 les conteneurs de charge globale OKE dans OCI.

    L'exemple ci-dessous crée une instance d'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. Si aucune valeur n'est indiquée, 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 d'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 au format JSON comme suit :

    { "Region": "<your-service-region>",
 "AuthorizationProvider":  {
   "AuthorizationType": "IAM",
   "UseOKEWorkLoadIdentity": true
 },
 "Compartment": "ocid1.compartment.oc1.............................",
}

Vous pouvez vous connecter à NDCS de l'une des manières 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 une 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 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 fournie dans une structure HandleBuilder. Les instances du Handle sont sécurisées 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 via un principal d'instance

    Instance Principal est une fonctionnalité du service IAM permettant aux instances d'être des acteurs autorisés (ou un des principaux) afin d'effectuer des actions sur des 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()?
.compartment_id ("ocid1.compartment.oc1.............................")?
.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
Connecter votre application Connectez votre application pour utiliser les tables Oracle NoSQL Database Cloud Service. Connexion de l'application à NDCS
Développement de l'application Développez l'application après avoir été connecté aux tables Oracle NoSQL Database Cloud Service. Développement dans Oracle Cloud

Développement dans le simulateur de cloud Oracle NoSQL Database</p>

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

Tutoriels de démarrage rapide

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

  1. Obtenez l'accès au service.

    Inscrivez- vous à une promotion cloud ou achetez un abonnement Oracle Cloud. Activez votre commande, créez des utilisateurs (facultatif). Reportez-vous à Configuration du service.

  2. Obtenez des informations d'identification permettant de connecter l'application. Reportez-vous à Authentification pour la connexion à Oracle NoSQL Database.

  3. Créez une table dans Oracle NoSQL Database Cloud Service. Pour commencer, reportez-vous à Introduction aux tables dans Oracle NoSQL Database Cloud Service.