As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Migração do Couchbase Server
<a name="migration-from-couchbase"></a>

**Topics**
+ [Introdução](#introduction)
+ [Comparação com o Amazon DocumentDB](#comparison-to-amazon-documentdb)
+ [Descoberta](#discovery)
+ [Planejamento](#planning)
+ [Migração](#migration)
+ [Validação](#validation)

## Introdução
<a name="introduction"></a>

Este guia apresenta os principais pontos a serem considerados ao migrar do Couchbase Server para o Amazon DocumentDB. Ele explica as considerações sobre as fases de descoberta, planejamento, execução e validação de sua migração. Também explica como realizar migrações offline e online.

## Comparação com o Amazon DocumentDB
<a name="comparison-to-amazon-documentdb"></a>


|  | **Servidor Couchbase ** | ** Amazon DocumentDB** | 
| --- | --- | --- | 
| Organização de dados  | Nas versões 7.0 e posteriores, os dados são organizados em intervalos, escopos e coleções. Nas versões anteriores, os dados são organizados em compartimentos. | Os dados são organizados em bancos de dados e coleções. | 
| Compatibilidade  | Há APIs separadas para cada serviço (por exemplo, dados, índice, pesquisa etc.). As pesquisas secundárias usam SQL\+\+ (anteriormente conhecido como N1QL); uma linguagem de consulta baseada em ANSI-standard SQL, por isso é familiar para muitos desenvolvedores. | O Amazon DocumentDB é [ compatível com a API do MongoDB. ](compatibility.html) | 
| Arquitetura | O armazenamento é anexado a cada instância do cluster. Você não pode escalar a computação independentemente do armazenamento. | O Amazon DocumentDB foi projetado para a nuvem e para evitar as limitações das arquiteturas tradicionais de banco de dados. As camadas de [ computação e armazenamento são separadas ](db-clusters-understanding.html) no Amazon DocumentDB e a camada de computação pode ser [ escalada independentemente do armazenamento. ](how-it-works.html) | 
| Adicione capacidade de leitura sob demanda  | Os clusters podem ser ampliados com a adição de instâncias. Como o armazenamento está conectado à instância em que o serviço está em execução, o tempo necessário para escalar depende da quantidade de dados que precisam ser movidos para a nova instância ou rebalanceados. | Você pode obter escalabilidade de leitura para seu cluster Amazon DocumentDB [ criando até 15 réplicas ](db-cluster-manage-performance.html#db-cluster-manage-scaling-reads) do Amazon DocumentDB no cluster. Não há impacto na camada de armazenamento. | 
| Recupere-se rapidamente da falha do nó  | Os clusters têm recursos de failover automático, mas o tempo necessário para recuperar a força total do cluster depende da quantidade de dados que precisam ser movidos para a nova instância. | O Amazon DocumentDB pode fazer o [ failover do primário ](failover.html) normalmente em 30 segundos e restaurar a força total do cluster em 8 a 10 minutos, independentemente da quantidade de dados no cluster. | 
| Dimensione o armazenamento à medida que os dados crescem  | Para clusters autogerenciados, o armazenamento e o iOS não são escalados automaticamente. | O [ armazenamento do Amazon DocumentDB e o iOS escalam automaticamente](db-cluster-manage-performance.html#db-cluster-manage-scaling-storage). | 
| Faça backup de dados sem afetar o desempenho  | Os backups são executados pelo serviço de backup e não são ativados por padrão. Como o armazenamento e a computação não estão separados, pode haver um impacto no desempenho. | Os backups do Amazon DocumentDB são habilitados por padrão e não podem ser desativados. Os backups são gerenciados pela camada de armazenamento, portanto, não causam impacto na camada de computação. O Amazon DocumentDB oferece suporte à [ restauração a partir de um snapshot de cluster ](backup_restore-restore_from_snapshot.html) e à [ restauração em um ponto no tempo. ](backup_restore-point_in_time_recovery.html) | 
| Durabilidade dos dados  | Pode haver no máximo 3 cópias de réplica de dados em um cluster, totalizando 4 cópias. Cada instância em que o serviço de dados estiver em execução terá 1, 2 ou 3 cópias ativas dos dados. | O Amazon DocumentDB mantém 6 cópias de dados, independentemente de quantas instâncias de computação existam, com um quórum de gravação de 4 e persistem como verdadeiras. Os clientes recebem uma confirmação após a camada de armazenamento persistir em 4 cópias dos dados. | 
| Consistência | A consistência imediata K/V das operações é suportada. O SDK do Couchbase encaminha as K/V solicitações para a instância específica que contém a cópia ativa dos dados. Assim que uma atualização for confirmada, o cliente terá a garantia de lê-la. A replicação de atualizações para outros serviços (indexação, pesquisa, análise, eventos) acaba sendo consistente. | Eventualmente, as réplicas do Amazon DocumentDB são consistentes. Se forem necessárias leituras de consistência imediata, o cliente poderá ler da instância primária. | 
| Replicação | Cross-Data O Center Replication (XDCR) fornece replicação filtrada e ativa de dados passive/active em muitas topologias. | [Os clusters globais do Amazon DocumentDB ](global-clusters.html) fornecem replicação ativa-passiva em topologias 1:muitas (até 10). | 

## Descoberta
<a name="discovery"></a>

A migração para o Amazon DocumentDB exige uma compreensão completa da carga de trabalho existente do banco de dados. A descoberta da carga de trabalho é o processo de analisar a configuração e as características operacionais do cluster Couchbase — conjunto de dados, índices e carga de trabalho — para ajudar a garantir uma transição perfeita com o mínimo de interrupção.

### Configuração do cluster
<a name="cluster-configuration"></a>

O Couchbase usa uma arquitetura centrada no serviço em que cada recurso corresponde a um serviço. Execute o seguinte comando em seu cluster Couchbase para determinar quais serviços estão sendo usados (consulte [ Obtenção de informações sobre nós](https://docs.couchbase.com/server/current/rest-api/rest-node-get-info.html)):

```
curl -v -u <administrator>:<password> \
  http://<ip-address-or-hostname>:<port>/pools/nodes | \
  jq '[.nodes[].services[]] | unique'
```

Exemplo de saída:

```
[
  "backup",
  "cbas",
  "eventing",
  "fts",
  "index",
  "kv",
  "n1ql"
]
```

Os serviços do Couchbase incluem o seguinte:

#### Serviço de dados (kv)
<a name="data-service-kv"></a>

O serviço de dados fornece read/write acesso aos dados na memória e no disco.

O Amazon DocumentDB oferece suporte a K/V operações em dados JSON por meio da API [ MongoDB. ](java-crud-operations.html)

#### Serviço de consulta (n1ql)
<a name="query-service-n1ql"></a>

O serviço de consulta oferece suporte à consulta de dados JSON via SQL\+\+.

O Amazon DocumentDB oferece suporte à consulta de dados JSON por meio da API do MongoDB.

#### Serviço de indexação (índice)
<a name="index-service-index"></a>

O serviço de indexação cria e mantém índices nos dados, permitindo consultas mais rápidas.

O Amazon DocumentDB oferece suporte a um índice primário padrão e à criação de índices secundários em dados JSON por meio da API do MongoDB.

#### Serviço de pesquisa (fts)
<a name="search-service-fts"></a>

O serviço de pesquisa oferece suporte à criação de índices para pesquisa de texto completo.

O recurso nativo de pesquisa de texto completo do Amazon DocumentDB permite que você [ realize consultas de texto básicas em grandes conjuntos de dados textuais usando índices ](text-search.html) de texto para fins especiais usando a API. MongoDB Para recursos avançados, como pesquisa difusa, pesquisa multilíngue e pesquisa entre coleções, use a integração Zero-ETL do [ Amazon DocumentDB com o Amazon Service. OpenSearch ](https://aws.amazon.com/blogs/big-data/amazon-documentdb-zero-etl-integration-with-amazon-opensearch-service-is-now-available/)

#### Serviço de análise (cbas)
<a name="analytics-service-cbas"></a>

O serviço de análise oferece suporte à análise de dados JSON quase em tempo real.

O Amazon DocumentDB oferece suporte a consultas ad-hoc em dados JSON por meio da API do MongoDB. Você também pode [ executar consultas complexas em seus dados JSON no Amazon DocumentDB usando o Apache Spark em execução no Amazon EMR. ](https://aws.amazon.com/blogs/database/run-complex-queries-on-massive-amounts-of-data-stored-on-your-amazon-documentdb-clusters-using-apache-spark-running-on-amazon-emr/)

#### Serviço de eventos (eventos)
<a name="eventing-service-eventing"></a>

O serviço de eventos executa a lógica de negócios definida pelo usuário em resposta às mudanças nos dados.

O Amazon DocumentDB automatiza cargas de trabalho orientadas por eventos [ invocando AWS Lambda funções sempre que os dados são alterados com seu cluster Amazon DocumentDB. ](https://docs.aws.amazon.com/lambda/latest/dg/with-documentdb-tutorial.html)

#### Serviço de backup (backup)
<a name="backup-service-backup"></a>

O serviço de backup agenda backups de dados completos e incrementais e mescla de backups de dados anteriores.

O Amazon DocumentDB faz backup contínuo de seus dados no Amazon S3 com um período de retenção de 1 a 35 dias para que você possa restaurar rapidamente em qualquer ponto dentro do período de retenção de backup. O Amazon DocumentDB também tira snapshots automáticos dos seus dados como parte desse processo de backup contínuo. Você também pode [ gerenciar o backup e a restauração do Amazon DocumentDB com AWS Backup. ](https://aws.amazon.com/blogs/storage/manage-backup-and-restore-of-amazon-documentdb-with-aws-backup/).

### Características operacionais
<a name="operational-characteristics"></a>

Use a ferramenta [ Discovery para Couchbase ](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/discovery-tool-for-couchbase) para obter as seguintes informações sobre seu conjunto de dados, índices e carga de trabalho. Essas informações ajudarão você a dimensionar seu cluster Amazon DocumentDB.

#### Conjunto de dados
<a name="data-set"></a>

A ferramenta recupera as seguintes informações de bucket, escopo e coleta:

1. nome do bucket

1. tipo de bucket

1. nome do escopo

1. nome da coleção

1. tamanho total (bytes)

1. total de itens

1. tamanho do item (bytes)

#### Índices
<a name="couchbase-indexes"></a>

A ferramenta recupera as seguintes estatísticas de índice e todas as definições de índice para todos os compartimentos. Observe que os índices primários são excluídos, pois o Amazon DocumentDB cria automaticamente um índice primário para cada coleção.

1. nome do bucket

1. nome do escopo

1. nome da coleção

1. nome do índice

1. tamanho do índice (bytes)

#### Workload
<a name="workload"></a>

A ferramenta K/V recupera as métricas de consulta N1QL. K/V os valores das métricas são coletados no nível do bucket e as métricas do SQL\+\+ são coletadas no nível do cluster.

As opções da linha de comando da ferramenta são as seguintes:

```
python3 discovery.py \
  --username <source cluster username> \
  --password <source cluster password> \
  --data_node <data node IP address or DNS name> \
  --admin_port <administration http REST port> \
  --kv_zoom <get bucket statistics for specified interval> \
  --tools_path <full path to Couchbase tools> \
  --index_metrics <gather index definitions and SQL++ metrics> \
  --indexer_port <indexer service http REST port> \
  --n1ql_start <start time for sampling> \
  --n1ql_step <sample interval over the sample period>
```

Veja a seguir um exemplo de comando:

```
python3 discovery.py \
  --username username \
  --password ******** \
  --data_node "http://10.0.0.1" \
  --admin_port 8091 \
  --kv_zoom week \
  --tools_path "/opt/couchbase/bin" \
  --index_metrics true \
  --indexer_port 9102 \
  --n1ql_start -60000 \
  --n1ql_step 1000
```

K/V os valores métricos serão baseados em amostras a cada 10 minutos na semana passada (consulte Método [ HTTP e URI](https://docs.couchbase.com/server/current/rest-api/rest-bucket-stats.html#http-method-and-uri)). Os valores métricos do SQL\+\+ serão baseados em amostras a cada 1 segundo nos últimos 60 segundos (consulte Rótulos [https://docs.couchbase.com/server/current/rest-api/rest-statistics-single.html#general-labels](https://docs.couchbase.com/server/current/rest-api/rest-statistics-single.html#general-labels) gerais). A saída do comando estará nos seguintes arquivos:

**collection-stats.csv ** — informações de bucket, escopo e coleta

```
bucket,bucket_type,scope_name,collection_name,total_size,total_items,document_size
beer-sample,membase,_default,_default,2796956,7303,383
gamesim-sample,membase,_default,_default,114275,586,196
pillowfight,membase,_default,_default,1901907769,1000006,1902
travel-sample,membase,inventory,airport,547914,1968,279
travel-sample,membase,inventory,airline,117261,187,628
travel-sample,membase,inventory,route,13402503,24024,558
travel-sample,membase,inventory,landmark,3072746,4495,684
travel-sample,membase,inventory,hotel,4086989,917,4457
...
```

**index-stats.csv ** — nomes e tamanhos de índices

```
bucket,scope,collection,index-name,index-size
beer-sample,_default,_default,beer_primary,468144
gamesim-sample,_default,_default,gamesim_primary,87081
travel-sample,inventory,airline,def_inventory_airline_primary,198290
travel-sample,inventory,airport,def_inventory_airport_airportname,513805
travel-sample,inventory,airport,def_inventory_airport_city,487289
travel-sample,inventory,airport,def_inventory_airport_faa,526343
travel-sample,inventory,airport,def_inventory_airport_primary,287475
travel-sample,inventory,hotel,def_inventory_hotel_city,497125
...
```

**kv-stats.csv ** — obtenha, defina e exclua métricas para todos os buckets

```
bucket,gets,sets,deletes
beer-sample,0,0,0
gamesim-sample,0,0,0
pillowfight,369,521,194
travel-sample,0,0,0
```

**n1ql-stats.csv ** — Métricas de seleção, exclusão e inserção do SQL \+\+ para o cluster

```
selects,deletes,inserts
0,132,87
```

**indexes- <bucket-name>.txt ** — definições de índice de todos os índices no bucket. Observe que os índices primários são excluídos, pois o Amazon DocumentDB cria automaticamente um índice primário para cada coleção.

```
CREATE INDEX `def_airportname` ON `travel-sample`(`airportname`)
CREATE INDEX `def_city` ON `travel-sample`(`city`)
CREATE INDEX `def_faa` ON `travel-sample`(`faa`)
CREATE INDEX `def_icao` ON `travel-sample`(`icao`)
CREATE INDEX `def_inventory_airport_city` ON `travel-sample`.`inventory`.`airport`(`city`)
CREATE INDEX `def_inventory_airport_faa` ON `travel-sample`.`inventory`.`airport`(`faa`)
CREATE INDEX `def_inventory_hotel_city` ON `travel-sample`.`inventory`.`hotel`(`city`)
CREATE INDEX `def_inventory_landmark_city` ON `travel-sample`.`inventory`.`landmark`(`city`)
CREATE INDEX `def_sourceairport` ON `travel-sample`(`sourceairport`)
...
```

## Planejamento
<a name="planning"></a>

Na fase de planejamento, você determinará os requisitos de cluster do Amazon DocumentDB e o mapeamento dos buckets, escopos e coleções do Couchbase para bancos de dados e coleções do Amazon DocumentDB.

### Requisitos de cluster do Amazon DocumentDB
<a name="amazon-documentdb-cluster-requirements"></a>

Use os dados coletados na fase de descoberta para dimensionar seu cluster Amazon DocumentDB. Consulte Dimensionamento de [ instâncias ](best_practices.html#best_practices-instance_sizing) para obter mais informações sobre como dimensionar seu cluster Amazon DocumentDB.

### Mapeando intervalos, escopos e coleções para bancos de dados e coleções
<a name="mapping-buckets-scopes-and-collections-to-databases-and-collections"></a>

Determine os bancos de dados e as coleções que existirão em seus clusters do Amazon DocumentDB. Considere as seguintes opções, dependendo de como os dados são organizados em seu cluster Couchbase. Essas não são as únicas opções, mas fornecem pontos de partida para você considerar.

#### Couchbase Server 6.x ou anterior
<a name="couchbase-6x-or-earlier"></a>

##### Buckets do Couchbase para coleções do Amazon DocumentDB
<a name="couchbase-buckets-to-amazon-documentdb-collections"></a>

Migre cada bucket para uma coleção diferente do Amazon DocumentDB. Nesse cenário, o valor do documento Couchbase será usado como o `id` valor do Amazon `_id` DocumentDB.

![Buckets do Couchbase Server 6.x ou anteriores para coleções do Amazon DocumentDB](https://docs.aws.amazon.com/pt_br/documentdb/latest/devguide/images/buckets-to-collections.png)


#### Couchbase Server 7.0 ou posterior
<a name="couchbase-70-or-later"></a>

##### Coleções do Couchbase para coleções do Amazon DocumentDB
<a name="couchbase-collections-to-amazon-documentdb-collections"></a>

Migre cada coleção para uma coleção diferente do Amazon DocumentDB. Nesse cenário, o valor do documento Couchbase será usado como o `id` valor do Amazon `_id` DocumentDB.

![Coleções do Couchbase Server 7.0 ou posteriores para coleções do Amazon DocumentDB](https://docs.aws.amazon.com/pt_br/documentdb/latest/devguide/images/collections-to-collections.png)


## Migração
<a name="migration"></a>

### Migração de índices
<a name="index-migration"></a>

A migração para o Amazon DocumentDB envolve a transferência não apenas de dados, mas também de índices para manter o desempenho das consultas e otimizar as operações do banco de dados. Esta seção descreve o processo detalhado passo a passo para migrar índices para o Amazon DocumentDB e, ao mesmo tempo, garantir a compatibilidade e a eficiência.

Use o [ Amazon Q ](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/chat-with-q.html) (disponível no AWS Management Console ou no seu IDE) para converter instruções SQL\+\+ em `CREATE INDEX` comandos do Amazon `createIndex()` DocumentDB.

1. Faça o upload do (s) <bucket name>**arquivo (s) ** indexes- .txt criados pela Discovery Tool for Couchbase.

1. Digite o seguinte prompt:

   `Convert the Couchbase CREATE INDEX statements to Amazon DocumentDB createIndex commands`

O Amazon Q gerará `createIndex()` comandos equivalentes do Amazon DocumentDB. Observe que talvez seja necessário atualizar os nomes das coleções com base em como você [ mapeou os buckets, escopos e coleções do Couchbase para as coleções do Amazon DocumentDB. ](#mapping-buckets-scopes-and-collections-to-databases-and-collections)

Por exemplo:

**indexes-beer-sample.txt **

```
CREATE INDEX `beerType` ON `beer-sample`(`type`)
CREATE INDEX `code` ON `beer-sample`(`code`) WHERE (`type` = "brewery")
```

Exemplo de saída do Amazon Q (trecho):

```
db.beerSample.createIndex(
  { "type": 1 },
  {
    "name": "beerType",
    "background": true
  }
)

db.beerSample.createIndex(
  { "code": 1 },
  {
    "name": "code",
    "background": true,
    "partialFilterExpression": { "type": "brewery" }
  }
)
```

Para quaisquer índices que o Amazon Q não consiga converter, consulte [ Gerenciando índices ](managing-indexes.html) e índices do Amazon DocumentDB e [ propriedades ](mongo-apis.html#mongo-apis-index) do índice para obter mais informações.

### Refatore o código para usar as APIs do MongoDB
<a name="refactor-code-to-use-the-mongodb-apis"></a>

Os clientes usam os SDKs do Couchbase para se conectar ao Couchbase Server. Os clientes do Amazon DocumentDB usam drivers do MongoDB para se conectar ao Amazon DocumentDB. Todos os idiomas suportados pelos SDKs do Couchbase também são suportados pelos drivers do MongoDB. Consulte [ MongoDB Drivers ](https://www.mongodb.com/docs/drivers/) para obter mais informações sobre o driver para seu idioma.

Como as APIs são diferentes entre o Couchbase Server e o Amazon DocumentDB, você precisará refatorar seu código para usar as APIs apropriadas do MongoDB. Você pode usar o [ Amazon Q ](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/chat-with-q.html) para converter as chamadas de K/V API e as consultas SQL\+\+ nas APIs equivalentes do MongoDB:

1. Faça upload do (s) arquivo (s) do código-fonte.

1. Digite o seguinte prompt:

   `Convert the Couchbase API code to Amazon DocumentDB API code`

Usando a amostra de código do [ Hello Couchbase ](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html#hello-couchbase) Python, o Amazon Q gera o seguinte (trecho):

```
from pymongo import MongoClient

# Connection parameters
database_name = "travel-sample"

# Connect to Amazon DocumentDB cluster
client = MongoClient('<Amazon DocumentDB connection string>',
                     tls=True,
                     tlsCAFile='global-bundle.pem')

# Get reference to database and collection
db = client['travel-sample']
airline_collection = db['airline']

# upsert document function
def upsert_document(doc):
    print("\nUpsert Result: ")
    try:
        # key will equal: "airline_8091"
        key = doc["type"] + "_" + str(doc["id"])
        doc['_id'] = key # Amazon DocumentDB uses _id as primary key
        result = airline_collection.update_one(
            {'_id': key},
            {'$set': doc},
            upsert=True
        )
        print(f"Modified count: {result.modified_count}")
    except Exception as e:
        print(e)

# get document function
def get_airline_by_key(key):
    print("\nGet Result: ")
    try:
        result = airline_collection.find_one({'_id': key})
        print(result)
    except Exception as e:
        print(e)

# query for document by callsign
def lookup_by_callsign(cs):
    print("\nLookup Result: ")
    try:
        result = airline_collection.find(
            {'callsign': cs},
            {'name': 1, '_id': 0}
        )
        for doc in result:
            print(doc['name'])
    except Exception as e:
        print(e)

# Test document
airline = {
    "type": "airline",
    "id": 8091,
    "callsign": "CBS",
    "iata": None,
    "icao": None,
    "name": "Couchbase Airways",
}

upsert_document(airline)
get_airline_by_key("airline_8091")
lookup_by_callsign("CBS")
```

Consulte [ Conectando-se programaticamente ao Amazon DocumentDB ](connect_programmatically.html) para ver exemplos de conexão com o Amazon DocumentDB em Python, PHP, Go, Java Node.js, C\#/.NET, R e Ruby.

### Selecione a abordagem de migração
<a name="select-the-migration-approach"></a>

Ao migrar dados para o Amazon DocumentDB, há duas opções:

1. [migração off-line ](#offline-migration)

1. [migração on-line ](#online-migration)

**nota**  
O Amazon DocumentDB usa o `_id` campo como chave primária para cada documento. As abordagens de migração neste guia armazenam a chave do documento do Couchbase no `_id` campo. Para migração offline, isso é feito por meio da `--include-key _id` opção em`cbexport`. Para a migração on-line, isso é feito por meio do conector Kafka. `ProvidedInKeyStrategy`

#### Migração offline
<a name="offline-migration"></a>

Considere uma migração off-line quando:
+ **O tempo de inatividade é aceitável: a migração ** off-line envolve interromper as operações de gravação no banco de dados de origem, exportar os dados e importá-los para o Amazon DocumentDB. Esse processo gera tempo de inatividade para seu aplicativo. Se seu aplicativo ou carga de trabalho tolerar esse período de indisponibilidade, a migração off-line é uma opção viável.
+ **Migração de conjuntos de dados menores ou realização de provas de conceito: ** para conjuntos de dados menores, o tempo necessário para o processo de exportação e importação é relativamente curto, tornando a migração off-line um método rápido e simples. Também é adequado para ambientes de desenvolvimento, teste e prova de conceito, nos quais o tempo de inatividade é menos crítico.
+ **Simplicidade é uma prioridade: ** o método offline, usando cbexport e mongoimport, geralmente é a abordagem mais direta para migrar dados. Ele evita as complexidades da captura de dados de mudança (CDC) envolvida nos métodos de migração on-line.
+ **Nenhuma alteração contínua precisa ser replicada: ** se o banco de dados de origem não estiver recebendo mudanças ativamente durante a migração, ou se essas alterações não forem essenciais para serem capturadas e aplicadas ao destino durante o processo de migração, uma abordagem off-line é apropriada.

**Topics**
+ [Couchbase Server 6.x ou anterior](#couchbase-6x-or-earlier-offline)
+ [Couchbase Server 7.0 ou posterior](#couchbase-70-or-later-offline)

##### Couchbase Server 6.x ou anterior
<a name="couchbase-6x-or-earlier-offline"></a>

##### Bucket Couchbase para a coleção Amazon DocumentDB
<a name="couchbase-bucket-to-amazon-documentdb-collection-offline"></a>

Exporte dados usando [ cbexport json ](https://docs-archive.couchbase.com/server/6.6/tools/cbexport-json.html) para criar um despejo JSON de todos os dados no bucket. Para a `--format` opção, você pode usar `lines` ou`list`.

```
cbexport json \
  --cluster <source cluster endpoint> \
  --bucket <bucket name> \
  --format <lines | list> \
  --username <username> \
  --password <password> \
  --output export.json \
  --include-key _id
```

Importe os dados para uma coleção do Amazon DocumentDB usando [ mongoimport ](backup_restore-dump_restore_import_export_data.html#backup_restore-dump_restore_import_export_data-mongoimport) com a opção apropriada para importar as linhas ou a lista:

linhas:

```
mongoimport \
  --db <database> \
  --collection <collection> \
  --uri "<Amazon DocumentDB cluster connection string>" \
  --ssl \
  --sslCAFile global-bundle.pem \
  --file export.json
```

lista:

```
mongoimport \
  --db <database> \
  --collection <collection> \
  --uri "<Amazon DocumentDB cluster connection string>" \
  --ssl \
  --sslCAFile global-bundle.pem \
  --jsonArray \
  --file export.json
```

##### Couchbase Server 7.0 ou posterior
<a name="couchbase-70-or-later-offline"></a>

Para realizar uma migração offline, use as ferramentas cbexport e mongoimport:

##### Bucket Couchbase com escopo padrão e coleção padrão
<a name="couchbase-bucket-with-default-scope-and-default-collection-offline"></a>

Exporte dados usando [ cbexport json ](https://docs.couchbase.com/server/current/tools/cbexport-json.html) para criar um dump JSON de todas as coleções no bucket. Para a `--format` opção, você pode usar `lines` ou`list`.

```
cbexport json \
  --cluster <source cluster endpoint> \
  --bucket <bucket name> \
  --format <lines | list> \
  --username <username> \
  --password <password> \
  --output export.json \
  --include-key _id
```

Importe os dados para uma coleção do Amazon DocumentDB usando [ mongoimport ](backup_restore-dump_restore_import_export_data.html#backup_restore-dump_restore_import_export_data-mongoimport) com a opção apropriada para importar as linhas ou a lista:

linhas:

```
mongoimport \
  --db <database> \
  --collection <collection> \
  --uri "<Amazon DocumentDB cluster connection string>" \
  --ssl \
  --sslCAFile global-bundle.pem \
  --file export.json
```

lista:

```
mongoimport \
  --db <database> \
  --collection <collection> \
  --uri "<Amazon DocumentDB cluster connection string>" \
  --ssl \
  --sslCAFile global-bundle.pem \
  --jsonArray \
  --file export.json
```

##### Coleções do Couchbase para coleções do Amazon DocumentDB
<a name="couchbase-collections-to-amazon-documentdb-collections-offline"></a>

Exporte dados usando [ cbexport json ](https://docs.couchbase.com/server/current/tools/cbexport-json.html) para criar um dump JSON de cada coleção. Use a `--include-data` opção de exportar cada coleção. Para a `--format` opção, você pode usar `lines` ou`list`. Use as `--collection-field` opções `--scope-field` e para armazenar o nome do escopo e da coleção nos campos especificados em cada documento JSON.

```
cbexport json \
  --cluster <source cluster endpoint> \
  --bucket <bucket name> \
  --include-data <scope name>.<collection name> \
  --format <lines | list> \
  --username <username> \
  --password <password> \
  --output export.json \
  --include-key _id \
  --scope-field "_scope" \
  --collection-field "_collection"
```

Como cbexport adicionou os `_collection` campos `_scope` e a cada documento exportado, você pode removê-los de cada documento no arquivo de exportação por meio de pesquisa e substituição`sed`, ou qualquer método de sua preferência.

Importe os dados de cada coleção para uma coleção do Amazon DocumentDB usando [ mongoimport ](backup_restore-dump_restore_import_export_data.html#backup_restore-dump_restore_import_export_data-mongoimport) com a opção apropriada para importar as linhas ou a lista:

linhas:

```
mongoimport \
  --db <database> \
  --collection <collection> \
  --uri "<Amazon DocumentDB cluster connection string>" \
  --ssl \
  --sslCAFile global-bundle.pem \
  --file export.json
```

lista:

```
mongoimport \
  --db <database> \
  --collection <collection> \
  --uri "<Amazon DocumentDB cluster connection string>" \
  --ssl \
  --sslCAFile global-bundle.pem \
  --jsonArray \
  --file export.json
```

#### migração online
<a name="online-migration"></a>

Considere uma migração on-line quando precisar minimizar o tempo de inatividade e as mudanças contínuas precisarem ser replicadas para o Amazon DocumentDB quase em tempo real.

Consulte [ Como realizar uma migração ao vivo do Couchbase para o Amazon DocumentDB ](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/migration-utility-for-couchbase) para saber como realizar uma migração ao vivo para o Amazon DocumentDB. A documentação orienta você na implantação da solução e na execução de uma migração ao vivo de um bucket para um cluster do Amazon DocumentDB.

**Topics**
+ [Couchbase Server 6.x ou anterior](#couchbase-6x-or-earlier-online)
+ [Couchbase Server 7.0 ou posterior](#couchbase-70-or-later-online)

##### Couchbase Server 6.x ou anterior
<a name="couchbase-6x-or-earlier-online"></a>

##### Bucket Couchbase para a coleção Amazon DocumentDB
<a name="couchbase-bucket-to-amazon-documentdb-collection-online"></a>

O utilitário de [ migração do Couchbase ](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/migration-utility-for-couchbase) é pré-configurado para realizar uma migração on-line de um bucket do Couchbase para uma coleção do Amazon DocumentDB. Observando a [ configuração do conector de ](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) coletor, o `document.id.strategy` parâmetro é configurado para usar o valor da chave da mensagem como o valor do `_id` campo (consulte Propriedades da estratégia de ID do conector de [ coletor](https://www.mongodb.com/docs/kafka-connector/current/sink-connector/configuration-properties/id-strategy/#std-label-sink-configuration-id-strategy)):

```
ConnectorConfiguration:
  document.id.strategy: 'com.mongodb.kafka.connect.sink.processor.id.strategy.ProvidedInKeyStrategy'
```

##### Couchbase Server 7.0 ou posterior
<a name="couchbase-70-or-later-online"></a>

##### Bucket Couchbase com escopo padrão e coleção padrão
<a name="couchbase-bucket-with-default-scope-and-default-collection-online"></a>

O utilitário de [ migração do Couchbase ](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/migration-utility-for-couchbase) é pré-configurado para realizar uma migração on-line de um bucket do Couchbase para uma coleção do Amazon DocumentDB. Observando a [ configuração do conector de ](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) coletor, o `document.id.strategy` parâmetro é configurado para usar o valor da chave da mensagem como o valor do `_id` campo (consulte Propriedades da estratégia de ID do conector de [ coletor](https://www.mongodb.com/docs/kafka-connector/current/sink-connector/configuration-properties/id-strategy/#std-label-sink-configuration-id-strategy)):

```
ConnectorConfiguration:
  document.id.strategy: 'com.mongodb.kafka.connect.sink.processor.id.strategy.ProvidedInKeyStrategy'
```

##### Coleções do Couchbase para coleções do Amazon DocumentDB
<a name="couchbase-collections-to-amazon-documentdb-collections-online"></a>

Configure o conector de [ origem ](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) para transmitir cada coleção do Couchbase em cada escopo para um tópico separado (consulte Opções [ de configuração de ](https://docs.couchbase.com/kafka-connector/current/source-configuration-options.html#couchbase.collections) origem). Por exemplo:

```
ConnectorConfiguration:
  # add couchbase.collections configuration
  couchbase.collections: '<scope 1>.<collection 1>, <scope 1>.<collection 2>, ...'
```

Configure o conector de [ coletor ](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) para transmitir de cada tópico para uma coleção separada do Amazon DocumentDB (consulte Propriedades de configuração do conector de [ coletor](https://github.com/mongodb-labs/mongo-kafka/blob/master/docs/sink.md#sink-connector-configuration-properties)). Por exemplo:

```
ConnectorConfiguration:
  # remove collection configuration  
  #collection: 'test'
  
  # modify topics configuration
  topics: '<bucket>.<scope 1>.<collection 1>, <bucket>.<scope 1>.<collection 2>, ...'

  # add topic.override.%s.%s configurations for each topic 
  topic.override.<bucket>.<scope 1>.<collection 1>.collection: '<collection>'
  topic.override.<bucket>.<scope 1>.<collection 2>.collection: '<collection>'
```

## Validação
<a name="validation"></a>

Esta seção fornece um processo de validação detalhado para verificar a consistência e a integridade dos dados após a migração para o Amazon DocumentDB. As etapas de validação se aplicam independentemente do método de migração.

**Topics**
+ [Verifique se todas as coleções existem no destino](#validation-checklist-step-1)
+ [Verifique a contagem de documentos entre os clusters de origem e de destino](#validation-checklist-step-2)
+ [Compare documentos entre clusters de origem e de destino](#validation-checklist-step-3)

### Verifique se todas as coleções existem no destino
<a name="validation-checklist-step-1"></a>

#### Fonte do Couchbase
<a name="source-verify-collections"></a>

opção 1: banco de trabalho de consulta

```
SELECT RAW `path`
  FROM system:keyspaces
  WHERE `bucket` = '<bucket>'
```

opção 2: ferramenta [ cbq ](https://docs.couchbase.com/server/current/cli/cbq-tool.html)

```
cbq \
  -e <source cluster endpoint> \
  -u <username> \
  -p <password> \
  -q "SELECT RAW `path`
       FROM system:keyspaces
       WHERE `bucket` = '<bucket>'"
```

#### Destino do Amazon DocumentDB
<a name="target-verify-collections"></a>

mongosh (consulte [ Conecte-se ao seu cluster Amazon DocumentDB): ](connect-ec2-manual.html#manual-connect-ec2.connect-use)

```
db.getSiblingDB('<database>')
db.getCollectionNames()
```

### Verifique a contagem de documentos entre os clusters de origem e de destino
<a name="validation-checklist-step-2"></a>

#### Fonte do Couchbase
<a name="source-verify-document-count"></a>

##### Couchbase Server 6.x ou anterior
<a name="source-verify-document-count-couchbase-6x-or-earlier"></a>

opção 1: banco de trabalho de consulta

```
SELECT COUNT(*)
FROM `<bucket>`
```

opção 2: [ cbq ](https://docs.couchbase.com/server/current/cli/cbq-tool.html)

```
cbq \
  -e <source cluster endpoint> \
  -u <username> \
  -p <password> \
  -q "SELECT COUNT(*)
       FROM `<bucket>`"
```

##### Couchbase Server 7.0 ou posterior
<a name="source-verify-document-count-couchbase-70-or-later"></a>

opção 1: banco de trabalho de consulta

```
SELECT COUNT(*)
FROM `<bucket>`.`<scope>`.`<collection>`
```

opção 2: [ cbq ](https://docs.couchbase.com/server/current/cli/cbq-tool.html)

```
cbq \
  -e <source cluster endpoint> \
  -u <username> \
  -p <password> \
  -q "SELECT COUNT(*)
       FROM `<bucket>`.`<scope>`.`<collection>`"
```

#### Destino do Amazon DocumentDB
<a name="target-verify-document-count"></a>

mongosh (consulte [ Conecte-se ao seu cluster Amazon DocumentDB): ](connect-ec2-manual.html#manual-connect-ec2.connect-use)

```
db = db.getSiblingDB('<database>')
db.getCollection('<collection>').countDocuments()
```

### Compare documentos entre clusters de origem e de destino
<a name="validation-checklist-step-3"></a>

#### Fonte do Couchbase
<a name="source-compare-documents"></a>

##### Couchbase Server 6.x ou anterior
<a name="source-compare-documents-couchbase-6x-or-earlier"></a>

opção 1: banco de trabalho de consulta

```
SELECT META().id as _id, *
FROM `<bucket>`
LIMIT 5
```

opção 2: [ cbq ](https://docs.couchbase.com/server/current/cli/cbq-tool.html)

```
cbq \
  -e <source cluster endpoint> \
  -u <username> \
  -p <password> \
  -q "SELECT META().id as _id, *
       FROM `<bucket>`
       LIMIT 5"
```

##### Couchbase Server 7.0 ou posterior
<a name="source-compare-documents-couchbase-70-or-later"></a>

opção 1: banco de trabalho de consulta

```
SELECT META().id as _id, *
FROM `<bucket>`.`<scope>`.`<collection>`
LIMIT 5
```

opção 2: [ cbq ](https://docs.couchbase.com/server/current/cli/cbq-tool.html)

```
cbq \
  -e <source cluster endpoint> \
  -u <username> \
  -p <password> \
  -q "SELECT META().id as _id, *
       FROM `<bucket>`.`<scope>`.`<collection>`
       LIMIT 5"
```

#### Destino do Amazon DocumentDB
<a name="target-compare-documents"></a>

mongosh (consulte [ Conecte-se ao seu cluster Amazon DocumentDB): ](connect-ec2-manual.html#manual-connect-ec2.connect-use)

```
db = db.getSiblingDB('<database>')
db.getCollection('<collection>').find({
  _id: {
    $in: [
      <_id 1>, <_id 2>, <_id 3>, <_id 4>, <_id 5>
    ]
  }
})
```