Pour commencer avec Oracle NoSQL Database Cloud Service

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

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

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

Cet article contient les rubriques suivantes :

Rubriques connexes

Liens rapides

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

Table - Liens rapides

     

Introduction

Connecter

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

Create Tables

Placer et explorer des données

Gérer les tables

Gérer la sécurité

Surveiller le service

Utilitaires

Référence SQL

Guide de référence

Configuration du service

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

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

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

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

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

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

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

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

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

Accès au service à partir de la console Infrastructure

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

  1. Localisez l'URL du service dans le courriel de bienvenue, puis connectez-vous à votre service Oracle NoSQL Database Cloud Service.
  2. Ouvrez le menu de navigation, cliquez sur Bases de données, puis sur NoSQL Base de données.
  3. Sélectionnez le compartiment créé pour vos tables par l'administrateur du service.
Pour afficher l'aide correspondant à la page courante, cliquez sur Tiroir d'aide en haut de la page.

Création d'un compartiment

Lorsque vous vous inscrivez à Oracle Cloud Infrastructure, Oracle crée votre location avec un compartiment racine qui contient toutes vos ressources en nuage. Vous créez ensuite des compartiments supplémentaires au sein de la location (compartiment racine), ainsi que des politiques pour contrôler l'accès aux ressources dans chaque compartiment. Avant de créer une table Oracle NoSQL Database Cloud Service, Oracle recommande de configurer le compartiment auquel la table doit appartenir.

Vous créez des compartiments dans le service Oracle Cloud Infrastructure Identity and Access Management (IAM). Voir Configuration de votre location et Gestion des compartiments dans la documentation Oracle Cloud Infrastructure.

Authentification pour la connexion à Oracle NoSQL Database

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

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

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

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

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

Informations comprises dans les données d'identification :

Table - Données d'identification

C'est quoi? Emplacement
ID location et ID utilisateur (les deux sont OCID) Voir Où obtenir l'OCID de la location et l'OCID de l'utilisateur dans la documentation sur Oracle Cloud Infrastructure.
Clé de signature d'API

Pour l'utilisateur de l'application, une clé de signature d'API doit être générée et chargée. Si cela a déjà été fait, cette étape peut être ignorée.

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

Conseil :

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

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

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

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

Si vous utilisez un fichier de configuration, l'emplacement par défaut est ~/.oci/config. Les trousses SDK autorisent que ce fichier réside dans d'autres emplacements. Son contenu se présente comme suit :
[DEFAULT]
user=ocid1.user.oc1..aaaaaaaas...7ap
fingerprint=d1:b2:32:53:d3:5f:cf:68:2d:6f:8b:5f:77:8f:07:13
key_file=~/.oci/oci_api_key_private.pem
tenancy=ocid1.tenancy.oc1..aaaaaaaap...keq
pass_phrase=mysecretphrase
La ligne [DEFAULT] indique que les lignes suivantes spécifient le profil Par défaut. Un fichier de configuration peut comprendre plusieurs profils, précédés de [PROFILE_NAME]. Par exemple :
[DEFAULT]
user=ocid1.user.oc1..aaaaaaaas...7us
fingerprint=d1:b2:32:53:d3:5f:cf:68:2d:6f:8b:5f:77:8f:07:15
key_file=~/.oci/oci_api_key_private.pem
tenancy=ocid1.tenancy.oc1..aaaaabbap...keq
pass_phrase=mysecretphrase

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

Méthode d'authentification #2 : Principaux d'instance

Instance Principals est une fonction du service Oracle Cloud Infrastructure Identity and Access Management (IAM) qui vous permet d'effectuer des appels de service à partir d'une instance. Avec les principaux d'instance, vous n'avez pas besoin de configurer les données d'identification d'utilisateur pour les services exécutés sur vos instances de calcul ni de faire pivoter les données d'identification. Les instances elles-mêmes sont maintenant un type de principal dans le service IAM. Chaque instance de calcul possède sa propre identité et s'authentifie à l'aide des certificats ajoutés à l'instance. Ces certificats sont automatiquement créés, affectés aux instances et soumis à une rotation.

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

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

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

Un principal de ressource permet aux ressources d'être autorisées à effectuer des actions sur les services Oracle Cloud Infrastructure. Chaque ressource possède sa propre identité et s'authentification à l'aide des certificats qui y sont ajoutés. Ces certificats sont créés, affectés aux ressources et soumis à une rotation, ce qui vous évite d'avoir à créer et à gérer vos propres données d'identification pour accéder à la ressource. Lorsque vous effectuez l'authentification à l'aide d'un principal de ressource, il n'est pas nécessaire de créer et de gérer des données d'identification pour accéder aux ressources Oracle Cloud Infrastructure.

Une fois authentifié, vous devez être autorisé à accéder aux ressources Oracle Cloud Infrastructure. Pour plus de détails, voir Configuration d'utilisateurs, de groupes et de politiques à l'aide de la gestion des identités et des accès.

Connexion de votre application à NDCS

Voyez comment connecter votre application à Oracle NoSQL Database Cloud Service.

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

Vous pouvez vous authentifier en utilisant l'une des méthodes suivantes :
  • Clé de signature d'API
    • À partir de n'importe quel programme SDK (Java, Python, C#, GO, Node.js) codé en dur directement
    • Un fichier de configuration avec un profil par défaut
    • Un fichier de configuration avec un profil non par défaut
  • Principaux d'instance avec jetons d'authentification
  • Principaux de ressources

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

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

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

//At this point, your handle is set up to perform data operations.
  • Connexion à l'aide 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 non défini 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 fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentification à l'aide des certificats ajoutés à celle-ci. 
    SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();

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

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

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

Vous pouvez vous connecter à NDCS à l'aide d'une des méthodes suivantes :
  • Fournir directement les informations d'identification dans le code :
    from borneo.iam import SignatureProvider
#
# Use SignatureProvider directly via API. Note that the
# private_key argument can either point to a key file or be the
# string content of the private key itself.
#
at_provider = SignatureProvider(tenant_id='ocid1.tenancy.oc1..tenancy',
                                user_id='ocid1.user.oc1..user',
                                private_key=key_file_or_key, 
                                fingerprint='fingerprint',   
                                pass_phrase='mypassphrase')
  • Connexion à l'aide 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 non défini par défaut :
    from borneo.iam import SignatureProvider
#
# Use SignatureProvider with a non-default credentials file and profile
#
at_provider = SignatureProvider(config_file='myconfigfile', 
                                profile_name='myprofile')

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

    Le principal d'instance est une fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentification à l'aide des certificats ajoutés à celle-ci. 
    at_provider =
SignatureProvider.create_with_instance_principal(region=my_region)

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

    Le principal de ressource est une fonction de service IAM qui permet aux ressources de être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service.
    at_provider = SignatureProvider.create_with_resource_principal()
Vous pouvez connecter votre application à NDCS à l'aide de l'une des méthodes suivantes :
  • Fournir directement les informations d'identification dans le code :
    privateKeyFile := "/path/to/privateKeyFile"
passphrase := "examplepassphrase"
sp, err := iam.NewRawSignatureProvider("ocid1.tenancy.oc1..tenancy",
                                       "ocid1.user.oc1..user",
                                       "<your-service-region>", 
                                       "fingerprint", 
                                       "compartmentID", 
                                       privateKeyFile ,
                                       &passphrase )
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    // This is only required if the "region" property is not 
    //specified in the config file.
    Region: "<your-service-region>",
}
  • Connexion à l'aide 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 non défini par défaut :
    sp, err := iam.NewSignatureProviderFromFile("your_config_file_path", 
           "your_profile_name", "", "compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    // This is only required if the "region" property is not specified in the config file.
    Region: "us-ashburn-1",
}
client, err := nosqldb.NewClient(cfg)

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

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

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

    Le principal de ressource est une fonction de service IAM qui permet aux ressources de être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service.
    sp, err := iam.NewSignatureProviderWithResourcePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)
Vous pouvez vous connecter à NDCS à l'aide d'une des méthodes suivantes :

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

    Vous pouvez spécifier des données d'identification directement dans le cadre de la propriété auth.iam dans la configuration initiale. Créez l'instance NoSQLClient comme suit :
    import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({
    region: <your-service-region>
    auth: {
        iam: {
            tenantId: myTenancyOCID,
            userId: myUserOCID,
            fingerprint: myPublicKeyFingerprint,
            privateKeyFile: myPrivateKeyFile,
            passphrase: myPrivateKeyPassphrase
        }
    }
});

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

    Vous pouvez stocker les données d'identification dans un fichier de configuration Oracle Cloud Infrastructure. Le chemin par défaut du fichier de configuration est ~/.oci/config, où ~ représente le répertoire de base de l'utilisateur. Sous Windows, ~ est une valeur de variable d'environnement USERPROFILE. Le fichier peut contenir plusieurs profils. Par défaut, la trousse SDK utilise le profil DEFAULT pour stocker les données d'identification.

    Pour utiliser ces valeurs par défaut, créez un fichier nommé config dans le répertoire ~/.oci avec le contenu suivant :
    [DEFAULT]
tenancy=<your-tenancy-ocid>
user=<your-user-ocid>
fingerprint=<fingerprint-of-your-public-key>
key_file=<path-to-your-private-key-file>
pass_phrase=<your-private-key-passphrase>
region=<your-region-identifier>
    Notez que vous pouvez également spécifier l'identificateur de votre région avec les données d'identification dans le fichier de configuration OCI. Le pilote examinera l'emplacement ci-dessus par défaut, et si une région est fournie avec des données d'identification, vous n'avez pas besoin de fournir la configuration initiale et vous pouvez utiliser le constructeur sans argument :
    import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient();
    Vous pouvez également choisir de spécifier la région dans la configuration :
    import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({ region: Region.<your-service-region> });

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

    Vous pouvez choisir d'utiliser un chemin différent pour le fichier de configuration OCI ainsi qu'un profil différent dans le fichier de configuration. Dans ce cas, spécifiez-les dans la propriété auth.iam de la configuration initiale. Par exemple, si le chemin d'accès au fichier de configuration OCI est ~/myapp/.oci/config et que vous stockez vos données d'identification sous le profil Jane :

    Créez ensuite l'instance NoSQLClient comme suit :
    import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({
    region: Region.<your-service-region>,
    auth: {
        iam: {
            configFile: '<your_config_file>',
            profileName: '<name_of_your_profile>'
        }
    }
});

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

    Le principal d'instance est une fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentification à l'aide des certificats ajoutés à celle-ci.

    Une fois configurée, créez l'instance NoSQLClient comme suit :
    import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............'
    auth: {
        iam: {
            useInstancePrincipal: true
        }
    }
});
    Vous pouvez également utiliser un fichier de configuration JSON avec la même configuration que celle décrite ci-dessus. Notez que lorsque vous utilisez le principal d'instance, vous devez spécifier l'ID compartiment (OCID) comme propriété de compartiment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Notez que vous devez utiliser l'ID compartiment et non le nom ou le chemin du compartiment. En outre, lors de l'utilisation du principal d'instance, vous ne pouvez pas ajouter de préfixe au nom de la table avec le nom ou le chemin du compartiment lors de l'appel des API NoSQLClient.

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

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

    Une fois configurée, créez l'instance NoSQLClient comme suit :
    import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    auth: {
        iam: {
            useResourcePrincipal: true
        }
    }
});
    Vous pouvez également utiliser un fichier de configuration JSON avec la même configuration que celle décrite ci-dessus. Notez que lorsque vous utilisez un principal de ressource, vous devez spécifier l'ID compartiment (OCID) comme propriété de compartiment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Notez que vous devez utiliser l'ID compartiment et non le nom ou le chemin du compartiment. En outre, lors de l'utilisation du principal de ressource, vous ne pouvez pas ajouter de préfixe au nom de la table avec le nom ou le chemin du compartiment lors de l'appel des API NoSQLClient.
Vous pouvez vous connecter à NDCS à l'aide d'une des méthodes suivantes :

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

    Vous pouvez spécifier des données d'identification directement en tant que IAMCredentials lors de la création de IAMAuthorizationProvider. Créez NoSQLClient comme suit :
    var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            new IAMCredentials
            {
                TenantId=myTenancyOCID,
                UserId=myUserOCID,
                Fingerprint=myPublicKeyFingerprint,
                PrivateKeyFile=myPrivateKeyFile
            })
    });

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

    Vous pouvez stocker les données d'identification dans un fichier de configuration Oracle Cloud Infrastructure. Le chemin par défaut du fichier de configuration est ~/.oci/config, où ~ représente le répertoire de base de l'utilisateur. Sous Windows, ~ est une valeur de variable d'environnement USERPROFILE. Le fichier peut contenir plusieurs profils. Par défaut, la trousse SDK utilise le profil DEFAULT pour stocker les données d'identification

    Pour utiliser ces valeurs par défaut, créez le fichier nommé config dans le répertoire ~/.oci avec le contenu suivant :
    [DEFAULT]
tenancy=<your-tenancy-ocid>
user=<your-user-ocid>
fingerprint=<fingerprint-of-your-public-key>
key_file=<path-to-your-private-key-file>
pass_phrase=<your-private-key-passphrase>
region=<your-region-identifier>
    Notez que vous pouvez également spécifier l'identificateur de votre région avec les données d'identification dans le fichier de configuration OCI. Par défaut, le pilote recherche les données d'identification et une région dans le fichier de configuration OCI dans le chemin par défaut et dans le profil par défaut. Ainsi, si vous fournissez la région avec les données d'identification comme indiqué ci-dessus, vous pouvez créer une instance NoSQLClient sans transmettre de configuration :
    var client = new NoSQLClient();
    Vous pouvez également spécifier la région (ainsi que d'autres propriétés) dans NoSQLConfig :
    var client = new NoSQLClient(
    new NoSQLConfig(
    {
        Region = Region.<your-service-region>,
        Timeout = TimeSpan.FromSeconds(10),
    });

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

    Vous pouvez choisir d'utiliser un chemin différent pour le fichier de configuration OCI ainsi qu'un profil différent dans le fichier de configuration. Dans ce cas, spécifiez-les dans la propriété auth.iam de la configuration initiale. Par exemple, si le chemin d'accès au fichier de configuration OCI est ~/myapp/.oci/config et que vous stockez vos données d'identification sous le profil Jane :

    Créez ensuite l'instance NoSQLClient comme suit :
    var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = Region.<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            "<your_config_file>", "<your_profile_name>")
    });

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

    Le principal d'instance est une fonction de service IAM qui permet aux instances d'être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Chaque instance de calcul possède sa propre identité et s'authentification à l'aide des certificats ajoutés à celle-ci. Une fois configurée, créez l'instance NoSQLClient comme suit :
    var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        Compartment="ocid1.compartment.oc1.............................",
        AuthorizationProvider=IAMAuthorizationProvider.CreateWithInstancePrincipal()
    });
    Vous pouvez également représenter la même configuration dans JSON comme suit :
    {
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseInstancePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}

    Notez que lorsque vous utilisez le principal d'instance, vous devez spécifier l'ID compartiment (OCID) en tant que propriété de compartiment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Notez que vous devez utiliser l'ID compartiment et non le nom ou le chemin du compartiment. En outre, lors de l'utilisation du principal d'instance, vous ne pouvez pas ajouter de préfixe au nom de la table avec le nom ou le chemin du compartiment lors de l'appel des API NoSQLClient.

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

    Le principal de ressource est une fonction de service IAM qui permet aux ressources de être des acteurs (ou principaux) autorisés à effectuer des actions sur les ressources de service. Une fois configurée, créez l'instance NoSQLClient comme suit :
    var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = <your-service-region>,
        Compartment =
            "ocid1.compartment.oc1.............................",
        AuthorizationProvider =
            IAMAuthorizationProvider.CreateWithResourcePrincipal()
    });
    Vous pouvez également représenter la même configuration dans JSON comme suit :
    {
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseResourcePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}

    Notez que lors de l'utilisation du principal de ressource, vous devez spécifier l'ID compartiment (OCID) en tant que propriété de compartiment. Cette opération est requise même si vous souhaitez utiliser le compartiment par défaut. Notez que vous devez utiliser l'ID compartiment et non le nom ou le chemin du compartiment. En outre, lors de l'utilisation du principal de ressource, vous ne pouvez pas ajouter de préfixe au nom de la table avec le nom ou le chemin du compartiment lors de l'appel des API NoSQLClient.

Flux de travail type

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

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

Tâche Description Informations supplémentaires
Connecter votre application Connectez votre application pour utiliser des tables Oracle NoSQL Database Cloud Service. Connexion de votre application à NDCS
Développer votre application Développez votre application après vous être connecté aux tables Oracle NoSQL Database Cloud Service. Développement dans Oracle Cloud

Développement dans le simulateur Oracle NoSQL Database Cloud

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

Didacticiels pour démarrage rapide

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

  1. Accédez au service.

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

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

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