Introduction à Oracle NoSQL Database Cloud Service

Liens express

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

Tableau - Liens rapides


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

Configuration du service

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

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

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

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

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

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

en haut de la page.

Création d'un compartiment

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

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

Authentification pour la connexion à Oracle NoSQL Database

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

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

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

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

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

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

Informations composant les informations d'identification :

Table - Informations d'identification

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

Conseil :

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

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

Fourniture des informations d'identification à l'application :

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

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

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

La ligne [DEFAULT] indique que les lignes qui suivent spécifient le profil par défaut. Un fichier de configuration peut inclure plusieurs profils, avec le préfixe [PROFILE_NAME]. Exemple :

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

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

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

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

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

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

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

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

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

Connexion de l'application à NDCS

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

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

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

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

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

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

Fournir directement des informations d'identification dans le code :

/* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * By default, the SignatureProvider will read your OCI configuration file 
 * from the default location, ~/.oci/config. See SignatureProvider for 
 * additional options for reading configurations in other ways.*/
SignatureProvider sp = new SignatureProvider(
 tenantId,     // a string, OCID
 userId,       // a string, OCID
 fingerprint , // a string
 privateKey,   // a string, content of private key
 passPhrase    // optional, char[]
);
//Create an handle to access the cloud service in your service region.
NoSQLHandleConfig config = new NoSQLHandleConfig(Region.<your-service-region>);
config.setAuthorizationProvider(sp);
NoSQLHandle handle = NoSQLHandleFactory.createNoSQLHandle(config);

//At this point, your handle is set up to perform data operations.

Connexion à l'aide d'un fichier de configuration 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 d'un fichier de configuration avec un profil autre que celui par défaut :

/* Use the SignatureProvider to supply your credentials to NoSQL Database. 
* Specify the full location of the configuration file in the construtor for SignatureProvider. 
*/
final String config_file = "<path_to_config_file>";
SignatureProvider sp = new SignatureProvider(config_file);

Connexion à l'aide d'un principal d'instance :
Le principal d'instance est une fonctionnalité de service IAM qui permet aux instances d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats qui lui sont ajoutés.
```
SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();
```
Connexion à l'aide d'un principal de ressource :
Le principal de ressource est une fonctionnalité de service IAM qui permet aux ressources d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service.
```
SignatureProvider authProvider = SignatureProvider.createWithResourcePrincipal();
```

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

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

Fournir directement des informations d'identification dans le code :

from borneo.iam import SignatureProvider
#
# Use SignatureProvider directly via API. Note that the
# private_key argument can either point to a key file or be the
# string content of the private key itself.
#
at_provider = SignatureProvider(tenant_id='ocid1.tenancy.oc1..tenancy',
                                user_id='ocid1.user.oc1..user',
                                private_key=key_file_or_key, 
                                fingerprint='fingerprint',   
                                pass_phrase='mypassphrase')

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

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

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

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

Connexion à l'aide d'un principal d'instance :
Le principal d'instance est une fonctionnalité de service IAM qui permet aux instances d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats qui lui sont ajoutés.
```
at_provider =
SignatureProvider.create_with_instance_principal(region=my_region)
```
Connexion à l'aide d'un principal de ressource :
Le principal de ressource est une fonctionnalité de service IAM qui permet aux ressources d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service.
```
at_provider = SignatureProvider.create_with_resource_principal()
```

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

Fournir directement des informations d'identification dans le code :

privateKeyFile := "/path/to/privateKeyFile"
passphrase := "examplepassphrase"
sp, err := iam.NewRawSignatureProvider("ocid1.tenancy.oc1..tenancy",
                                       "ocid1.user.oc1..user",
                                       "<your-service-region>", 
                                       "fingerprint", 
                                       "compartmentID", 
                                       privateKeyFile ,
                                       &passphrase )
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    // This is only required if the "region" property is not 
    //specified in the config file.
    Region: "<your-service-region>",
}

Connexion à l'aide d'un fichier de configuration 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 d'un fichier de configuration avec un profil autre que celui par défaut :

sp, err := iam.NewSignatureProviderFromFile("your_config_file_path", 
           "your_profile_name", "", "compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    // This is only required if the "region" property is not specified in the config file.
    Region: "us-ashburn-1",
}
client, err := nosqldb.NewClient(cfg)

Connexion à l'aide d'un principal d'instance :
Le principal d'instance est une fonctionnalité de service IAM qui permet aux instances d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et est authentifiée à l'aide des certificats qui lui sont ajoutés.
```
sp, err := iam.NewSignatureProviderWithInstancePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)
```
Connexion à l'aide d'un principal de ressource :
Le principal de ressource est une fonctionnalité de service IAM qui permet aux ressources d'être des acteurs autorisés (ou des principaux) afin d'effectuer des actions sur les ressources de service.
```
sp, err := iam.NewSignatureProviderWithResourcePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)
```

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

Fournir directement des informations d'identification dans le code :

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

import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({
    region: <your-service-region>
    auth: {
        iam: {
            tenantId: myTenancyOCID,
            userId: myUserOCID,
            fingerprint: myPublicKeyFingerprint,
            privateKeyFile: myPrivateKeyFile,
            passphrase: myPrivateKeyPassphrase
        }
    }
});

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

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

Vous pouvez choisir d'utiliser un chemin différent pour le fichier de configuration OCI ainsi qu'un profil différent dans le fichier de configuration. Dans ce cas, spécifiez-les dans la propriété auth.iam de la configuration initiale. Par exemple, si le chemin du fichier de configuration OCI est ~/myapp/.oci/config et que vous stockez vos informations d'identification sous le profil Jane :
Créez ensuite l'instance NoSQLClient comme suit :
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({
    region: Region.<your-service-region>,
    auth: {
        iam: {
            configFile: '<your_config_file>',
            profileName: '<name_of_your_profile>'
        }
    }
});
```
Connexion à l'aide d'un principal d'instance :

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

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

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

Fournir directement des informations d'identification dans le code :

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

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

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

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

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

Workflow standard

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

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

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

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

Didacticiels de démarrage rapide

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

Obtenez l'accès au service.

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