Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memuat data ke Aurora DSQL
Baik Anda bermigrasi dari database yang ada, mengimpor file dari Amazon Simple Storage Service, atau memuat data dari sistem lokal Anda, Aurora DSQL menyediakan beberapa pendekatan untuk memasukkan data Anda. Bagian ini mencakup alat dan teknik yang direkomendasikan untuk memuat data dari semua ukuran, dari gigabyte hingga ratusan terabyte.
## Memilih pendekatan pemuatan
Aurora DSQL mendukung perintah pemuatan data PostgreSQL standar, tetapi memuat data secara efisien dalam skala memerlukan penanganan paralelisasi, manajemen koneksi, dan pemulihan kesalahan. Tabel berikut merangkum opsi Anda:
| Pendekatan | Terbaik untuk | Pertimbangan-pertimbangan |
| --- | --- | --- |
| Aurora DSQL Loader - Utilitas open source yang memudahkan untuk memparalelkan sisipan saat menggunakan Aurora DSQL | Sebagian besar skenario pemuatan data, terutama migrasi dan impor massal | Menangani paralelisasi, penyatuan koneksi, resolusi konflik, dan otentikasi IAM secara otomatis. Tersedia sebagai kode sumber atau biner. |
| PostgreSQL - Perintah \\copy meta-sisi klien psql | Beban sederhana saat Anda sudah terhubung melalui psql | Membaca file pada klien dan mengalirkan data melalui koneksi; Anda mengelola paralelisasi sendiri |
| INSERTtransaksi - Standar SQL DML | Kumpulan data kecil atau sisipan berbasis aplikasi | Pendekatan paling sederhana tetapi paling lambat untuk data massal |
Untuk sebagian besar tugas pemuatan data, gunakan Aurora DSQL Loader. Ini menangani kompleksitas operasional pemuatan data ke dalam database terdistribusi, termasuk eksekusi paralel di beberapa koneksi dan coba ulang otomatis operasi yang gagal.
## Aurora DSQL Loader
[Aurora DSQL Loader](https://github.com/aws-samples/aurora-dsql-loader) adalah utilitas baris perintah open-source yang dirancang untuk memuat data secara efisien ke dalam cluster Aurora DSQL. Ini mengelola penyatuan koneksi, memparalelkan transfer data di beberapa pekerja, dan menangani konflik dan mencoba ulang secara otomatis.
### Fitur utama
Aurora DSQL Loader menyediakan kemampuan berikut:
**Pemuatan paralel**
Thread pekerja yang dapat dikonfigurasi memungkinkan pemuatan data bersamaan di beberapa koneksi untuk meningkatkan kinerja.
**Pengumpulan koneksi**
Mengelola kumpulan koneksi ke cluster Aurora DSQL Anda, menangani autentikasi IAM dan siklus hidup koneksi secara otomatis.
**Dukungan beberapa format file**
Mendukung CSV (nilai yang dipisahkan koma), TSV (nilai yang dipisahkan tab), dan format kolom Apache Parquet. Loader secara otomatis mendeteksi format file berdasarkan ekstensi URI sumber.
**Inferensi skema otomatis**
Saat digunakan dengan `--if-not-exists` bendera, loader dapat secara otomatis membuat tabel dengan jenis kolom yang sesuai berdasarkan data.
**Penanganan konflik**
Jika tabel target Anda memiliki batasan unik, konfigurasikan cara loader menangani konflik menggunakan `--on-conflict` opsi: lewati duplikat, tambahkan catatan, atau kembalikan kesalahan.
**Toleransi kesalahan**
Percobaan ulang otomatis dan kemampuan dimulainya kembali pekerjaan memastikan bahwa beban yang terputus dapat berlanjut dari titik penghentiannya daripada memulai kembali sepenuhnya.
**Sumber lokal dan S3**
Muat data dari jalur sistem file lokal atau langsung dari bucket Amazon S3 menggunakan S3. URIs
### Prasyarat
Sebelum menggunakan Aurora DSQL Loader, pastikan Anda memiliki yang berikut:
+ Cluster Aurora DSQL aktif dengan titik akhir yang valid.
+ AWS kredensil yang dikonfigurasi melalui peran AWS CLI (**aws configure**), AWS Single Sign-On (**aws sso login**), atau IAM.
+ Izin IAM: `dsql:DbConnectAdmin` atau `dsql:DbConnect` di cluster Aurora DSQL Anda.
+ Untuk sumber S3, izin yang sesuai untuk membaca dari bucket sumber.
### Penginstalan
Unduh rilis terbaru dari [halaman GitHub rilis](https://github.com/aws-samples/aurora-dsql-loader/releases/latest). Binari pra-bangun tersedia untuk platform umum. Untuk petunjuk tentang membangun dari sumber, lihat repositori [Aurora DSQL Loader](https://github.com/aws-samples/aurora-dsql-loader).
### Contoh penggunaan
Contoh berikut menunjukkan kasus penggunaan umum untuk Aurora DSQL Loader.
**Example Memuat file CSV lokal**
Contoh ini memuat file CSV dari sistem file lokal Anda ke dalam tabel yang ada:
```
aurora-dsql-loader load \
--endpoint {{cluster-id}}.dsql.{{region}}.on.aws \
--source-uri {{data.csv}} \
--table {{my_table}}
```
**Example Memuat data dari Amazon S3**
Contoh ini memuat file Parket dari bucket Amazon S3:
```
aurora-dsql-loader load \
--endpoint {{cluster-id}}.dsql.{{region}}.on.aws \
--source-uri s3://{{my-bucket}}/{{data.parquet}} \
--table {{my_table}}
```
**Example Pembuatan tabel otomatis**
Contoh ini membuat tabel baru secara otomatis berdasarkan skema data:
```
aurora-dsql-loader load \
--endpoint {{cluster-id}}.dsql.{{region}}.on.aws \
--source-uri {{data.csv}} \
--table {{my_table}} \
--if-not-exists
```
**Example Memvalidasi sebelum memuat**
Contoh ini memvalidasi konfigurasi Anda tanpa benar-benar memuat data:
```
aurora-dsql-loader load \
--endpoint {{cluster-id}}.dsql.{{region}}.on.aws \
--source-uri {{data.csv}} \
--table {{my_table}} \
--dry-run
```
**Example Melanjutkan beban yang terputus**
Jika operasi pemuatan terganggu, Anda dapat melanjutkannya menggunakan ID pekerjaan dari proses sebelumnya:
```
aurora-dsql-loader load \
--endpoint {{cluster-id}}.dsql.{{region}}.on.aws \
--source-uri {{data.csv}} \
--table {{my_table}} \
--resume-job-id {{job-id}} \
--manifest-dir {{./loader-state}}
```
Saat melanjutkan, loader melewatkan sebagian besar pekerjaan yang sudah selesai tetapi dapat mencoba kembali beberapa catatan. Jika tabel target Anda memiliki batasan unik, gunakan `--on-conflict` opsi untuk menangani duplikat — misalnya, `DO NOTHING` untuk melewatinya atau untuk meningkatkan. `DO UPDATE`
### Opsi baris perintah
Aurora DSQL Loader mendukung opsi baris perintah berikut:
`--endpoint`
(Wajib) Titik akhir cluster Aurora DSQL. Contoh: `{{cluster-id}}.dsql.{{region}}.on.aws`
`--source-uri`
(Wajib) Jalur ke file data. Bisa berupa jalur file lokal atau URI S3 (misalnya,`s3://{{bucket-name}}/{{file.parquet}}`).
`--table`
(Wajib) Nama tabel target dalam database Aurora DSQL Anda.
`--if-not-exists`
(Opsional) Secara otomatis membuat tabel target jika tidak ada. Loader menyimpulkan skema dari data.
`--dry-run`
(Opsional) Validasi konfigurasi dan data tanpa benar-benar memuatnya ke dalam database.
`--resume-job-id`
(Opsional) Lanjutkan operasi beban yang sebelumnya terputus menggunakan ID pekerjaan yang ditentukan.
`--manifest-dir`
(Opsional) Direktori untuk menyimpan status pekerjaan dan manifes, digunakan untuk dimulainya kembali pekerjaan.
`--on-conflict`
(Opsional) Menentukan cara menangani konflik saat memasukkan baris yang melanggar kendala unik pada tabel target. Nilai yang valid adalah `error` (mengembalikan kesalahan), `do-nothing` (lewati baris duplikat), atau `do-update` (perbarui baris yang ada dengan nilai baru).
Untuk daftar lengkap opsi dan parameter konfigurasi tambahan, jalankan:
```
aurora-dsql-loader load --help
```
### Praktik terbaik
+ **Gunakan dry-run untuk validasi** — Selalu uji konfigurasi pemuatan Anda `--dry-run` sebelum memuat data ke dalam tabel produksi.
+ **Tentukan batasan unik untuk dimulainya kembali** - Jika Anda perlu melanjutkan beban yang terputus, tentukan batasan unik pada tabel target Anda dan gunakan opsi untuk menangani catatan yang sudah dimuat. `--on-conflict`
+ **Gunakan Parket untuk kumpulan data besar** — Format kolom Parket biasanya memberikan kompresi yang lebih baik dan pemuatan yang lebih cepat untuk kumpulan data besar dibandingkan dengan CSV atau TSV.
+ **Pertahankan direktori manifes** — Simpan direktori manifes untuk memuat pekerjaan hingga Anda mengonfirmasi pemuatan berhasil diselesaikan, memungkinkan dimulainya kembali jika diperlukan.
+ **Pra-buat tabel bila memungkinkan** - Tentukan tabel target dengan tipe data kolom eksplisit dan kunci utama sebelum memuat data. Skema yang dibuat sebelumnya memberi Anda kontrol atas presisi dan pengindeksan tipe, yang biasanya menghasilkan kinerja kueri yang lebih baik dibandingkan dengan skema yang disimpulkan secara otomatis.
### Pemecahan masalah
Kesalahan autentikasi
Verifikasi AWS kredensil Anda dikonfigurasi dengan benar dan identitas IAM Anda memiliki persyaratan `dsql:DbConnect` atau `dsql:DbConnectAdmin` izin pada kluster target.
Kesalahan akses S3
Pastikan identitas IAM Anda memiliki izin baca S3 yang sesuai untuk bucket sumber dan objek.
Kesalahan inferensi skema
Saat menggunakan`--if-not-exists`, pastikan file data Anda memiliki tipe kolom yang konsisten. Jenis campuran dalam kolom dapat menyebabkan inferensi skema gagal.
Gandakan kesalahan kunci pada resume
Jika Anda mengalami kesalahan kunci duplikat saat melanjutkan pemuatan, tambahkan batasan unik ke tabel target sehingga loader dapat digunakan untuk melewati catatan yang sudah dimuat. `ON CONFLICT DO NOTHING`
Untuk informasi pemecahan masalah tambahan, lihat repositori [Aurora](https://github.com/aws-samples/aurora-dsql-loader) DSQL Loader. GitHub
## Jalur migrasi
Bagian berikut menjelaskan cara memigrasikan data dari sistem sumber umum ke Aurora DSQL.
### Migrasi dari PostgreSQL
Untuk memigrasikan data dari database PostgreSQL yang ada ke Aurora DSQL:
1. Ekspor data Anda dari PostgreSQL ke format CSV atau Parket. Anda dapat menggunakan perintah `COPY` PostgreSQL untuk mengekspor setiap tabel:
```
COPY {{my_table}} TO '{{/path/to/my_table.csv}}' WITH (FORMAT csv, HEADER true);
```
1. Buat tabel target di Aurora DSQL. Anda dapat membuat skema secara manual atau menggunakan `--if-not-exists` flag loader untuk menyimpulkan skema dari data Anda.
1. Muat data yang diekspor menggunakan Aurora DSQL Loader:
```
aurora-dsql-loader load \
--endpoint {{cluster-id}}.dsql.{{region}}.on.aws \
--source-uri {{/path/to/my_table.csv}} \
--table {{my_table}}
```
**Tip**
Untuk migrasi besar, pertimbangkan untuk mengekspor ke format Parket untuk kompresi yang lebih baik dan pemuatan yang lebih cepat. Alat seperti DuckDB dapat mengonversi file CSV ke Parquet secara efisien.
### Migrasi dari MySQL
Untuk memigrasikan data dari MySQL ke Aurora DSQL:
1. Ekspor data Anda dari MySQL ke format CSV `SELECT INTO OUTFILE` menggunakan atau alat **mysqldump** seperti dengan opsi: `--tab`
```
SELECT * FROM {{my_table}}
INTO OUTFILE '{{/path/to/my_table.csv}}'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n';
```
1. Buat tabel target di Aurora DSQL dengan tipe data yang kompatibel dengan PostgreSQL yang sesuai.
1. Muat data yang diekspor menggunakan Aurora DSQL Loader:
```
aurora-dsql-loader load \
--endpoint {{cluster-id}}.dsql.{{region}}.on.aws \
--source-uri {{/path/to/my_table.csv}} \
--table {{my_table}}
```
**catatan**
MySQL dan PostgreSQL memiliki sistem tipe data yang berbeda. Tinjau skema Anda dan sesuaikan tipe data sesuai kebutuhan saat membuat tabel di Aurora DSQL.
### Memuat dari Amazon S3
Jika data Anda sudah ada di Amazon S3, Anda dapat memuatnya secara langsung tanpa mengunduh ke sistem lokal Anda. Aurora DSQL Loader mendukung S3 secara asli: URIs
```
aurora-dsql-loader load \
--endpoint {{cluster-id}}.dsql.{{region}}.on.aws \
--source-uri s3://{{my-bucket}}/{{path/to/data.parquet}} \
--table {{my_table}}
```
Pastikan identitas IAM Anda memiliki `s3:GetObject` izin pada objek sumber.
## Menggunakan PostgreSQL\\ copy
Jika Anda sudah terhubung ke Aurora DSQL melalui `psql` sesi yang menangani otentikasi IAM, Anda dapat menggunakan `\copy` meta-command sisi klien untuk memuat data dari sistem file lokal Anda. Berbeda dengan `COPY` pernyataan sisi server, `\copy` membaca file di mesin klien dan mengalirkan data melalui koneksi yang ada, sehingga tidak diperlukan akses file sisi server. Pendekatan ini bekerja dengan baik untuk beban ulir tunggal yang sederhana.
**Example Memuat file CSV dengan\\ copy**
```
\copy {{my_table}} FROM '{{/path/to/data.csv}}' WITH (FORMAT csv, HEADER true);
```
Saat menggunakan `\copy` secara langsung, Anda bertanggung jawab untuk:
+ Mengelola paralelisasi jika memuat banyak file atau kumpulan data besar
+ Menangani manajemen koneksi dan penyegaran token otentikasi
+ Menerapkan logika coba lagi untuk operasi yang gagal
### Praktik terbaik untuk transaksi INSERT
Saat menggunakan `INSERT` pernyataan untuk memuat data ke Aurora DSQL, ikuti praktik berikut untuk meningkatkan throughput dan keandalan:
+ **Batch rows menjadi multi-row INSERTs** — Kelompokkan beberapa baris ke dalam satu `INSERT` pernyataan untuk mengurangi perjalanan pulang pergi. Misalnya, `INSERT INTO my_table VALUES (1, 'a'), (2, 'b'), (3, 'c')` lebih efisien daripada tiga pernyataan terpisah.
+ **Gunakan kueri berparameter** - Gunakan pernyataan yang disiapkan dengan pengikatan parameter alih-alih rangkaian string. Ini menghindari risiko injeksi SQL dan memungkinkan database untuk menggunakan kembali rencana kueri.
+ **Pertahankan transaksi kecil** — Aurora DSQL menggunakan kontrol konkurensi yang optimis, sehingga transaksi besar yang menyentuh banyak baris lebih mungkin menghadapi konflik. Bertujuan untuk transaksi beberapa ratus baris daripada ribuan.
+ **Implementasikan logika coba ulang** — Kesalahan sementara seperti konflik kontrol konkurensi optimis (OCC) diharapkan dalam sistem terdistribusi. Terapkan backoff eksponensial dengan coba lagi untuk transaksi yang gagal.
+ **Paralelisasi di seluruh koneksi** - Buka beberapa koneksi dan distribusikan sisipan di atasnya. Setiap koneksi dapat memproses subset data yang berbeda secara bersamaan.
Untuk sebagian besar kasus penggunaan, Aurora DSQL Loader menyediakan pendekatan yang lebih sederhana dan lebih kuat untuk pemuatan data.
## Sumber daya tambahan
+ [Aurora DSQL Loader aktif GitHub](https://github.com/aws-samples/aurora-dsql-loader) — Kode sumber, dokumentasi, dan pelacakan masalah
+ [Menghasilkan token otentikasi di Amazon Aurora DSQL](SECTION_authentication-token.md)— Pelajari tentang token otentikasi IAM untuk Aurora DSQL
+ [Mengakses Aurora DSQL dengan klien yang kompatibel dengan PostgreSQL](accessing.md)— Connect ke Aurora DSQL menggunakan berbagai klien dan alat