Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengimpor data ke Oracle di Amazon RDS
Cara Anda mengimpor data ke instans Amazon RDS untuk Oracle DB bergantung pada hal berikut:
+ Jumlah data yang Anda miliki
+ Jumlah objek basis data di basis data Anda
+ Variasi objek basis data di basis data Anda
Misalnya, alat berikut dapat Anda gunakan, tergantung kebutuhan Anda:
+ SQLPengembang Oracle - Impor database 20 MB sederhana.
+ Oracle Data Pump – Mengimpor basis data yang kompleks, atau basis data yang berukuran beberapa ratus megabyte atau beberapa terabyte. Misalnya, Anda dapat mengangkut tablespace dari database lokal ke instans Oracle RDS DB Anda. Anda dapat menggunakan Amazon S3 atau Amazon EFS untuk mentransfer file data dan metadata. Lihat informasi selengkapnya di [Bermigrasi menggunakan tablespace yang dapat dipindahkan Oracle](oracle-migrating-tts.md), [Integrasi Amazon EFS](oracle-efs-integration.md), dan [Integrasi Amazon S3](oracle-s3-integration.md).
+ AWS Database Migration Service (AWS DMS) — Migrasikan database tanpa downtime. Untuk informasi selengkapnya AWS DMS, lihat [Apa itu AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) dan posting blog [Memigrasi database Oracle dengan menggunakan downtime mendekati nol](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/). AWS DMS
**penting**
Sebelum Anda menggunakan teknik migrasi sebelumnya, sebaiknya buat cadangan basis data Anda. Setelah mengimpor data, Anda dapat mencadangkan instans Oracle DB Anda RDS dengan membuat snapshot. Selanjutnya, Anda dapat memulihkan snapshot tersebut. Untuk informasi selengkapnya, lihat [Mencadangkan, memulihkan, dan mengekspor data](CHAP_CommonTasks.BackupRestore.md).
Untuk sebagian besar mesin basis data, replikasi berkelanjutan dapat terus berlangsung hingga Anda siap untuk beralih ke basis data target. Anda dapat menggunakan AWS DMS untuk bermigrasi ke RDS Oracle dari mesin database yang sama atau mesin yang berbeda. Jika Anda bermigrasi dari mesin database yang berbeda, Anda dapat menggunakan objek skema AWS Schema Conversion Tool untuk memigrasi yang AWS DMS tidak bermigrasi.
**Topics**
+ [Mengimpor menggunakan Oracle SQL Developer](Oracle.Procedural.Importing.SQLDeveloper.md)
+ [Bermigrasi menggunakan tablespace yang dapat dipindahkan Oracle](oracle-migrating-tts.md)
+ [Mengimpor menggunakan Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md)
+ [Impor menggunakan Ekspor/Impor Oracle](Oracle.Procedural.Importing.ExportImport.md)
+ [Mengimpor menggunakan Oracle SQL\$1Loader](Oracle.Procedural.Importing.SQLLoader.md)
+ [Bermigrasi dengan tampilan terwujud Oracle](Oracle.Procedural.Importing.Materialized.md)
# Mengimpor menggunakan Oracle SQL Developer
Oracle SQL Developer adalah alat Java grafis yang didistribusikan tanpa biaya oleh Oracle. SQL Developer menyediakan opsi untuk memigrasi data antara dua basis data Oracle, atau untuk memigrasi data dari basis data lain, seperti MySQL, ke basis data Oracle. Alat ini paling baik untuk memigrasi database kecil.
Anda dapat menginstal alat ini di komputer desktop (Windows, Linux, atau Mac) atau di salah satu server Anda. Setelah menginstal SQL Developer, Anda dapat menggunakannya untuk terhubung ke basis data sumber dan target. Gunakan perintah **Database Copy** pada menu Tools untuk menyalin data Anda ke RDS Anda untuk instans Oracle DB.
Untuk mengunduh SQL Developer, kunjungi [http://www.oracle.com/technetwork/developer-tools/sql-developer.](http://www.oracle.com/technetwork/developer-tools/sql-developer)
Sebaiknya baca dokumentasi produk Oracle SQL Developer sebelum Anda mulai memigrasikan data Anda. Oracle juga memiliki dokumentasi terkait cara bermigrasi dari basis data lain, termasuk MySQL dan SQL Server. Untuk informasi selengkapnya, lihat [http://www.oracle.com/technetwork/database/migration](http://www.oracle.com/technetwork/database/migration) dalam dokumentasi Oracle.
# Bermigrasi menggunakan tablespace yang dapat dipindahkan Oracle
Anda dapat menggunakan fitur tablespace yang dapat dipindahkan Oracle untuk menyalin satu set tablespace dari basis data Oracle on-premise ke instans DB RDS for Oracle. Pada tingkat fisik, Anda mentransfer file data sumber dan file metadata ke instans DB target menggunakan Amazon EFS atau Amazon S3. Fitur ruang meja yang dapat diangkut menggunakan paket. `rdsadmin.rdsadmin_transport_util` Untuk sintaks dan semantik paket ini, lihat. [Mengangkut tablespace](rdsadmin_transport_util.md)
Untuk posting blog yang menjelaskan cara mengangkut tablespace, lihat [Memigrasi Database Oracle untuk AWS menggunakan ruang meja yang dapat diangkut dan [Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/amazon-rds-for-oracle-transportable-tablespaces-using-rman/) Transportable Tablespaces](https://aws.amazon.com/blogs/database/migrate-oracle-databases-to-aws-using-transportable-tablespace/) menggunakan RMAN.
**Topics**
+ [Ikhtisar tablespace Oracle yang dapat dipindahkan](#oracle-migrating-tts.overview)
+ [Tahap 1: Siapkan host sumber](#oracle-migrating-tts.setup-phase)
+ [Tahap 2: Siapkan pencadangan tablespace penuh](#oracle-migrating-tts.initial-br-phase)
+ [Tahap 3: Buat dan transfer cadangan inkremental](#oracle-migrating-tts.roll-forward-phase)
+ [Tahap 4: Pindahkan tablespace](#oracle-migrating-tts.final-br-phase)
+ [Tahap 5: Validasi tablespace yang dipindahkan](#oracle-migrating-tts.validate)
+ [Tahap 6: Bersihkan file sisa](#oracle-migrating-tts.cleanup)
## Ikhtisar tablespace Oracle yang dapat dipindahkan
Set tablespace yang dapat dipindahkan terdiri dari file data untuk set tablespace yang dipindahkan dan file dump ekspor yang berisi metadata tablespace. Dalam solusi migrasi fisik seperti tablespace yang dapat dipindahkan, Anda mentransfer file fisik: file data, file konfigurasi, dan file dump Data Pump.
**Topics**
+ [Kelebihan dan kekurangan tablespace yang dapat dipindahkan](#oracle-migrating-tts.overview.benefits)
+ [Batasan tablespace yang dapat dipindahkan](#oracle-migrating-tts.limitations)
+ [Prasyarat untuk tablespace yang dapat dipindahkan](#oracle-migrating-tts.requirements)
### Kelebihan dan kekurangan tablespace yang dapat dipindahkan
Penggunaan tablespace yang dapat dipindahkan disarankan saat Anda perlu memigrasikan satu atau beberapa tablespace besar ke RDS dengan waktu henti minimum. Dibanding migrasi logis, tablespace yang dapat dipindahkan memiliki kelebihan sebagai berikut:
+ Waktu henti lebih rendah dibandingkan solusi migrasi Oracle lainnya.
+ Karena fitur tablespace yang dapat dipindahkan hanya menyalin file fisik, fitur ini mencegah kesalahan integritas data dan kerusakan logis yang dapat terjadi pada migrasi logis.
+ Tidak perlu lisensi tambahan.
+ Anda bisa memigrasikan set tablespace di berbagai platform dan jenis endian, misalnya, dari platform Oracle Solaris ke Linux. Namun, pemindahan tablespace ke dan dari server Windows tidak didukung.
**catatan**
Linux sepenuhnya teruji dan didukung. Tidak semua variasi UNIX telah diuji.
Jika Anda menggunakan tablespace yang dapat dipindahkan, Anda dapat memindahkan data menggunakan Amazon S3 atau Amazon EFS:
+ Saat menggunakan EFS, cadangan Anda tetap berada di sistem file EFS selama impor. Anda dapat menghapus file sesudahnya. Dalam teknik ini, Anda tidak perlu menyediakan penyimpanan EBS untuk instans DB. Karena alasan ini, sebaiknya gunakan Amazon EFS sebagai ganti S3. Untuk informasi selengkapnya, lihat [Integrasi Amazon EFS](oracle-efs-integration.md).
+ Ketika menggunakan S3, Anda mengunduh cadangan RMAN ke penyimpanan EBS yang terhubung ke instans DB Anda. File tetap berada di penyimpanan EBS Anda selama impor. Setelah impor, Anda dapat mengosongkan ruang ini, yang tetap dialokasikan untuk instans DB Anda.
Kekurangan utama dari tablespace yang dapat dipindahkan adalah perlunya pengetahuan yang cukup mendalam tentang Oracle Database. Untuk informasi selengkapnya, lihat [Transporting Tablespaces Between Databases](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-F7B2B591-AA88-4D16-8DCF-712763923FFB) dalam *Panduan Administrator Oracle Database*.
### Batasan tablespace yang dapat dipindahkan
Batasan Oracle Database untuk tablespace yang dapat dipindahkan berlaku ketika Anda menggunakan fitur ini di RDS for Oracle. Untuk informasi selengkapnya, lihat [Limitations on Transportable Tablespaces]( https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-DAB51E42-9BBC-4001-B5CB-0ECDBE128787) dan [General Limitations on Transporting Data](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) dalam *Panduan Administrator Oracle Database*. Ketahui batasan tambahan untuk tablespace yang dapat dipindahkan di RDS for Oracle berikut:
+ Baik sumber maupun basis data target tidak dapat menggunakan Standard Edition 2 (SE2). Hanya mendukung Enterprise Edition.
+ Anda tidak dapat menggunakan basis data Oracle Database 11g sebagai sumber. Fitur tablespace lintas platform yang dapat dipindahkan RMAN bergantung pada mekanisme pemindahan RMAN, yang tidak didukung oleh Oracle Database 11g.
+ Anda tidak dapat memigrasikan data dari instans DB RDS for Oracle menggunakan tablespace yang dapat dipindahkan. Anda hanya dapat menggunakan tablespace yang dapat dipindahkan untuk memigrasikan data ke instans DB RDS for Oracle.
+ Tidak mendukung sistem operasi Windows.
+ Anda tidak dapat memindahkan tablespace ke dalam basis data pada tingkat rilis yang lebih rendah. Basis data target harus berada pada tingkat rilis yang sama atau lebih baru dengan basis data sumber. Sebagai contoh, Anda tidak dapat memindahkan tablespace dari Oracle Database 21c ke Oracle Database 19c.
+ Anda tidak dapat memindahkan tablespace administratif seperti `SYSTEM` dan `SYSAUX`.
+ Anda tidak dapat mengangkut objek non-data seperti PL/SQL paket, kelas Java, tampilan, pemicu, urutan, pengguna, peran, dan tabel sementara. Untuk memindahkan objek non-data, buat secara manual atau gunakan ekspor dan impor metadata Data Pump. Untuk informasi selengkapnya, lihat [My Oracle Support Note 1454872.1](https://support.oracle.com/knowledge/Oracle%20Cloud/1454872_1.html).
+ Anda tidak dapat memindahkan tablespace terenkripsi atau menggunakan kolom terenkripsi.
+ Jika Anda mentransfer file menggunakan Amazon S3, ukuran file maksimum yang didukung adalah 5 TiB.
+ Jika basis data sumber menggunakan opsi Oracle seperti Spatial, Anda hanya dapat memindahkan tablespace jika basis data target mengonfigurasikan opsi yang sama.
+ Anda tidak dapat memindahkan tablespace ke instans DB RDS for Oracle dalam konfigurasi replika Oracle. Sebagai solusinya, Anda dapat menghapus semua replika, memindahkan tablespace, lalu membuat ulang replika.
### Prasyarat untuk tablespace yang dapat dipindahkan
Sebelum memulai, selesaikan tugas berikut:
+ Tinjau persyaratan untuk tablespace yang dapat dipindahkan yang dijelaskan dalam dokumen berikut di Dukungan Oracle Saya:
+ [Reduce Transportable Tablespace Downtime using Cross Platform Incremental Backup (Doc ID 2471245.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1)
+ [Transportable Tablespace (TTS) Restrictions and Limitations: Details, Reference, and Version Where Applicable (Doc ID 1454872.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1454872.1)
+ [Primary Note for Transportable Tablespaces (TTS) -- Common Questions and Issues (Doc ID 1166564.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1166564.1)
+ Rencanakan konversi endian. Jika Anda menentukan ID platform sumber, RDS for Oracle akan otomatis mengonversi endian. Untuk mempelajari cara menemukan platform IDs, lihat [Data Guard Support for Heterogenous Primary and Physical Standbys in Same Data Guard Configuration (Doc ID](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1) 413484.1).
+ Pastikan fitur tablespace yang dapat dipindahkan telah aktif pada instans DB target Anda. Fitur ini hanya diaktifkan jika tidak ada kesalahan `ORA-20304` saat Anda menjalankan kueri berikut:
```
SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
```
Jika fitur tablespace yang dapat dipindahkan tidak diaktifkan, boot ulang instans DB Anda. Untuk informasi selengkapnya, lihat [Mem-boot ulang instans DB DB](USER_RebootInstance.md).
+ Pastikan file zona waktu sama di basis data sumber dan target.
+ Pastikan bahwa set karakter database pada basis data sumber dan target memenuhi salah satu dari persyaratan berikut:
+ Set karakternya sama.
+ Set karakter kompatibel. Untuk daftar persyaratan kompatibilitas, lihat [Batasan Umum tentang Mengangkut Data dalam dokumentasi](https://docs.oracle.com/en/database/oracle/oracle-database/19/spmdu/general-limitations-on-transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) Oracle Database.
+ Jika Anda berencana untuk mentransfer file menggunakan Amazon S3, lakukan hal berikut:
+ Pastikan bucket Amazon S3 tersedia untuk transfer file, dan bucket Amazon S3 berada di Wilayah yang AWS sama dengan instans DB Anda. Untuk mengetahui petunjuknya, lihat [Membuat bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) di *Panduan Memulai Amazon Simple Storage Service*.
+ Siapkan bucket Amazon S3 untuk integrasi Amazon RDS dengan mengikuti petunjuk di [Mengonfigurasi izin IAM untuk integrasi RDS for Oracle dengan Amazon S3](oracle-s3-integration.preparing.md).
+ Jika Anda berencana untuk mentransfer file menggunakan Amazon EFS, pastikan EFS telah dikonfigurasi sesuai dengan petunjuk di [Integrasi Amazon EFS](oracle-efs-integration.md).
+ Sangat disarankan untuk mengaktifkan pencadangan otomatis di instans DB target Anda. Karena [ langkah impor metadata](#oracle-migrating-tts.transport.import-dmp) berpotensi gagal, pastikan instans DB dapat dipulihkan ke kondisi sebelum impor, sehingga tablespace tidak perlu dicadangkan, ditransfer, dan diimpor kembali.
## Tahap 1: Siapkan host sumber
Pada langkah ini, salin skrip tablespace pemindahan yang disediakan oleh Dukungan My Oracle dan siapkan file konfigurasi yang diperlukan. Pada langkah berikut, *host sumber* menjalankan basis data yang berisi tablespace yang akan dipindahkan ke *instans target*.
**Untuk menyiapkan host sumber**
1. Masuk ke host sumber sebagai pemilik beranda Oracle.
1. Pastikan variabel lingkungan `ORACLE_HOME` dan `ORACLE_SID` mengarah ke basis data sumber Anda.
1. Masuk ke basis data sebagai administrator, dan pastikan versi zona waktu, set karakter DB, dan set karakter nasional sama dengan yang ada di basis data target.
```
SELECT * FROM V$TIMEZONE_FILE;
SELECT * FROM NLS_DATABASE_PARAMETERS
WHERE PARAMETER IN ('NLS_CHARACTERSET','NLS_NCHAR_CHARACTERSET');
```
1. Siapkan utilitas tablespace yang dapat dipindahkan seperti yang dijelaskan di [Oracle Support note 2471245.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1).
Penyiapan termasuk mengedit file `xtt.properties` di host sumber Anda. Sampel file `xtt.properties` berikut menetapkan pencadangan tiga tablespace di dalam direktori `/dsk1/backups`. Ketiganya adalah tablespace yang akan Anda pindahkan ke instans DB target. Sampel tersebut juga menentukan ID platform sumber untuk mengonversi endian secara otomatis.
**catatan**
Untuk platform yang valid IDs, lihat [Dukungan Data Guard untuk Siaga Primer dan Fisik Heterogen dalam Konfigurasi Penjaga Data yang Sama (ID Dokumen](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1) 413484.1).
```
#linux system
platformid=13
#list of tablespaces to transport
tablespaces=TBS1,TBS2,TBS3
#location where backup will be generated
src_scratch_location=/dsk1/backups
#RMAN command for performing backup
usermantransport=1
```
## Tahap 2: Siapkan pencadangan tablespace penuh
Pada tahap ini, Anda mencadangkan tablespace untuk pertama kalinya, mentransfer cadangan ke host target, lalu memulihkannya menggunakan prosedur `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`. Setelah tahap ini selesai, cadangan tablespace awal berada di instans DB target Anda dan dapat diperbarui dengan cadangan inkremental.
**Topics**
+ [Langkah 1: Cadangkan tablespace pada host sumber](#oracle-migrating-tts.backup-full)
+ [Langkah 2: Transfer file cadangan ke instans DB target Anda](#oracle-migrating-tts.transfer-full)
+ [Langkah 3: Impor tablespace pada instans DB target Anda](#oracle-migrating-tts.initial-tts-import)
### Langkah 1: Cadangkan tablespace pada host sumber
Pada langkah ini, gunakan skrip `xttdriver.pl` untuk mencadangkan tablespace Anda secara keseluruhan. Output `xttdriver.pl` disimpan dalam variabel lingkungan `TMPDIR`.
**Untuk mencadangkan tablespace**
1. Jika ruang tabel Anda berada dalam mode hanya-baca, masuk ke database sumber Anda sebagai pengguna dengan `ALTER TABLESPACE` hak istimewa, dan tempatkan ruang tabel Anda dalam mode. read/write Jika tidak, lewati ke langkah berikutnya.
Contoh tempat berikut`tbs1`,`tbs2`, dan `tbs3` dalam read/write mode.
```
ALTER TABLESPACE tbs1 READ WRITE;
ALTER TABLESPACE tbs2 READ WRITE;
ALTER TABLESPACE tbs3 READ WRITE;
```
1. Cadangkan tablespace Anda menggunakan skrip `xttdriver.pl`. Secara opsional, Anda dapat menentukan `--debug` untuk menjalankan skrip dalam mode debug.
```
export TMPDIR=location_of_log_files
cd location_of_xttdriver.pl
$ORACLE_HOME/perl/bin/perl xttdriver.pl --backup
```
### Langkah 2: Transfer file cadangan ke instans DB target Anda
Pada langkah ini, salin file cadangan dan konfigurasi dari lokasi awal ke instans DB target. Pilih salah satu opsi berikut:
+ Jika host sumber dan target menggunakan sistem file Amazon EFS yang sama, gunakan utilitas sistem operasi seperti `cp` untuk menyalin file cadangan dan file `res.txt` dari lokasi awal ke direktori bersama. Lalu, langsung ke [Langkah 3: Impor tablespace pada instans DB target Anda](#oracle-migrating-tts.initial-tts-import).
+ Jika Anda perlu melakukan pencadangan ke bucket Amazon S3, selesaikan langkah berikut.
![\[Transfer file menggunakan Amazon S3 atau Amazon EFS.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/oracle-tts.png)
#### Langkah 2.2: Unggah cadangan ke bucket Amazon S3 Anda
Unggah cadangan dan `res.txt` file Anda dari direktori awal ke bucket Amazon S3. Untuk informasi selengkapnya, lihat [Mengunggah objek](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) di *Panduan Pengguna Amazon Simple Storage Service*.
#### Langkah 2.3: Unduh cadangan dari bucket Amazon S3 ke instans DB target
Pada langkah ini, gunakan prosedur `rdsadmin.rdsadmin_s3_tasks.download_from_s3` untuk mengunduh cadangan ke instans DB RDS for Oracle.
**Untuk mengunduh cadangan dari bucket Amazon S3**
1. Mulai SQL\$1Plus atau Oracle SQL Developer dan masuk ke instans DB RDS for Oracle.
1. Unduh cadangan dari bucket Amazon S3 ke instans DB target Anda menggunakan prosedur Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3` untuk d. Contoh berikut ini mengunduh semua file dari bucket Amazon S3 bernama `amzn-s3-demo-bucket` ke direktori `DATA_PUMP_DIR`.
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'res.txt');
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
Pernyataan `SELECT` mengembalikan ID tugas dalam jenis data `VARCHAR2`. Untuk informasi selengkapnya, lihat [Mengunduh file dari bucket Amazon S3 ke instans DB Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Langkah 3: Impor tablespace pada instans DB target Anda
Untuk mengembalikan tablespace Anda ke instans DB target Anda, gunakan prosedur`rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`. Prosedur ini secara otomatis mengonversi file data ke format endian yang benar.
Jika Anda mengimpor dari platform selain Linux, tentukan platform sumber menggunakan parameter `p_platform_id` saat Anda menelepon`import_xtts_tablespaces`. Pastikan ID platform yang Anda tentukan cocok dengan yang ditentukan dalam `xtt.properties` file di[Langkah 2: Ekspor metadata tablespace di host sumber Anda](#oracle-migrating-tts.transport.export).
**Impor tablespace pada instans DB target Anda**
1. Mulai klien Oracle SQL dan masuk ke instans DB RDS for Oracle target Anda sebagai pengguna utama.
1. Jalankan prosedur `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, tentukan tablespace yang akan diimpor dan direktori yang berisi cadangan.
Contoh berikut mengimpor tablespaces*TBS1*,*TBS2*, dan *TBS3* dari direktori. *DATA\$1PUMP\$1DIR* Platform sumbernya adalah Sistem berbasis AIX (64-bit), yang memiliki ID platform. `6` Anda dapat menemukan platform IDs dengan menanyakan`V$TRANSPORTABLE_PLATFORM`.
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
1. (Opsional) Pantau kemajuan dengan membuat kueri tabel `rdsadmin.rds_xtts_operation_info`. Kolom `xtts_operation_state` menampilkan nilai `EXECUTING`, `COMPLETED`, atau `FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**catatan**
Untuk operasi berdurasi panjang, Anda juga dapat membuat kueri `V$SESSION_LONGOPS`, `V$RMAN_STATUS`, dan `V$RMAN_OUTPUT`.
1. Lihat log impor yang telah selesai menggunakan ID tugas dari langkah sebelumnya.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Pastikan impor sudah berhasil sebelum melanjutkan ke langkah berikutnya.
## Tahap 3: Buat dan transfer cadangan inkremental
Pada tahap ini, buat dan transfer cadangan inkremental secara berkala saat basis data sumber aktif. Teknik ini mengurangi ukuran pencadangan akhir tablespace Anda. Jika Anda mengambil beberapa cadangan inkremental, Anda harus menyalin file `res.txt` setelah pencadangan inkremental terakhir sebelum menerapkannya pada instans target.
Langkahnya sama seperti pada [Tahap 2: Siapkan pencadangan tablespace penuh](#oracle-migrating-tts.initial-br-phase), kecuali langkah impor yang sifatnya opsional.
## Tahap 4: Pindahkan tablespace
Pada tahap ini, cadangkan tablespace hanya baca dan ekspor metadata Data Pump, transfer file ini ke host target, dan impor tablespace dan metadata.
**Topics**
+ [Langkah 1: Cadangkan tablespace hanya baca Anda](#oracle-migrating-tts.final-backup)
+ [Langkah 2: Ekspor metadata tablespace di host sumber Anda](#oracle-migrating-tts.transport.export)
+ [Langkah 3: (Hanya Amazon S3) Transfer file cadangan dan ekspor ke instans DB target](#oracle-migrating-tts.transport)
+ [Langkah 4: Impor tablespace pada instans DB target Anda](#oracle-migrating-tts.restore-full)
+ [Langkah 5: Impor metadata tablespace pada instans DB target Anda](#oracle-migrating-tts.transport.import-dmp)
### Langkah 1: Cadangkan tablespace hanya baca Anda
Langkah ini sama dengan [Langkah 1: Cadangkan tablespace pada host sumber](#oracle-migrating-tts.backup-full), dengan satu perbedaan utama: tablespace Anda diubah ke mode hanya baca sebelum dicadangkan untuk terakhir kalinya.
Contoh berikut menempatkan `tbs1`, `tbs2`, dan `tbs3` dalam mode hanya baca.
```
ALTER TABLESPACE tbs1 READ ONLY;
ALTER TABLESPACE tbs2 READ ONLY;
ALTER TABLESPACE tbs3 READ ONLY;
```
### Langkah 2: Ekspor metadata tablespace di host sumber Anda
Ekspor metadata tablespace dengan menjalankan utilitas `expdb` di host sumber Anda. Contoh berikut mengekspor tablespaces*TBS1*,*TBS2*, dan *TBS3* untuk membuang file *xttdump.dmp* dalam direktori. *DATA\$1PUMP\$1DIR*
```
expdp username/pwd \
dumpfile=xttdump.dmp \
directory=DATA_PUMP_DIR \
statistics=NONE \
transport_tablespaces=TBS1,TBS2,TBS3 \
transport_full_check=y \
logfile=tts_export.log
```
Jika *DATA\$1PUMP\$1DIR* merupakan direktori bersama di Amazon EFS, lewati ke[Langkah 4: Impor tablespace pada instans DB target Anda](#oracle-migrating-tts.restore-full).
### Langkah 3: (Hanya Amazon S3) Transfer file cadangan dan ekspor ke instans DB target
Jika Anda menggunakan Amazon S3 untuk melakukan pencadangan tablespace dan file ekspor Data Pump, selesaikan langkah berikut.
#### Langkah 3.1: Unggah cadangan dan file dump dari host sumber ke bucket Amazon S3 Anda
Unggah cadangan dan file dump dari host sumber ke bucket Amazon S3 Anda. Untuk informasi selengkapnya, lihat [Mengunggah objek](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) di *Panduan Pengguna Amazon Simple Storage Service*.
#### Langkah 3.2: Unduh cadangan dan file dump dari bucket Amazon S3 ke instans DB target Anda
Pada langkah ini, gunakan prosedur `rdsadmin.rdsadmin_s3_tasks.download_from_s3` untuk mengunduh cadangan dan file dump ke instans DB RDS for Oracle. Ikuti langkah-langkahnya di [Langkah 2.3: Unduh cadangan dari bucket Amazon S3 ke instans DB target](#oracle-migrating-tts.download-full).
### Langkah 4: Impor tablespace pada instans DB target Anda
Gunakan prosedur `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` untuk memulihkan tablespace. Untuk sintaks dan semantik prosedur ini, lihat [Mengimpor tablespace yang diangkut ke instans DB Anda](rdsadmin_transport_util_import_xtts_tablespaces.md)
**penting**
Setelah impor akhir tablespace selesai, kemudian [impor metadata Oracle Data Pump](#oracle-migrating-tts.transport.export). Jika impor gagal, instans DB harus dikembalikan ke kondisi sebelum terjadi kegagalan. Oleh karena itu, sebaiknya buat snapshot DB untuk instans DB Anda sesuai petunjuk di [Membuat snapshot DB untuk instans DB AZ tunggal untuk Amazon RDS](USER_CreateSnapshot.md). Snapshot akan berisi semua tablespace yang diimpor, jadi jika impor gagal, Anda tidak perlu mengulangi proses pencadangan dan impor.
Jika instans DB target Anda mengaktifkan pencadangan otomatis, dan Amazon RDS tidak mendeteksi adanya snapshot yang valid sebelum impor metadata dilakukan, RDS akan mencoba membuat snapshot. Bergantung pada aktivitas instans Anda, snapshot ini kemungkinan dapat berhasil atau gagal. Jika tidak ada snapshot yang valid atau snapshot tidak dapat dimulai, maka impor metadata akan gagal.
**Impor tablespace pada instans DB target Anda**
1. Mulai klien Oracle SQL dan masuk ke instans DB RDS for Oracle target Anda sebagai pengguna utama.
1. Jalankan prosedur `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, tentukan tablespace yang akan diimpor dan direktori yang berisi cadangan.
Contoh berikut mengimpor tablespaces*TBS1*,*TBS2*, dan *TBS3* dari direktori. *DATA\$1PUMP\$1DIR*
```
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces('TBS1,TBS2,TBS3','DATA_PUMP_DIR');
END;
/
PRINT task_id
```
1. (Opsional) Pantau kemajuan dengan membuat kueri tabel `rdsadmin.rds_xtts_operation_info`. Kolom `xtts_operation_state` menampilkan nilai `EXECUTING`, `COMPLETED`, atau `FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**catatan**
Untuk operasi berdurasi panjang, Anda juga dapat membuat kueri `V$SESSION_LONGOPS`, `V$RMAN_STATUS`, dan `V$RMAN_OUTPUT`.
1. Lihat log impor yang telah selesai menggunakan ID tugas dari langkah sebelumnya.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Pastikan impor sudah berhasil sebelum melanjutkan ke langkah berikutnya.
1. Ambil snapshot DB manual dengan mengikuti petunjuk di [Membuat snapshot DB untuk instans DB AZ tunggal untuk Amazon RDS](USER_CreateSnapshot.md).
### Langkah 5: Impor metadata tablespace pada instans DB target Anda
Pada langkah ini, Anda mengimpor metadata tablespace yang dapat dipindahkan ke dalam instans DB RDS for Oracle menggunakan prosedur `rdsadmin.rdsadmin_transport_util.import_xtts_metadata`. Untuk sintaks dan semantik prosedur ini, lihat [Mengimpor metadata tablespace yang dapat diangkut ke instans DB Anda](rdsadmin_transport_util_import_xtts_metadata.md). Selama operasi, status impor ditunjukkan pada tabel `rdsadmin.rds_xtts_operation_info`.
**penting**
Sebelum mengimpor metadata, sangat disarankan untuk memastikan bahwa snapshot DB telah berhasil dibuat setelah Anda mengimpor tablespace. Jika langkah impor gagal, pulihkan instans DB, atasi kesalahan impor, lalu coba impor kembali.
**Impor metadata Data Pump ke dalam instans DB RDS for Oracle**
1. Mulai klien Oracle SQL dan masuk ke instans DB target Anda sebagai pengguna utama.
1. Buat pengguna yang memiliki skema di tablespace yang dipindahkan, jika pengguna tersebut belum ada.
```
CREATE USER tbs_owner IDENTIFIED BY password;
```
1. Impor metadata, tentukan nama file dump dan lokasi direktorinya.
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
1. (Opsional) Kueri tabel riwayat tablespace yang dapat dipindahkan untuk melihat status impor metadata.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
Setelah operasi selesai, tablespace Anda berada dalam mode hanya baca.
1. (Opsional) Lihat file log.
Contoh berikut mencantumkan konten direktori BDUMP, kemudian membuat kueri log impor.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'BDUMP'));
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-import_xtts_metadata-2023-05-22.01-52-35.560858000.log'));
```
## Tahap 5: Validasi tablespace yang dipindahkan
Dalam langkah opsional ini, Anda memvalidasi ruang tabel yang diangkut menggunakan prosedur`rdsadmin.rdsadmin_rman_util.validate_tablespace`, dan kemudian menempatkan ruang tabel Anda dalam mode. read/write
**Untuk memvalidasi data yang dipindahkan**
1. Mulai SQL\$1Plus atau SQL Developer dan masuk ke instans DB target Anda sebagai pengguna utama.
1. Validasi tablespace menggunakan prosedur `rdsadmin.rdsadmin_rman_util.validate_tablespace`.
```
SET SERVEROUTPUT ON
BEGIN
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS1',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS2',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS3',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
END;
/
```
1. Tempatkan ruang meja Anda dalam read/write mode.
```
ALTER TABLESPACE TBS1 READ WRITE;
ALTER TABLESPACE TBS2 READ WRITE;
ALTER TABLESPACE TBS3 READ WRITE;
```
## Tahap 6: Bersihkan file sisa
Dalam langkah opsional ini, hapus file yang tidak dibutuhkan. Gunakan prosedur `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` untuk membuat daftar file data yang tidak memiliki induk setelah impor tablespace, lalu gunakan prosedur `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` untuk menghapusnya. Untuk sintaks dan semantik prosedur ini, lihat [Mencantumkan file tanpa induk setelah impor tablespace](rdsadmin_transport_util_list_xtts_orphan_files.md) dan [Menghapus file data tanpa induk setelah impor tablespace](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md).
**Untuk membersihkan file sisa**
1. Hapus cadangan lama *DATA\$1PUMP\$1DIR* sebagai berikut:
1. Buat daftar file cadangan dengan menjalankan `rdsadmin.rdsadmin_file_util.listdir`.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'DATA_PUMP_DIR'));
```
1. Hapus cadangan satu per satu dengan memanggil `UTL_FILE.FREMOVE`.
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'backup_filename');
```
1. Jika Anda mengimpor tablespace tetapi tidak mengimpor metadatanya, Anda dapat menghapus file data tanpa induk sebagai berikut:
1. Buat daftar file data tanpa induk yang perlu dihapus. Contoh berikut menjalankan prosedur `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
1. Hapus file tanpa induk dengan menjalankan prosedur `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
Operasi pembersihan menghasilkan file log yang menggunakan format nama `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` dalam direktori `BDUMP`.
1. Baca file log yang dihasilkan pada langkah sebelumnya. Contoh berikut membaca log `rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log`.
```
SELECT *
FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log'));
TEXT
--------------------------------------------------------------------------------
orphan transported datafile datafile_7.dbf deleted.
orphan transported datafile datafile_8.dbf deleted.
```
1. Jika Anda mengimpor tablespace beserta metadatanya, tetapi terjadi kesalahan kompatibilitas atau masalah Oracle Data Pump lainnya, bersihkan file data yang dipindahkan sebagian sebagai berikut:
1. Buat daftar tablespace yang berisi file data yang dipindahkan sebagian dengan kueri `DBA_TABLESPACES`.
```
SQL> SELECT TABLESPACE_NAME FROM DBA_TABLESPACES WHERE PLUGGED_IN='YES';
TABLESPACE_NAME
--------------------------------------------------------------------------------
TBS_3
```
1. Hapus tabelspace dan file data yang dipindahkan sebagian.
```
DROP TABLESPACE TBS_3 INCLUDING CONTENTS AND DATAFILES;
```
# Mengimpor menggunakan Oracle Data Pump
Oracle Data Pump adalah utilitas yang memungkinkan Anda untuk mengekspor data Oracle ke file dump dan mengimpornya ke basis data Oracle lain. Ini adalah pengganti jangka panjang untuk Export/Import utilitas Oracle. Oracle Data Pump adalah cara yang disarankan untuk memindahkan sejumlah besar data dari basis data Oracle ke instans DB Amazon RDS.
Contoh dalam bagian ini menunjukkan satu cara untuk mengimpor data ke dalam basis data Oracle, tetapi Oracle Data Pump mendukung teknik lainnya. Lihat informasi yang lebih lengkap dalam [dokumentasi Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump.html#GUID-501A9908-BCC5-434C-8853-9A6096766B5A).
Contoh dalam bagian ini menggunakan paket `DBMS_DATAPUMP`. Anda dapat menyelesaikan tugas yang sama menggunakan utilitas baris perintah `impdp` dan `expdp` Oracle Data Pump. Anda dapat menginstal utilitas ini pada host jarak jauh sebagai bagian dari instalasi Oracle Client, termasuk Oracle Instant Client. Untuk informasi selengkapnya, lihat [Bagaimana cara menggunakan Oracle Instant Client untuk menjalankan Impor atau Ekspor Data Pump untuk instans DB Amazon RDS for Oracle saya?](https://aws.amazon.com/premiumsupport/knowledge-center/rds-oracle-instant-client-datapump/)
**Topics**
+ [Gambaran umum Oracle Data Pump](#Oracle.Procedural.Importing.DataPump.Overview)
+ [Mengimpor data dengan Oracle Data Pump dan bucket Amazon S3](#Oracle.Procedural.Importing.DataPump.S3)
+ [Mengimpor data dengan Oracle Data Pump dan tautan basis data](#Oracle.Procedural.Importing.DataPump.DBLink)
## Gambaran umum Oracle Data Pump
Oracle Data Pump terdiri dari komponen-komponen berikut:
+ Klien baris perintah dan `expdp` `impdp`
+ `DBMS_DATAPUMP` PL/SQL Paketnya
+ `DBMS_METADATA` PL/SQL Paketnya
Anda dapat menggunakan Oracle Data Pump untuk skenario berikut:
+ Impor data dari basis data Oracle, baik on-premise maupun di sebuah instans Amazon EC2, ke instans DB RDS for Oracle.
+ Impor data dari instans DB RDS for Oracle ke basis data Oracle, baik on-premise maupun di sebuah instans Amazon EC2.
+ Impor data antara instans DB RDS for Oracle, misalnya, untuk memigrasi data dari EC2-Klasik ke VPC.
Untuk mengunduh utilitas Oracle Data Pump, lihat [Unduhan perangkat lunak basis data Oracle](http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html) di situs web Oracle Technology Network. Untuk pertimbangan kompatibilitas ketika memigrasikan antarversi Oracle Database, lihat [dokumentasi Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-BAA3B679-A758-4D55-9820-432D9EB83C68).
### Alur kerja Oracle Data Pump
Biasanya, Anda menggunakan Oracle Data Pump dalam tahapan berikut:
1. Ekspor data Anda ke dalam file dump pada basis data sumber.
1. Unggah file dump Anda ke instans DB RDS for Oracle tujuan Anda. Anda dapat mentransfer menggunakan bucket Amazon S3 atau menggunakan tautan basis data antara dua basis data tersebut.
1. Impor data dari file dump Anda ke instans DB RDS for Oracle.
### Praktik terbaik Oracle Data Pump
Saat Anda menggunakan Oracle Data Pump untuk mengimpor data ke dalam instans RDS for Oracle, kami merekomendasikan praktik terbaik berikut:
+ Lakukan impor dalam mode `schema` atau `table` untuk mengimpor skema dan objek tertentu.
+ Hanya impor skema yang diperlukan oleh aplikasi Anda.
+ Jangan mengimpor dalam mode `full` atau mengimpor skema untuk komponen yang dikelola sistem.
Karena RDS for Oracle tidak mengizinkan akses untuk pengguna administratif `SYS` atau `SYSDBA`, tindakan ini dapat merusak kamus data Oracle dan memengaruhi stabilitas basis data Anda.
+ Saat memuat data dalam jumlah besar, lakukan hal berikut:
1. Transfer file dump ke instans DB RDS for Oracle target.
1. Ambil snapshot DB dari instans Anda.
1. Uji pengimporan untuk memastikan keberhasilannya.
Jika komponen basis data tidak divalidasi, Anda dapat menghapus instans DB dan membuat ulang instans tersebut dari snapshot DB. Instans DB yang dipulihkan mencakup file dump yang ditetapkan pada instans DB saat Anda mengambil snapshot DB.
+ Jangan mengimpor file dump yang dibuat menggunakan parameter ekspor Oracle Data Pump`TRANSPORT_TABLESPACES`, `TRANSPORTABLE`, atau `TRANSPORT_FULL_CHECK`. Instans DB RDS for Oracle tidak mendukung pengimporan file dump ini.
+ Jangan mengimpor file dump yang berisi objek Oracle Scheduler di `SYS`, `SYSTEM` ,`RDSADMIN`, `RDSSEC`, serta `RDS_DATAGUARD`, dan yang termasuk dalam kategori berikut:
+ Tugas
+ Program
+ Jadwal
+ Rantai
+ Aturan
+ Konteks evaluasi
+ Set aturan
Instans DB RDS for Oracle tidak mendukung pengimporan file dump ini.
+ Untuk mengecualikan objek Oracle Scheduler yang tidak didukung, gunakan arahan tambahan selama ekspor Data Pump. Jika Anda menggunakan`DBMS_DATAPUMP`, Anda dapat menambahkan `METADATA_FILTER` tambahan sebelum `DBMS_METADATA.START_JOB`:
```
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
```
Jika Anda menggunakan`expdp`, buat file parameter yang berisi arahan `exclude` sebagaimana ditunjukkan dalam contoh berikut. Kemudian gunakan `PARFILE=parameter_file` dengan perintah `expdp`.
```
exclude=procobj:"IN
(SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)"
```
## Mengimpor data dengan Oracle Data Pump dan bucket Amazon S3
Proses impor berikut menggunakan Oracle Data Pump dan bucket Amazon S3. Langkah-langkahnya adalah sebagai berikut:
1. Ekspor data pada basis data sumber menggunakan paket [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html) Oracle.
1. Tempatkan file dump di bucket Amazon S3.
1. Unduh file dump dari bucket Amazon S3 ke direktori `DATA_PUMP_DIR` pada instans DB RDS for Oracle target.
1. Impor data dari file dump yang disalin ke dalam instans DB RDS for Oracle menggunakan paket `DBMS_DATAPUMP`.
**Topics**
+ [Persyaratan untuk Mengimpor data dengan Oracle Data Pump dan bucket Amazon S3](#Oracle.Procedural.Importing.DataPumpS3.requirements)
+ [Langkah 1: Berikan hak istimewa kepada pengguna basis data pada instans DB target RDS for Oracle](#Oracle.Procedural.Importing.DataPumpS3.Step1)
+ [Langkah 2: Ekspor data ke file dump menggunakan DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpS3.Step2)
+ [Langkah 3: Unggah file dump ke bucket Amazon S3 Anda](#Oracle.Procedural.Importing.DataPumpS3.Step3)
+ [Langkah 4: Unduh file dump dari bucket Amazon S3 Anda ke instans DB target Anda](#Oracle.Procedural.Importing.DataPumpS3.Step4)
+ [Langkah 5: Impor file dump Anda ke instans DB target Anda menggunakan DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpS3.Step5)
+ [Langkah 6: Bersihkan](#Oracle.Procedural.Importing.DataPumpS3.Step6)
### Persyaratan untuk Mengimpor data dengan Oracle Data Pump dan bucket Amazon S3
Proses ini memiliki persyaratan sebagai berikut:
+ Pastikan bucket Amazon S3 tersedia untuk transfer file, dan bucket Amazon S3 Wilayah AWS sama dengan instans DB. Untuk mengetahui petunjuknya, lihat [Membuat bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) di *Panduan Memulai Amazon Simple Storage Service*.
+ Objek yang Anda unggah ke dalam bucket Amazon S3 harus sebesar 5 TB atau kurang. Untuk mengetahui informasi selengkapnya tentang cara menggunakan objek di Amazon S3, lihat [Panduan Pengguna Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingObjects.html).
**catatan**
Jika file dump lebih besar dari 5 TB, Anda dapat menjalankan ekspor Oracle Data Pump dengan opsi paralel. Operasi ini menyebarkan data ke dalam banyak file dump sehingga setiap file tidak melebihi batas 5 TB.
+ Anda harus menyiapkan bucket Amazon S3 untuk integrasi Amazon RDS dengan mengikuti petunjuk di [Mengonfigurasi izin IAM untuk integrasi RDS for Oracle dengan Amazon S3](oracle-s3-integration.preparing.md).
+ Anda harus memastikan bahwa ruang penyimpanan cukup untuk menyimpan file dump pada instans sumber dan instans DB target.
**catatan**
Proses ini mengimpor file dump ke dalam direktori `DATA_PUMP_DIR`, direktori yang telah dikonfigurasi di semua instans DB Oracle. Direktori ini terletak di volume penyimpanan yang sama dengan file data Anda. Saat Anda mengimpor file dump, file data Oracle yang ada menggunakan lebih banyak ruang. Dengan demikian, Anda harus memastikan bahwa instans DB Anda dapat mengakomodasi penggunaan ruang tambahan. File dump yang diimpor tidak secara otomatis dihapus atau dihilangkan dari direktori `DATA_PUMP_DIR`. Untuk menghapus file dump yang diimpor, gunakan [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), yang ada di situs web Oracle.
### Langkah 1: Berikan hak istimewa kepada pengguna basis data pada instans DB target RDS for Oracle
Pada langkah ini, Anda membuat skema yang akan menerima impor data dan memberikan hak istimewa yang diperlukan kepada pengguna.
**Untuk membuat pengguna dan memberikan hak istimewa yang diperlukan pada instans target RDS for Oracle**
1. Gunakan SQL\$1Plus atau Oracle SQL Developer untuk masuk sebagai pengguna master ke instans DB RDS for Oracle tempat data akan diimpor. Lihat informasi yang lebih lengkap tentang cara menghubungi instans Anda di [Terhubung ke instans DB Oracle Anda](USER_ConnectToOracleInstance.md).
1. Buat ruang tabel yang diperlukan sebelum Anda mengimpor data. Untuk informasi selengkapnya, lihat [Membuat dan mengukur ruang meja di RDS untuk Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Buat akun pengguna dan berikan izin serta peran yang diperlukan jika akun pengguna tempat impor data tidak ada. Jika Anda berencana mengimpor data ke dalam beberapa skema pengguna, buat setiap akun pengguna serta berikan hak istimewa dan peran yang diperlukan ke akun tersebut.
Misalnya, pernyataan SQL berikut membuat pengguna baru serta memberikan izin dan peran yang diperlukan untuk mengimpor data ke dalam skema yang dimiliki oleh pengguna ini. Ganti `schema_1` dengan nama skema Anda pada langkah ini dan pada langkah selanjutnya.
```
CREATE USER schema_1 IDENTIFIED BY my_password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**catatan**
Tentukan kata sandi selain perintah yang ditampilkan di sini sebagai praktik terbaik keamanan.
Pernyataan sebelumnya memberi pengguna baru hak istimewa `CREATE SESSION` dan peran `RESOURCE`. Anda mungkin memerlukan hak istimewa dan peran tambahan, tergantung objek basis data yang Anda impor.
### Langkah 2: Ekspor data ke file dump menggunakan DBMS\$1DATAPUMP
Untuk membuat file dump, gunakan paket `DBMS_DATAPUMP`.
**Untuk mengekspor data Oracle ke dalam file dump**
1. Gunakan SQL Plus atau Oracle SQL Developer untuk terhubung dengan instans DB Oracle sumber dengan pengguna administratif. Jika basis data sumber adalah instans DB RDS for Oracle, hubungkan dengan pengguna utama Amazon RDS.
1. Ekspor data dengan memanggil prosedur `DBMS_DATAPUMP`.
Skrip berikut mengekspor skema `SCHEMA_1` ke file dump bernama `sample.dmp` dalam direktori `DATA_PUMP_DIR`. Ganti `SCHEMA_1` dengan nama skema yang ingin Anda ekspor.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT',
job_mode => 'SCHEMA',
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_exp.log',
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**catatan**
Data Pump memulai tugas secara asinkron. Untuk informasi tentang pemantauan tugas Data Pump, lihat [ Monitoring job status](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) dalam dokumentasi Oracle.
1. (Opsional) Lihat konten log ekspor dengan memanggil prosedur `rdsadmin.rds_file_util.read_text_file`. Untuk informasi selengkapnya, lihat [Membaca file di direktori instans DB](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Langkah 3: Unggah file dump ke bucket Amazon S3 Anda
Gunakan prosedur Amazon RDS `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` untuk menyalin file dump ke bucket Amazon S3. Contoh berikut ini mengunggah semua file dari direktori `DATA_PUMP_DIR` ke bucket Amazon S3 bernama `amzn-s3-demo-bucket`.
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
Pernyataan `SELECT` mengembalikan ID tugas dalam jenis data `VARCHAR2`. Untuk informasi selengkapnya, lihat [Mengunggah file dari instans DB RDS for Oracle ke bucket Amazon S3](oracle-s3-integration.using.md#oracle-s3-integration.using.upload).
### Langkah 4: Unduh file dump dari bucket Amazon S3 Anda ke instans DB target Anda
Lakukan langkah ini menggunakan prosedur `rdsadmin.rdsadmin_s3_tasks.download_from_s3` Amazon RDS. Saat Anda mengunduh file ke direktori, prosedur `download_from_s3` melewatkan unduhan jika file bernama identik sudah ada di direktori. Untuk menghapus file dari direktori unduhan, gunakan [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), yang ada di situs web Oracle.
**Untuk mengunduh file dump Anda**
1. Mulai SQL\$1Plus atau Oracle SQL Developer dan login sebagai master di instans DB Oracle target Amazon RDS Anda.
1. Unduh file dump menggunakan prosedur `rdsadmin.rdsadmin_s3_tasks.download_from_s3` Amazon RDS.
Contoh berikut ini mengunduh semua file dari bucket Amazon S3 bernama `amzn-s3-demo-bucket` ke direktori `DATA_PUMP_DIR`.
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
Pernyataan `SELECT` mengembalikan ID tugas dalam jenis data `VARCHAR2`. Untuk informasi selengkapnya, lihat [Mengunduh file dari bucket Amazon S3 ke instans DB Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Langkah 5: Impor file dump Anda ke instans DB target Anda menggunakan DBMS\$1DATAPUMP
Gunakan `DBMS_DATAPUMP` untuk mengimpor skema ke instans DB RDS for Oracle Anda. Opsi tambahan seperti `METADATA_REMAP` mungkin diperlukan.
**Untuk mengimpor data ke instans DB target Anda**
1. Mulai SQL\$1Plus atau SQL Developer dan login sebagai pengguna master ke instans DB RDS for Oracle Anda.
1. Impor data dengan memanggil `DBMS_DATAPUMP` prosedur.
Contoh berikut mengimpor *SCHEMA\$11* data dari `sample_copied.dmp` instans DB target Anda.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**catatan**
Tugas Data Pump dimulai secara asinkron. Untuk informasi tentang pemantauan tugas Data Pump, lihat [ Monitoring job status](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) dalam dokumentasi Oracle. Anda dapat melihat konten log impor menggunakan prosedur `rdsadmin.rds_file_util.read_text_file`. Untuk informasi selengkapnya, lihat [Membaca file di direktori instans DB](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
1. Verifikasi impor data dengan mencantumkan tabel skema pada instans DB target Anda.
Misalnya, kueri berikut mengembalikan jumlah tabel untuk `SCHEMA_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Langkah 6: Bersihkan
Setelah data diimpor, Anda dapat menghapus file yang tidak ingin Anda simpan.
**Untuk menghapus file yang tidak diperlukan**
1. Mulai SQL\$1Plus atau SQL Developer dan login sebagai pengguna master ke instans DB RDS for Oracle Anda.
1. Cantumkan file di `DATA_PUMP_DIR` menggunakan perintah berikut.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
1. Hapus file di `DATA_PUMP_DIR` yang tidak lagi Anda perlukan menggunakan perintah berikut.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','filename');
```
Misalnya, perintah berikut menghapus file bernama `sample_copied.dmp`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
## Mengimpor data dengan Oracle Data Pump dan tautan basis data
Proses impor berikut menggunakan Oracle Data Pump dan paket [DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_FILE_TRANSFER.html) Oracle. Langkah-langkahnya adalah sebagai berikut:
1. Hubungkan basis data Oracle sumber, yang dapat berupa basis data on-premise, instans Amazon EC2, atau instans DB RDS for Oracle.
1. Ekspor data menggunakan paket [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html).
1. Gunakan `DBMS_FILE_TRANSFER.PUT_FILE` untuk menyalin file dump dari basis data Oracle ke direktori `DATA_PUMP_DIR` pada instans DB RDS for Oracle yang terhubung menggunakan tautan basis data.
1. Impor data dari file dump yang disalin ke dalam instans DB RDS for Oracle menggunakan paket ` DBMS_DATAPUMP`.
Proses impor yang menggunakan Oracle Data Pump dan paket `DBMS_FILE_TRANSFER` memiliki langkah-langkah berikut.
**Topics**
+ [Persyaratan untuk mengimpor data dengan Oracle Data Pump dan tautan basis data](#Oracle.Procedural.Importing.DataPumpDBLink.requirements)
+ [Langkah 1: Berikan hak istimewa kepada pengguna pada instans DB target RDS for Oracle](#Oracle.Procedural.Importing.DataPumpDBLink.Step1)
+ [Langkah 2: Berikan hak istimewa kepada pengguna pada basis data sumber](#Oracle.Procedural.Importing.DataPumpDBLink.Step2)
+ [Langkah 3: Buat file dump menggunakan DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpDBLink.Step3)
+ [Langkah 4: Buat tautan basis data ke instans DB target](#Oracle.Procedural.Importing.DataPumpDBLink.Step4)
+ [Langkah 5: Salin file dump yang diekspor ke instans DB target menggunakan DBMS\$1FILE\$1TRANSFER](#Oracle.Procedural.Importing.DataPumpDBLink.Step5)
+ [Langkah 6: Impor file data ke instans DB target menggunakan DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpDBLink.Step6)
+ [Langkah 7: Bersihkan](#Oracle.Procedural.Importing.DataPumpDBLink.Step7)
### Persyaratan untuk mengimpor data dengan Oracle Data Pump dan tautan basis data
Proses ini memiliki persyaratan sebagai berikut:
+ Anda harus memiliki hak istimewa eksekusi pada paket `DBMS_FILE_TRANSFER` dan `DBMS_DATAPUMP`.
+ Anda harus memiliki hak istimewa tulis ke direktori `DATA_PUMP_DIR` pada instans DB sumber.
+ Anda harus memastikan bahwa ruang penyimpanan cukup untuk menyimpan file dump pada instans sumber dan instans DB target.
**catatan**
Proses ini mengimpor file dump ke dalam direktori `DATA_PUMP_DIR`, direktori yang telah dikonfigurasi di semua instans DB Oracle. Direktori ini terletak di volume penyimpanan yang sama dengan file data Anda. Saat Anda mengimpor file dump, file data Oracle yang ada menggunakan lebih banyak ruang. Dengan demikian, Anda harus memastikan bahwa instans DB Anda dapat mengakomodasi penggunaan ruang tambahan. File dump yang diimpor tidak secara otomatis dihapus atau dihilangkan dari direktori `DATA_PUMP_DIR`. Untuk menghapus file dump yang diimpor, gunakan [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), yang ada di situs web Oracle.
### Langkah 1: Berikan hak istimewa kepada pengguna pada instans DB target RDS for Oracle
Untuk memberikan hak istimewa kepada pengguna pada instans DB target RDS for Oracle, lakukan langkah-langkah berikut:
1. Gunakan SQL Plus atau Oracle SQL Developer untuk terhubung dengan instans DB RDS for Oracle yang datanya akan diimpor. Terhubung sebagai pengguna master Amazon RDS. Lihat informasi yang lebih lengkap tentang cara menghubungkan ke instans DB di [Terhubung ke instans DB Oracle Anda](USER_ConnectToOracleInstance.md).
1. Buat ruang tabel yang diperlukan sebelum Anda mengimpor data. Untuk informasi selengkapnya, lihat [Membuat dan mengukur ruang meja di RDS untuk Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Jika akun pengguna untuk impor data tidak ada, buat akun pengguna serta berikan izin dan peran yang diperlukan. Jika Anda berencana mengimpor data ke dalam beberapa skema pengguna, buat setiap akun pengguna serta berikan hak istimewa dan peran yang diperlukan ke akun tersebut.
Misalnya, perintah berikut membuat pengguna baru bernama *schema\$11* dan memberikan izin dan peran yang diperlukan untuk mengimpor data ke dalam skema untuk pengguna ini.
```
CREATE USER schema_1 IDENTIFIED BY my-password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**catatan**
Tetapkan kata sandi selain penggugah (prompt) yang ditampilkan di sini sebagai praktik terbaik keamanan.
Contoh sebelumnya memberi pengguna baru hak istimewa `CREATE SESSION` dan peran `RESOURCE`. Hak istimewa dan peran tambahan mungkin diperlukan bergantung pada objek basis data yang Anda impor.
**catatan**
Ganti `schema_1` dengan nama skema Anda pada langkah ini dan pada langkah selanjutnya.
### Langkah 2: Berikan hak istimewa kepada pengguna pada basis data sumber
Gunakan SQL\$1Plus atau Oracle SQL Developer untuk terhubung ke instans DB RDS for Oracle yang berisi data untuk diimpor. Jika perlu, buat akun pengguna dan berikan izin yang diperlukan.
**catatan**
Jika basis data sumber adalah instans Amazon RDS, Anda dapat melewati langkah ini. Anda menggunakan akun pengguna master Amazon RDS untuk melakukan ekspor.
Perintah berikut membuat pengguna baru dan memberikan izin yang diperlukan.
```
CREATE USER export_user IDENTIFIED BY my-password;
GRANT CREATE SESSION, CREATE TABLE, CREATE DATABASE LINK TO export_user;
ALTER USER export_user QUOTA 100M ON users;
GRANT READ, WRITE ON DIRECTORY data_pump_dir TO export_user;
GRANT SELECT_CATALOG_ROLE TO export_user;
GRANT EXECUTE ON DBMS_DATAPUMP TO export_user;
GRANT EXECUTE ON DBMS_FILE_TRANSFER TO export_user;
```
**catatan**
Tentukan kata sandi selain perintah yang ditampilkan di sini sebagai praktik terbaik keamanan.
### Langkah 3: Buat file dump menggunakan DBMS\$1DATAPUMP
Untuk membuat file dump, lakukan hal berikut:
1. Gunakan SQL\$1Plus atau Oracle SQL Developer untuk terhubung ke instans Oracle sumber dengan pengguna administratif atau pengguna yang Anda buat pada langkah 2. Jika basis data sumber adalah instans DB Amazon RDS for Oracle, hubungkan dengan pengguna utama Amazon RDS.
1. Buat file dump menggunakan utilitas Oracle Data Pump.
Skrip berikut membuat file dump bernama *sampel.dmp* dalam direktori `DATA_PUMP_DIR`.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT' ,
job_mode => 'SCHEMA' ,
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample_exp.log' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl ,
'SCHEMA_EXPR' ,
'IN (''SCHEMA_1'')'
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**catatan**
Tugas Data Pump dimulai secara asinkron. Untuk informasi tentang pemantauan tugas Data Pump, lihat [ Monitoring job status](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) dalam dokumentasi Oracle. Anda dapat melihat konten log ekspor menggunakan prosedur `rdsadmin.rds_file_util.read_text_file`. Untuk informasi selengkapnya, lihat [Membaca file di direktori instans DB](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Langkah 4: Buat tautan basis data ke instans DB target
Buat tautan basis data antara instans sumber Anda dan instans DB target Anda. Instans Oracle lokal Anda harus memiliki konektivitas jaringan ke instans DB untuk membuat tautan basis data dan untuk mentransfer file dump ekspor Anda.
Lakukan langkah ini dengan terhubung ke akun pengguna yang sama dengan langkah sebelumnya.
Jika Anda membuat tautan database antara dua instance DB di dalam VPC atau VPCs peered yang sama, kedua instance DB harus memiliki rute yang valid di antara keduanya. Grup keamanan dari setiap instans DB harus memungkinkan proses masuk dan keluar dari instans DB lainnya. Aturan masuk dan keluar grup keamanan dapat merujuk ke grup keamanan dari VPC yang sama atau VPC terhubung. Untuk informasi selengkapnya, lihat [Menyesuaikan tautan basis data untuk penggunaan instans DB di VPC](Appendix.Oracle.CommonDBATasks.DBLinks.md).
Perintah berikut membuat tautan basis data bernama `to_rds` yang terhubung dengan pengguna master Amazon RDS pada instans DB target.
```
CREATE DATABASE LINK to_rds
CONNECT TO IDENTIFIED BY
USING '(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=)
(PORT=))(CONNECT_DATA=(SID=)))';
```
### Langkah 5: Salin file dump yang diekspor ke instans DB target menggunakan DBMS\$1FILE\$1TRANSFER
Gunakan `DBMS_FILE_TRANSFER` untuk menyalin file dump dari instans basis data sumber ke instans DB target. Skrip berikut menyalin file dump bernama sample.dmp dari instans sumber ke tautan basis data target bernama *to-rds* (yang dibuat pada langkah sebelumnya).
```
BEGIN
DBMS_FILE_TRANSFER.PUT_FILE(
source_directory_object => 'DATA_PUMP_DIR',
source_file_name => 'sample.dmp',
destination_directory_object => 'DATA_PUMP_DIR',
destination_file_name => 'sample_copied.dmp',
destination_database => 'to_rds' );
END;
/
```
### Langkah 6: Impor file data ke instans DB target menggunakan DBMS\$1DATAPUMP
Gunakan Oracle Data Pump untuk mengimpor skema dalam instans DB. Opsi tambahan seperti METADATA\$1REMAP mungkin diperlukan.
Hubungkan ke instans DB dengan akun pengguna master Amazon RDS untuk melakukan impor.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file );
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**catatan**
Tugas Data Pump dimulai secara asinkron. Untuk informasi tentang pemantauan tugas Data Pump, lihat [ Monitoring job status](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) dalam dokumentasi Oracle. Anda dapat melihat konten log impor menggunakan prosedur `rdsadmin.rds_file_util.read_text_file`. Untuk informasi selengkapnya, lihat [Membaca file di direktori instans DB](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
Anda dapat memverifikasi impor data dengan melihat tabel pengguna pada instans DB. Misalnya, kueri berikut mengembalikan jumlah tabel untuk `schema_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Langkah 7: Bersihkan
Setelah data diimpor, Anda dapat menghapus file yang tidak ingin Anda simpan. Anda dapat mencantumkan file di `DATA_PUMP_DIR` menggunakan perintah berikut.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
Untuk menghapus file di `DATA_PUMP_DIR` yang tidak lagi Anda perlukan, gunakan perintah berikut.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','');
```
Misalnya, perintah berikut menghapus file bernama `"sample_copied.dmp"`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
# Impor menggunakan Ekspor/Impor Oracle
Anda dapat mempertimbangkan utilitas Ekspor/Impor Oracle untuk migrasi dalam kondisi berikut:
+ Ukuran data Anda kecil.
+ Tidak memerlukan jenis data seperti binary float dan double.
Proses impor menciptakan objek skema yang diperlukan. Dengan demikian, Anda tidak perlu menjalankan skrip untuk membuat objek sebelumnya.
Cara termudah untuk menginstal utilitas ekspor dan impor Oracle adalah dengan menginstal Oracle Instant Client. Untuk mengunduh perangkat lunak tersebut, buka [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Dokumentasinya bisa dilihat di [Instant Client for SQL\$1Loader, Export, and Import](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965) dalam manual *Oracle Database Utilities*.
**Cara mengekspor tabel lalu mengimpornya**
1. Ekspor tabel dari basis data sumber menggunakan perintah `exp`.
Perintah berikut mengekspor tabel bernama `tab1`, `tab2`, dan `tab3`. File dump-nya adalah `exp_file.dmp`.
```
exp cust_dba@ORCL FILE=exp_file.dmp TABLES=(tab1,tab2,tab3) LOG=exp_file.log
```
Ekspor menciptakan file dump biner yang berisi skema dan data untuk tabel yang ditentukan.
1. Impor skema dan data tersebut ke dalam basis data target menggunakan perintah `imp`.
Perintah berikut mengimpor tabel `tab1`, `tab2`, dan `tab3` dari file dump `exp_file.dmp`.
```
imp cust_dba@targetdb FROMUSER=cust_schema TOUSER=cust_schema \
TABLES=(tab1,tab2,tab3) FILE=exp_file.dmp LOG=imp_file.log
```
Ekspor dan Impor memiliki variasi lain yang mungkin lebih sesuai dengan kebutuhan Anda. Lihat dokumentasi Oracle Database untuk mengetahui detail selengkapnya.
# Mengimpor menggunakan Oracle SQL\$1Loader
Anda dapat mempertimbangkan Oracle SQL\$1Loader untuk basis data besar yang berisi objek dalam jumlah terbatas. Karena proses pengeksporan dari basis data sumber dan pemuatan ke basis data target spesifik untuk skema, contoh berikut membuat objek skema sampel, mengekspor dari sumber, lalu memuat data ke dalam basis data target.
Cara termudah untuk menginstal Oracle SQL\$1Loader adalah dengan menginstal Oracle Instant Client. Untuk mengunduh perangkat lunak tersebut, buka [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Dokumentasinya bisa dilihat di [Instant Client for SQL\$1Loader, Export, and Import](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965) dalam manual *Oracle Database Utilities*.
**Cara mengimpor data menggunakan Oracle SQL\$1Loader**
1. Buat tabel sumber sampel menggunakan pernyataan SQL berikut.
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
```
1. Pada instans DB RDS for Oracle target, buat tabel tujuan untuk memuat data. Klausa `WHERE 1=2` memastikan bahwa Anda menyalin struktur `ALL_OBJECTS` tanpa menyalin baris apa pun.
```
CREATE TABLE customer_1 TABLESPACE users
AS (SELECT 0 AS ID, OWNER, OBJECT_NAME, CREATED
FROM ALL_OBJECTS
WHERE 1=2);
```
1. Ekspor data dari basis data sumber ke file teks. Contoh berikut menggunakan SQL\$1Plus. Untuk data Anda, Anda mungkin perlu membuat skrip yang melakukan ekspor untuk semua objek dalam basis data.
```
ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY/MM/DD HH24:MI:SS'
SET LINESIZE 800 HEADING OFF FEEDBACK OFF ARRAY 5000 PAGESIZE 0
SPOOL customer_0.out
SET MARKUP HTML PREFORMAT ON
SET COLSEP ','
SELECT id, owner, object_name, created
FROM customer_0;
SPOOL OFF
```
1. Buat file kontrol untuk mendeskripsikan data tersebut. Anda mungkin perlu menulis skrip untuk melakukan langkah ini.
```
cat << EOF > sqlldr_1.ctl
load data
infile customer_0.out
into table customer_1
APPEND
fields terminated by "," optionally enclosed by '"'
(
id POSITION(01:10) INTEGER EXTERNAL,
owner POSITION(12:41) CHAR,
object_name POSITION(43:72) CHAR,
created POSITION(74:92) date "YYYY/MM/DD HH24:MI:SS"
)
```
Jika perlu, salin file yang dihasilkan oleh kode sebelumnya ke area penahapan, seperti instans Amazon EC2.
1. Impor data menggunakan SQL\$1Loader dengan nama pengguna dan kata sandi yang sesuai untuk basis data target.
```
sqlldr cust_dba@targetdb CONTROL=sqlldr_1.ctl BINDSIZE=10485760 READSIZE=10485760 ROWS=1000
```
# Bermigrasi dengan tampilan terwujud Oracle
Untuk memigrasikan set data berukuran besar secara efisien, Anda dapat menggunakan replikasi tampilan terwujud Oracle. Dengan replikasi, tabel target tetap dapat sinkron dengan tabel sumber. Dengan demikian, Anda dapat beralih ke Amazon RDS nanti, jika diperlukan.
Sebelum Anda dapat bermigrasi menggunakan tampilan terwujud, pastikan Anda memenuhi persyaratan berikut:
+ Konfigurasikan akses dari basis data target ke basis data sumber. Dalam contoh berikut, aturan akses diaktifkan pada database sumber untuk memungkinkan database target Oracle RDS untuk terhubung ke sumber melalui SQL \$1Net.
+ Buat tautan database dari instance RDS for Oracle DB ke database sumber.
**Cara memigrasikan data menggunakan tampilan terwujud**
1. Buat akun pengguna di sumber dan RDS untuk instance target Oracle yang dapat mengautentikasi dengan kata sandi yang sama. Contoh berikut membuat pengguna bernama `dblink_user`.
```
CREATE USER dblink_user IDENTIFIED BY my-password
DEFAULT TABLESPACE users
TEMPORARY TABLESPACE temp;
GRANT CREATE SESSION TO dblink_user;
GRANT SELECT ANY TABLE TO dblink_user;
GRANT SELECT ANY DICTIONARY TO dblink_user;
```
**catatan**
Tetapkan kata sandi selain penggugah (prompt) yang ditampilkan di sini sebagai praktik terbaik keamanan.
1. Buat tautan database dari instance target RDS untuk Oracle ke instance sumber menggunakan pengguna yang baru dibuat.
```
CREATE DATABASE LINK remote_site
CONNECT TO dblink_user IDENTIFIED BY my-password
USING '(description=(address=(protocol=tcp) (host=my-host)
(port=my-listener-port)) (connect_data=(sid=my-source-db-sid)))';
```
**catatan**
Tetapkan kata sandi selain penggugah (prompt) yang ditampilkan di sini sebagai praktik terbaik keamanan.
1. Uji tautan tersebut:
```
SELECT * FROM V$INSTANCE@remote_site;
```
1. Buat tabel sampel dengan kunci primer dan log tampilan terwujud pada instans sumber.
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
ALTER TABLE customer_0 ADD CONSTRAINT pk_customer_0 PRIMARY KEY (id) USING INDEX;
CREATE MATERIALIZED VIEW LOG ON customer_0;
```
1. Pada target RDS instans Oracle DB, buat tampilan terwujud.
```
CREATE MATERIALIZED VIEW customer_0
BUILD IMMEDIATE REFRESH FAST
AS (SELECT *
FROM cust_dba.customer_0@remote_site);
```
1. Pada target RDS instans Oracle DB, segarkan tampilan terwujud.
```
EXEC DBMS_MVIEW.REFRESH('CUSTOMER_0', 'f');
```
1. Batalkan tampilan terwujud dan sertakan klausa `PRESERVE TABLE` untuk mempertahankan tabel kontainer tampilan terwujud beserta kontennya.
```
DROP MATERIALIZED VIEW customer_0 PRESERVE TABLE;
```
Tabel yang dipertahankan memiliki nama yang sama dengan tampilan terwujud yang dibatalkan.