Conceitos Básicos do Serviço Oracle NoSQL Database Cloud

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

O NoSQL Database Cloud Service permite aos desenvolvedores se concentrarem no desenvolvimento da aplicação em vez de configurar servidores de cluster ou executar monitoramento, ajuste, diagnóstico e dimensionamento de 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 em telas on-line.

Depois de ser autenticado em sua conta do Oracle Cloud, você poderá criar uma tabela NoSQL e especificar requisitos de throughput e armazenamento para a tabela. O sistema 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:

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 Agora - Início Rápido: Primeiros Passos - Principais Recursos - Conceitos de Nuvem - Preços	Conectar - Adquirir suas Credenciais - Autenticação para estabelecer conexão com o NDCS - Conectando seu Aplicativo ao NDCS - Regiões de Dados e Pontos Finais de Serviço Associados	IDE and SDKs - Using IntelliJ Plugin for Development - Using Visual Studio Code Extension for Development - Oracle NoSQL Java SDK - Oracle NoSQL Python SDK - Oracle NoSQL GO SDK - Oracle NoSQL Node.js SDK - Oracle NoSQL Dotnet SDK - Oracle NoSQL Rust SDK
Criar Tabelas - Criando uma Tabela - Usando a Console para criar Tabelas Únicas - Usando APIs para criar Tabelas Únicas - Tabelas Ativas Globais - Usando a console para criar uma Tabela Ativa Global - Usando APIs para criar uma Tabela Ativa Global - Usando a cli do OCI para criar uma tabela	Colocar e Explorar Dados - Usando a Console para adicionar dados - Usando APIs para adicionar dados - Usando a Console para extrair dados - Usando Obter API para extrair dados - Usando a API de Consulta para extrair dados - Consultando tabelas pai-filho	Gerenciar Tabelas - Modificando Tabelas Singleton Usando APIs - Modificando Tabelas Ativas Globais Usando APIs - Eliminando Tabelas e Índices - Gerenciando Tabelas e Índices Usando a Console
Gerenciar Segurança - Configurar Grupos de Usuários e Políticas - Dando Permissão a Outro Usuário para Gerenciar Tabelas NoSQL - Referência de Políticas	Monitorar o Serviço - Eventos de Serviço - Cotas de Serviço - Métricas - Criar e Gerenciar Alarmes	Serviços Públicos - Faça o Download do Oracle NoSQL Database Cloud Simulator - Desenvolvendo no Oracle NoSQL Database Cloud Simulator - Usando o Oracle NoSQL Database Migrator - Usando o Oracle NoSQL Database Analytics Integrator
Referência de SQL - Usando Operadores em SQL - Classificando Agrupamento e Limitando Dados - Usando Expressões Primárias em SQL - Usando funções de Timestamp em consultas - Usando funções de String em consultas	Guias de Referência - Referência do Analytics Integrator - Amostras de casos de uso para NDCS - Solucionar problemas com o GAT

Configurando o Seu Serviço

Se você estiver configurando o Oracle NoSQL Database Cloud Service pela primeira vez, siga estas tarefas como guia.

Tarefa	Reference	Informações Relacionadas
Faça um pedido para o Oracle NoSQL Database Cloud Service ou cadastre-se para a Avaliação Grátis da 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 Seu Custo Mensal. Para fazer upgrade da sua conta gratuita ou para 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.	Como Acessar a Console na Documentação do Oracle Cloud Infrastructure.	Para se familiarizar com a Console do Oracle Cloud Infrastructure, 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 Noções Básicas de Compartimentos 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 a segurança do modelo NoSQL Database Cloud Service, consulte Sobre Oracle NoSQL Database Cloud Service Security Model.

Acessando o Serviço pela Console de Infraestrutura

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

Localize o URL do serviço no e-mail e acesse o seu Oracle NoSQL Database Cloud Service.
Abra o menu de navegação, clique em Bancos de Dados e, em seguida, clique em NoSQL Database.
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 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 que você crie uma tabela do Oracle NoSQL Database Cloud Service, a Oracle recomenda que você configure o compartimento ao qual deseja que a tabela pertença.

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 seu aplicativo ao Oracle NoSQL Database Cloud Service.

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

Método de Autenticação #1: Controladores do Usuário

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 você quiser criar um usuário para o 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 o OCID do usuário, o OCID da tenancy, a região, o caminho da chave privada e a impressão digital. Você poderá 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.
Fornecimento das credenciais por meio de uma API.
Armazenando as credenciais em um vault em algum lugar.

Informações sobre as Credenciais:

Tabela - Credenciais

O que é isso?	Onde encontro?
ID da Tenancy e ID do Usuário (ambos são OCID)	Consulte Onde 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: Como Gerar uma Chave de Assinatura de API para gerar a chave de assinatura com uma frase-sasse opcional. Como Fazer Upload da Chave Pública para fazer upload da chave de assinatura de API para a conta do usuário.
Impressão Digital da Chave de Assinatura e da Frase-Senha (Opcional) da Chave de Assinatura	A impressão digital e a frase-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.

O que é isso?

Onde encontro?

ID da Tenancy e ID do Usuário (ambos são OCID)

Consulte Onde 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:

Como Gerar uma Chave de Assinatura de API para gerar a chave de assinatura com uma frase-sasse opcional.
Como Fazer Upload da Chave Pública para fazer upload da chave de assinatura de API para a conta do usuário.

Impressão Digital da Chave de Assinatura e da Frase-Senha (Opcional) da Chave de Assinatura

A impressão digital e a frase-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.

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

Após executar as tarefas discutidas acima, colete as informações de credenciais e forneça-as 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 para o driver da linguagem da programação que você está usando para saber 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. O 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 #2: Controladores de Instâncias

O 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 controladores de instância, você não precisa configurar credenciais de usuário para os serviços em execução em suas instâncias de computação ou rotacionar as credenciais. As próprias instâncias agora são um tipo principal no IAM. Cada instância de computação tem sua própria identidade e é autenticada usando certificados que são incluídos na instância Esses certificados são criados automaticamente, atribuídos a instâncias e alternados.

Usando autenticação de controladores de instância, você pode autorizar uma instância a fazer chamadas da API em serviços doOracle 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ância pode ser usada em uma instância em que você não deseja armazenar um arquivo de configuração.

Método de Autenticação nº 3: Controlador 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 controlador 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 ele se autentica usando os certificados que são incluídos nele. Esses certificados são criados automaticamente, atribuídos a recursos e rotacionados, evitando a necessidade de criar e gerenciar suas próprias credenciais para acessar o recurso. Ao se autenticar usando um controlador de recursos, você não precisa criar e gerenciar credenciais para acessar recursos do Oracle Cloud Infrastructure.

Após a autenticação, você precisa estar autorizado a acessar os recursos do Oracle Cloud Infrastructure. Consulte Configurando Usuários, Grupos e Políticas Usando o Identity and Access Management para obter mais detalhes.

Método de autenticação nº 4: Autenticação baseada em token

A autenticação baseada em token permite que você crie e use 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 da configuração local que contém informações que incluem o OCID do usuário, o OCID do tenancy, a região, o caminho da chave privada e um caminho do arquivo do token da sessão temporária. 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 usar um web browser.

Com um navegador:

Para usar a autenticação baseada em token para a CLI em um computador com um web browser:

No terminal, execute o seguinte comando:
```
oci session authenticate
```
Selecione uma região.
No browser, informe suas credenciais de usuário.
Após a autenticação bem-sucedida, feche o navegador e siga o prompt interativo no terminal. Você precisa fornecer o nome do perfil que 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 em que 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 autentique-se usando a autenticação baseada em chave de API.

oci setup config

Esse comando solicita você as informações necessárias para criar o arquivo de configuração e as chaves públicas e privadas 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

Você precisa fornecer o nome do perfil que 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 em que 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 nº 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 controle de gerenciamento de acesso e identidade refinado. Uma carga de trabalho é um aplicativo em execução no Kubernetes. Ele pode ser composto por um único componente ou vários componentes que trabalham 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 do K8s acesso orientado por política aos recursos do OCI (Oracle Cloud Infrastructure) usando o OCI Identity and Access Management (IAM).

Com o Workload Identity, você não precisa mais armazenar credenciais como segredos no cluster do Kubernetes ou confiar em grupos dinâmicos da OCI para acesso orientado por políticas do nó de trabalho aos recursos da OCI e, mais especificamente, acesso às suas tabelas NoSQL. Quando os aplicativos exigem acesso aos recursos do OCI, o Workload Identity permite gravar 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 em execução dentro desses 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 a ser usado.
Definir uma política do IAM para conceder ao recurso de carga de trabalho acesso a outros recursos do OCI.
Faça download do SDK apropriado e configure-o para o idioma em que 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 na 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:

No Console do OCI, Abra o menu de navegação e clique em Identity & Security. Em Identity, clique em Policies.
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 que você criou anteriormente.
<service-account-name> é o nome da conta de serviço que você criou 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 seu aplicativo ao Oracle NoSQL Database Cloud Service.

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

Você pode se autenticar usando uma das seguintes opções:

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
Controladores de Instâncias com tokens de Autenticação
Controlador de Recursos
Token da sessão
Identidade de 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:

Fornecer diretamente 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 um 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 constructor for SignatureProvider. */

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

Estabelecendo conexão usando o arquivo de configuração e o perfil 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 Usando um Controlador de Instâncias:

O Controlador de Instâncias é um recurso de serviço do serviço IAM que permite que as instâncias sejam atores autorizados (ou principais) para executar ações nos recursos de serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são incluídos nela.
```
SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();
```
Estabelecendo Conexão Usando um Controlador de Recursos:

O Controlador de Recursos é um recurso de serviço do IAM que permite que os recursos sejam atores autorizados (ou principais) para executar ações nos recursos de serviço
```
SignatureProvider authProvider = SignatureProvider.createWithResourcePrincipal();
```
Estabelecendo conexão 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 de carga de trabalho do Container Engine for Kubernetes (OKE) usando o token de conta de serviço do Kubernetes no caminho padrão /var/run/secrets/kubernetes.io/serviceaccount/token. Esse provedor só pode ser usado dentro dos pods do Kubernetes.
```
SignatureProvider authProvider =
SignatureProvider.createWithOkeWorkloadIdentity();
```
Você também pode especificar o token de conta de serviço específico do Kubernetes a ser usado, conforme mostrado abaixo.
```
SignatureProvider authProvider =
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken>);
```
Como alternativa, você também pode especificar o local do token de conta de serviço específico do Kubernetes 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:

Fornecer diretamente 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 um 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')

Estabelecendo conexão usando um Controlador de Instâncias:

O Controlador de Instâncias é um recurso de serviço do serviço IAM que permite que as instâncias sejam atores autorizados (ou principais) para executar ações nos recursos de serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são incluídos nela.
```
at_provider =
SignatureProvider.create_with_instance_principal(region=my_region)
```
Estabelecendo Conexão Usando um Controlador de Recursos:

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

Estabelecendo conexão usando o token de sessão:

Borneo 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 toda uma carga de trabalho (um aplicativo em execução em clusters do Kubernetes) acesso a tabelas NoSQL usando a Identidade de Carga de Trabalho do OKE. Ele pode ser recuperado pelo oci.auth.signers.get_oke_workload_identity_resource_principal_signer. O assinante recuperado pode 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 de 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:

Fornecer diretamente 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 um 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)

Estabelecendo conexão usando um Controlador de Instâncias:

O Controlador de Instâncias é um recurso de serviço do serviço IAM que permite que as instâncias sejam atores autorizados (ou principais) para executar ações nos recursos de serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são incluídos nela.
```
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 de serviço do IAM que permite que os recursos sejam atores (ou principais) autorizados a executar ações nos recursos de 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)

Estabelecendo conexão usando o token de sessão:

A função NewSessionTokenSignatureProvider cria uma 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 não for especificada 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 nos contêineres de Carga de Trabalho do OKE no OCI. No código que cria um SignatureProvider a ser usado com o 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:

Fornecer diretamente credenciais no código:

Você pode especificar credenciais diretamente como parte da propriedade auth.iam na configuração inicial. Crie uma 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 para o arquivo de configuração é ~/.oci/config, em que ~ significa 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 um 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 o identificador de região junto com as credenciais no arquivo de configuração do OCI. O driver examinará o local acima por padrão e, se uma região for fornecida 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 um perfil não padrão:

Você pode optar por usar outro caminho para o arquivo de configuração do OCI, bem como outro perfil 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 do 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>'
        }
    }
});
```
Estabelecendo conexão usando um Controlador de Instâncias:

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

Depois de configurar, crie a instância do 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 é obrigató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 do NoSQLClient.
Estabelecendo Conexão Usando um Controlador de Recursos:

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

Depois de configurar, crie a instância do 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 é obrigató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 do NoSQLClient.
Estabelecendo conexão usando o token de sessão:

Usando a autenticação baseada em token da sessão, você cria um arquivo da configuração local que contém informações, incluindo o OCID do usuário, o OCID do tenancy, a região, o caminho da chave privada e um caminho do arquivo do token da sessão temporária.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............
   ' auth: {
       iam: { useSessionToken: true }
  }
});
```
Este método usa um token de sessão temporária 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 nos 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 nos pods do Kubernetes. O uso da identidade da carga de trabalho do OKE 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 sobre o conteúdo e o formato do arquivo.

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

Fornecer diretamente 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 para o arquivo de configuração é ~/.oci/config, em que ~ significa 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 DEFAULT para armazenar as credenciais

Para usar esses valores padrão, crie um 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 o identificador de região junto com as 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. Assim, se você fornecer a região junto com as 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 um perfil não padrão:

Você pode optar por usar outro caminho para o arquivo de configuração do OCI, bem como outro perfil dentro do arquivo de configuração. Nesse caso, especifique-as dentro da 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 do NoSQLClient da seguinte forma:
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = Region.<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            "<your_config_file>", "<your_profile_name>")
    });
```
Estabelecendo conexão usando um Controlador de Instâncias:

O Controlador de Instâncias é um recurso de serviço do serviço IAM que permite que as instâncias sejam atores autorizados (ou principais) para executar ações nos recursos de serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são incluídos nela. Depois de configurar, crie a instância do 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 de compartimento. Isso é obrigató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 do NoSQLClient.
Estabelecendo Conexão Usando um Controlador de Recursos:

O Controlador de Recursos é um recurso de serviço do IAM que permite que os recursos sejam atores (ou principais) autorizados a executar ações nos recursos de serviço, Depois de configurar, crie a instância do 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 de compartimento. Isso é obrigató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 do NoSQLClient.
Estabelecendo conexão usando o token de sessão:

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

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 do 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 do 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 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 do IAMAuthorizationProvider usando autenticação baseada em token de sessão com o arquivo de configuração e o nome do 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 do Oracle NoSQL Dotnet suporta a execução de programas nos contêineres de Carga de Trabalho do OKE no OCI.

O exemplo abaixo cria uma nova instância do IAMAuthorizationProvider usando a identidade da carga de trabalho do OKE. Este 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 do IAMAuthorizationProvider usando a identidade de carga de trabalho do OKE e o arquivo de token de 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 se conectar ao 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 para o arquivo de configuração é ~/.oci/config, em que ~ significa 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 DEFAULT para armazenar as credenciais

Para usar esses valores padrão, crie um 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 o identificador de região junto com as 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á necessária se HandleBuilder::cloud_region() não for usado. O pass_phrase só será necessário se o arquivo de chaves RSA exigir um.

A primeira etapa de qualquer aplicativo Oracle NoSQL Database Cloud Service Rust é criar um Handle usado para enviar solicitações ao serviço, com base na configuração fornecida em uma estrutura do HandleBuilder. As instâncias do Handle são seguras para uso simultâneo e destinadas a serem compartilhadas em um aplicativo multithread ou assíncrono. 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 de serviço do serviço IAM que permite que as instâncias sejam atores autorizados (ou principais) para executar ações nos recursos de serviço. Cada instância de computação tem sua própria identidade e faz a autenticação usando os certificados que são incluídos nela. Para configurar o NoSQL nesse modo, use o seguinte código:
```
let handle = Handle::builder()
.cloud_auth_from_instance()?
.compartment_id ("ocid1.compartment.oc1.............................")?
.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 estas tarefas como um guia.

Tarefa	Descrição	Mais informações
Conecte seu aplicativo	Conecte seu aplicativo para usar tabelas do Oracle NoSQL Database Cloud Service.	Conectando seu Aplicativo ao NDCS
Desenvolver o seu aplicativo	Desenvolva seu aplicativo depois de se conectar às tabelas do Oracle NoSQL Database Cloud Service.	Developing in Oracle Cloud Developing in Oracle NoSQL Database Cloud Simulator</p>

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

Tutoriais de Início Rápido

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

Obtenha acesso ao serviço.

Inscreva-se para uma promoção em Nuvem ou compre uma assinatura do Oracle Cloud. de Ative o seu pedido, crie usuários (opcional). Consulte Configurando o Serviço.
Adquira credenciais para conectar o seu aplicativo. Consulte Autenticação para estabelecer conexão com o Oracle NoSQL Database.
Crie uma tabela no Oracle NoSQL Database Cloud Service. Para começar, consulte Conceitos Básicos de Tabelas no Oracle NoSQL Database Cloud Service.

Conceitos Básicos do Serviço Oracle NoSQL Database Cloud

Links Rápidos

Configurando o Seu Serviço

Acessando o Serviço pela Console de Infraestrutura

Criando um Compartimento

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

Conectando seu Aplicativo ao NDCS

Workflow Típico

Tutoriais de Início Rápido

Tópicos Relacionados