Démarrez avec Amazon RDS : zéro ETL intégration avec Amazon Redshift

Avant de créer une ETL intégration zéro avec Amazon Redshift, configurez votre 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 base de données.

2. Créez un de base de données 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'ETLintégrations zéro avec Amazon RDS avec Amazon Redshift.

Astuce

Vous pouvez avoir RDS effectué ces étapes de configuration pour vous lors de la création de 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'ETLintégrations zéro avec Amazon RDS avec Amazon Redshift.

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

ETLLes intégrations Amazon RDS Zero avec Amazon Redshift nécessitent des valeurs spécifiques pour les paramètres de base de données qui contrôlent la journalisation binaire (binlog). Pour configurer la journalisation binaire, 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.

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

• 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.

É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-en un RDSpour le cluster SQL de base de données My database . Ce de base de données sera la source de réplication des données vers Amazon Redshift. Pour obtenir des instructions sur la création d'un . Création d'une RDS instance de base de données Amazon

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 ETL intégrations RDS nulles d'Amazon avec Amazon Redshift.

Pour obtenir des instructions sur la création d'un . Création d'une RDS instance de base de données Amazon Pour obtenir des instructions sur la création d'un cluster de base de données multi-AZ, reportez-vous Création d'un cluster de base de données multi-AZ pour Amazon RDS à.

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 3 : Créer un entrepôt des données Amazon Redshift 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 dans Amazon Redshift. 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, voir Gestion des groupes de paramètres à l'aide de la console ou Configuration des valeurs de paramètres à l'aide du 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 distinction majuscules/minuscules dans un groupe de travail Redshift Serverless, vous devez utiliser le AWS CLI. La console Amazon Redshift ne prend actuellement pas en charge la modification des valeurs des paramètres Redshift Serverless. 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 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 AWS SDK for Python (Boto3)pour créer un source RDSpour l'instance My SQL DB et cibler l'entrepôt de données Amazon Redshift, chacun avec les valeurs de paramètres requises. Il attend ensuite que les bases de données soient disponibles avant de créer une ETL intégration nulle 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.

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_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()         

Étapes suivantes

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