# Exportación de datos de una Aurora PostgreSQL de base de datos de clústerde Amazon S3
Puede consultar datos de una instancia de clúster de base de datos de Aurora PostgreSQL y exportarlos directamente a archivos almacenados en un bucket de Amazon S3. Para ello, primero debe instalar la extensión de Aurora PostgreSQL `aws_s3`. Esta extensión le proporciona las funciones que utiliza para exportar los resultados de las consultas a Amazon S3. A continuación, puede averiguar cómo instalar la extensión y cómo exportar datos de Amazon S3.
Solo se puede exportar desde una instancia de base de datos aprovisionada o de Aurora Serverless v2. Estos pasos no se admiten para Aurora Serverless v1.
**nota**
No se ha agregado compatibilidad con la exportación entre cuentas a Amazon S3.
Todas las versiones disponibles actualmente de Aurora PostgreSQL admiten la exportación de datos a Amazon Simple Storage Service. Para obtener información detallada sobre la versión, consulte las [actualizaciones de Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html) en las *notas de la versión de Aurora PostgreSQL*.
Si no tienes un bucket configurado para la exportación, consulta los siguientes temas: *Guía del usuario de Amazon Simple Storage Service*.
+ [Configuración de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/setting-up-s3.html)
+ [Crear un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html)
De forma predeterminada, los datos exportados desde Aurora PostgreSQL a Amazon S3 utilizan cifrado del servidor con Clave administrada de AWS. De forma alternativa, puede utilizar una clave administrada por el cliente que ya haya creado. Si utiliza cifrado de buckets, el bucket de Amazon S3 debe cifrarse con una clave AWS Key Management Service (AWS KMS) (SSE-KMS). En la actualidad, no se admiten buckets cifrados con claves administradas de Amazon S3 (SSE-S3).
**nota**
Puede guardar datos de instantáneas de base de datos y de base de datos en Amazon S3 mediante la Consola de administración de AWS, la AWS CLI o la API de Amazon RDS. Para obtener más información, consulte [Exportación de datos de instantánea del clúster de bases de datos a Amazon S3](aurora-export-snapshot.md).
**Topics**
+ [
## Instalación de la extensión aws\$1s3
](#USER_PostgreSQL.S3Export.InstallExtension)
+ [
## Información general de la exportación de datos a Amazon S3
](#postgresql-s3-export-overview)
+ [
## Especificación de la ruta del archivo de Amazon S3 a exportar
](#postgresql-s3-export-file)
+ [
# Configuración del acceso a un bucket de Amazon S3
](postgresql-s3-export-access-bucket.md)
+ [
# Exportación de datos de consulta mediante la función aws\$1s3.query\$1export\$1to\$1s3
](postgresql-s3-export-examples.md)
+ [
# Referencia de funciones
](postgresql-s3-export-functions.md)
+ [
# Solución de errores de acceso a Amazon S3
](postgresql-s3-export-troubleshoot.md)
## Instalación de la extensión aws\$1s3
Antes de poder usar Amazon Simple Storage Service con su clúster de base de datos de Aurora PostgreSQL, , debe instalar la extensión `aws_s3`. Esta extensión proporciona funciones para exportar datos desde la instancia de escritura de un clúster de base de datos de Aurora PostgreSQL a un bucket de Amazon S3. También proporciona funciones para importar datos desde Amazon S3. Para obtener más información, consulte [Importación de datos de Amazon S3 en un clúster de base de datos Aurora PostgreSQL](USER_PostgreSQL.S3Import.md). La extensión `aws_s3` depende de algunas de las funciones de ayuda en la extensión de `aws_commons`, que se instala automáticamente cuando es necesario.
**Para instalar la extensión de `aws_s3`**
1. Utilice psql (o pgAdmin) para conectarse a la instancia de escritor del clúster de base de datos de Aurora PostgreSQL como usuario que tiene privilegios de `rds_superuser`. Si mantuvo el nombre predeterminado durante el proceso de configuración, conéctese como `postgres`.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Para instalar la extensión, ejecute el siguiente comando:
```
postgres=> CREATE EXTENSION aws_s3 CASCADE;
NOTICE: installing required extension "aws_commons"
CREATE EXTENSION
```
1. Para comprobar que la extensión está instalada, puede usar el metacomando 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)
```
Ya están disponibles las funciones para importar datos de Amazon S3 y para exportar datos a Amazon S3.
### Confirme que su versión de Aurora PostgreSQL admite exportaciones a Amazon S3.
Puede comprobar que su versión de Aurora PostgreSQL admite la exportación a Amazon S3 mediante el comando `describe-db-engine-versions`. El siguiente ejemplo comprueba si la versión 10.14 se puede exportar a Amazon S3.
```
aws rds describe-db-engine-versions --region us-east-1 \
--engine aurora-postgresql --engine-version 10.14 | grep s3Export
```
Si en la salida se recoge la cadena de texto `"s3Export"`, el motor admite las exportaciones de Amazon S3 . Si no es así, el motor no las admite.
## Información general de la exportación de datos a Amazon S3
Para exportar datos almacenados en una base de datos de Aurora PostgreSQL a un bucket de Amazon S3, utilice el siguiente procedimiento.
**Para exportar Aurora PostgreSQL datos a S3**
1. Identifique la ruta de archivo de Amazon S3 que se va a utilizar para exportar datos. Para obtener más información sobre este proceso, consulte [Especificación de la ruta del archivo de Amazon S3 a exportar](#postgresql-s3-export-file).
1. Conceda permiso para acceder al bucket de Amazon S3.
Para exportar datos a un archivo de Amazon S3, conceda permiso al clúster de base de datos de Aurora PostgreSQL para obtener acceso al bucket de Amazon S3 que la exportación usará para el almacenamiento. Esto incluye los siguientes pasos:
1. Cree una política de IAM que proporcione acceso al bucket de Amazon S3 al que se desea exportar.
1. Cree un rol de IAM.
1. Asocie la política que ha creado al rol que ha creado.
1. Agregue este rol de IAM al clúster de base de datos.
Para obtener más información sobre este proceso, consulte [Configuración del acceso a un bucket de Amazon S3](postgresql-s3-export-access-bucket.md).
1. Identifique una consulta de base de datos para obtener los datos. Exporte los datos de consulta llamando a la función `aws_s3.query_export_to_s3`.
Después de completar las tareas de preparación anteriores, utilice la función [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) para exportar los resultados de la consulta a Amazon S3. Para obtener más información sobre este proceso, consulte [Exportación de datos de consulta mediante la función aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
## Especificación de la ruta del archivo de Amazon S3 a exportar
Especifique la siguiente información para identificar la ubicación de Amazon S3 a la que desea exportar los datos:
+ Nombre de bucket: un *bucket* es un contenedor para objetos o archivos de Amazon S3.
Para obtener más información sobre cómo almacenar datos con Amazon S3, consulte [Crear un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) y [Trabajar con objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-downloading-objects.html) en la *Guía del usuario de Amazon Simple Storage Service*.
+ Ruta del archivo: la ruta del archivo identifica dónde se almacena la exportación en el bucket de Amazon S3. La ruta del archivo consta de lo siguiente:
+ Un prefijo de ruta opcional que identifica una ruta de carpeta virtual.
+ Un prefijo de archivo que identifica uno o varios archivos que se van a almacenar. Las exportaciones más grandes se almacenan en varios archivos, cada uno con un tamaño máximo de aproximadamente 6 GB. Los nombres de archivo adicionales tienen el mismo prefijo de archivo, pero con `_partXX` anexado. `XX` representa 2, luego 3, y así sucesivamente.
Por ejemplo, una ruta de archivo con una carpeta `exports` y un prefijo de archivo `query-1-export` es `/exports/query-1-export`.
+ Región de AWS (opcional): la región de AWS donde se encuentra el bucket de Amazon S3. Si no especifica un valor de región de AWS, Aurora guarda sus archivos en Amazon S3, en la misma región de AWS que el clúster de base de datos de exportación.
**nota**
Actualmente, la región de AWS debe ser la misma región que la del clúster de base de datos e de exportación.
Para ver una lista de los nombres de regiones de AWS y los valores asociados, consulte [Regiones y zonas de disponibilidad](Concepts.RegionsAndAvailabilityZones.md).
Para mantener la información del archivo de Amazon S3 acerca de dónde se va a almacenar la exportación, puede utilizar la función [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri) para crear una estructura compuesta `aws_commons._s3_uri_1` de la siguiente manera.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Más adelante, proporcione este valor `s3_uri_1` como un parámetro en la llamada a la función [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Para ver ejemplos, consulte [Exportación de datos de consulta mediante la función aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
# Configuración del acceso a un bucket de Amazon S3
Para exportar datos a Amazon S3, conceda permiso al clúster de base de datos de PostgreSQL para acceder al bucket de Amazon S3 al que irán los archivos.
Para ello, siga el procedimiento que se indica a continuación.
**Para proporcionar al clúster de base de datos de PostgreSQL acceso a Amazon S3 a través de un rol de IAM**
1. Cree una política de IAM.
Esta política concede los permisos de bucket y objeto que permiten al clúster de base de datos de PostgreSQL acceder a Amazon S3.
Como parte de la creación de esta política, realice los siguientes pasos:
1. Incluya las siguientes acciones necesarias en la política para permitir la transferencia de archivos del clúster de base de datos de PostgreSQL a un bucket de Amazon S3:
+ `s3:PutObject`
+ `s3:AbortMultipartUpload`
1. Incluye el nombre de recurso de Amazon (ARN) que identifica el bucket de Amazon S3 y los objetos del bucket. El formato del ARN para acceder a Amazon S3 es: `arn:aws:s3:::amzn-s3-demo-bucket/*`
Para obtener información adicional sobre cómo crear una política de IAM para Aurora PostgreSQL, consulte [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Consulte también el [Tutorial: Crear y asociar su primera política administrada por el cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) en la *Guía del usuario de IAM*.
El siguiente comando de la AWS CLI crea una política de IAM denominada `rds-s3-export-policy` con estas opciones. Otorga acceso a un bucket denominado *amzn-s3-demo-bucket*.
**aviso**
Le recomendamos que configure la base de datos en una VPC privada que tenga políticas de punto de enlace configuradas para acceder a buckets específicos. Para obtener más información, consulte [Uso de políticas de punto de enlace para Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html#vpc-endpoints-policies-s3) en la Guía del usuario de Amazon VPC.
Recomendamos encarecidamente que no cree una política con acceso a todos los recursos. Este acceso puede representar una amenaza para la seguridad de los datos. Si crea una política que da acceso `S3:PutObject` a todos los recursos mediante `"Resource":"*"`, un usuario con privilegios de exportación puede exportar datos a todos los buckets de su cuenta. Además, el usuario puede exportar datos a *cualquier bucket en el que se pueda escribir públicamente dentro de su región de AWS*.
Después de crear la política, anote el nombre de recurso de Amazon (ARN) de la política. Cuando asocia la política a un rol de IAM, necesita el ARN para realizar un paso posterior.
```
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. Cree un rol de IAM.
Realiza este paso para que Aurora PostgreSQL pueda asumir este rol de IAM en su nombre para obtener acceso a los buckets de Amazon S3. Para obtener más información, consulte [Creación de un rol para delegar permisos a un usuario de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) en la *Guía del usuario de IAM*.
Le recomendamos que utilice las claves de contexto de condición globales de `[aws:SourceArn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)` y `[aws:SourceAccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)` en las políticas basadas en recursos para limitar los permisos del servicio a un recurso específico. Esta es la forma más eficaz de protegerse contra el [problema del suplente confuso](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).
Si utiliza claves de contexto de condición globales y el valor `aws:SourceArn` contiene el ID de cuenta, el valor `aws:SourceAccount` y la cuenta en el valor `aws:SourceArn` deben utilizar el mismo ID de cuenta cuando se utiliza en la misma instrucción de política.
+ Use `aws:SourceArn` si quiere acceso entre servicios para un único recurso.
+ Use `aws:SourceAccount` si quiere permitir que cualquier recurso de esa cuenta se asocie al uso entre servicios.
En la política, asegúrese de utilizar la clave de contexto de condición global `aws:SourceArn` con el ARN completo del recurso. En el siguiente ejemplo se muestra cómo se usa el comando de la AWS CLI para crear un rol denominado `rds-s3-export-role`.
**Example**
Para Linux, macOS o 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:cluster:dbname"
}
}
}
]
}'
```
Para 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:cluster:dbname"
}
}
}
]
}'
```
1. Asocie la política de IAM que creó al rol de IAM creado.
El siguiente comando de la AWS CLI asocia la política creada anteriormente al rol denominado `rds-s3-export-role.`. Sustituya `your-policy-arn` por el ARN de la política que ha anotado en un paso anterior.
```
aws iam attach-role-policy --policy-arn your-policy-arn --role-name rds-s3-export-role
```
1. Añada el rol de IAM al clúster de base de datos. Para ello, utilice la Consola de administración de AWS o la AWS CLI, tal y como se describe a continuación.
## Consola
**Para añadir un rol de IAM para un clúster de base de datos de PostgreSQL utilizando la consola**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Seleccione el nombre de clúster de base de datos de PostgreSQL para mostrar sus detalles.
1. En la pestaña **Connectivity & security (Conectividad y seguridad)**, en la sección **Manage IAM roles (Administrar roles de IAM)**, elija el rol que desee añadir en **Add IAM roles to this instance (Añadir roles de IAM a esta instancia)**.
1. En **Feature (Característica)**, elija **s3Export**.
1. Seleccione **Add role (Añadir rol)**.
## AWS CLI
**Para añadir un rol de IAM para un clúster de base de datos de PostgreSQL mediante la CLI, realice el siguiente procedimiento:**
+ Utilice el siguiente comando para añadir el rol al clúster de base de datos de PostgreSQL denominado `my-db-cluster`. Sustituya *`your-role-arn`* por el ARN del rol que ha anotado en el paso anterior. Utilice `s3Export` para el valor de la opción `--feature-name`.
**Example**
Para Linux, macOS o Unix:
```
aws rds add-role-to-db-cluster \
--db-cluster-identifier my-db-cluster \
--feature-name s3Export \
--role-arn your-role-arn \
--region your-region
```
Para Windows:
```
aws rds add-role-to-db-cluster ^
--db-cluster-identifier my-db-cluster ^
--feature-name s3Export ^
--role-arn your-role-arn ^
--region your-region
```
# Exportación de datos de consulta mediante la función aws\$1s3.query\$1export\$1to\$1s3
Exporte sus datos de PostgreSQL a Amazon S3 llamando a la función [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3).
**Topics**
+ [
## Requisitos previos
](#postgresql-s3-export-examples-prerequisites)
+ [
## Llamar a aws\$1s3.query\$1export\$1to\$1s3
](#postgresql-s3-export-examples-basic)
+ [
## Exportación a un archivo CSV que utiliza un delimitador personalizado
](#postgresql-s3-export-examples-custom-delimiter)
+ [
## Exportación a un archivo binario con codificación
](#postgresql-s3-export-examples-encoded)
## Requisitos previos
Antes de utilizar la función `aws_s3.query_export_to_s3`, asegúrese de completar los siguientes requisitos previos:
+ Instale las extensiones de PostgreSQL necesarias como se describe en [Información general de la exportación de datos a Amazon S3](postgresql-s3-export.md#postgresql-s3-export-overview).
+ Determine a dónde exportar los datos en Amazon S3 como se describe en [Especificación de la ruta del archivo de Amazon S3 a exportar](postgresql-s3-export.md#postgresql-s3-export-file).
+ Tenga cuidado de que la instancia de base de datos tenga acceso de exportación a Amazon S3 según se describe en [Configuración del acceso a un bucket de Amazon S3](postgresql-s3-export-access-bucket.md).
Los ejemplos siguientes utilizan una tabla de base de datos llamada `sample_table`. Estos ejemplos exportan los datos a un bucket llamado *amzn-s3-demo-bucket*. La tabla y los datos de ejemplo se crean con las siguientes instrucciones SQL en 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');
```
## Llamar a aws\$1s3.query\$1export\$1to\$1s3
A continuación, se muestran las formas básicas de llamar a la función [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3).
En estos ejemplos se utiliza la variable `s3_uri_1` para identificar una estructura que contiene la información que identifica el archivo de Amazon S3. Utilice la función [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri) para crear la estructura.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Aunque los parámetros varían para las dos llamadas a funciones siguientes `aws_s3.query_export_to_s3`, los resultados son los mismos para estos ejemplos. Todas las filas de la tabla `sample_table` se exportan a un bucket llamado *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');
```
Los parámetros se describen de la siguiente manera:
+ `'SELECT * FROM sample_table'`: el primer parámetro es una cadena de texto requerida que contiene una consulta SQL. El motor de PostgreSQL ejecuta esta consulta. Los resultados de la consulta se copian en el bucket de S3 identificado en otros parámetros.
+ `:'s3_uri_1'`: este parámetro es una estructura que identifica el archivo de Amazon S3. En este ejemplo se utiliza una variable para identificar la estructura creada anteriormente. En su lugar, puede crear la estructura incluyendo la llamada a la función `aws_commons.create_s3_uri` insertada dentro de la llamada a la función `aws_s3.query_export_to_s3` de la siguiente manera.
```
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'`: el parámetro `options` es una cadena de texto opcional que contiene argumentos `COPY` de PostgreSQL. El proceso de copia utiliza los argumentos y el formato del comando [COPY de PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
Si el archivo especificado no existe en el bucket de Amazon S3, se crea. Si el archivo ya existe, se sobrescribe. La sintaxis para acceder a los datos exportados en Amazon S3 es la siguiente.
```
s3-region://bucket-name[/path-prefix]/file-prefix
```
Las exportaciones más grandes se almacenan en varios archivos, cada uno con un tamaño máximo de aproximadamente 6 GB. Los nombres de archivo adicionales tienen el mismo prefijo de archivo, pero con `_partXX` anexado. `XX` representa 2, luego 3, y así sucesivamente. Por ejemplo, supongamos que especifica la ruta donde almacena los archivos de datos como sigue.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
```
Si la exportación tiene que crear tres archivos de datos, el bucket de Amazon S3 contiene los siguientes archivos de datos.
```
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
```
Para obtener la referencia completa de esta función y formas adicionales de llamarla, consulte [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Para obtener más información sobre el acceso a archivos en Amazon S3, consulte [Ver un objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) en la *Guía del usuario de Amazon Simple Storage Service*.
## Exportación a un archivo CSV que utiliza un delimitador personalizado
En el ejemplo siguiente se muestra cómo llamar a la función [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) para exportar datos a un archivo que utiliza un delimitador personalizado. En el ejemplo se utilizan argumentos del comando [COPY de PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html) para especificar el formato de valor separado por comas (CSV) y un delimitador de dos puntos (:).
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format csv, delimiter $$:$$');
```
## Exportación a un archivo binario con codificación
En el ejemplo siguiente se muestra cómo llamar a la función [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) para exportar datos a un archivo binario que tiene codificación Windows-1253.
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format binary, encoding WIN1253');
```
# Referencia de funciones
**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
Exporta un resultado de consulta PostgreSQL a un bucket de Amazon S3. La extensión `aws_s3` proporciona la función `aws_s3.query_export_to_s3`.
Los parámetros obligatorios son `query` y `s3_info`. Definen la consulta que se va a exportar e identifican el bucket de Amazon S3 al que se va a exportar. Un parámetro opcional llamado `options` proporciona la definición de varios parámetros de exportación. Para obtener ejemplos sobre el uso de la función `aws_s3.query_export_to_s3`, consulte [Exportación de datos de consulta mediante la función aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
**Sintaxis**
```
aws_s3.query_export_to_s3(
query text,
s3_info aws_commons._s3_uri_1,
options text,
kms_key text
)
```Parámetros de entrada
*query*
Cadena de texto necesaria que contiene una consulta SQL que ejecuta el motor de PostgreSQL. Los resultados de esta consulta se copian en un bucket de S3 identificado en el parámetro `s3_info`.
*s3\$1info*
Tipo compuesto `aws_commons._s3_uri_1` que contiene la siguiente información sobre el objeto de S3:
+ `bucket`: el nombre del bucket de Amazon S3 que contiene el archivo.
+ `file_path` –: la ruta de Amazon S3 del archivo.
+ `region`: la región de AWS en la que se encuentra el bucket. Para ver una lista de los nombres de regiones de AWS y los valores asociados, consulte [Regiones y zonas de disponibilidad](Concepts.RegionsAndAvailabilityZones.md).
Actualmente, este valor debe ser la misma región de AWS que la del clúster de base de datos e de exportación. El valor predeterminado es la región de AWS del clúster de base de datos e de exportación.
Para crear una estructura compuesta `aws_commons._s3_uri_1`, consulte la función [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri).
*options*
Cadena de texto opcional que contiene argumentos para el comando `COPY` de PostgreSQL. Estos argumentos especifican cómo se copian los datos cuando se exportan. Para obtener más detalles, consulte la [documentación de COPY de PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Una cadena de texto opcional que contiene la clave KMS administrada por el cliente del bucket de S3 al que se exportan los datos.
### Parámetros de entrada alternativos
Como ayuda en las pruebas, puede utilizar un conjunto de parámetros expandido en lugar del parámetro `s3_info`. A continuación, se incluyen otras variaciones de la sintaxis de la función `aws_s3.query_export_to_s3`.
En lugar de utilizar el parámetro `s3_info` para identificar un archivo de Amazon S3, utilice la combinación de los parámetros `bucket`, `file_path` y `region`.
```
aws_s3.query_export_to_s3(
query text,
bucket text,
file_path text,
region text,
options text,
kms_key text
)
```
*query*
Cadena de texto necesaria que contiene una consulta SQL que ejecuta el motor de PostgreSQL. Los resultados de esta consulta se copian en un bucket de S3 identificado en el parámetro `s3_info`.
*bucket*
Cadena de texto obligatoria que incluye el nombre del bucket de Amazon S3 que contiene el archivo.
*file\$1path*
Cadena de texto requerida que contiene la ruta de Amazon S3 del archivo.
*region*
Cadena de texto opcional que contiene la región de AWS en la que se encuentra el bucket. Para ver una lista de los nombres de regiones de AWS y los valores asociados, consulte [Regiones y zonas de disponibilidad](Concepts.RegionsAndAvailabilityZones.md).
Actualmente, este valor debe ser la misma región de AWS que la del clúster de base de datos e de exportación. El valor predeterminado es la región de AWS del clúster de base de datos e de exportación.
*options*
Cadena de texto opcional que contiene argumentos para el comando `COPY` de PostgreSQL. Estos argumentos especifican cómo se copian los datos cuando se exportan. Para obtener más detalles, consulte la [documentación de COPY de PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Una cadena de texto opcional que contiene la clave KMS administrada por el cliente del bucket de S3 al que se exportan los datos.
### Parámetros de salida
```
aws_s3.query_export_to_s3(
OUT rows_uploaded bigint,
OUT files_uploaded bigint,
OUT bytes_uploaded bigint
)
```
*rows\$1uploaded*
Número de filas de tabla que se cargaron correctamente a Amazon S3 para la consulta dada.
*files\$1uploaded*
El número de archivos cargados en Amazon S3. Los archivos se crean en tamaños de aproximadamente 6 GB. Cada archivo adicional creado tiene `_partXX` anexado al nombre. `XX` representa 2, luego 3, y así sucesivamente según sea necesario.
*bytes\$1uploaded*
El número total de bytes cargados a Amazon S3.
### Ejemplos
```
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
Crea una estructura `aws_commons._s3_uri_1` para contener la información de archivos de Amazon S3. Debe utilizar los resultados de la función `aws_commons.create_s3_uri` en el parámetro `s3_info` de la función [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3). Para ver un ejemplo de uso de la función `aws_commons.create_s3_uri`, consulte [Especificación de la ruta del archivo de Amazon S3 a exportar](postgresql-s3-export.md#postgresql-s3-export-file).
**Sintaxis**
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```Parámetros de entrada
*Bucket de*
Cadena de texto obligatoria que contiene el nombre del bucket de Amazon S3 del archivo.
*file\$1path*
Cadena de texto requerida que contiene la ruta de Amazon S3 del archivo.
*region*
Cadena de texto obligatoria que contiene la región de AWS en la que se encuentra el archivo. Para ver una lista de los nombres de regiones de AWS y los valores asociados, consulte [Regiones y zonas de disponibilidad](Concepts.RegionsAndAvailabilityZones.md).
# Solución de errores de acceso a Amazon S3
Si se producen problemas de conexión al intentar exportar los datos a Amazon S3, confirme primero que las reglas de acceso saliente del grupo de seguridad de la VPC asociado a la instancia de base de datos permitan la conectividad de red. En concreto, el grupo de seguridad debe tener una regla que permita que la instancia de base de datos envíe tráfico TCP al puerto 443 y a cualquier dirección IPv4 (0.0.0.0/0). Para obtener más información, consulte [Proporcionar acceso al clúster de base de datos en la VPC mediante la creación de un grupo de seguridad](CHAP_SettingUp_Aurora.md#CHAP_SettingUp_Aurora.SecurityGroup).
También consulte las recomendaciones siguientes:
+ [Solución de problemas de identidades y accesos en Amazon Aurora](security_iam_troubleshoot.md)
+ [Solución de problemas de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/troubleshooting.html) en la *Guía del usuario de Amazon Simple Storage Service*
+ [Solución de problemas de Amazon S3 e IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_iam-s3.html) en la *Guía del usuario de IAM*