Étape 1 : Créer un groupe de paramètres de base de données personnalisé Étape 2 : sélectionner ou créer un de base de données source Étape 3a : créer un entrepôt de données cible Configurez une intégration à l'aide du AWS SDKs Étape 3b : Création d'un AWS Glue catalogue pour l'intégration Amazon SageMaker AI Zero-ETL Étapes suivantes

Démarrez avec les intégrations Amazon RDS

Avant de créer une intégration zéro ETL, configurez votre et votre entrepôt de données avec les paramètres et autorisations requis. Au cours de la configuration, vous allez suivre les étapes suivantes :

Création d'un groupe personnalisé de paramètres de base de données.
Créez un de base de données source.
Créez un entrepôt de données cible pour Amazon Redshift ou créez un lakehouse Amazon SageMaker AI cible.

Une fois ces tâches terminées, passez à Création d'intégrations zéro ETL d'Amazon RDS à Amazon Redshift ouCréation d'intégrations Amazon RDS Zero-ETL avec un lakehouse Amazon SageMaker.

Astuce

Vous pouvez demander à RDS d'effectuer ces étapes de configuration pour vous pendant que vous créez l'intégration, plutôt que de les exécuter manuellement. Pour commencer immédiatement la création d'une intégration, consultez Création d'intégrations zéro ETL d'Amazon RDS à Amazon Redshift.

Pour l'étape 3, vous pouvez choisir de créer un entrepôt de données cible (étape 3a) ou un lakehouse cible (étape 3b) en fonction de vos besoins :

Choisissez un entrepôt de données si vous avez besoin de fonctionnalités d'entreposage de données traditionnelles avec des analyses basées sur SQL.
Choisissez un Amazon SageMaker AI Lakehouse si vous avez besoin de fonctionnalités d'apprentissage automatique et souhaitez utiliser les fonctionnalités de Lakehouse pour la science des données et les flux de travail de machine learning.

Étape 1 : Créer un groupe de paramètres de base de données personnalisé

Les intégrations Amazon RDS Zero-ETL nécessitent des valeurs spécifiques pour les paramètres de base de données qui contrôlent la réplication des données. Les paramètres spécifiques dépendent de votre moteur de base de données source. Pour configurer ces paramètres, vous devez d'abord créer un groupe de paramètres de base de données personnalisé, puis l'associer à la base de données source. Configurez les valeurs de paramètres suivantes en fonction de votre moteur de base de données source. Pour obtenir des instructions sur la création d'un groupe de paramètres, consultez Groupes de paramètres de base de données pour les instances de base de données RDSAmazon. Nous vous recommandons de configurer toutes les valeurs de paramètres dans la même demande afin d'éviter les problèmes de dépendance.

RDS pour MySQL :

binlog_format=ROW
binlog_row_image=full

Assurez-vous également que le paramètre binlog_row_value_options n'est pas défini sur PARTIAL_JSON. Si la base de données source est un cluster de base de données multi-AZ, assurez-vous que le binlog_transaction_compression paramètre n'est pas défini sur. ON

Certains de ces paramètres (tels quebinlog_format) sont dynamiques, ce qui signifie que vous pouvez appliquer des modifications au paramètre sans déclencher de redémarrage. Cela signifie que certaines sessions existantes peuvent continuer à utiliser l'ancienne valeur du paramètre. Pour éviter que cela ne pose de problèmes lors de la création d'une intégration zéro ETL, activez le schéma de performance. Le schéma de performance garantit l'exécution de pré-contrôles zéro ETL, ce qui permet de détecter les paramètres manquants au début du processus.

RDS pour PostgreSQL :

rds.logical_replication = 1
rds.replica_identity_full = 1
session_replication_role = origin
wal_sender_timeout ≥ 20000 or = 0
max_wal_senders ≥ 20
max_replication_slots ≥ 20

Pour plusieurs intégrations PostgreSQL, un emplacement de réplication logique sera utilisé par intégration. Vérifiez les max_wal_senders paramètres max_replication_slots et en fonction de votre utilisation.

Pour une synchronisation efficace des données dans les intégrations sans ETL, configurez-la rds.replica_identity_full dans votre instance de base de données source. Cela indique à la base de données de consigner les données de ligne complètes dans le journal d'écriture anticipée (WAL) pendant UPDATE les DELETE opérations, plutôt que simplement les informations clés primaires. Zero-ETL nécessite des données de ligne complètes, même lorsque toutes les tables répliquées doivent disposer de clés primaires. Pour déterminer quelles données sont visibles lors des requêtes, Amazon Redshift utilise une stratégie anti-jointure spécialisée pour comparer vos données à celles d'une table de suivi des suppressions interne. L'enregistrement d'images en ligne complète permet à Amazon Redshift de réaliser efficacement ces anti-jointures. Sans données de ligne complètes, Amazon Redshift devrait effectuer des recherches supplémentaires, ce qui pourrait ralentir les performances lors d'opérations à haut débit dans le moteur en colonnes utilisé par Amazon Redshift.

Important

La configuration de l'identité de réplique pour enregistrer les lignes complètes augmente le volume de votre WAL, ce qui peut entraîner une augmentation de l'amplification et de I/O l'utilisation de l'écriture, en particulier pour les tables larges ou les mises à jour fréquentes. Pour vous préparer à ces impacts, planifiez votre capacité de stockage et vos I/O besoins, surveillez la croissance de votre WAL et suivez le retard de réplication dans les charges de travail intensives en écriture.

RDS pour Oracle :

Aucune modification de paramètre n'est requise pour RDS pour Oracle.

Étape 2 : sélectionner ou créer un de base de données source

Après avoir créé un groupe de paramètres de de base de données personnalisé, choisissez ou créez un RDS. Ce de base de données sera la source de réplication des données vers l'entrepôt de données cible. Pour obtenir des instructions sur la création d'un cluster de base de données multi-AZ, consultezCréation d'un cluster de base de données multi-AZ pour Amazon RDS.

La base de données doit exécuter une version du moteur de base de données prise en charge. Pour une liste de versions prises en charge, consultez Régions et moteurs de base de données pris en charge pour les intégrations Amazon RDS Zero-ETL.

Lorsque vous créez la base de données, sous Configuration supplémentaire, remplacez le groupe de paramètres du de base de données par défaut par le groupe de paramètres personnalisé que vous avez créé à l'étape précédente.

Note

Pour obtenir des instructions, consultez Redémarrage d'une instance de base de données ou Redémarrage d'un cluster de base de données multi-AZ et d'instances de base de données de lecture pour Amazon RDS.

Assurez-vous également que les sauvegardes automatisées sont activées sur la base de données. Pour de plus amples informations, veuillez consulter Activation des sauvegardes automatiques.

Étape 3a : créer un entrepôt de données cible

Après avoir créé votre de base de données source, vous devez créer et configurer un entrepôt de données cible. L'entrepôt de données doit respecter les exigences suivantes :

En utilisant un type de RA3 nœud avec au moins deux nœuds, ou Redshift Serverless.
Chiffré (si vous utilisez un cluster provisionné). Pour plus d’informations, consultez Chiffrement de base de données Amazon Redshift.

Pour obtenir des instructions sur la création d'un entrepôt des données, consultez Création d'un cluster pour les clusters provisionnés ou Création d'un groupe de travail avec un espace de noms pour Redshift sans serveur.

Activer la sensibilité à la casse sur l'entrepôt des données

Pour que l'intégration réussisse, le paramètre de sensibilité à la casse (enable_case_sensitive_identifier) doit être activé pour l'entrepôt des données. Par défaut, la sensibilité à la casse est désactivée sur tous les clusters provisionnés et les groupes de travail Redshift sans serveur.

Pour activer la sensibilité à la casse, effectuez les étapes suivantes en fonction du type de votre entrepôt des données :

Cluster provisionné : pour activer la sensibilité à la casse sur un cluster provisionné, créez un groupe de paramètres personnalisé en activant le paramètre enable_case_sensitive_identifier. Associez ensuite le groupe de paramètres au cluster. Pour obtenir des instructions, consultez Gestion des groupes de paramètres à l'aide de la console ou Configuration des valeurs des paramètres à l'aide de l' AWS CLI.

Note
N'oubliez pas de redémarrer le cluster après lui avoir associé le groupe de paramètres personnalisé.
Groupe de travail sans serveur : pour activer la sensibilité à la casse sur un groupe de travail Redshift sans serveur, vous devez utiliser l' AWS CLI. La console Amazon Redshift ne prend actuellement pas en charge la modification des valeurs des paramètres Redshift sans serveur. Envoyez la demande de mise à jour du groupe de travail suivante :
```
aws redshift-serverless update-workgroup \
  --workgroup-name target-workgroup \
  --config-parameters parameterKey=enable_case_sensitive_identifier,parameterValue=true
```
Vous n'avez pas besoin de redémarrer un groupe de travail après avoir modifié ses valeurs de paramètres.

Configuration de l'autorisation pour l'entrepôt des données

Après avoir créé un entrepôt de données, vous devez configurer le de la base de données RDS source en tant que source d'intégration autorisée. Pour obtenir des instructions, consultez Configuration de l'autorisation pour votre entrepôt des données Amazon Redshift.

Configurez une intégration à l'aide du AWS SDKs

Plutôt que de configurer chaque ressource manuellement, vous pouvez exécuter le script Python suivant pour configurer automatiquement les ressources requises pour vous. L'exemple de code utilise le AWS SDK pour Python (Boto3)pour créer une instance de base de données source RDS pour MySQL et un entrepôt de données cible, chacun avec les valeurs de paramètres requises. Il attend ensuite que les bases de données soient disponibles avant de créer une intégration zéro ETL entre elles. Vous pouvez commenter différentes fonctions en fonction des ressources que vous devez configurer.

Pour installer les dépendances requises, exécutez les commandes suivantes :


pip install boto3
pip install time

Dans le script, modifiez éventuellement les noms de la source, de la cible et des groupes de paramètres. La fonction finale crée une intégration nommée d'my-integrationaprès la configuration des ressources.


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_db_name = 'my-source-db' # A name for the source database
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_db(*args):
    """Creates a source RDS for MySQL DB instance"""

    response = rds.create_db_parameter_group(
        DBParameterGroupName=source_param_group_name,
        DBParameterGroupFamily='mysql8.0',
        Description='RDS for MySQL zero-ETL integrations'
    )
    print('Created source parameter group: ' + response['DBParameterGroup']['DBParameterGroupName'])

    response = rds.modify_db_parameter_group(
        DBParameterGroupName=source_param_group_name,
        Parameters=[
            {
                'ParameterName': 'binlog_format',
                'ParameterValue': 'ROW',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_row_image',
                'ParameterValue': 'full',
                'ApplyMethod': 'pending-reboot'
            }
        ]
    )
    print('Modified source parameter group: ' + response['DBParameterGroupName'])

    response = rds.create_db_instance(
        DBInstanceIdentifier=source_db_name,
        DBParameterGroupName=source_param_group_name,
        Engine='mysql',
        EngineVersion='8.0.32',
        DBName='mydb',
        DBInstanceClass='db.m5.large',
        AllocatedStorage=15,
        MasterUsername='username',
        MasterUserPassword='Password01**'
    )
    print('Creating source database: ' + response['DBInstance']['DBInstanceIdentifier'])
    source_arn = (response['DBInstance']['DBInstanceArn'])
    create_target_cluster(target_cluster_name, source_arn, target_param_group_name)
    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='RDS for 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 granting access to source database 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_db_availability(*args):
    """Waits for both databases to be available"""

    print('Waiting for source and target to be available...')

    response = rds.describe_db_instances(
        DBInstanceIdentifier=source_db_name
    )
    source_status = response['DBInstances'][0]['DBInstanceStatus']
    source_arn = response['DBInstances'][0]['DBInstanceArn']

    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 databases are available
    if source_status != 'available' or target_status != 'available':
        time.sleep(60)
        response = wait_for_db_availability(
            source_db_name, target_cluster_name)
    else:
        print('Databases 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 databases"""

    response = rds.create_integration(
        SourceArn=source_arn,
        TargetArn=target_arn,
        IntegrationName='my-integration'
    )
    print('Creating integration: ' + response['IntegrationName'])
    
def main():
    """main function"""
    create_source_db(source_db_name, source_param_group_name)
    wait_for_db_availability(source_db_name, target_cluster_name)

if __name__ == "__main__":
    main()

Étape 3b : Création d'un AWS Glue catalogue pour l'intégration Amazon SageMaker AI Zero-ETL

Lorsque vous créez une intégration zéro ETL avec un Amazon SageMaker AI Lakehouse, vous devez créer un catalogue AWS Glue géré dans. AWS Lake Formation Le catalogue cible doit être un catalogue géré par Amazon Redshift. Pour créer un catalogue géré Amazon Redshift, créez d'abord le rôle lié à un AWSServiceRoleForRedshift service. Dans la console Lake Formation, ajoutez le AWSServiceRoleForRedshift en tant qu'administrateur en lecture seule.

Pour plus d'informations sur les tâches précédentes, consultez les rubriques suivantes.

Pour plus d'informations sur la création d'un catalogue géré Amazon Redshift, consultez la section Création d'un catalogue géré Amazon Redshift dans AWS Glue Data CatalogAWS Lake Formation le manuel du développeur.
Pour plus d'informations sur le rôle lié à un service pour Amazon Redshift, consultez la section Utilisation des rôles liés à un service pour Amazon Redshift dans le guide de gestion Amazon Redshift.
Pour plus d'informations sur les autorisations d'administrateur en lecture seule pour Lake Formation, consultez les références relatives aux personas de Lake Formation et aux autorisations IAM dans le Guide du développeur.AWS Lake Formation

Configurer les autorisations pour le AWS Glue catalogue cible

Avant de créer un catalogue cible pour une intégration Zero-ETL, vous devez créer le rôle de création de cible Lake Formation et le rôle de transfert de AWS Glue données. Utilisez le rôle de création de cibles Lake Formation pour créer le catalogue cible. Lors de la création du catalogue cible, entrez le rôle de transfert de données Glue dans le champ Rôle IAM de la section Accès depuis les moteurs.

Le rôle de création de la cible doit être un administrateur de Lake Formation et nécessite les autorisations suivantes.

Le rôle de création de la cible doit avoir la relation de confiance suivante.

Le rôle de transfert de données Glue est requis pour les opérations du catalogue MySQL et doit disposer des autorisations suivantes.

Le rôle de transfert de données Glue doit avoir la relation de confiance suivante.

Étapes suivantes

Avec un source et un entrepôt de données cible Amazon Redshift ou SageMaker Amazon AI Lakehouse, vous pouvez créer une intégration zéro ETL et répliquer les données. Pour obtenir des instructions, veuillez consulter Création d'intégrations zéro ETL d'Amazon RDS à Amazon Redshift.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Intégrations zéro ETL

Création d'intégrations sans ETL avec Amazon Redshift