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 PostgreSQL sur Amazon RDS
Supposons que vous disposez d'un déploiement PostgreSQL existant que vous souhaitez transférer dans Amazon RDS. La complexité de votre tâche dépend de la taille de votre base de données et des types d'objets de base de données que vous transférez. Prenons l'exemple d'une base de données qui contient des jeux de données se mesurant en gigaoctets, ainsi que des déclencheurs et des procédures stockés. Une telle base de données va être plus compliquée qu'une base de données simple avec seulement quelques mégaoctets de données de test et pas de déclencheurs, ni de procédures stockés.
Nous vous recommandons d'utiliser les outils de migration de base de données PostgreSQL natifs dans les conditions suivantes :
+ Vous avez une migration homogène, dans le sens où vous migrez depuis une base de données avec le même moteur de base de données que la base de données cible.
+ Vous migrez une base de données entière.
+ Les outils natifs vous permettent de migrer votre système avec une interruption minimale.
Dans la plupart des autres cas, la meilleure approche consiste à effectuer une migration AWS de base de données à l'aide du Service de migration de base de données (AWS DMS). AWS DMS peut migrer des bases de données sans interruption et, pour de nombreux moteurs de base de données, poursuivre la réplication continue jusqu'à ce que vous soyez prêt à passer à la base de données cible. Vous pouvez migrer vers le même moteur de base de données ou vers un autre moteur de base de données à l'aide de AWS DMS. Si vous migrez vers un moteur de base de données différent de celui de votre base de données source, vous pouvez utiliser le AWS Schema Conversion Tool (AWS SCT). Vous pouvez l'utiliser AWS SCT pour migrer des objets de schéma qui ne sont pas migrés par AWS DMS. Pour plus d'informations sur le AWS DMS, voir [Qu'est-ce que c'est ? AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
Modifiez votre groupe de paramètres de base de données pour inclure les paramètres suivants *pour votre importation uniquement*. Vous devez tester les réglages des paramètres pour déterminer les réglages les plus efficaces pour la taille de votre instance de base de données. Vous devez également revenir aux valeurs de production pour ces paramètres une fois votre importation terminée.
Modifiez les paramètres de l'instance de base de données comme suit :
+ Désactivez les sauvegardes de l'instance de base de données (affectez la valeur 0 à backup\$1retention).
+ Désactivez le mode multi-AZ.
Modifiez votre groupe de paramètres DB pour inclure les paramètres suivants. Vous devez utiliser ces paramètres uniquement lors de l'importation des données. Vous devez tester les réglages des paramètres pour déterminer les réglages les plus efficaces pour la taille de votre instance de base de données. Vous devez également revenir aux valeurs de production pour ces paramètres une fois votre importation terminée.
| Paramètre | Valeur recommandée lors de l'importation | Description |
| --- | --- | --- |
| `maintenance_work_mem` | 524288, 1048576, 2097152 ou 4194304 (en Ko). Ces paramètres sont comparables à 512 Mo, 1 Go, 2 Go et 4 Go. | La valeur de ce paramètre dépend de la taille de votre hôte. Ce paramètre est utilisé lors des instructions CREATE INDEX et chaque commande parallèle peut utiliser cette quantité de mémoire. Calculez la meilleure valeur afin de ne pas définir de valeur si élevée et risquer de manquer de mémoire. |
| `max_wal_size` | 256 (pour la version 9.6), 4096 (pour les versions 10 et ultérieures) | Taille maximale pour permettre au journal WAL de croître lors des points de contrôle automatiques. L'augmentation de ce paramètre peut augmenter le temps nécessaire à la reprise sur incident. Ce paramètre remplace `checkpoint_segments` pour PostgreSQL 9.6 et versions ultérieures. Pour PostgreSQL version 9.6, cette valeur est exprimée en unités de 16 Mo. Pour les versions ultérieures, la valeur est exprimée en unités de 1 Mo. Par exemple, dans la version 9.6, 128 signifie 128 fragments d'une taille de 16 Mo chacun. Dans la version 12.4, 2048 signifie 2048 fragments de 1 Mo chacun. |
| `checkpoint_timeout` | 1800 | La valeur de ce paramètre vous permet une rotation WAL moins fréquente. |
| `synchronous_commit` | Désactivé | Désactivez ce paramètre pour accélérer les écritures. Le fait de désactiver ce paramètre peut augmenter le risque de perte de données en cas de défaillance du serveur (ne désactivez pas FSYNC). |
| `wal_buffers` | 8192 | Cette valeur est en unités de 8 Ko. Cela permet de nouveau d'accélérer la génération WAL |
| `autovacuum` | 0 | Désactivez le paramètre auto-vacuum de PostgreSQL lorsque vous chargez des données afin qu'il n'utilise pas de ressources |
Utilisez les commandes `pg_dump -Fc` (compressé) ou `pg_restore -j` (parallèle) avec ces paramètres.
**Note**
La commande PostgreSQL `pg_dumpall` requiert des autorisations super\$1user qui ne sont pas accordées lorsque vous créez une instance de base de données, si bien qu'elle ne peut pas être utilisée pour importer des données.
**Topics**
+ [Importation d'une base de données PostgreSQL à partir d'une instance Amazon EC2](PostgreSQL.Procedural.Importing.EC2.md)
+ [Utilisation de la commande \$1copy pour importer des données dans une table sur une instance de base de données PostgreSQL](PostgreSQL.Procedural.Importing.Copy.md)
+ [Importation de données Amazon S3 dans une instance de base de données RDS for PostgreSQL d'un](USER_PostgreSQL.S3Import.md)
+ [Transport de bases de données PostgreSQL entre des instances de base de données](PostgreSQL.TransportableDB.md)
# Importation d'une base de données PostgreSQL à partir d'une instance Amazon EC2
Si vous possédez des données dans un serveur PostgreSQL sur une instance Amazon EC2 et que vous souhaitez les déplacer vers une instance de base de données PostgreSQL, vous pouvez suivre ce processus.
1. Créez un fichier contenant les données à charger à l'aide de pg\$1dump
1. Créez l'instance de base de données cible
1. Utilisez *psql* pour créer la base de données sur l'instance de base de données et pour charger les données
1. Créez un instantané de base de données de l'instance de base de données
Les sections suivantes fournissent plus de détails sur chacune des étapes indiquées ci-dessus.
## Étape 1 : Créer un fichier contenant les données à charger à l'aide de pg\$1dump
L'utilitaire `pg_dump` utilise la commande COPY pour créer un schéma et un vidage des données d'une base de données PostgreSQL. Le script de vidage généré par `pg_dump` charge les données dans une base de données dotée du même nom et recrée les tables, les index et les clés étrangères. Vous pouvez utiliser la commande `pg_restore` et le paramètre `-d` pour restaurer les données dans une base de données dotée d'un nom différent.
Avant de créer le vidage des données, vous devez interroger les tables à vider pour obtenir le nombre de lignes afin de pouvoir confirmer ce nombre sur l'instance de base de données cible.
La commande suivante crée un fichier de vidage mydb2dump.sql pour une base de données nommée mydb2.
```
prompt>pg_dump dbname=mydb2 -f mydb2dump.sql
```
## Étape 2 : Créer l'instance de bases de données cible
Créez l'instance de base de données PostgreSQL cible à l'aide soit de la console Amazon RDS, de l' AWS CLI ou de l'API. Créez l'instance avec le paramètre de rétention des sauvegardes défini sur 0 et désactivez le mode multi-AZ. Cela vous permet d'effectuer une importation plus rapide des données. Vous devez créer une base de données sur l'instance avant de pouvoir vider les données. La base de données peut avoir le même nom que celle qui contenait les données vidées. Sinon, vous pouvez créer une base de données avec un autre nom. Dans ce cas, vous pouvez utiliser la commande `pg_restore` et le paramètre `-d` pour restaurer les données dans une base de données dotée d'un nouveau nom.
Par exemple, les commandes suivantes permettent de vider, de restaurer et de renommer une base de données.
```
pg_dump -Fc -v -h [endpoint of instance] -U [master username] [database] > [database].dump
createdb [new database name]
pg_restore -v -h [endpoint of instance] -U [master username] -d [new database name] [database].dump
```
## Étape 3 : Utiliser psql pour créer la base de données sur l'instance de base de données et charger les données
Vous pouvez utiliser la même connexion que vous avez utilisée pour exécuter la commande pg\$1dump pour vous connecter à l'instance de base de données cible et recréer la base de données. Grâce à *psql*, vous pouvez utiliser l'identifiant principal et le mot de passe principal pour créer la base de données sur l'instance de base de données.
L'exemple suivant utilise *psql* et un fichier de vidage nommé mydb2dump.sql pour créer une base de données appelée mydb2 sur une instance de base de données PostgreSQL nommée mypginstance :
Pour Linux, macOS ou Unix :
```
psql \
-f mydb2dump.sql \
--host mypginstance.555555555555.aws-region.rds.amazonaws.com \
--port 8199 \
--username myawsuser \
--password password \
--dbname mydb2
```
Pour Windows :
```
psql ^
-f mydb2dump.sql ^
--host mypginstance.555555555555.aws-region.rds.amazonaws.com ^
--port 8199 ^
--username myawsuser ^
--password password ^
--dbname mydb2
```
**Note**
Spécifiez un mot de passe autre que celui indiqué ici, en tant que bonne pratique de sécurité.
## Étape 4 : Créer un instantané de base de données de l'instance de bases de données
Une fois que vous avez vérifié que les données ont été chargées dans votre instance de base de données, nous vous conseillons de créer un instantané de base de données de l'instance de base de données PostgreSQL cible. Les snapshots DB sont des sauvegardes complètes de votre instance de base de données qui peuvent être utilisées pour restaurer l'instance de base de données à un état connu. Un instantané de base de données pris immédiatement après le chargement vous évite de devoir charger les données à nouveau en cas d'incident. Vous pouvez également l'utiliser pour créer de nouvelles instances de base de données. Pour plus d'informations sur la création d'un instantané de base de données, consultez [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).
# Utilisation de la commande \$1copy pour importer des données dans une table sur une instance de base de données PostgreSQL
La commande PostgreSQL `\copy` est une méta-commande disponible à partir de l'outil client interactif `psql`. Vous pouvez utiliser `\copy` pour importer des données dans une table sur votre instance de base de données RDS pour PostgreSQL. Pour utiliser la commande `\copy`, vous devez d'abord créer la structure de la table sur l'instance de base de données cible, afin que `\copy` dispose d'une destination pour les données copiées.
Vous pouvez utiliser `\copy` pour charger des données à partir d'un fichier CSV (valeurs séparées par des virgules), par exemple un fichier qui a été exporté et enregistré sur votre poste de travail client.
Pour importer les données CSV vers l’instance de base de données RDS pour PostgreSQL cible, connectez-vous d’abord à l’instance de base de données cible à l’aide de `psql`.
```
psql --host=db-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=target-db
```
Exécutez ensuite la commande `\copy` avec les paramètres suivants afin d'identifier la cible pour les données et son format.
+ `target_table` : nom de la table devant recevoir les données copiées à partir du fichier CSV.
+ `column_list` : spécifications des colonnes pour la table.
+ `'filename'` : chemin d'accès complet vers le fichier CSV sur votre poste de travail local.
```
\copy target_table from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV;
```
Si votre fichier CSV contient des informations d'en-tête de colonne, vous pouvez utiliser cette version de la commande et des paramètres.
```
\copy target_table (column-1, column-2, column-3, ...)
from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV HEADER;
```
Si la commande `\copy` échoue, PostgreSQL renvoie des messages d'erreur.
Création d’une nouvelle instance de base de données dans la commande `psql` de l’environnement de version préliminaire de base de données avec la méta-commande `\copy` telle qu’illustrée dans les exemples suivants. Cet exemple utilise *source-table* comme nom de tableau source, *source-table.csv* comme fichier .csv et *target-db* comme base de données cible :
Pour Linux, macOS ou Unix :
```
$psql target-db \
-U \
-p \
-h \
-c "\copy source-table from 'source-table.csv' with DELIMITER ','"
```
Pour Windows :
```
$psql target-db ^
-U ^
-p ^
-h ^
-c "\copy source-table from 'source-table.csv' with DELIMITER ','"
```
Pour plus de détails sur la commande `\copy`, consultez la page [psql](http://www.postgresql.org/docs/current/static/app-psql.html) dans la documentation PostgreSQL, au sein de la section *Meta-Commands*.
# Importation de données Amazon S3 dans une instance de base de données RDS for PostgreSQL d'un
Vous pouvez importer des données qui ont été stockées à l'aide d'Amazon Simple Storage Service dans une table sur une instance de base de données RDS for PostgreSQL. Pour ce faire, vous devez d'abord installer l'extension `aws_s3` RDS for PostgreSQL. Cette extension fournit les fonctions que vous utilisez pour importer des données à partir d'un compartiment Amazon S3. Un *compartiment* est un conteneur Amazon S3 pour les objets et les fichiers. Les données peuvent résider dans un fichier CSV (valeur séparée par des virgules), un fichier texte ou un fichier compressé (gzip). Vous apprendrez ensuite comment installer l'extension et comment importer des données d'Amazon S3 dans un tableau.
Votre base de données doit exécuter PostgreSQL version 10.7 ou supérieure pour importer depuis Simple Storage Service (Amazon S3) vers RDS for PostgreSQL.
Si vous n'avez pas de données stockées sur Amazon S3, vous devez d'abord créer un compartiment et y stocker les données. Pour en savoir plus, consulter les rubriques suivantes dans le *Guide de l'utilisateur d'Amazon Simple Storage Service*.
+ [Créez un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#creating-bucket)
+ [Ajout d'un objet dans un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket)
L'importation entre comptes depuis Amazon S3 est prise en charge. Pour plus d’informations, consultez [Octroi d'autorisations entre comptes](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*.
Vous pouvez utiliser la clé gérée par le client pour le chiffrement lors de l'importation de données depuis S3. Pour plus d'informations, consultez [Clés KMS stockées dans AWS KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*.
**Topics**
+ [Installation de l'extension aws\$1s3](USER_PostgreSQL.S3Import.InstallExtension.md)
+ [Présentation de l’importation de données à partir de données Amazon S3](USER_PostgreSQL.S3Import.Overview.md)
+ [Configuration de l’accès à un compartiment Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md)
+ [Importation de données depuis Amazon S3 vers votre instance de base de données RDS pour PostgreSQL](USER_PostgreSQL.S3Import.FileFormats.md)
+ [Références de fonctions](USER_PostgreSQL.S3Import.Reference.md)
# Installation de l'extension aws\$1s3
Avant de pouvoir utiliser Amazon S3 avec votre instance de base de données RDS for PostgreSQL, vous devez installer l'extension. Cette extension fournit des fonctions pour importer des données depuis un compartiment Amazon S3. Il fournit également des fonctions pour exporter des données depuis une instance de base de données RDS for PostgreSQL vers un compartiment Amazon S3. Pour de plus amples informations, consultez [Exportation de données à partir d’une instance de base de données RDS pour PostgreSQL vers Amazon S3](postgresql-s3-export.md). L'extension `aws_s3` dépend de certaines des fonctions d'aide de l'extension `aws_commons`, qui est installée automatiquement lorsque cela est nécessaire.
**Pour installer l'extension `aws_s3`**
1. Utilisez psql (ou pgAdmin) pour vous connecter à l'instance de base de données RDS for PostgreSQL en tant qu'utilisateur disposant de privilèges `rds_superuser`. Si vous avez conservé le nom par défaut pendant le processus d'installation, vous vous connectez en tant que `postgres`.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Pour installer l'extension, exécutez la commande suivante.
```
postgres=> CREATE EXTENSION aws_s3 CASCADE;
NOTICE: installing required extension "aws_commons"
CREATE EXTENSION
```
1. Pour vérifier que l'extension est installée, vous pouvez utiliser la métacommande psql `\dx`.
```
postgres=> \dx
List of installed extensions
Name | Version | Schema | Description
-------------+---------+------------+---------------------------------------------
aws_commons | 1.2 | public | Common data types across AWS services
aws_s3 | 1.1 | public | AWS S3 extension for importing data from S3
plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language
(3 rows)
```
Les fonctions d'importation de données depuis Amazon S3 et d'exportation de données vers Amazon S3 sont désormais disponibles.
# Présentation de l’importation de données à partir de données Amazon S3
**Pour importer des données S3 dans Amazon RDS**
Tout d’abord, rassemblez les informations que vous devez fournir à la fonction. Il s'agit notamment du nom de la table sur l'instance de base de données RDS pour PostgreSQL, ainsi que du nom du compartiment, du chemin du fichier, du type de fichier et de l'endroit où Région AWS les données Amazon S3 sont stockées. Pour plus d’informations, consultez [View an object](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) (Afficher un objet) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.
**Note**
L’importation de données partitionnées depuis Amazon S3 n’est pas prise en charge actuellement.
1. Obtenez le nom de la table dans laquelle la fonction `aws_s3.table_import_from_s3` doit importer les données. À titre d’exemple, la commande suivante crée une table `t1` qui peut être utilisée dans les étapes suivantes.
```
postgres=> CREATE TABLE t1
(col1 varchar(80),
col2 varchar(80),
col3 varchar(80));
```
1. Obtenez les détails sur le compartiment Amazon S3 et les données à importer. Pour ce faire, ouvrez la console Amazon S3 à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/), puis choisissez **Buckets**. Trouvez le compartiment contenant vos données dans la liste. Sélectionnez le compartiment, ouvrez sa page Object overview (Présentation des objets), puis choisissez Properties (Propriétés).
Notez le nom du compartiment, le chemin Région AWS, le et le type de fichier. Vous aurez besoin du nom Amazon Resource Name (ARN) pour configurer l’accès à Amazon S3 via un rôle IAM. Pour obtenir plus d’informations, consultez [Configuration de l’accès à un compartiment Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md). L’image suivante montre un exemple.
![\[Image d’un objet fichier dans un compartiment Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/aws_s3_import-export_s3_bucket-info.png)
1. Vous pouvez vérifier le chemin d'accès aux données du compartiment Amazon S3 à l'aide de la AWS CLI commande`aws s3 cp`. Si les informations sont correctes, cette commande télécharge une copie du fichier Amazon S3.
```
aws s3 cp s3://amzn-s3-demo-bucket/sample_file_path ./
```
1. Configurez les autorisations sur votre instance de base de données RDS pour PostgreSQL pour permettre l’accès au fichier sur le compartiment Amazon S3. Pour ce faire, vous devez utiliser un rôle Gestion des identités et des accès AWS (IAM) ou des informations d'identification de sécurité. Pour de plus amples informations, veuillez consulter [Configuration de l’accès à un compartiment Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md).
1. Fournissez le chemin et les autres détails de l’objet Amazon S3 recueillis (voir l’étape 2) à la fonction `create_s3_uri` pour construire un objet URI Amazon S3. Pour en savoir plus sur cette fonction, consultez [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri). Voici un exemple de construction de cet objet pendant une session psql.
```
postgres=> SELECT aws_commons.create_s3_uri(
'docs-lab-store-for-rpg',
'versions_and_jdks_listing.csv',
'us-west-1'
) AS s3_uri \gset
```
Dans l’étape suivante, vous transmettez cet objet (`aws_commons._s3_uri_1`) à la fonction `aws_s3.table_import_from_s3` pour importer les données dans la table.
1. Appelez la fonction `aws_s3.table_import_from_s3` pour importer les données d’Amazon S3 dans votre table. Pour obtenir des informations de référence, consultez [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). Pour obtenir des exemples, consultez [Importation de données depuis Amazon S3 vers votre instance de base de données RDS pour PostgreSQL](USER_PostgreSQL.S3Import.FileFormats.md).
# Configuration de l’accès à un compartiment Amazon S3
Pour importer des données à partir d’un fichier Amazon S3, vous devez accorder à l’instance de base de données RDS pour PostgreSQL une autorisation d’accès au compartiment Amazon S3 contenant le fichier. Pour accorder l’accès à un compartiment Amazon S3, vous pouvez employer une des deux méthodes décrites dans les rubriques suivantes.
**Topics**
+ [Utilisation d’un rôle IAM pour accéder à un compartiment Amazon S3](#USER_PostgreSQL.S3Import.ARNRole)
+ [Utilisation d’informations d’identification de sécurité pour accéder à un compartiment Amazon S3](#USER_PostgreSQL.S3Import.Credentials)
+ [Résolution des problèmes d’accès à Amazon S3](#USER_PostgreSQL.S3Import.troubleshooting)
## Utilisation d’un rôle IAM pour accéder à un compartiment Amazon S3
Avant de charger des données à partir d’un fichier Amazon S3, accordez à votre instance de base de données RDS pour PostgreSQL l’autorisation d’accéder au compartiment Amazon S3 dans lequel se trouve le fichier. De cette façon, vous n’avez pas à gérer d’informations d’identification supplémentaires ni à les fournir dans l’appel de fonction [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
Pour ce faire, créez une politique IAM qui donne accès au compartiment Amazon S3. Créez un rôle IAM et attachez la politique à ce rôle. Attribuez ensuite le rôle IAM à votre instance de base de données.
**Pour permettre à une instance de base de données RDS for PostgreSQL d'accéder à Amazon S3 via un rôle IAM**
1. Créez une politique IAM.
Celle-ci fournit au compartiment et à l’objet les autorisations permettant à votre instance de base de données RDS pour PostgreSQL d’accéder à Amazon S3.
Incluez à la politique les actions obligatoires suivantes pour permettre le transfert de fichiers d’un compartiment Amazon S3 vers Amazon RDS :
+ `s3:GetObject`
+ `s3:ListBucket`
Incluez à la politique les ressources suivantes pour identifier le compartiment Amazon S3 et les objets qu’il contient. Voici le format Amazon Resource Name (ARN) permettant d’accéder à Amazon S3 :
+ arn:aws:s3 : *amzn-s3-demo-bucket*
+ arn:aws:s3 : :1 /\$1 *amzn-s3-demo-bucket*
Pour obtenir plus d’informations sur la création d’une politique IAM pour RDS pour PostgreSQL, consultez [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Consultez également [Didacticiel : création et attachement de votre première politique gérée par le client](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) dans le *Guide de l’utilisateur IAM*.
La AWS CLI commande suivante crée une politique IAM nommée `rds-s3-import-policy` avec ces options. Elle accorde un accès à un compartiment nommé *amzn-s3-demo-bucket*.
**Note**
Notez le Amazon Resource Name (ARN) de la politique renvoyée par cette commande. Vous en aurez besoin par la suite pour attacher la politique à un rôle IAM.
**Example**
Pour Linux, macOS ou Unix :
```
aws iam create-policy \
--policy-name rds-s3-import-policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3import",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
Pour Windows :
```
aws iam create-policy ^
--policy-name rds-s3-import-policy ^
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3import",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
1. Créez un rôle IAM.
L’objectif est ici de permettre à Amazon RDS d’endosser ce rôle IAM pour accéder à vos compartiments Amazon S3. Pour plus d’informations, consultez [Création d’un rôle pour déléguer des autorisations à un utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) dans le *Guide de l’utilisateur IAM*.
Nous vous recommandons d’utiliser les clés de contexte de condition globale `[aws:SourceArn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)` et `[aws:SourceAccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)` dans des politiques basées sur les ressources pour limiter les autorisations du service à une ressource spécifique. C’est le moyen le plus efficace de se protéger contre le [problème du député confus](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).
Si vous utilisez les deux clés de contexte de condition globale et que la valeur de `aws:SourceArn` contient l’ID de compte, la valeur de `aws:SourceAccount` et le compte indiqué dans la valeur de `aws:SourceArn` doivent utiliser le même ID de compte lorsqu’il est utilisé dans la même déclaration de politique.
+ Utilisez `aws:SourceArn` si vous souhaitez un accès interservices pour une seule ressource.
+ Utilisez `aws:SourceAccount` si vous souhaitez autoriser une ressource de ce compte à être associée à l’utilisation interservices.
Dans la politique, veillez à utiliser la clé de contexte de condition globale `aws:SourceArn` avec l’ARN complet de la ressource. L'exemple suivant montre comment procéder à l'aide de la AWS CLI commande pour créer un rôle nommé`rds-s3-import-role`.
**Example**
Pour Linux, macOS ou Unix :
```
aws iam create-role \
--role-name rds-s3-import-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:db:dbname"
}
}
}
]
}'
```
Pour Windows :
```
aws iam create-role ^
--role-name rds-s3-import-role ^
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:db:dbname"
}
}
}
]
}'
```
1. Attachez la politique IAM que vous avez créée au rôle IAM que vous venez de créer.
La AWS CLI commande suivante associe la politique créée à l'étape précédente au rôle nommé `rds-s3-import-role` Remplacer `your-policy-arn` par l'ARN de stratégie que vous avez noté à l'étape précédente.
**Example**
Pour Linux, macOS ou Unix :
```
aws iam attach-role-policy \
--policy-arn your-policy-arn \
--role-name rds-s3-import-role
```
Pour Windows :
```
aws iam attach-role-policy ^
--policy-arn your-policy-arn ^
--role-name rds-s3-import-role
```
1. Ajoutez le rôle IAM à l’instance de base de données.
Pour ce faire, utilisez le AWS Management Console ou AWS CLI, comme décrit ci-dessous.
### Console
**Pour ajouter un rôle IAM à l’instance de base de données PostgreSQL à l’aide de la console**
1. Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)l'adresse.
1. Choisissez le nom de l’instance de base de données PostgreSQL pour afficher ses détails.
1. Sous l’onglet **Connectivity & security** (Connectivité et sécurité), accédez à la section **Manage IAM roles** (Gérer les rôles IAM) et choisissez le rôle à ajouter sous **Add IAM roles to this instance** (Ajouter des rôles IAM à ce cluster/cette instance).
1. Sous **Feature** (Fonction), choisissez **s3Import**.
1. Choisissez **Add role** (Ajouter un rôle).
### AWS CLI
**Pour ajouter un rôle IAM à une instance de base de données PostgreSQL à l’aide de la CLI**
+ Utilisez la commande suivante pour ajouter le rôle à l’instance de base de données PostgreSQL nommée `my-db-instance`. Remplacez *`your-role-arn`* par l’ARN de rôle que vous avez noté lors d’une étape précédente. Utilisez `s3Import` comme valeur de l’option `--feature-name`.
**Example**
Pour Linux, macOS ou Unix :
```
aws rds add-role-to-db-instance \
--db-instance-identifier my-db-instance \
--feature-name s3Import \
--role-arn your-role-arn \
--region your-region
```
Pour Windows :
```
aws rds add-role-to-db-instance ^
--db-instance-identifier my-db-instance ^
--feature-name s3Import ^
--role-arn your-role-arn ^
--region your-region
```
### API RDS
Pour ajouter un rôle IAM pour une instance de cluster de base de données à l'aide de l'API Amazon RDS, appelez l'opération.
## Utilisation d’informations d’identification de sécurité pour accéder à un compartiment Amazon S3
Si vous préférez, au lieu de donner à accès un compartiment Amazon S3 avec un rôle IAM, vous pouvez utiliser des informations d’identification de sécurité. Pour ce faire, spécifiez le paramètre `credentials` dans l’appel de fonction [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
Le `credentials` paramètre est une structure de type contenant `aws_commons._aws_credentials_1` des AWS informations d'identification. Utilisez la fonction [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials) pour définir la clé d’accès et la clé secrète dans une structure `aws_commons._aws_credentials_1`, comme indiqué ci-après.
```
postgres=> SELECT aws_commons.create_aws_credentials(
'sample_access_key', 'sample_secret_key', '')
AS creds \gset
```
Après avoir créé la structure `aws_commons._aws_credentials_1 `, utilisez la fonction [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) avec le paramètre `credentials` pour importer les données, comme indiqué ci-après.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't', '', '(format csv)',
:'s3_uri',
:'creds'
);
```
Vous pouvez également inclure l’appel de fonction [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials) en ligne au sein de l’appel de fonction `aws_s3.table_import_from_s3`.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't', '', '(format csv)',
:'s3_uri',
aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '')
);
```
## Résolution des problèmes d’accès à Amazon S3
Si vous rencontrez des problèmes de connexion lorsque vous tentez d’importer des données depuis Amazon S3, consultez les recommandations suivantes :
+ [Résolution des problèmes liés à Identity and Access Amazon RDS](security_iam_troubleshoot.md)
+ [Dépannage d’Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/troubleshooting.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.
+ [Dépannage d’Amazon S3 et IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_iam-s3.html) dans le *Guide de l’utilisateur IAM*
# Importation de données depuis Amazon S3 vers votre instance de base de données RDS pour PostgreSQL
Vous importez des données depuis votre compartiment Amazon S3 en utilisant la fonction `table_import_from_s3` de l'extension aws\$1s3. Pour obtenir des informations de référence, consultez [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
**Note**
Les exemples suivants utilisent la méthode du rôle IAM pour donner accès au compartiment Amazon S3. Les appels de fonction `aws_s3.table_import_from_s3` n'incluent donc aucun paramètre d'informations d'identification.
L'exemple suivant montre un exemple typique.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't1',
'',
'(format csv)',
:'s3_uri'
);
```
Les paramètres sont les suivants :
+ `t1` – Nom de la table de l'instance de base de données PostgreSQL dans laquelle copier les données.
+ `''` – Liste facultative des colonnes de la table de base de données. Vous pouvez utiliser ce paramètre pour indiquer quelles colonnes des données S3 sont copiées dans quelles colonnes de table. Si aucune colonne n'est spécifiée, toutes les colonnes sont copiées dans la table. Pour obtenir un exemple d'utilisation d'une liste de colonnes, veuillez consulter [Importation d'un fichier Amazon S3 qui utilise un délimiteur personnalisé](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter).
+ `(format csv)` – Arguments PostgreSQL COPY. Le processus de copie utilise les arguments et le format de la commande [PostgreSQL COPY](https://www.postgresql.org/docs/current/sql-copy.html) pour importer les données. Les choix de format comprennent les valeurs séparées par des virgules (CSV) comme dans cet exemple, le texte et les données binaires. Par défaut, il s'agit de texte.
+ `s3_uri` – Structure contenant les informations d'identification du fichier Amazon S3. Pour obtenir un exemple d'utilisation de la fonction [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) pour créer une structure `s3_uri`, consultez [Présentation de l’importation de données à partir de données Amazon S3](USER_PostgreSQL.S3Import.Overview.md).
Pour plus d’informations sur cette fonction, consultez [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
La fonction `aws_s3.table_import_from_s3` retourne du texte. Pour spécifier d'autres types de fichiers à importer à partir d'un compartiment Amazon S3, consultez l'un des exemples suivants.
**Note**
L'importation d'un fichier de 0 octet entraîne une erreur.
**Topics**
+ [Importation d'un fichier Amazon S3 qui utilise un délimiteur personnalisé](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter)
+ [Importation d'un fichier compressé Amazon S3 (gzip)](#USER_PostgreSQL.S3Import.FileFormats.gzip)
+ [Importation d'un fichier codé Amazon S3](#USER_PostgreSQL.S3Import.FileFormats.Encoded)
## Importation d'un fichier Amazon S3 qui utilise un délimiteur personnalisé
L'exemple suivant montre comment importer un fichier qui utilise un délimiteur personnalisé. Il montre également comment définir l'emplacement de destination des données dans la table de base de données à l'aide du paramètre `column_list` de la fonction [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
Pour cet exemple, supposons que les informations suivantes sont organisées en colonnes délimitées par une barre verticale dans le fichier Amazon S3.
```
1|foo1|bar1|elephant1
2|foo2|bar2|elephant2
3|foo3|bar3|elephant3
4|foo4|bar4|elephant4
...
```
**Pour importer un fichier qui utilise un délimiteur personnalisé**
1. Créez une table dans la base de données pour les données importées.
```
postgres=> CREATE TABLE test (a text, b text, c text, d text, e text);
```
1. Utilisez le format suivant de la fonction [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) pour importer des données à partir du fichier Amazon S3.
Vous pouvez inclure l'appel de fonction [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) en ligne au sein de l'appel de fonction `aws_s3.table_import_from_s3` pour spécifier le fichier.
```
postgres=> SELECT aws_s3.table_import_from_s3(
'test',
'a,b,d,e',
'DELIMITER ''|''',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'pipeDelimitedSampleFile', 'us-east-2')
);
```
Les données se retrouvent désormais dans la table dans les colonnes suivantes.
```
postgres=> SELECT * FROM test;
a | b | c | d | e
---+------+---+---+------+-----------
1 | foo1 | | bar1 | elephant1
2 | foo2 | | bar2 | elephant2
3 | foo3 | | bar3 | elephant3
4 | foo4 | | bar4 | elephant4
```
## Importation d'un fichier compressé Amazon S3 (gzip)
L'exemple suivant montre comment importer un fichier compressé avec gzip à partir d'Amazon S3. Le fichier que vous importez doit comporter les métadonnées Amazon S3 suivantes :
+ Clé : `Content-Encoding`
+ Valeur : `gzip`
Si vous chargez le fichier à l'aide du AWS Management Console, les métadonnées sont généralement appliquées par le système. Pour plus d'informations sur le chargement de fichiers vers Amazon S3 à l'aide de, de AWS Management Console AWS CLI, ou de l'API, consultez la section [Chargement d'objets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) dans le guide de l'*utilisateur d'Amazon Simple Storage Service*.
Pour de plus amples informations sur les métadonnées Amazon S3 et les métadonnées fournies par le système, veuillez consulter [Editing object metadata in the Amazon S3 console](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-object-metadata.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*.
Importez le fichier gzip dans votreinstance de base de données RDS for PostgreSQL comme décrit ci-après.
```
postgres=> CREATE TABLE test_gzip(id int, a text, b text, c text, d text);
postgres=> SELECT aws_s3.table_import_from_s3(
'test_gzip', '', '(format csv)',
'amzn-s3-demo-bucket', 'test-data.gz', 'us-east-2'
);
```
## Importation d'un fichier codé Amazon S3
L'exemple suivant montre comment importer un fichier codé en Windows-1252 à partir d'Amazon S3.
```
postgres=> SELECT aws_s3.table_import_from_s3(
'test_table', '', 'encoding ''WIN1252''',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'SampleFile', 'us-east-2')
);
```
# Références de fonctions
**Topics**
+ [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3)
+ [aws\$1commons.create\$1s3\$1uri](#USER_PostgreSQL.S3Import.create_s3_uri)
+ [aws\$1commons.create\$1aws\$1credentials](#USER_PostgreSQL.S3Import.create_aws_credentials)
## aws\$1s3.table\$1import\$1from\$1s3
Importe les données Amazon S3 vers une table Amazon RDS. L'extension `aws_s3` fournit la fonction `aws_s3.table_import_from_s3`. La valeur renvoyée est du texte.
### Syntaxe
Les paramètres requis sont `table_name`, `column_list` et `options`. Ils identifient la table de base de données et spécifient la façon dont les données sont copiées dans la table.
Vous pouvez également utiliser les paramètres suivants :
+ Le paramètre `s3_info` spécifie le fichier Amazon S3 à importer. Lorsque vous utilisez ce paramètre, l'accès à Amazon S3 est fourni par un rôle IAM pour le l'instance de base de données PostgreSQL.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
s3_info aws_commons._s3_uri_1
)
```
+ Le paramètre `credentials` spécifie les informations d'identification permettant d'accéder à Amazon S3. Lorsque vous utilisez ce paramètre, vous n'utilisez pas de rôle IAM.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
s3_info aws_commons._s3_uri_1,
credentials aws_commons._aws_credentials_1
)
```
### Parameters
*table\$1name*
Chaîne de texte obligatoire contenant le nom de la table de base de données PostgreSQL dans laquelle importer les données.
*column\$1list*
Chaîne de texte obligatoire contenant la liste facultative des colonnes de la table de base de données PostgreSQL dans lesquelles copier les données. Si la chaîne est vide, toutes les colonnes de la table sont utilisées. Pour obtenir un exemple, veuillez consulter [Importation d'un fichier Amazon S3 qui utilise un délimiteur personnalisé](USER_PostgreSQL.S3Import.FileFormats.md#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter).
*options*
Chaîne de texte obligatoire contenant les arguments de la commande `COPY` de PostgreSQL. Ces arguments spécifient la façon dont les données sont copiées dans la table PostgreSQL. Pour plus d'informations, consultez la [documentation sur la commande COPY de PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*s3\$1info*
Type composite `aws_commons._s3_uri_1` contenant les informations suivantes sur l'objet S3 :
+ `bucket` – Nom du compartiment Amazon S3 contenant le fichier.
+ `file_path` – Nom du fichier Amazon S3, avec le chemin d'accès à celui-ci.
+ `region`— La AWS région dans laquelle se trouve le fichier. Pour obtenir la liste des noms de AWS régions et des valeurs associées, consultez[Régions, zones de disponibilité et zones locales ](Concepts.RegionsAndAvailabilityZones.md).
*credentials*
Type composite `aws_commons._aws_credentials_1` contenant les informations d'identification suivantes à utiliser pour l'opération d'importation :
+ Clé d'accès
+ Clé secrète
+ Jeton de session
Pour plus d'informations sur la création d'une structure composite `aws_commons._aws_credentials_1`, veuillez consulter [aws\$1commons.create\$1aws\$1credentials](#USER_PostgreSQL.S3Import.create_aws_credentials).
### Syntaxe alternative
Pour faciliter le test, vous pouvez utiliser un ensemble étendu de paramètres au lieu des paramètres `s3_info` et `credentials`. Plusieurs variations de syntaxe supplémentaires pour la fonction `aws_s3.table_import_from_s3` sont fournies ci-dessous.
+ Au lieu d'utiliser le paramètre `s3_info` pour identifier un fichier Amazon S3, utilisez la combinaison des paramètres `bucket`, `file_path` et `region`. Sous cette forme, l'accès à Amazon S3 est fourni par un rôle IAM sur l'instance de base de données PostgreSQL.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
bucket text,
file_path text,
region text
)
```
+ Au lieu d'utiliser le paramètre `credentials` pour spécifier l'accès à Amazon S3, utilisez la combinaison des paramètres `access_key`, `session_key` et `session_token`.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
bucket text,
file_path text,
region text,
access_key text,
secret_key text,
session_token text
)
```
### Autres paramètres
*bucket*
Chaîne de texte comportant le nom du compartiment Amazon S3 qui contient le fichier.
*file\$1path*
Chaîne de texte contenant le nom du fichier Amazon S3, avec le chemin d'accès à celui-ci.
*region*
Chaîne de texte identifiant l' Région AWS emplacement du fichier. Pour obtenir la liste des Région AWS noms et des valeurs associées, consultez[Régions, zones de disponibilité et zones locales ](Concepts.RegionsAndAvailabilityZones.md).
*access\$1key*
Chaîne de texte contenant la clé d'accès à utiliser pour l'opération d'importation. La valeur par défaut est NULL.
*secret\$1key*
Chaîne de texte contenant la clé secrète à utiliser pour l'opération d'importation. La valeur par défaut est NULL.
*session\$1token*
(Facultatif) Chaîne de texte contenant la clé de session à utiliser pour l'opération d'importation. La valeur par défaut est NULL.
## aws\$1commons.create\$1s3\$1uri
Crée une structure `aws_commons._s3_uri_1` pour contenir les informations relatives au fichier Amazon S3. Utilisez les résultats de la fonction `aws_commons.create_s3_uri` dans le paramètre `s3_info` de la fonction [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3).
### Syntaxe
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```
### Parameters
*bucket*
Chaîne de texte obligatoire contenant le nom du compartiment Amazon S3 pour le fichier.
*file\$1path*
Chaîne de texte obligatoire contenant le nom du fichier Amazon S3, avec le chemin d’accès à celui-ci.
*region*
Chaîne de texte obligatoire Région AWS contenant le contenu du fichier. Pour obtenir la liste des Région AWS noms et des valeurs associées, consultez[Régions, zones de disponibilité et zones locales ](Concepts.RegionsAndAvailabilityZones.md).
## aws\$1commons.create\$1aws\$1credentials
Définit une clé d'accès et une clé secrète dans une structure `aws_commons._aws_credentials_1`. Utilisez les résultats de la fonction `aws_commons.create_aws_credentials` dans le paramètre `credentials` de la fonction [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3).
### Syntaxe
```
aws_commons.create_aws_credentials(
access_key text,
secret_key text,
session_token text
)
```
### Parameters
*access\$1key*
Chaîne de texte obligatoire contenant la clé d'accès à utiliser pour l'importation d'un fichier Amazon S3. La valeur par défaut est NULL.
*secret\$1key*
Chaîne de texte obligatoire contenant la clé secrète à utiliser pour l'importation d'un fichier Amazon S3. La valeur par défaut est NULL.
*session\$1token*
Chaîne de texte facultative contenant le jeton de session à utiliser pour l'importation d'un fichier Amazon S3. La valeur par défaut est NULL. Si vous saisissez le paramètre `session_token` facultatif, vous pouvez utiliser les informations d'identification temporaires.
# Transport de bases de données PostgreSQL entre des instances de base de données
En utilisant les bases de données transportables PostgreSQL pour Amazon RDS, vous pouvez déplacer une base de données PostgreSQL entre deux instances de base de données. Il s'agit d'un moyen très rapide de migrer de grandes bases de données entre différentes instances de base de données. Pour utiliser cette approche, vos instances de base de données doivent toutes deux exécuter la même version majeure de PostgreSQL.
Cette fonctionnalité nécessite que vous installiez l'extension `pg_transport` sur les instances de base de données source et de destination. L'extension `pg_transport` fournit un mécanisme de transport physique qui déplace les fichiers de base de données avec un traitement minimal. Ce mécanisme déplace les données beaucoup plus rapidement que les processus traditionnels de vidage et de chargement, avec moins de temps d'arrêt.
**Note**
Les bases de données transportables PostgreSQL sont disponibles dans RDS for PostgreSQL versions 10.10 et ultérieures, ansi que versions 11.5 et ultérieures.
Pour transporter une instance de base de données PostgreSQL d'une instance de base de données RDS for PostgreSQL à une autre, vous devez d'abord configurer les instances source et de destination, comme indiqué dans la section [ Configuration d'instances de base de données pour leur transport](PostgreSQL.TransportableDB.Setup.md). Vous pouvez ensuite transporter la base de données à l'aide de la fonction décrite dans [ Transport d'une base de données PostgreSQL](PostgreSQL.TransportableDB.Transporting.md).
**Topics**
+ [Que se passe-t-il durant le transport d'une base de données ?](#PostgreSQL.TransportableDB.DuringTransport)
+ [Limites à l'utilisation de bases de données transportables PostgreSQL](#PostgreSQL.TransportableDB.Limits)
+ [Configuration pour le transport d'une base de données PostgreSQL](PostgreSQL.TransportableDB.Setup.md)
+ [Transport d'une base de données PostgreSQL vers la destination depuis la source](PostgreSQL.TransportableDB.Transporting.md)
+ [Référence des fonctions des base de données transportables](PostgreSQL.TransportableDB.transport.import_from_server.md)
+ [Référence des paramètres des bases de données transportables](PostgreSQL.TransportableDB.Parameters.md)
## Que se passe-t-il durant le transport d'une base de données ?
La fonction de bases de données transportables PostgreSQL utilisent un modèle d'extraction pour importer la base de données à partir de l'instance de base de données source. La fonction `transport.import_from_server` crée la base de données en transit sur l'instance de base de données de destination. La base de données en transit est inaccessible sur l'instance de base de données de destination pendant toute la durée du transport.
Lorsque le transport commence, toutes les sessions en cours sur la base de données source cessent. Les bases de données autres que la base de données source sur l'instance de base de données source ne sont pas affectées par le transport.
La base de données source est placée dans un mode lecture seule spécial. Lorsqu'elle est dans ce mode, vous pouvez vous connecter à la base de données source et exécuter des requêtes de lecture seule. Par contre, les requêtes d'écriture et certains autres types de commandes sont bloqués. Seule la base de données source qui fait l'objet du transport est affectée par ces restrictions.
Durant le transport, vous ne pouvez pas restaurer l'instance de base de données de destination à un instant dans le passé. En effet, le transport n'est pas transactionnel et n'utilise pas le journal write-ahead (WAL) PostgreSQL pour enregistrer les modifications. Si les sauvegardes automatiques sont activées sur l'instance de base de données de destination, une sauvegarde est automatiquement effectuée une fois le transport terminé. Point-in-timeles restaurations sont disponibles pendant un certain temps *après* la fin de la sauvegarde.
En cas d'échec du transport, l'extension `pg_transport` tente d'annuler toutes les modifications apportées aux instances de base de données source et de destination. Cela inclut la suppression de la base de données partiellement transportée sur la destination. Selon le type de défaillance, la base de données source peut continuer à rejeter les requêtes d'écriture. Si tel est le cas, utilisez la commande suivante pour autoriser les requêtes d'écriture.
```
ALTER DATABASE db-name SET default_transaction_read_only = false;
```
## Limites à l'utilisation de bases de données transportables PostgreSQL
Les bases de données transportables présentent les limites suivantes :
+ **Réplicas en lecture **– Vous ne pouvez pas utiliser des bases de données transportables sur des réplicas en lecture ou des instances parentes de réplicas en lecture.
+ **Types de colonne non pris en charge** – Vous ne pouvez pas utiliser les types de données `reg` dans des tables de bases de données que vous souhaitez transporter avec cette méthode. Ces types dépendent de l'objet du catalogue système IDs (OIDs), qui change souvent pendant le transport.
+ **Espaces de tables** – Tous les objets de base de données sources doivent se trouver dans l'espace de table `pg_default` par défaut .
+ **Compatibilité** – Les instances de base de données source et destination doivent exécuter la même version majeure de PostgreSQL.
+ **Extensions** : l'instance de base de données source ne peut avoir que `pg_transport` installé.
+ **Rôles et ACLs** — Les privilèges d'accès et les informations de propriété de la base de données source ne sont pas transférés vers la base de données de destination. Tous les objets de base de données sont créés par l'utilisateur de destination locale du transport et sont sa propriété.
+ **Transports simultanés** : une seule instance de base de données peut prendre en charge jusqu'à 32 transports simultanés, y compris les importations et les exportations, si les processus de travail ont été correctement configurés.
+ **Uniquement RDS pour les instances de bases de données PostgreSQL** : les bases de données transportables PostgreSQL ne sont prises en charge que sur les instances de base de données RDS for PostgreSQL. Vous ne pouvez pas l'utiliser avec des bases de données locales ou des bases de données exécutées sur Amazon EC2.
# Configuration pour le transport d'une base de données PostgreSQL
Avant de commencer, vérifiez que vos instances de base de données RDS pour PostgreSQL répondent aux exigences suivantes :
+ Les instances de base de données source et destination doivent exécuter la même version de PostgreSQL.
+ La base de données de destination ne peut pas avoir de base de données portant le même nom que la base de données source que vous souhaitez transporter.
+ Le compte que vous utilisez pour exécuter le transport doit avoir les privilèges `rds_superuser` sur les bases de données source et de destination.
+ Le groupe de sécurité de l'instance de base de données source doit autoriser l'accès entrant depuis l'instance de base de données de destination. C'est peut-être déjà le cas si vos instances de base de données source et de destination se trouvent dans le VPC. Pour plus d’informations sur les groupes de sécurité, consultez [Contrôle d’accès par groupe de sécurité](Overview.RDSSecurityGroups.md).
Le transport de bases de données d'une instance de base de données source vers une instance de base de données de destination nécessite plusieurs modifications apportées au groupe de paramètres de base de données associé à chaque instance. Cela signifie que vous devez créer un groupe de paramètres de base de données personnalisé pour l'instance de base de données source et créer un groupe de paramètres de base de données personnalisé pour l'instance de base de données de destination.
**Note**
Si vos instances de base de données sont déjà configurées à l'aide de groupes de paramètres de base de données personnalisés, vous pouvez commencer par l'étape 2 de la procédure suivante.
**Pour configurer les paramètres de groupe de base de données personnalisés pour le transport de bases de données**
Pour les étapes suivantes, utilisez un compte doté des privilèges `rds_superuser`.
1. Si les instances de base de données source et de destination utilisent un groupe de paramètres de base de données par défaut, vous devez créer un groupe de paramètres de base de données personnalisé à l’aide de la version appropriée pour vos instances. Vous pouvez ainsi modifier les valeurs de plusieurs paramètres. Pour de plus amples informations, veuillez consulter [Groupes de paramètres pour Amazon RDS](USER_WorkingWithParamGroups.md).
1. Dans le groupe de paramètres de base de données personnalisé, modifiez les valeurs des paramètres suivants :
+ `shared_preload_libraries` : ajoutez `pg_transport` à la liste des bibliothèques.
+ `pg_transport.num_workers` : la valeur par défaut est 3. Augmentez ou réduisez cette valeur au besoin pour votre base de données. Pour une base de données de 200 Go, nous recommandons de ne pas dépasser 8. N'oubliez pas que si vous augmentez la valeur par défaut de ce paramètre, vous devez également augmenter la valeur de `max_worker_processes`.
+ `pg_transport.work_mem` : la valeur par défaut est 128 Mo ou 256 Mo, selon la version PostgreSQL. Le paramètre par défaut peut généralement rester inchangé.
+ `max_worker_processes` : la valeur de ce paramètre doit être définie à l'aide du calcul suivant :
```
(3 * pg_transport.num_workers) + 9
```
Cette valeur est nécessaire au niveau de la destination pour gérer les divers processus employés en arrière-plan impliqués dans le transport. Pour en savoir plus sur `max_worker_processes,`, consultez [Resource Consumption](https://www.postgresql.org/docs/current/runtime-config-resource.html) (Consommation des ressources) dans la documentation de PostgreSQL.
Pour de plus amples informations sur les paramètres `pg_transport`, consultez [Référence des paramètres des bases de données transportables](PostgreSQL.TransportableDB.Parameters.md).
1. Redémarrez l’instance de base de données source RDS pour PostgreSQL et l’instance de destination pour que les paramètres prennent effet.
1. Connectez-vous à votre instance de base de données source RDS pour PostgreSQL.
```
psql --host=source-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Supprimez les extensions externes du schéma public de l'instance de base de données. Seule l'extension `pg_transport` est autorisée pendant l'opération de transport réelle.
1. Installez l'extension `pg_transport` comme suit :
```
postgres=> CREATE EXTENSION pg_transport;
CREATE EXTENSION
```
1. Connectez-vous à votre instance de base de données de destination RDS pour PostgreSQL. Supprimez toutes les extensions externes, puis installez l'extension `pg_transport`.
```
postgres=> CREATE EXTENSION pg_transport;
CREATE EXTENSION
```
# Transport d'une base de données PostgreSQL vers la destination depuis la source
Une fois terminé le processus décrit dans [Configuration pour le transport d'une base de données PostgreSQL](PostgreSQL.TransportableDB.Setup.md), vous pouvez démarrer le transport. Pour cela, exécutez la fonction `transport.import_from_server` sur l'instance de base de données de destination. Dans la syntaxe suivante, vous trouverez les paramètres de la fonction.
```
SELECT transport.import_from_server(
'source-db-instance-endpoint',
source-db-instance-port,
'source-db-instance-user',
'source-user-password',
'source-database-name',
'destination-user-password',
false);
```
Le valeur `false` illustrée dans l'exemple indique à la fonction qu'il ne s'agit pas d'un test. Pour tester la configuration de votre transport, vous pouvez spécifier `true` pour `dry_run` lorsque vous appelez la fonction, comme illustré ci-après :
```
postgres=> SELECT transport.import_from_server(
'docs-lab-source-db.666666666666aws-region.rds.amazonaws.com', 5432,
'postgres', '********', 'labdb', '******', true);
INFO: Starting dry-run of import of database "labdb".
INFO: Created connections to remote database (took 0.03 seconds).
INFO: Checked remote cluster compatibility (took 0.05 seconds).
INFO: Dry-run complete (took 0.08 seconds total).
import_from_server
--------------------
(1 row)
```
Les lignes INFO sont affichées car le paramètre `pg_transport.timing` est défini sur sa valeur par défaut, à savoir `true`. Définissez `dry_run` à la valeur `false` lorsque vous exécutez la commande et que la base de données source est importée vers la destination, comme indiqué ci-dessous :
```
INFO: Starting import of database "labdb".
INFO: Created connections to remote database (took 0.02 seconds).
INFO: Marked remote database as read only (took 0.13 seconds).
INFO: Checked remote cluster compatibility (took 0.03 seconds).
INFO: Signaled creation of PITR blackout window (took 2.01 seconds).
INFO: Applied remote database schema pre-data (took 0.50 seconds).
INFO: Created connections to local cluster (took 0.01 seconds).
INFO: Locked down destination database (took 0.00 seconds).
INFO: Completed transfer of database files (took 0.24 seconds).
INFO: Completed clean up (took 1.02 seconds).
INFO: Physical transport complete (took 3.97 seconds total).
import_from_server
--------------------
(1 row)
```
Cette fonction nécessite que vous fournissiez les mots de passe utilisateur de la base de données. Nous vous recommandons donc de modifier les mots de passe des rôles utilisateur que vous avez utilisés une fois le transport terminé. Vous pouvez aussi utiliser des variables de liaison SQL pour créer des rôles utilisateur temporaires. Utilisez ces rôles temporaires pour le transport, puis supprimez-les une fois que vous n'en avez plus besoin.
Si votre transport n'est pas réussi, vous pouvez voir un message d'erreur similaire à ce qui suit :
```
pg_transport.num_workers=8 25% of files transported failed to download file data
```
Le message d'erreur « Impossible de télécharger les données du fichier » indique que le nombre de processus de travail n'est pas défini correctement pour la taille de la base de données. Vous devrez peut-être augmenter ou diminuer la valeur définie pour `pg_transport.num_workers`. Chaque échec indique le pourcentage d'achèvement, afin que vous puissiez voir l'impact de vos modifications. Par exemple, la modification du paramètre de 8 à 4 dans un cas a entraîné les résultats suivants :
```
pg_transport.num_workers=4 75% of files transported failed to download file data
```
Gardez à l'esprit que le paramètre `max_worker_processes` est également pris en compte pendant le processus de transport. Autrement dit, vous devrez peut-être modifier à la fois `pg_transport.num_workers` et `max_worker_processes` pour transporter correctement la base de données. L'exemple présenté a finalement fonctionné lorsque le `pg_transport.num_workers` a été réglé sur 2 :
```
pg_transport.num_workers=2 100% of files transported
```
Pour plus d'informations sur la fonction `transport.import_from_server` et ses paramètres, veuillez consulter [Référence des fonctions des base de données transportables](PostgreSQL.TransportableDB.transport.import_from_server.md).
# Référence des fonctions des base de données transportables
La fonction `transport.import_from_server` transporte une base de données PostgreSQL en l'important d'une instance de base de données source vers une instance de base de données de destination. Elle effectue cette opération en utilisant un mécanisme de transport physique de connexion de base de données.
Avant de démarrer le transport, cette fonction vérifie que les instances de base de données source et de destination sont de la même version et sont compatibles avec la migration. Elle confirme également que l'instance de base de données de destination dispose de suffisamment d'espace pour la source.
**Syntaxe**
```
transport.import_from_server(
host text,
port int,
username text,
password text,
database text,
local_password text,
dry_run bool
)
```
**Valeur renvoyée**
Aucun.
**Paramètres**
Le tableau ci-dessous contient les descriptions des paramètres de la fonction `transport.import_from_server`.
****
| Paramètre | Description |
| --- | --- |
| host | Point de terminaison de l'instance de base de données source. |
| port | Entier représentant le port de l'instance de base de données source. Les instances de base de données PostgreSQL utilisent souvent le port 5432. |
| username | Utilisateur de l'instance de base de données source. Cet utilisateur doit être membre du rôle `rds_superuser`. |
| password | Mot de passe utilisateur de l'instance de base de données source. |
| database | Nom de la base de données à transporter à partir de l'instance de base de données source. |
| local\$1password | Mot de passe local de l'utilisateur actuel pour l'instance de base de données de destination. Cet utilisateur doit être membre du rôle `rds_superuser`. |
| dry\$1run | Valeur booléenne facultative spécifiant si un essai est nécessaire. La valeur par défaut est `false`, ce qui signifie que le transport est effectué.Pour vérifier la compatibilité entre les instances de base de données source et de destination sans effectuer le transport réel, définissez dry\$1run sur true. |
**Exemple**
Pour obtenir un exemple, consultez [Transport d'une base de données PostgreSQL vers la destination depuis la source](PostgreSQL.TransportableDB.Transporting.md).
# Référence des paramètres des bases de données transportables
Plusieurs paramètres contrôlent le comportement de l'extension `pg_transport`. Vous trouverez ci-dessous la description de ces paramètres.
**`pg_transport.num_workers`**
Le nombre d'unités de travail à utiliser pour le processus de transport. La valeur par défaut est 3. Les valeurs valides vont de 1 à 32. Même les transports de base de données les plus volumineux nécessitent généralement moins de 8 unités de travail. La valeur de ce paramètre sur l'instance de base de données de destination est utilisée par la destination et la source pendant le transport.
**`pg_transport.timing` **
Indique s'il faut signaler les informations de synchronisation pendant le transport. La valeur par défaut est `true`, ce qui signifie que les informations de synchronisation sont signalées. Nous vous recommandons de laisser ce paramètre défini sur `true` pour que vous puissiez suivre les progrès réalisés. Pour un exemple de sortie, veuillez consulter [Transport d'une base de données PostgreSQL vers la destination depuis la source](PostgreSQL.TransportableDB.Transporting.md).
**`pg_transport.work_mem`**
Quantité de mémoire maximale à allouer à chaque unité de travail. La valeur par défaut est 131 072 kilo-octets (Ko) ou 262 144 Ko (256 Mo), selon la version PostgreSQL. La valeur minimale est de 64 méga-octets (65 536 Ko). Les valeurs valides sont exprimées en kilo-octets (KBs) sous forme d'unités binaires en base 2, où 1 Ko = 1024 octets.
Le transport peut utiliser moins de mémoire que spécifié dans ce paramètre. Même les transports de base de données volumineux nécessitent généralement moins de 256 Mo (262 144 Ko) de mémoire par unité de travail.