Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Importation de données dans Oracle sur Amazon RDS
La façon dont vous importez des données dans une instance de base de données Amazon RDS for Oracle dépend des éléments suivants :
+ La quantité de données dont vous disposez
+ Le nombre d'objets de base de données dans votre base de données
+ La variété d'objets de base de données dans votre base de données
Par exemple, vous pouvez utiliser les outils suivants, en fonction de vos besoins :
+ Oracle SQL Developer – Importez une base de données simple de 20 Mo.
+ Oracle Data Pump – Importez des bases de données complexes ou des bases de données de centaines de mégaoctets ou de plusieurs téraoctets. Par exemple, vous pouvez transporter des espaces de table depuis une base de données sur site vers votre instance de base de données RDS for Oracle. Vous pouvez utiliser Amazon S3 ou Amazon EFS pour transférer les fichiers de données et les métadonnées. Pour plus d’informations, consultez [Migration à l'aide des espaces de table transportables Oracle](oracle-migrating-tts.md), [Intégration Amazon EFS](oracle-efs-integration.md) et [Intégration Amazon S3](oracle-s3-integration.md).
+ AWS Database Migration Service (AWS DMS) – Migrez des bases de données sans interruption. Pour plus d'informations sur AWS DMS, consultez [Présentation d'AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) et le billet de blog [Migration de bases de données Oracle avec un temps d'arrêt quasi nul à l'aide d'AWS DMS](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/).
**Important**
Avant d'utiliser les techniques de migration précédentes, nous vous recommandons de sauvegarder votre base de données. Après avoir importé les données, vous pouvez sauvegarder vos instances de base de données RDS for Oracle en créant des instantanés. Vous pouvez restaurer ultérieurement les instantanés. Pour plus d'informations, consultez [Sauvegarde, restauration et exportation de données](CHAP_CommonTasks.BackupRestore.md).
Pour de nombreux moteurs de base de données, la réplication en cours peut se poursuivre jusqu'à ce que vous soyez prêt à basculer sur la base de données cible. Vous pouvez utiliser AWS DMS pour migrer vers RDS for Oracle à partir du même moteur de base de données ou d'un moteur différent. Si vous migrez à partir d'un moteur de base de données différent, vous pouvez utiliser l'AWS Schema Conversion Tool pour migrer les objets de schéma que AWS DMS ne migre pas.
**Topics**
+ [
# Importation à l'aide d'Oracle SQL Developer
](Oracle.Procedural.Importing.SQLDeveloper.md)
+ [
# Migration à l'aide des espaces de table transportables Oracle
](oracle-migrating-tts.md)
+ [
# Importation à l'aide d'Oracle Data Pump
](Oracle.Procedural.Importing.DataPump.md)
+ [
# Importation avec les utilitaires d’importation/importation d’Oracle
](Oracle.Procedural.Importing.ExportImport.md)
+ [
# Importation avec Oracle SQL\$1Loader
](Oracle.Procedural.Importing.SQLLoader.md)
+ [
# Migration avec les vues matérialisées d'Oracle
](Oracle.Procedural.Importing.Materialized.md)
# Importation à l'aide d'Oracle SQL Developer
Oracle SQL Developer est un outil Java graphique distribué gratuitement par Oracle. SQL Developer offre des options pour la migration des données entre deux bases de données Oracle, ou pour la migration des données d'autres bases de données, telles que MySQL, vers une base de données Oracle. Cet outil convient parfaitement à la migration de bases de données peu volumineuses.
Vous pouvez installer cet outil sur votre ordinateur de bureau (Windows, Linux ou Mac) ou l'un de vos serveurs. Après avoir installé SQL Developer, vous pouvez l'utiliser pour vous connecter à vos bases de données source et cible. Utilisez la commande **Copie de la base de données** dans le menu Outils pour copier vos données vers votre instance de base de données RDS for Oracle.
Pour télécharger SQL Developer, consultez [ http://www.oracle.com/technetwork/developer-tools/sql-developer](http://www.oracle.com/technetwork/developer-tools/sql-developer).
Nous vous recommandons de lire la documentation de produit Oracle SQL Developer avant de commencer à migrer vos données. Oracle possède également une documentation sur la façon de migrer depuis d'autres bases de données dont MySQL et SQL Server. Pour plus d'informations, consultez [http://www.oracle.com/technetwork/database/migration](http://www.oracle.com/technetwork/database/migration) dans la documentation Oracle.
# Migration à l'aide des espaces de table transportables Oracle
Vous pouvez utiliser la fonctionnalité d'espaces de table transportables Oracle pour copier un ensemble d'espaces de table à partir d'une base de données Oracle sur site vers une instance de base de données RDS for Oracle. Au niveau physique, vous transférez les fichiers de données et de métadonnées sources vers votre instance de base de données cible avec Amazon EFS ou Amazon S3. La fonctionnalité de tablespaces transportables utilise le package `rdsadmin.rdsadmin_transport_util`. Pour la syntaxe et la sémantique de ce package, consultez [Transport des espaces de table](rdsadmin_transport_util.md).
Pour les articles de blog expliquant comment transporter des espaces disque logiques, consultez les sections [Migrer les bases de données Oracle vers des tablespaces transportables et Amazon RDS for Oracle Transportable Tablespaces à l' AWS aide](https://aws.amazon.com/blogs/database/migrate-oracle-databases-to-aws-using-transportable-tablespace/) [de RMAN.](https://aws.amazon.com/blogs/database/amazon-rds-for-oracle-transportable-tablespaces-using-rman/)
**Topics**
+ [
## Vue d'ensemble des espaces de table transportables Oracle
](#oracle-migrating-tts.overview)
+ [
## Phase 1 : Configuration de votre hôte source
](#oracle-migrating-tts.setup-phase)
+ [
## Phase 2 : Préparation de la sauvegarde complète des espaces de table
](#oracle-migrating-tts.initial-br-phase)
+ [
## Phase 3 : Création et transfert de sauvegardes incrémentielles
](#oracle-migrating-tts.roll-forward-phase)
+ [
## Phase 4 : Transport des espaces de table
](#oracle-migrating-tts.final-br-phase)
+ [
## Phase 5 : Validation des espaces de table transportés
](#oracle-migrating-tts.validate)
+ [
## Phase 6 : Nettoyage des fichiers restants
](#oracle-migrating-tts.cleanup)
## Vue d'ensemble des espaces de table transportables Oracle
Un ensemble d'espaces de table transportables se compose de fichiers de données pour l'ensemble d'espaces de table en cours de transport et d'un fichier de vidage d'exportation contenant les métadonnées des espaces de table. Dans une solution de migration physique telle que les espaces de table transportables, vous transférez des fichiers physiques : fichiers de données, fichiers de configuration et fichiers de vidage Data Pump.
**Topics**
+ [
### Avantages et inconvénients des espaces de table transportables
](#oracle-migrating-tts.overview.benefits)
+ [
### Limitations applicables aux espaces de table transportables
](#oracle-migrating-tts.limitations)
+ [
### Prérequis pour les espaces de table transportables
](#oracle-migrating-tts.requirements)
### Avantages et inconvénients des espaces de table transportables
Nous vous recommandons d'utiliser des espaces de table transportables lorsque vous devez migrer un ou plusieurs espaces de table volumineux vers RDS avec un minimum de temps d'arrêt. Les espaces de table transportables offrent les avantages suivants par rapport à la migration logique :
+ Les temps d'arrêt sont inférieurs à ceux de la plupart des autres solutions de migration Oracle.
+ Comme la fonctionnalité des espaces de table transportables copie uniquement les fichiers physiques, elle évite les erreurs d'intégrité des données et la corruption logique qui peuvent survenir lors d'une migration logique.
+ Aucune licence supplémentaire n'est requise.
+ Vous pouvez migrer un ensemble d'espaces de table entre différentes plateformes et différents types d'endianisme, par exemple d'une plateforme Oracle Solaris vers Linux. Toutefois, le transport des espaces de table vers et depuis des serveurs Windows n'est pas pris en charge.
**Note**
Linux est entièrement testé et pris en charge. Toutes les variantes UNIX n'ont pas été testées.
Si vous utilisez des espaces de table transportables, vous pouvez transporter les données à l'aide d'Amazon S3 ou d'Amazon EFS :
+ Lorsque vous utilisez EFS, vos sauvegardes restent dans le système de fichiers EFS pendant toute la durée de l'importation. Vous pouvez ensuite supprimer les fichiers. Dans cette technique, vous n'avez pas besoin de provisionner le stockage EBS pour votre instance de base de données. C'est pourquoi nous vous recommandons d'utiliser Amazon EFS plutôt que S3. Pour plus d’informations, consultez [Intégration Amazon EFS](oracle-efs-integration.md).
+ Lorsque vous utilisez S3, vous téléchargez des sauvegardes RMAN sur le stockage EBS attaché à votre instance de base de données. Les fichiers restent dans votre stockage EBS pendant l'importation. Après l'importation, vous pouvez libérer cet espace, qui reste alloué à votre instance de base de données.
Le principal inconvénient des espaces de table transportables est que vous nécessitez une connaissance relativement avancée d'Oracle Database. Pour plus d'informations, consultez [Transport des espaces de table entre bases de données](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-F7B2B591-AA88-4D16-8DCF-712763923FFB) dans le *Guide de l'administrateur Oracle Database* (langue française non garantie).
### Limitations applicables aux espaces de table transportables
Les limitations Oracle Database pour les espaces de table transportables s'appliquent lorsque vous utilisez cette fonctionnalité dans RDS for Oracle. Pour plus d'informations, consultez [Limitations relatives aux espaces de table transportables]( https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-DAB51E42-9BBC-4001-B5CB-0ECDBE128787) et [Limitations générales relatives au transport de données](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) dans le *Guide de l'administrateur Oracle Database* (langue française non garantie). Notez les limitations supplémentaires suivantes pour les espaces de table transportables dans RDS for Oracle :
+ Ni la base de données source ni la base de données cible ne peuvent utiliser Standard Edition 2 (SE2). Seule Enterprise Edition est prise en charge.
+ Vous ne pouvez pas utiliser une base de données Oracle Database 11g comme source. La fonctionnalité de tablespaces transportables multiplateformes RMAN repose sur le mécanisme de transport RMAN, qu’Oracle Database 11g ne prend pas en charge.
+ Vous ne pouvez pas migrer des données depuis une instance de base de données RDS for Oracle en utilisant des espaces de table transportables. Vous pouvez uniquement utiliser des espaces de table transportables pour migrer des données vers une instance de base de données RDS for Oracle.
+ Le système d'exploitation Windows n'est pas pris en charge.
+ Vous ne pouvez pas transporter des espaces de table vers une base de données à un niveau de version inférieur. La base de données cible doit être à un niveau de version égal ou supérieur à celui de la base de données source. Par exemple, vous ne pouvez pas transporter des espaces de table d'Oracle Database 21c vers Oracle Database 19c.
+ Vous ne pouvez pas transporter des espaces de table administratifs tels que `SYSTEM` et `SYSAUX`.
+ Vous ne pouvez pas transporter d'objets autres que des données tels que des PL/SQL packages, des classes Java, des vues, des déclencheurs, des séquences, des utilisateurs, des rôles et des tables temporaires. Pour transporter des objets autres que des données, créez-les manuellement ou utilisez l’exportation et l’importation de métadonnées Data Pump. Pour plus d’informations, consultez la [Note de support My Oracle 1454872.1](https://support.oracle.com/knowledge/Oracle%20Cloud/1454872_1.html).
+ Vous ne pouvez pas transporter des espaces de table chiffrés ou qui utilisent des colonnes chiffrées.
+ Si vous transférez des fichiers à l'aide d'Amazon S3, la taille de fichier maximale prise en charge est de 5 Tio.
+ Si la base de données source utilise des options Oracle telles que Spatial, vous ne pouvez pas transporter des espaces de table à moins que les mêmes options soient configurées sur la base de données cible.
+ Vous ne pouvez pas transporter des espaces de table vers une instance de base de données RDS for Oracle dans une configuration de réplicas Oracle. Pour contourner ce problème, vous pouvez supprimer tous les réplicas, transporter les espaces de table, puis recréer les réplicas.
### Prérequis pour les espaces de table transportables
Avant de commencer, effectuez les tâches suivantes :
+ Passez en revue les exigences en matière d'espaces de table transportables, décrites dans les documents suivants figurant dans My Oracle Support :
+ [Réduire les temps d'arrêt des espaces de table transportables en utilisant la sauvegarde incrémentielle multiplateforme (ID de document 2471245.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1) (langue française non garantie)
+ [Restrictions et limites relatives aux espaces de table transportables (TTS) : détails, référence et version, le cas échéant (ID de document 1454872.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1454872.1) (langue française non garantie)
+ [Note principale concernant les espaces de table transportables (TTS) -- Questions et problèmes courants (ID de document 1166564.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1166564.1) (langue française non garantie)
+ Prévoyez la conversion de l'endianisme. Si vous spécifiez l'identifiant de la plateforme source, RDS for Oracle convertit automatiquement l'endianisme. Pour savoir comment trouver une plateforme IDs, consultez [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).
+ Assurez-vous que la fonctionnalité des espaces de table transportables est activée sur votre instance de base de données cible. Cette fonctionnalité est activée uniquement si vous n'obtenez pas une erreur `ORA-20304` lorsque vous exécutez la requête suivante :
```
SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
```
Si la fonctionnalité des espaces de table transportables n'est pas activée, redémarrez votre instance de base de données. Pour plus d’informations, consultez [Redémarrage d'une instance de base de données cluster de base de données](USER_RebootInstance.md).
+ Assurez-vous que le fichier de fuseau horaire est identique dans les bases de données source et cible.
+ Assurez-vous que les jeux de caractères des bases de données source et cible répondent à l’une des exigences suivantes :
+ Les jeux de caractères sont identiques.
+ Les jeux de caractères sont compatibles. Pour obtenir la liste des exigences de compatibilité, consultez [Limitations générales relatives au transport de données](https://docs.oracle.com/en/database/oracle/oracle-database/19/spmdu/general-limitations-on-transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) dans la documentation d’Oracle Database.
+ Si vous envisagez de transférer des fichiers à l'aide d'Amazon S3, procédez comme suit :
+ Assurez-vous qu'un compartiment Amazon S3 est disponible pour les transferts de fichiers et qu'il se trouve dans la même AWS région que votre instance de base de données. Pour plus d’informations, consultez [Créer un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) dans le *Guide de démarrage d’Amazon Simple Storage Service*.
+ Préparez le compartiment Amazon S3 pour l'intégration d'Amazon RDS en suivant les instructions fournies dans [Configuration des autorisations IAM pour l'intégration de RDS for Oracle à Amazon S3](oracle-s3-integration.preparing.md).
+ Si vous envisagez de transférer des fichiers à l'aide d'Amazon EFS, assurez-vous d'avoir configuré EFS conformément aux instructions fournies dans [Intégration Amazon EFS](oracle-efs-integration.md).
+ Nous vous recommandons vivement d'activer les sauvegardes automatiques dans votre instance de base de données cible. Comme l'[étape d'importation des métadonnées](#oracle-migrating-tts.transport.import-dmp) peut échouer, il est important de pouvoir restaurer votre instance de base de données dans son état d'avant l'importation, afin d'éviter d'avoir à sauvegarder, transférer et importer à nouveau vos espaces de table.
## Phase 1 : Configuration de votre hôte source
Au cours de cette étape, vous copiez les scripts de transport des espaces de table fournis par My Oracle Support et configurez les fichiers de configuration nécessaires. Dans les étapes suivantes, l'*hôte source* exécute la base de données qui contient les espaces de table à transporter vers votre *instance cible*.
**Pour configurer votre hôte source**
1. Connectez-vous à votre hôte source en tant que propriétaire de votre répertoire de base Oracle.
1. Assurez-vous que vos variables d'environnement `ORACLE_HOME` et `ORACLE_SID` pointent vers votre base de données source.
1. Connectez-vous à votre base de données en tant qu'administrateur et vérifiez que la version de fuseau horaire, le jeu de caractères de base de données et le jeu de caractères national sont identiques à ceux de votre base de données cible.
```
SELECT * FROM V$TIMEZONE_FILE;
SELECT * FROM NLS_DATABASE_PARAMETERS
WHERE PARAMETER IN ('NLS_CHARACTERSET','NLS_NCHAR_CHARACTERSET');
```
1. Configurez l'utilitaire d'espace de table transportable comme décrit dans la [note de support Oracle 2471245.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1) (langue française non garantie).
La configuration inclut la modification du fichier `xtt.properties` sur votre hôte source. L'exemple de fichier `xtt.properties` suivant spécifie les sauvegardes de trois espaces de table dans le répertoire `/dsk1/backups`. Il s'agit des espaces de table que vous souhaitez transporter vers votre instance de base de données cible. Il spécifie également l'identifiant de la plateforme source pour convertir automatiquement l'endianisme.
**Note**
Pour une plate-forme valide IDs, consultez [Data Guard Support pour les systèmes de secours primaires et physiques hétérogènes dans la même configuration Data Guard (Doc ID](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
```
## Phase 2 : Préparation de la sauvegarde complète des espaces de table
Au cours de cette phase, vous sauvegardez vos espaces de table pour la première fois, vous transférez les sauvegardes vers votre hôte cible, puis vous les restaurez à l'aide de la procédure `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`. Lorsque cette phase est terminée, les sauvegardes initiales des espaces de table résident sur votre instance de base de données cible et peuvent être mises à jour avec des sauvegardes incrémentielles.
**Topics**
+ [
### Étape 1 : Sauvegarder les espaces de table sur votre hôte source
](#oracle-migrating-tts.backup-full)
+ [
### Étape 2 : Transférer les fichiers de sauvegarde vers votre instance de base de données cible
](#oracle-migrating-tts.transfer-full)
+ [
### Étape 3 : Importer les espaces de table dans votre instance de base de données cible
](#oracle-migrating-tts.initial-tts-import)
### Étape 1 : Sauvegarder les espaces de table sur votre hôte source
Au cours de cette étape, vous utilisez le script `xttdriver.pl` pour effectuer une sauvegarde complète de vos espaces de table. La sortie de `xttdriver.pl` est stockée dans la variable d'environnement `TMPDIR`.
**Pour sauvegarder vos espaces de table**
1. Si vos espaces disque logiques sont en mode lecture seule, connectez-vous à votre base de données source en tant qu'utilisateur autorisé et placez vos `ALTER TABLESPACE` espaces disque logiques en mode. read/write Sinon, passez à l’étape suivante.
L'exemple suivant place `tbs1``tbs2`, et `tbs3` en read/write mode.
```
ALTER TABLESPACE tbs1 READ WRITE;
ALTER TABLESPACE tbs2 READ WRITE;
ALTER TABLESPACE tbs3 READ WRITE;
```
1. Sauvegardez vos espaces de table à l'aide du script `xttdriver.pl`. Vous pouvez éventuellement spécifier `--debug` pour exécuter le script en mode débogage.
```
export TMPDIR=location_of_log_files
cd location_of_xttdriver.pl
$ORACLE_HOME/perl/bin/perl xttdriver.pl --backup
```
### Étape 2 : Transférer les fichiers de sauvegarde vers votre instance de base de données cible
Au cours de cette étape, copiez les fichiers de sauvegarde et de configuration à partir de votre emplacement zéro vers votre instance de base de données cible. Choisissez l’une des options suivantes :
+ Si les hôtes source et cible partagent un système de fichiers Amazon EFS, utilisez un utilitaire de système d'exploitation tel que `cp` pour copier vos fichiers de sauvegarde et le fichier `res.txt` à partir de votre emplacement zéro vers un répertoire partagé. Passez ensuite à [Étape 3 : Importer les espaces de table dans votre instance de base de données cible](#oracle-migrating-tts.initial-tts-import).
+ Si vous devez organiser vos sauvegardes vers un compartiment Amazon S3, procédez comme suit.
![\[Transférez les fichiers en utilisant Amazon S3 ou Amazon EFS.\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/oracle-tts.png)
#### Étape 2.2 : Charger les sauvegardes dans votre compartiment Amazon S3
Chargez vos sauvegardes et le fichier `res.txt` depuis votre répertoire zéro vers votre compartiment Amazon S3. Pour plus d'informations, consultez [Chargement d'objets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*.
#### Étape 2.3 : Télécharger les sauvegardes depuis votre compartiment Amazon S3 vers votre instance de base de données cible
Au cours de cette étape, vous utilisez la procédure `rdsadmin.rdsadmin_s3_tasks.download_from_s3` pour télécharger vos sauvegardes dans votre instance de base de données RDS for Oracle.
**Pour télécharger vos sauvegardes depuis votre compartiment Amazon S3**
1. Lancez SQL\$1Plus ou Oracle SQL Developer et connectez-vous à votre instance de base de données RDS for Oracle.
1. Téléchargez les sauvegardes depuis le compartiment Amazon S3 vers votre instance de base de données cible en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3`. L'exemple suivant télécharge tous les fichiers d'un compartiment Amazon S3 nommé `amzn-s3-demo-bucket` vers le répertoire `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'instruction `SELECT` renvoie l'ID de la tâche dans un type de données `VARCHAR2`. Pour plus d’informations, consultez [Téléchargement des fichiers d'un compartiment Amazon S3 vers une instance de base de données Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Étape 3 : Importer les espaces de table dans votre instance de base de données cible
Utilisez la procédure `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` pour restaurer vos tablespaces vers votre instance de base de données cible. Cette procédure convertit automatiquement les fichiers de données au format endian approprié.
Si vous importez depuis une plateforme autre que Linux, spécifiez la plateforme source à l’aide du paramètre `p_platform_id` lorsque vous appelez `import_xtts_tablespaces`. Assurez-vous que l’ID de plateforme que vous spécifiez correspond à celui spécifié dans le fichier `xtt.properties` dans [Étape 2 : Exporter les métadonnées d'espace de table sur votre hôte source](#oracle-migrating-tts.transport.export).
**Pour importer les espaces de table dans votre instance de base de données cible**
1. Démarrez un client Oracle SQL et connectez-vous en tant qu'utilisateur principal à votre instance de base de données RDS for Oracle cible.
1. Exécutez la procédure `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` en spécifiant les espaces de table à importer et le répertoire contenant les sauvegardes.
L'exemple suivant importe les tablespaces *TBS1**TBS2*, et *TBS3* depuis le répertoire. *DATA\$1PUMP\$1DIR* La plateforme source est AIX-Based Systems (64 bits), dont l’ID de plateforme est `6`. Vous pouvez trouver la plateforme IDs en `V$TRANSPORTABLE_PLATFORM` interrogeant.
```
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. (Facultatif) Surveillez la progression en interrogeant la table `rdsadmin.rds_xtts_operation_info`. La colonne `xtts_operation_state` indique la valeur `EXECUTING`, `COMPLETED` ou `FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**Note**
Pour les opérations de longue durée, vous pouvez également interroger `V$SESSION_LONGOPS`, `V$RMAN_STATUS` et `V$RMAN_OUTPUT`.
1. Consultez le journal de l'importation terminée en utilisant l'ID de tâche issu de l'étape précédente.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Assurez-vous de la réussite de l'importation avant de passer à l'étape suivante.
## Phase 3 : Création et transfert de sauvegardes incrémentielles
Dans cette phase, vous effectuez et transférez régulièrement des sauvegardes incrémentielles pendant que la base de données source est active. Cette technique réduit la taille de la sauvegarde finale de vos espaces de table. Si vous effectuez plusieurs sauvegardes incrémentielles, vous devez copier le fichier `res.txt` après la dernière sauvegarde incrémentielle afin de pouvoir l'appliquer à l'instance cible.
Les étapes sont les mêmes que dans [Phase 2 : Préparation de la sauvegarde complète des espaces de table](#oracle-migrating-tts.initial-br-phase), si ce n'est que l'étape d'importation est facultative.
## Phase 4 : Transport des espaces de table
Dans cette phase, vous sauvegardez vos espaces de table en lecture seule et exportez les métadonnées Data Pump, transférez ces fichiers vers votre hôte cible et importez à la fois les espaces de table et les métadonnées.
**Topics**
+ [
### Étape 1 : Sauvegarder vos espaces de table en lecture seule
](#oracle-migrating-tts.final-backup)
+ [
### Étape 2 : Exporter les métadonnées d'espace de table sur votre hôte source
](#oracle-migrating-tts.transport.export)
+ [
### Étape 3 : (Amazon S3 uniquement) Transférer les fichiers de sauvegarde et d'exportation vers votre instance de base de données cible
](#oracle-migrating-tts.transport)
+ [
### Étape 4 : Importer les espaces de table dans votre instance de base de données cible
](#oracle-migrating-tts.restore-full)
+ [
### Étape 5 : Importer les métadonnées d'espace de table dans votre instance de base de données cible
](#oracle-migrating-tts.transport.import-dmp)
### Étape 1 : Sauvegarder vos espaces de table en lecture seule
Cette étape est identique à [Étape 1 : Sauvegarder les espaces de table sur votre hôte source](#oracle-migrating-tts.backup-full), mais présente une différence clé : vous placez vos espaces de table en mode lecture seule avant de les sauvegarder pour la dernière fois.
L'exemple suivant place `tbs1`, `tbs2` et `tbs3` en mode lecture seule.
```
ALTER TABLESPACE tbs1 READ ONLY;
ALTER TABLESPACE tbs2 READ ONLY;
ALTER TABLESPACE tbs3 READ ONLY;
```
### Étape 2 : Exporter les métadonnées d'espace de table sur votre hôte source
Exportez les métadonnées de vos espaces de table en exécutant l'utilitaire `expdb` sur votre hôte source. L'exemple suivant exporte des tablespaces *TBS1**TBS2*, et *TBS3* vers un fichier de sauvegarde *xttdump.dmp* dans un répertoire. *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
```
S'il s'*DATA\$1PUMP\$1DIR*agit d'un répertoire partagé dans Amazon EFS, passez directement à[Étape 4 : Importer les espaces de table dans votre instance de base de données cible](#oracle-migrating-tts.restore-full).
### Étape 3 : (Amazon S3 uniquement) Transférer les fichiers de sauvegarde et d'exportation vers votre instance de base de données cible
Si vous utilisez Amazon S3 pour organiser vos sauvegardes d'espaces de table et votre fichier d'exportation Data Pump, procédez comme suit.
#### Étape 3.1 : Charger les sauvegardes et le fichier de vidage depuis votre hôte source dans votre compartiment Amazon S3
Chargez vos fichiers de sauvegarde et de vidage depuis votre hôte source dans votre compartiment Amazon S3. Pour plus d'informations, consultez [Chargement d'objets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*.
#### Étape 3.2 : Télécharger les sauvegardes et le fichier de vidage depuis votre compartiment Amazon S3 vers votre instance de base de données cible
Au cours de cette étape, vous utilisez la procédure `rdsadmin.rdsadmin_s3_tasks.download_from_s3` pour télécharger vos sauvegardes et le fichier de vidage vers votre instance de base de données RDS for Oracle. Suivez les étapes de [Étape 2.3 : Télécharger les sauvegardes depuis votre compartiment Amazon S3 vers votre instance de base de données cible](#oracle-migrating-tts.download-full).
### Étape 4 : Importer les espaces de table dans votre instance de base de données cible
Utilisez la procédure `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` pour restaurer les espaces de table. Pour la syntaxe et la sémantique de cette procédure, consultez [Importation des espaces de table transportés dans votre instance de base de données](rdsadmin_transport_util_import_xtts_tablespaces.md)
**Important**
Une fois l'importation finale de vos espaces de table terminée, l'étape suivante consiste à [importer les métadonnées Oracle Data Pump](#oracle-migrating-tts.transport.export). Si l'importation échoue, il est important de rétablir l'état de votre instance de base de données avant l'échec. Nous vous recommandons donc de créer un instantané de base de données de votre instance de base de données en suivant les instructions fournies dans [Création d’un instantané de base de données pour une instance de base de données mono-AZ pour Amazon RDS](USER_CreateSnapshot.md). Cet instantané contiendra tous les espaces de table importés. Ainsi, si l'importation échoue, vous n'avez pas besoin de répéter le processus de sauvegarde et d'importation.
Si les sauvegardes automatiques de votre instance de base de données cible sont activées et qu'Amazon RDS ne détecte pas qu'un instantané valide a été lancé avant que vous importiez les métadonnées, RDS tente de créer un instantané. En fonction de l'activité de votre instance, cet instantané peut réussir ou non. Si aucun instantané valide n'est détecté ou si un instantané ne peut pas être lancé, l'importation des métadonnées se termine avec des erreurs.
**Pour importer les espaces de table dans votre instance de base de données cible**
1. Démarrez un client Oracle SQL et connectez-vous en tant qu'utilisateur principal à votre instance de base de données RDS for Oracle cible.
1. Exécutez la procédure `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` en spécifiant les espaces de table à importer et le répertoire contenant les sauvegardes.
L'exemple suivant importe les tablespaces *TBS1**TBS2*, et *TBS3* depuis le répertoire. *DATA\$1PUMP\$1DIR*
```
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces('TBS1,TBS2,TBS3','DATA_PUMP_DIR');
END;
/
PRINT task_id
```
1. (Facultatif) Surveillez la progression en interrogeant la table `rdsadmin.rds_xtts_operation_info`. La colonne `xtts_operation_state` indique la valeur `EXECUTING`, `COMPLETED` ou `FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**Note**
Pour les opérations de longue durée, vous pouvez également interroger `V$SESSION_LONGOPS`, `V$RMAN_STATUS` et `V$RMAN_OUTPUT`.
1. Consultez le journal de l'importation terminée en utilisant l'ID de tâche issu de l'étape précédente.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Assurez-vous de la réussite de l'importation avant de passer à l'étape suivante.
1. Prenez un instantané de base de données manuel en suivant les instructions fournies dans [Création d’un instantané de base de données pour une instance de base de données mono-AZ pour Amazon RDS](USER_CreateSnapshot.md).
### Étape 5 : Importer les métadonnées d'espace de table dans votre instance de base de données cible
Au cours de cette étape, vous importez les métadonnées d'espace de table transportable dans votre instance de base de données RDS for Oracle en utilisant la procédure `rdsadmin.rdsadmin_transport_util.import_xtts_metadata`. Pour la syntaxe et la sémantique de cette procédure, consultez [Importation des métadonnées d'espaces de table transportables dans votre instance de base de données](rdsadmin_transport_util_import_xtts_metadata.md). Pendant l'opération, le statut de l'importation est indiqué dans la table `rdsadmin.rds_xtts_operation_info`.
**Important**
Avant d'importer les métadonnées, nous vous recommandons vivement de confirmer qu'un instantané de base de données a bien été créé après l'importation de vos espaces de table. Si l'étape d'importation échoue, restaurez votre instance de base de données, corrigez les erreurs d'importation, puis retentez l'importation.
**Pour importer les métadonnées Data Pump dans votre instance de base de données RDS for Oracle**
1. Démarrez votre client Oracle SQL et connectez-vous en tant qu'utilisateur principal à votre instance de base de données cible.
1. Créez les utilisateurs propriétaires des schémas dans vos espaces de table transportés, si ces utilisateurs n'existent pas encore.
```
CREATE USER tbs_owner IDENTIFIED BY password;
```
1. Importez les métadonnées en spécifiant le nom du fichier de vidage et l'emplacement du répertoire.
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
1. (Facultatif) Interrogez la table d'historique des espaces de table transportables pour voir le statut de l'importation des métadonnées.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
Une fois l'opération terminée, vos espaces de table sont en mode lecture seule.
1. (Facultatif) Affichez le fichier journal.
L'exemple suivant répertorie le contenu du répertoire BDUMP, puis interroge le journal d'importation.
```
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'));
```
## Phase 5 : Validation des espaces de table transportés
Dans cette étape facultative, vous validez vos espaces disque logiques transportés à l'aide de la procédure`rdsadmin.rdsadmin_rman_util.validate_tablespace`, puis vous les placez en mode. read/write
**Pour valider les données transportées**
1. Lancez SQL\$1Plus ou SQL Developer et connectez-vous en tant qu'utilisateur principal à votre instance de base de données cible.
1. Validez les espaces de table à l'aide de la procédure `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. Placez vos tablespaces en mode. read/write
```
ALTER TABLESPACE TBS1 READ WRITE;
ALTER TABLESPACE TBS2 READ WRITE;
ALTER TABLESPACE TBS3 READ WRITE;
```
## Phase 6 : Nettoyage des fichiers restants
Au cours de cette étape facultative, vous supprimez tous les fichiers inutiles. Utilisez la procédure `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` pour répertorier les fichiers de données devenus orphelins après une importation d'espace de table, puis utilisez la procédure `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` pour les supprimer. Pour la syntaxe et la sémantique de ces procédures, consultez [Établissement de la liste des fichiers orphelins après une importation d'espace de table](rdsadmin_transport_util_list_xtts_orphan_files.md) et [Suppression des fichiers de données devenus orphelins après une importation d'espace de table](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md).
**Pour nettoyer les fichiers restants**
1. Supprimez les anciennes sauvegardes *DATA\$1PUMP\$1DIR* comme suit :
1. Répertoriez les fichiers de sauvegarde en exécutant `rdsadmin.rdsadmin_file_util.listdir`.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'DATA_PUMP_DIR'));
```
1. Supprimez les sauvegardes une par une en appelant `UTL_FILE.FREMOVE`.
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'backup_filename');
```
1. Si vous avez importé des espaces de table mais n'avez pas importé de métadonnées pour ces espaces de table, vous pouvez supprimer les fichiers de données orphelins comme suit :
1. Répertoriez les fichiers de données orphelins que vous devez supprimer. L'exemple suivant exécute la procédure `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. Supprimez les fichiers orphelins en exécutant la procédure `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
L'opération de nettoyage génère un fichier journal qui utilise le format de nom `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` dans le répertoire `BDUMP`.
1. Lisez le fichier journal généré à l'étape précédente. L'exemple suivant lit le journal `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. Si vous avez importé des espaces de table et importé des métadonnées pour ces espaces de table, mais que vous avez rencontré des erreurs de compatibilité ou d'autres problèmes liés à Oracle Data Pump, nettoyez les fichiers de données partiellement transportés comme suit :
1. Répertoriez les espaces de table qui contiennent des fichiers de données partiellement transportés en interrogeant `DBA_TABLESPACES`.
```
SQL> SELECT TABLESPACE_NAME FROM DBA_TABLESPACES WHERE PLUGGED_IN='YES';
TABLESPACE_NAME
--------------------------------------------------------------------------------
TBS_3
```
1. Supprimez les espaces de table et les fichiers de données partiellement transportés.
```
DROP TABLESPACE TBS_3 INCLUDING CONTENTS AND DATAFILES;
```
# Importation à l'aide d'Oracle Data Pump
Oracle Data Pump est un utilitaire qui vous permet d'exporter des données Oracle vers un fichier de vidage et de les importer dans une autre base de données Oracle. Il s'agit d'un remplacement à long terme des Export/Import utilitaires Oracle. Oracle Data Pump est le moyen recommandé pour déplacer de grandes quantités de données d'une base de données Oracle vers une instance de base de données Amazon RDS.
Les exemples de cette section montrent une façon d'importer des données dans une base de données Oracle, mais Oracle Data Pump prend en charge d'autres techniques. Pour plus d'informations, consultez la [documentation Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump.html#GUID-501A9908-BCC5-434C-8853-9A6096766B5A).
Les exemples de cette section utilisent le package `DBMS_DATAPUMP`. Vous pouvez accomplir les mêmes tâches en utilisant les utilitaires de ligne de commande Oracle Data Pump `impdp` et `expdp`. Vous pouvez installer ces utilitaires sur un hôte distant dans le cadre d'une installation de client Oracle, y compris Oracle Instant Client. Pour obtenir plus d'informations, consultez la section [How do I use Oracle Instant Client to run Data Pump Import or Export for my Amazon RDS for Oracle DB instance?](https://aws.amazon.com/premiumsupport/knowledge-center/rds-oracle-instant-client-datapump/) (Comment utiliser Oracle Instant Client pour exécuter Data Pump Import ou Export pour mon instance de base de données Amazon RDS for Oracle ?
**Topics**
+ [
## Présentation d'Oracle Data Pump
](#Oracle.Procedural.Importing.DataPump.Overview)
+ [
## Importation de données avec Oracle Data Pump et un compartiment Amazon S3
](#Oracle.Procedural.Importing.DataPump.S3)
+ [
## Importation de données avec Oracle Data Pump et un lien de base de données
](#Oracle.Procedural.Importing.DataPump.DBLink)
## Présentation d'Oracle Data Pump
Oracle Data Pump est constitué des composants suivants :
+ Clients de la ligne de commande `expdp` et `impdp`
+ Le package `DBMS_DATAPUMP` PL/SQL
+ Le package `DBMS_METADATA` PL/SQL
Vous pouvez utiliser Oracle Data Pump dans les scénarios suivants :
+ Importez des données d'une base de données Oracle, sur site ou sur une instance Amazon EC2, vers une instance de base de données RDS for Oracle.
+ Importez des données d'une instance de base de données RDS for Oracle vers une base de données Oracle, sur site ou sur une instance Amazon EC2.
+ Importez des données entre des instances de base de données RDS for Oracle, par exemple pour migrer des données de EC2-Classic vers un VPC.
Pour télécharger les utilitaires Oracle Data Pump, consultez [Oracle Database Software Downloads](http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html) sur le site web Oracle Technology Network. Pour en savoir plus sur la compatibilité lors de la migration entre les versions d’Oracle Database, consultez [la documentation Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-BAA3B679-A758-4D55-9820-432D9EB83C68).
### Flux de travail Oracle Data Pump
En général, vous utilisez Oracle Data Pump pour les opérations suivantes :
1. Exportez vos données dans un fichier de vidage sur la base de données source.
1. Chargez votre fichier de vidage sur votre instance de base de données RDS for Oracle de destination. Vous pouvez effectuer le transfert à l'aide d'un compartiment Amazon S3 ou en utilisant un lien de base de données entre les deux bases de données.
1. Importez les données de votre fichier de vidage dans votre instance de base de données RDS for Oracle.
### Bonnes pratiques d'Oracle Data Pump
Lorsque vous utilisez Oracle Data Pump pour importer des données dans une instance RDS for Oracle, nous vous recommandons de suivre les bonnes pratiques suivantes :
+ Effectuez les importations en mode `schema` ou `table` pour importer des schémas et des objets spécifiques.
+ Limitez les schémas que vous importez à ceux requis par votre application.
+ N’importez pas en mode `full` ou importez des schémas pour les composants maintenus par le système.
Comme RDS for Oracle n'autorise pas l'accès aux utilisateurs administratifs `SYS` ou `SYSDBA`, ces actions peuvent endommager le dictionnaire de données Oracle et affecter la stabilité de votre base de données.
+ Lorsque vous chargez de grandes quantités de données, procédez comme suit :
1. Transférez le fichier de vidage vers l'instance de base de données RDS for Oracle cible.
1. Prenez un instantané de base de données de votre instance.
1. Testez l'importation pour en vérifier le bon fonctionnement.
Si les composants de la base de données sont invalidés, vous pouvez supprimer l'instance de base de données et la recréer à partir de l'instantané de base de données. L'instance de base de données restaurée inclut les fichiers de vidage intermédiaires sur l'instance de base de données lorsque vous avez pris l'instantané de base de données.
+ N'importez pas de fichiers de vidage qui ont été créés à l'aide des paramètres d'exportation d'Oracle Data Pump `TRANSPORT_TABLESPACES`, `TRANSPORTABLE` ou `TRANSPORT_FULL_CHECK`. Les instances de base de données RDS for Oracle ne prennent pas en charge l'importation de ces fichiers de vidage.
+ N'importez pas de fichiers de vidage contenant des objets Oracle Scheduler dans `SYS`, `SYSTEM`, `RDSADMIN`, `RDSSEC`, et `RDS_DATAGUARD` et appartenant aux catégories suivantes :
+ Tâches
+ Programmes
+ Schedules
+ Chaînes
+ Rules
+ Contextes d'évaluation
+ Ensemble de règles
Les instances de base de données RDS for Oracle ne prennent pas en charge l'importation de ces fichiers de vidage.
+ Pour exclure les objets Oracle Scheduler non pris en charge, utilisez des directives supplémentaires lors de l'exportation Data Pump. Si vous utilisez `DBMS_DATAPUMP`, vous pouvez ajouter un `METADATA_FILTER` supplémentaire avant le `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'
);
```
Si vous utilisez `expdp`, créez un fichier de paramètres contenant la directive `exclude` indiquée dans l'exemple suivant. Ensuite, utilisez `PARFILE=parameter_file` avec votre commande `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')
)
)"
```
## Importation de données avec Oracle Data Pump et un compartiment Amazon S3
Le processus d'importation suivant utilise Oracle Data Pump et un compartiment Amazon S3. La procédure est la suivante :
1. Exportez les données de la base de données source à l'aide du package Oracle [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html).
1. Placez le fichier de vidage dans un compartiment Amazon S3.
1. Téléchargez le fichier de vidage depuis le compartiment Amazon S3 vers le répertoire `DATA_PUMP_DIR` de l'instance de base de données RDS for Oracle cible.
1. Importez les données du fichier de vidage copié dans l'instance de base de données RDS for Oracle à l'aide du package `DBMS_DATAPUMP`.
**Topics**
+ [
### Conditions requises pour importer des données avec Oracle Data Pump et un compartiment Amazon S3
](#Oracle.Procedural.Importing.DataPumpS3.requirements)
+ [
### Étape 1 : accordez des privilèges à l'utilisateur de la base de données sur l'instance de base de données cible RDS for Oracle.
](#Oracle.Procedural.Importing.DataPumpS3.Step1)
+ [
### Étape 2 : exporter les données dans un fichier de vidage en utilisant DBMS\$1DATAPUMP
](#Oracle.Procedural.Importing.DataPumpS3.Step2)
+ [
### Étape 3 : Charger le fichier de vidage dans votre compartiment Amazon S3
](#Oracle.Procedural.Importing.DataPumpS3.Step3)
+ [
### Étape 4 : téléchargez le fichier de vidage depuis votre compartiment Amazon S3 vers votre instance de base de données cible.
](#Oracle.Procedural.Importing.DataPumpS3.Step4)
+ [
### Étape 5 : importez votre fichier de vidage dans votre instance de base de données cible en utilisant DBMS\$1DATAPUMP.
](#Oracle.Procedural.Importing.DataPumpS3.Step5)
+ [
### Étape 6 : nettoyer
](#Oracle.Procedural.Importing.DataPumpS3.Step6)
### Conditions requises pour importer des données avec Oracle Data Pump et un compartiment Amazon S3
Le processus est soumis aux exigences suivantes :
+ Assurez-vous qu'un compartiment Amazon S3 est disponible pour les transferts de fichiers et que le compartiment Amazon S3 se trouve dans le même emplacement Région AWS que l'instance de base de données. Pour plus d’informations, consultez [Créer un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) dans le *Guide de démarrage d’Amazon Simple Storage Service*.
+ L'objet que vous téléchargez dans le compartiment Amazon S3 doit être d'une taille inférieure ou égale à 5 To. Pour plus d'informations sur l'utilisation des objets dans Amazon S3, consultez le [Guide de l'utilisateur Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingObjects.html).
**Note**
Si le fichier de vidage dépasse 5 To, vous pouvez exécuter l'exportation Oracle Data Pump avec l'option parallèle. Cette opération répartit les données dans plusieurs fichiers de vidage de sorte que la taille de chaque fichier ne dépasse pas la limite de 5 To.
+ Vous devez préparer le compartiment Amazon S3 pour l'intégration Amazon RDS en suivant les instructions de [Configuration des autorisations IAM pour l'intégration de RDS for Oracle à Amazon S3](oracle-s3-integration.preparing.md).
+ Vous devez veiller à disposer de suffisamment d'espace de stockage pour stocker le fichier de vidage sur l'instance source et l'instance de base de données cible.
**Note**
Ce processus importe un fichier de vidage dans le répertoire `DATA_PUMP_DIR`, qui est préconfiguré sur toutes les instances de bases de données Oracle. Ce répertoire est situé sur le même volume de stockage que vos fichiers de données. Lorsque vous importez le fichier de vidage, les fichiers de données Oracle existants utilisent davantage d'espace. Vous devez donc veiller à ce que votre instance de base de données puisse répondre aux besoins de cette utilisation d'espace supplémentaire. Le fichier de vidage importé n'est pas automatiquement supprimé ou purgé du répertoire `DATA_PUMP_DIR`. Pour supprimer le fichier de vidage importé, utilisez [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), disponible sur le site web d’Oracle.
### Étape 1 : accordez des privilèges à l'utilisateur de la base de données sur l'instance de base de données cible RDS for Oracle.
Dans cette étape, vous créez les schémas dans lesquels vous prévoyez d'importer des données et vous accordez aux utilisateurs les privilèges nécessaires.
**Pour créer des utilisateurs et accorder les privilèges nécessaires sur l'instance cible RDS for Oracle**
1. Utilisez SQL\$1Plus ou Oracle SQL Developer pour vous connecter en tant qu'utilisateur principal à l'instance de la base de données RDS for Oracle dans laquelle les données seront importées. Pour en savoir plus sur la connexion à une instance de base de données, consultez [Connexion à votre instance de base de données Oracle](USER_ConnectToOracleInstance.md).
1. Créez les espaces de table requis avant d’importer les données. Pour plus d’informations, consultez [Création et dimensionnement de tablespaces dans RDS pour Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Créez le compte utilisateur et accordez les autorisations et les rôles nécessaires si le compte utilisateur dans lequel les données sont importées n'existe pas. Si vous importez des données avec plusieurs schémas d’utilisateur, créez chaque compte d’utilisateur et accordez-lui les privilèges et rôles nécessaires.
Par exemple, les instructions SQL suivantes créent un utilisateur et lui accordent les autorisations et rôles nécessaires pour importer les données dans le schéma de celui-ci : Remplacez `schema_1` par le nom de votre schéma dans cette étape et dans les étapes suivantes.
```
CREATE USER schema_1 IDENTIFIED BY my_password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**Note**
Spécifiez un mot de passe autre que celui indiqué ici, en tant que bonne pratique de sécurité.
Les instructions précédentes accordent au nouvel utilisateur le privilège `CREATE SESSION` et le rôle `RESOURCE`. Vous pouvez avoir besoin de privilèges et de rôles supplémentaires en fonction des objets de la base de données que vous importez.
### Étape 2 : exporter les données dans un fichier de vidage en utilisant DBMS\$1DATAPUMP
Pour créer un fichier de vidage, utilisez le package `DBMS_DATAPUMP`.
**Pour exporter des données Oracle dans un fichier de vidage**
1. Utilisez SQL Plus ou Oracle SQL Developer pour vous connecter à l'instance de base de données RDS for Oracle source avec un utilisateur administratif. Si la base de données source est une instance de base de données RDS for Oracle, connectez-vous avec l'utilisateur principal Amazon RDS.
1. Exportez les données en appelant des procédures `DBMS_DATAPUMP`.
Le script suivant exporte le schéma `SCHEMA_1` dans un fichier de vidage nommé `sample.dmp` dans le répertoire `DATA_PUMP_DIR`. Remplacez `SCHEMA_1` par le nom du schéma que vous souhaitez exporter.
```
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;
/
```
**Note**
Data Pump lance les tâches de manière asynchrone. Pour obtenir des informations sur la surveillance d’une tâche Data Pump, consultez [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) dans la documentation Oracle.
1. (Facultatif) Visualisez le contenu du journal d'exportation en appelant la procédure `rdsadmin.rds_file_util.read_text_file`. Pour plus d’informations, consultez [Lecture de fichiers dans un répertoire d'instance de base de données](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Étape 3 : Charger le fichier de vidage dans votre compartiment Amazon S3
Utilisez la procédure Amazon RDS `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` pour copier le fichier de vidage dans le compartiment Amazon S3. L’exemple suivant charge tous les fichiers du répertoire `DATA_PUMP_DIR` dans le compartiment Amazon S3 nommé `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'instruction `SELECT` renvoie l'ID de la tâche dans un type de données `VARCHAR2`. Pour plus d’informations, consultez [Chargement de fichiers depuis votre instance de base de données RDS for Oracle vers un compartiment Amazon S3](oracle-s3-integration.using.md#oracle-s3-integration.using.upload).
### Étape 4 : téléchargez le fichier de vidage depuis votre compartiment Amazon S3 vers votre instance de base de données cible.
Effectuez cette étape en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3`. Lorsque vous téléchargez un fichier dans un répertoire, la procédure `download_from_s3` ignore le téléchargement si un fichier de même nom existe déjà dans le répertoire. Pour supprimer un fichier du répertoire de téléchargement, utilisez [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), que vous trouverez sur le site Web d'Oracle.
**Pour télécharger votre fichier de vidage**
1. Lancez SQL\$1Plus ou Oracle SQL Developer et connectez-vous en tant que maître sur votre instance de base de données Oracle cible Amazon RDS.
1. Téléchargez le fichier de vidage en utilisant la procédure Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3`.
L'exemple suivant télécharge tous les fichiers d'un compartiment Amazon S3 nommé `amzn-s3-demo-bucket` dans le répertoire `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’instruction `SELECT` renvoie l’ID de la tâche dans un type de données `VARCHAR2`. Pour plus d’informations, consultez [Téléchargement des fichiers d'un compartiment Amazon S3 vers une instance de base de données Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Étape 5 : importez votre fichier de vidage dans votre instance de base de données cible en utilisant DBMS\$1DATAPUMP.
Utilisez `DBMS_DATAPUMP` pour importer le schéma dans votre instance de base de données RDS for Oracle. Des options supplémentaires telles que `METADATA_REMAP` peuvent être nécessaires.
**Pour importer des données dans votre instance de base de données cible**
1. Lancez SQL\$1Plus ou SQL Developer et connectez-vous en tant qu’utilisateur principal à votre instance de base de données RDS for Oracle.
1. Importez les données en appelant des procédures `DBMS_DATAPUMP`.
L'exemple suivant importe les *SCHEMA\$11* données depuis votre `sample_copied.dmp` instance de base de données cible.
```
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;
/
```
**Note**
Les tâches de vidage de données sont démarrées de façon asynchrone. Pour obtenir des informations sur la surveillance d’une tâche Data Pump, consultez [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) dans la documentation Oracle. Vous pouvez afficher le contenu du journal d'importation à l'aide de la procédure `rdsadmin.rds_file_util.read_text_file`. Pour plus d’informations, consultez [Lecture de fichiers dans un répertoire d'instance de base de données](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
1. Vérifiez l'importation des données en listant les tables de schéma sur votre instance de base de données cible.
Par exemple, la requête suivante renvoie le nombre de tables de `SCHEMA_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Étape 6 : nettoyer
Après l’importation des données, vous pouvez supprimer les fichiers que vous ne souhaitez plus conserver.
**Pour supprimer les fichiers inutiles**
1. Lancez SQL\$1Plus ou SQL Developer et connectez-vous en tant qu'utilisateur principal à votre instance de base de données RDS for Oracle.
1. Listez les fichiers dans `DATA_PUMP_DIR` en utilisant la commande suivante.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
1. Supprimez des fichiers dont vous n'avez plus besoin dans `DATA_PUMP_DIR`, utilisez la commande suivante :
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','filename');
```
Par exemple, la commande suivante supprime le fichier appelé `sample_copied.dmp`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
## Importation de données avec Oracle Data Pump et un lien de base de données
Le processus d'importation suivant utilise Oracle Data Pump et le package [DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_FILE_TRANSFER.html). La procédure est la suivante :
1. Connectez-vous à une base de données Oracle source, qui peut être une base de données sur site, une instance Amazon EC2 ou une instance de base de données RDS for Oracle.
1. Exportez des données à l'aide du package [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html).
1. Utilisez `DBMS_FILE_TRANSFER.PUT_FILE` pour copier le fichier de vidage de la base de données Oracle dans le répertoire `DATA_PUMP_DIR` de l'instance de base de données RDS for Oracle cible qui est connectée à l'aide d'un lien de base de données.
1. Importez les données du fichier de vidage copié dans l'instance de base de données RDS for Oracle à l'aide du package ` DBMS_DATAPUMP`.
Le processus d'importation utilisant Oracle Data Pump et le package `DBMS_FILE_TRANSFER` comporte les étapes suivantes :
**Topics**
+ [
### Conditions requises pour importer des données avec Oracle Data Pump et un lien vers une base de données
](#Oracle.Procedural.Importing.DataPumpDBLink.requirements)
+ [
### Étape 1 : accorder des privilèges à l'utilisateur sur l'instance de base de données cible de RDS for Oracle
](#Oracle.Procedural.Importing.DataPumpDBLink.Step1)
+ [
### Étape 2 : Accorder des privilèges à l'utilisateur sur la base de données source
](#Oracle.Procedural.Importing.DataPumpDBLink.Step2)
+ [
### Étape 3 : créer un fichier de vidage en utilisant DBMS\$1DATAPUMP
](#Oracle.Procedural.Importing.DataPumpDBLink.Step3)
+ [
### Étape 4 : créer un lien de base de données vers l'instance de base de données cible
](#Oracle.Procedural.Importing.DataPumpDBLink.Step4)
+ [
### Étape 5 : copier le fichier de vidage exporté vers l'instance de base de données cible en utilisant DBMS\$1FILE\$1TRANSFER
](#Oracle.Procedural.Importing.DataPumpDBLink.Step5)
+ [
### Étape 6 : importer le fichier de données vers l'instance de base de données cible en utilisant DBMS\$1DATAPUMP
](#Oracle.Procedural.Importing.DataPumpDBLink.Step6)
+ [
### Étape 7 : nettoyer
](#Oracle.Procedural.Importing.DataPumpDBLink.Step7)
### Conditions requises pour importer des données avec Oracle Data Pump et un lien vers une base de données
Le processus est soumis aux exigences suivantes :
+ Vous devez disposer des privilèges d'exécution sur les packages `DBMS_FILE_TRANSFER` et `DBMS_DATAPUMP`.
+ Vous devez disposer de privilèges d'écriture sur le répertoire `DATA_PUMP_DIR` de l'instance de base de données source.
+ Vous devez veiller à disposer de suffisamment d'espace de stockage pour stocker le fichier de vidage sur l'instance source et l'instance de base de données cible.
**Note**
Ce processus importe un fichier de vidage dans le répertoire `DATA_PUMP_DIR`, qui est préconfiguré sur toutes les instances de bases de données Oracle. Ce répertoire est situé sur le même volume de stockage que vos fichiers de données. Lorsque vous importez le fichier de vidage, les fichiers de données Oracle existants utilisent davantage d'espace. Vous devez donc veiller à ce que votre instance de base de données puisse répondre aux besoins de cette utilisation d'espace supplémentaire. Le fichier de vidage importé n'est pas automatiquement supprimé ou purgé du répertoire `DATA_PUMP_DIR`. Pour supprimer le fichier de vidage importé, utilisez [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), disponible sur le site web d’Oracle.
### Étape 1 : accorder des privilèges à l'utilisateur sur l'instance de base de données cible de RDS for Oracle
Pour accorder des privilèges à l'utilisateur sur l'instance de base de données cible RDS for Oracle, procédez comme suit :
1. Utilisez SQL Plus ou Oracle SQL Developer pour vous connecter à l'instance de la base de données RDS for Oracle dans laquelle vous souhaitez importer les données. Connectez-vous à l'utilisateur principal Amazon RDS. Pour plus d'informations sur la connexion à votre instance de base de données, consultez [Connexion à votre instance de base de données Oracle](USER_ConnectToOracleInstance.md).
1. Créez les espaces de table requis avant d'importer les données. Pour plus d'informations, consultez [Création et dimensionnement de tablespaces dans RDS pour Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Si le compte d'utilisateur dans lequel les données seront importées n'existe pas, créez-en un et accordez-lui les autorisations et rôles nécessaires. Si vous importez des données avec plusieurs schémas d’utilisateur, créez chaque compte d’utilisateur et accordez-lui les privilèges et rôles nécessaires.
Par exemple, les commandes suivantes créent un nouvel utilisateur nommé *schema\$11* et accordent les autorisations et les rôles nécessaires pour importer les données dans le schéma de cet utilisateur.
```
CREATE USER schema_1 IDENTIFIED BY my-password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**Note**
Spécifiez un mot de passe autre que celui indiqué ici, en tant que bonne pratique de sécurité.
L’exemple précédent montre comment accorder au nouvel utilisateur le privilège `CREATE SESSION` et le rôle `RESOURCE`. Des privilèges et rôles supplémentaires peuvent être requis en fonction des objets de la base de données que vous allez importer.
**Note**
Remplacez `schema_1` par le nom de votre schéma dans cette étape et dans les étapes suivantes.
### Étape 2 : Accorder des privilèges à l'utilisateur sur la base de données source
Utilisez SQL\$1Plus ou Oracle SQL Developer pour vous connecter à l'instance de la base de données RDS for Oracle qui contient les données à importer. Le cas échéant, créez un compte utilisateur et accordez les autorisations nécessaires.
**Note**
Si la base de données source est une instance Amazon RDS, vous pouvez ignorer cette étape. Vous allez utiliser votre compte d'utilisateur principal Amazon RDS for effectuer l'exportation.
Les commandes suivantes créent un nouvel utilisateur et accordent les autorisations nécessaires.
```
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;
```
**Note**
Spécifiez un mot de passe autre que celui indiqué ici, en tant que bonne pratique de sécurité.
### Étape 3 : créer un fichier de vidage en utilisant DBMS\$1DATAPUMP
Pour créer un fichier de vidage, procédez comme suit :
1. Utilisez SQL\$1Plus ou Oracle SQL Developer pour vous connecter à l'instance Oracle source avec un utilisateur administrateur ou avec l'utilisateur créé à l'étape 2. Si la base de données source est une instance de base de données Amazon RDS for Oracle, connectez-vous avec l'utilisateur principal Amazon RDS.
1. Créez un fichier de vidage à l'aide de l'utilitaire Oracle Data Pump.
Le script suivant crée un fichier de vidage appelé *sample.dmp* dans le répertoire `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;
/
```
**Note**
Les tâches de vidage de données sont démarrées de façon asynchrone. Pour obtenir des informations sur la surveillance d’une tâche Data Pump, consultez [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) dans la documentation Oracle. Vous pouvez afficher le contenu du journal d'exportation à l'aide de la procédure `rdsadmin.rds_file_util.read_text_file`. Pour plus d'informations, consultez [Lecture de fichiers dans un répertoire d'instance de base de données](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Étape 4 : créer un lien de base de données vers l'instance de base de données cible
Créez un lien de base de données entre votre instance de base de données source et votre instance de base de données cible. Notez que votre instance Oracle locale doit avoir une connectivité réseau à l'instance de base de données pour créer un lien de base de données et transférer votre fichier de vidage.
Exécutez cette étape en étant connecté au même compte d'utilisateur qu'à l'étape précédente.
Si vous créez un lien de base de données entre deux instances de base de données au sein du même VPC ou peered VPCs, les deux instances de base de données doivent avoir une route valide entre elles. Le groupe de sécurité de chaque instance de base de données doit autoriser le trafic entrant dans l'autre instance de base de données et le trafic sortant de cette instance. Les règles entrantes et sortantes des groupes de sécurité peuvent faire référence à des groupes de sécurité à partir du même VPC ou d'un VPC appairé. Pour plus d'informations, consultez [Réglage des liens de base de données pour une utilisation avec les instances de base de données dans un VPC](Appendix.Oracle.CommonDBATasks.DBLinks.md).
La commande suivante crée un lien de base de données appelé `to_rds` qui se connecte à l'utilisateur principal Amazon RDS au niveau de l'instance de base de données cible :
```
CREATE DATABASE LINK to_rds
CONNECT TO IDENTIFIED BY
USING '(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=)
(PORT=))(CONNECT_DATA=(SID=)))';
```
### Étape 5 : copier le fichier de vidage exporté vers l'instance de base de données cible en utilisant DBMS\$1FILE\$1TRANSFER
Utilisez `DBMS_FILE_TRANSFER` pour copier le fichier de vidage depuis l'instance de base de données source vers l'instance de base de données cible. Le script suivant copie un fichier de vidage appelé sample.dmp depuis l'instance source vers un lien de base de données cible appelé *to\$1rds* (créé dans l'étape précédente) :
```
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;
/
```
### Étape 6 : importer le fichier de données vers l'instance de base de données cible en utilisant DBMS\$1DATAPUMP
Utilisez Oracle Data Pump pour importer le schéma dans l'instance de base de données. Notez que des options supplémentaires comme METADATA\$1REMAP pourraient être obligatoires.
Connectez-vous à l'instance de base de données avec le compte d'utilisateur principal Amazon RDS for effectuer l'importation.
```
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;
/
```
**Note**
Les tâches de vidage de données sont démarrées de façon asynchrone. Pour obtenir des informations sur la surveillance d’une tâche Data Pump, consultez [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) dans la documentation Oracle. Vous pouvez afficher le contenu du journal d'importation à l'aide de la procédure `rdsadmin.rds_file_util.read_text_file`. Pour plus d'informations, consultez [Lecture de fichiers dans un répertoire d'instance de base de données](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
Vous pouvez vérifier l'importation des données en consultant les table de l'utilisateur sur l'instance de base de données. Par exemple, la requête suivante renvoie le nombre de tables de `schema_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Étape 7 : nettoyer
Après l'importation des données, vous pouvez supprimer les fichiers que vous ne souhaitez plus conserver. Vous pouvez répertorier les fichiers de `DATA_PUMP_DIR` à l'aide de la commande suivante.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
Pour supprimer des fichiers dont vous n'avez plus besoin dans `DATA_PUMP_DIR`, utilisez la commande suivante :
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','');
```
Par exemple, la commande suivante supprime le fichier appelé `"sample_copied.dmp"`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
# Importation avec les utilitaires d’importation/importation d’Oracle
Vous pouvez envisager les utilitaires d’importation/importation d’Oracle pour les migrations dans les conditions suivantes :
+ La taille de vos données est réduite.
+ Les types de données tels que les nombres flottants binaires et doubles ne sont pas nécessaires.
Le processus d'importation crée les objets de schéma nécessaires. Ainsi, vous n'avez pas besoin d'exécuter un script pour créer les objets au préalable.
La méthode la plus simple pour installer les utilitaires d'exportation et d'importation d'Oracle est d'installer le client instantané Oracle. Pour télécharger le logiciel, accédez à [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Pour la documentation, consultez [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) (Instant Client pour SQL\$1Loader, export et importation) dans le manuel *Oracle Database Utilities*.
**Pour exporter des tables et les importer ensuite**
1. Exportez les tables depuis la base de données source en utilisant la commande `exp`.
La commande suivante exporte les tables nommées `tab1`, `tab2` et `tab3`. Le fichier de vidage est `exp_file.dmp`.
```
exp cust_dba@ORCL FILE=exp_file.dmp TABLES=(tab1,tab2,tab3) LOG=exp_file.log
```
L'exportation crée un fichier de vidage binaire qui contient le schéma et les données pour les tables spécifiées.
1. Importez le schéma et les données dans une base de données cible à l'aide de la commande `imp`.
La commande suivante importe les tables `tab1`, `tab2` et `tab3` depuis le fichier de vidage `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
```
L'exportation et l'importation ont d'autres variantes qui pourraient être mieux adaptées à vos besoins. Consultez la documentation de la base de données Oracle pour plus de détails.
# Importation avec Oracle SQL\$1Loader
Vous pouvez envisager Oracle SQL\$1Loader pour les grandes bases de données qui contiennent un nombre limité d'objets. Comme le processus d'exportation à partir d'une base de données source et de chargement dans une base de données cible est spécifique au schéma, l'exemple suivant crée les objets du schéma type, exporte à partir d'une source, puis charge les données dans une base de données cible.
La méthode la plus simple pour installer Oracle SQL\$1Loader est d'installer Oracle Instant Client. Pour télécharger le logiciel, accédez à [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Pour la documentation, consultez [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) (Instant Client pour SQL\$1Loader, export et importation) dans le manuel *Oracle Database Utilities*.
**Pour importer des données avec Oracle SQL\$1Loader**
1. Créez une table source type en utilisant l'instruction SQL suivante.
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
```
1. Sur l'instance de base de données RDS for Oracle cible, créez une table de destination pour le chargement des données. La clause `WHERE 1=2` permet de copier la structure de `ALL_OBJECTS` sans copier aucune ligne.
```
CREATE TABLE customer_1 TABLESPACE users
AS (SELECT 0 AS ID, OWNER, OBJECT_NAME, CREATED
FROM ALL_OBJECTS
WHERE 1=2);
```
1. Exportez les données de la base de données source vers un fichier texte. L'exemple suivant utilise SQL\$1Plus. Pour vos données, vous pourrez avoir besoin de générer un script qui exporte tous les objets dans la base de données.
```
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. Créez un fichier de contrôle pour décrire les données. Vous devrez peut-être écrire un script pour réaliser cette étape.
```
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"
)
```
Le cas échéant, copiez les fichiers générés par le code précédent vers une zone tampon comme une instance Amazon EC2.
1. Importez les données en utilisant SQL\$1Loader avec le nom d'utilisateur et le mot de passe appropriés pour la base de données cible.
```
sqlldr cust_dba@targetdb CONTROL=sqlldr_1.ctl BINDSIZE=10485760 READSIZE=10485760 ROWS=1000
```
# Migration avec les vues matérialisées d'Oracle
Pour migrer efficacement de grands jeux de données, vous pouvez utiliser la réplication de vues matérialisées Oracle. Avec la réplication, vous pouvez maintenir les tables cibles synchronisées avec les tables sources. Ainsi, vous pouvez passer à Amazon RDS plus tard, si nécessaire.
Avant de procéder à une migration à l'aide de vues matérialisées, assurez-vous que vous remplissez les conditions suivantes :
+ Configurez l'accès de la base de données cible à la base de données source. Dans l'exemple suivant, les règles d'accès ont été activées sur la base de données source pour permettre à la base de données cible RDS for Oracle de se connecter à la source via SQL\$1Net.
+ Créez un lien de base de données entre l'instance de base de données RDS for Oracle et la base de données source.
**Pour migrer des données en utilisant des vues matérialisées**
1. Créez un compte utilisateur sur les instances RDS for Oracle source et cible que vous pouvez authentifier avec le même mot de passe. L’exemple suivant crée un utilisateur nommé `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;
```
**Note**
Spécifiez un mot de passe autre que celui indiqué ici, en tant que bonne pratique de sécurité.
1. Créez un lien de base de données entre l'instance cible RDS for Oracle et l'instance source en utilisant votre utilisateur nouvellement créé.
```
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)))';
```
**Note**
Spécifiez un mot de passe autre que celui indiqué ici, en tant que bonne pratique de sécurité.
1. Testez le lien :
```
SELECT * FROM V$INSTANCE@remote_site;
```
1. Créez un exemple de table avec une clé primaire et un journal des vues matérialisées sur l'instance source.
```
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. Sur l'instance de base de données RDS for Oracle cible, créez une vue matérialisée.
```
CREATE MATERIALIZED VIEW customer_0
BUILD IMMEDIATE REFRESH FAST
AS (SELECT *
FROM cust_dba.customer_0@remote_site);
```
1. Sur l'instance de base de données RDS for Oracle cible, actualisez la vue matérialisée.
```
EXEC DBMS_MVIEW.REFRESH('CUSTOMER_0', 'f');
```
1. Supprimez la vue matérialisée et ajoutez la clause `PRESERVE TABLE` pour conserver la table conteneur de la vue matérialisée et son contenu.
```
DROP MATERIALIZED VIEW customer_0 PRESERVE TABLE;
```
La table conservée a le même nom que la vue matérialisée supprimée.