Bien démarrer avec les intégrations zéro ETL d'Aurora à Amazon Redshift

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

1. Création d'un groupe personnalisé de paramètres de cluster de base de données.

2. Créez un cluster source.

3. Création d'un entrepôt des données Amazon Redshift cible.

Une fois ces étapes terminées, reportez-vous à Création d'intégrations zéro ETL d'Aurora à Amazon Redshift.

Vous pouvez utiliser les AWS SDK pour automatiser le processus de configuration à votre place. Pour plus d’informations, consultez Configurer une intégration à l'aide des AWS SDK (Aurora MySQL uniquement).

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

Les intégrations Aurora Zero-ETL avec Amazon Redshift nécessitent des valeurs spécifiques pour les paramètres du cluster de base de données qui contrôlent la réplication. Plus précisément, Aurora MySQL nécessite un binlog (aurora_enhanced_binlog) amélioré, et Aurora PostgreSQL nécessite une réplication logique améliorée (). aurora.enhanced_logical_replication

Pour configurer la journalisation binaire ou la réplication logique, vous devez d'abord créer un groupe de paramètres de cluster de base de données personnalisé, puis l'associer au cluster de base de données source.

Créez un groupe de paramètres de cluster de base de données personnalisé avec les paramètres suivants 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 Utilisation des groupes de paramètres de clusters de base de données.

Aurora MySQL (famille aurora-mysql8.0) :

• aurora_enhanced_binlog=1

• binlog_backup=0

• binlog_format=ROW

• binlog_replication_globaldb=0

• binlog_row_image=full

• binlog_row_metadata=full

Assurez-vous également que le paramètre binlog_transaction_compression n'est pas défini sur ON et que le paramètre binlog_row_value_options n'est pas défini sur PARTIAL_JSON.

Pour plus d'informations sur le journal binaire amélioré d'Aurora MySQL, consultezConfiguration du binlog amélioré.

Aurora PostgreSQL (famille aurora-postgresql15) :

Note

Pour les clusters de bases de données Aurora PostgreSQL, vous devez créer le groupe de paramètres personnalisé dans l'environnement de prévisualisation de base de données Amazon RDS, dans l'est des États-Unis (Ohio) (us-east-2). Région AWS

• rds.logical_replication=1

• aurora.enhanced_logical_replication=1

• aurora.logical_replication_backup=0

• aurora.logical_replication_globaldb=0

L'activation de la réplication logique améliorée (aurora.enhanced_logical_replication) définit automatiquement le REPLICA IDENTITY paramètre surFULL, ce qui signifie que toutes les valeurs des colonnes sont écrites dans le journal d'écriture anticipée (WAL). Cela augmentera les IOPS pour votre cluster de base de données source.

Étape 2 : sélectionner ou créer un cluster source

Après avoir créé un groupe de paramètres de cluster de base de données personnalisé, choisissez ou créez une instance de base de données MySQL ou Aurora PostgreSQL). Ce cluster de données sera la source de réplication des données vers Amazon Redshift.

Le cluster de données doit exécuter MySQL version 3.05 (compatible avec MySQL 8.0.32) ou supérieure, ou Aurora PostgreSQL (compatible avec PostgreSQL 15.4 et Zero-ETL Support). Pour obtenir des instructions sur la création d'un cluster de base de données d', consultez.

Note

Vous devez créer des clusters de bases de données Aurora PostgreSQL dans l'environnement de prévisualisation de base de données Amazon RDS, dans l'est des États-Unis (Ohio) (us-east-2). Région AWS

Sous Configuration supplémentaire, remplacez le groupe de paramètres du cluster 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 Aurora MySQL, vous associez le groupe de paramètres au cluster de de une fois que celui-ci a déjà été créé, vous devez redémarrer l'instance de principale du cluster pour appliquer les modifications avant de pouvoir créer une intégration zéro ETL. Pour obtenir des instructions, veuillez consulter Redémarrage d'un cluster de bases de données Amazon Aurora ou d'une instance de base de données Amazon Aurora.

Lors de la version préliminaire des intégrations Zero-ETL d'Aurora PostgreSQL avec Amazon Redshift, vous devez associer le cluster au groupe de paramètres de cluster de base de données personnalisé lors de la création du cluster. Vous ne pouvez pas effectuer cette action une fois que le cluster de base de données source est déjà créé, sinon vous devez le supprimer et le recréer.

Étape 3 : Créer un entrepôt des données Amazon Redshift cible

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

• Créé en version préliminaire (pour les sources Aurora PostgreSQL uniquement). Pour les sources Aurora MySQL, vous devez créer des clusters de production et des groupes de travail.

  • Pour créer un cluster provisionné dans la version préliminaire, choisissez Créer un cluster en version préliminaire dans la bannière du tableau de bord des clusters provisionnés. Pour plus d'informations, consultez Création d'un cluster en version prélimnaire.

    

    Lors de la création du cluster, définissez l'option Chemin d'accès à la prévisualisation sur preview_2023.

  • Pour créer un groupe de travail Redshift sans serveur en version préliminaire, choisissez Créer un groupe de travail en mode de prévisualisation dans la bannière du tableau de bord sans serveur. Pour plus d'informations, consultez Création d'un groupe de travail de prévisualisation.

    

• En utilisant un type de nœud RA3 (ra3.xlplus,ra3.4xlarge, oura3.16xlarge) , 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 cluster Aurora DB de la 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.

Configurer une intégration à l'aide des AWS SDK (Aurora MySQL uniquement)

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 for Python (Boto3)pour créer un cluster de base de données Aurora MySQL source et cibler l'entrepôt de données Amazon Redshift, chacun avec les valeurs de paramètres requises. Il attend ensuite que les clusters soient disponibles avant de créer une intégration zéro ETL entre eux. 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.

Exemple de code Python

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 zero-ETL integrations'
    )
    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()

Étapes suivantes

Avec un cluster de Aurora DB source et un entrepôt de données cible Amazon Redshift, vous pouvez désormais créer une intégration zéro ETL et répliquer les données. Pour obtenir des instructions, consultez Création d'intégrations zéro ETL d'Aurora à Amazon Redshift.