Conceitos Básicos do Oracle NoSQL Database Cloud Service

O Oracle NoSQL Database Cloud Service é um serviço de banco de dados em nuvem totalmente gerenciado, projetado para operações de banco de dados que exigem respostas previsíveis, com uma única latência de milissegundos para consultas simples.

O NoSQL Database Cloud Service permite que os desenvolvedores se concentrem no desenvolvimento de aplicativos, em vez de configurar os servidores do cluster ou executar o monitoramento, ajuste, diagnóstico e dimensionamento do sistema. O NoSQL Database Cloud Service é adequado para aplicativos como Internet of Things, personalização da experiência do usuário, detecção instantânea de fraudes e publicidade on-line.

Após a autenticação na sua conta do Oracle Cloud, você poderá criar uma tabela NoSQL e especificar requisitos de throughput e armazenamento para a tabela. O Oracle reserva e gerencia os recursos para atender aos seus requisitos e provisiona a capacidade para você. A capacidade é especificada com unidades de leitura e gravação por throughput e GB para unidades de armazenamento.

Este artigo tem os seguintes tópicos:

Tópicos Relacionados

Links rápidos

Você pode começar a usar o Oracle NoSQL Database Service em um dos links rápidos abaixo:

Tabela - Links Rápidos

     

Comece a Trabalhar

Conectar

IDE e SDKs

Create Tables

Colocar e Explorar Dados

Manage Tables

Gerenciar Segurança

Monitorar o Serviço

Utilitários

Referência SQL

Guias de referência

Configurando o Seu Serviço

Se você estiver configurando o Oracle NoSQL Database Cloud Service pela primeira vez, siga essas tarefas para guiá-lo.

Tarefa Reference Informações Relacionadas
Faça um pedido do Oracle NoSQL Database Cloud Service ou registre-se na Avaliação Grátis do Oracle. Inscrevendo-se no Oracle Cloud Infrastructure na Documentação do Oracle Cloud Infrastructure.

Para saber como estimar o custo mensal da sua assinatura do Oracle NoSQL Database Cloud Service, consulte Estimando o Seu Custo Mensal.

Para atualizar sua conta grátis ou alterar seu método de pagamento, consulte Alterando seu Método de Pagamento na Documentação do Oracle Cloud Infrastructure.

Ativar sua conta do Oracle Cloud e acessar pela primeira vez. Entrando na Console na Documentação do Oracle Cloud Infrastructure.

Para se familiarizar com a Console de Infraestrutura do Oracle Cloud, consulte Usando a Console na Documentação do Oracle Cloud Infrastructure.

(Recomendado) Crie um compartimento para o seu serviço. Criando um Compartimento

Se você não estiver familiarizado com compartimentos, consulte Understanding Compartments na Documentação do Oracle Cloud Infrastructure.

Gerencie a segurança do seu serviço. Sobre o Modelo de Segurança do Oracle NoSQL Database Cloud Service Para se familiarizar com o modelo de segurança do NoSQL Database Cloud Service, consulte Sobre o Modelo de Segurança do Oracle NoSQL Database Cloud Service.

Acessando o Serviço na Console de Infraestrutura

Saiba como acessar o serviço Oracle NoSQL Database Cloud Service na Console de Infraestrutura.

  1. Localize o URL do serviço no e-mail de boas-vindas. Em seguida, acesse o Oracle NoSQL Database Cloud Service.
  2. Abra o menu de navegação, clique em Bancos de Dados e, em seguida, clique em NoSQL Banco de Dados.
  3. Selecione o compartimento criado para as suas tabelas pelo administrador do serviço.
Para exibir a ajuda da página atual, clique no ícone de ajuda Ícone Gaveta de Ajuda, localizado na parte superior da página.

Criando um Compartimento

Quando você se inscreve no Oracle Cloud Infrastructure, a Oracle cria sua tenancy com um compartimento raiz que contém todos os seus recursos de nuvem. Em seguida, você cria compartimentos adicionais na tenancy (compartimento-raiz) e políticas correspondentes para controlar o acesso aos recursos em cada compartimento. Antes de criar uma tabela do Oracle NoSQL Database Cloud Service, a Oracle recomenda configurar o compartimento ao qual a tabela deverá pertencer.

Você cria compartimentos no Oracle Cloud Infrastructure Identity and Access Management (IAM). Consulte Configurando sua Tenancy e Gerenciando Compartimentos na Documentação do Oracle Cloud Infrastructure.

Autenticação para estabelecer conexão com o Oracle NoSQL Database

Você precisa de uma conta do Oracle Cloud para conectar o seu aplicativo com o Oracle NoSQL Database Cloud Service.

Se você ainda não tiver uma conta do Oracle Cloud, poderá começar pelo Oracle Cloud. Você precisa se autenticar ao estabelecer conexão com o Oracle NoSQL Database. Você pode ser autenticado usando uma das seguintes maneiras:

Método de autenticação no 1: Controlador de usuários

Aqui você usa um usuário do OCI e uma chave de API para autenticação. As credenciais usadas para conectar o seu aplicativo são associadas a um usuário específico. Se quiser criar um usuário para o seu aplicativo, consulte Configurando Usuários, Grupos e Políticas Usando o Identity and Access Management.

Você pode fornecer suas credenciais para este método de autenticação usando uma das seguintes maneiras:
  • Usando um arquivo em um disco local, o arquivo contém detalhes como OCID do usuário, OCID da tenancy, região, caminho da chave privada e impressão digital. Você pode usar isso se estiver trabalhando em uma rede segura e o armazenamento de chaves privadas e configurações localmente estiver em conformidade com suas políticas de segurança.
  • Fornecer as credenciais por meio de uma API.
  • Armazenando as credenciais em um vault em algum lugar.

Informações sobre as Credenciais:

Tabela - Credenciais

O que é? Onde encontro?
ID da Tenancy e ID do Usuário (ambos são OCID ) Consulte Para Obter o OCID da Tenancy e o OCID do Usuário na Documentação do Oracle Cloud Infrastructure.
Chave de Assinatura de API

Para o usuário do aplicativo, uma chave de assinatura da API deve ser gerada e carregada. Se isso já tiver sido feito, esta etapa poderá ser ignorada.

Para saber mais, consulte os seguintes recursos na Documentação do Oracle Cloud Infrastructure:
Impressão Digital da Chave de Assinatura e da Frase-Senha (Opcional) da Chave de Assinatura A impressão digital e a senha da chave de assinatura são criadas durante a geração e o upload da Chave de Assinatura da API. Consulte Como Obter a Impressão Digital da Chave na Documentação do Oracle Cloud Infrastructure.

Dica:

Faça uma anotação da localização da sua chave privada, da frase-senha opcional e da impressão digital da chave pública ao gerar e fazer o upload da Chave de Assinatura da API.

Após executar as tarefas discutidas acima, colete as informações de credenciais e forneça para o seu aplicativo.

Fornecendo as Credenciais para o seu Aplicativo:

Os SDKs do Oracle NoSQL Database permitem que você forneça as credenciais para um aplicativo de várias maneiras. Os SDKs suportam um arquivo de configuração e também uma ou mais interfaces que permitem a especificação direta das informações. Consulte a documentação do driver da linguagem de programação que você está usando para obter mais informações sobre as interfaces de credenciais específicas.

Se você estiver usando um arquivo de configuração, a localização padrão será ~/.oci/config. Os SDKs permitem que o arquivo resida em locais alternativos. Seu conteúdo é semelhante a este:
[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
A linha [DEFAULT] indica que as linhas a seguir especificam o perfil DEFAULT. Um arquivo de configuração pode incluir vários perfis, prefixados com [PROFILE_NAME]. Por exemplo:
[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étodo de Autenticação no 2: Controladores de Instância

Controlador de Instâncias é um recurso do Oracle Cloud Infrastructure Identity and Access Management (IAM) que permite fazer chamadas de serviço de uma instância. Com os principais de instâncias, você não precisa configurar credenciais de usuário para os serviços em execução em suas instâncias de computação nem rotacionar as credenciais. As próprias instâncias agora são um tipo de principal no IAM. Cada instância de computação tem sua própria identidade e faz a autenticação usando certificados que são adicionados à instância. Esses certificados são criados, designados a instâncias e rotacionados automaticamente.

Usando a autenticação do controlador de instâncias, você pode autorizar uma instância a fazer chamadas de API nos serviços do Oracle Cloud Infrastructure. Após configurar os recursos e as políticas obrigatórias, um aplicativo que esteja em execução em uma instância pode chamar serviços públicos do Oracle Cloud Infrastructure, removendo a necessidade de configurar credenciais do usuário ou um arquivo de configuração. A autenticação do controlador de instâncias pode ser usada em uma instância na qual você não deseja armazenar um arquivo de configuração.

Método de Autenticação no 3: Controladores de Recursos

Você pode usar um controlador de recursos para autenticar e acessar recursos do Oracle Cloud Infrastructure. O controlador de recursos consiste em um token de sessão temporário e credenciais seguras que permitem que outros serviços do Oracle Cloud se autentiquem no Oracle NoSQL Database. A autenticação do controlador de recursos é muito semelhante à autenticação do controlador de instâncias, mas destina-se a ser usada para recursos que não são instâncias, como funções sem servidor.

Um principal de recursos permite que os recursos sejam autorizados a executar ações nos serviços do Oracle Cloud Infrastructure. Cada recurso tem sua própria identidade, e o recurso faz a autenticação usando os certificados que são adicionados a ele. Esses certificados são criados, designados aos recursos e rotacionados automaticamente, evitando a necessidade de criar e gerenciar suas próprias credenciais para acessar o recurso. Quando você faz a autenticação usando um controlador de recursos, não é necessário criar e gerenciar credenciais para acessar os recursos do Oracle Cloud Infrastructure.

Depois de autenticado, você precisa estar autorizado a acessar os recursos do Oracle Cloud Infrastructure. Consulte Configurando Usuários, Grupos e Políticas com o Serviço Identity and Access Management para obter mais detalhes.

Método de Autenticação no 4: Autenticação baseada em token:

A autenticação baseada em token permite criar e usar um token de sessão temporário para autenticar e acessar recursos do Oracle Cloud Infrastructure. Usando a autenticação baseada em token, você cria um arquivo de configuração local que contém informações como OCID do usuário, OCID da tenancy, região, caminho da chave privada e um caminho de arquivo de token de sessão temporário. Esse método usa essas informações juntamente com o token de sessão temporário, que expira em uma hora (por padrão). A autenticação baseada em token de sessão pode ser usada quando você precisa de uma autenticação rápida e temporária.

Criando um token de sessão: Você pode gerar um token de sessão com ou sem o uso de um Web browser.

Com um navegador:

Para usar a autenticação baseada em token para a CLI em um computador com um web browser:
  1. No terminal, execute o seguinte comando: 
    oci session authenticate
  2. Selecione uma região.
  3. No browser, informe as credenciais do usuário.
  4. Após a autenticação bem-sucedida, feche o navegador e siga o prompt interativo no terminal. É necessário fornecer o nome do perfil que você deseja criar no arquivo de configuração. A nova configuração de perfil é gravada no arquivo ~/.oci/config. Um exemplo do arquivo de configuração no qual o novo perfil (por exemplo, TESTE) é atualizado é mostrado abaixo. 
    [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>

Sem um navegador:

Para usar a autenticação baseada em token para a CLI sem um web browser, primeiro você deve autenticar usando a autenticação baseada em chave de API.
oci setup config
Esse comando solicita as informações necessárias para criar o arquivo de configuração e as chaves pública e privada da API. A caixa de diálogo de configuração usa essas informações para gerar um par de chaves da API e cria o arquivo de configuração. Para usar a autenticação baseada em token para a CLI sem um web browser, execute o seguinte comando:
oci session authenticate --no-browser
É necessário fornecer o nome do perfil que você deseja criar no arquivo de configuração. A nova configuração de perfil é gravada no arquivo ~/.oci/config. Um exemplo do arquivo de configuração no qual o novo perfil (por exemplo, TESTE) é atualizado é mostrado abaixo.
[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étodo de Autenticação no 5: Autenticação baseada em Identidade da Carga de Trabalho do OKE:

A Identidade de Carga de Trabalho do Oracle Container Engine for Kubernetes (OKE) fornece identidade refinada e controle de gerenciamento de acesso. Uma carga de trabalho é um aplicativo em execução no Kubernetes. Ele pode ser composto por um único componente ou vários componentes que funcionam juntos em execução dentro de um conjunto de pods. Um recurso de carga de trabalho é identificado pela combinação exclusiva de cluster, namespace e conta de serviço. Essa combinação exclusiva é chamada de identidade da carga de trabalho. A Identidade de Carga de Trabalho do OKE permite que você conceda aos pods K8s acesso orientado por política aos recursos do OCI (Oracle Cloud Infrastructure) usando o IAM (OCI Identity and Access Management).

Com a Identidade de Carga de Trabalho, você não precisa mais armazenar credenciais como segredos no cluster do Kubernetes ou confiar nos grupos dinâmicos do OCI para acesso orientado por política do nó de trabalho aos recursos do OCI e, mais especificamente, acesso às suas tabelas NoSQL. Quando os aplicativos exigem acesso aos recursos do OCI, o Workload Identity permite que você grave políticas do OCI IAM com escopo na conta de serviço do Kubernetes associada aos pods de aplicativos. Esse recurso permite que os aplicativos executados nesses pods acessem diretamente a API do OCI com base nas permissões fornecidas pelas políticas.

Para conceder a todos os pods em uma carga de trabalho acesso a qualquer recurso do OCI:
  • Crie um namespace para uma conta de serviço.
  • Crie uma conta de serviço para o aplicativo usar.
  • Defina uma política do serviço IAM para conceder ao recurso de carga de trabalho acesso a outros recursos do OCI.
  • Faça download e configure o SDK apropriado para o idioma no qual o aplicativo foi gravado.
  • Edite o aplicativo a ser especificado:
    • que as solicitações de carga de trabalho devem ser autenticadas usando o provedor de identidades de carga de trabalho do Kubernetes Engine
    • os recursos do OCI que devem ser acessados
  • Atualize a especificação de implantação do aplicativo para especificar que cada pod da carga de trabalho deve usar a conta de serviço.
Autorização para permitir que a carga de trabalho acesse os recursos necessários do OCI:
  • Na Console do OCI, Abra o menu de navegação e clique em Identidade e Segurança. Em Identidade, clique em Políticas.
  • Clique em Criar Política e dê um nome à política.
  • Digite uma instrução de política para permitir que a carga de trabalho acesse os recursos necessários do OCI, no formato mostrado abaixo:
    Allow any-user to <verb> <resource> in <location> where all
{
request.principal.type = 'workload', 
request.principal.namespace = '<namespace-name>', 
request.principal.service_account = '<service-account-name>', 
request.principal.cluster_id = '<cluster-ocid>'
}
em que:
  • <namespace-name> é o nome do namespace criado anteriormente.
  • <service-account-name> é o nome da conta de serviço criada anteriormente.
  • <cluster-OCID> é o OCID do cluster obtido anteriormente.

Clique em Criar para criar a nova política.

Conectando seu Aplicativo ao NDCS

Saiba como conectar o seu aplicativo com o Oracle NoSQL Database Cloud Service.

Seu aplicativo se conecta ao Oracle NoSQL Database Cloud Service depois de ser autenticado usando um dos muitos métodos disponíveis.

Você pode ser autenticado usando um dos seguintes:
  • chave de assinatura de API
    • De qualquer programa SDK (Java, Python, C#, GO, Node.js, Rust) codificado diretamente
    • Um arquivo de configuração com um perfil padrão
    • Um arquivo de configuração com um perfil não padrão
  • Controlador de Instâncias com tokens de Autenticação
  • Controlador de Recursos
  • token de sessão
  • Identidade da Carga de Trabalho do OKE

Consulte Autenticação para estabelecer conexão com o Oracle NoSQL Database para obter mais detalhes sobre as opções de autenticação.

Você pode se conectar ao NDCS usando um dos seguintes métodos:

  • Fornecimento direto de credenciais no código:
    /* 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.
  • Estabelecendo conexão usando o arquivo de configuração padrão com um perfil padrão:
    /* 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();
  • Estabelecendo conexão usando o arquivo de configuração padrão com o perfil não padrão:
    /* Use the SignatureProvider to supply your credentials to NoSQL Database. 
* Specify the name of the non-default profile in the construtor for SignatureProvider. 
*/
final String profile_name = "<name_of_the_profile>";
SignatureProvider sp = new SignatureProvider(profile_name);
  • Estabelecendo conexão usando o perfil e o arquivo de configuração especificados:
    /* 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);

  • Estabelecendo Conexão com um Controlador de Instâncias:

    Controlador de Instâncias é um recurso do serviço IAM que permite que instâncias sejam atores autorizados (ou principais) para executar ações em recursos do serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são adicionados a ela. 
    SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();

  • Estabelecendo Conexão usando um Controlador de Recursos:

    O Controlador de Recursos é um recurso do serviço IAM que permite que os recursos sejam atores autorizados (ou principais) para executar ações nos recursos do serviço.
    SignatureProvider authProvider = SignatureProvider.createWithResourcePrincipal();

  • Conectando usando o token de sessão:

    Você usa o método createWithSessionToken() para criar um SignatureProvider usando um token de sessão temporário lido de um arquivo de token. O caminho do arquivo de token é lido no perfil padrão no arquivo de configuração no local padrão. O arquivo de configuração usado é ~/.oci/config.
    SignatureProvider authProvider = 
SignatureProvider.createWithSessionToken();
    Você também pode fornecer o caminho do arquivo de token no perfil não padrão no arquivo de configuração, conforme mostrado abaixo. O caminho do arquivo de token é lido no perfil especificado no arquivo de configuração no local padrão.
    SignatureProvider authProvider = 
SignatureProvider.createWithSessionToken(<profile_name>);

  • Estabelecendo conexão usando a Identidade de Carga de Trabalho do OKE:

    Você pode criar um SignatureProvider com a identidade da carga de trabalho do Container Engine for Kubernetes (OKE) usando o token da conta de serviço do Kubernetes no caminho padrão /var/run/secrets/kubernetes.io/serviceaccount/token. Esse provedor só pode ser usado dentro de pods do Kubernetes.
    SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity();
    Você também pode especificar o token específico da conta de serviço do Kubernetes a ser usado, conforme mostrado abaixo.
    SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken>);
    Como alternativa, você também pode especificar o local do token da conta de serviço do Kubernetes específico a ser usado, conforme mostrado abaixo.
    SignatureProvider authProvider = 
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken_location>);

Consulte SignatureProvider para obter mais detalhes sobre as classes Java usadas.

Você pode se conectar ao NDCS usando um dos seguintes métodos:
  • Fornecimento direto de credenciais no código:
    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')
  • Estabelecendo conexão usando o arquivo de configuração padrão com um perfil padrão:
    from borneo.iam import SignatureProvider
#
# Use SignatureProvider with a default credentials file and
# profile in $HOME/.oci/config
#
at_provider = SignatureProvider()
  • Estabelecendo conexão usando o arquivo de configuração especificado com o perfil não padrão:
    from borneo.iam import SignatureProvider
#
# Use SignatureProvider with a non-default credentials file and profile
#
at_provider = SignatureProvider(config_file='myconfigfile', 
                                profile_name='myprofile')

  • Conexão usando um Controlador de Instâncias:

    Controlador de Instâncias é um recurso do serviço IAM que permite que instâncias sejam atores autorizados (ou principais) para executar ações em recursos do serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são adicionados a ela. 
    at_provider =
SignatureProvider.create_with_instance_principal(region=my_region)

  • Estabelecendo Conexão usando um Controlador de Recursos:

    O Controlador de Recursos é um recurso do serviço IAM que permite que os recursos sejam atores autorizados (ou principais) para executar ações nos recursos do serviço.
    at_provider = SignatureProvider.create_with_resource_principal()

  • Conectando usando o token de sessão:

    O Bornéu usa o OCI SDK para autenticação usando tokens de Sessão. O signatário do OCI é passado como um parâmetro para o construtor SignatureProvider, conforme mostrado abaixo.
    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>)

  • Estabelecendo conexão usando a Identidade de Carga de Trabalho do OKE:

    O OKE Workload Auth Signer é um signatário que concede a uma carga de trabalho inteira (um aplicativo em execução em clusters do Kubernetes) acesso às tabelas NoSQL usando a Identidade de Carga de Trabalho do OKE. Ele pode ser recuperado por oci.auth.signers.get_oke_workload_identity_resource_principal_signer. O assinante recuperado pode então ser usado ao inicializar um cliente.
    from borneo.iam import SignatureProvider
oke_workload_signer = oci.auth.signers.get_oke_workload_identity_resource_principal_signer()
    Se você tiver um caminho de token da conta de serviço do Kubernetes diferente do caminho padrão, poderá especificar o caminho conforme mostrado abaixo:
    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)
    Você também pode passar diretamente o token da conta de serviço do Kubernetes, conforme mostrado abaixo:
    #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)
Você pode conectar seu aplicativo ao NDCS usando qualquer um dos seguintes métodos:
  • Fornecimento direto de credenciais no código:
    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>",
}
  • Estabelecendo conexão usando o arquivo de configuração padrão com um perfil padrão: 
    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)
  • Estabelecendo conexão usando o arquivo de configuração especificado com o perfil não padrão:
    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)

  • Conexão usando um Controlador de Instâncias:

    Controlador de Instâncias é um recurso do serviço IAM que permite que instâncias sejam atores autorizados (ou principais) para executar ações em recursos do serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são adicionados a ela. 
    sp, err := iam.NewSignatureProviderWithInstancePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)

  • Estabelecendo Conexão usando um Controlador de Recursos:

    O Controlador de Recursos é um recurso do serviço IAM que permite que os recursos sejam atores autorizados (ou principais) para executar ações nos recursos do serviço.
    sp, err := iam.NewSignatureProviderWithResourcePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)

  • Conectando usando o token de sessão:

    A função NewSessionTokenSignatureProvider cria um SignatureProvider usando um token de sessão temporário lido de um arquivo de token. 
    func NewSessionTokenSignatureProvider() (*SignatureProvider, error)

    O arquivo de configuração usado é ~/.oci/config. O perfil DEFAULT é usado. O caminho do arquivo de token é lido na configuração, usando o valor do campo security_token_file. Ao usar esse construtor, o usuário tem um compartimento padrão para todas as tabelas. É o compartimento raiz da tenancy do usuário.

    Para usar um arquivo de configuração não padrão (diferente de ~/.oci/config), você pode usar a função NewSessionTokenSignatureProviderFromFile.
    func NewSessionTokenSignatureProviderFromFile(configFilePath, 
ociProfile, privateKeyPassphrase string) (*SignatureProvider, error)

    Essa função cria um SignatureProvider usando um token de sessão temporário lido de um arquivo de token, usando o ociProfile especificado no arquivo de configuração do OCI configFilePath. O caminho do arquivo de token é lido na configuração, usando o valor do campo security_token_file. O campo privateKeyPassphrase só será obrigatório se a chave privada usar uma frase-senha e ele não for especificado no campo pass_phrase no arquivo de configuração do OCI. Ao usar esse construtor, o usuário tem um compartimento padrão para todas as tabelas. É o compartimento raiz da tenancy do usuário.

  • Estabelecendo conexão usando a Identidade de Carga de Trabalho do OKE:

    O Oracle NoSQL go SDK suporta a execução de programas dentro de contêineres de Carga de Trabalho do OKE no OCI. No seu código que cria um SignatureProvider a ser usado com NoSQL, adicione o seguinte código para usar a identidade da Carga de Trabalho do OKE:
    conf, err := ociauth.OkeWorkloadIdentityConfigurationProvider()
if err != nil {
   return nil, fmt.Errorf("cannot create an Oke Provider: %v", err)
}
myconf := &myConfigProvider{conf}
sp, err := iam.NewSignatureProviderWithConfiguration(myconf, compartmentID)
if err != nil {
  return nil, fmt.Errorf("cannot create a Signature Provider: %v", err)
}
Você pode se conectar ao NDCS usando um dos seguintes métodos:

  • Fornecimento direto de credenciais no código:

    Você pode especificar credenciais diretamente como parte da propriedade auth.iam na configuração inicial. Crie a instância NoSQLClient da seguinte forma:
    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
        }
    }
});

  • Estabelecendo conexão usando o arquivo de configuração padrão com um perfil padrão:

    Você pode armazenar as credenciais em um arquivo de configuração do Oracle Cloud Infrastructure. O caminho padrão do arquivo de configuração é ~/.oci/config, em que ~ significa o diretório home do usuário. No Windows, ~ é um valor da variável de ambiente USERPROFILE. O arquivo pode conter vários perfis. Por padrão, o SDK usa o perfil DEFAULT para armazenar as credenciais.

    Para usar esses valores padrão, crie o arquivo nomeado config no diretório ~/.oci com o seguinte conteúdo:
    [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>
    Observe que você também pode especificar seu identificador de região juntamente com credenciais no arquivo de configuração do OCI. O driver examinará o local acima por padrão e, se uma região for fornecida juntamente com credenciais, você não precisará fornecer a configuração inicial e poderá usar o construtor sem argumento:
    import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient();
    Como alternativa, você pode optar por especificar a região na configuração:
    import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({ region: Region.<your-service-region> });

  • Estabelecendo conexão usando o arquivo de configuração especificado com o perfil não padrão:

    Você pode optar por usar um caminho diferente para o arquivo de configuração do OCI, bem como um perfil diferente dentro do arquivo de configuração. Nesse caso, especifique-os na propriedade auth.iam da configuração inicial. Por exemplo, se o caminho do arquivo de configuração do OCI for ~/myapp/.oci/config e você armazenar suas credenciais no perfil Jane:

    Em seguida, crie a instância NoSQLClient da seguinte forma:
    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>'
        }
    }
});

  • Conexão usando um Controlador de Instâncias:

    Controlador de Instâncias é um recurso do serviço IAM que permite que instâncias sejam atores autorizados (ou principais) para executar ações em recursos do serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são adicionados a ela.

    Depois de configurada, crie a instância NoSQLClient da seguinte forma:
    import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............'
    auth: {
        iam: {
            useInstancePrincipal: true
        }
    }
});
    Você também pode usar o arquivo de configuração JSON com a mesma configuração descrita acima. Observe que ao usar o Controlador de Instâncias, você deve especificar o id do compartimento (OCID) como propriedade do compartimento. Isso é necessário mesmo que você queira usar o compartimento padrão. Observe que você deve usar o id do compartimento e não o nome ou o caminho do compartimento. Além disso, ao usar o Controlador de Instâncias, você não pode prefixar o nome da tabela com o nome ou o caminho do compartimento ao chamar APIs NoSQLClient.

  • Estabelecendo Conexão usando um Controlador de Recursos:

    O Controlador de Recursos é um recurso do serviço IAM que permite que os recursos sejam atores autorizados (ou principais) para executar ações nos recursos do serviço.

    Depois de configurada, crie a instância NoSQLClient da seguinte forma:
    import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    auth: {
        iam: {
            useResourcePrincipal: true
        }
    }
});
    Você também pode usar o arquivo de configuração JSON com a mesma configuração descrita acima. Observe que ao usar o Controlador de Recursos, você deve especificar o id do compartimento (OCID) como propriedade do compartimento. Isso é necessário mesmo que você queira usar o compartimento padrão. Observe que você deve usar o id do compartimento e não o nome ou o caminho do compartimento. Além disso, ao usar o Controlador de Recursos, você não pode prefixar o nome da tabela com o nome ou o caminho do compartimento ao chamar APIs NoSQLClient.

  • Conectando usando o token de sessão:

    Usando a autenticação baseada em token de sessão, você cria um arquivo de configuração local que contém informações como OCID do usuário, OCID da tenancy, região, caminho da chave privada e um caminho de arquivo de token de sessão temporário.
    import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............
   ' auth: {
       iam: { useSessionToken: true }  
  }
});

    Esse método usa um token de sessão temporário lido de um arquivo de token. O caminho do arquivo de token é lido no perfil padrão no arquivo de configuração do OCI como o valor do campo security_token_file.

    Para usar um arquivo de configuração não padrão (diferente de ~/.oci/config), você pode especificar o caminho do arquivo de configuração e o nome do perfil, conforme mostrado abaixo.
    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>"
    }  
  }
});

  • Estabelecendo conexão usando a Identidade de Carga de Trabalho do OKE:

    O Oracle NoSQL Node.js SDK suporta a execução de programas em contêineres de Carga de Trabalho do OKE no OCI. 
    import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    ' auth: {
        iam: { useOKEWorkloadIdentity: true }
    }'
  }
);
    Esse esquema de autorização só pode ser usado dentro da identidade de carga de trabalho do OKE pods.Using do Kubernetes requer um token de conta de serviço. Por padrão, o provedor carregará o token da conta de serviço do caminho de arquivo padrão /var/run/secrets/kubernetes.io/serviceaccount/token. Você pode substituir isso e fornecer seu token de conta de serviço especificando uma das 3 propriedades:
    • serviceAccountToken para fornecer uma string de token da conta de serviço.
    • serviceAccountTokenFile para fornecer um caminho para o arquivo de token da conta de serviço.
    • serviceAccountTokenProvider para fornecer um provedor personalizado para carregar tokens de conta de serviço.

Consulte Arquivo de Configuração do SDK para obter detalhes do conteúdo e formato do arquivo.

Você pode se conectar ao NDCS usando um dos seguintes métodos:

  • Fornecimento direto de credenciais no código:

    Você pode especificar credenciais diretamente como IAMCredentials ao criar IAMAuthorizationProvider. Crie NoSQLClient da seguinte forma:
    var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            new IAMCredentials
            {
                TenantId=myTenancyOCID,
                UserId=myUserOCID,
                Fingerprint=myPublicKeyFingerprint,
                PrivateKeyFile=myPrivateKeyFile
            })
    });

  • Estabelecendo conexão usando o arquivo de configuração padrão com um perfil padrão:

    Você pode armazenar as credenciais em um arquivo de configuração do Oracle Cloud Infrastructure. O caminho padrão do arquivo de configuração é ~/.oci/config, em que ~ significa o diretório home do usuário. No Windows, ~ é um valor da variável de ambiente USERPROFILE. O arquivo pode conter vários perfis. Por padrão, o SDK usa o perfil DEFAULT para armazenar as credenciais

    Para usar esses valores padrão, crie o arquivo chamado config no diretório ~/.oci com o seguinte conteúdo:
    [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>
    Observe que você também pode especificar seu identificador de região juntamente com credenciais no arquivo de configuração do OCI. Por padrão, o driver procurará credenciais e uma região no arquivo de configuração do OCI no caminho padrão e no perfil padrão. Portanto, se você fornecer a região juntamente com credenciais, conforme mostrado acima, poderá criar a instância NoSQLClient sem especificar nenhuma configuração:
    var client = new NoSQLClient();
    Como alternativa, você pode especificar a região (assim como outras propriedades) em NoSQLConfig:
    var client = new NoSQLClient(
    new NoSQLConfig(
    {
        Region = Region.<your-service-region>,
        Timeout = TimeSpan.FromSeconds(10),
    });

  • Estabelecendo conexão usando o arquivo de configuração especificado com o perfil não padrão:

    Você pode optar por usar um caminho diferente para o arquivo de configuração do OCI, bem como um perfil diferente dentro do arquivo de configuração. Nesse caso, especifique-os na propriedade auth.iam da configuração inicial. Por exemplo, se o caminho do arquivo de configuração do OCI for ~/myapp/.oci/config e você armazenar suas credenciais no perfil Jane:

    Em seguida, crie a instância NoSQLClient da seguinte forma:
    var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = Region.<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            "<your_config_file>", "<your_profile_name>")
    });

  • Conexão usando um Controlador de Instâncias:

    Controlador de Instâncias é um recurso do serviço IAM que permite que instâncias sejam atores autorizados (ou principais) para executar ações em recursos do serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são adicionados a ela. Depois de configurada, crie a instância NoSQLClient da seguinte forma:
    var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        Compartment="ocid1.compartment.oc1.............................",
        AuthorizationProvider=IAMAuthorizationProvider.CreateWithInstancePrincipal()
    });
    Você também pode representar a mesma configuração em JSON da seguinte forma:
    {
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseInstancePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}

    Observe que ao usar o Controlador de Instâncias, você deve especificar o id do compartimento (OCID) como propriedade compartimento. Isso é necessário mesmo que você queira usar o compartimento padrão. Observe que você deve usar o id do compartimento e não o nome ou o caminho do compartimento. Além disso, ao usar o Controlador de Instâncias, você não pode prefixar o nome da tabela com o nome ou o caminho do compartimento ao chamar APIs NoSQLClient.

  • Estabelecendo Conexão usando um Controlador de Recursos:

    O Controlador de Recursos é um recurso do serviço IAM que permite que os recursos sejam atores autorizados (ou principais) para executar ações nos recursos do serviço. Depois de configurada, crie a instância NoSQLClient da seguinte forma:
    var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = <your-service-region>,
        Compartment =
            "ocid1.compartment.oc1.............................",
        AuthorizationProvider =
            IAMAuthorizationProvider.CreateWithResourcePrincipal()
    });
    Você também pode representar a mesma configuração em JSON da seguinte forma:
    {
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseResourcePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}

    Observe que ao usar o Controlador de Recursos, você deve especificar o id do compartimento (OCID) como propriedade compartimento. Isso é necessário mesmo que você queira usar o compartimento padrão. Observe que você deve usar o id do compartimento e não o nome ou o caminho do compartimento. Além disso, ao usar o Controlador de Recursos, você não pode prefixar o nome da tabela com o nome ou o caminho do compartimento ao chamar APIs NoSQLClient.

  • Conectando usando o token de sessão:

    Usando a autenticação baseada em token de sessão, você cria um arquivo de configuração local que contém informações como OCID do usuário, OCID da tenancy, região, caminho da chave privada e um caminho de arquivo de token de sessão temporário.

    Você pode usar a autenticação baseada em token de sessão usando um dos três métodos, conforme mostrado abaixo.

    Opção 1: Isso cria uma nova instância de IAMAuthorizationProvider usando a autenticação baseada em token de sessão com o arquivo de configuração padrão do OCI e o nome do perfil padrão. 
    var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken()
});
    Opção 2: Isso cria uma nova instância de IAMAuthorizationProvider usando autenticação baseada em token de sessão com o arquivo de configuração padrão do OCI e o nome de perfil especificado.
    var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<profileName>)
});
    Opção 3: Isso cria uma nova instância de IAMAuthorizationProvider usando autenticação baseada em token de sessão com o arquivo de configuração e o nome de perfil do OCI especificados.
    var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<configFile>,<profileName>)
});
    Você também pode representar a mesma configuração em JSON da seguinte forma:
    {
  "Region": "<your-service-region>",
  "AuthorizationProvider": {
    "AuthorizationType": "IAM",
    "UseSessionToken": true
  },
  "Compartment": "ocid1.compartment.oc1............................."
}

  • Estabelecendo conexão usando a Identidade de Carga de Trabalho do OKE:

    O SDK Dotnet NoSQL da Oracle suporta a execução de programas em contêineres de Carga de Trabalho do OKE no OCI.

    O exemplo abaixo cria uma nova instância de IAMAuthorizationProvider usando a identidade da carga de trabalho do OKE. Esse método permite especificar uma string de token de conta de serviço opcional. Se não for especificado, o token da conta de serviço será lido no caminho de arquivo padrão /var/run/secrets/kubernetes.io/serviceaccount/token.
    var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithOKEWorkloadIdentity()
});
    Você também pode criar uma nova instância de IAMAuthorizationProvider usando a identidade da carga de trabalho do OKE e o arquivo de token da conta de serviço especificado, conforme mostrado abaixo.
    var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = 
    IAMAuthorizationProvider.CreateWithOKEWorkloadIdentityAndTokenFile(<serviceAccountTokenFile>)
});
    Você também pode representar a mesma configuração em JSON da seguinte forma:
    { "Region": "<your-service-region>",  
 "AuthorizationProvider":  {
   "AuthorizationType": "IAM",
   "UseOKEWorkLoadIdentity": true 
 },
 "Compartment": "ocid1.compartment.oc1.............................",
}
Você pode estabelecer conexão com o NDCS usando um dos seguintes métodos:

  • Estabelecendo conexão usando o arquivo de configuração padrão com um perfil padrão:

    Você pode armazenar as credenciais em um arquivo de configuração do Oracle Cloud Infrastructure. O caminho padrão do arquivo de configuração é ~/.oci/config, em que ~ representa o diretório home do usuário. No Windows, ~ é um valor de variável de ambiente USERPROFILE. O arquivo pode conter vários perfis. Por padrão, o SDK usa o perfil chamado DEFAULT para armazenar as credenciais

    Para usar esses valores padrão, crie o arquivo chamado config no diretório ~/.oci com o seguinte conteúdo:
    [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>

    Observe que você também pode especificar seu identificador de região junto com credenciais no arquivo de configuração do OCI. Por padrão, o driver procurará credenciais e uma região no arquivo de configuração do OCI no caminho padrão e no perfil padrão. A região só será obrigatória se HandleBuilder::cloud_region() não for usado. O pass_phrase só será obrigatório se o arquivo de chave RSA exigir um.

    A primeira etapa em qualquer aplicativo Oracle NoSQL Database Cloud Service Rust é criar um Identificador usado para enviar solicitações ao serviço, com base na configuração fornecida em uma estrutura HandleBuilder. As instâncias do identificador são seguras para uso simultâneo e devem ser compartilhadas em uma aplicação multithread ou assíncrona. O exemplo de código a seguir mostra como estabelecer conexão com o serviço de nuvem, usando um arquivo de configuração do usuário:
    let handle = Handle::builder()
.cloud_auth_from_file("~/.oci/config")?
.build().await?;

  • Estabelecendo Conexão usando um Controlador de Instâncias

    O Controlador de Instâncias é um recurso do serviço IAM que permite que as instâncias sejam atores autorizados (ou principais) para executar ações em recursos do serviço. Cada instância de computação tem sua própria identidade e faz autenticação usando os certificados que são adicionados a ela. Para configurar NoSQL nesse modo, use o seguinte código:
    let handle = Handle::builder()
.cloud_auth_from_instance()?
.build().await?;

  • Estabelecendo Conexão com um Controlador de Recursos

    O Controlador de Recursos é um recurso do serviço IAM que permite que os recursos sejam atores autorizados (ou principais) para executar ações nos recursos de serviço. Para configurar NoSQL nesse modo, use o seguinte código:
    let handle = Handle::builder()
.cloud_auth_from_resource()?
.build().await?;

Workflow Típico

Sequência típica de tarefas para trabalhar com o Oracle NoSQL Database Cloud Service.

Se você estiver desenvolvendo aplicativos usando o Oracle NoSQL Database Cloud Service pela primeira vez, siga essas tarefas para guiar.

Tarefa Descrição Mais informações
Conecte seu aplicativo Conecte o seu aplicativo para usar tabelas do Oracle NoSQL Database Cloud Service. Conectando seu Aplicativo ao NDCS
Desenvolver o seu aplicativo Desenvolva o seu aplicativo conectando-se com as tabelas do Oracle NoSQL Database Cloud Service. Desenvolvendo no Oracle Cloud

Desenvolvendo no Oracle NoSQL Database Cloud Simulator

Se você estiver configurando o Oracle NoSQL Database Cloud Service pela primeira vez, consulte Configurando o Seu Serviço.

Tutoriais de Início Rápido

Acesse os tutoriais de início rápido e comece a usar o serviço.

  1. Obtenha acesso ao serviço.

    Inscreva-se em uma promoção do Cloud ou adquira uma assinatura do Oracle Cloud. Ative seu pedido, crie usuários (opcional). Consulte Configurando o Serviço.

  2. Obtenha credenciais para conectar o seu aplicativo. Consulte Autenticação para estabelecer conexão com o Oracle NoSQL Database.

  3. Crie uma tabela no Oracle NoSQL Database Cloud Service.