Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Migrasi dari Couchbase Server
<a name="migration-from-couchbase"></a>

**Topics**
+ [Pengantar](#introduction)
+ [Perbandingan dengan Amazon DocumentDB](#comparison-to-amazon-documentdb)
+ [Penemuan](#discovery)
+ [Perencanaan](#planning)
+ [Migrasi](#migration)
+ [Validasi](#validation)

## Pengantar
<a name="introduction"></a>

Panduan ini menyajikan poin-poin penting yang perlu dipertimbangkan saat bermigrasi dari Couchbase Server ke Amazon DocumentDB. Ini menjelaskan pertimbangan untuk fase penemuan, perencanaan, pelaksanaan, dan validasi migrasi Anda. Ini juga menjelaskan cara melakukan migrasi offline dan online.

## Perbandingan dengan Amazon DocumentDB
<a name="comparison-to-amazon-documentdb"></a>


|  | **Server Couchbase ** | **Amazon DocumentDB** | 
| --- | --- | --- | 
| Organisasi Data  | Di versi 7.0 dan yang lebih baru, data diatur ke dalam bucket, cakupan, dan koleksi. Pada versi sebelumnya, data diatur ke dalam bucket. | Data diatur ke dalam database dan koleksi. | 
| Kompatibilitas  | Ada API terpisah untuk setiap layanan (misalnya data, indeks, pencarian, dll.). Pencarian sekunder menggunakan SQL\+\+ (sebelumnya dikenal sebagai N1QL); bahasa query berdasarkan ANSI-standard SQL sehingga akrab bagi banyak pengembang. | Amazon DocumentDB [ kompatibel dengan API MongoDB. ](compatibility.html) | 
| Arsitektur  | Penyimpanan dilampirkan ke setiap instance cluster. Anda tidak dapat menskalakan komputasi secara independen dari penyimpanan. | Amazon DocumentDB dirancang untuk cloud dan untuk menghindari keterbatasan arsitektur database tradisional. Lapisan [ komputasi dan penyimpanan dipisahkan ](db-clusters-understanding.html) di Amazon DocumentDB dan lapisan komputasi dapat dis [ kalakan secara independen dari penyimpanan. ](how-it-works.html) | 
| Tambahkan kapasitas baca sesuai permintaan  | Cluster dapat diperkecil dengan menambahkan instance. Karena penyimpanan dilampirkan ke instance tempat layanan berjalan, waktu yang diperlukan untuk menskalakan tergantung pada jumlah data yang perlu dipindahkan ke instans baru, atau diseimbangkan kembali. | Anda dapat mencapai penskalaan baca untuk cluster Amazon DocumentDB Anda dengan [ membuat hingga 15 replika Amazon DocumentDB ](db-cluster-manage-performance.html#db-cluster-manage-scaling-reads) di cluster. Tidak ada dampak pada lapisan penyimpanan. | 
| Pulihkan dengan cepat dari kegagalan node  | Cluster memiliki kemampuan failover otomatis tetapi waktu untuk mengembalikan cluster ke kekuatan penuh tergantung pada jumlah data yang perlu dipindahkan ke instance baru. | Amazon DocumentDB dapat [ failover utama ](failover.html) biasanya dalam waktu 30 detik dan mengembalikan cluster kembali ke kekuatan penuh dalam 8-10 menit terlepas dari jumlah data di cluster. | 
| Menskalakan penyimpanan seiring bertambahnya data  | Untuk cluster yang dikelola sendiri, penyimpanan dan iOS tidak skalakan secara otomatis. | Penyimpanan Amazon DocumentDB [ dan iOS dinaikkan secara otomatis](db-cluster-manage-performance.html#db-cluster-manage-scaling-storage). | 
| Cadangkan data tanpa mempengaruhi kinerja  | Pencadangan dilakukan oleh layanan cadangan dan tidak diaktifkan secara default. Karena penyimpanan dan komputasi tidak dipisahkan, dapat berdampak pada kinerja. | Pencadangan Amazon DocumentDB diaktifkan secara default dan tidak dapat dimatikan. Backup ditangani oleh lapisan penyimpanan, sehingga tidak berdampak pada lapisan komputasi. Amazon DocumentDB mendukung [ pemulihan dari snapshot cluster ](backup_restore-restore_from_snapshot.html) dan [ memulihkan ke titik waktu ](backup_restore-point_in_time_recovery.html) tertentu. | 
| Daya tahan data  | Bisa ada maksimal 3 salinan replika data dalam sebuah cluster dengan total 4 salinan. Setiap instance di mana layanan data berjalan akan memiliki salinan data yang aktif dan 1, 2, atau 3 replika. | Amazon DocumentDB menyimpan 6 salinan data tidak peduli berapa banyak instance komputasi yang ada dengan kuorum tulis 4 dan tetap benar. Klien menerima pengakuan setelah lapisan penyimpanan mempertahankan 4 salinan data. | 
| Konsistensi  | Konsistensi langsung untuk K/V operasi didukung. Couchbase SDK mer K/V utekan permintaan ke instance tertentu yang berisi salinan aktif data sehingga setelah pembaruan diakui, klien dijamin untuk membaca pembaruan itu. Replikasi pembaruan ke layanan lain (indeks, pencarian, analitik, acara) akhirnya konsisten. | Replika Amazon DocumentDB akhirnya konsisten. Jika pembacaan konsistensi segera diperlukan, klien dapat membaca dari instance utama. | 
| Replikasi  | Cross-Data Center Replication (XDCR) menyediakan replikasi data aktif yang difilter passive/active dalam banyak topologi: banyak. | [Cluster global Amazon DocumentDB ](global-clusters.html) menyediakan replikasi aktif-pasif dalam topologi 1:many (hingga 10). | 

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

Migrasi ke Amazon DocumentDB memerlukan pemahaman menyeluruh tentang beban kerja database yang ada. Penemuan beban kerja adalah proses menganalisis konfigurasi cluster Couchbase Anda dan karakteristik operasional — kumpulan data, indeks, dan beban kerja — untuk membantu memastikan transisi yang mulus dengan gangguan minimal.

### Konfigurasi klaster
<a name="cluster-configuration"></a>

Couchbase menggunakan arsitektur berpusat layanan di mana setiap kemampuan sesuai dengan layanan. Jalankan perintah berikut terhadap cluster Couchbase Anda untuk menentukan layanan mana yang digunakan (lihat Mendap [ atkan Informasi tentang Node): ](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'
```

Contoh output:

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

Layanan Couchbase meliputi yang berikut:

#### Layanan data (kv)
<a name="data-service-kv"></a>

Layanan data menyediakan read/write akses ke data dalam memori dan pada disk.

Amazon DocumentDB mendukung K/V operasi pada data JSON melalui API [ MongoDB. ](java-crud-operations.html)

#### Layanan kueri (n1ql)
<a name="query-service-n1ql"></a>

Layanan query mendukung query data JSON melalui SQL \+\+.

Amazon DocumentDB mendukung kueri data JSON melalui API MongoDB.

#### Layanan indeks (indeks)
<a name="index-service-index"></a>

Layanan indeks membuat dan memelihara indeks pada data, memungkinkan kueri yang lebih cepat.

Amazon DocumentDB mendukung indeks primer default dan pembuatan indeks sekunder pada data JSON melalui API MongoDB.

#### Layanan pencarian (fts)
<a name="search-service-fts"></a>

Layanan pencarian mendukung pembuatan indeks untuk pencarian teks lengkap.

Fitur pencarian teks lengkap asli Amazon DocumentDB memungkinkan Anda [ melakukan kueri teks dasar pada kumpulan data tekstual besar menggunakan indeks teks tujuan khusus ](text-search.html) dengan menggunakan API. MongoDB Untuk kemampuan lanjutan seperti pencarian fuzzy, pencarian multibahasa, dan pencarian koleksi silang, gunakan integrasi [ Amazon DocumentDB Zero-ETL dengan Amazon Service. OpenSearch ](https://aws.amazon.com/blogs/big-data/amazon-documentdb-zero-etl-integration-with-amazon-opensearch-service-is-now-available/)

#### Layanan analisis (cbas)
<a name="analytics-service-cbas"></a>

Layanan analitik mendukung analisis data JSON hampir secara real-time.

Amazon DocumentDB mendukung kueri ad-hoc pada data JSON melalui API MongoDB. Anda juga dapat [ menjalankan kueri kompleks pada data JSON Anda di Amazon DocumentDB menggunakan Apache Spark yang berjalan di Amazon EM ](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/) R.

#### Layanan Eventing (Eventing)
<a name="eventing-service-eventing"></a>

Layanan eventing mengeksekusi logika bisnis yang ditentukan pengguna sebagai respons terhadap perubahan data.

Amazon DocumentDB mengotomatiskan beban kerja berbasis peristiwa dengan [ memanggil AWS Lambda fungsi setiap kali data berubah dengan cluster Amazon DocumentDB Anda. ](https://docs.aws.amazon.com/lambda/latest/dg/with-documentdb-tutorial.html)

#### Layanan cadangan (cadangan)
<a name="backup-service-backup"></a>

Layanan pencadangan menjadwalkan pencadangan data penuh dan inkremental dan penggabungan cadangan data sebelumnya.

Amazon DocumentDB terus mencadangkan data Anda ke Amazon S3 dengan periode penyimpanan 1—35 hari sehingga Anda dapat dengan cepat memulihkan ke titik mana pun dalam periode retensi cadangan. Amazon DocumentDB juga mengambil snapshot otomatis data Anda sebagai bagian dari proses backup terus menerus ini. Anda juga dapat [ mengelola pencadangan dan pemulihan Amazon DocumentDB dengan AWS Backup. ](https://aws.amazon.com/blogs/storage/manage-backup-and-restore-of-amazon-documentdb-with-aws-backup/).

### Karakteristik operasional
<a name="operational-characteristics"></a>

Gunakan Alat [ Penemuan untuk Couchbase ](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/discovery-tool-for-couchbase) untuk mendapatkan informasi berikut tentang kumpulan data, indeks, dan beban kerja Anda. Informasi ini akan membantu Anda mengukur cluster Amazon DocumentDB Anda.

#### Kumpulan data
<a name="data-set"></a>

Alat ini mengambil bucket, ruang lingkup, dan informasi koleksi berikut:

1. nama bucket

1. jenis ember

1. nama ruang lingkup

1. nama koleksi

1. ukuran total (byte)

1. total item

1. ukuran item (byte)

#### Indeks
<a name="couchbase-indexes"></a>

Alat ini mengambil statistik indeks berikut dan semua definisi indeks untuk semua bucket. Perhatikan bahwa indeks utama dikecualikan karena Amazon DocumentDB secara otomatis membuat indeks utama untuk setiap koleksi.

1. nama bucket

1. nama ruang lingkup

1. nama koleksi

1. nama indeks

1. ukuran indeks (byte)

#### Beban Kerja
<a name="workload"></a>

Alat ini mengambil K/V dan metrik kueri N1QL. K/V nilai metrik dikumpulkan pada tingkat bucket dan metrik SQL\+\+ dikumpulkan di tingkat cluster.

Opsi baris perintah alat adalah sebagai berikut:

```
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>
```

Berikut adalah contoh perintah:

```
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 nilai metrik akan didasarkan pada sampel setiap 10 menit selama seminggu terakhir (lihat metode [ HTTP dan URI](https://docs.couchbase.com/server/current/rest-api/rest-bucket-stats.html#http-method-and-uri)). Nilai metrik SQL\+\+ akan didasarkan pada sampel setiap 1 detik selama 60 detik terakhir (lihat Label [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) Umum). Output dari perintah akan berada di file berikut:

**collection-stats.csv ** - bucket, ruang lingkup, dan informasi koleksi

```
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 ** - nama indeks dan ukuran

```
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 ** — mendapatkan, mengatur, dan menghapus metrik untuk semua bucket

```
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 ** - SQL\+\+ memilih, menghapus, dan memasukkan metrik untuk cluster

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

**indexes- <bucket-name>.txt ** — definisi indeks dari semua indeks dalam bucket. Perhatikan bahwa indeks utama dikecualikan karena Amazon DocumentDB secara otomatis membuat indeks utama untuk setiap koleksi.

```
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`)
...
```

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

Pada fase perencanaan, Anda akan menentukan persyaratan cluster Amazon DocumentDB dan pemetaan bucket, cakupan, dan koleksi Couchbase ke database dan koleksi Amazon DocumentDB.

### Persyaratan cluster Amazon DocumentDB
<a name="amazon-documentdb-cluster-requirements"></a>

Gunakan data yang dikumpulkan dalam fase penemuan untuk mengukur cluster Amazon DocumentDB Anda. Lihat Ukuran [ instans ](best_practices.html#best_practices-instance_sizing) untuk informasi selengkapnya tentang menentukan ukuran cluster Amazon DocumentDB Anda.

### Memetakan bucket, cakupan, dan koleksi ke database dan koleksi
<a name="mapping-buckets-scopes-and-collections-to-databases-and-collections"></a>

Tentukan database dan koleksi yang akan ada di cluster Amazon DocumentDB Anda. Pertimbangkan opsi berikut tergantung pada bagaimana data diatur dalam cluster Couchbase Anda. Ini bukan satu-satunya pilihan, tetapi mereka memberikan titik awal untuk Anda pertimbangkan.

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

##### Bucket Couchbase ke koleksi Amazon DocumentDB
<a name="couchbase-buckets-to-amazon-documentdb-collections"></a>

Migrasikan setiap bucket ke koleksi Amazon DocumentDB yang berbeda. Dalam skenario ini, nilai dokumen Couchbase akan digunakan sebagai `id` nilai Amazon Document `_id` DB.

![Couchbase Server 6.x atau bucket sebelumnya ke koleksi Amazon DocumentDB](https://docs.aws.amazon.com/id_id/documentdb/latest/devguide/images/buckets-to-collections.png)


#### Couchbase Server 7.0 atau yang lebih baru
<a name="couchbase-70-or-later"></a>

##### Koleksi Couchbase ke koleksi Amazon DocumentDB
<a name="couchbase-collections-to-amazon-documentdb-collections"></a>

Migrasikan setiap koleksi ke koleksi Amazon DocumentDB yang berbeda. Dalam skenario ini, nilai dokumen Couchbase akan digunakan sebagai `id` nilai Amazon Document `_id` DB.

![Koleksi Couchbase Server 7.0 atau yang lebih baru ke koleksi Amazon DocumentDB](https://docs.aws.amazon.com/id_id/documentdb/latest/devguide/images/collections-to-collections.png)


## Migrasi
<a name="migration"></a>

### Migrasi indeks
<a name="index-migration"></a>

Migrasi ke Amazon DocumentDB melibatkan transfer tidak hanya data tetapi juga indeks untuk mempertahankan kinerja kueri dan mengoptimalkan operasi database. Bagian ini menguraikan proses langkah demi langkah terperinci untuk memigrasi indeks ke Amazon DocumentDB sambil memastikan kompatibilitas dan efisiensi.

Gunakan [ Amazon Q ](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/chat-with-q.html) (tersedia di AWS Management Console atau IDE Anda) untuk mengonversi `CREATE INDEX` pernyataan SQL\+\+ menjadi perintah Amazon Document `createIndex()` DB.

1. Unggah <bucket name>**file ** index.txt yang dibuat oleh Alat Penemuan untuk Couchbase.

1. Masukkan prompt berikut:

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

Amazon Q akan menghasilkan `createIndex()` perintah Amazon DocumentDB yang setara. Perhatikan bahwa Anda mungkin perlu memperbarui nama koleksi berdasarkan cara Anda memetakan bucket, [ cakupan, dan koleksi Couchbase ke koleksi Amazon DocumentDB. ](#mapping-buckets-scopes-and-collections-to-databases-and-collections)

Contoh:

**indexes-beer-sample.txt **

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

Contoh keluaran Amazon Q (kutipan):

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

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

Untuk indeks apa pun yang tidak dapat dikonversi oleh Amazon Q, lihat M [ engelola indeks dan Indeks Amazon DocumentDB ](managing-indexes.html) dan properti [ indeks untuk ](mongo-apis.html#mongo-apis-index) informasi selengkapnya.

### Refaktor kode untuk menggunakan API MongoDB
<a name="refactor-code-to-use-the-mongodb-apis"></a>

Klien menggunakan SDK Couchbase untuk terhubung ke Couchbase Server. Klien Amazon DocumentDB menggunakan driver MongoDB untuk terhubung ke Amazon DocumentDB. Semua bahasa yang didukung oleh Couchbase SDK juga didukung oleh driver MongoDB. Lihat Driver [ MongoDB ](https://www.mongodb.com/docs/drivers/) untuk informasi lebih lanjut tentang driver untuk bahasa Anda.

Karena API berbeda antara Couchbase Server dan Amazon DocumentDB, Anda perlu memfaktorkan ulang kode Anda untuk menggunakan API MongoDB yang sesuai. Anda dapat menggunakan [ Amazon Q ](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/chat-with-q.html) untuk mengonversi panggilan K/V API dan kueri SQL\+\+ ke API MongoDB yang setara:

1. Unggah file kode sumber.

1. Masukkan prompt berikut:

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

Menggunakan contoh kode [ Python ](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html#hello-couchbase) Hello Couchbase, Amazon Q menghasilkan yang berikut (kutipan):

```
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")
```

Lihat Mengh [ ubungkan secara terprogram ke Amazon DocumentDB ](connect_programmatically.html) untuk contoh menghubungkan ke Amazon DocumentDB dalam Python,, PHP, Go Node.js, Java, C\#/.NET, R, dan Ruby.

### Pilih pendekatan migrasi
<a name="select-the-migration-approach"></a>

Saat memigrasikan data ke Amazon DocumentDB, ada dua opsi:

1. [migrasi offline ](#offline-migration)

1. [migrasi online ](#online-migration)

**catatan**  
Amazon DocumentDB menggunakan `_id` bidang sebagai kunci utama untuk setiap dokumen. Pendekatan migrasi dalam panduan ini menyimpan kunci dokumen Couchbase di lapangan`_id`. Untuk migrasi offline, ini dilakukan melalui `--include-key _id` opsi di`cbexport`. Untuk migrasi online, ini dilakukan melalui konektor Kafka. `ProvidedInKeyStrategy`

#### Migrasi offline
<a name="offline-migration"></a>

Pertimbangkan migrasi offline saat:
+ **Waktu henti dapat diterima: Migrasi ** offline melibatkan penghentian operasi penulisan ke database sumber, mengekspor data, dan kemudian mengimpornya ke Amazon DocumentDB. Proses ini menimbulkan downtime untuk aplikasi Anda. Jika aplikasi atau beban kerja Anda dapat mentolerir periode ketidaktersediaan ini, migrasi offline adalah pilihan yang layak.
+ **Migrasi kumpulan data yang lebih kecil atau melakukan bukti konsep: ** Untuk kumpulan data yang lebih kecil, waktu yang dibutuhkan untuk proses ekspor dan impor relatif singkat, menjadikan migrasi offline metode yang cepat dan sederhana. Ini juga sangat cocok untuk lingkungan pengembangan, pengujian, dan pembuktian konsep di mana waktu henti kurang penting.
+ **Kesederhanaan adalah prioritas: ** Metode offline, menggunakan cbexport dan mongoimport, umumnya merupakan pendekatan yang paling mudah untuk memigrasi data. Ini menghindari kompleksitas pengambilan data perubahan (CDC) yang terlibat dalam metode migrasi online.
+ **Tidak ada perubahan berkelanjutan yang perlu direplikasi: ** Jika database sumber tidak secara aktif menerima perubahan selama migrasi, atau jika perubahan tersebut tidak penting untuk ditangkap dan diterapkan ke target selama proses migrasi, maka pendekatan offline sesuai.

**Topics**
+ [Couchbase Server 6.x atau sebelumnya](#couchbase-6x-or-earlier-offline)
+ [Couchbase Server 7.0 atau yang lebih baru](#couchbase-70-or-later-offline)

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

##### Bucket Couchbase ke koleksi Amazon DocumentDB
<a name="couchbase-bucket-to-amazon-documentdb-collection-offline"></a>

Ekspor data menggunakan [ cbexport json ](https://docs-archive.couchbase.com/server/6.6/tools/cbexport-json.html) untuk membuat dump JSON dari semua data di bucket. Untuk `--format` opsi yang dapat Anda gunakan `lines` atau`list`.

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

Impor data ke koleksi Amazon DocumentDB menggunakan [ mongoimport ](backup_restore-dump_restore_import_export_data.html#backup_restore-dump_restore_import_export_data-mongoimport) dengan opsi yang sesuai untuk mengimpor baris atau daftar:

garis:

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

daftar:

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

##### Couchbase Server 7.0 atau yang lebih baru
<a name="couchbase-70-or-later-offline"></a>

Untuk melakukan migrasi offline, gunakan alat cbexport dan mongoimport:

##### Bucket Couchbase dengan cakupan default dan koleksi default
<a name="couchbase-bucket-with-default-scope-and-default-collection-offline"></a>

Ekspor data menggunakan [ cbexport json ](https://docs.couchbase.com/server/current/tools/cbexport-json.html) untuk membuat dump JSON dari semua koleksi di bucket. Untuk `--format` opsi yang dapat Anda gunakan `lines` atau`list`.

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

Impor data ke koleksi Amazon DocumentDB menggunakan [ mongoimport ](backup_restore-dump_restore_import_export_data.html#backup_restore-dump_restore_import_export_data-mongoimport) dengan opsi yang sesuai untuk mengimpor baris atau daftar:

garis:

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

daftar:

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

##### Koleksi Couchbase ke koleksi Amazon DocumentDB
<a name="couchbase-collections-to-amazon-documentdb-collections-offline"></a>

Ekspor data menggunakan [ cbexport json ](https://docs.couchbase.com/server/current/tools/cbexport-json.html) untuk membuat dump JSON dari setiap koleksi. Gunakan `--include-data` opsi untuk mengekspor setiap koleksi. Untuk `--format` opsi yang dapat Anda gunakan `lines` atau`list`. Gunakan `--collection-field` opsi `--scope-field` dan untuk menyimpan nama cakupan dan koleksi di bidang yang ditentukan di setiap dokumen 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"
```

Karena cbexport menambahkan `_collection` bidang `_scope` dan ke setiap dokumen yang diekspor, Anda dapat menghapusnya dari setiap dokumen dalam file ekspor melalui pencarian dan ganti`sed`, atau metode apa pun yang Anda inginkan.

Impor data untuk setiap koleksi ke koleksi Amazon DocumentDB menggunakan [ mongoimport ](backup_restore-dump_restore_import_export_data.html#backup_restore-dump_restore_import_export_data-mongoimport) dengan opsi yang sesuai untuk mengimpor baris atau daftar:

garis:

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

daftar:

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

#### Migrasi online
<a name="online-migration"></a>

Pertimbangkan migrasi online saat Anda perlu meminimalkan waktu henti dan perubahan yang sedang berlangsung perlu direplikasi ke Amazon DocumentDB hampir secara real time.

Lihat [ Cara melakukan migrasi langsung dari Couchbase ke Amazon DocumentDB untuk mempelajari ](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/migration-utility-for-couchbase) cara melakukan migrasi langsung ke Amazon DocumentDB. Dokumentasi akan memandu Anda melalui penerapan solusi dan melakukan migrasi langsung bucket ke cluster Amazon DocumentDB.

**Topics**
+ [Couchbase Server 6.x atau sebelumnya](#couchbase-6x-or-earlier-online)
+ [Couchbase Server 7.0 atau yang lebih baru](#couchbase-70-or-later-online)

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

##### Bucket Couchbase ke koleksi Amazon DocumentDB
<a name="couchbase-bucket-to-amazon-documentdb-collection-online"></a>

Utilitas [ migrasi untuk Couchbase telah ](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/migration-utility-for-couchbase) dikonfigurasi sebelumnya untuk melakukan migrasi online dari bucket Couchbase ke koleksi Amazon DocumentDB. Melihat [ konfigurasi konektor ](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) wastafel, `document.id.strategy` parameter dikonfigurasi untuk menggunakan nilai kunci pesan sebagai nilai `_id` bidang (lihat [ Properti Strategi Id Konektor Sink](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 atau yang lebih baru
<a name="couchbase-70-or-later-online"></a>

##### Bucket Couchbase dengan cakupan default dan koleksi default
<a name="couchbase-bucket-with-default-scope-and-default-collection-online"></a>

Utilitas [ migrasi untuk Couchbase telah ](https://github.com/awslabs/amazon-documentdb-tools/tree/master/migration/migration-utility-for-couchbase) dikonfigurasi sebelumnya untuk melakukan migrasi online dari bucket Couchbase ke koleksi Amazon DocumentDB. Melihat [ konfigurasi konektor ](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) wastafel, `document.id.strategy` parameter dikonfigurasi untuk menggunakan nilai kunci pesan sebagai nilai `_id` bidang (lihat [ Properti Strategi Id Konektor Sink](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'
```

##### Koleksi Couchbase ke koleksi Amazon DocumentDB
<a name="couchbase-collections-to-amazon-documentdb-collections-online"></a>

Konfigurasikan konektor [ sumber ](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) untuk mengalirkan setiap koleksi Couchbase di setiap lingkup ke topik terpisah (lihat Opsi [ Konfigurasi ](https://docs.couchbase.com/kafka-connector/current/source-configuration-options.html#couchbase.collections) Sumber). Contoh:

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

Konfigurasikan konektor [ wastafel ](https://github.com/awslabs/amazon-documentdb-tools/blob/master/migration/migration-utility-for-couchbase/migration-utility-connectors.yaml) untuk melakukan streaming dari setiap topik ke koleksi Amazon DocumentDB terpisah (lihat [ Properti Konfigurasi Konektor Sink](https://github.com/mongodb-labs/mongo-kafka/blob/master/docs/sink.md#sink-connector-configuration-properties)). Contoh:

```
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>'
```

## Validasi
<a name="validation"></a>

Bagian ini menyediakan proses validasi terperinci untuk memverifikasi konsistensi dan integritas data setelah bermigrasi ke Amazon DocumentDB. Langkah-langkah validasi berlaku terlepas dari metode migrasi.

**Topics**
+ [Verifikasi bahwa semua koleksi ada di target](#validation-checklist-step-1)
+ [Verifikasi jumlah dokumen antara cluster sumber dan target](#validation-checklist-step-2)
+ [Bandingkan dokumen antara cluster sumber dan target](#validation-checklist-step-3)

### Verifikasi bahwa semua koleksi ada di target
<a name="validation-checklist-step-1"></a>

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

opsi 1: meja kerja kueri

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

opsi 2: alat [ 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>'"
```

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

mongosh (lihat Menghubun [ gkan ke cluster Amazon DocumentDB Anda): ](connect-ec2-manual.html#manual-connect-ec2.connect-use)

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

### Verifikasi jumlah dokumen antara cluster sumber dan target
<a name="validation-checklist-step-2"></a>

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

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

opsi 1: meja kerja kueri

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

opsi 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 atau yang lebih baru
<a name="source-verify-document-count-couchbase-70-or-later"></a>

opsi 1: meja kerja kueri

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

opsi 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>`"
```

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

mongosh (lihat Menghubun [ gkan ke cluster Amazon DocumentDB Anda): ](connect-ec2-manual.html#manual-connect-ec2.connect-use)

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

### Bandingkan dokumen antara cluster sumber dan target
<a name="validation-checklist-step-3"></a>

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

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

opsi 1: meja kerja kueri

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

opsi 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 atau yang lebih baru
<a name="source-compare-documents-couchbase-70-or-later"></a>

opsi 1: meja kerja kueri

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

opsi 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"
```

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

mongosh (lihat Menghubun [ gkan ke cluster Amazon DocumentDB Anda): ](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>
    ]
  }
})
```