Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Erste Schritte mit Aurora Zero-ETL-Integrationen
Bevor Sie eine Zero-ETL-Integration erstellen, konfigurieren Sie Ihren Aurora DB-Cluster für die und Ihr Data Warehouse mit den erforderlichen Parametern und Berechtigungen. Während der Einrichtung führen Sie die folgenden Schritte aus:
Nachdem Sie diese Aufgaben abgeschlossen haben, fahren Sie mit oder fortErstellen von Null-ETL-Integrationen von Aurora mit Amazon Redshift. Erstellen von Aurora Zero-ETL-Integrationen mit einem Lakehouse Amazon SageMaker
Sie können den verwenden AWS SDKs , um den Einrichtungsprozess für Sie zu automatisieren. Weitere Informationen finden Sie unter Richten Sie eine Integration mit dem ein AWS SDKs.
Für Schritt 3 können Sie je nach Bedarf wählen, ob Sie entweder ein Ziel-Data Warehouse (Schritt 3a) oder ein Ziel-Lakehouse (Schritt 3b) erstellen möchten:
-
Wählen Sie ein Data Warehouse, wenn Sie herkömmliche Data Warehousing-Funktionen mit SQL-basierten Analysen benötigen.
-
Entscheiden Sie sich für ein Amazon SageMaker AI Lakehouse, wenn Sie Funktionen für maschinelles Lernen benötigen und Lakehouse-Funktionen für Data-Science- und ML-Workflows verwenden möchten.
Schritt 1: Erstellen einer benutzerdefinierten DB-Cluster-Parametergruppe
Aurora Zero-ETL-Integrationen erfordern spezifische Werte für die DB-Cluster-Parameter, die die Replikation steuern. Insbesondere erfordert Aurora MySQL eine erweiterte binlog (aurora_enhanced_binlog), und Aurora PostgreSQL erfordert eine erweiterte logische Replikation (). aurora.enhanced_logical_replication
Um die binäre Protokollierung oder logische Replikation zu konfigurieren, müssen Sie zuerst eine benutzerdefinierte DB-Cluster-Parametergruppe erstellen und diese dann dem Quell-DB-Cluster zuordnen.
Aurora MySQL (Aurora-Mysql8.0-Familie):
Stellen Sie außerdem sicher, dass der binlog_transaction_compression-Parameter nicht auf ON und der binlog_row_value_options-Parameter nicht auf PARTIAL_JSON gesetzt ist.
Weitere Informationen zu Aurora MySQL Enhanced Binlog finden Sie unterErweitertes Binlog für Aurora MySQL einrichten.
Aurora PostgreSQL (Aurora-Postgresql16-Familie):
-
rds.logical_replication=1
-
aurora.enhanced_logical_replication=1
-
aurora.logical_replication_backup=0
-
aurora.logical_replication_globaldb=0
Wenn Sie die erweiterte logische Replikation (aurora.enhanced_logical_replication) aktivieren, werden immer alle Spaltenwerte in das Write-Ahead-Protokoll (WAL) geschrieben, auch wenn es nicht aktiviert ist. REPLICA IDENTITY FULL Dies kann die IOPS für Ihren Quell-DB-Cluster erhöhen.
Wenn Sie den aurora.enhanced_logical_replication DB-Cluster-Parameter aktivieren oder deaktivieren, macht die primäre DB-Instance alle logischen Replikationssteckplätze ungültig. Dadurch wird die Replikation von der Quelle zum Ziel gestoppt, und Sie müssen die Replikationssteckplätze auf der primären DB-Instance neu erstellen. Um Unterbrechungen zu vermeiden, sollten Sie den Parameterstatus während der Replikation konsistent halten.
Schritt 2: Wählen oder erstellen Sie einen
Nachdem Sie eine benutzerdefinierte DB-Cluster-Parametergruppe erstellt haben, wählen oder erstellen Sie einen Aurora-DB-Cluster für die . Dieser wird die Quelle der Datenreplikation zum Ziel-Data Warehouse sein. Sie können einen DB-Cluster angeben, der bereitgestellte DB-Instances oder Aurora Serverless v2 DB-Instances als Quelle verwendet. Anweisungen zum Erstellen eines finden Sie unter oder. Erstellen eines Amazon Aurora-DB ClustersErstellen eines DB-Clusters, das Aurora Serverless v2
Auf der Datenbank muss eine unterstützte DB-Engine-Version ausgeführt werden. Eine Liste der unterstützten Versionen finden Sie unter Unterstützte Regionen und Aurora-DB-Engines für Zero-ETL-Integrationen.
Wenn Sie die Datenbank erstellen, ändern Sie unter Zusätzliche Konfiguration die Standard-DB-Cluster-Parametergruppe in die benutzerdefinierte Parametergruppe, die Sie im vorherigen Schritt erstellt haben.
Schritt 3a: Erstellen Sie ein Ziel-Data Warehouse
Nachdem Sie Ihren erstellt haben, müssen Sie ein Ziel-Data Warehouse erstellen und konfigurieren. Das Data Warehouse muss die folgenden Anforderungen erfüllen:
-
Verwendung eines RA3 Knotentyps mit mindestens zwei Knoten oder Redshift Serverless.
-
Es muss verschlüsselt sein (bei Verwendung eines bereitgestellten Clusters). Weitere Informationen finden Sie unter Datenbankverschlüsselung in Amazon Redshift.
Anweisungen zum Erstellen eines Data Warehouse finden Sie unter Erstellen eines Clusters für bereitgestellte Cluster oder Erstellen einer Arbeitsgruppe mit einem Namespace für Redshift Serverless.
Aktivieren Sie die Berücksichtigung von Groß- und Kleinschreibung im Data Warehouse
Damit die Integration erfolgreich ist, muss der Parameter für die Berücksichtigung von Groß- und Kleinschreibung (enable_case_sensitive_identifier) für das Data Warehouse aktiviert sein. Standardmäßig ist die Berücksichtigung von Groß- und Kleinschreibung auf allen bereitgestellten Clustern und Redshift-Serverless-Arbeitsgruppen deaktiviert.
Um die Berücksichtigung von Groß- und Kleinschreibung zu aktivieren, führen Sie je nach Data-Warehouse-Typ die folgenden Schritte aus:
-
Bereitgestellter Cluster – Um die Berücksichtigung von Groß- und Kleinschreibung in einem bereitgestellten Cluster zu aktivieren, erstellen Sie eine benutzerdefinierte Parametergruppe mit aktiviertem enable_case_sensitive_identifier-Parameter. Ordnen Sie diese Parametergruppe dann dem Cluster zu. Anweisungen finden Sie unter Verwalten von Parametergruppen mit der Konsole oder Konfigurieren von Parameterwerten mit der AWS CLI.
Denken Sie daran, den Cluster neu zu starten, nachdem Sie ihm die benutzerdefinierte Parametergruppe zugeordnet haben.
-
Serverless-Arbeitsgruppe – Um die Berücksichtigung von Groß- und Kleinschreibung in einer Redshift-Serverless-Arbeitsgruppe zu aktivieren, müssen Sie die AWS CLI verwenden. Die Amazon-Redshift-Konsole unterstützt derzeit nicht das Ändern von Redshift-Serverless-Parameterwerten. Senden Sie die folgende Anfrage zur Aktualisierung der Arbeitsgruppe:
aws redshift-serverless update-workgroup \
--workgroup-name target-workgroup \
--config-parameters parameterKey=enable_case_sensitive_identifier,parameterValue=true
Sie müssen eine Arbeitsgruppe nicht neu starten, nachdem Sie ihre Parameterwerte geändert haben.
Konfigurieren der Autorisierung für das Data Warehouse
Nachdem Sie ein Data Warehouse erstellt haben, müssen Sie den Aurora-DB-Cluster der als autorisierte Integrationsquelle konfigurieren. Anweisungen finden Sie unter Konfigurieren der Autorisierung für Ihr Amazon-Redshift-Data-Warehouse.
Richten Sie eine Integration mit dem ein AWS SDKs
Anstatt jede Ressource manuell einzurichten, können Sie das folgende Python-Skript ausführen, um die erforderlichen Ressourcen automatisch für Sie einzurichten. Das Codebeispiel verwendet den AWS SDK für Python (Boto3), um einen Amazon Aurora Aurora-DB-Cluster als Quelle, eine und ein Ziel-Data Warehouse zu erstellen, jeweils mit den erforderlichen Parameterwerten. Es wartet dann, bis die Datenbanken verfügbar sind, bevor eine Zero-ETL-Integration zwischen ihnen erstellt wird. Sie können verschiedene Funktionen auskommentieren, je nachdem, welche Ressourcen Sie einrichten müssen.
Führen Sie die folgenden Befehle aus, um die erforderlichen Abhängigkeiten zu installieren:
pip install boto3
pip install time
Innerhalb des Skripts können Sie optional die Namen der Quell-, Ziel- und Parametergruppen ändern. Die letzte Funktion erstellt eine Integration, die my-integration nach der Einrichtung der Ressourcen benannt ist.
- 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()
Schritt 3b: Erstellen Sie einen AWS Glue Katalog für die Amazon SageMaker AI Zero-ETL-Integration
Wenn Sie eine Zero-ETL-Integration mit einem Amazon SageMaker AI Lakehouse erstellen, müssen Sie einen AWS Glue verwalteten Katalog in erstellen. AWS Lake Formation Der Zielkatalog muss ein von Amazon Redshift verwalteter Katalog sein. Um einen von Amazon Redshift verwalteten Katalog zu erstellen, erstellen Sie zunächst die AWSServiceRoleForRedshift serviceverknüpfte Rolle. Fügen Sie in der Lake Formation Formation-Konsole den AWSServiceRoleForRedshift als Administrator mit Schreibschutz hinzu.
Weitere Informationen zu den vorherigen Aufgaben finden Sie in den folgenden Themen.
Konfigurieren Sie die Berechtigungen für den Zielkatalog AWS Glue
Bevor Sie einen Zielkatalog für die Zero-ETL-Integration erstellen, müssen Sie die Lake Formation Formation-Zielerstellungsrolle und die AWS Glue Datenübertragungsrolle erstellen. Verwenden Sie die Rolle Lake Formation Target Creation, um den Zielkatalog zu erstellen. Geben Sie bei der Erstellung des Zielkatalogs die Glue-Datenübertragungsrolle in das Feld IAM-Rolle im Abschnitt Zugriff von Engines ein.
Die Rolle zur Zielerstellung muss ein Lake Formation-Administrator sein und erfordert die folgenden Berechtigungen.
- 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"
]
}
]
}
Die Rolle zur Zielerstellung muss über die folgende Vertrauensstellung verfügen.
- 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"
}
]
}
Die Glue-Datenübertragungsrolle ist für MySQL-Katalogoperationen erforderlich und muss über die folgenden Berechtigungen verfügen.
- JSON
-
-
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DataTransferRolePolicy",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"glue:GetCatalog",
"glue:GetDatabase"
],
"Resource": [
"*"
]
}
]
}
Die Glue-Datenübertragungsrolle muss über die folgende Vertrauensstellung verfügen.
- JSON
-
-
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
Nächste Schritte
Mit einem Aurora-DB-Cluster für die und entweder einem Amazon Redshift Redshift-Ziel-Data Warehouse oder einem Amazon SageMaker AI Lakehouse können Sie eine Zero-ETL-Integration erstellen und Daten replizieren. Detaillierte Anweisungen finden Sie unter Erstellen von Null-ETL-Integrationen von Aurora mit Amazon Redshift.
