Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Importazione di dati in Oracle in Amazon RDS
La modalità di importazione dei dati in un'istanza database Amazon RDS per Oracle dipende da quanto segue:
+ La quantità di dati disponibili
+ Il numero di oggetti di database esistenti nel database
+ La varietà di oggetti di database esistenti nel database
Ad esempio, puoi usare i seguenti strumenti, a seconda delle esigenze:
+ Oracle SQL Developer: importazione di un database semplice da 20 MB.
+ Oracle Data Pump: importazione di database complessi o database con dimensioni di diverse centinaia di megabyte o diversi terabyte. Ad esempio, è possibile trasportare tablespace da un database on-premise all'istanza database RDS per Oracle. È possibile usare Amazon S3 o Amazon EFS per trasferire i file di dati e i metadati. Per ulteriori informazioni, consulta [Migrazione utilizzando le tablespace trasportabili Oracle](oracle-migrating-tts.md), [Integrazione Amazon EFS](oracle-efs-integration.md) e [Integrazione Amazon S3](oracle-s3-integration.md).
+ AWS Database Migration Service (AWS DMS): migrazione dei database senza tempi di inattività. Per ulteriori informazioni su AWS DMS, consulta [Che cos'è AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) e il post del blog [Migrazione di database Oracle con tempi di inattività quasi zero utilizzando AWS DMS](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/).
**Importante**
Prima di utilizzare le tecniche di migrazione precedentemente descritte, è consigliabile eseguire il backup del database. Dopo avere importato i dati, puoi eseguire il backup delle istanze database RDS per Oracle creando snapshot. Successivamente, è possibile ripristinare gli snapshot. Per ulteriori informazioni, consulta [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md).
Per molti motori di database, la replica continua può continuare fino a quando non si è pronti per passare al database di destinazione. È possibile utilizzare AWS DMS per eseguire la migrazione a RDS per Oracle dallo stesso motore di database o da un motore diverso. Se esegui la migrazione da un motore di database diverso, puoi utilizzare AWS Schema Conversion Tool per la migrazione degli oggetti dello schema non migrati da AWS DMS.
**Topics**
+ [Importazione utilizzando Oracle SQL Developer](Oracle.Procedural.Importing.SQLDeveloper.md)
+ [Migrazione utilizzando le tablespace trasportabili Oracle](oracle-migrating-tts.md)
+ [Importazione utilizzando Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md)
+ [Importazione con le utilità Oracle di esportazione/importazione](Oracle.Procedural.Importing.ExportImport.md)
+ [Importazione utilizzando Oracle SQL\$1Loader](Oracle.Procedural.Importing.SQLLoader.md)
+ [Migrazione con le viste materializzate Oracle](Oracle.Procedural.Importing.Materialized.md)
# Importazione utilizzando Oracle SQL Developer
Oracle SQL Developer è uno strumento Java grafico distribuito gratuitamente da Oracle. SQL Developer fornisce opzioni per la migrazione dei dati tra due database Oracle oppure per la migrazione dei dati da altri database, come MySQL, a Oracle. Questo strumento è ideale per la migrazione di database di piccole dimensioni.
Puoi installare questo strumento nel computer desktop (Windows, Linux o Mac) o in uno dei server. Dopo avere installato SQL Developer, puoi utilizzarlo per connetterti ai database di origine e di destinazione. Utilizza il comando **Database Copy** del menu Tools per copiare i dati nell’istanza database RDS per Oracle.
Per scaricare SQL Developer, vai alla pagina [http://www.oracle.com/technetwork/developer-tools/sql-developer](http://www.oracle.com/technetwork/developer-tools/sql-developer).
Prima di iniziare la migrazione dei dati, è consigliabile leggere la documentazione di Oracle SQL Developer. Oracle fornisce anche la documentazione relativa alla migrazione da altri database, tra cui MySQL e SQL Server. Per ulteriori informazioni, consulta [http://www.oracle.com/technetwork/database/migration](http://www.oracle.com/technetwork/database/migration) nella documentazione di Oracle.
# Migrazione utilizzando le tablespace trasportabili Oracle
È possibile utilizzare la funzionalità Oracle Tablespace trasportabile per copiare un set di tablespace da un database Oracle on-premise a un'istanza RDS per Oracle DB. A livello fisico, trasferisci file di dati e metadati di origine nell’istanza database di destinazione utilizzando Amazon EFS o Amazon S3. La funzionalità relativa ai tablespace trasportabili utilizza il pacchetto `rdsadmin.rdsadmin_transport_util`. Per la sintassi e la semantica di questo pacchetto, consulta [Trasporto di tablespace](rdsadmin_transport_util.md).
Per i post di blog che spiegano come trasportare le tablespace, consulta [Migrare i database Oracle verso l'utilizzo di tablespace trasportabili e [Amazon RDS for Oracle Transportable Tablespaces AWS usando RMAN](https://aws.amazon.com/blogs/database/amazon-rds-for-oracle-transportable-tablespaces-using-rman/)](https://aws.amazon.com/blogs/database/migrate-oracle-databases-to-aws-using-transportable-tablespace/).
**Topics**
+ [Panoramica delle tablespace trasportabili Oracle](#oracle-migrating-tts.overview)
+ [Fase 1: configurazione dell'host di origine](#oracle-migrating-tts.setup-phase)
+ [Fase 2: preparazione del backup completo delle tablespace](#oracle-migrating-tts.initial-br-phase)
+ [Fase 3: creazione e trasferimento dei backup incrementali](#oracle-migrating-tts.roll-forward-phase)
+ [Fase 4: trasporto delle tablespace](#oracle-migrating-tts.final-br-phase)
+ [Fase 5: convalida delle tablespace trasportate](#oracle-migrating-tts.validate)
+ [Fase 6: rimozione dei file residui](#oracle-migrating-tts.cleanup)
## Panoramica delle tablespace trasportabili Oracle
Un set di tablespace trasportabili è composto da file di dati per il set di tablespace da trasportare e da un file di dump di esportazione contenente i metadati delle tablespace. In una soluzione di migrazione fisica come le tablespace trasportabili, si trasferiscono file fisici, ovvero file di dati, file di configurazione e file di dump di Data Pump.
**Topics**
+ [Vantaggi e svantaggi delle tablespace trasportabili](#oracle-migrating-tts.overview.benefits)
+ [Limitazioni relative alle tablespace trasportabili](#oracle-migrating-tts.limitations)
+ [Prerequisiti per le tablespace trasportabili](#oracle-migrating-tts.requirements)
### Vantaggi e svantaggi delle tablespace trasportabili
Si consiglia di utilizzare tablespace trasportabili quando è necessario eseguire la migrazione di una o più tablespace di grandi dimensioni su RDS con tempi di inattività minimi. Rispetto alla migrazione logica, le tablespace trasportabili offrono i seguenti vantaggi:
+ I tempi di inattività sono inferiori rispetto alla maggior parte delle altre soluzioni di migrazione Oracle.
+ Poiché la funzionalità Tablespace trasportabile copia solo i file fisici, vengono evitati gli errori di integrità dei dati e il danneggiamento logico che si possono verificare nella migrazione logica.
+ Non è richiesta alcuna licenza aggiuntiva.
+ È possibile eseguire la migrazione di un set di tablespace su diverse piattaforme e tipi di endianità, ad esempio, da una piattaforma Oracle Solaris a Linux. Tuttavia, il trasporto di tablespace da e verso i server Windows non è supportato.
**Nota**
Linux è completamente testato e supportato. Non tutte le varianti di UNIX sono state testate.
Se vengono utilizzate tablespace trasportabili, è possibile trasportare i dati utilizzando Amazon S3 o Amazon EFS:
+ In caso di utilizzo di EFS, i backup rimangono nel file system EFS per tutta la durata dell'importazione. È possibile rimuovere i file in seguito. Con questa tecnica, non è necessario effettuare il provisioning dello spazio di archiviazione EBS per l'istanza database. Per questo motivo, è consigliabile utilizzare Amazon EFS anziché S3. Per ulteriori informazioni, consulta [Integrazione Amazon EFS](oracle-efs-integration.md).
+ In caso di utilizzo di S3, è sufficiente scaricare i backup RMAN nello spazio di archiviazione EBS associato all'istanza database. I file rimangono nello spazio di archiviazione EBS durante l'importazione. Dopo l'importazione, è possibile liberare questo spazio, che rimane allocato all'istanza database.
Lo svantaggio principale delle tablespace trasportabili è dato dal fatto che è necessaria una conoscenza relativamente avanzata del database Oracle. Per ulteriori informazioni, consulta l'argomento relativo al [trasporto delle tablespace tra database](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-F7B2B591-AA88-4D16-8DCF-712763923FFB) nel manuale *Oracle Database Administrator's Guide* (Guida per gli amministratori di Oracle Database).
### Limitazioni relative alle tablespace trasportabili
Le limitazioni di Oracle Database per le tablespace trasportabili si applicano se si utilizza questa funzionalità in RDS per Oracle. Per ulteriori informazioni, consulta l'argomento relativo alle [limitazioni delle tablespace trasportabili]( https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-DAB51E42-9BBC-4001-B5CB-0ECDBE128787) e alle [limitazioni generali relative al trasporto dei dati](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) nel manuale *Oracle Database Administrator's Guide*. È opportuno considerare le seguenti limitazioni aggiuntive per le tablespace trasportabili in RDS per Oracle:
+ Né il database di origine né quello di destinazione possono utilizzare Standard Edition 2 (). SE2 È supportata solo la versione Enterprise Edition.
+ Non è possibile utilizzare un database Oracle Database 11g come origine. La funzionalità di tablespace trasportabili multipiattaforma di RMAN si basa sul meccanismo di trasporto RMAN, che non è supportato da Oracle Database 11g.
+ Non è possibile eseguire la migrazione dei dati da un'istanza database RDS per Oracle utilizzando le tablespace trasportabili. È possibile utilizzare solo tablespace trasportabili per eseguire la migrazione dei dati su un'istanza database RDS per Oracle.
+ Il sistema operativo Windows non è supportato.
+ Non è possibile effettuare il trasporto delle tablespace in un database di una versione inferiore. Il database di destinazione deve essere della stessa versione o di una versione successiva rispetto al database di origine. Ad esempio, non è possibile effettuare il trasporto delle tablespace da Oracle Database 21c a Oracle Database 19c.
+ Non è possibile effettuare il trasporto delle tablespace amministrative, ad esempio `SYSTEM` e `SYSAUX`.
+ Non è possibile trasportare oggetti non contenenti dati come PL/SQL pacchetti, classi Java, viste, trigger, sequenze, utenti, ruoli e tabelle temporanee. Per trasportare oggetti non contenenti dati, creali manualmente o utilizza la funzionalità di esportazione e importazione dei metadati di Data Pump. Per ulteriori informazioni, consulta il [documento 1454872.1 di My Oracle Support](https://support.oracle.com/knowledge/Oracle%20Cloud/1454872_1.html).
+ Non è possibile effettuare il trasporto di tablespace crittografate o utilizzare colonne crittografate.
+ In caso di trasferimento di file utilizzando Amazon S3, la dimensione massima supportata è di 5 TiB.
+ Se il database di origine utilizza opzioni Oracle come Spatial (Spaziale), non è possibile effettuare il trasporto delle tablespace a meno che le stesse opzioni non siano configurate anche nel database di destinazione.
+ Non è possibile effettuare il trasporto delle tablespace in un'istanza database RDS per Oracle in una configurazione di replica Oracle. Come soluzione alternativa, è possibile eliminare tutte le repliche, effettuare il trasporto delle tablespace e quindi ricreare le repliche.
### Prerequisiti per le tablespace trasportabili
Prima di iniziare, completa le seguenti attività:
+ Fare riferimento ai requisiti per le tablespace trasportabili descritti nei seguenti documenti in My Oracle Support:
+ [Reduce Transportable Tablespace Downtime using Cross Platform Incremental Backup (Doc ID 2471245.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1) (Riduzione dei tempi di inattività delle tablespace trasportabili utilizzando il backup incrementale multipiattaforma [ID documento 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) (Restrizioni e limitazioni relative alle tablespace trasportabili (TTS): dettagli, riferimento e versione laddove applicabile [ID documento 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) (Nota principale per le tablespace trasportabili (TTS) – Domande e problemi comuni [ID documento 1166564.1])
+ Piano per la conversione endianness. Se specifichi l'ID della piattaforma di origine, RDS per Oracle converte automaticamente l'endianness. Per informazioni su come trovare la piattaforma IDs, consulta [Data Guard Support per standby primari e fisici eterogenei nella stessa configurazione Data Guard (](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1)ID doc 413484.1).
+ Assicurarsi che la funzionalità Tablespace trasportabile sia abilitata nell'istanza database di destinazione. La funzionalità è abilitata solo se non vengono visualizzati errori `ORA-20304` quando si esegue la seguente query:
```
SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
```
Se la funzionalità Tablespace trasportabile non è abilitata, riavviare l'istanza database. Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
+ Assicurati che il file di fuso orario corrisponda al database di origine e destinazione.
+ Assicurati che i set di caratteri del database di origine e di quello di destinazione soddisfino uno dei seguenti requisiti:
+ I set di caratteri sono gli stessi.
+ I set di caratteri sono compatibili. Per un elenco dei requisiti di compatibilità, consulta [General Limitations on Transporting Data](https://docs.oracle.com/en/database/oracle/oracle-database/19/spmdu/general-limitations-on-transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) nella documentazione di Oracle Database.
+ Se si prevede di trasferire file utilizzando Amazon S3, procedere come segue:
+ Assicurati che sia disponibile un bucket Amazon S3 per i trasferimenti di file e che il bucket Amazon S3 si trovi nella stessa AWS regione dell'istanza DB. Per istruzioni, consultare [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) nella *Guida introduttiva di Amazon Simple Storage Service*.
+ Preparare il bucket Amazon S3 per l'integrazione con Amazon RDS seguendo le istruzioni in [Configurazione delle autorizzazioni IAM per l'integrazione di RDS per Oracle con Amazon S3](oracle-s3-integration.preparing.md).
+ Se si prevede di trasferire file utilizzando Amazon EFS, assicurarsi di aver configurato EFS secondo le istruzioni riportate in [Integrazione Amazon EFS](oracle-efs-integration.md).
+ È vivamente consigliabile di attivare i backup automatici nell'istanza database di destinazione. Poiché la [fase di importazione dei metadati](#oracle-migrating-tts.transport.import-dmp) può potenzialmente non riuscire, è importante poter ripristinare lo stato dell'istanza database precedente all'importazione, evitando così la necessità di eseguire nuovamente il backup, il trasferimento e l'importazione delle tablespace.
## Fase 1: configurazione dell'host di origine
In questo passaggio, si copiano gli script delle tablespace di trasporto forniti da My Oracle Support e si impostano i file di configurazione necessari. Nei passaggi seguenti, l'*host di origine* esegue il database contenente le tablespace da trasportare nell'*istanza di destinazione*.
**Configurazione dell'host di origine**
1. Accedere all'host di origine come proprietario della Oracle home.
1. Assicurarsi che le variabili di ambiente `ORACLE_HOME` e `ORACLE_SID` puntino al database di origine.
1. Accedere al database come amministratore e verificare che la versione del fuso orario, il set di caratteri del database e il set di caratteri nazionali siano gli stessi del database di destinazione.
```
SELECT * FROM V$TIMEZONE_FILE;
SELECT * FROM NLS_DATABASE_PARAMETERS
WHERE PARAMETER IN ('NLS_CHARACTERSET','NLS_NCHAR_CHARACTERSET');
```
1. Configurare l'utilità Tablespace trasportabile come descritto in [Oracle Support note 2471245.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1) (Nota del Supporto Oracle 2471245.1).
La configurazione include la modifica del file `xtt.properties` sull'host di origine. Il file `xtt.properties` di esempio seguente specifica i backup delle tre tablespace nella directory `/dsk1/backups`. Si tratta delle tablespace da trasportare nell'istanza database di destinazione. Specifica inoltre l'ID della piattaforma di origine per convertire automaticamente l'endiannes.
**Nota**
Per una piattaforma valida IDs, consulta [Data Guard Support per standby primari e fisici eterogenei nella stessa configurazione Data Guard (](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1)ID doc 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
```
## Fase 2: preparazione del backup completo delle tablespace
In questa fase, si esegue il backup delle tablespace per la prima volta, si trasferiscono i backup sull'host di destinazione e quindi li si ripristina utilizzando la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`. Dopo aver completato questa fase, i backup iniziali delle tablespace si trovano nell'istanza database di destinazione e possono essere aggiornati mediante backup incrementali.
**Topics**
+ [Passaggio 1: esecuzione del backup delle tablespace sull'host di origine](#oracle-migrating-tts.backup-full)
+ [Passaggio 2: trasferimento dei file di backup nell'istanza database di destinazione](#oracle-migrating-tts.transfer-full)
+ [Passaggio 3: importazione delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.initial-tts-import)
### Passaggio 1: esecuzione del backup delle tablespace sull'host di origine
In questo passaggio, si utilizza lo script `xttdriver.pl` per eseguire un backup completo delle tablespace. L'output di `xttdriver.pl` è archiviato nella variabile di ambiente `TMPDIR`.
**Esecuzione del backup delle tablespace**
1. Se i tablespace sono in modalità di sola lettura, accedi al database di origine come utente con il privilegio e imposta i tablespace in modalità. `ALTER TABLESPACE` read/write Altrimenti, passare alla fase successiva.
L'esempio seguente posiziona e in modalità. `tbs1` `tbs2` `tbs3` read/write
```
ALTER TABLESPACE tbs1 READ WRITE;
ALTER TABLESPACE tbs2 READ WRITE;
ALTER TABLESPACE tbs3 READ WRITE;
```
1. Eseguire il backup delle tablespace utilizzando lo script `xttdriver.pl`. Facoltativamente, è possibile specificare `--debug` per eseguire lo script in modalità di debug.
```
export TMPDIR=location_of_log_files
cd location_of_xttdriver.pl
$ORACLE_HOME/perl/bin/perl xttdriver.pl --backup
```
### Passaggio 2: trasferimento dei file di backup nell'istanza database di destinazione
In questo passaggio, vengono copiati i file di backup e la configurazione dalla posizione temporanea all'istanza database di destinazione. Scegli una delle seguenti opzioni:
+ Se gli host di origine e di destinazione condividono un file system Amazon EFS, utilizzare un'utilità del sistema operativo, ad esempio `cp`, per copiare i file di backup e il file `res.txt` dalla posizione temporanea in una directory condivisa. Quindi passa a [Passaggio 3: importazione delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.initial-tts-import).
+ Se è necessario preparare i backup in un bucket Amazon S3, completare i seguenti passaggi.
![\[Trasferire i file utilizzando Amazon S3 o Amazon EFS.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/oracle-tts.png)
#### Passaggio 2.2: caricamento dei backup nel bucket Amazon S3
Caricare i backup e il file `res.txt` dalla cartella temporanea al bucket Amazon S3. Per ulteriori informazioni, consulta [Caricamento degli oggetti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
#### Passaggio 2.3: scaricamento dei backup dal bucket Amazon S3 all'istanza database di destinazione
In questo passaggio, si utilizza la procedura `rdsadmin.rdsadmin_s3_tasks.download_from_s3` per scaricare i backup nell'istanza database RDS per Oracle.
**Scaricamento dei backup dal bucket Amazon S3**
1. Avviare SQL\$1Plus o Oracle SQL Developer e accedere all'istanza database RDS per Oracle.
1. Scaricare i backup dal bucket Amazon S3 nell'istanza database di destinazione utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3` su d. L'esempio seguente illustra come scaricare tutti i file da un bucket Amazon S3 denominato `amzn-s3-demo-bucket` nella directory `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;
```
L'istruzione `SELECT` restituisce l'ID dell'attività in un tipo di dati `VARCHAR2`. Per ulteriori informazioni, consulta [Download di file da un bucket Amazon S3 a un'istanza database Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Passaggio 3: importazione delle tablespace nell'istanza database di destinazione
Per ripristinare i tablespace nell’istanza database di destinazione utilizza la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`. Questa procedura converte automaticamente i file di dati nel formato endian corretto.
Se esegui l’importazione da una piattaforma diversa da Linux, specifica la piattaforma di origine utilizzando il parametro `p_platform_id` quando chiami `import_xtts_tablespaces`. Assicurati che l’ID specificato corrisponda a quello presente nel file `xtt.properties` in [Passaggio 2: esportazione dei metadati delle tablespace nell'host di origine](#oracle-migrating-tts.transport.export).
**Importazione delle tablespace nell'istanza database di destinazione**
1. Avviare il client Oracle SQL e accedere come utente master all'istanza database RDS per Oracle di destinazione.
1. Eseguire la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, specificando le tablespace da importare e la directory contenente i backup.
L'esempio seguente importa le tablespace *TBS1* e *TBS3* dalla directory. *TBS2* *DATA\$1PUMP\$1DIR* La piattaforma di origine è AIX-Based Systems (64 bit), identificata dall’ID `6`. È possibile trovare la piattaforma IDs eseguendo una query. `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. (Facoltativo) Monitorare l'avanzamento eseguendo una query sulla tabella `rdsadmin.rds_xtts_operation_info`. La colonna `xtts_operation_state` mostra il valore `EXECUTING`, `COMPLETED` o`FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**Nota**
Per operazioni con tempi di esecuzione lunghi, è anche possibile eseguire una query su `V$SESSION_LONGOPS` `V$RMAN_STATUS` e `V$RMAN_OUTPUT`.
1. Visualizzare il log dell'importazione completata utilizzando l'ID attività del passaggio precedente.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Assicurarsi che l'importazione sia stata completata correttamente prima di passare alla fase successiva.
## Fase 3: creazione e trasferimento dei backup incrementali
In questa fase, si effettuano e si trasferiscono periodicamente backup incrementali mentre il database di origine è attivo. Questa tecnica riduce le dimensioni del backup finale delle tablespace. Se vengono eseguiti più backup incrementali, è necessario copiare il file `res.txt` dopo l'ultimo backup incrementale prima di poterlo applicare all'istanza di destinazione.
I passaggi sono gli stessi di quelli indicati in [Fase 2: preparazione del backup completo delle tablespace](#oracle-migrating-tts.initial-br-phase), tranne per il fatto che il passaggio di importazione è facoltativo.
## Fase 4: trasporto delle tablespace
In questa fase, si esegue il backup delle tablespace di sola lettura e si esportano i metadati di Data Pump, questi file vengono quindi trasferiti nell'host di destinazione e infine vengono importati sia le tablespace che i metadati.
**Topics**
+ [Passaggio 1: esecuzione del backup delle tablespace di sola lettura](#oracle-migrating-tts.final-backup)
+ [Passaggio 2: esportazione dei metadati delle tablespace nell'host di origine](#oracle-migrating-tts.transport.export)
+ [Passaggio 3: (solo Amazon S3) trasferimento dei file di backup ed esportazione nell'istanza database di destinazione](#oracle-migrating-tts.transport)
+ [Passaggio 4: importazione delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.restore-full)
+ [Passaggio 5: importazione dei metadati delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.transport.import-dmp)
### Passaggio 1: esecuzione del backup delle tablespace di sola lettura
Questo passaggio è identico a [Passaggio 1: esecuzione del backup delle tablespace sull'host di origine](#oracle-migrating-tts.backup-full), con una differenza fondamentale: le tablespace vengono impostate sulla modalità di sola lettura prima di eseguirne il backup per l'ultima volta.
L'esempio seguente imposta `tbs1`, `tbs2` e `tbs3` sulla modalità di sola lettura.
```
ALTER TABLESPACE tbs1 READ ONLY;
ALTER TABLESPACE tbs2 READ ONLY;
ALTER TABLESPACE tbs3 READ ONLY;
```
### Passaggio 2: esportazione dei metadati delle tablespace nell'host di origine
Esportare i metadati delle tablespace eseguendo l'utilità `expdb` nell'host di origine. L'esempio seguente esporta i tablespace e *TBS1* scarica *TBS2* il file nella *TBS3* directory. *xttdump.dmp* *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
```
Se *DATA\$1PUMP\$1DIR* è una directory condivisa in Amazon EFS, passa a[Passaggio 4: importazione delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.restore-full).
### Passaggio 3: (solo Amazon S3) trasferimento dei file di backup ed esportazione nell'istanza database di destinazione
Se si utilizza Amazon S3 per preparare i backup delle tablespace e il file di esportazione di Data Pump, completare i seguenti passaggi.
#### Passaggio 3.1: caricamento dei backup e del file di dump dall'host di origine al bucket Amazon S3
Caricare i file di backup e i file di dump dall'host di origine al bucket Amazon S3. Per ulteriori informazioni, consulta [Caricamento degli oggetti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
#### Passaggio 3.2: scaricamento dei backup e del file di dump dal bucket Amazon S3 all'istanza database di destinazione
In questo passaggio, si utilizza la procedura `rdsadmin.rdsadmin_s3_tasks.download_from_s3` per scaricare i backup e il file di dump nell'istanza database RDS per Oracle. Segui la procedura riportata in [Passaggio 2.3: scaricamento dei backup dal bucket Amazon S3 all'istanza database di destinazione](#oracle-migrating-tts.download-full).
### Passaggio 4: importazione delle tablespace nell'istanza database di destinazione
Utilizzare la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` per ripristinare le tablespace. Per la sintassi e la semantica di questa procedura, consulta [Importazione di tablespace trasportate nell'istanza database](rdsadmin_transport_util_import_xtts_tablespaces.md)
**Importante**
Dopo aver completato l'importazione finale delle tablespace, il passaggio successivo prevede l'[importazione dei metadati di Oracle Data Pump](#oracle-migrating-tts.transport.export). Se l'importazione non riesce, è importante ripristinare lo stato dell'istanza database precedente all'errore. Pertanto, è consigliabile creare uno snapshot DB dell'istanza database seguendo le istruzioni riportate in [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md). Lo snapshot conterrà tutte le tablespace importate. Pertanto, se l'importazione non riesce, non sarà necessario ripetere il processo di backup e importazione.
Se per l'istanza database di destinazione sono stati abilitati i backup automatici e Amazon RDS non rileva che è stato eseguito uno snapshot valido prima dell'importazione dei metadati, RDS tenta di creare uno snapshot. A seconda dell'attività dell'istanza, questo snapshot potrebbe riuscire o meno. Se non viene rilevato uno snapshot valido o non è possibile avviarne uno, l'importazione dei metadati viene terminata con errori.
**Importazione delle tablespace nell'istanza database di destinazione**
1. Avviare il client Oracle SQL e accedere come utente master all'istanza database RDS per Oracle di destinazione.
1. Eseguire la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, specificando le tablespace da importare e la directory contenente i backup.
L'esempio seguente importa i tablespace *TBS1* e *TBS3* dalla *TBS2* directory. *DATA\$1PUMP\$1DIR*
```
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces('TBS1,TBS2,TBS3','DATA_PUMP_DIR');
END;
/
PRINT task_id
```
1. (Facoltativo) Monitorare l'avanzamento eseguendo una query sulla tabella `rdsadmin.rds_xtts_operation_info`. La colonna `xtts_operation_state` mostra il valore `EXECUTING`, `COMPLETED` o`FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**Nota**
Per operazioni con tempi di esecuzione lunghi, è anche possibile eseguire una query su `V$SESSION_LONGOPS` `V$RMAN_STATUS` e `V$RMAN_OUTPUT`.
1. Visualizzare il log dell'importazione completata utilizzando l'ID attività del passaggio precedente.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Assicurarsi che l'importazione sia stata completata correttamente prima di passare alla fase successiva.
1. Eseguire uno snapshot DB manuale seguendo le istruzioni riportate in [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
### Passaggio 5: importazione dei metadati delle tablespace nell'istanza database di destinazione
In questo passaggio, vengono importati i metadati delle tablespace trasportabili nell'istanza database RDS per Oracle utilizzando la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_metadata`. Per la sintassi e la semantica di questa procedura, consulta [Importazione dei metadati delle tablespace trasportabili nell'istanza database](rdsadmin_transport_util_import_xtts_metadata.md). Durante l'operazione, lo stato dell'importazione viene visualizzato nella tabella `rdsadmin.rds_xtts_operation_info`.
**Importante**
Prima di importare i metadati, è vivamente consigliabile di verificare che sia stato creato correttamente uno snapshot DB dopo aver importato le tablespace. Se la fase di importazione ha esito negativo, ripristinare l'istanza database, correggere gli errori di importazione e riprovare l'importazione.
**Importazione dei metadati di Data Pump nell'istanza database RDS per Oracle**
1. Avviare il client Oracle SQL e accedere come utente master all'istanza database RDS per Oracle di destinazione.
1. Se non esistono già, creare gli utenti proprietari degli schemi nelle tablespace trasportate.
```
CREATE USER tbs_owner IDENTIFIED BY password;
```
1. Importare i metadati, specificando il nome del file di dump e la sua posizione nella directory.
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
1. (Facoltativo) Eseguire una query sulla tabella della cronologia delle tablespace trasportabili per visualizzare lo stato dell'importazione dei metadati.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
Al termine dell'operazione, le tablespace sono in modalità di sola lettura.
1. (Facoltativo) Visualizzare il file di log.
L'esempio seguente elenca il contenuto della directory BDUMP e quindi esegue una query sul log di importazione.
```
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'));
```
## Fase 5: convalida delle tablespace trasportate
In questo passaggio facoltativo, si convalidano le tablespace trasportate utilizzando la procedura `rdsadmin.rdsadmin_rman_util.validate_tablespace` e quindi si attivano le tablespace. read/write
**Convalida dei dati trasportati**
1. Avviare SQL\$1Plus o SQL Developer e accedere come utente master all'istanza database RDS per Oracle.
1. Convalidare le tablespace utilizzando la procedura `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. Mettete le tablespace in modalità. read/write
```
ALTER TABLESPACE TBS1 READ WRITE;
ALTER TABLESPACE TBS2 READ WRITE;
ALTER TABLESPACE TBS3 READ WRITE;
```
## Fase 6: rimozione dei file residui
In questo passaggio facoltativo, tutti i file non necessari vengono rimossi. Usa la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` per elencare i file di dati che sono rimasti orfani dopo un'importazione tablespace, quindi utilizza la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` per eliminarli. Per la sintassi e la semantica di queste procedure, consulta [Elenco dei file orfani dopo un'importazione della tablespace](rdsadmin_transport_util_list_xtts_orphan_files.md) e [Eliminazione di file di dati rimasti orfani dopo un'importazione della tablespace](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md).
**Rimozione dei file residui**
1. Rimuovi i vecchi backup nel modo seguente: *DATA\$1PUMP\$1DIR*
1. Elencare i file di backup eseguendo `rdsadmin.rdsadmin_file_util.listdir`.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'DATA_PUMP_DIR'));
```
1. Rimuovere i backup uno a uno chiamando `UTL_FILE.FREMOVE`.
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'backup_filename');
```
1. Se è stata eseguita l'importazione delle tablespace, ma non dei relativi metadati, è possibile eliminare i file di dati orfani nel seguente modo:
1. Elencare i file di dati orfani da eliminare. L'esempio seguente esegue la procedura `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. Eliminare i file orfani eseguendo la procedura `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
L'operazione di rimozione genera un file di log che utilizza il formato di nome `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` nella directory `BDUMP`.
1. Leggere il file di log generato nel passaggio precedente. Il seguente esempio legge il 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. Se è stata eseguita l'importazione sia delle tablespace che dei relativi metadati, ma sono stati restituiti errori di compatibilità o si sono verificati problemi di altro tipo con Oracle Data Pump, rimuovere i file di dati parzialmente trasportati nel seguente modo:
1. Elencare le tablespace contenente i file di dati parzialmente trasportati mediante una query su `DBA_TABLESPACES`.
```
SQL> SELECT TABLESPACE_NAME FROM DBA_TABLESPACES WHERE PLUGGED_IN='YES';
TABLESPACE_NAME
--------------------------------------------------------------------------------
TBS_3
```
1. Rimuovere le tablespace e i file di dati parzialmente trasportati.
```
DROP TABLESPACE TBS_3 INCLUDING CONTENTS AND DATAFILES;
```
# Importazione utilizzando Oracle Data Pump
Oracle Data Pump è un'utilità che consente di esportare i dati Oracle in un file di dump e importarli in un altro database Oracle. È un sostituto a lungo termine delle Export/Import utilità Oracle. rappresenta lo strumento consigliato per spostare grandi quantità di dati da un'installazione di Oracle a un'istanza database Amazon RDS.
Gli esempi riportati in questa sezione mostrano un modo per importare i dati in un database Oracle, ma Oracle Data Pump supporta anche altre procedure. Per ulteriori informazioni, consulta la [documentazione relativa a Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump.html#GUID-501A9908-BCC5-434C-8853-9A6096766B5A).
Gli esempi in questa sezione utilizzano il pacchetto `DBMS_DATAPUMP`. Puoi eseguire le stesse attività utilizzando le utilità della riga di comando di Oracle Data Pump `impdp` e `expdp`. È possibile installare queste utilità in un host remoto come parte di un'installazione Oracle Client, incluso Oracle Instant Client. Per ulteriori informazioni, consulta la pagina relativa alla [procedura di Oracle Instant Client da usare per eseguire l'importazione o l'esportazione di Data Pump per l'istanza database Amazon RDS per Oracle](https://aws.amazon.com/premiumsupport/knowledge-center/rds-oracle-instant-client-datapump/).
**Topics**
+ [Panoramica su Oracle Data Pump](#Oracle.Procedural.Importing.DataPump.Overview)
+ [Importazione di dati con Oracle Data Pump e un bucket Amazon S3](#Oracle.Procedural.Importing.DataPump.S3)
+ [Importazione di dati con Oracle Data Pump e un collegamento di database](#Oracle.Procedural.Importing.DataPump.DBLink)
## Panoramica su Oracle Data Pump
Oracle Data Pump è composto dai seguenti componenti:
+ Client della riga di comando `expdp` e `impdp`
+ Il pacchetto `DBMS_DATAPUMP` PL/SQL .
+ Il pacchetto `DBMS_METADATA` PL/SQL .
Puoi utilizzare Oracle Data Pump per gli scenari seguenti:
+ Importazione dei dati da un database Oracle (on-premise o in un'istanza Amazon EC2) in un'istanza database Amazon RDS per Oracle.
+ Importazione dei dati da un'istanza database RDS per Oracle in un database Oracle (locale o su un'istanza Amazon EC2).
+ Importazione dei dati tra istanze database RDS per Oracle (ad esempio, per la migrazione dei dati da EC2-Classic a VPC).
Per scaricare le utilità di Oracle Data Pump, consultare [Download di software per database Oracle](http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html) sul sito web di Oracle Technology Network. Per le considerazioni sulla compatibilità durante la migrazione tra versioni di Oracle Database, consulta la [documentazione di Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-BAA3B679-A758-4D55-9820-432D9EB83C68).
### Flusso di lavoro di Oracle Data Pump
In genere, si utilizza Oracle Data Pump nelle seguenti fasi:
1. Esportazione dei dati in un file di dump nel database di origine.
1. Caricamento del file di dump nell'istanza database RDS per Oracle di destinazione. Puoi eseguire il trasferimento utilizzando un bucket Amazon S3 o un collegamento di database tra i due database.
1. Importazione i dati dal file di dump nell'istanza database RDS per Oracle.
### Best practice di Oracle Data Pump
Quando si utilizza Oracle Data Pump per importare dati in un'istanza RDS per Oracle, si consiglia di attenersi alle seguenti best practice:
+ Esegui le importazioni in modalità `schema` o `table` per importare schemi e oggetti specifici.
+ Limita gli schemi che importi a quelli richiesti dalla tua applicazione.
+ Non eseguire l'importazione in modalità `full`, né importare schemi per i componenti gestiti dal sistema.
Perché RDS per Oracle non consente l'accesso a utenti con privilegi di amministratore `SYS` o `SYSDBA`, queste azioni potrebbero danneggiare il dizionario dei dati Oracle e pregiudicare la stabilità del database.
+ Quando si caricano grandi quantità di dati, procedere nel seguente modo:
1. Trasferire il file di dump nell'istanza database RDS per Oracle di destinazione.
1. Acquisire una snapshot DB dell'istanza.
1. Verificare che l'importazione ha esito positivo.
Se i componenti del database sono invalidati, puoi eliminare l'istanza database e ricrearla dallo snapshot del database. L'istanza database ripristinata include i file di dump archiviati sull'istanza database al momento della creazione dello snapshot del database.
+ Non importare file di dump creati utilizzando i parametri di esportazione di Oracle Data Pump `TRANSPORT_TABLESPACES`, `TRANSPORTABLE` oppure `TRANSPORT_FULL_CHECK`. Le istanze database RDS per Oracle non supportano l'importazione di questi file di dump.
+ Non importare file di dump che contengono oggetti Oracle Scheduler in `SYS`, `SYSTEM`, `RDSADMIN`, `RDSSEC` e `RDS_DATAGUARD`, e che appartengono alle seguenti categorie:
+ Jobs
+ Programmi
+ Piani
+ Chain
+ Regole
+ Contesti di valutazione
+ Set di regole
Le istanze database RDS per Oracle non supportano l'importazione di questi file di dump.
+ Per escludere gli oggetti di Oracle Scheduler non supportati, utilizza direttive aggiuntive durante l'esportazione Data Pump. Se utilizzi `DBMS_DATAPUMP`, aggiungi un'altra direttiva `METADATA_FILTER` prima di `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'
);
```
Se utilizzi `expdp`, crea un file di parametri contenente la direttiva `exclude` illustrata nell'esempio seguente. Quindi usa `PARFILE=parameter_file` con il comando `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')
)
)"
```
## Importazione di dati con Oracle Data Pump e un bucket Amazon S3
Il seguente processo di importazione utilizza Oracle Data Pump e un bucket Amazon S3. I passaggi sono i seguenti:
1. Esporta i dati nel database di origine utilizzando il pacchetto Oracle [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html).
1. Inserisci il file di dump in un bucket Amazon S3.
1. Scarica il file di dump dal bucket Amazon S3 nella directory `DATA_PUMP_DIR` sull'istanza database RDS per Oracle di destinazione.
1. Importa i dati del file di dump copiato nell'istanza database RDS per Oracle utilizzando il pacchetto `DBMS_DATAPUMP`.
**Topics**
+ [Requisiti di importazione dei dati con Oracle Data Pump e un bucket Amazon S3](#Oracle.Procedural.Importing.DataPumpS3.requirements)
+ [Fase 1: concessione dei privilegi all'utente del database sull'istanza database RDS per Oracle](#Oracle.Procedural.Importing.DataPumpS3.Step1)
+ [Fase 2: esportazione dei dati in un file di dump utilizzando DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpS3.Step2)
+ [Passaggio 3: Caricamento del file di dump sul bucket Amazon S3](#Oracle.Procedural.Importing.DataPumpS3.Step3)
+ [Fase 4: scaricamento del file di dump dal bucket Amazon S3 all'istanza database di destinazione](#Oracle.Procedural.Importing.DataPumpS3.Step4)
+ [Fase 5: importazione del file di dump nell'istanza DB di destinazione utilizzando DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpS3.Step5)
+ [Fase 6: eseguire la pulizia](#Oracle.Procedural.Importing.DataPumpS3.Step6)
### Requisiti di importazione dei dati con Oracle Data Pump e un bucket Amazon S3
Il processo ha i requisiti seguenti:
+ Assicurati che sia disponibile un bucket Amazon S3 per i trasferimenti di file e che il bucket Amazon S3 sia nella stessa istanza DB. Regione AWS Per istruzioni, consultare [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) nella *Guida introduttiva di Amazon Simple Storage Service*.
+ L'oggetto caricato nel bucket Amazon S3 deve essere pari o inferiore a 5 TB. Per ulteriori informazioni sull'utilizzo di oggetti nel Amazon S3, consulta [Guida per l'utente di Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingObjects.html).
**Nota**
Se il file di dump supera i 5 TB, è possibile eseguire l'esportazione Oracle Data Pump con l'opzione parallela. Questa operazione diffonde i dati in più file di dump in modo da non superare il limite di 5 TB per i singoli file.
+ È necessario preparare il bucket Amazon S3 per l'integrazione con Amazon RDS seguendo le istruzioni in [Configurazione delle autorizzazioni IAM per l'integrazione di RDS per Oracle con Amazon S3](oracle-s3-integration.preparing.md).
+ È necessario disporre di spazio di storage sufficiente per archiviare il file dump nell'istanza di origine e nell'istanza database di destinazione.
**Nota**
Questo processo importa un file dump nella directory `DATA_PUMP_DIR`, una directory preconfigurata in tutte le istanze database Oracle. La directory si trova nello stesso volume di storage dei file di dati. Quando importi il file di dump, i file di dati di Oracle esistenti occupano più spazio. Pertanto, devi assicurarti che l'istanza database possa accomodare tale utilizzo dello spazio aggiuntivo. Il file dump importato non viene eliminato o ripulito automaticamente dalla directory `DATA_PUMP_DIR`. Per rimuovere il file di dump importato, utilizzare [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), disponibile sul sito web di Oracle.
### Fase 1: concessione dei privilegi all'utente del database sull'istanza database RDS per Oracle
In questa fase, si creano gli schemi in cui si intende importare i dati e si concedono agli utenti i privilegi necessari.
**Per creare utenti e concedere i privilegi necessari sull'istanza RDS per Oracle di destinazione**
1. Utilizza SQL\$1Plus o Oracle SQL Developer per la connessione come utente master all'istanza database RDS per Oracle in cui verranno importati i dati. Per informazioni sulla connessione a un'istanza database, consulta [Connessione all'istanza database Oracle](USER_ConnectToOracleInstance.md).
1. Prima di importare i dati, crea gli spazi di tabella necessari. Per ulteriori informazioni, consulta [Creazione e dimensionamento di tablespace in RDS for Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Se l'account utente in cui vengono importati i dati non esiste, crealo e concedigli le autorizzazioni e i ruoli necessari. Se intendi importare i dati su più schemi utente, crea tutti gli account utente e concedi loro i privilegi e i ruoli necessari.
Ad esempio, le istruzioni SQL seguenti permettono di creare un nuovo utente e concedergli le autorizzazioni e i ruoli necessari per importare i dati nel suo schema. In questo passaggio e in quelli successivi, sostituisci `schema_1` con il nome del tuo schema.
```
CREATE USER schema_1 IDENTIFIED BY my_password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
Le istruzioni precedenti concedono al nuovo utente il privilegio `CREATE SESSION` e il ruolo `RESOURCE`. Potrebbero essere necessari privilegi e ruoli aggiuntivi, a seconda degli oggetti del database da importare.
### Fase 2: esportazione dei dati in un file di dump utilizzando DBMS\$1DATAPUMP
Per creare un file di dump, utilizza il pacchetto `DBMS_DATAPUMP`.
**Per esportare i dati Oracle in un file di dump**
1. Utilizza SQL Plus o Oracle SQL Developer per connetterti all'istanza database RDS per Oracle di origine come utente amministratore. Se il database di origine è un'istanza database RDS per Oracle, esegui la connessione con l'utente master Amazon RDS.
1. Esporta i dati richiamando le procedure `DBMS_DATAPUMP`.
Il seguente script esporta lo schema `SCHEMA_1` in un file di dump denominato `sample.dmp`nella directory `DATA_PUMP_DIR`. Sostituisci `SCHEMA_1` con il nome dello schema che si desidera esportare.
```
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;
/
```
**Nota**
Data Pump avvia i processi in modo asincrono. Per informazioni sul monitoraggio di un processo di Data Pump, consulta la pagina relativa al [ monitoraggio dello stato dei processi](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) nella documentazione di Oracle.
1. (Facoltativo) Visualizza il contenuto del log di esportazione utilizzando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Passaggio 3: Caricamento del file di dump sul bucket Amazon S3
Utilizzare la procedura `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` di Amazon RDS per copiare il file dump sul bucket Amazon S3. L'esempio seguente carica tutti i file dalla directory `DATA_PUMP_DIR` su un bucket Amazon S3 denominato `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;
```
L'istruzione `SELECT` restituisce l'ID dell'attività in un tipo di dati `VARCHAR2`. Per ulteriori informazioni, consulta [Caricamento di file da un'istanza database Oracle a un bucket Amazon S3](oracle-s3-integration.using.md#oracle-s3-integration.using.upload).
### Fase 4: scaricamento del file di dump dal bucket Amazon S3 all'istanza database di destinazione
Esegui questo passaggio utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3`. Quando si scarica un file in una directory, la procedura `download_from_s3` salta il processo di scaricamento se nella directory esiste già un file con lo stesso nome. Per rimuovere il file di dump importato, utilizza [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), disponibile sul sito Web di Oracle.
**Per scaricare il file di dump**
1. Avvia SQL\$1Plus o Oracle SQL Developer e accedi come utente principale nell'istanza database Amazon RDS per Oracle di destinazione.
1. Scarica il file di dump utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3`.
L'esempio seguente illustra come scaricare tutti i file da un bucket Amazon S3 denominato `amzn-s3-demo-bucket` nella directory `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;
```
L'istruzione `SELECT` restituisce l'ID dell'attività in un tipo di dati `VARCHAR2`. Per ulteriori informazioni, consulta [Download di file da un bucket Amazon S3 a un'istanza database Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Fase 5: importazione del file di dump nell'istanza DB di destinazione utilizzando DBMS\$1DATAPUMP
Usa `DBMS_DATAPUMP` per importare lo schema nell'istanza database RDS per Oracle. Potrebbero essere necessarie opzioni aggiuntive, come `METADATA_REMAP`.
**Per importare dati nell'istanza database di destinazione**
1. Avvia SQL\$1Plus o SQL Developer e accedi come utente master all'istanza database RDS per Oracle.
1. Importa i dati chiamando le procedure `DBMS_DATAPUMP`.
L'esempio seguente importa i *SCHEMA\$11* dati dall'istanza DB di `sample_copied.dmp` destinazione.
```
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;
/
```
**Nota**
I processi di Data Pump vengono avviati in modo asincrono. Per informazioni sul monitoraggio di un processo di Data Pump, consulta la pagina relativa al [ monitoraggio dello stato dei processi](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) nella documentazione di Oracle. È possibile visualizzare il contenuto del log di importazione utilizzando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
1. Verifica l'importazione dei dati elencando le tabelle dello schema nell'istanza database di destinazione.
Ad esempio, la query seguente restituisce il numero di tabelle per `SCHEMA_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Fase 6: eseguire la pulizia
Dopo che i dati sono stati importati, puoi eliminare i file che non intendi conservare.
**Per rimuovere i file non necessari**
1. Avvia SQL\$1Plus o SQL Developer e accedi come utente master all'istanza database RDS per Oracle.
1. Elenca i file contenuti in `DATA_PUMP_DIR` utilizzando il seguente comando.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
1. Elimina i file non più necessari da `DATA_PUMP_DIR` utilizzando il seguente comando.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','filename');
```
Ad esempio, il comando seguente elimina il file denominato `sample_copied.dmp`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
## Importazione di dati con Oracle Data Pump e un collegamento di database
I processi di importazione seguenti utilizzano Oracle Data Pump e il pacchetto Oracle [DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_FILE_TRANSFER.html). I passaggi sono i seguenti:
1. Stabilisci una connessione a un database Oracle di origine che può essere on-premise, un'istanza Amazon EC2 o un'istanza database RDS per Oracle.
1. Esporta i dati utilizzando il pacchetto [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html).
1. Utilizza `DBMS_FILE_TRANSFER.PUT_FILE` per copiare il file di dump dal database Oracle alla directory `DATA_PUMP_DIR` sull'istanza database RDS per Oracle di destinazione connessa tramite un collegamento di database.
1. Importa i dati del file di dump copiato nell'istanza database RDS per Oracle utilizzando il pacchetto ` DBMS_DATAPUMP`.
Il processo di importazione che utilizza Oracle Data Pump e il pacchetto `DBMS_FILE_TRANSFER` è costituito dalle seguenti fasi.
**Topics**
+ [Requisiti di importazione dei dati con Oracle Data Pump e un collegamento di database](#Oracle.Procedural.Importing.DataPumpDBLink.requirements)
+ [Fase 1: concessione dei privilegi all'utente sull'istanza database RDS per Oracle di destinazione](#Oracle.Procedural.Importing.DataPumpDBLink.Step1)
+ [Passaggio 2: Concessione dei privilegi all'utente nel database di origine](#Oracle.Procedural.Importing.DataPumpDBLink.Step2)
+ [Fase 3: creazione di un file di dump mediante DBMS\$1DATAPUM](#Oracle.Procedural.Importing.DataPumpDBLink.Step3)
+ [Fase 4: Creazione di un collegamento di database all'istanza database di destinazione](#Oracle.Procedural.Importing.DataPumpDBLink.Step4)
+ [Fase 5: copia del file di dump esportato nell'istanza database di destinazione mediante DBMS\$1FILE\$1TRANSFER](#Oracle.Procedural.Importing.DataPumpDBLink.Step5)
+ [Fase 6: importazione del file di dati nell'istanza database di destinazione mediante DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpDBLink.Step6)
+ [Fase 7: pulizia](#Oracle.Procedural.Importing.DataPumpDBLink.Step7)
### Requisiti di importazione dei dati con Oracle Data Pump e un collegamento di database
Il processo ha i requisiti seguenti:
+ Sono necessari i privilegi di esecuzione per i pacchetti `DBMS_FILE_TRANSFER` e `DBMS_DATAPUMP`.
+ Sono necessari i privilegi di scrittura nella directory `DATA_PUMP_DIR` nell'istanza database di origine.
+ È necessario disporre di spazio di storage sufficiente per archiviare il file dump nell'istanza di origine e nell'istanza database di destinazione.
**Nota**
Questo processo importa un file dump nella directory `DATA_PUMP_DIR`, una directory preconfigurata in tutte le istanze database Oracle. La directory si trova nello stesso volume di storage dei file di dati. Quando importi il file di dump, i file di dati di Oracle esistenti occupano più spazio. Pertanto, devi assicurarti che l'istanza database possa accomodare tale utilizzo dello spazio aggiuntivo. Il file dump importato non viene eliminato o ripulito automaticamente dalla directory `DATA_PUMP_DIR`. Per rimuovere il file di dump importato, utilizzare [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), disponibile sul sito web di Oracle.
### Fase 1: concessione dei privilegi all'utente sull'istanza database RDS per Oracle di destinazione
Per concedere i privilegi all'utente sull'istanza database RDS per Oracle di destinazione, esegui i seguenti passaggi:
1. Utilizza SQL Plus o Oracle SQL Developer per la connessione all'istanza database RDS per Oracle di destinazione in cui verranno importati i dati. Esegui la connessione come utente master Amazon RDS. Per informazioni sulla connessione all'istanza database, consulta [Connessione all'istanza database Oracle](USER_ConnectToOracleInstance.md).
1. Prima di importare i dati, crea gli spazi di tabella necessari. Per ulteriori informazioni, consulta [Creazione e dimensionamento di tablespace in RDS for Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Se l'account utente in cui vengono importati i dati non esiste, crealo e concedigli le autorizzazioni e i ruoli necessari. Se intendi importare i dati su più schemi utente, crea tutti gli account utente e concedi loro i privilegi e i ruoli necessari.
Ad esempio, i comandi seguenti creano un nuovo utente denominato *schema\$11* e concedono le autorizzazioni e i ruoli necessari per importare i dati nello schema per questo utente.
```
CREATE USER schema_1 IDENTIFIED BY my-password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
L'esempio precedente concede al nuovo utente il privilegio `CREATE SESSION` e il ruolo `RESOURCE`. Potrebbero essere necessari privilegi e ruoli aggiuntivi, a seconda degli oggetti del database da importare.
**Nota**
In questo passaggio e in quelli successivi, sostituisci `schema_1` con il nome del tuo schema.
### Passaggio 2: Concessione dei privilegi all'utente nel database di origine
Utilizza SQL\$1Plus o Oracle SQL Developer per la connessione all'istanza database RDS per Oracle contenente i dati da importare. Se necessario, crea un account utente e concedi le autorizzazioni necessarie.
**Nota**
Se il database di origine è un'istanza Amazon RDS, puoi ignorare questa fase. Per eseguire l'esportazione, utilizzi l'account utente master Amazon RDS.
I comandi seguenti creano un nuovo utente e gli concedono le autorizzazioni necessarie.
```
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;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
### Fase 3: creazione di un file di dump mediante DBMS\$1DATAPUM
Per creare il file batch, procedi come segue:
1. Utilizza SQL\$1Plus o Oracle SQL Developer per la connessione all'istanza Oracle di origine come utente amministratore o come l'utente creato nel passaggio 2. Se il database di origine è un'istanza database Amazon RDS for Oracle, esegui la connessione con l'utente master Amazon RDS.
1. Crea un file di dump utilizzando l'utilità Oracle Data Pump.
Lo script seguente crea un file dump denominato *sample.dmp* nella directory `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;
/
```
**Nota**
I processi di Data Pump vengono avviati in modo asincrono. Per informazioni sul monitoraggio di un processo di Data Pump, consulta la pagina relativa al [ monitoraggio dello stato dei processi](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) nella documentazione di Oracle. È possibile visualizzare il contenuto del log di esportazione utilizzando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Fase 4: Creazione di un collegamento di database all'istanza database di destinazione
Crea un collegamento di database tra le istanze database di origine e destinazione. Tieni presente che, per creare un collegamento di database e trasferire il file dump esportato, l'istanza Oracle locale deve disporre di connettività di rete verso l'istanza database di destinazione.
Esegui questa fase connettendoti con lo stesso account utente utilizzato nella fase precedente.
Se stai creando un database link tra due istanze DB all'interno dello stesso VPC o VPCs peered, le due istanze DB dovrebbero avere un percorso valido tra di loro. Il gruppo di sicurezza di ogni istanza database deve permettere l'ingresso e l'uscita dall'altra istanza database. Le regole per il traffico in entrata e in uscita del gruppo di sicurezza possono fare riferimento a gruppi di sicurezza dello stesso VPC o di un VPC in peering. Per ulteriori informazioni, consulta [Modifica dei collegamenti di database per l'utilizzo con le istanze database in un VPC](Appendix.Oracle.CommonDBATasks.DBLinks.md).
Il comando seguente crea un collegamento di database denominato `to_rds` che si connette all'utente master Amazon RDS sull'istanza database di destinazione:
```
CREATE DATABASE LINK to_rds
CONNECT TO IDENTIFIED BY
USING '(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=)
(PORT=))(CONNECT_DATA=(SID=)))';
```
### Fase 5: copia del file di dump esportato nell'istanza database di destinazione mediante DBMS\$1FILE\$1TRANSFER
Utilizza `DBMS_FILE_TRANSFER` per copiare il file dump dall'istanza database di origine all'istanza database di destinazione. Il seguente script copia un file di dump denominato sample.dmp dall'istanza di origine su un collegamento di database di destinazione denominato *to\$1rds* (creato nel passaggio precedente).
```
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;
/
```
### Fase 6: importazione del file di dati nell'istanza database di destinazione mediante DBMS\$1DATAPUMP
Utilizza Oracle Data Pump per importare lo schema nell'istanza database. Potrebbero essere necessarie opzioni aggiuntive, come METADATA\$1REMAP.
Stabilisci la connessione all'istanza database con l'account utente master Amazon RDS per eseguire l'importazione.
```
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;
/
```
**Nota**
I processi di Data Pump vengono avviati in modo asincrono. Per informazioni sul monitoraggio di un processo di Data Pump, consulta la pagina relativa al [ monitoraggio dello stato dei processi](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) nella documentazione di Oracle. È possibile visualizzare il contenuto del log di importazione utilizzando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
Puoi verificare l'importazione dei dati visualizzando le tabelle dell'utente nell'istanza database. Ad esempio, la query seguente restituisce il numero di tabelle per `schema_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Fase 7: pulizia
Dopo che i dati sono stati importati, puoi eliminare i file che non intendi conservare. Puoi elencare i file contenuti in `DATA_PUMP_DIR` utilizzando il seguente comando.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
Per eliminare i file non più necessari da `DATA_PUMP_DIR`, utilizza il seguente comando.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','');
```
Ad esempio, il comando seguente elimina il file denominato `"sample_copied.dmp"`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
# Importazione con le utilità Oracle di esportazione/importazione
È possibile valutare la possibilità di utilizzare le utilità Oracle di esportazione/importazione per le migrazioni nelle seguenti condizioni:
+ Le dimensioni dei dati sono ridotte.
+ Non sono richiesti tipi di dati come binary float e double.
Il processo di importazione crea gli oggetti dello schema necessari. Pertanto, non devi eseguire prima uno script per creare gli oggetti.
Il modo più semplice per installare le utilità Oracle di esportazione e importazione è installare Oracle Instant Client. Per scaricare il software, vai su [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Per la documentazione, consulta [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) nel manuale *Oracle Database Utilities*.
**Per esportare le tabelle e quindi importarle**
1. Esporta le tabelle dal database di origine utilizzano il comando `exp`.
Il comando seguente esporta le tabelle denominate `tab1`, `tab2` e `tab3`. Il file di dump è `exp_file.dmp`.
```
exp cust_dba@ORCL FILE=exp_file.dmp TABLES=(tab1,tab2,tab3) LOG=exp_file.log
```
L'esportazione crea un file dump binario contenente sia lo schema che i dati delle tabelle specificate.
1. Importa lo schema e i dati in un database di destinazione utilizzando il comando `imp`.
Il comando seguente importa le tabelle `tab1`, `tab2` e `tab3` dal file di 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
```
Le esportazioni e importazione hanno altre varianti che potrebbero essere più adatte alle esigenze specifiche. Per dettagli completi, consulta la documentazione di Oracle Database.
# Importazione utilizzando Oracle SQL\$1Loader
Potresti valutare l'opportunità di utilizzare Oracle SQL\$1Loader per database di grandi dimensioni contenenti un numero limitato di oggetti. Poiché il processo di esportazione da un database di origine e di caricamento in un database di destinazione è specifico dello schema, l'esempio seguente crea gli oggetti dello schema di esempio, li esporta da un'origine e quindi carica i dati in un database di destinazione.
Il modo più semplice per installare Oracle SQL\$1Loader è installare Oracle Instant Client. Per scaricare il software, vai su [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Per la documentazione, consulta [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) nel manuale *Oracle Database Utilities*.
**Per importare dati utilizzando Oracle SQL\$1Loader**
1. Crea una tabella di origine di esempio utilizzando la seguente istruzione SQL.
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
```
1. Nell'istanza database RDS per Oracle di destinazione, crea una tabella di destinazione per caricare i dati. La clausola `WHERE 1=2` garantisce la copia della struttura di `ALL_OBJECTS`, ma non delle righe.
```
CREATE TABLE customer_1 TABLESPACE users
AS (SELECT 0 AS ID, OWNER, OBJECT_NAME, CREATED
FROM ALL_OBJECTS
WHERE 1=2);
```
1. Esporta i dati dal database di origine a un file di testo. L'esempio seguente utilizza SQL\$1Plus. Per i propri dati, è probabilmente necessario generare uno script che esegue l'esportazione per tutti gli oggetti nel database.
```
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. Crea un file di controllo per descrivere i dati. Potrebbe essere necessario scrivere uno script per eseguire questa operazione.
```
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"
)
```
Se necessario, copiare i file generati dal codice precedente in un'area di staging, ad esempio un'istanza Amazon EC2.
1. Importa i dati utilizzando SQL\$1Loader con il nome utente e la password appropriati per il database di destinazione.
```
sqlldr cust_dba@targetdb CONTROL=sqlldr_1.ctl BINDSIZE=10485760 READSIZE=10485760 ROWS=1000
```
# Migrazione con le viste materializzate Oracle
Per eseguire la migrazione di set di dati di grandi dimensioni in modo efficiente, è anche possibile utilizzare la replica delle viste materializzate Oracle. Una replica consente di mantenere la sincronizzazione tra le tabelle di destinazione e le tabelle di origine. Pertanto, puoi passare ad Amazon RDS in un secondo momento, se necessario.
Prima di poter migrare utilizzando le viste materializzate, verifica che siano soddisfatti i seguenti requisiti:
+ Configurazione dell'accesso dal database di destinazione al database di origine. Nell'esempio seguente sono state abilitate regole di accesso nel database di origine per permettere la connessione del database RDS per Oracle di destinazione all'origine tramite SQL\$1Net.
+ Crea un collegamento di database tra l'istanza database RDS per Oracle e il database di origine.
**Per eseguire la migrazione dei dati utilizzando viste materializzate**
1. Nelle istanze RDS per Oracle di origine e di destinazione crea un account utente per il quale sia possibile eseguire l'autenticazione con la stessa password. L'esempio seguente crea un utente denominato `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;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
1. Crea un collegamento di database dall'istanza RDS per Oracle di destinazione all'istanza di origine utilizzando il nuovo utente creato.
```
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)))';
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
1. Testare il collegamento:
```
SELECT * FROM V$INSTANCE@remote_site;
```
1. Creare una tabella di esempio con una chiave primaria e un log della vista materializzata nell'istanza di origine.
```
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. Nell'istanza database RDS per Oracle di destinazione, crea una vista materializzata.
```
CREATE MATERIALIZED VIEW customer_0
BUILD IMMEDIATE REFRESH FAST
AS (SELECT *
FROM cust_dba.customer_0@remote_site);
```
1. Nell'istanza database RDS per Oracle di destinazione, aggiorna la vista materializzata.
```
EXEC DBMS_MVIEW.REFRESH('CUSTOMER_0', 'f');
```
1. Elimina la vista materializzata e includi la clausola `PRESERVE TABLE` per mantenere la tabella container della vista materializzata e il relativo contenuto.
```
DROP MATERIALIZED VIEW customer_0 PRESERVE TABLE;
```
La tabella conservata ha lo stesso nome della vista materializzata eliminata.