# Introducción a las integraciones sin ETL de Aurora
Antes de crear una integración sin ETL, configure el clúster de base de datos de Aurora y el almacén de datos con los parámetros y permisos necesarios. Durante la configuración, realizará los siguientes pasos:
1. [Creación de un grupo de parámetros de clúster de base de datos personalizado.](#zero-etl.parameters)
1. [Cree un clúster de base de datos de origen](#zero-etl.create-cluster).
1. [Cree un almacenamiento de datos de destino para Amazon Redshift](#zero-etl-setting-up.data-warehouse) o [cree un Amazon SageMaker Lakehouse](#zero-etl-setting-up.sagemaker).
Una vez que haya completado estas tareas, continúe con [Creación de integraciones sin ETL de Aurora con Amazon Redshift](zero-etl.creating.md) o [Creación de integraciones sin ETL de Aurora con un Amazon SageMaker Lakehouse](zero-etl.creating-smlh.md).
Puede utilizar los SDK de AWS para automatizar el proceso de configuración. Para obtener más información, consulte [Configuración de una integración mediante los AWS SDK](#zero-etl.setup-sdk).
**sugerencia**
Puede dejar que RDS complete estos pasos de configuración automáticamente mientras crea la integración, en lugar de hacerlos de forma manual. Para empezar inmediatamente a crear una integración, consulte [Creación de integraciones sin ETL de Aurora con Amazon Redshift](zero-etl.creating.md).
En el paso 3, puede optar por crear un almacén de datos de destino (paso 3a) o un Lakehouse de destino (paso 3b), según sus necesidades:
+ Elija un almacén de datos si necesita capacidades de almacenamiento de datos tradicionales con análisis basados en SQL.
+ Elija un Amazon SageMaker Lakehouse si necesita capacidades de machine learning y desea utilizar las características de lakehouse para la ciencia de datos y los flujos de trabajo de machine learning.
## Crear un grupo de parámetros de clúster de base de datos personalizado
Las integraciones sin ETL de Aurora requieren valores específicos para los parámetros del clúster de base de datos que controlan la replicación. En concreto, Aurora MySQL requiere un *binlog mejorado* (`aurora_enhanced_binlog`) y Aurora PostgreSQL requiere *replicación lógica mejorada* (`aurora.enhanced_logical_replication`).
Para configurar el registro binario o la replicación lógica, primero debe crear un grupo de parámetros personalizado del clúster de base de datos y, a continuación, asociarlo al clúster de base de datos de origen.
**Aurora MySQL (familia aurora-mysql)**:
+ `aurora_enhanced_binlog=1`
+ `binlog_backup=0`
+ `binlog_format=ROW`
+ `binlog_replication_globaldb=0`
+ `binlog_row_image=full`
+ `binlog_row_metadata=full`
Además, compruebe que el parámetro `binlog_transaction_compression` *no* esté establecido en `ON` y que el parámetro `binlog_row_value_options` *no* esté establecido en `PARTIAL_JSON`.
Para obtener más información sobre el binlog mejorado de Aurora MySQL, consulte [Configuración del binlog mejorado para Aurora MySQL](AuroraMySQL.Enhanced.binlog.md).
**Aurora PostgreSQL (familia aurora-postgresql):**
+ `rds.logical_replication=1`
+ `aurora.enhanced_logical_replication=1`
+ `aurora.logical_replication_backup=0`
+ `aurora.logical_replication_globaldb=0`
Al habilitar la replicación lógica mejorada (`aurora.enhanced_logical_replication`), siempre se escribirán todos los valores de las columnas en el registro de escritura anticipada (WAL), incluso si `REPLICA IDENTITY FULL` no está habilitada. Esto podría aumentar las IOPS del clúster de base de datos de origen.
**importante**
Si habilita o desactiva el parámetro del clúster de base de datos `aurora.enhanced_logical_replication`, la instancia de base de datos principal invalida todas las ranuras de replicación lógica. Esto detiene la replicación desde el origen hasta el destino y debe volver a crear los intervalos de replicación en la instancia de base de datos principal. Para evitar interrupciones, mantenga el estado de parámetro coherente durante la replicación.
## Paso 2: seleccionar o crear un clúster de base de datos de origen
Tras crear un grupo de parámetros personalizado del clúster de base de datos, elija o cree un un clúster de base de datos de Aurora. Este clúster será el origen de la replicación de datos en el almacén de datos de destino. Puede especificar un clúster de base de datos que utilice instancias de base de datos o instancias de base de datos de Aurora Serverless v2 aprovisionadas. Para obtener instrucciones sobre cómo crear un clúster de base de datos, consulte [Creación de un clúster de base de datos de Amazon Aurora](Aurora.CreateInstance.md) o [Creación de un clúster de base de datos que utiliza Aurora Serverless v2](aurora-serverless-v2.create.md).
La base de datos debe ejecutar una versión de motor de base de datos compatible. Para obtener una lista de las versiones compatibles, consulte [Regiones y motores de base de datos de Aurora admitidos para integraciones sin ETL](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Zero-ETL.md).
Al crear la base de datos, en **Configuración adicional**, cambie el **grupo de parámetros de clúster de base de datos** predeterminado por el grupo de parámetros personalizado que ha creado en el paso anterior.
**nota**
Si asocia el grupo de parámetros al clúster de base de datos *después* de haber creado el clúster, debe reiniciar la instancia de base de datos principal del clúster para aplicar los cambios y poder crear una integración sin ETL. Para obtener instrucciones, consulte [Reinicio de un clúster de base de datos de Amazon Aurora o de una instancia de base de datos de Amazon Aurora](USER_RebootCluster.md).
## Paso 3a: crear un almacén de datos de destino
Tras crear el clúster de base de datos de origen, debe crear y configurar un almacén de datos de destino. El almacenamiento de datos debe cumplir los siguientes requisitos:
+ Uso de un tipo de nodo RA3 con al menos dos nodos o Redshift sin servidor.
+ Cifrado (si se utiliza un clúster aprovisionado). Para obtener más información, consulte [Cifrado de base de datos de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
Para obtener instrucciones sobre cómo crear un almacenamiento de datos, consulte la sección [Creación de un clúster](https://docs.aws.amazon.com/redshift/latest/mgmt/create-cluster) para clústeres aprovisionados o [Creación de un grupo de trabajo con un espacio de nombres](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-console-workgroups-create-workgroup-wizard.html) para Redshift Serverless.
### Activar la distinción entre mayúsculas y minúsculas en el almacén de datos
Para que la integración funcione, el parámetro de distinción entre mayúsculas y minúsculas ([https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html)) debe estar habilitado en el almacenamiento de datos. De forma predeterminada, la distinción entre mayúsculas y minúsculas está desactivada en todos los clústeres y grupos de trabajo sin servidor de Redshift suministrados.
Para activar la distinción entre mayúsculas y minúsculas, realice los siguientes pasos en función del tipo de almacén de datos:
+ **Clúster aprovisionado**: para habilitar la distinción entre mayúsculas y minúsculas en un clúster aprovisionado, cree un grupo de parámetros personalizado con el parámetro `enable_case_sensitive_identifier` habilitado. A continuación, asocie el grupo de parámetros al clúster. Para obtener instrucciones, consulte la sección [Administración de grupos de parámetros mediante la consola](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-parameter-groups-console.html) o [Configuración de los valores de parámetros mediante la AWS CLI](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#configure-parameters-using-the-clil).
**nota**
Recuerde reiniciar el clúster después de asociarlo el grupo de parámetros personalizado.
+ **Grupo de trabajo sin servidor**: para habilitar la distinción entre mayúsculas y minúsculas en un grupo de trabajo sin servidor de Redshift, debe usar AWS CLI. Actualmente, la consola de Amazon Redshift no permite modificar los valores de los parámetros de Redshift sin servidor. Envíe la siguiente solicitud de [update-workgroup](https://docs.aws.amazon.com/cli/latest/reference/redshift-serverless/update-workgroup.html):
```
aws redshift-serverless update-workgroup \
--workgroup-name target-workgroup \
--config-parameters parameterKey=enable_case_sensitive_identifier,parameterValue=true
```
No es necesario reiniciar un grupo de trabajo después de modificar los valores de los parámetros.
### Configure la autorización para el almacenamiento de datos
Tras crear un almacenamiento de datos, debe configurar el clúster de base de datos de Aurora de origen como origen de integración autorizado. Para obtener instrucciones, consulte [Configuración de la autorización para el almacenamiento de datos de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam).
## Configuración de una integración mediante los AWS SDK
En lugar de configurar cada recurso manualmente, puede ejecutar el siguiente script de Python para configurar automáticamente los recursos necesarios. El ejemplo de código utiliza [AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) para crear un clúster de base de datos de Amazon Aurora de origen y un almacén de datos de destino, cada uno de ellos con los valores de parámetros necesarios. A continuación, espera a que las bases de datos estén disponibles antes de crear una integración sin ETL entre ellas. Puede comentar diferentes funciones dependiendo de los recursos que necesite configurar.
Ejecute los siguientes comandos para asegurarse de que dispone de todas las dependencias necesarias:
```
pip install boto3
pip install time
```
En el script, si lo desea, modifique los nombres de los grupos de origen, destino y parámetros. La función final crea una integración denominada `my-integration` después de configurar los recursos.
### Ejemplo de código Python
------
#### [ Aurora MySQL ]
```
import boto3
import time
# Build the client using the default credential configuration.
# You can use the CLI and run 'aws configure' to set access key, secret
# key, and default Region.
rds = boto3.client('rds')
redshift = boto3.client('redshift')
sts = boto3.client('sts')
source_cluster_name = 'my-source-cluster' # A name for the source cluster
source_param_group_name = 'my-source-param-group' # A name for the source parameter group
target_cluster_name = 'my-target-cluster' # A name for the target cluster
target_param_group_name = 'my-target-param-group' # A name for the target parameter group
def create_source_cluster(*args):
"""Creates a source Aurora MySQL DB cluster"""
response = rds.create_db_cluster_parameter_group(
DBClusterParameterGroupName=source_param_group_name,
DBParameterGroupFamily='aurora-mysql8.0',
Description='For Aurora MySQL binary logging'
)
print('Created source parameter group: ' + response['DBClusterParameterGroup']['DBClusterParameterGroupName'])
response = rds.modify_db_cluster_parameter_group(
DBClusterParameterGroupName=source_param_group_name,
Parameters=[
{
'ParameterName': 'aurora_enhanced_binlog',
'ParameterValue': '1',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'binlog_backup',
'ParameterValue': '0',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'binlog_format',
'ParameterValue': 'ROW',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'binlog_replication_globaldb',
'ParameterValue': '0',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'binlog_row_image',
'ParameterValue': 'full',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'binlog_row_metadata',
'ParameterValue': 'full',
'ApplyMethod': 'pending-reboot'
}
]
)
print('Modified source parameter group: ' + response['DBClusterParameterGroupName'])
response = rds.create_db_cluster(
DBClusterIdentifier=source_cluster_name,
DBClusterParameterGroupName=source_param_group_name,
Engine='aurora-mysql',
EngineVersion='8.0.mysql_aurora.3.05.2',
DatabaseName='myauroradb',
MasterUsername='username',
MasterUserPassword='Password01**'
)
print('Creating source cluster: ' + response['DBCluster']['DBClusterIdentifier'])
source_arn = (response['DBCluster']['DBClusterArn'])
create_target_cluster(target_cluster_name, source_arn, target_param_group_name)
response = rds.create_db_instance(
DBInstanceClass='db.r6g.2xlarge',
DBClusterIdentifier=source_cluster_name,
DBInstanceIdentifier=source_cluster_name + '-instance',
Engine='aurora-mysql'
)
return(response)
def create_target_cluster(target_cluster_name, source_arn, target_param_group_name):
"""Creates a target Redshift cluster"""
response = redshift.create_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
ParameterGroupFamily='redshift-1.0',
Description='For Aurora MySQL zero-ETL integrations'
)
print('Created target parameter group: ' + response['ClusterParameterGroup']['ParameterGroupName'])
response = redshift.modify_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
Parameters=[
{
'ParameterName': 'enable_case_sensitive_identifier',
'ParameterValue': 'true'
}
]
)
print('Modified target parameter group: ' + response['ParameterGroupName'])
response = redshift.create_cluster(
ClusterIdentifier=target_cluster_name,
NodeType='ra3.4xlarge',
NumberOfNodes=2,
Encrypted=True,
MasterUsername='username',
MasterUserPassword='Password01**',
ClusterParameterGroupName=target_param_group_name
)
print('Creating target cluster: ' + response['Cluster']['ClusterIdentifier'])
# Retrieve the target cluster ARN
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Retrieve the current user's account ID
response = sts.get_caller_identity()
account_id = response['Account']
# Create a resource policy specifying cluster ARN and account ID
response = redshift.put_resource_policy(
ResourceArn=target_arn,
Policy='''
{
\"Version\":\"2012-10-17\",
\"Statement\":[
{\"Effect\":\"Allow\",
\"Principal\":{
\"Service\":\"redshift.amazonaws.com\"
},
\"Action\":[\"redshift:AuthorizeInboundIntegration\"],
\"Condition\":{
\"StringEquals\":{
\"aws:SourceArn\":\"%s\"}
}
},
{\"Effect\":\"Allow\",
\"Principal\":{
\"AWS\":\"arn:aws:iam::%s:root\"},
\"Action\":\"redshift:CreateInboundIntegration\"}
]
}
''' % (source_arn, account_id)
)
return(response)
def wait_for_cluster_availability(*args):
"""Waits for both clusters to be available"""
print('Waiting for clusters to be available...')
response = rds.describe_db_clusters(
DBClusterIdentifier=source_cluster_name
)
source_status = response['DBClusters'][0]['Status']
source_arn = response['DBClusters'][0]['DBClusterArn']
response = rds.describe_db_instances(
DBInstanceIdentifier=source_cluster_name + '-instance'
)
source_instance_status = response['DBInstances'][0]['DBInstanceStatus']
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_status = response['Clusters'][0]['ClusterStatus']
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Every 60 seconds, check whether the clusters are available.
if source_status != 'available' or target_status != 'available' or source_instance_status != 'available':
time.sleep(60)
response = wait_for_cluster_availability(
source_cluster_name, target_cluster_name)
else:
print('Clusters available. Ready to create zero-ETL integration.')
create_integration(source_arn, target_arn)
return
def create_integration(source_arn, target_arn):
"""Creates a zero-ETL integration using the source and target clusters"""
response = rds.create_integration(
SourceArn=source_arn,
TargetArn=target_arn,
IntegrationName='my-integration'
)
print('Creating integration: ' + response['IntegrationName'])
def main():
"""main function"""
create_source_cluster(source_cluster_name, source_param_group_name)
wait_for_cluster_availability(source_cluster_name, target_cluster_name)
if __name__ == "__main__":
main()
```
------
#### [ Aurora PostgreSQL ]
```
import boto3
import time
# Build the client using the default credential configuration.
# You can use the CLI and run 'aws configure' to set access key, secret
# key, and default Region.
rds = boto3.client('rds')
redshift = boto3.client('redshift')
sts = boto3.client('sts')
source_cluster_name = 'my-source-cluster' # A name for the source cluster
source_param_group_name = 'my-source-param-group' # A name for the source parameter group
target_cluster_name = 'my-target-cluster' # A name for the target cluster
target_param_group_name = 'my-target-param-group' # A name for the target parameter group
def create_source_cluster(*args):
"""Creates a source Aurora PostgreSQL DB cluster"""
response = rds.create_db_cluster_parameter_group(
DBClusterParameterGroupName=source_param_group_name,
DBParameterGroupFamily='aurora-postgresql16',
Description='For Aurora PostgreSQL logical replication'
)
print('Created source parameter group: ' + response['DBClusterParameterGroup']['DBClusterParameterGroupName'])
response = rds.modify_db_cluster_parameter_group(
DBClusterParameterGroupName=source_param_group_name,
Parameters=[
{
'ParameterName': 'rds.logical_replication',
'ParameterValue': '1',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'aurora.enhanced_logical_replication',
'ParameterValue': '1',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'aurora.logical_replication_backup',
'ParameterValue': '0',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'aurora.logical_replication_globaldb',
'ParameterValue': '0',
'ApplyMethod': 'pending-reboot'
}
]
)
print('Modified source parameter group: ' + response['DBClusterParameterGroupName'])
response = rds.create_db_cluster(
DBClusterIdentifier=source_cluster_name,
DBClusterParameterGroupName=source_param_group_name,
Engine='aurora-postgresql',
EngineVersion='16.4.aurora-postgresql',
DatabaseName='mypostgresdb',
MasterUsername='username',
MasterUserPassword='Password01**'
)
print('Creating source cluster: ' + response['DBCluster']['DBClusterIdentifier'])
source_arn = (response['DBCluster']['DBClusterArn'])
create_target_cluster(target_cluster_name, source_arn, target_param_group_name)
response = rds.create_db_instance(
DBInstanceClass='db.r6g.2xlarge',
DBClusterIdentifier=source_cluster_name,
DBInstanceIdentifier=source_cluster_name + '-instance',
Engine='aurora-postgresql'
)
return(response)
def create_target_cluster(target_cluster_name, source_arn, target_param_group_name):
"""Creates a target Redshift cluster"""
response = redshift.create_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
ParameterGroupFamily='redshift-1.0',
Description='For Aurora PostgreSQL zero-ETL integrations'
)
print('Created target parameter group: ' + response['ClusterParameterGroup']['ParameterGroupName'])
response = redshift.modify_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
Parameters=[
{
'ParameterName': 'enable_case_sensitive_identifier',
'ParameterValue': 'true'
}
]
)
print('Modified target parameter group: ' + response['ParameterGroupName'])
response = redshift.create_cluster(
ClusterIdentifier=target_cluster_name,
NodeType='ra3.4xlarge',
NumberOfNodes=2,
Encrypted=True,
MasterUsername='username',
MasterUserPassword='Password01**',
ClusterParameterGroupName=target_param_group_name
)
print('Creating target cluster: ' + response['Cluster']['ClusterIdentifier'])
# Retrieve the target cluster ARN
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Retrieve the current user's account ID
response = sts.get_caller_identity()
account_id = response['Account']
# Create a resource policy specifying cluster ARN and account ID
response = redshift.put_resource_policy(
ResourceArn=target_arn,
Policy='''
{
\"Version\":\"2012-10-17\",
\"Statement\":[
{\"Effect\":\"Allow\",
\"Principal\":{
\"Service\":\"redshift.amazonaws.com\"
},
\"Action\":[\"redshift:AuthorizeInboundIntegration\"],
\"Condition\":{
\"StringEquals\":{
\"aws:SourceArn\":\"%s\"}
}
},
{\"Effect\":\"Allow\",
\"Principal\":{
\"AWS\":\"arn:aws:iam::%s:root\"},
\"Action\":\"redshift:CreateInboundIntegration\"}
]
}
''' % (source_arn, account_id)
)
return(response)
def wait_for_cluster_availability(*args):
"""Waits for both clusters to be available"""
print('Waiting for clusters to be available...')
response = rds.describe_db_clusters(
DBClusterIdentifier=source_cluster_name
)
source_status = response['DBClusters'][0]['Status']
source_arn = response['DBClusters'][0]['DBClusterArn']
response = rds.describe_db_instances(
DBInstanceIdentifier=source_cluster_name + '-instance'
)
source_instance_status = response['DBInstances'][0]['DBInstanceStatus']
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_status = response['Clusters'][0]['ClusterStatus']
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Every 60 seconds, check whether the clusters are available.
if source_status != 'available' or target_status != 'available' or source_instance_status != 'available':
time.sleep(60)
response = wait_for_cluster_availability(
source_cluster_name, target_cluster_name)
else:
print('Clusters available. Ready to create zero-ETL integration.')
create_integration(source_arn, target_arn)
return
def create_integration(source_arn, target_arn):
"""Creates a zero-ETL integration using the source and target clusters"""
response = rds.create_integration(
SourceArn=source_arn,
TargetArn=target_arn,
IntegrationName='my-integration'
)
print('Creating integration: ' + response['IntegrationName'])
def main():
"""main function"""
create_source_cluster(source_cluster_name, source_param_group_name)
wait_for_cluster_availability(source_cluster_name, target_cluster_name)
if __name__ == "__main__":
main()
```
------
## Paso 3b: creación de un catálogo de AWS Glue para una integración sin ETL de Amazon SageMaker Lakehouse
Al crear una integración sin ETL con un Amazon SageMaker Lakehouse, debe crear un catálogo administrado por AWS Glue en AWS Lake Formation. El catálogo de destino debe ser un catálogo administrado por Amazon Redshift. Para crear un catálogo administrado por Amazon Redshift, cree primero el rol vinculado al servicio de `AWSServiceRoleForRedshift`. En la consola de Lake Formation, agregue `AWSServiceRoleForRedshift` como administrador de solo lectura.
Para obtener más información sobre las tareas anteriores, consulte los siguientes temas.
+ Para obtener información sobre la creación de un catálogo administrado por Amazon Redshift, consulte [Creación de un catálogo administrado por Amazon Redshift en AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-rms-catalog.html) en la *Guía para desarrolladores de AWS Lake Formation*.
+ Para obtener información sobre el role vinculado al servicio para Amazon Redshift, consulte [Uso de roles vinculados a servicios para Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/using-service-linked-roles.html) en la *Guía de administración de Amazon Redshift*.
+ Para obtener información sobre los permisos de administrador de solo lectura para Lake Formation, consulte la [referencia sobre las personas de Lake Formation y los permisos de IAM](https://docs.aws.amazon.com/lake-formation/latest/dg/permissions-reference.html) en la *Guía para desarrolladores de AWS Lake Formation*.
### Configuración de los permisos para el catálogo de AWS Glue de destino
Antes de crear un catálogo de destino para la integración sin ETL, debe crear el rol de creación de destino de Lake Formation y el rol de transferencia de datos de AWS Glue. Utilice el rol de creación de destino de Lake Formation para crear el catálogo de destino. Al crear el catálogo de destino, ingrese el rol de transferencia de datos de Glue en el campo **Rol de IAM** de la **sección Acceso desde motores**.
#### Rol de creación de destino de Lake Formation
El rol de creación de destino debe ser un administrador de Lake Formation y requiere los siguientes permisos.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "lakeformation:RegisterResource",
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"s3:PutEncryptionConfiguration",
"iam:PassRole",
"glue:CreateCatalog",
"glue:GetCatalog",
"s3:PutBucketTagging",
"s3:PutLifecycleConfiguration",
"s3:PutBucketPolicy",
"s3:CreateBucket",
"redshift-serverless:CreateNamespace",
"s3:DeleteBucket",
"s3:PutBucketVersioning",
"redshift-serverless:CreateWorkgroup"
],
"Resource": [
"arn:aws:glue:*:111122223333:catalog",
"arn:aws:glue:*:111122223333:catalog/*",
"arn:aws:s3:::*",
"arn:aws:redshift-serverless:*:111122223333:workgroup/*",
"arn:aws:redshift-serverless:*:111122223333:namespace/*",
"arn:aws:iam::111122223333:role/GlueDataCatalogDataTransferRole"
]
}
]
}
```
------
El rol de creación de destino debe tener la siguiente relación de confianza.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:user/Username"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
#### Rol de transferencia de datos de Glue
El rol de transferencia de datos de Glue es necesario para las operaciones del catálogo de MySQL y debe tener los siguientes permisos.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataTransferRolePolicy",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"glue:GetCatalog",
"glue:GetDatabase"
],
"Resource": [
"*"
]
}
]
}
```
------
El rol de transferencia de datos de Glue debe tener la siguiente relación de confianza.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
## Siguientes pasos
Con un clúster de base de datos de Aurora de origen y un almacenamiento de datos de destino de Amazon Redshift o Amazon SageMaker Lakehouse, puede crear una integración sin ETL y datos de replicación. Para obtener instrucciones, consulte [Creación de integraciones sin ETL de Aurora con Amazon Redshift](zero-etl.creating.md).