Introduction au service Oracle NoSQL Database Cloud

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 latence de l'ordre de la milliseconde près pour les 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 est adapté aux applications telles que Internet of Things, la personnalisation de l'expérience utilisateur, la détection instantanée des fraudes et l'affichage publicitaire 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 :

Liens rapides

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

Table - Liens rapides

     
Démarrer

- Démarrage rapide : Démarrage
- Fonctions clés
- Concepts relatifs au nuage
- Tarification		 Connexion

- Acquérir vos données d'identification
- Authentification pour la connexion à NDCS
- Connexion de votre application à NDCS
- Régions de données et points d'extrémité de service associés		 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
Create Tables

- Designing a Table
- Using Console to create Singleton Tables
- Using APIs to create Singleton Tables
- Global Active Tables
- Using console to create a Global Active Table
- Using APIs to create a Global Active Table
- Using OCI cli to create a table		 Put and Explore Data

- Using Console to add data
- Using APIs to add data
- Using Console to fetch data
- Using Get API to fetch data
- Using Query API to fetch data
- Querying parent-child tables		 Gérer les 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 des tables et des index à l'aide de la console
Gérer la sécurité

- Configurer des groupes d'utilisateurs et des politiques
- Autoriser un autre utilisateur à gérer les tables NoSQL
- Informations de référence sur les politiques		 Surveiller le service

- Événements de service
- Quotas de service
- Mesures
- Créer et gérer des alarmes		 Services publics

- Télécharger le simulateur Oracle NoSQL Database Cloud
- Développement dans le simulateur Oracle NoSQL Database Cloud
- Utilisation du migrateur Oracle NoSQL Database
- Utilisation de l'intégrateur Oracle NoSQL Database Analytics
SQL Reference

- Using Operators in SQL
- Sorting Grouping and Limiting Data
- Using Primary Expressions in SQL
- Using Timestamp functions in queries
- Using String functions in queries		 Guides de référence

- Informations de référence sur Analytics Integrator
- Exemples de cas d'utilisation pour NDCS
- Dépanner les problèmes de GAT		  

Configuration de votre service

Pour configurer Oracle NoSQL Database Cloud Service pour la première fois, effectuez les tâches suivantes :

Tâche Informations de référence Informations connexes
Commander Oracle NoSQL Database Cloud Service ou vous inscrire à 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 ne connaissez pas les compartiments, voir Présentation des compartiments dans la documentation sur Oracle Cloud Infrastructure.
Gérer la sécurité de votre service. À propos du modèle de sécurité du service Oracle NoSQL Database Cloud Pour vous familiariser avec le modèle de sécurité du service NoSQL Database Cloud, voir À propos du modèle de sécurité du service Oracle NoSQL Database Cloud Service.

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

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

  1. Localisez l'URL du service à partir du 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 vos tables par l'administrateur du service.

Pour afficher l'aide sur la page courante, cliquez sur l'icône d'aide Icône du 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 destiné à contenir 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 vous recommande de configurer le compartiment dans lequel vous voulez que la table appartienne.

Vous créez des compartiments dans le service de gestion des identités et des accès (GIA) pour Oracle Cloud Infrastructure. Voir Configuration de votre location et Gestion des compartiments dans la documentation sur Oracle Cloud Infrastructure.

Authentification pour se connecter à 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 avec Oracle Cloud. Vous devez vous authentifier lorsque vous connectez à Oracle NoSQL Database. Vous pouvez être authentifié de l'une des façons suivantes :

Méthode d'authentification #1 : Principaux utilisateurs

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 :

Informations comprises dans les données d'identification :

Table - Données d'identification

De quoi s'agit-il? 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 ces opérations ont déjà été effectuées, cette étape peut être ignorée.

Pour en savoir plus, voir 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 phrase secrète 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.

Note : Prenez note de 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 avoir exécuté les tâches ci-dessus, collectez les données d'identification et fournissez-les à votre application.

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

Les trousses SDK d'Oracle NoSQL Database vous permettent de fournir les données d'identification à une application de plusieurs façons. Les trousses 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 qui suivent spécifient le profil DEFAULT. 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 n°2 : Principaux d'instance

Instance Principals est une capacité 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 ou d'effectuer une rotation des données d'identification. Les instances elles-mêmes sont désormais un type principal dans IAM. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats ajoutés à l'instance. Ces certificats sont créés automatiquement, affectés aux instances et soumis à une rotation.

Avec l'authentification des principaux d'instance, vous pouvez autoriser une instance à appeler des API sur les services Oracle Cloud Infrastructure. Une fois les ressources et politiques requises configurées, 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 sur laquelle vous ne voulez pas stocker de fichier de configuration.

Méthode d'authentification no 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 de données d'identification sécurisées qui permettent à d'autres services Oracle Cloud de s'authentifier auprès d'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 elle s'authentifie à l'aide des certificats qui y sont ajoutés. Ces certificats sont créés automatiquement, 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 procédez à l'authentification à l'aide d'un principal de ressource, vous n'avez pas besoin de créer ni 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 authentifier et accéder aux ressources Oracle Cloud Infrastructure. Avec l'authentification basée sur un jeton, vous créez un fichier de configuration local qui contient des informations, notamment l'OCID de l'utilisateur, l'OCID de la location, la région, le chemin 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 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. 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 où 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 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 où 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 no 5 : Authentification basée sur l'identité pour la charge de travail OKE

L'identité de charge de travail Oracle Container Engine for Kubernetes (OKE) fournit 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 à l'intérieur d'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. L'identité de charge de travail OKE vous permet d'accorder aux pods K8s un accès basé sur une politique aux ressources Oracle Cloud Infrastructure (OCI) à l'aide du service de gestion des identités et des accès (IAM) de l'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 ni de vous fier aux groupes dynamiques OCI pour accéder aux ressources OCI en fonction des politiques des noeuds 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 adaptées au 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 :

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

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 à l'aide de l'un des éléments suivants :

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

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

  • Fourniture directe des données 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 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 fichier de configuration et du profil spécifiés :

    /* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * You specify the full path of the non-default config file and also the name
 * of the profile
 */

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

  • Connexion à l'aide d'un principal d'instance :

    Le principal d'instance est une 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.

    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 d'ê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 fournisseur de signature à 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 par défaut dans le fichier de configuration, comme illustré 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 identité de charge de travail SignatureProvider avec Container Engine pour 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 spécifier le jeton de compte de service Kubernetes spécifique à utiliser, comme illustré ci-dessous.

    SignatureProvider authProvider =
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken>);

    Vous pouvez également spécifier l'emplacement du jeton de compte de service Kubernetes spécifique à 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 de l'une des méthodes suivantes :

  • Fourniture directe des données 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 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'authentifie à l'aide des certificats qui y 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 fonction de service IAM qui permet aux ressources d'ê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 s'exécutant 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 vous avez un chemin de jeton de compte de service Kubernetes 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 :

  • Fourniture directe des données 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 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'authentifie à l'aide des certificats qui y 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 fonction de service IAM qui permet aux ressources d'ê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 une valeur SignatureProvider à l'aide d'un jeton de session temporaire lu à partir d'un fichier de jeton, à l'aide de la valeur ociProfile spécifié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 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 go d'Oracle NoSQL prend en charge l'exécution de programmes dans les conteneurs de charge de travail OKE dans OCI. Dans le code qui crée un fournisseur de signature à utiliser avec NoSQL, ajoutez le code suivant pour utiliser l'identité OKE Workload :

    conf, err := ociauth.OkeWorkloadIdentityConfigurationProvider()
if err != nil {
   return nil, fmt.Errorf("cannot create an Oke Provider: %v", err)
}
myconf := &myConfigProvider{conf}
sp, err := iam.NewSignatureProviderWithConfiguration(myconf, compartmentID)
if err != nil {
  return nil, fmt.Errorf("cannot create a Signature Provider: %v", err)
}

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

  • Fourniture directe des données 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 votre identificateur de région ainsi que les données d'identification dans le fichier de configuration OCI. Le pilote examinera par défaut l'emplacement ci-dessus. 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 autre que 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 votre 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'authentifie à l'aide des certificats qui y sont ajoutés.

    Une fois configurée, créez l'instance NoSQLClient comme suit :

    import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............'
    auth: {
        iam: {
            useInstancePrincipal: true
        }
    }
});

    Vous pouvez également utiliser le fichier de configuration JSON avec la même configuration que celle décrite ci-dessus. Notez que lorsque vous utilisez le principal d'instance, vous devez spécifier l'ID compartiment (OCID) en tant que propriété de compartiment. Cela est requis 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 préfixer le 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 d'ê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 le fichier de configuration JSON avec la même configuration que celle décrite ci-dessus. Notez que lorsque vous utilisez le principal de ressource, vous devez spécifier l'ID compartiment (OCID) en tant que propriété de compartiment. Cela est requis 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 préfixer le 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 :

    Avec l'authentification basée sur un jeton de session, vous créez un fichier de configuration local qui contient des informations, notamment l'OCID de l'utilisateur, l'OCID de la location, la région, le chemin 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 Node.js d'Oracle NoSQL 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 les pods Kubernetes. L'utilisation de l'identité de charge de travail OKE nécessite un jeton de compte de service. Par défaut, le fournisseur chargera le jeton du compte de service à partir du chemin d'accès au fichier par défaut /var/run/secrets/kubernetes.io/serviceaccount/token. Vous pouvez remplacer cela 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 de compte de service.

    • serviceAccountTokenProvider fournit 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 de l'une des méthodes suivantes :

  • Fourniture directe des données d'identification dans le code :

    Vous pouvez indiquer des données d'identification directement en tant que données d'identification 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 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. Ainsi, si vous fournissez une région avec des 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 autre que 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 votre 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'authentifie à l'aide des certificats qui y sont ajoutés. Une fois configurée, créez l'instance NoSQLClient comme suit :

    var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        Compartment="ocid1.compartment.oc1.............................",
        AuthorizationProvider=IAMAuthorizationProvider.CreateWithInstancePrincipal()
    });

    Vous pouvez également représenter la même configuration dans JSON comme suit :

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

    Notez que lorsque vous utilisez le principal d'instance, vous devez spécifier l'ID compartiment (OCID) en tant que propriété de compartiment. Cela est requis 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 préfixer le 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 d'ê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 lorsque vous utilisez le principal de ressource, vous devez spécifier l'ID compartiment (OCID) en tant que propriété de compartiment. Cela est requis 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 préfixer le 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 :

    Avec l'authentification basée sur un jeton de session, vous créez un fichier de configuration local qui contient des informations, notamment l'OCID de l'utilisateur, l'OCID de la location, la région, le chemin 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 décrites 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 : Permet de créer 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 : Permet de créer 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 Oracle NoSQL Dotnet prend en charge l'exécution de programmes dans les conteneurs de charge de travail OKE 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 du compte de service sera 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()?
.compartment_id ("ocid1.compartment.oc1.............................")?
.build().await?;

Flux de travail type

Séquence type 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, reportez-vous à ces tâches comme guide.

Tâche Description Informations supplémentaires
Connecter votre application Connecter votre application pour utiliser les 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</p>

Si vous configurez Oracle NoSQL Database Cloud Service pour la première fois, voir Configuration de votre service.

Tutoriels pour démarrage rapide

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

  1. Accédez au service.

    Inscrivez-vous pour une promotion sur le 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 se connecter à Oracle NoSQL Database.

  3. Créez une table dans Oracle NoSQL Database Cloud Service. Pour commencer, voir Introduction aux tables dans Oracle NoSQL Database Cloud Service.