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.
# Exportation de données à partir d’une instance de base de données RDS pour PostgreSQL vers Amazon S3
Vous pouvez interroger des données à partir d’une instance de base de données RDS pour PostgreSQL et les exporter directement dans des fichiers stockés dans un compartiment Amazon S3. Pour ce faire, vous devez d’abord installer l’extension `aws_s3` RDS pour PostgreSQL. Cette extension vous fournit les fonctions que vous utilisez pour exporter les résultats des requêtes vers Amazon S3. Vous trouverez ci-dessous comment installer l’extension et comment exporter des données vers Amazon S3.
**Note**
L’exportation intercompte vers Amazon S3 n’est pas prise en charge.
Toutes les versions actuellement disponibles de RDS pour PostgreSQL prennent en charge l’exportation de données vers Amazon Simple Storage Service. Pour des informations détaillées sur les versions, consultez [Mises à jour d’Amazon RDS pour PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-versions.html) dans *Notes de mise à jour d’Amazon RDS pour PostgreSQL*.
Si vous n’avez pas de compartiment configuré pour votre exportation, consultez les rubriques suivantes du *Guide de l’utilisateur d’Amazon Simple Storage Service*.
+ [Configuration d’Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/setting-up-s3.html)
+ [Création d’un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html)
Par défaut, les données exportées depuis RDS pour PostgreSQL vers Amazon S3 utilisent un chiffrement côté serveur avec une Clé gérée par AWS. Si vous utilisez le chiffrement par compartiment, le compartiment Amazon S3 doit être chiffré avec une clé AWS Key Management Service (AWS KMS) (SSE-KMS). Actuellement, les compartiments chiffrés avec des clés gérées par Amazon S3 (SSE-S3) ne sont pas pris en charge.
**Note**
Vous pouvez enregistrer les données des instantanés de base de données sur Amazon S3 à l'aide de l'API AWS Management Console AWS CLI, ou Amazon RDS. Pour de plus amples informations, veuillez consulter [Exportation de données d’instantanés de bases de données vers Amazon S3 pour Amazon RDS](USER_ExportSnapshot.md).
**Topics**
+ [Installation de l’extension aws\$1s3](#USER_PostgreSQL.S3Export.InstallExtension)
+ [Présentation de l’exportation de données vers Amazon S3](#postgresql-s3-export-overview)
+ [Spécification du chemin d’accès au fichier Amazon S3 vers lequel effectuer l’exportation](#postgresql-s3-export-file)
+ [Configuration de l’accès à un compartiment Amazon S3](postgresql-s3-export-access-bucket.md)
+ [Exportation de données de requête à l’aide de la fonction aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md)
+ [Références de fonctions](postgresql-s3-export-functions.md)
+ [Résolution des problèmes d'accès à Amazon S3](postgresql-s3-export-troubleshoot.md)
## Installation de l’extension aws\$1s3
Avant de pouvoir utiliser Amazon Simple Storage Service avec votre instance de base de données RDS pour PostgreSQL, vous devez installer l’extension `aws_s3`. Cette extension fournit des fonctions pour exporter des données depuis une instance de base de données RDS pour PostgreSQL vers un compartiment Amazon S3. Il fournit également des fonctions pour importer des données depuis un compartiment Amazon S3. Pour plus d’informations, consultez [Importation de données Amazon S3 dans une instance de base de données RDS for PostgreSQL d'un ](USER_PostgreSQL.S3Import.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 pour 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.
### Vérifiez que votre version de RDS pour PostgreSQL Aurora PostgreSQL en charge les exportations vers Amazon S3
Vous pouvez vérifier que votre version de RDS pour PostgreSQL prend en charge l’exportation vers Amazon S3 en utilisant la commande `describe-db-engine-versions`. L’exemple suivant vérifie la prise en charge de la version 10.14.
```
aws rds describe-db-engine-versions --region us-east-1
--engine postgres --engine-version 10.14 | grep s3Export
```
Si la sortie inclut la chaîne `"s3Export"`, le moteur prend en charge les exportations Amazon S3. Sinon, le moteur ne les prend pas en charge.
## Présentation de l’exportation de données vers Amazon S3
Pour exporter des données stockées dans un RDS pour PostgreSQL vers un compartiment Amazon S3, procédez comme suit.
**Pour exporter des données RDS pour PostgreSQL vers S3**
1. Identifiez un chemin d’accès de fichier Amazon S3 à utiliser pour exporter des données. Pour plus d’informations sur ce processus, consultez [Spécification du chemin d’accès au fichier Amazon S3 vers lequel effectuer l’exportation](#postgresql-s3-export-file).
1. Fournissez une autorisation d’accès au compartiment Amazon S3.
Pour exporter des données vers un fichier Amazon S3, vous devez accorder à l’instance de base de données RDS pour PostgreSQL l’autorisation d’accéder au compartiment Amazon S3 que l’exportation utilisera pour le stockage. Cette opération comprend les étapes suivantes :
1. Créez une politique IAM donnant accès à un compartiment Amazon S3 vers lequel vous souhaitez exporter.
1. Créez un rôle IAM.
1. Attachez la politique que vous avez créée au rôle que vous avez créé.
1. Ajoutez ce rôle IAM à votre instance de base de données.
Pour plus d’informations sur ce processus, consultez [Configuration de l’accès à un compartiment Amazon S3](postgresql-s3-export-access-bucket.md).
1. Identifiez une requête de base de données pour obtenir les données. Exportez les données de requête en appelant la fonction `aws_s3.query_export_to_s3`.
Après avoir terminé les tâches de préparation précédentes, utilisez la fonction [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) pour exporter les résultats de requête vers Amazon S3. Pour plus d’informations sur ce processus, consultez [Exportation de données de requête à l’aide de la fonction aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
## Spécification du chemin d’accès au fichier Amazon S3 vers lequel effectuer l’exportation
Spécifiez les informations suivantes pour identifier l’emplacement dans Amazon S3 vers lequel vous souhaitez exporter des données :
+ Nom du compartiment : un *compartiment* est un conteneur d’objets ou de fichiers Amazon S3.
Pour plus d’informations sur le stockage de données avec Amazon S3, consultez [Création d’un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) et [Utilisation des objets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-downloading-objects.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.
+ Chemin d’accès au fichier : le chemin d’accès au fichier identifie l’emplacement de stockage de l’exportation dans le compartiment Amazon S3. Le chemin d’accès au fichier se compose des éléments suivants :
+ Préfixe de chemin facultatif qui identifie un chemin d’accès à un dossier virtuel.
+ Préfixe de fichier qui identifie un ou plusieurs fichiers à stocker. Les exportations les plus volumineuses sont stockées dans plusieurs fichiers, chacun ayant une taille maximale d’environ 6 Go. Les noms de fichiers supplémentaires ont le même préfixe de fichier mais en ajoutant `_partXX`. `XX` représente 2, puis 3, et ainsi de suite.
Par exemple, un chemin d’accès de fichier avec un dossier `exports` et un préfixe de fichier `query-1-export` sera représenté par `/exports/query-1-export`.
+ AWS Région (facultatif) : AWS région dans laquelle se trouve le compartiment Amazon S3. Si vous ne spécifiez aucune valeur de AWS région, Amazon RDS enregistre vos fichiers dans Amazon S3 dans la même AWS région que l'instance de base de données du cluster exportant.
**Note**
Actuellement, la AWS région doit être identique à la région de l'instance de base de données du de bases de données exportatrice.
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).
Pour conserver les informations de fichier Amazon S3 sur l’emplacement de stockage de l’exportation, vous pouvez utiliser la fonction [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri) pour créer une structure composite `aws_commons._s3_uri_1` comme suit.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Vous fournissez ultérieurement cette valeur `s3_uri_1` en tant que paramètre dans l’appel à la fonction [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Pour obtenir des exemples, consultez [Exportation de données de requête à l’aide de la fonction aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
# Configuration de l’accès à un compartiment Amazon S3
Pour exporter des données vers Amazon S3, accordez à votre instance l’autorisation d’accéder au compartiment Amazon S3 dans lequel les fichiers doivent être stockés.
Pour cela, procédez comme suit :
**Pour donner à une instance de base de données PostgreSQL l’accès à Amazon S3 via un rôle IAM**
1. Créez une politique IAM.
Cette stratégie fournit le compartiment et les autorisations d’objet permettant à votre instance de base de données PostgreSQL d’accéder à Amazon S3.
Dans le cadre de la création de cette politique, procédez comme suit :
1. Incluez dans la stratégie les actions obligatoires suivantes pour permettre le transfert de fichiers de votre instance de base de données PostgreSQL vers un compartiment Amazon S3 :
+ `s3:PutObject`
+ `s3:AbortMultipartUpload`
1. Incluez l’Amazon Resource Name (ARN) qui identifie le compartiment Amazon S3 et les objets du compartiment. Le format ARN pour l’accès à Amazon S3 est le suivant : `arn:aws:s3:::amzn-s3-demo-bucket/*`
Pour plus d’informations sur la création d’une politique IAM pour Amazon 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-export-policy` avec ces options. Elle accorde un accès à un compartiment nommé *amzn-s3-demo-bucket*.
**Avertissement**
Nous vous recommandons de configurer votre base de données dans un VPC privé dont les politiques de point de terminaison sont configurées pour accéder à des compartiments spécifiques. Pour plus d’informations, consultez [Utilisation des stratégies de point de terminaison pour Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html#vpc-endpoints-policies-s3) dans le Guide de l’utilisateur Amazon VPC.
Nous vous recommandons vivement de ne pas créer de politique avec accès à toutes les ressources. Cet accès peut constituer une menace pour la sécurité des données. Si vous créez une stratégie qui accorde à `S3:PutObject` un accès à toutes les ressources à l’aide de `"Resource":"*"`, un utilisateur disposant de privilèges d’exportation peut exporter des données vers tous les compartiments de votre compte. En outre, l’utilisateur peut exporter des données vers *n’importe quel compartiment accessible publiquement en écriture dans votre région AWS *.
Après avoir créé la politique, notez son ARN (Amazon Resource Name). Vous en aurez besoin par la suite pour attacher la politique à un rôle IAM.
```
aws iam create-policy --policy-name rds-s3-export-policy --policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3export",
"Action": [
"s3:PutObject*",
"s3:ListBucket",
"s3:GetObject*",
"s3:DeleteObject*",
"s3:GetBucketLocation",
"s3:AbortMultipartUpload"
],
"Effect": "Allow",
"Resource": [
"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 en votre nom 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-export-role`.
**Example**
Pour Linux, macOS ou Unix :
```
aws iam create-role \
--role-name rds-s3-export-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-export-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 précédemment au rôle nommé `rds-s3-export-role.` Remplacer `your-policy-arn` par l'ARN de stratégie que vous avez noté lors d'une étape précédente.
```
aws iam attach-role-policy --policy-arn your-policy-arn --role-name rds-s3-export-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. Dans l’onglet **Connectivité & sécurité** de la section **Gérer les rôles IAM**, choisissez le rôle à ajouter sous **Ajouter des rôles IAM à cette instance**.
1. Sous **Fonctionnalité**, choisissez **s3Export**.
1. Choisissez **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 `s3Export` 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 s3Export \
--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 s3Export ^
--role-arn your-role-arn ^
--region your-region
```
# Exportation de données de requête à l’aide de la fonction aws\$1s3.query\$1export\$1to\$1s3
Exportez vos données PostgreSQL vers Amazon S3 en appelant la fonction [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3).
**Topics**
+ [Conditions préalables](#postgresql-s3-export-examples-prerequisites)
+ [Appel de aws\$1s3.query\$1export\$1to\$1s3](#postgresql-s3-export-examples-basic)
+ [Exportation vers un fichier CSV qui utilise un délimiteur personnalisé](#postgresql-s3-export-examples-custom-delimiter)
+ [Exportation vers un fichier binaire avec encodage](#postgresql-s3-export-examples-encoded)
## Conditions préalables
Avant d’utiliser la fonction `aws_s3.query_export_to_s3`, assurez-vous de remplir les conditions préalables suivantes :
+ Installez les extensions PostgreSQL requises comme décrit dans [Présentation de l’exportation de données vers Amazon S3](postgresql-s3-export.md#postgresql-s3-export-overview).
+ Déterminez vers quel emplacement Amazon S3 exporter vos données comme décrit dans [Spécification du chemin d’accès au fichier Amazon S3 vers lequel effectuer l’exportation](postgresql-s3-export.md#postgresql-s3-export-file).
+ Assurez-vous que l’instance de base de données dispose d’un accès à Amazon S3 comme décrit dans [Configuration de l’accès à un compartiment Amazon S3](postgresql-s3-export-access-bucket.md).
Les exemples suivants utilisent une table de base de données appelée `sample_table`. Ces exemples exportent les données dans un compartiment appelé *amzn-s3-demo-bucket*. Les exemples de table et de données sont créés avec les instructions SQL suivantes dans psql.
```
psql=> CREATE TABLE sample_table (bid bigint PRIMARY KEY, name varchar(80));
psql=> INSERT INTO sample_table (bid,name) VALUES (1, 'Monday'), (2,'Tuesday'), (3, 'Wednesday');
```
## Appel de aws\$1s3.query\$1export\$1to\$1s3
Ce qui suit montre les techniques de base permettant d’appeler la fonction [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3).
Ces exemples utilisent la variable `s3_uri_1` pour identifier une structure contenant les informations identifiant le fichier Amazon S3. Utilisez la fonction [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri) pour créer la structure.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Bien que les paramètres varient pour les deux appels de fonction `aws_s3.query_export_to_s3` suivants, les résultats sont les mêmes pour ces exemples. Toutes les lignes de la table `sample_table` sont exportées dans un compartiment appelé *amzn-s3-demo-bucket*.
```
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1');
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1', options :='format text');
```
Les paramètres sont décrits comme suit :
+ `'SELECT * FROM sample_table'` – Le premier paramètre est une chaîne de texte obligatoire contenant une requête SQL. Le moteur PostgreSQL exécute cette requête. Les résultats de la requête sont copiés dans le compartiment S3 identifié dans d’autres paramètres.
+ `:'s3_uri_1'` – Ce paramètre est une structure qui identifie le fichier Amazon S3. Cet exemple utilise une variable pour identifier la structure créée précédemment. Vous pouvez plutôt créer la structure en incluant l’appel de fonction `aws_commons.create_s3_uri` en ligne dans l’appel de fonction `aws_s3.query_export_to_s3` comme suit.
```
SELECT * from aws_s3.query_export_to_s3('select * from sample_table',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'sample-filepath', 'us-west-2')
);
```
+ `options :='format text'` – Le paramètre `options` est une chaîne de texte facultative contenant des arguments `COPY` PostgreSQL. Le processus de copie utilise les arguments et le format de la commande [PostgreSQL COPY](https://www.postgresql.org/docs/current/sql-copy.html).
Si le fichier spécifié n’existe pas dans le compartiment Amazon S3, il est créé. Si le fichier existe déjà, il est remplacé. La syntaxe d’accès aux données exportées dans Amazon S3 est la suivante.
```
s3-region://bucket-name[/path-prefix]/file-prefix
```
Les exportations les plus volumineuses sont stockées dans plusieurs fichiers, chacun ayant une taille maximale d’environ 6 Go. Les noms de fichiers supplémentaires ont le même préfixe de fichier mais en ajoutant `_partXX`. `XX` représente 2, puis 3, et ainsi de suite. Par exemple, supposons que vous spécifiiez le chemin d’accès où vous stockez les fichiers de données comme suit.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
```
Si l’exportation doit créer trois fichiers de données, le compartiment Amazon S3 contient les fichiers de données suivants.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part2
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part3
```
Pour obtenir la référence complète de cette fonction et les moyens supplémentaires de l’appeler, consultez [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Pour plus d’informations sur l’accès aux fichiers dans Amazon S3, consultez [Afficher un objet](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.
## Exportation vers un fichier CSV qui utilise un délimiteur personnalisé
L’exemple suivant montre comment appeler la fonction [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) pour exporter des données vers un fichier qui utilise un délimiteur personnalisé. L’exemple utilise les arguments de la commande [PostgreSQL COPY](https://www.postgresql.org/docs/current/sql-copy.html) pour spécifier le format CSV (valeur séparée par des virgules) et un délimiteur deux-points ( :).
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format csv, delimiter $$:$$');
```
## Exportation vers un fichier binaire avec encodage
L’exemple suivant montre comment appeler la fonction [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) pour exporter des données vers un fichier binaire ayant un encodage Windows-1253.
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format binary, encoding WIN1253');
```
# Références de fonctions
**Topics**
+ [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3)
+ [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri)
## aws\$1s3.query\$1export\$1to\$1s3
Exporte un résultat de requête PostgreSQL vers un compartiment Amazon S3. L’extension `aws_s3` fournit la fonction `aws_s3.query_export_to_s3`.
Les deux paramètres requis sont `query` et `s3_info`. Ils définissent la requête à exporter et identifient le compartiment Amazon S3 vers lequel effectuer l’exportation. Un paramètre facultatif appelé `options` permet de définir différents paramètres d’exportation. Pour obtenir des exemples d’utilisation de la fonction `aws_s3.query_export_to_s3`, consultez [Exportation de données de requête à l’aide de la fonction aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
**Syntaxe**
```
aws_s3.query_export_to_s3(
query text,
s3_info aws_commons._s3_uri_1,
options text,
kms_key text
)
```Paramètres d’entrée
*query*
Chaîne de texte obligatoire contenant une requête SQL exécutée par le moteur PostgreSQL. Les résultats de cette requête sont copiés dans un compartiment S3 identifié dans le paramètre `s3_info`.
*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 et chemin d’accès à celui-ci.
+ `region`— La AWS région dans laquelle se trouve le compartiment. 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).
Actuellement, cette valeur doit être la même AWS région que celle de l'instance de base de données du de bases de données exportatrice. La valeur par défaut est la AWS région de l'instance de base de données du de bases de données exportatrice.
Pour créer une structure composite `aws_commons._s3_uri_1`, consultez [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri) fonction.
*options*
Chaîne de texte facultative contenant les arguments de la commande `COPY` de PostgreSQL. Ces arguments spécifient la façon dont les données doivent être copiées lors de l’exportation. Pour plus d’informations, consultez la [documentation sur la commande COPY de PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Chaîne de texte facultative contenant la clé KMS gérée par le client du compartiment S3 vers lequel exporter les données.
### Autres paramètres d’entrée
Pour faciliter le test, vous pouvez utiliser un ensemble étendu de paramètres au lieu du paramètre `s3_info`. Plusieurs variations de syntaxe supplémentaires pour la fonction `aws_s3.query_export_to_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`.
```
aws_s3.query_export_to_s3(
query text,
bucket text,
file_path text,
region text,
options text,
kms_key text
)
```
*query*
Chaîne de texte obligatoire contenant une requête SQL exécutée par le moteur PostgreSQL. Les résultats de cette requête sont copiés dans un compartiment S3 identifié dans le paramètre `s3_info`.
*bucket*
Chaîne de texte obligatoire comportant le nom du compartiment Amazon S3 qui contient 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 facultative contenant la AWS région dans laquelle se trouve le compartiment. 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).
Actuellement, cette valeur doit être la même AWS région que celle de l'instance de base de données du de bases de données exportatrice. La valeur par défaut est la AWS région de l'instance de base de données du de bases de données exportatrice.
*options*
Chaîne de texte facultative contenant les arguments de la commande `COPY` de PostgreSQL. Ces arguments spécifient la façon dont les données doivent être copiées lors de l’exportation. Pour plus d’informations, consultez la [documentation sur la commande COPY de PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Chaîne de texte facultative contenant la clé KMS gérée par le client du compartiment S3 vers lequel exporter les données.
### Paramètres de sortie
```
aws_s3.query_export_to_s3(
OUT rows_uploaded bigint,
OUT files_uploaded bigint,
OUT bytes_uploaded bigint
)
```
*rows\$1uploaded*
Nombre de lignes de table qui ont été téléchargées avec succès vers Amazon S3 pour la requête donnée.
*files\$1uploaded*
Nombre de fichiers téléchargés vers Amazon S3. Les fichiers sont créés avec des tailles d’environ 6 Go. Chaque fichier supplémentaire créé voit l’élément `_partXX` ajouté à son nom. `XX` représente 2, puis 3, et ainsi de suite.
*bytes\$1uploaded*
Nombre total d’octets téléchargés vers Amazon S3.
### Exemples
```
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2','format text');
```
## aws\$1commons.create\$1s3\$1uri
Crée une structure `aws_commons._s3_uri_1` pour contenir les informations relatives au fichier Amazon S3. Vous utilisez les résultats de la fonction `aws_commons.create_s3_uri` dans le paramètre `s3_info` de la fonction [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3). Pour obtenir un exemple d’utilisation de la fonction `aws_commons.create_s3_uri`, consultez [Spécification du chemin d’accès au fichier Amazon S3 vers lequel effectuer l’exportation](postgresql-s3-export.md#postgresql-s3-export-file).
**Syntaxe**
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```Paramètres d’entrée
*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 contenant 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).
# Résolution des problèmes d'accès à Amazon S3
Si vous rencontrez des problèmes de connexion lorsque vous essayez d'exporter des données vers Amazon S3, confirmez d'abord que les règles d'accès sortant du groupe de sécurité VPC associé à votre instance de base de données permettent la connectivité réseau. Plus précisément, le groupe de sécurité doit comporter une règle qui autorise l'instance de base de données à envoyer du trafic TCP au port 443 et à toute adresse IPv4 (0.0.0.0/0). Pour de plus amples informations, consultez [Créer un groupe de sécurité qui autorise l'accès à votre instance de base de données dans votre VPC](CHAP_SettingUp.md#CHAP_SettingUp.SecurityGroup).
Voir également 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*