# Importación de datos en PostgreSQL en Amazon RDS
Supongamos que tiene una implementación de PostgreSQL existente que quiere pasar a Amazon RDS. La complejidad de la tarea dependerá del tamaño de la base de datos y de los tipos de objetos de base de datos que se van a transferir. Por ejemplo, considere una base de datos que contenga conjuntos de datos de tamaños del orden de gigabytes, junto con disparadores y procedimientos almacenados. Esta base de datos será más complicada que una base de datos sencilla con tan solo unos cuantos megabytes de datos de prueba sin disparadores ni procedimientos almacenados.
Es recomendable usar las herramientas de migración de bases de datos de PostgreSQL nativas si se dan las condiciones siguientes:
+ Se trata de una migración homogénea, en la que se migra desde una base de datos con el mismo motor de base de datos que la base de datos de destino.
+ Se va a migrar una base de datos completa.
+ Las herramientas nativas permiten migrar el sistema con un tiempo de inactividad mínimo.
En la mayoría de los demás casos, realizar una migración de base de datos mediante Database Migration Service (AWS DMS) de AWS es el mejor enfoque. AWS DMS puede migrar bases de datos sin tiempo de inactividad y, para numerosos motores de base de datos, continuar la reproducción en curso hasta que todo esté preparado para cambiar a la base de datos de destino. Puede migrar al mismo motor de base de datos o a un motor de base de datos diferente con DMS de AWS. Si va a migrar a un motor de base de datos distinto del de la base de datos origen, puede usar la AWS Schema Conversion Tool (AWS SCT). Se utiliza AWS SCT para migrar objetos de esquema que AWS DMS no ha migrado. Para obtener más información acerca del uso de DMS de AWS, consulte [¿Qué es AWS Database Migration Service?](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
Modifique el grupo de parámetros de base de datos para incluir la siguiente configuración *solo para su importación*. Debe probar la configuración de los parámetros para encontrar los ajustes más eficientes para el tamaño de su instancia de base de datos. También tiene que volver a los valores de producción para esos parámetros cuando se complete la importación.
Modifique la configuración de su instancia de base de datos como se indica a continuación:
+ Deshabilite los backups de la instancia de base de datos (defina backup\$1retention como 0).
+ Deshabilite el uso de Multi-AZ.
Modifique el grupo de parámetros de base de datos para incluir la siguiente configuración. Solo debe usar estos ajustes al importar los datos. Debe probar la configuración de los parámetros para encontrar los ajustes más eficientes para el tamaño de su instancia de base de datos. También tiene que volver a los valores de producción para esos parámetros cuando se complete la importación.
| Parámetro | Valor recomendado al importar | Descripción |
| --- | --- | --- |
| `maintenance_work_mem` | 524288, 1048576, 2097152, o 4194304 (in KB). Estos valores son comparables a 512 MB, 1 GB, 2 GB y 4 GB. | El valor de este ajuste depende del tamaño de su host. Este parámetro se usa en las declaraciones CREATE INDEX y cada comando paralelo puede usar esa cantidad de memoria. Calcule el mejor valor para no elegir uno demasiado alto y quedarse sin memoria. |
| `max_wal_size` | 256 (para la versión 9.6), 4096 (para las versiones 10 y posteriores) | Tamaño máximo para permitir que el WAL crezca durante los puntos de control automáticos. Aumentar este parámetro puede aumentar la cantidad de tiempo necesario para la recuperación de fallos. Este parámetro reemplaza `checkpoint_segments` a la versión 9.6 y versiones posteriores de PostgreSQL. Para la versión 9.6 de PostgreSQL, este valor está en unidades de 16 MB. Para versiones posteriores, el valor está en unidades de 1 MB. Por ejemplo, en la versión 9.6, 128 significa 128 fragmentos que tienen un tamaño de 16 MB cada uno. En la versión 12.4, 2048 significa 2048 fragmentos que tienen un tamaño de 1 MB cada uno. |
| `checkpoint_timeout` | 1800 | El valor de este ajuste reduce la frecuencia de la rotación de WAL. |
| `synchronous_commit` | Desact. | Deshabilite este ajuste para acelerar las operaciones de escritura. La desactivación de este parámetro puede aumentar el riesgo de pérdida de datos si se bloquea el servidor (no desactive FSYNC). |
| `wal_buffers` | 8192 | Este valor está en unidades de 8 KB. Esto mejora la velocidad de generación de WAL. |
| `autovacuum` | 0 | Deshabilite el parámetro autovacuum de PostgreSQL mientras carga los datos para que no consuma recursos. |
Use los comandos `pg_dump -Fc` (comprimido) o `pg_restore -j` (paralelo) con estos ajustes.
**nota**
El comando PostgreSQL `pg_dumpall` requiere permisos de super\$1user que no se conceden al crear una instancia de base de datos, por lo que no se puede usar para importar los datos.
**Topics**
+ [Importación de una base de datos de PostgreSQL desde una instancia Amazon EC2](PostgreSQL.Procedural.Importing.EC2.md)
+ [Uso del comando \$1copy para importar datos en una tabla en una instancia de base de datos PostgreSQL](PostgreSQL.Procedural.Importing.Copy.md)
+ [Importación de datos de Amazon S3 en una instancia de base de datos de RDS para PostgreSQL](USER_PostgreSQL.S3Import.md)
+ [Transporte de bases de datos de PostgreSQL entre instancias de base de datos](PostgreSQL.TransportableDB.md)
# Importación de una base de datos de PostgreSQL desde una instancia Amazon EC2
Si tiene datos en un servidor de PostgreSQL en una instancia de Amazon EC2 y desea moverlos a una instancia de base de datos de PostgreSQL, puede seguir este proceso para migrar los datos.
1. Use pg\$1dump para crear un archivo que contenga los datos que se van a cargar
1. Cree la instancia de base de datos de destino
1. Use *psql* para crear la base de datos en la instancia de base de datos y cargar los datos
1. Cree una instantánea de base de datos de la instancia de la base de datos
En las siguientes secciones. se proporciona más información sobre cada uno de los pasos mencionados anteriormente.
## Paso 1: cree un archivo utilizando pg\$1dump que contiene los datos que se van a cargar
La utilidad `pg_dump` usa el comando COPY para crear un esquema y un volcado de datos de una base de datos de PostgreSQL. El script de volcado generado por `pg_dump` carga los datos en una base de datos con el mismo nombre y vuelve a crear las tablas, los índices y las claves externas. Puede usar el comando `pg_restore` y el parámetro `-d` para restaurar los datos en una base de datos con un nombre diferente.
Antes de crear el volcado de datos, debe consultar las tablas que se van a volcar para obtener un recuento de filas que le permita confirmar el recuento en la instancia de base de datos de destino.
El siguiente comando crea un archivo de volcado llamado mydb2dump.sql para una base de datos llamada mydb2.
```
prompt>pg_dump dbname=mydb2 -f mydb2dump.sql
```
## Paso 2: cree la instancia de base de datos de destino
Cree la instancia de base de datos PostgreSQL de destino con la consola de Amazon RDS, la AWS CLI o la API. Cree la instancia con el ajuste de retención de backup definido en 0 y deshabilite el uso de Multi-AZ. Esto le permitirá acelerar la importación de los datos. Debe crear una instancia de base de datos en la instancia para poder volcar los datos. La base de datos puede tener el mismo nombre que la base de datos que contiene los datos volcados. Si lo prefiere, puede crear una base de datos con un nombre diferente. En este caso, puede usar el comando `pg_restore` y el parámetro `-d` para restaurar los datos en la base de datos que acaba de nombrar.
Por ejemplo, los siguientes comandos se pueden usar para volcar, restaurar y cambiar de nombre una base de datos.
```
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
```
## Paso 3: use psql para crear la base de datos en la instancia de base de datos y cargar los datos
Puede usar la misma conexión que utilizó para ejecutar el comando pg\$1dump para conectar con la instancia de base de datos de destino y volver a crear la base de datos. Con *psql*, puede usar el nombre del usuario maestro y la contraseña maestra para crear la base de datos en la instancia de base de datos.
El ejemplo siguiente usa *psql* y un archivo de volcado llamado mydb2dump.sql para crear una base de datos llamada mydb2 en una instancia de base de datos PostgreSQL llamada mypginstance:
Para Linux, macOS o Unix:
```
psql \
-f mydb2dump.sql \
--host mypginstance.555555555555.aws-region.rds.amazonaws.com \
--port 8199 \
--username myawsuser \
--password password \
--dbname mydb2
```
Para Windows:
```
psql ^
-f mydb2dump.sql ^
--host mypginstance.555555555555.aws-region.rds.amazonaws.com ^
--port 8199 ^
--username myawsuser ^
--password password ^
--dbname mydb2
```
**nota**
Especifique una contraseña distinta de la que se muestra aquí como práctica recomendada de seguridad.
## Paso 4: cree una instantánea de base de datos de la instancia de base de datos
Una vez que haya comprobado que los datos se han cargado en su instancia de base de datos, es recomendable que cree una instantánea de base de datos de la instancia de base de datos PostgreSQL de destino. Las instantáneas de base de datos son copias de seguridad completos de una instancia de base de datos que se pueden usar para restaurarla a un estado conocido. Una instantánea de base de datos tomada inmediatamente después de la carga le evita tener que volver a cargar los datos en caso de error. También puede usar dicha instantánea para inicializar nuevas instancias de bases de datos. Para obtener más información acerca de la creación de una instantánea de base de datos, consulte [Creación de una instantánea de base de datos para una instancia de base de datos single-AZ para Amazon RDS](USER_CreateSnapshot.md).
# Uso del comando \$1copy para importar datos en una tabla en una instancia de base de datos PostgreSQL
El comando `\copy` PostgreSQL es un metacomando disponible desde la herramienta de cliente interactiva de `psql`. Puede usar `\copy` para importar datos a una tabla de su instancia de base de datos de RDS for PostgreSQL. Para usar el comando `\copy`, primero debe crear la estructura de la tabla en la instancia de base de datos de destino para que `\copy` tenga un destino para los datos que se copian.
Puede usar `\copy` para cargar los datos de un archivo de valores separados por comas (CSV), como uno que se haya exportado y guardado en su estación de trabajo de cliente.
Para importar los datos CSV a la instancia de base de datos de RDS for PostgreSQL de destino, primero conéctese a la instancia de base de datos de destino con `psql`.
```
psql --host=db-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=target-db
```
A continuación, se ejecuta el comando `\copy` con los siguientes parámetros para identificar el destino de los datos y su formato.
+ `target_table`: el nombre de la tabla que debe recibir los datos que se copian del archivo CSV.
+ `column_list`: las especificaciones de las columnas de la tabla.
+ `'filename'`: la ruta completa del archivo CSV en la estación de trabajo local.
```
\copy target_table from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV;
```
Si el archivo CSV tiene información sobre el encabezamiento de las columnas, puede utilizar esta versión del comando y los parámetros.
```
\copy target_table (column-1, column-2, column-3, ...)
from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV HEADER;
```
Si el comando `\copy` falla, PostgreSQL genera mensajes de error.
Creación de una nueva instancia de base de datos en el entorno de vista previa de bases de datos utilizando el comando `psql` con el metacomando `\copy`, tal y como se muestra en los siguientes ejemplos. Este ejemplo usa *source-table* como nombre de la tabla de origen, *source-table.csv* como archivo .csv y *target-db* como base de datos de destino:
Para Linux, macOS o Unix:
```
$psql target-db \
-U \
-p \
-h \
-c "\copy source-table from 'source-table.csv' with DELIMITER ','"
```
Para Windows:
```
$psql target-db ^
-U ^
-p ^
-h ^
-c "\copy source-table from 'source-table.csv' with DELIMITER ','"
```
Para obtener más información sobre el comando `\copy`, consulte la página de [psql](http://www.postgresql.org/docs/current/static/app-psql.html) en la documentación de PostgreSQL, en la sección *Meta-Commands* (Metacomandos).
# Importación de datos de Amazon S3 en una instancia de base de datos de RDS para PostgreSQL
Puede importar los datos que se hayan almacenado mediante Amazon Simple Storage Service a una tabla en una instancia de base de datos de RDS para PostgreSQL. Para ello, primero debe instalar la extensión de RDS para PostgreSQL `aws_s3`. Esta extensión proporciona las funciones que se utilizan para importar datos de un bucket de Amazon S3. Un *bucket* es un contenedor de objetos o archivos de Amazon S3. Los datos pueden estar en un archivo de valores separados por comas (CSV), un archivo de texto o un archivo comprimido (gzip). A continuación, aprenderá a instalar la extensión y a importar datos de Amazon S3 en una tabla.
Para hacer la importación de Simple Storage Service (Amazon S3) hacia RDS for PostgreSQL, la base de datos debe ejecutar la versión de PostgreSQL 10.7 o superior.
Si no tiene datos almacenados en Amazon S3, primero debe crear un bucket y almacenar los datos. Para obtener más información, consulte los siguientes temas en la *guía del usuario de Amazon Simple Storage Service*.
+ [Crear un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#creating-bucket)
+ [Añadir un objeto a un bucket. ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket)
Se admite la importación entre cuentas desde Amazon S3. Para obtener más información, consulte [Concesión de permisos entre cuentas](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html) en la *Guía del usuario de Amazon Simple Storage Service*.
Puede utilizar la clave administrada por el cliente para el cifrado al importar datos desde S3. Para obtener más información, consulte [Claves de KMS almacenadas en AWS KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) en la *Guía del usuario de Amazon Simple Storage Service*.
**Topics**
+ [Instalación de la extensión aws\$1s3](USER_PostgreSQL.S3Import.InstallExtension.md)
+ [Información general sobre la importación de datos desde los datos de Amazon S3](USER_PostgreSQL.S3Import.Overview.md)
+ [Configuración del acceso a un bucket de Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md)
+ [Importación de datos de Amazon S3 a una instancia de base de datos de RDS para PostgreSQL](USER_PostgreSQL.S3Import.FileFormats.md)
+ [Referencia de funciones](USER_PostgreSQL.S3Import.Reference.md)
# Instalación de la extensión aws\$1s3
Antes de poder usar Amazon S3 con su instancia de base de datos de RDS para PostgreSQL, debe instalar la extensión `aws_s3`. Esta extensión proporciona funciones para importar datos desde Amazon S3. También proporciona funciones para exportar datos desde una instancia de base de datos de RDS para PostgreSQL a un bucket de Amazon S3. Para obtener más información, consulte [Exportación de datos de una de Amazon S3](postgresql-s3-export.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 base de datos de RDS para 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.
# Información general sobre la importación de datos desde los datos de Amazon S3
**Para importar datos de S3 en Amazon RDS, realice el siguiente procedimiento:**
Primero, reúna los detalles que necesita proporcionar a la función. Entre ellos se incluye el nombre de la tabla en la instancia de base de datos RDS para PostgreSQL, y el nombre del bucket, la ruta del archivo, el tipo de archivo y la Región de AWS donde se almacenan los datos de Amazon S3. Para obtener más información, consulte el tema para [ver un objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) en la *guía del usuario de Amazon Simple Storage Service*.
**nota**
Actualmente no se admite la importación de datos multiparte desde Amazon S3.
1. Obtenga el nombre de la tabla en la que la función `aws_s3.table_import_from_s3` va a importar los datos. A modo de ejemplo, el siguiente comando crea una tabla `t1` que se puede utilizar en pasos posteriores.
```
postgres=> CREATE TABLE t1
(col1 varchar(80),
col2 varchar(80),
col3 varchar(80));
```
1. Obtenga información sobre el bucket de Amazon S3 y los datos que se van a importar. Para ello, abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) y elija **Buckets**. Busque el bucket que contiene sus datos en la lista. Elija el bucket, abra la página de información general de objetos y, a continuación, Properties (Propiedades).
Anote el nombre del bucket, la ruta, la Región de AWS y el tipo de archivo. Necesitará el nombre de recurso de Amazon (ARN) más adelante para configurar el acceso a Amazon S3 a través de un rol de IAM. Para obtener más información, consulte [Configuración del acceso a un bucket de Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md). En la siguiente imagen se muestra un ejemplo.
![\[Imagen de un objeto de archivo en un bucket de Amazon S3.\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/aws_s3_import-export_s3_bucket-info.png)
1. Para verificar la ruta a los datos en el bucket de Amazon S3, utilice el comando de AWS CLI `aws s3 cp`. Si la información es correcta, este comando descarga una copia del archivo de Amazon S3.
```
aws s3 cp s3://amzn-s3-demo-bucket/sample_file_path ./
```
1. Configure los permisos de instancia de base de datos de RDS para PostgreSQL para permitir el acceso al archivo en el bucket de Amazon S3. Para ello, utilice un rol de AWS Identity and Access Management (IAM) o las credenciales de seguridad. Para obtener más información, consulte [Configuración del acceso a un bucket de Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md).
1. Proporcione la ruta y otros detalles del objeto de Amazon S3 recopilados (consulte el paso 2) para la función `create_s3_uri` para construir un objeto URI de Amazon S3. Para obtener más información sobre esta función, consulte [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri). A continuación se muestra un ejemplo de cómo construir este objeto durante una sesión de 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
```
En el paso siguiente, pase este objeto (`aws_commons._s3_uri_1`) a la función `aws_s3.table_import_from_s3` para importar los datos a la tabla.
1. Invoque la función `aws_s3.table_import_from_s3` para importar los datos de Amazon S3 a la tabla. Para obtener información de referencia, consulte [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). Para ver ejemplos, consulte [Importación de datos de Amazon S3 a una instancia de base de datos de RDS para PostgreSQL](USER_PostgreSQL.S3Import.FileFormats.md).
# Configuración del acceso a un bucket de Amazon S3
Para importar datos de un archivo de Amazon S3, conceda permiso a la instancia de base de datos de RDS for PostgreSQL del para obtener acceso al bucket de Amazon S3 en el que se encuentra el archivo. Puede proporcionar acceso a un bucket de Amazon S3 de una de las dos formas siguientes, tal y como se describe en los siguientes temas.
**Topics**
+ [Uso de un rol de IAM para obtener acceso a un bucket de Amazon S3](#USER_PostgreSQL.S3Import.ARNRole)
+ [Uso de credenciales de seguridad para obtener acceso a un bucket de Amazon S3](#USER_PostgreSQL.S3Import.Credentials)
+ [Solución de errores de acceso a Amazon S3](#USER_PostgreSQL.S3Import.troubleshooting)
## Uso de un rol de IAM para obtener acceso a un bucket de Amazon S3
Antes de cargar los datos de un archivo de Amazon S3, conceda permiso a la instancia de RDS para la base de datos de PostgreSQL para obtener acceso al bucket de Amazon S3 en el que se encuentra el archivo. De esta forma, no tiene que facilitar ni administrar información adicional de credenciales en la llamada a la función [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
Para ello, cree una política de IAM que proporcione acceso al bucket de Amazon S3. Cree un rol de IAM y conecte la política a dicho rol. A continuación, asigne el rol de IAM a la instancia de base de datos.
**Para dar a una instancia de RDS para la base de datos PostgreSQL acceso a Amazon S3 a través de un rol de IAM, realice el siguiente procedimiento:**
1. Cree una política de IAM.
Esta política concede los permisos de bucket y objeto que permiten que la instancia de RDS para base de datos de PostgreSQL tenga acceso a Amazon S3.
Incluya las siguientes acciones requeridas en la política para permitir la transferencia de archivos de un bucket de Amazon S3 a Amazon RDS:
+ `s3:GetObject`
+ `s3:ListBucket`
Incluya los siguientes recursos en la política para identificar el bucket de Amazon S3 y los objetos incluidos en este. A continuación se muestra el formato de nombre de recurso de Amazon (ARN) para obtener acceso a Amazon S3.
+ arn:aws:s3:::*amzn-s3-demo-bucket*
+ arn:aws:s3:::*amzn-s3-demo-bucket*/\$1
Para obtener información adicional sobre cómo crear una política de IAM para RDS para 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-import-policy` con estas opciones. Otorga acceso a un bucket denominado *amzn-s3-demo-bucket*.
**nota**
Anote el Nombre de recurso de Amazon (ARN) de la política que devolvió este comando. Al asociar la política a un rol de IAM, se necesita el ARN para realizar un paso posterior.
**Example**
Para Linux, macOS o 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/*"
]
}
]
}'
```
Para 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. Crear un rol de IAM.
Haga esto para que Amazon RDS pueda asumir este rol de IAM para obtener acceso a los buckets de Amazon S3. Para obtener más información, vea [Crear 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 *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-import-role`.
**Example**
Para Linux, macOS o 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"
}
}
}
]
}'
```
Para 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. Asocie la política de IAM que creó al rol de IAM creado.
El siguiente comando AWS CLI adjunta la política creada en el paso anterior al rol denominado `rds-s3-import-role`. Sustituya `your-policy-arn` por el ARN de la política que ha anotado en un paso anterior.
**Example**
Para Linux, macOS o Unix:
```
aws iam attach-role-policy \
--policy-arn your-policy-arn \
--role-name rds-s3-import-role
```
Para Windows:
```
aws iam attach-role-policy ^
--policy-arn your-policy-arn ^
--role-name rds-s3-import-role
```
1. Añada el rol de IAM a la instancia 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 una instancia 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 instancia 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 agregar en la instancia **Add IAM roles to this (Agregar roles de IAM a este clúster) **.
1. En Feature **Feature** (Característica), elija **s3Import**.
1. Seleccione **Add role (Añadir rol)**.
### AWS CLI
**Para añadir un rol de IAM para una instancia de base de datos de PostgreSQL utilizando la CLI**
+ Utilice el siguiente comando para añadir el rol a la instancia de base de datos de PostgreSQL denominada `my-db-instance`. Sustituya *`your-role-arn`* por el ARN del rol que ha anotado en el paso anterior. Utilice `s3Import` para el valor de la opción `--feature-name`.
**Example**
Para Linux, macOS o 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
```
Para 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 de RDS
Para agregar un rol de IAM para una instancia de base de datos de PostgreSQL mediante la API de Amazon RDS, llame a la operación [AddRoleToDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_AddRoleToDBInstance.html).
## Uso de credenciales de seguridad para obtener acceso a un bucket de Amazon S3
Si lo prefiere, puede utilizar credenciales de seguridad para proporcionar acceso a un bucket de Amazon S3, en lugar de proporcionar acceso con un rol de IAM. Para ello, especifique el parámetro `credentials` en la llamada a la función [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
El parámetro `credentials` es una estructura de tipo `aws_commons._aws_credentials_1`, que contiene credenciales de AWS. Utilice la función [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials) para establecer la clave de acceso y la clave secreta en una estructura `aws_commons._aws_credentials_1`, como se muestra a continuación.
```
postgres=> SELECT aws_commons.create_aws_credentials(
'sample_access_key', 'sample_secret_key', '')
AS creds \gset
```
Tras crear la estructura `aws_commons._aws_credentials_1 `, utilice la función [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) con el parámetro `credentials` para importar los datos, tal y como se muestra a continuación.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't', '', '(format csv)',
:'s3_uri',
:'creds'
);
```
O bien puede incluir la llamada a la función [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials) insertada dentro de la llamada a la función `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', '')
);
```
## Solución de errores de acceso a Amazon S3
Si tiene problemas de conexión al intentar importar los datos de Amazon S3, consulte las recomendaciones que se indican a continuación:
+ [Solución de problemas de identidades y accesos en Amazon RDS](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*
# Importación de datos de Amazon S3 a una instancia de base de datos de RDS para PostgreSQL
Para importar datos desde su bucket de Amazon S3, utilice la función `table_import_from_s3` de la extensión aws\$1s3. Para obtener información de referencia, consulte [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
**nota**
En los siguientes ejemplos se utiliza el método de rol de IAM para permitir el acceso al bucket de Amazon S3. Por tanto, no hay parámetros de credenciales en las llamadas a la función `aws_s3.table_import_from_s3`.
A continuación se muestra un ejemplo típico.
```
postgres=> SELECT aws_s3.table_import_from_s3(
't1',
'',
'(format csv)',
:'s3_uri'
);
```
Los parámetros son los siguientes:
+ `t1`: nombre de la tabla en la instancia de base de datos de PostgreSQL en la que desea copiar los datos.
+ `''`: lista opcional de columnas en la tabla de la base de datos. Puede utilizar este parámetro para indicar qué columnas de los datos de S3 van en las columnas de la tabla. Si no se especifica ninguna columna, se copian en la tabla todas las columnas. Para obtener un ejemplo de uso de una lista de columnas, consulte [Importación de un archivo de Amazon S3 que utiliza un delimitador personalizado](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter).
+ `(format csv)`: argumentos de 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) para importar los datos. Las opciones de formato incluyen un valor separado por comas (CSV), como se muestra en este ejemplo, texto y binario. El valor predeterminado es texto.
+ `s3_uri`: una estructura que contiene la información que identifica el archivo de Amazon S3. Para ver un ejemplo de cómo utilizar la función [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) para crear una estructura `s3_uri`, consulte [Información general sobre la importación de datos desde los datos de Amazon S3](USER_PostgreSQL.S3Import.Overview.md).
Para obtener más información acerca de esta función, consulte [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
La función `aws_s3.table_import_from_s3` devuelve texto. Para especificar otros tipos de archivos que se van a importar desde un bucket de Amazon S3, consulte uno de los siguientes ejemplos.
**nota**
Si importa 0 bytes, se producirá un error.
**Topics**
+ [Importación de un archivo de Amazon S3 que utiliza un delimitador personalizado](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter)
+ [Importación de un archivo comprimido (gzip) de Amazon S3](#USER_PostgreSQL.S3Import.FileFormats.gzip)
+ [Importación de un archivo de Amazon S3 codificado](#USER_PostgreSQL.S3Import.FileFormats.Encoded)
## Importación de un archivo de Amazon S3 que utiliza un delimitador personalizado
En el siguiente ejemplo se muestra cómo importar un archivo que utiliza un delimitador personalizado. También se muestra cómo controlar dónde colocar los datos en la tabla de la base de datos usando el parámetro `column_list` de la función [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3).
En este ejemplo, supongamos que la siguiente información está organizada en columnas delimitadas por barras verticales en el archivo de Amazon S3.
```
1|foo1|bar1|elephant1
2|foo2|bar2|elephant2
3|foo3|bar3|elephant3
4|foo4|bar4|elephant4
...
```
**Para importar un archivo que utiliza un delimitador personalizado**
1. Cree una tabla en la base de datos para los datos importados.
```
postgres=> CREATE TABLE test (a text, b text, c text, d text, e text);
```
1. Utilice el siguiente formulario de la función [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) para importar datos desde el archivo de Amazon S3.
Puede incluir la llamada a la función [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) insertada dentro de la llamada a la función `aws_s3.table_import_from_s3` para especificar el archivo.
```
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')
);
```
Los datos se encuentran ahora en la tabla en las siguientes columnas.
```
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
```
## Importación de un archivo comprimido (gzip) de Amazon S3
El siguiente ejemplo muestra cómo importar un archivo comprimido con gzip desde Amazon S3. El archivo que se importa debe tener los siguientes metadatos de Simple Storage Service (Amazon S3):
+ Clave: `Content-Encoding`
+ Valor:: `gzip`
Si carga el archivo con la Consola de administración de AWS, el sistema suele aplicar los metadatos. Para obtener información sobre cómo cargar archivos en Simple Storage Service (Amazon S3) con la Consola de administración de AWS, la AWS CLI o la API, consulte [Carga de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) en la *Guía del usuario de Amazon Simple Storage Service*.
Para obtener más información acerca de los metadatos de Simple Storage Service (Amazon S3) y detalles acerca de los metadatos proporcionados por el sistema, consulte [Edición de metadatos de objeto en la consola de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-object-metadata.html) en la *Guía del usuario de Amazon Simple Storage Service*.
Importe el archivo gzip en su instancia de RDS para la base de datos PostgreSQL como se muestra a continuación.
```
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'
);
```
## Importación de un archivo de Amazon S3 codificado
El siguiente ejemplo muestra cómo importar un archivo desde Amazon S3 que tenga codificación Windows-1252.
```
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')
);
```
# Referencia de funciones
**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
Importa datos de Amazon S3 en una tabla Amazon RDS. La extensión `aws_s3` proporciona la función `aws_s3.table_import_from_s3`. El valor de devolución es texto.
### Sintaxis
Los parámetros obligatorios son `table_name`, `column_list` y `options`. Estos identifican la tabla de la base de datos y especifican cómo se copian los datos en la tabla.
Asimismo, puede utilizar los siguientes parámetros:
+ El parámetro `s3_info` especifica el archivo Amazon S3 que se va a importar. Cuando utilice este parámetro, se proporciona acceso a Amazon S3 mediante un rol de IAM para la instancia de base de datos de PostgreSQL.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
s3_info aws_commons._s3_uri_1
)
```
+ El parámetro `credentials` especifica las credenciales para acceder a Amazon S3. Cuando utilice este parámetro, no utilice un rol de 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*
Cadena de texto obligatoria que contiene el nombre de la tabla de la base de datos de PostgreSQL a la que importar los datos.
*column\$1list*
Cadena de texto obligatoria que contiene una lista opcional de las columnas de la tabla de la base de datos de PostgreSQL en la que se copiarán los datos. Si la cadena está vacía, se utilizan todas las columnas de la tabla. Para ver un ejemplo, consulte [Importación de un archivo de Amazon S3 que utiliza un delimitador personalizado](USER_PostgreSQL.S3Import.FileFormats.md#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter).
*Opciones de*
Cadena de texto obligatoria que contiene argumentos para el comando `COPY` de PostgreSQL. Estos argumentos especifican cómo se copian los datos en la tabla PostgreSQL. Para obtener más detalles, consulte la [documentación de COPY de PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*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 archivo. Para ver una lista de los nombres de regiones de AWS y los valores asociados, consulte [Regiones, zonas de disponibilidad y Local Zones](Concepts.RegionsAndAvailabilityZones.md).
*credenciales*
Tipo compuesto `aws_commons._aws_credentials_1` que contiene las siguientes credenciales para usar en la operación de importación:
+ Clave de acceso
+ Clave secreta
+ Token de sesión
Para obtener información sobre la creación de una estructura compuesta `aws_commons._aws_credentials_1`, consulte [aws\$1commons.create\$1aws\$1credentials](#USER_PostgreSQL.S3Import.create_aws_credentials).
### Sintaxis alternativa
Como ayuda en las pruebas, puede utilizar un conjunto de parámetros expandido en lugar de los parámetros `s3_info` y `credentials`. A continuación, se incluyen variaciones de sintaxis adicionales para la función:`aws_s3.table_import_from_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`. Con esta forma de la función, se facilita acceso a Amazon S3 mediante un rol de IAM en la instancia de base de datos de PostgreSQL.
```
aws_s3.table_import_from_s3 (
table_name text,
column_list text,
options text,
bucket text,
file_path text,
region text
)
```
+ En lugar de utilizar el parámetro `credentials` para especificar el acceso a Amazon S3, utilice la combinación de parámetros `access_key`, `session_key` y `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
)
```
### Parámetros alternativos
*Bucket de*
Cadena de texto que incluye el nombre del bucket de Amazon S3 que contiene el archivo.
*file\$1path*
Cadena de texto que contiene la ruta de Amazon S3 del archivo.
*region*
Una cadena de texto que identifique la ubicación de Región de AWS del archivo. Para ver una lista de los nombres de Región de AWS y los valores asociados, consulte [Regiones, zonas de disponibilidad y Local Zones](Concepts.RegionsAndAvailabilityZones.md).
*access\$1key*
Cadena de texto que contiene la clave de acceso que se va a utilizar para la operación de importación. El valor predeterminado es NULL.
*secret\$1key*
Cadena de texto que contiene la clave secreta que se va a usar para la operación de importación. El valor predeterminado es NULL.
*session\$1token*
(Opcional) Cadena de texto que contiene la clave de la sesión que se va a utilizar para la operación de importación. El valor predeterminado es NULL.
## aws\$1commons.create\$1s3\$1uri
Crea una estructura `aws_commons._s3_uri_1` para contener la información de archivos de Amazon S3. Utilice los resultados de la función `aws_commons.create_s3_uri` en el parámetro `s3_info` de la función [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3).
### Sintaxis
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```
### Parameters
*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 Región de AWS y los valores asociados, consulte [Regiones, zonas de disponibilidad y Local Zones](Concepts.RegionsAndAvailabilityZones.md).
## aws\$1commons.create\$1aws\$1credentials
Establece una clave de acceso y una clave secreta en una estructura `aws_commons._aws_credentials_1`. Utilice los resultados de la función `aws_commons.create_aws_credentials` en el parámetro `credentials` de la función [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3).
### Sintaxis
```
aws_commons.create_aws_credentials(
access_key text,
secret_key text,
session_token text
)
```
### Parameters
*access\$1key*
Cadena de texto obligatoria que contiene la clave de acceso que se va a utilizar para importar un archivo de Amazon S3. El valor predeterminado es NULL.
*secret\$1key*
Cadena de texto obligatoria que contiene la clave secreta que se va a utilizar para importar un archivo de Amazon S3. El valor predeterminado es NULL.
*session\$1token*
Cadena de texto opcional que contiene el token de la sesión que se va a utilizar para importar un archivo de Amazon S3. El valor predeterminado es NULL. Si facilita un `session_token` opcional, puede usar credenciales temporales.
# Transporte de bases de datos de PostgreSQL entre instancias de base de datos
Cuando utilice bases de datos transportables de PostgreSQL para Amazon RDS, puede trasladar una base de datos de PostgreSQL entre dos instancias de base de datos. Es una forma muy rápida de migrar bases de datos grandes entre distintas instancias de base de datos. Para utilizar este enfoque, ambas instancias de base de datos deben ejecutar la misma versión principal de PostgreSQL.
Esta capacidad requiere que instale la extensión `pg_transport` tanto en la instancia de base de datos de origen como en la de destino. La extensión `pg_transport` proporciona un mecanismo físico de transporte que traslada los archivos de base de datos con un procesamiento mínimo. Este mecanismo traslada los datos mucho más rápido que los procesos tradicionales de volcado y carga, con menos tiempo de inactividad.
**nota**
Las bases de datos transportables de PostgreSQL están disponibles para la versión 11.5 y las versiones posteriores de RDS for PostgreSQL, al igual que para la versión 10.10 y las versiones posteriores.
Para transportar una instancia de base de datos de PostgreSQL de una instancia de base de datos de RDS for PostgreSQL a otra, primero configure las instancias de origen y destino según se detalla en [ Configuración de una instancia de base de datos para transporte](PostgreSQL.TransportableDB.Setup.md). A continuación, puede transportar la base de datos mediante la función descrita en [ Transporte de una base de datos de PostgreSQL](PostgreSQL.TransportableDB.Transporting.md).
**Topics**
+ [Lo que ocurre durante el transporte de base de datos](#PostgreSQL.TransportableDB.DuringTransport)
+ [Limitaciones del uso de bases de datos transportables de PostgreSQL](#PostgreSQL.TransportableDB.Limits)
+ [Configuración de transporte de una base de datos de PostgreSQL](PostgreSQL.TransportableDB.Setup.md)
+ [Transporte de una base de datos PostgreSQL al destino desde el origen](PostgreSQL.TransportableDB.Transporting.md)
+ [Referencia de función de bases de datos transportables](PostgreSQL.TransportableDB.transport.import_from_server.md)
+ [Referencia de parámetros de bases de datos transportables](PostgreSQL.TransportableDB.Parameters.md)
## Lo que ocurre durante el transporte de base de datos
La característica de bases de datos transportables de PostgreSQL utiliza un modelo de extracción para importar la base de datos de la instancia de base de datos de origen a la de destino. La función `transport.import_from_server` crea la base de datos en tránsito en la instancia de base de datos de destino. No se puede acceder a la base de datos en tránsito en la instancia de base de datos de destino mientras dura el transporte.
Cuando el transporte comienza, finalizan todas las sesiones actuales en la base de datos de origen. Cualquier base de datos distinta a la base de datos de origen en la instancia de base de datos de origen no se ve afectada por el transporte.
La base de datos de origen se pone en un modo de solo lectura especial. Mientras está en este modo, puede conectar a la base de datos de origen y ejecutar consultas de solo lectura. Sin embargo, las consultas habilitadas para escritura y algunos otros tipos de comandos están bloqueados. Solo la base de datos de origen específica que se transporta se ve afectada por estas restricciones.
Durante el transporte, no puede restaurar la instancia de base de datos de destino a un momento en el tiempo. Esto se debe a que el transporte no es transaccional y no utiliza el registro antes de la escritura de PostgreSQL para registrar cambios. Si la instancia de base de datos de destino tiene habilitadas las copias de seguridad automáticas, se realiza automáticamente una copia de seguridad una vez que se completa el transporte. Las restauraciones a un momento dado están disponibles para momentos *después* de que finalice la copia de seguridad.
Si el transporte devuelve un error, la extensión `pg_transport` intenta deshacer todos los cambios en las instancias de base de datos de origen y de destino. Esto incluye eliminar la base de datos transportada parcialmente del destino. En función del tipo de error, la base de datos de origen podría seguir rechazando consultas habilitadas para escritura. Si esto ocurre, utilice el comando siguiente para permitir consultas habilitadas para escritura.
```
ALTER DATABASE db-name SET default_transaction_read_only = false;
```
## Limitaciones del uso de bases de datos transportables de PostgreSQL
Las bases de datos transportables tienen las limitaciones siguientes:
+ **Réplicas de lectura**: no puede utilizar bases de datos transportables en réplicas de lectura o instancias principales de réplicas de lectura.
+ **Tipos de columna no admitidos**: no puede usar los tipos de datos `reg` en las tablas de base de datos que tenga previsto transportar con este método. Estos tipos depende de los ID de objeto (OID) de catálogo del sistema, que suelen cambiar durante el transporte.
+ **Espacios de tablas**: todos los objetos de base de datos de origen deben estar en el espacio de tablas `pg_default` predeterminado.
+ **Compatibilidad**: tanto las instancias de base de datos de origen como destino deben ejecutar la misma versión principal de PostgreSQL.
+ **Extensiones**: la instancia de base de datos de origen solo puede tener la extensión `pg_transport` instalada.
+ **Roles y ACL**: los privilegios de acceso y base de datos de origen y la información de propiedad no se traslada a la base de datos de destino. Todos los objetos de base de datos los crea y son propiedad del usuario de destino local del transporte.
+ **Transportes simultáneos**: una única instancia de base de datos puede admitir hasta 32 transportes simultáneos, incluidas tanto las importaciones como las exportaciones, si los procesos de trabajo se han configurado correctamente.
+ **Únicamente para instancias de bases de datos de RDS for PostgreSQL**: las bases de datos transportables de PostgreSQL solo son compatibles en instancias de bases de datos de RDS for PostgreSQL. No puede usarlo con bases de datos locales o bases de datos que se ejecutan en Amazon EC2.
# Configuración de transporte de una base de datos de PostgreSQL
Antes de comenzar, asegúrese de que las instancias de base de datos de RDS for PostgreSQL cumplan los siguientes requisitos:
+ Las instancias de base de datos de RDS for PostgreSQL de origen y destino deben ejecutar la misma versión de PostgreSQL.
+ La base de datos de destino no puede tener una base de datos del mismo nombre que la base de datos de origen que desea transportar.
+ La cuenta que utiliza para gestionar el transporte necesita privilegios `rds_superuser` tanto en la base de datos de origen como en la base de datos de destino.
+ El grupo de seguridad de la instancia de base de datos de origen debe permitir el acceso entrante desde la instancia de base de datos de destino. Es posible que esto ya ocurra si las instancias de base de datos de origen y destino se encuentran en la VPC. Para obtener más información acerca de los grupos de seguridad, consulte [Control de acceso con grupos de seguridad](Overview.RDSSecurityGroups.md).
El transporte de bases de datos desde una instancia de base de datos de origen a una instancia de base de datos de destino requiere varios cambios en el grupo de parámetros de base de datos asociado a cada instancia. Esto significa que debe crear un grupo de parámetros de base de datos personalizado para la instancia de base de datos de origen y otro para la instancia de base de datos de destino.
**nota**
Si las instancias de base de datos ya están configuradas mediante grupos de parámetros de base de datos personalizados, puede comenzar con el paso 2 del siguiente procedimiento.
**Para configurar los parámetros de grupo de bases de datos personalizados para transportar bases de datos**
Para los siguientes pasos, utilice una cuenta que tenga privilegios `rds_superuser`.
1. Si las instancias de base de datos de origen y destino utilizan un grupo de parámetros de base de datos predeterminado, debe crear un grupo de parámetros de base de datos personalizado con la versión adecuada para sus instancias. Haga esto para poder cambiar los valores de varios parámetros. Para obtener más información, consulte [Grupos de parámetros para Amazon RDS](USER_WorkingWithParamGroups.md).
1. En el grupo de parámetros de base de datos personalizado, cambie los valores de los siguientes parámetros:
+ `shared_preload_libraries` – Agregue `pg_transport` a la lista de bibliotecas.
+ `pg_transport.num_workers` – El valor predeterminado es 3. Aumente o reduzca este valor según sea necesario para su base de datos. Para una base de datos de 200 GB, recomendamos que no sea superior a 8. Tenga en cuenta que si aumenta el valor predeterminado de este parámetro, también debe aumentar el valor de `max_worker_processes`.
+ `pg_transport.work_mem` – El valor predeterminado es 128 MB o 256 MB, según la versión de PostgreSQL. Por lo general, la configuración predeterminada se puede dejar sin cambios.
+ `max_worker_processes`: el valor de este parámetro debe establecerse utilizando el siguiente cálculo:
```
(3 * pg_transport.num_workers) + 9
```
Este valor es necesario en el destino para gestionar varios procesos de trabajo en segundo plano involucrados en el transporte. Para obtener más información sobre `max_worker_processes,` y otros parámetros, consulte [Consumo de recursos](https://www.postgresql.org/docs/current/runtime-config-resource.html) en la documentación de PostgreSQL.
Para obtener más información acerca de los parámetros `pg_transport`, consulte [Referencia de parámetros de bases de datos transportables](PostgreSQL.TransportableDB.Parameters.md).
1. Reinicie la instancia de base de datos de origen de RSD for PostgreSQL y la instancia de destino para que la configuración de los parámetros surta efecto.
1. Conéctese a una instancia de base de datos de origen de RDS for PostgreSQL.
```
psql --host=source-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Elimine extensiones extrañas del esquema público de la instancia de base de datos. Solo se permite la extensión `pg_transport` durante la operación de transporte real.
1. Instale la extensión `pg_transport` de la siguiente manera:
```
postgres=> CREATE EXTENSION pg_transport;
CREATE EXTENSION
```
1. Conéctese a una instancia de base de datos de destino de RDS for PostgreSQL. Elimine las extensiones extrañas y, a continuación, instale la extensión `pg_transport`.
```
postgres=> CREATE EXTENSION pg_transport;
CREATE EXTENSION
```
# Transporte de una base de datos PostgreSQL al destino desde el origen
Después de completar el proceso descrito en [Configuración de transporte de una base de datos de PostgreSQL](PostgreSQL.TransportableDB.Setup.md), puede comenzar el transporte. Para ello, ejecute la función `transport.import_from_server` en la instancia de base de datos de destino. En la siguiente sintaxis, puede encontrar los parámetros de la función.
```
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);
```
El valor `false` que se muestra en el ejemplo indica a la función que no se trata de una prueba. Para probar la configuración de transporte, puede especificar `true` para la opción `dry_run` cuando ejecute la función, como se muestra a continuación:
```
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)
```
Las líneas de INFO se generan porque el parámetro `pg_transport.timing` se establece en su valor predeterminado `true`. Configure `dry_run` en `false` cuando ejecute el comando y la base de datos de origen se importe al destino, como se muestra a continuación:
```
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)
```
Esta función requiere que proporcione contraseñas de usuario de base de datos. De esta manera, le recomendamos que cambie las contraseñas de los roles de usuario que ha utilizado después de completar el transporte. O, puede utilizar variables de enlace SQL para crear roles de usuario temporales. Utilice estos roles temporales para el transporte y, a continuación, descarte los roles con posterioridad.
Si el transporte no se realiza correctamente, es posible que vea un mensaje de error similar al siguiente:
```
pg_transport.num_workers=8 25% of files transported failed to download file data
```
El mensaje de error “Failed to download file data” (No se pudo descargar los datos de archivo) indica que el número de procesos de trabajo no está configurado correctamente para el tamaño de la base de datos. Es posible que tenga que aumentar o disminuir el valor establecido para `pg_transport.num_workers`. Cada error informa el porcentaje de finalización, de modo que pueda ver el impacto de los cambios. Por ejemplo, cambiar la configuración de 8 a 4 en un caso dio lugar a lo siguiente:
```
pg_transport.num_workers=4 75% of files transported failed to download file data
```
Tenga en cuenta que el parámetro `max_worker_processes` también se tiene en cuenta durante el proceso de transporte. En otras palabras, es posible que tenga que modificar tanto `pg_transport.num_workers` como `max_worker_processes` para transportar correctamente la base de datos. El ejemplo que se muestra finalmente funcionó cuando `pg_transport.num_workers` se estableció en 2:
```
pg_transport.num_workers=2 100% of files transported
```
Para obtener más información sobre la funcionalidad `transport.import_from_server` y sus parámetros, consulte [Referencia de función de bases de datos transportables](PostgreSQL.TransportableDB.transport.import_from_server.md).
# Referencia de función de bases de datos transportables
La función `transport.import_from_server` transporta una base de datos de PostgreSQL importándola desde una instancia de base de datos de origen en una instancia de base de datos de destino. Lo hace utilizando un mecanismo de transporte de conexión de base de datos física.
Antes de iniciar el transporte, esta función verifica que las instancias de base de datos de origen y de destino sean la misma versión y sean compatibles para la migración. También confirma que la instancia de base de datos de destino tenga suficiente espacio para la de origen.
**Sintaxis**
```
transport.import_from_server(
host text,
port int,
username text,
password text,
database text,
local_password text,
dry_run bool
)
```
**Valor de retorno**
Ninguno.
**Parámetros**
Puede buscar las descripciones de los parámetros de función `transport.import_from_server` en la tabla siguiente.
****
| Parámetro | Descripción |
| --- | --- |
| host | El punto de enlace de una instancia de base de datos de origen. |
| port | Un entero que representa el puerto de la instancia de base de datos de origen. Las instancias de base de datos de PostgreSQL suelen utilizar el puerto 5432. |
| username | El usuario de la instancia de base de datos de origen. Este usuario debe ser un miembro del rol `rds_superuser`. |
| password | La contraseña de usuario de la instancia de base de datos de origen. |
| database | El nombre de la base de datos en la instancia de base de datos de origen que transportar. |
| local\$1password | La contraseña local del usuario actual para la instancia de base de datos de destino. Este usuario debe ser un miembro del rol `rds_superuser`. |
| dry\$1run | Un valor booleano opcional que especifique si realizar un simulacro. El valor predeterminado es `false`, lo que significa que el transporte continúa.Para confirmar la compatibilidad entre las instancias de base de datos de origen y destino sin llevar a cabo el transporte real, defina dry\$1run en true. |
**Ejemplo**
Para ver un ejemplo, consulte [Transporte de una base de datos PostgreSQL al destino desde el origen](PostgreSQL.TransportableDB.Transporting.md).
# Referencia de parámetros de bases de datos transportables
Varios parámetros controlan el comportamiento de la extensión `pg_transport`. A continuación, puede encontrar las descripciones de estos parámetros.
**`pg_transport.num_workers`**
El número de empleados que se necesitarán para el proceso de transporte. El valor predeterminado es 3. Los valores válidos están comprendidos entre 1 y 32. Incluso los transportes de base de datos más grandes normalmente requieren menos de 8 empleados. El valor de esta configuración en la instancia de base de datos de destino se utiliza tanto en las instancias de base de datos de destino y de origen durante el transporte.
**`pg_transport.timing` **
Especifica si se debe notificar la información de tiempo durante el transporte. El valor predeterminado es `true`, lo que significa que se informa la información de los plazos. Le recomendamos que deje este parámetro configurado en `true` para que pueda supervisar el progreso. Para ejemplo de salida, consulte [Transporte de una base de datos PostgreSQL al destino desde el origen](PostgreSQL.TransportableDB.Transporting.md).
**`pg_transport.work_mem`**
La cantidad de memoria máxima que asignar para cada proceso de trabajo. El valor predeterminado es 131 072 kilobytes (KB) o 262 144 KB (256 MB), según la versión de PostgreSQL. El valor mínimo es 64 megabytes (65 536 KB). Los valores válidos están en kilobytes (KB) como unidades binarias de base 2, donde 1 KB = 1024 bytes.
El transporte podría utilizar menos memoria que la que se especifica en este parámetro. Incluso los transportes de base de datos grandes normalmente requieren menos de 256 MB (262 144 KB) de memoria por proceso de trabajo.