Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Intégrations zéro ETL Amazon RDS
Il s’agit d’une solution entièrement gérée qui permet de rendre les données transactionnelles disponibles dans votre destination d’analytique après leur écriture dans une base de données RDS. Le processus d’*extraction, transformation* et *chargement* (ETL) consiste à combiner des données provenant de plusieurs sources dans un grand entrepôt de données central.
Une intégration zéro ETL rend les données de votre base de données RDS disponibles dans Amazon Redshift ou un Amazon SageMaker AI Lakehouse en temps quasi réel. Une fois que ces données se trouvent dans l'entrepôt de données ou le lac de données cible, vous pouvez optimiser vos charges de travail d'analyse, de machine learning et d'IA à l'aide des fonctionnalités intégrées, telles que l'apprentissage automatique, les vues matérialisées, le partage de données, l'accès fédéré à plusieurs magasins de données et lacs de données, et les intégrations avec SageMaker Amazon AI, Quick, etc. Services AWS
Pour créer une intégration zéro ETL, vous devez spécifier une base de données RDS comme *source* et un entrepôt de données ou un lakehouse pris en charge comme *cible*. L’intégration réplique les données de la base de données source vers l’entrepôt de données ou le lakehouse cible.
Le schéma suivant illustre cette fonctionnalité d’intégration zéro ETL à Amazon Redshift :
![\[Intégration zéro ETL\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/zero-etl-integrations.png)
Le schéma suivant illustre cette fonctionnalité pour l’intégration zéro ETL avec un Amazon SageMaker AI Lakehouse :
![\[Une intégration zéro ETL avec un lakehouse Amazon SageMaker AI\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/zero-etl-rds-lakehouse.png)
L’intégration surveille l’état du pipeline de données et effectue la récupération en cas de problèmes, lorsque cela est possible. Vous pouvez créer des intégrations à partir de plusieurs bases de données RDS dans un seul entrepôt de données ou lakehouse cible, ce qui vous permet de dériver des informations entre plusieurs applications.
**Topics**
+ [Avantages](#zero-etl.benefits)
+ [Concepts clés](#zero-etl.concepts)
+ [Limitations](#zero-etl.reqs-lims)
+ [Quotas](#zero-etl.quotas)
+ [Régions prises en charge](#zero-etl.regions)
+ [Bien démarrer avec les intégrations zéro ETL Amazon RDS](zero-etl.setting-up.md)
+ [Création d'intégrations zéro ETL d'Amazon RDS à Amazon Redshift](zero-etl.creating.md)
+ [Création d’intégrations zéro ETL Amazon RDS avec un Amazon SageMaker Lakehouse](zero-etl.creating-smlh.md)
+ [Filtrage des données pour les intégrations zéro ETL Amazon RDS](zero-etl.filtering.md)
+ [Ajouter des données à une base de données RDS source et les interroger](zero-etl.querying.md)
+ [Affichage et surveillance des intégrations zéro ETL Amazon RDS](zero-etl.describingmonitoring.md)
+ [Modification des intégrations zéro ETL Amazon RDS](zero-etl.modifying.md)
+ [Suppression d’intégrations zéro ETL Amazon RDS](zero-etl.deleting.md)
+ [Résolution des problèmes liés aux intégrations zéro ETL Amazon RDS](zero-etl.troubleshooting.md)
## Avantages
Les intégrations zéro ETL RDS présentent les avantages suivants :
+ Elles vous aident à dériver des informations holistiques de plusieurs sources de données.
+ Elles éliminent la nécessité de créer et de gérer des pipelines de données complexes qui effectuent des opérations d'extraction, de transformation et de chargement (ETL). Les intégrations zéro ETL suppriment les défis liés à la création et à la gestion de pipelines en les provisionnant et en les gérant pour vous.
+ Elles réduisent la charge opérationnelle et les coûts, et vous permettent de vous concentrer sur l'amélioration de vos applications.
+ Elles vous permettent de tirer parti des fonctionnalités d’analytique et de machine learning de la destination cible pour dériver des informations à partir de données transactionnelles et autres, afin de répondre efficacement aux événements critiques et urgents.
## Concepts clés
Lorsque vous commencez à utiliser des intégrations zéro ETL, tenez compte des concepts suivants :
**Integration**
Pipeline de données entièrement géré qui réplique automatiquement les données transactionnelles et les schémas d’une base de données RDS vers un entrepôt de données ou un catalogue.
**Cluster de bases de données source**
Base de données RDS à partir d’où les données sont répliquées. Vous pouvez spécifier une instance de base de données mono-AZ ou multi-AZ, ou un cluster de base de données multi-AZ (pour RDS pour MySQL uniquement).
**Cible**
L’entrepôt de données ou le lakehouse vers lequel les données sont répliquées. Il existe deux types d'entrepôts de données : l'entrepôt de données en [cluster provisionné](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html) et l'entrepôt de données [sans serveur](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-workgroup-namespace.html). Un entrepôt de données en cluster provisionné est une collection de ressources informatiques appelées nœuds, qui sont organisées en un groupe appelé *cluster*. Un entrepôt de données sans serveur est composé d'un groupe de travail qui stocke les ressources de calcul et d'un espace de noms qui héberge les utilisateurs et les objets de base de données. Les deux entrepôts de données exécutent un moteur d’analytique et contiennent une ou plusieurs bases de données.
Un lakehouse cible se compose de catalogues, de bases de données, de tables et de vues. Pour plus d’informations sur l’architecture de lakehouse, consultez la section [https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html) dans le *Guide de l’utilisateur Amazon SageMaker AI Unified Studio*.
Plusieurs bases de données sources peuvent écrire sur la même cible.
Pour plus d'informations, consultez [Architecture système de l'entrepôt de données](https://docs.aws.amazon.com/redshift/latest/dg/c_high_level_system_architecture.html) dans le *Guide du développeur de base de données Amazon Redshift*.
## Limitations
Les limitations suivantes s’appliquent aux intégrations zéro ETL RDS.
**Topics**
+ [Limitations générales](#zero-etl.reqs-lims-general)
+ [Limitations propres à RDS for MySQL](#zero-etl.reqs-lims-mysql)
+ [Limitations relatives à RDS pour PostgreSQL](#zero-etl.reqs-lims-rds-postgres)
+ [Limitations RDS for Oracle](#zero-etl.reqs-lims-oracle)
+ [Limitations propres à Amazon Redshift](#zero-etl.reqs-lims-redshift)
+ [Amazon SageMaker AI limites du lakehouse](#zero-etl.reqs-lims-sagemaker-)
### Limitations générales
+ La base de données source doit se trouver dans la même région que la cible.
+ Vous ne pouvez pas renommer une base de données possédant des intégrations existantes.
+ Vous ne pouvez pas créer plusieurs intégrations entre les mêmes bases de données source et cible.
+ Vous ne pouvez pas supprimer une base de données qui possède des intégrations existantes. Vous devez d’abord supprimer toutes les intégrations associées.
+ Si vous arrêtez la base de données source, les dernières transactions risquent de ne pas être répliquées vers l’entrepôt de données cible tant que vous ne reprenez pas l’exécution de la base de données.
+ Vous ne pouvez pas supprimer une intégration si la base de données source est arrêtée.
+ Si votre base de données est la source d’un déploiement bleu/vert, les environnements bleu et vert ne peuvent pas comporter d’intégrations zéro ETL existantes lors de la bascule. Vous devez d'abord supprimer l'intégration et basculer, puis la recréer.
+ Vous ne pouvez pas créer d’intégration pour une base de données source dont une autre intégration est activement créée.
+ Lors de la création initiale d'une intégration ou lors de la resynchronisation d'une table, l'ensemencement des données de la source vers la cible peut prendre 20 à 25 minutes, voire plus, selon la taille de la base de données source. Ce délai peut entraîner une augmentation du retard de réplica.
+ Certains types de données ne sont pas pris en charge. Pour de plus amples informations, veuillez consulter [Différences de type de données entre les bases de données RDS et Amazon Redshift](zero-etl.querying.md#zero-etl.data-type-mapping).
+ Les tables système, les tables temporaires et les vues ne sont pas répliquées vers les entrepôts cibles.
+ L’exécution de commandes DDL (par exemple`ALTER TABLE`) sur une table source peut déclencher une resynchronisation de la table, rendant la table indisponible pour les requêtes pendant la resynchronisation. Pour de plus amples informations, veuillez consulter [Une ou plusieurs de mes tables Amazon Redshift nécessitent une resynchronisation](zero-etl.troubleshooting.md#zero-etl.troubleshooting.resync).
### Limitations propres à RDS for MySQL
+ Votre base de données source doit exécuter une version prise en charge de RDS for MySQL. 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 zéro ETL Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ Les intégrations Zero-ETL ne sont pas prises en charge à la fois sur l'instance principale et sur une instance de réplication en lecture dans la même AWS région.
+ Les intégrations zéro ETL s'appuient sur la journalisation binaire MySQL (binlog) pour capturer les modifications continues des données. N’utilisez par le filtrage de données basé sur binlog, car cela peut entraîner des incohérences de données entre les bases de données source et cible.
+ Les intégrations zéro ETL sont prises en charge uniquement pour les bases de données configurées pour utiliser le moteur de stockage InnoDB.
+ Les références de clé étrangère avec des mises à jour de table prédéfinies ne sont pas prises en charge. Plus précisément, les règles `ON DELETE` et `ON UPDATE` ne sont pas prises en charge avec les actions `CASCADE`, `SET NULL` et `SET DEFAULT`. Toute tentative de création ou de mise à jour d'une table contenant de telles références à une autre table entraînera l'échec de la table.
+ Vous ne pouvez pas créer d'intégration pour une base de données source qui utilise le stockage magnétique.
### Limitations relatives à RDS pour PostgreSQL
+ La base de données source doit être une instance RDS pour PostgreSQL exécutant les versions 15.7\$1, 16.3\$1 ou 17.1\$1. Les versions antérieures ne sont pas prises en charge.
+ Les intégrations RDS pour PostgreSQL Zero-ETL ne prennent pas en charge les clusters de bases de données multi-AZ en tant que bases de données sources.
+ Vous ne pouvez pas créer une intégration zéro ETL à partir d’une instance de réplica en lecture de RDS pour PostgreSQL.
+ Les tables non enregistrées et les vues matérialisées de PostgreSQL ne sont pas répliquées sur Amazon Redshift.
+ La réplication de certains types de données PostgreSQL, tels que les [types de données géométriques](https://www.postgresql.org/docs/current/datatype-geometric.html) et les données supérieures à 64 Ko, n’est pas prise en charge en raison des limites d’Amazon Redshift. Pour plus d’informations sur les différences de type de données entre RDS pour PostgreSQL et Amazon Redshift, consultez [RDS pour PostgreSQL](zero-etl.querying.md#zero-etl.data-type-mapping-postgres) dans la section **Différences entre les types de données**.
+ Vous ne pouvez pas effectuer de [mise à niveau de version majeure](USER_UpgradeDBInstance.PostgreSQL.md) sur l’instance RDS pour PostgreSQL source si celle-ci possède une intégration zéro ETL active. Pour mettre à niveau l’instance source, vous devez d’abord supprimer toutes les intégrations zéro ETL qui existent. Une fois la mise à niveau de version majeure effectuée, vous pouvez recréer les intégrations zéro ETL.
+ Si vous effectuez des transactions de [partitionnement déclaratif](https://www.postgresql.org/docs/current/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE) sur l’instance de base de données source, toutes les tables concernées entrent dans un état d’échec et ne sont plus accessibles.
### Limitations RDS for Oracle
+ La base de données source doit être une instance RDS for Oracle exécutant la version 19c Enterprise Edition ou Standard Edition 2, mise à jour de version de juillet 2019 ou ultérieure. Les versions antérieures ne sont pas prises en charge.
+ Vous ne pouvez pas créer une intégration zéro ETL à partir d’une instance de réplica en lecture de RDS for Oracle.
+ Vous ne pouvez pas renommer une [base de données locataire](Oracle.Concepts.CDBs.md) lorsqu’elle comporte une intégration zéro ETL.
+ Une base de données locataire ne peut avoir qu’une seule intégration zéro ETL.
+ RDS for Oracle et Amazon Redshift présentent certaines différences de type de données. Pour plus d’informations, consultez [RDS for Oracle](zero-etl.querying.md#zero-etl.data-type-mapping-oracle) dans la section **Type d’enregistrement**.
### Limitations propres à Amazon Redshift
Pour une liste des limitations Amazon Redshift liées aux intégrations zéro ETL, consultez la section [Considérations relatives au moment d’utiliser les intégrations zéro ETL avec Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl.reqs-lims.html) dans le *Guide de gestion Amazon Redshift*.
### Amazon SageMaker AI limites du lakehouse
Voici une limite pour les intégrations Amazon SageMaker AI Lakehouse Zero-ETL.
+ Les noms de catalogue sont limités à 19 caractères.
## Quotas
Votre compte possède les quotas suivants relatifs aux intégrations zéro ETL RDS. Chaque quota s'applique par région, sauf indication contraire.
| Nom | Par défaut | Description |
| --- | --- | --- |
| Intégrations | 100 | Nombre total d'intégrations au sein d'un Compte AWS. |
| Intégrations par cible | 50 | Nombre d’intégrations envoyant des données à un entrepôt de données ou un lakehouse cible unique. |
| Intégrations par instance source | 5 | Nombre d’intégrations envoyant des données à partir d’une instance de base de données source unique. |
En outre, l’entrepôt cible impose certaines limites au nombre de tables autorisées dans chaque instance de base de données ou nœud de cluster. Pour plus d’informations sur les quotas et limites relatifs à Amazon Redshift, consultez la section [Quotas et limites dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) dans le *Guide de gestion Amazon Redshift*.
## Régions prises en charge
Les intégrations RDS Zero-ETL sont disponibles dans un sous-ensemble de. Régions AWS Pour obtenir une liste des régions prises en charge, consultez [Régions et moteurs de base de données pris en charge pour les intégrations zéro ETL Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
# Bien démarrer avec les intégrations zéro ETL Amazon RDS
Avant de créer une intégration zéro ETL, configurez votre base de données RDS et votre entrepôt de données avec les paramètres et les autorisations nécessaires. Au cours de la configuration, vous allez suivre les étapes suivantes :
1. [Création d’un groupe personnalisé de paramètres données.](#zero-etl.parameters)
1. [Créez une base de données source](#zero-etl.create-cluster).
1. [Créez un entrepôt de données cible pour Amazon Redshift](#zero-etl-setting-up.data-warehouse) ou [créez un Amazon SageMaker ](#zero-etl-setting-up.sagemaker) Lakehouse cible.
Une fois ces tâches terminées, reportez-vous à [Création d'intégrations zéro ETL d'Amazon RDS à Amazon Redshift](zero-etl.creating.md) ou [Création d’intégrations zéro ETL Amazon RDS avec un Amazon SageMaker Lakehouse](zero-etl.creating-smlh.md).
**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](zero-etl.creating.md).
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 opérations d’analytique basées sur SQL.
+ Choisissez un Amazon SageMaker Lakehouse si vous avez besoin de fonctionnalités d'apprentissage automatique et si vous souhaitez utiliser les fonctionnalités de Lakehouse pour la science des données et les flux de travail ML.
## Étape 1 : Création d’un groupe de paramètres données personnalisé
Les intégrations zéro ETL Amazon RDS 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 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 Amazon RDS](USER_WorkingWithDBInstanceParamGroups.md). 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 for 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 bases de données multi-AZ, assurez-vous que le paramètre `binlog_transaction_compression` n’est *pas* défini sur `ON`.
Certains de ces paramètres (tels que `binlog_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 des problèmes lors de la création d’une intégration zéro ETL, activez le [schéma de performance](USER_PerfInsights.EnableMySQL.md). 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 est utilisé par intégration. Passez en revue les paramètres `max_wal_senders` et `max_replication_slots` en fonction de votre utilisation.
Pour une synchronisation efficace des données dans les intégrations zéro ETL, configurez `rds.replica_identity_full` dans votre instance de base de données source. Cela indique à la base de données de [journaliser les données de ligne complètes](https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY) dans le journal d’écriture anticipée (WAL) pendant les opérations `UPDATE` et `DELETE`, plutôt que simplement les informations clés primaires. Sans extraction, transformation ni chargement (sans 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. La journalisation 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](https://www.postgresql.org/docs/current/runtime-config-wal.html#GUC-WAL-LEVEL), 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 for Oracle** :
Aucune modification de paramètre n’est requise pour RDS for Oracle.
## Étape 2 : Sélection ou création d’une base de données source
Après avoir créé un groupe de paramètres de de bases de données personnalisés, choisissez ou créez une instance de base de données RDS . Cette base de données est la source de réplication des données vers l’entrepôt de données cible. Pour des instructions sur la création d’une instance de base de données mono-AZ ou multi-AZ, consultez [Création d'une instance de base de données Amazon RDS](USER_CreateDBInstance.md). Pour obtenir des instructions sur la création d'un cluster de base de données multi-AZ (RDS pour MySQL uniquement), consultez. [Création d’un cluster de bases de données Multi-AZ pour Amazon RDS](create-multi-az-db-cluster.md)
La base de données doit exécuter une version de 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 zéro ETL Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
Lorsque vous cliquez sur la base de données, sous **Configuration supplémentaire**, remplacez le **groupe de paramètres de de bases de données** par défaut par le groupe de paramètres personnalisés que vous avez créé à l’étape précédente.
**Note**
Si vous associez le groupe de paramètres à la base de données *après la création* de celle-ci, vous devez redémarrer la base de données pour appliquer les modifications avant de créer une intégration zéro ETL. Pour obtenir des instructions, consultez [Redémarrage d'une instance de base de données cluster de base de données](USER_RebootInstance.md) ou [Redémarrage d’un cluster de bases de données multi-AZ et des instances de base de données de lecteur pour Amazon RDS](multi-az-db-clusters-concepts-rebooting.md).
En outre, assurez-vous que les sauvegardes automatiques sont activées sur la base de données. Pour de plus amples informations, veuillez consulter [Activation des sauvegardes automatiques](USER_WorkingWithAutomatedBackups.Enabling.md).
## Étape 3a : Création d’un entrepôt de données cible
Après avoir créé votre 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](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
Pour obtenir des instructions sur la création d’un entrepôt de données, consultez [Création d’un cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/create-cluster) pour les clusters provisionnés ou [Création d’un groupe de travail avec un espace de noms pour](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-console-workgroups-create-workgroup-wizard.html) Redshift sans serveur.
### Activer la sensibilité à la casse sur l’entrepôt de données
Pour que l’intégration réussisse, le paramètre de sensibilité à la casse ([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)) doit être activé pour l’entrepôt de 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 de 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](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-parameter-groups-console.html) ou [Configuration des valeurs des paramètres à l'aide de l' AWS CLI](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#configure-parameters-using-the-clil).
**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 [update-workgroup](https://docs.aws.amazon.com/cli/latest/reference/redshift-serverless/update-workgroup.html) 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 de données
Après avoir créé un entrepôt de données, vous devez configurer 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 de données Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam).
## 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)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) pour créer une instance de base de données RDS for MySQL source 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 `my-integration` d’aprè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()
```
## Étape 3b : Création d'un AWS Glue catalogue pour l'intégration d'Amazon SageMaker Lakehouse Zero-ETL
Lorsque vous créez une intégration zéro ETL avec un Amazon SageMaker Lakehouse, vous devez créer un catalogue AWS Glue géré dans. AWS Lake Formation Le catalogue cible doit être un catalogue géré Amazon Redshift. Pour créer un catalogue géré Amazon Redshift, créez d’abord le rôle lié à un service `AWSServiceRoleForRedshift`. 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 le AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-rms-catalog.html) du *Guide du développeur AWS Lake Formation *.
+ 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](https://docs.aws.amazon.com/redshift/latest/mgmt/using-service-linked-roles.html) du *Guide de gestion Amazon Redshift*.
+ Pour plus d’informations sur les autorisations d’administrateur en lecture seule pour Lake Formation, consultez la section [Références relatives aux personas de Lake Formation et aux autorisations IAM](https://docs.aws.amazon.com/lake-formation/latest/dg/permissions-reference.html) 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 cible 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**.
#### Rôle de création de cible Lake Formation
Le rôle de création de cible doit être un administrateur de Lake Formation et nécessite les autorisations suivantes.
------
#### [ 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"
]
}
]
}
```
------
Le rôle de création de cible doit avoir la relation d’approbation suivante :
------
#### [ 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"
}
]
}
```
------
#### Rôle de transfert de données Glue
Le rôle de transfert de données Glue est requis pour les opérations du catalogue MySQL et doit disposer des autorisations suivantes.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataTransferRolePolicy",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"glue:GetCatalog",
"glue:GetDatabase"
],
"Resource": [
"*"
]
}
]
}
```
------
Le rôle de transfert de données Glue doit avoir la relation d’approbation suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
## Étapes suivantes
Avec un source et un entrepôt de données cible Amazon Redshift ou SageMaker Amazon 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](zero-etl.creating.md).
# Création d'intégrations zéro ETL d'Amazon RDS à Amazon Redshift
Lorsque vous créez une intégration zéro ETL Amazon RDS, vous spécifiez la base de données RDS source et l’entrepôt de données Amazon Redshift cible. Vous pouvez également personnaliser les paramètres de chiffrement et ajouter des balises. Amazon RDS crée une intégration entre la base de données source et sa cible. Une fois l’intégration active, toutes les données que vous insérez dans la base de données source sont répliquées dans la cible Amazon Redshift configurée.
## Conditions préalables
Avant de créer une intégration zéro ETL, vous devez spécifier une base de données source et un entrepôt de données Amazon Redshift cible. Vous devez également autoriser la réplication dans l’entrepôt de données en ajoutant la base de données en tant que source d’intégration autorisée.
Pour obtenir des instructions sur la réalisation de chacune de ces étapes, consultez [Bien démarrer avec les intégrations zéro ETL Amazon RDS](zero-etl.setting-up.md).
## Autorisations requises
Certaines autorisations IAM sont requises pour créer une intégration zéro ETL. Vous avez au moins besoin des autorisations requises pour effectuer les actions suivantes :
+ Créer des intégrations zéro ETL la base de données RDS source.
+ Afficher et supprimer toutes les intégrations zéro ETL.
+ Créer des intégrations entrantes dans l'entrepôt de données cible.
Les exemples de politiques suivants montrent les [autorisations de moindre privilège](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) requises pour créer et gérer des intégrations. Il se peut que vous n’ayez pas besoin de ces autorisations exactes si votre utilisateur ou votre rôle dispose d’autorisations plus étendues, telles qu’une politique gérée `AdministratorAccess`.
**Note**
Les noms de ressources Redshift Amazon (ARNs) ont le format suivant. Notez l'utilisation d'une barre oblique (`(/`) à la place du caractère deux-points (`:`) avant l'UUID de l'espace de noms sans serveur.
Cluster provisionné : `arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid`
Sans serveur : `arn:aws:redshift-serverless:{region}:{account-id}:namespace/namespace-uuid`
### Exemple de politique pour la cible Redshift
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CreateIntegration",
"Effect": "Allow",
"Action": [
"rds:CreateIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:db:source-db",
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "DescribeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DescribeIntegrations"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "ChangeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DeleteIntegration",
"rds:ModifyIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "AllowRedShiftIntegration",
"Effect": "Allow",
"Action": [
"redshift:CreateInboundIntegration"
],
"Resource": [
"arn:aws:redshift:us-east-1:123456789012:namespace:namespace-uuid"
]
}
]
}
```
------
### Choix d'un entrepôt de données cible dans un autre compte
Si vous prévoyez de spécifier un entrepôt de données Amazon Redshift cible situé dans un autre Compte AWS, vous devez créer un rôle permettant aux utilisateurs du compte courant d'accéder aux ressources du compte cible. Pour plus d'informations, consultez la section [Fournir un accès à un utilisateur IAM dans un autre utilisateur Compte AWS dont vous êtes le propriétaire.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html)
Le rôle doit disposer des autorisations suivantes, qui permettent à l'utilisateur de consulter les clusters provisionnés Amazon Redshift et les espaces de noms Redshift sans serveur disponibles dans le compte cible.
#### Autorisations requises et politique d'approbation
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"redshift:DescribeClusters",
"redshift-serverless:ListNamespaces"
],
"Resource":[
"*"
]
}
]
}
```
------
Le rôle doit respecter la politique d’approbation suivante, qui spécifie l’ID du compte cible.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Pour obtenir des instructions quant à la création du rôle, consultez [Création d'un rôle à l'aide de politiques d'approbation personnalisées](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Création d'intégrations zéro ETL
Vous pouvez créer une intégration zéro ETL à l'aide de l'API AWS Management Console, de AWS CLI, ou de l'API RDS.
**Important**
Les intégrations zéro ETL ne prennent pas en charge les opérations d’actualisation ou de resynchronisation. Si vous rencontrez des problèmes avec une intégration après sa création, vous devez supprimer l’intégration et en créer une nouvelle.
Par défaut, RDS for MySQL purge immédiatement les fichiers journaux binaires. Étant donné que les intégrations zéro ETL reposent sur des journaux binaires pour répliquer les données de la source vers la cible, la période de conservation de l’instance de base de données source doit être d’au moins une heure. Dès que vous créez une intégration, Amazon RDS vérifie la période de conservation du fichier journal binaire pour la base de données source sélectionnée. Si la valeur actuelle est 0 heures, Amazon RDS la remplace automatiquement par 1 heure. Sinon, la valeur reste la même.
### Console RDS
**Pour créer une intégration zéro ETL**
1. Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)l'adresse.
1. Dans le panneau de navigation de gauche, choisissez **Intégrations zéro ETL**.
1. Choisissez **Créer une intégration zéro ETL**.
1. Dans **Identifiant d’intégration**, saisissez un nom pour l’intégration. Ce nom peut comporter jusqu’à 63 caractères alphanumériques et peut inclure des traits d’union.
**Important**
Les noms de catalogue sont limités à 19 caractères. Assurez-vous que votre identifiant d’intégration répond à cette exigence s’il doit être utilisé comme nom de catalogue.
1. Choisissez **Suivant**.
1. Pour **Source**, sélectionnez la base de données RDS d’où proviendront les données.
**Note**
RDS vous avertit si les paramètres ne sont pas configurés correctement. Si vous recevez ce message, vous pouvez soit choisir **Fix it for me**, soit les configurer manuellement. Pour obtenir des instructions pour les corriger manuellement, reportez-vous à [Étape 1 : Création d’un groupe de paramètres données personnalisé](zero-etl.setting-up.md#zero-etl.parameters).
La modification des paramètres nécessite un redémarrage. Avant de créer l’intégration, le redémarrage doit être terminé et les nouvelles valeurs de paramètre doit être correctement appliquée à la base de données.
1. Une fois la configuration de la base de donnes source terminée, choisissez **Suivant**.
1. Pour **Cible**, procédez comme suit :
1. (Facultatif) Pour utiliser un autre Compte AWS compte pour la cible Amazon Redshift, choisissez **Spécifier un autre compte**. Saisissez ensuite l'ARN d'un rôle IAM doté d'autorisations pour afficher vos entrepôts des données. Pour obtenir des instructions sur la création du rôle IAM, consultez [Choix d'un entrepôt de données cible dans un autre compte](#zero-etl.create-permissions-cross-account).
1. Pour **Entrepôt de données Amazon Redshift**, sélectionnez la cible pour les données répliquées à partir de la base de donnes source. Vous pouvez choisir un *cluster* Amazon Redshift provisionné ou un *espace de noms* Redshift sans serveur comme cible.
**Note**
RDS vous avertit si la politique de ressources ou les paramètres de sensibilité à la casse pour l’entrepôt de données spécifié ne sont pas correctement configurés. Si vous recevez ce message, vous pouvez soit choisir **Fix it for me**, soit les configurer manuellement. Pour obtenir des instructions pour les corriger manuellement, consultez [Activation de la sensibilité à la casse pour votre entrepôt de données](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity) et [Configuration de l’autorisation pour votre entrepôt de données](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam) dans le *Guide de gestion Amazon Redshift*.
La modification de la sensibilité à la casse pour un cluster Redshift *provisionné* nécessite un redémarrage. Avant de créer l'intégration, le redémarrage doit être terminé et la nouvelle valeur de paramètre doit être correctement appliquée au cluster.
Si la source et la cible que vous avez sélectionnées se trouvent dans des Comptes AWS différents, Amazon RDS ne peut pas corriger ces paramètres pour vous. Vous devez accéder à l'autre compte et les corriger manuellement dans Amazon Redshift.
1. Une fois que votre entrepôt de données cible est correctement configuré, choisissez **Suivant**.
1. (Facultatif) Pour **Balises**, ajoutez une ou plusieurs balises à l’intégration. Pour plus d’informations, consultez [Marquage des Amazon RDS](USER_Tagging.md).
1. Pour **Chiffrement**, spécifiez la manière dont vous souhaitez que votre intégration soit chiffrée. Par défaut, RDS chiffre toutes les intégrations avec un. Clé détenue par AWS Pour choisir plutôt une clé gérée par le client, activez **Personnaliser les paramètres de chiffrement** et choisissez une clé KMS à utiliser pour le chiffrement. Pour plus d’informations, consultez [Chiffrement des ressources Amazon RDS](Overview.Encryption.md).
Ajoutez éventuellement un contexte de chiffrement. Consultez [Contexte de chiffrement](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) dans le *AWS Key Management Service guide du développeur* pour en savoir plus.
**Note**
Amazon RDS ajoute les paires de contextes de chiffrement suivantes en plus de celles que vous ajoutez :
`aws:redshift:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `Redshift`
Cela réduit le nombre total de paires que vous pouvez ajouter de 8 à 6 et contribue à la limite de caractères globale de la contrainte de subvention. Pour plus d’informations, consultez [Utilisation des contraintes d’octroi](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) dans le *Guide du développeur AWS Key Management Service *.
1. Choisissez **Suivant**.
1. Vérifiez vos paramètres d’intégration et choisissez **Créer une intégration zéro ETL**.
Si la création échoue, consultez [Je ne parviens pas à créer une intégration zéro ETL](zero-etl.troubleshooting.md#zero-etl.troubleshooting.creation) pour obtenir les étapes de résolution des problèmes.
L'intégration a un statut de `Creating` lors de sa création et l'entrepôt de données Amazon Redshift cible a un statut de `Modifying`. Pendant ce temps, vous ne pouvez pas interroger l'entrepôt de données ni y apporter aucune modification de configuration.
Quand l'intégration est créée avec succès, le statut de l'intégration et celui de l'entrepôt de données Amazon Redshift cible passent tous deux à `Active`.
### AWS CLI
Pour créer une intégration zéro ETL à l'aide de AWS CLI, utilisez la commande [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) avec les options suivantes :
**Note**
N’oubliez pas que les noms de catalogue sont limités à 19 caractères. Choisissez le nom de votre intégration en conséquence s’il doit être utilisé comme nom de catalogue.
+ `--integration-name` : spécifiez le nom de l’intégration.
+ `--source-arn` : spécifiez l’ARN de la base de données RDS qui sera la source de l’intégration.
+ `--target-arn` : spécifiez l’ARN de l’entrepôt de données Amazon Redshift qui sera la cible de l’intégration.
**Example**
Pour Linux, macOS ou Unix :
```
aws rds create-integration \
--integration-name my-integration \
--source-arn arn:aws:rds:{region}:{account-id}:my-db \
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
Pour Windows :
```
aws rds create-integration ^
--integration-name my-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:my-db ^
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
### API RDS
Pour créer une intégration zéro ETL à l'aide de l'API Amazon RDS, utilisez l'opération [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html) avec les paramètres suivants :
**Note**
Les noms de catalogue sont limités à 19 caractères. Assurez-vous que votre IntegrationName paramètre répond à cette exigence s'il doit être utilisé comme nom de catalogue.
+ `IntegrationName` : spécifiez le nom de l’intégration.
+ `SourceArn` : spécifiez l’ARN de la base de données RDS qui sera la source de l’intégration.
+ `TargetArn` : spécifiez l’ARN de l’entrepôt de données Amazon Redshift qui sera la cible de l’intégration.
## Chiffrement des intégrations avec une clé gérée par le client
Si vous spécifiez une clé KMS personnalisée plutôt qu'une clé Clé détenue par AWS lorsque vous créez une intégration, la politique de clé doit fournir au service Amazon Redshift l'accès principal à l'`CreateGrant`action. En outre, elle doit autoriser l’utilisateur actuel à effectuer les actions `DescribeKey` et `CreateGrant`.
L’exemple de stratégie suivant montre comment fournir les autorisations requises dans la stratégie de clé. Il inclut des clés contextuelles pour réduire davantage la portée des autorisations.
### Exemple de stratégie de clé
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "Enables IAM user permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "Allows the Redshift service principal to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current user or role to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current uer or role to retrieve information about a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Pour plus d’informations, consultez [Création d’une stratégie de clé](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) dans le *Guide du développeur AWS Key Management Service *.
## Étapes suivantes
Une fois que vous avez réussi à créer une intégration zéro ETL, vous devez créer une base de données de destination au sein de votre cluster ou groupe de travail Amazon Redshift cible. Ensuite, vous pouvez commencer à ajouter des données à la base de données RDS source et à les interroger dans Amazon Redshift. Pour obtenir des instructions, consultez [Création de bases de données de destination dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html).
# Création d’intégrations zéro ETL Amazon RDS avec un Amazon SageMaker Lakehouse
Lorsque vous créez une intégration Amazon RDS Zero-ETL avec un Amazon SageMaker Lakehouse, vous spécifiez le source et le catalogue géré cible. AWS Glue Vous pouvez également personnaliser les paramètres de chiffrement et ajouter des balises. Amazon RDS crée une intégration entre la base de données source et sa cible. Une fois l’intégration active, toutes les données que vous insérez dans la base de données source sont répliquées dans la cible configurée.
## Conditions préalables
Avant de créer une intégration zéro ETL avec un Amazon SageMaker Lakehouse, vous devez créer un de base de données source et un catalogue géré cible AWS Glue . Vous devez également autoriser la réplication dans le catalogue en ajoutant la base de données en tant que source d’intégration autorisée.
Pour obtenir des instructions sur la réalisation de chacune de ces étapes, consultez [Bien démarrer avec les intégrations zéro ETL Amazon RDS](zero-etl.setting-up.md).
## Autorisations requises
Certaines autorisations IAM sont requises pour créer une intégration zéro ETL avec un Amazon SageMaker Lakehouse. Vous avez au moins besoin des autorisations requises pour effectuer les actions suivantes :
+ Créer des intégrations zéro ETL la base de données RDS source.
+ Afficher et supprimer toutes les intégrations zéro ETL.
+ Créez des intégrations entrantes dans le catalogue AWS Glue géré cible.
+ Accédez aux compartiments Amazon S3 utilisés par le catalogue AWS Glue géré.
+ Utilisez AWS KMS des clés pour le chiffrement si le chiffrement personnalisé est configuré.
+ Enregistrez les ressources auprès de Lake Formation.
+ Appliquez une politique de ressources au catalogue AWS Glue géré pour autoriser les intégrations entrantes.
L’exemple de politique suivant illustre les [autorisations de moindre privilège](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) requises pour créer et gérer des intégrations avec un Amazon SageMaker Lakehouse. Il se peut que vous n’ayez pas besoin de ces autorisations exactes si votre utilisateur ou votre rôle dispose d’autorisations plus étendues, telles qu’une politique gérée `AdministratorAccess`.
En outre, vous devez configurer une politique de ressources sur le catalogue AWS Glue géré cible afin d'autoriser les intégrations entrantes. Utilisez la AWS CLI commande suivante pour appliquer la politique de ressources.
### Exemple de AWS CLI commande pour autoriser les intégrations entrantes sur le catalogue cible
```
aws glue put-resource-policy \
--policy-in-json '{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": [
"glue:AuthorizeInboundIntegration"
],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"],
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:rds:region:account_id:db:source_name"
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "account_id"
},
"Action": ["glue:CreateInboundIntegration"],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"]
}
]
}' \
--region region
```
**Note**
Les noms de ressources Amazon du catalogue Glue (ARNs) ont le format suivant :
Catalogue Glue : `arn:aws:glue:{region}:{account-id}:catalog/catalog-name`
### Choix d'un catalogue AWS Glue géré cible dans un autre compte
Si vous envisagez de spécifier un catalogue AWS Glue géré cible qui se trouve dans un autre Compte AWS, vous devez créer un rôle permettant aux utilisateurs du compte courant d'accéder aux ressources du compte cible. Pour plus d'informations, consultez la section [Fournir un accès à un utilisateur IAM dans un autre utilisateur Compte AWS dont vous êtes le propriétaire.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html)
Le rôle doit disposer des autorisations suivantes, qui permettent à l'utilisateur de consulter les AWS Glue catalogues disponibles dans le compte cible.
#### Autorisations requises et politique d’approbation
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"glue:GetCatalog"
],
"Resource":[
"*"
]
}
]
}
```
------
Le rôle doit respecter la politique d’approbation suivante, qui spécifie l’ID du compte cible.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"AWS": "arn:aws:iam::111122223333:root"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
Pour obtenir des instructions quant à la création du rôle, consultez [Création d’un rôle à l’aide de politiques d’approbation personnalisées](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Création d’Intégrations zéro ETL avec un Amazon SageMaker Lakehouse
Vous pouvez créer une intégration zéro ETL avec un Amazon SageMaker lakehouse à l'aide de l'API AWS Management Console, de AWS CLI, ou de l'API RDS.
**Important**
Les intégrations zéro ETL avec un Amazon SageMaker Lakehouse ne prennent pas en charge les opérations d’actualisation ou de resynchronisation. Si vous rencontrez des problèmes avec une intégration après sa création, vous devez supprimer l’intégration et en créer une nouvelle.
Par défaut, RDS for MySQL purge immédiatement les fichiers journaux binaires. Étant donné que les intégrations zéro ETL reposent sur des journaux binaires pour répliquer les données de la source vers la cible, la période de conservation de l’instance de base de données source doit être d’au moins une heure. Dès que vous créez une intégration, Amazon RDS vérifie la période de conservation du fichier journal binaire pour la base de données source sélectionnée. Si la valeur actuelle est 0 heures, Amazon RDS la remplace automatiquement par 1 heure. Sinon, la valeur reste la même.
### Console RDS
**Pour créer une intégration zéro ETL avec un Amazon SageMaker Lakehouse**
1. Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)l'adresse.
1. Dans le panneau de navigation de gauche, choisissez **Intégrations zéro ETL**.
1. Choisissez **Créer une intégration zéro ETL**.
1. Dans **Identifiant d’intégration**, saisissez un nom pour l’intégration. Ce nom peut comporter jusqu’à 63 caractères alphanumériques et peut inclure des traits d’union.
1. Choisissez **Suivant**.
1. Pour **Source**, sélectionnez la base de données RDS d’où proviendront les données.
**Note**
RDS vous avertit si les paramètres ne sont pas configurés correctement. Si vous recevez ce message, vous pouvez soit choisir **Fix it for me**, soit les configurer manuellement. Pour obtenir des instructions pour les corriger manuellement, reportez-vous à [Étape 1 : Création d’un groupe de paramètres données personnalisé](zero-etl.setting-up.md#zero-etl.parameters).
La modification des paramètres nécessite un redémarrage. Avant de créer l’intégration, le redémarrage doit être terminé et les nouvelles valeurs de paramètre doit être correctement appliquée à la base de données.
1. Une fois la configuration de la base de donnes source terminée, choisissez **Suivant**.
1. Pour **Cible**, procédez comme suit :
1. (Facultatif) Pour utiliser un autre Compte AWS compte pour la cible Amazon SageMaker Lakehouse, choisissez **Spécifier un autre compte**. Entrez ensuite l'ARN d'un rôle IAM autorisé à afficher vos AWS Glue catalogues. Pour obtenir des instructions sur la création du rôle IAM, consultez [Choix d'un catalogue AWS Glue géré cible dans un autre compte](#zero-etl.create-permissions-cross-account-smlh).
1. Pour **Catalogue AWS Glue **, sélectionnez la cible pour les données répliquées à partir de la base de données. Vous pouvez choisir un catalogue géré AWS Glue existant comme cible.
1. Le rôle IAM cible doit décrire les autorisations disponibles dans le catalogue cible et doit disposer des autorisations suivantes :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "glue:GetCatalog",
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog/*",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
}
]
}
```
------
Le rôle IAM doit avoir la relation d’approbation suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Vous devez accorder au rôle IAM cible des autorisations de description pour le catalogue AWS Glue géré cible avec le rôle d'administrateur de Lake Formation créé dans[Étape 3b : Création d'un AWS Glue catalogue pour l'intégration d'Amazon SageMaker Lakehouse Zero-ETL](zero-etl.setting-up.md#zero-etl-setting-up.sagemaker).
**Note**
RDS vous avertit si la politique de ressources ou les paramètres de configuration du catalogue AWS Glue géré spécifié ne sont pas correctement configurés. Si vous recevez ce message, vous pouvez soit choisir **Fix it for me**, soit les configurer manuellement.
Si la source et la cible que vous avez sélectionnées se trouvent dans des Comptes AWS différents, Amazon RDS ne peut pas corriger ces paramètres pour vous. Vous devez accéder à l’autre compte et les corriger manuellement dans SageMaker Unified Studio.
1. Une fois que votre catalogue AWS Glue géré cible est correctement configuré, choisissez **Next**.
1. (Facultatif) Pour **Balises**, ajoutez une ou plusieurs balises à l’intégration. Pour plus d’informations, consultez [Marquage des Amazon RDS](USER_Tagging.md).
1. Pour **Chiffrement**, spécifiez la manière dont vous souhaitez que votre intégration soit chiffrée. Par défaut, RDS chiffre toutes les intégrations avec un. Clé détenue par AWS Pour choisir plutôt une clé gérée par le client, activez **Personnaliser les paramètres de chiffrement** et choisissez une clé KMS à utiliser pour le chiffrement. Pour plus d’informations, consultez [Chiffrement des ressources Amazon RDS](Overview.Encryption.md).
Ajoutez éventuellement un contexte de chiffrement. Consultez [Contexte de chiffrement](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) dans le *AWS Key Management Service guide du développeur* pour en savoir plus.
**Note**
Amazon RDS ajoute les paires de contextes de chiffrement suivantes en plus de celles que vous ajoutez :
`aws:glue:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `glue`
Cela réduit le nombre total de paires que vous pouvez ajouter de 8 à 6 et contribue à la limite de caractères globale de la contrainte de subvention. Pour plus d’informations, consultez [Utilisation des contraintes d’octroi](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) dans le *Guide du développeur AWS Key Management Service *.
1. Choisissez **Suivant**.
1. Vérifiez vos paramètres d’intégration et choisissez **Créer une intégration zéro ETL**.
Si la création échoue, consultez [Résolution des problèmes liés aux intégrations zéro ETL Amazon RDS](zero-etl.troubleshooting.md) pour obtenir les étapes de résolution des problèmes.
L’intégration a un statut de `Creating` lors de sa création et l’Amazon SageMaker Lakehouse cible a un statut de `Modifying`. Pendant ce temps, vous ne pouvez pas interroger le catalogue ni y apporter aucune modification de configuration.
Quand l’intégration est créée avec succès, le statut de l’intégration et celui de l’Amazon SageMaker Lakehouse cible passent tous deux à `Active`.
### AWS CLI
Pour préparer un catalogue AWS Glue géré cible pour une intégration zéro ETL à l'aide de AWS CLI, vous devez d'abord utiliser la [create-integration-resource-property](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html)commande avec les options suivantes :
+ `--resource-arn`— Spécifiez l'ARN du catalogue AWS Glue géré qui sera la cible de l'intégration.
+ `--target-processing-properties`— Spécifiez l'ARN du rôle IAM pour accéder au catalogue AWS Glue géré cible
```
aws glue create-integration-resource-property --region us-east-1
--resource-arn arn:aws:glue:region:account_id:catalog/catalog_name \
--target-processing-properties '{"RoleArn" : "arn:aws:iam::account_id:role/TargetIamRole"}'
```
Pour créer une intégration zéro ETL avec un Amazon SageMaker lakehouse à l'aide de AWS CLI, utilisez la commande [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) avec les options suivantes :
+ `--integration-name` : spécifiez le nom de l’intégration.
+ `--source-arn` : spécifiez l’ARN de la base de données RDS qui sera la source de l’intégration.
+ `--target-arn`— Spécifiez l'ARN du catalogue AWS Glue géré qui sera la cible de l'intégration.
**Example**
Pour Linux, macOS ou Unix :
```
aws rds create-integration \
--integration-name my-sagemaker-integration \
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db \
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
Pour Windows :
```
aws rds create-integration ^
--integration-name my-sagemaker-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db ^
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
### API RDS
Pour créer une intégration zéro ETL à Amazon SageMaker à l’aide de l’API Amazon RDS, utilisez l’opération [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html) avec les paramètres suivants :
**Note**
Les noms de catalogue sont limités à 19 caractères. Assurez-vous que votre IntegrationName paramètre répond à cette exigence s'il doit être utilisé comme nom de catalogue.
+ `IntegrationName` : spécifiez le nom de l’intégration.
+ `SourceArn` : spécifiez l’ARN de la base de données RDS qui sera la source de l’intégration.
+ `TargetArn`— Spécifiez l'ARN du catalogue AWS Glue géré qui sera la cible de l'intégration.
## Chiffrement des intégrations avec une clé gérée par le client
Si vous spécifiez une clé KMS personnalisée plutôt qu'une clé Clé détenue par AWS lorsque vous créez une intégrationAmazon SageMaker, la politique de clé doit fournir au SageMaker Unified Studio service principal un accès à l'`CreateGrant`action. En outre, elle doit autoriser l’utilisateur actuel à effectuer les actions `DescribeKey` et `CreateGrant`.
L’exemple de stratégie suivant montre comment fournir les autorisations requises dans la stratégie de clé. Il inclut des clés contextuelles pour réduire davantage la portée des autorisations.
### Exemple de stratégie de clé
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "EnablesIAMUserPermissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "GlueServicePrincipalAddGrant",
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleAddGrantKMSKey",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleRetrieveKMSKeyInformation",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Pour plus d’informations, consultez [Création d’une stratégie de clé](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) dans le *Guide du développeur AWS Key Management Service *.
## Étapes suivantes
Une fois que vous avez créé avec succès une intégration zéro ETL avec Amazon SageMaker, vous pouvez commencer à ajouter des données à la base de données RDS et à les interroger dans votre Amazon SageMaker Lakehouse. Les données seront automatiquement répliquées et mises à disposition pour les charges de travail d’analytique et de machine learning.
# Filtrage des données pour les intégrations zéro ETL Amazon RDS
Les intégrations zéro ETL Amazon RDS prennent en charge le filtrage des données, ce qui vous permet de contrôler quelles données sont répliquées depuis votre base de données Amazon RDS source vers votre entrepôt de données cible. Au lieu de répliquer l’intégralité de la base de données, vous pouvez appliquer un ou plusieurs filtres pour inclure ou exclure des tables spécifiques de manière sélective. Cela vous permet d’optimiser les performances de stockage et de requête en garantissant que seules les données pertinentes sont transférées. Actuellement, le filtrage est limité aux niveaux de base de données et de table. Le filtrage au niveau des colonnes et des lignes n’est pas pris en charge.
Le filtrage des données peut être utile lorsque vous souhaitez :
+ Joindre certaines tables provenant d’au moins deux clusters source différents, et vous n’avez pas besoin de données complètes provenant de l’un ou l’autre des clusters.
+ Réduisez les coûts en effectuant des opérations d’analytique en utilisant uniquement un sous-ensemble de tables plutôt qu’une flotte complète de bases de données.
+ Filtrez les informations sensibles, telles que les numéros de téléphone, les adresses ou les informations de carte de crédit, de certaines tables.
Vous pouvez ajouter des filtres de données à une intégration sans ETL à l' AWS Management Console aide de l' AWS Command Line Interface API,AWS CLI the () ou Amazon RDS.
Si l’intégration a un cluster provisionné comme cible, le cluster doit être sur le [correctif 180](https://docs.aws.amazon.com/redshift/latest/mgmt/cluster-versions.html#cluster-version-180) ou supérieur pour utiliser le filtrage des données.
**Topics**
+ [Format d’un filtre de données](#zero-etl.filtering-format)
+ [Logique de filtrage](#zero-etl.filtering-evaluate)
+ [Ordre de priorité de filtre](#zero-etl.filtering-precedence)
+ [Exemples RDS for MySQL](#zero-etl.filtering-examples-mysql)
+ [Exemples RDS pour PostgreSQL](#zero-etl.filtering-examples-postgres)
+ [Exemples de RDS for Oracle](#zero-etl.filtering-examples-oracle)
+ [Ajout de filtres de données à une intégration](#zero-etl.add-filter)
+ [Suppression des filtres de données d’une intégration](#zero-etl.remove-filter)
## Format d’un filtre de données
Vous pouvez définir plusieurs filtres pour une seule intégration. Chaque filtre inclut ou exclut les tables de base de données existantes et futures qui correspondent à l’un des modèles de l’expression du filtre. Les intégrations zéro ETL Amazon RDS utilisent la [syntaxe du filtre Maxwell](https://maxwells-daemon.io/filtering/) pour le filtrage des données.
Chaque filtre contient les éléments suivants :
| Element | Description |
| --- | --- |
| Type de filtre | Un type de filtre `Include` *inclut* toutes les tables qui correspondent à l’un des modèles de l’expression du filtre. Un type de filtre `Exclude` *exclut* toutes les tables correspondant à l’un des modèles. |
| Expression de filtre | Une liste de modèles séparée par des virgules. Les expressions doivent utiliser la [syntaxe du filtre Maxwell](https://maxwells-daemon.io/filtering/). |
| Modèle | Un modèle de filtre au format `database.table` pour RDS for MySQL, ou `database.schema.table` pour RDS pour PostgreSQL. Vous pouvez spécifier des noms littéraux ou définir des expressions régulières. Pour RDS for MySQL, les expressions régulières sont prises en charge à la fois dans le nom de la base de données et dans le nom de la table. Pour RDS pour PostgreSQL, les expressions régulières ne sont prises en charge que dans le schéma et le nom de la table, et non dans le nom de la base de données. Vous ne pouvez pas inclure de filtres ou de listes de refus au niveau des colonnes. Une intégration unique peut avoir un maximum de 99 modèles. Dans la console, vous pouvez saisir des modèles dans une seule expression de filtre ou les répartir entre plusieurs expressions. La longueur d’un modèle unique ne peut pas dépasser 256 caractères. |
**Important**
Si vous sélectionnez une base de données RDS pour PostgreSQL source, vous devez spécifier au moins un modèle de filtre de données. Le modèle doit au minimum inclure une seule base de données (`database-name.*.*`) pour la réplication vers l’entrepôt de données cible.
L’image suivante montre la structure des filtres de données RDS for MySQL dans la console :
![\[Filtrage des données pour les intégrations zéro ETL\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/zero-etl-filter.png)
**Important**
N’incluez pas de données d’identification personnelle, confidentielles ou sensibles dans vos modèles de filtrage.
### Filtres de données dans le AWS CLI
Lorsque vous utilisez le AWS CLI pour ajouter un filtre de données, la syntaxe est légèrement différente de celle de la console. Vous devez attribuer un type de filtre (`Include` ou `Exclude`) à chaque modèle individuellement, afin de ne pas pouvoir regrouper plusieurs modèles sous un même type de filtre.
Par exemple, dans la console, vous pouvez regrouper les modèles suivants, séparés par des virgules, sous une seule instruction `Include` :
**RDS for MySQL**
```
mydb.mytable, mydb./table_\d+/
```
**RDS pour PostgreSQL**
```
mydb.myschema.mytable, mydb.myschema./table_\d+/
```
Toutefois, lorsque vous utilisez le AWS CLI, le même filtre de données doit être au format suivant :
**RDS for MySQL**
```
'include: mydb.mytable, include: mydb./table_\d+/'
```
**RDS pour PostgreSQL**
```
'include: mydb.myschema.mytable, include: mydb.myschema./table_\d+/'
```
## Logique de filtrage
Si vous ne spécifiez aucun filtre de données dans votre intégration, Amazon RDS suppose un filtre par défaut de `include:*.*`, qui réplique toutes les tables dans l’entrepôt de données cible. Toutefois, si vous ajoutez au moins un filtre, la logique par défaut passe à `exclude:*.*`, ce qui exclut toutes les tables par défaut. Cela vous permet de définir explicitement les bases de données et les tables à inclure dans la réplication.
Par exemple, si vous définissez le filtre suivant :
```
'include: db.table1, include: db.table2'
```
Amazon RDS évalue le filtre comme suit :
```
'exclude:*.*, include: db.table1, include: db.table2'
```
Par conséquent, Amazon RDS réplique uniquement `table1` et `table2` depuis la base de données nommée `db` vers l’entrepôt de données cible.
## Ordre de priorité de filtre
Amazon RDS évalue les filtres de données dans l’ordre que vous spécifiez. Dans le AWS Management Console, il traite les expressions de filtre de gauche à droite et de haut en bas. Un second filtre ou un modèle individuel qui suit le premier peut le remplacer.
Par exemple, si le premier filtre est `Include books.stephenking`, il inclut uniquement la table `stephenking` de la base de données `books`. Toutefois, si vous ajoutez un second filtre, `Exclude books.*`, il remplace le premier filtre. Cela empêche la réplication des tables de l’index `books` vers l’entrepôt de données cible.
Lorsque vous spécifiez au moins un filtre, la logique commence par l’hypothèse `exclude:*.*` par défaut, ce qui *exclut* automatiquement toutes les tables de la réplication. Une bonne pratique consiste à définir des filtres du plus large au plus spécifique. Commencez par une ou plusieurs instructions `Include` pour spécifier les données à répliquer, puis ajoutez des filtres `Exclude` pour supprimer certaines tables de manière sélective.
Le même principe s’applique aux filtres que vous définissez à l’aide de l’ AWS CLI. Amazon RDS évalue ces modèles de filtre dans l’ordre dans lequel vous les spécifiez, de sorte qu’un modèle peut remplacer celui que vous avez spécifié avant lui.
## Exemples RDS for MySQL
Les exemples suivants montrent comment fonctionne le filtrage des données pour intégrations zéro ETL Exemples RDS for MySQL :
+ Incluez toutes les bases de données et toutes les tables :
```
'include: *.*'
```
+ Incluez toutes les tables de la base de données `books` :
```
'include: books.*'
```
+ Excluez toutes les tables nommées `mystery` :
```
'include: *.*, exclude: *.mystery'
```
+ Incluez deux tables spécifiques dans la base de données `books` :
```
'include: books.stephen_king, include: books.carolyn_keene'
```
+ Incluez toutes les tables de la base de données `books`, à l’exception de celles contenant la sous-chaîne `mystery` :
```
'include: books.*, exclude: books./.*mystery.*/'
```
+ Incluez toutes les tables de la base de données `books`, à l’exception de celles commençant par `mystery` :
```
'include: books.*, exclude: books./mystery.*/'
```
+ Incluez toutes les tables de la base de données `books`, à l’exception de celles se terminant par `mystery` :
```
'include: books.*, exclude: books./.*mystery/'
```
+ Incluez toutes les tables de la base de données `books` qui commencent par `table_`, à l’exception de celle nommée `table_stephen_king`. Par exemple, `table_movies` ou `table_books` serait répliqué, mais pas `table_stephen_king`.
```
'include: books./table_.*/, exclude: books.table_stephen_king'
```
## Exemples RDS pour PostgreSQL
Les exemples suivants montrent comment fonctionne le filtrage des données pour intégrations zéro ETL RDS for MySQL :
+ Incluez toutes les tables de la base de données `books` :
```
'include: books.*.*'
```
+ Excluez toutes les tables nommées `mystery` de la base de données `books` :
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Incluez une table dans la base de données `books` dans le schéma `mystery`, et une table dans la base de données `employee` dans le schéma `finance` :
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Incluez toutes les tables de la base de données `books` et le schéma `science_fiction`, à l’exception de celles contenant la sous-chaîne `king` :
```
'include: books.science_fiction.*, exclude: books.*./.*king.*/
```
+ Incluez toutes les tables de la base de données `books`, à l’exception de celles avec un nom de schéma commençant par `sci` :
```
'include: books.*.*, exclude: books./sci.*/.*'
```
+ Incluez toutes les tables de la base de données `books`, à l’exception de celles dans le schéma `mystery` se terminant par `king` :
```
'include: books.*.*, exclude: books.mystery./.*king/'
```
+ Incluez toutes les tables de la base de données `books` qui commencent par `table_`, à l’exception de celle nommée `table_stephen_king`. Par exemple, `table_movies` dans le schéma `fiction` et `table_books` dans le schéma `mystery` sont répliqués, mais pas `table_stephen_king` dans l’un ou l’autre des schémas :
```
'include: books.*./table_.*/, exclude: books.*.table_stephen_king'
```
## Exemples de RDS for Oracle
Les exemples suivants montrent comment fonctionne le filtrage des données pour intégrations zéro ETL RDS for Oracle :
+ Incluez toutes les tables de la base de données books :
```
'include: books.*.*'
```
+ Excluez toutes les tables nommées mystery de la base de données books :
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Incluez une table dans la base de données books dans le schéma mystery, et une table dans la base de données employee dans le schéma finance :
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Incluez toutes les tables du schéma mystery dans la base de données books :
```
'include: books.mystery.*'
```
### Considérations sur la sensibilité à la casse
Oracle Database et Amazon Redshift gèrent la casse des noms d’objets différemment, ce qui affecte à la fois la configuration du filtre de données et les requêtes cibles. Notez ce qui suit :
+ Oracle Database stocke les noms des bases de données, des schémas et des objets en majuscules, sauf s’ils sont explicitement cités dans l’instruction `CREATE`. Par exemple, si vous créez `mytable` (sans guillemets), le dictionnaire de données Oracle enregistre le nom de la table sous la forme `MYTABLE`. Si vous citez le nom de l’objet, le dictionnaire de données préserve la casse.
+ Les filtres de données sans extraction, transformation ni chargement (sans ETL) distinguent les majuscules et minuscules et doivent correspondre exactement aux noms d’objets tels qu’ils apparaissent dans le dictionnaire de données Oracle.
+ Les requêtes Amazon Redshift utilisent par défaut des noms d’objets en minuscules, sauf entre guillemets explicites. Par exemple, une requête `MYTABLE` (sans guillemets) recherche `mytable`.
Tenez compte des différences de casses lorsque vous créez le filtre Amazon Redshift et que vous interrogez les données.
#### Création d’une intégration en majuscules
Lorsque vous créez une table sans indiquer le nom entre guillemets, la base de données Oracle enregistre le nom en majuscules dans le dictionnaire de données. Par exemple, vous pouvez créer `MYTABLE` à l’aide de l’une des instructions SQL suivantes.
```
CREATE TABLE REINVENT.MYTABLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reinvent.mytable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE REinvent.MyTable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reINVENT.MYtabLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Comme vous n’avez pas cité le nom de la table dans les instructions précédentes, la base de données Oracle enregistre le nom de l’objet en majuscules sous la forme `MYTABLE`.
Pour répliquer cette table sur Amazon Redshift, vous devez spécifier le nom en majuscules dans le filtre de données de votre commande `create-integration`. Le nom du filtre sans extraction, transformation ni chargement (sans ETL) et le nom du dictionnaire de données Oracle doivent correspondre.
```
aws rds create-integration \
--integration-name upperIntegration \
--data-filter "include: ORCL.REINVENT.MYTABLE" \
...
```
Par défaut, Amazon Redshift stocke les données en minuscules. Pour effectuer une requête `MYTABLE` dans la base de données répliquée dans Amazon Redshift, vous devez citer le nom en majuscules `MYTABLE` afin qu’il corresponde aux majuscules du dictionnaire de données Oracle.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
```
Les requêtes suivantes n’utilisent pas le mécanisme de citation. Ils renvoient tous une erreur, car ils recherchent une table Amazon Redshift nommée `mytable`, qui utilise le nom en minuscules par défaut, mais la table est nommée `MYTABLE` dans le dictionnaire de données Oracle.
```
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
SELECT * FROM targetdb1."REINVENT".mytable;
```
Les requêtes suivantes utilisent le mécanisme de citation pour spécifier un nom composé de majuscules et minuscules. Les requêtes renvoient toutes une erreur, car elles recherchent une table Amazon Redshift dont le nom n’est `MYTABLE`.
```
SELECT * FROM targetdb1."REINVENT"."MYtablE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."mytable";
```
#### Création d’une intégration en minuscules
Dans l’exemple alternatif suivant, vous utilisez des guillemets pour enregistrer le nom de la table en minuscules dans le dictionnaire de données Oracle. Vous créez `mytable` comme suit.
```
CREATE TABLE REINVENT."mytable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
La base de données Oracle enregistre le nom de la table `mytable` en minuscules. Pour répliquer cette table sur Amazon Redshift, vous devez spécifier le nom `mytable` en minuscules dans votre filtre de données sans extraction, transformation ni chargement (sans ETL).
```
aws rds create-integration \
--integration-name lowerIntegration \
--data-filter "include: ORCL.REINVENT.mytable" \
...
```
Lorsque vous interrogez cette table dans la base de données répliquée dans Amazon Redshift, vous pouvez spécifier le nom en minuscules `mytable`. La requête aboutit, car elle recherche une table nommée `mytable`, qui est le nom de la table dans le dictionnaire de données Oracle.
```
SELECT * FROM targetdb1."REINVENT".mytable;
```
Comme Amazon Redshift utilise par défaut les noms d’objets en minuscules, les requêtes suivantes réussissent également à trouver `mytable`.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
```
Les requêtes suivantes n’utilisent pas le mécanisme de citation pour le nom d’objet. Elles renvoient toutes une erreur, car elles recherchent une table Amazon Redshift dont le nom est différent de `mytable`.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."MYtablE";
```
#### Création d’une table avec intégration en casse mixte
Dans l’exemple suivant, vous utilisez des guillemets pour enregistrer le nom de la table en minuscules dans le dictionnaire de données Oracle. Vous créez `MyTable` comme suit.
```
CREATE TABLE REINVENT."MyTable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
La base de données Oracle stocke ce nom de table sous la forme `MyTable` avec une casse mixte. Pour répliquer cette table sur Amazon Redshift, vous devez spécifier le nom en casse mixte dans le filtre de données.
```
aws rds create-integration \
--integration-name mixedIntegration \
--data-filter "include: ORCL.REINVENT.MyTable" \
...
```
Lorsque vous interrogez cette table dans la base de données répliquée dans Amazon Redshift, vous devez spécifier le nom en casse mixte `MyTable` en mettant le nom d’objet entre guillemets.
```
SELECT * FROM targetdb1."REINVENT"."MyTable";
```
Comme Amazon Redshift utilise par défaut les noms d’objets en minuscules, les requêtes suivantes ne trouvent pas l’objet, car elles recherchent le nom en minuscules `mytable`.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".mytable;
```
**Note**
Vous ne pouvez pas utiliser d’expressions régulières dans la valeur du filtre pour le nom de base de données, le schéma ou le nom de table dans les intégrations RDS for Oracle.
## Ajout de filtres de données à une intégration
Vous pouvez configurer le filtrage des données à l'aide de l' AWS Management Console API AWS CLI, de, ou de l'API Amazon RDS.
**Important**
Si vous ajoutez un filtre après avoir créé une intégration, Amazon RDS le traite comme s’il avait toujours existé. Il supprime toutes les données de l’entrepôt de données cible qui ne correspondent pas aux nouveaux critères de filtrage et resynchronise toutes les tables concernées.
### Console RDS
**Pour ajouter des filtres de données à une intégration zéro ETL**
1. Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)l'adresse.
1. Dans le panneau de navigation de gauche, choisissez **Intégrations zéro ETL**. Sélectionnez l’intégration à laquelle vous souhaitez ajouter des filtres de données, puis choisissez **Modifier**.
1. Sous **Source**, ajoutez une ou plusieurs instructions `Include` et `Exclude`.
L’image suivante montre un exemple de filtres de données pour une intégration MySQL :
![\[Filtrage des données pour une intégration zéro ETL dans la console RDS\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/zero-etl-filter-data.png)
1. Lorsque vous êtes satisfait des modifications, choisissez **Continuer** et **Enregistrer les modifications**.
### AWS CLI
Pour ajouter des filtres de données à une intégration zéro ETL à l'aide de AWS CLI, appelez la commande [modify-integration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-integration.html). Outre l’identifiant d’intégration, spécifiez le paramètre `--data-filter` à l’aide d’une liste séparée par des virgules de filtres Maxwell `Include` et `Exclude`.
**Example**
L’exemple suivant ajoute des modèles de filtre à `my-integration`.
Pour Linux, macOS ou Unix :
```
aws rds modify-integration \
--integration-identifier my-integration \
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
Pour Windows :
```
aws rds modify-integration ^
--integration-identifier my-integration ^
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
### API RDS
Pour modifier une intégration zéro ETL à l'aide de l'API RDS, appelez l'[ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html)opération. Spécifiez l’identifiant d’intégration et fournissez une liste de modèles de filtre séparée par des virgules.
## Suppression des filtres de données d’une intégration
Lorsque vous supprimez un filtre de données d’une intégration, Amazon RDS réévalue les filtres restants comme si le filtre supprimé n’avait jamais existé. Il réplique ensuite toutes les données précédemment exclues qui répondent désormais aux critères dans l’entrepôt de données cible. Cela déclenche une resynchronisation de toutes les tables concernées.
# Ajouter des données à une base de données RDS source et les interroger
Pour finir de créer une intégration zéro ETL qui réplique les données d’Amazon RDS vers Amazon Redshift, vous devez créer une base de données dans la destination cible.
Pour les connections avec Amazon Redshift, connectez-vous à votre cluster ou groupe de travail Amazon Redshift et créez une base de données avec une référence à votre identifiant d’intégration. Ensuite, vous pouvez ajouter des données dans votre base de données RDS source afin qu’elles soient répliquées dans Amazon Redshift ou Amazon SageMaker.
**Topics**
+ [Création d’une base de données cible](#zero-etl.create-db)
+ [Ajout de données au cluster de bases de données source](#zero-etl.add-data-rds)
+ [Interrogation de vos données Amazon RDS dans Amazon Redshift](#zero-etl.query-data-redshift)
+ [Différences de type de données entre les bases de données RDS et Amazon Redshift](#zero-etl.data-type-mapping)
+ [Opérations DDL pour RDS pour PostgreSQL](#zero-etl.ddl-postgres)
## Création d’une base de données cible
Avant de pouvoir commencer à répliquer des données dans Amazon Redshift, après avoir créé une intégration, vous devez créer une base de données dans votre entrepôt de données cible. Cette base de données de doit inclure une référence à l’identifiant d’intégration. Vous pouvez utiliser la console Amazon Redshift ou l'éditeur de requête v2 pour créer la base de données.
Pour obtenir des instructions sur la création d'une base de données de destination, consultez [Création d'une base de données de destination dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
## Ajout de données au cluster de bases de données source
Après avoir configuré votre intégration, vous pouvez remplir la base de données RDS source avec les données que vous souhaitez répliquer dans votre entrepôt de données.
**Note**
Il existe des différences entre les types de données dans Amazon RDS et dans l’entrepôt d’analytique cible. Pour un tableau des mappages de types de données, consultez [Différences de type de données entre les bases de données RDS et Amazon Redshift](#zero-etl.data-type-mapping).
Tout d’abord, connectez-vous à la base de données source à l’aide du client MySQL de votre choix. Pour obtenir des instructions, veuillez consulter [Connexion à votre instance de base de données MySQL](USER_ConnectToInstance.md).
Ensuite, créez une table et insérez une ligne d'exemples de données.
**Important**
Assurez-vous que la table possède une clé primaire. Sinon, elle ne peut pas être répliquée vers l'entrepôt de données cible.
**RDS for MySQL**
L’exemple suivant utilise l’[utilitaire MySQL Workbench](https://dev.mysql.com/downloads/workbench/).
```
CREATE DATABASE my_db;
USE my_db;
CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS pour PostgreSQL**
L’exemple suivant utilise le terminal interactif PostgreSQL `[psql](https://www.postgresql.org/docs/current/app-psql.html)`. Lorsque vous vous connectez à la base de données, incluez le nom de la base de données que vous souhaitez répliquer.
```
psql -h mydatabase.123456789012.us-east-2.rds.amazonaws.com -p 5432 -U username -d named_db;
named_db=> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
named_db=> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS for Oracle**
L’exemple suivant utilise SQL\$1Plus pour vous connecter à votre base de données RDS for Oracle.
```
sqlplus 'user_name@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=dns_name)(PORT=port))(CONNECT_DATA=(SID=database_name)))'
SQL> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
SQL> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
## Interrogation de vos données Amazon RDS dans Amazon Redshift
Une fois que vous avez ajouté des données au cluster de bases de données Aurora, elles sont répliquées dans la base de données de destination et sont prêtes à être interrogées.
**Pour interroger les données répliquées**
1. Accédez à la console Amazon Redshift et choisissez **Éditeur de requête v2** dans le panneau de navigation de gauche.
1. Connectez-vous à votre cluster ou groupe de travail et choisissez votre base de données de destination (que vous avez créée à partir de l'intégration) dans le menu déroulant (**destination\$1database** dans cet exemple). Pour obtenir des instructions sur la création d'une base de données de destination, consultez [Création d'une base de données de destination dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
1. Utilisez une instruction SELECT pour interroger vos données. Dans cet exemple, vous pouvez exécuter la commande suivante pour sélectionner toutes les données de la table que vous avez créée dans la base de données RDS source :
```
SELECT * from my_db."books_table";
```
![\[Exécutez une instruction SELECT dans l’éditeur de requête. Le résultat est une seule ligne d’échantillons de données qui a été ajoutée à la base de données Amazon RDS.\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/zero-etl-redshift-editor.png)
+ `my_db` est le nom du schéma de base de données RDS.
+ `books_table` est le nom de la table RDS.
Vous pouvez également interroger les données à l’aide d’un client de ligne de commande : Par exemple :
```
destination_database=# select * from my_db."books_table";
ID | Title | Author | Copyright | Genre | txn_seq | txn_id
----+–------------+---------------+-------------+------------------------+----------+--------+
1 | The Shining | Stephen King | 1977 | Supernatural fiction | 2 | 12192
```
**Note**
Pour appliquer la sensibilité à la casse, utilisez des guillemets doubles (« ») pour les noms de schéma, de table et de colonne. Pour plus d'informations, consultez [enable\$1case\$1sensitive\$1identifier](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html).
## Différences de type de données entre les bases de données RDS et Amazon Redshift
Les tableaux suivants montrent les mappages des types de données RDS for MySQL, RDS pour PostgreSQL et RDS for Oracle avec les types de données de destination correspondants. *Amazon RDS ne prend actuellement en charge que ces types de données pour les intégrations zéro ETL*.
Si une table de votre base de données source inclut un type de données non pris en charge, la table est désynchronisée et n’est pas consommable par la destination cible. Le streaming de la source vers la cible se poursuit, mais le tableau contenant le type de données non pris en charge n'est pas disponible. Pour corriger la table et la mettre à disposition dans la destination cible, vous devez annuler manuellement la modification importante, puis actualiser l’intégration en exécutant `[ALTER DATABASE...INTEGRATION REFRESH](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html)`.
**Note**
Vous ne pouvez pas actualiser les intégrations zéro ETL à un Amazon SageMaker Lakehouse. Supprimez plutôt l’intégration et essayez de la créer à nouveau.
**Topics**
+ [RDS for MySQL](#zero-etl.data-type-mapping-mysql)
+ [RDS pour PostgreSQL](#zero-etl.data-type-mapping-postgres)
+ [RDS for Oracle](#zero-etl.data-type-mapping-oracle)
### RDS for MySQL
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS pour PostgreSQL
Les intégrations zéro ETL pour RDS pour PostgreSQL ne prennent pas en charge les types de données personnalisés ni les types de données créés par des extensions.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS for Oracle
**Types de données non pris en charge**
Les types de données RDS for Oracle suivants ne sont pas pris en charge par Amazon Redshift :
+ `ANYDATA`
+ `BFILE`
+ `REF`
+ `ROWID`
+ `UROWID`
+ `VARRAY`
+ `SDO_GEOMETRY`
+ Types de données définis par l'utilisateur
**Différences de type de données**
Le tableau suivant montre les différences de type de données qui affectent une intégration zéro ETL lorsque RDS for Oracle est la source et Amazon Redshift est la cible.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
## Opérations DDL pour RDS pour PostgreSQL
Amazon Redshift est dérivé de PostgreSQL. Il partage donc plusieurs fonctionnalités avec RDS pour PostgreSQL en raison de leur architecture PostgreSQL commune. Les intégrations zéro ETL tirent parti de ces similitudes pour rationaliser la réplication des données de RDS pour PostgreSQL vers Amazon Redshift, en mappant les bases de données par nom et en utilisant la base de données, le schéma et la structure de table partagés.
Tenez compte des points suivants lors de la gestion des intégrations zéro ETL RDS pour PostgreSQL :
+ L’isolation est gérée au niveau de la base de données.
+ La réplication s’effectue au niveau de la base de données.
+ Les bases de données RDS pour PostgreSQL sont mappées aux bases de données Amazon Redshift par leur nom, les données étant transmises à la base de données Redshift renommée correspondante si l’original est renommé.
Malgré leurs similitudes, Amazon Redshift et RDS pour PostgreSQL présentent des différences importantes. Les sections suivantes décrivent les réponses du système Amazon Redshift pour les opérations DDL courantes.
**Topics**
+ [Opérations de base de données](#zero-etl.ddl-postgres-database)
+ [Opérations de schéma](#zero-etl.ddl-postgres-schema)
+ [Opérations de table](#zero-etl.ddl-postgres-table)
### Opérations de base de données
Le tableau suivant présente les réponses du système aux opérations DDL de base de données.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Opérations de schéma
Le tableau suivant présente les réponses du système aux opérations DDL de schéma.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Opérations de table
Le tableau suivant présente les réponses du système aux opérations DDL de table.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
# Affichage et surveillance des intégrations zéro ETL Amazon RDS
Vous pouvez afficher les détails d'une intégration zéro ETL d'Amazon RDS pour voir ses informations de configuration et son statut actuel. Vous pouvez également surveiller le statut de votre intégration en interrogeant des vues système spécifiques dans Amazon Redshift. En outre, Amazon Redshift publie certaines métriques liées à l'intégration sur Amazon CloudWatch, que vous pouvez consulter dans la console Amazon Redshift.
**Topics**
+ [Affichage des intégrations](#zero-etl.describing)
+ [Surveillance des intégrations à l’aide des tables système pour Amazon Redshift](#zero-etl.monitoring)
+ [Surveillance des intégrations avec Amazon EventBridge pour Amazon Redshift](#zero-etl.eventbridge)
## Affichage des intégrations
Vous pouvez consulter les intégrations Amazon RDS Zero-ETL à l'aide de l'API AWS Management Console, de ou de l' AWS CLI API RDS.
### Console
**Pour afficher les détails d’une intégration zéro ETL**
1. Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)l'adresse.
1. Dans le panneau de navigation de gauche, choisissez **Intégrations zéro ETL**.
1. Sélectionnez une intégration pour afficher plus de détails à son sujet, tels que sa base de données source et son entrepôt de données cible.
![\[Détails d'une intégration zéro ETL\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/zero-etl-integration-view.png)
Une intégration peut avoir les statuts suivants :
+ `Creating` : l'intégration est en cours de création.
+ `Active` : l’intégration envoie des données transactionnelles à l’entrepôt de données cible.
+ `Syncing` : l'intégration a rencontré une erreur récupérable et réensemence les données. Les tables concernées ne peuvent pas être interrogées tant que leur resynchronisation n’est pas terminée.
+ `Needs attention` : l’intégration a rencontré un événement ou une erreur nécessitant une intervention manuelle pour être résolu. Pour corriger le problème, suivez les instructions du message d'erreur dans la page des détails relatifs à l'intégration.
+ `Failed` : l'intégration a rencontré un événement ou une erreur irrécupérable qui ne peut pas être corrigé. Vous devez supprimer et recréer l'intégration.
+ `Deleting` : l’intégration est en cours de suppression.
### AWS CLI
Pour afficher toutes les intégrations Zero-ETL du compte courant à l'aide de AWS CLI, utilisez la commande [describe-integrations](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-integrations.html) et spécifiez l'option. `--integration-identifier`
**Example**
Pour Linux, macOS ou Unix :
```
aws rds describe-integrations \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Pour Windows :
```
aws rds describe-integrations ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
### API RDS
Pour afficher une intégration zéro ETL à l'aide de l'API Amazon RDS, utilisez l'opération [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html) avec le paramètre `IntegrationIdentifier`.
## Surveillance des intégrations à l’aide des tables système pour Amazon Redshift
Amazon Redshift comporte des tables et vues système contenant des informations sur le fonctionnement du système. Vous pouvez interroger ces tables et vues système de la même manière que vous interrogez toute autre table de base de données. Pour plus d’informations sur les vues et les tables système dans Amazon Redshift, consultez [Informations de référence sur les tables et les vues système](https://docs.aws.amazon.com//redshift/latest/dg/cm_chap_system-tables.html) dans le *Guide du développeur de base de données Amazon Redshift*.
Vous pouvez interroger les vues et tables système suivantes pour obtenir des informations sur vos intégrations zéro ETL :
+ [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html) : fournit les détails de configuration de vos intégrations.
+ [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) : décrit l'état de chaque table au sein d'une intégration.
+ [SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html) : affiche les journaux de changement d'état des tables pour une intégration.
+ [SYS\$1INTEGRATION\$1ACTIVITY](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html) : fournit des informations sur les cycles d'intégration terminés.
Toutes les CloudWatch métriques Amazon liées à l'intégration proviennent d'Amazon Redshift. Pour plus d’informations, consultez la section [Métriques pour les intégrations zéro ETL](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.monitoring.html) dans le *Guide de gestion Amazon Redshift*. Actuellement, Amazon RDS () ne publie aucune métrique d'intégration sur CloudWatch.
## Surveillance des intégrations avec Amazon EventBridge pour Amazon Redshift
Amazon Redshift envoie des événements liés à l'intégration à Amazon. EventBridge Pour obtenir la liste des événements et de l'événement correspondant IDs, consultez la section [Notifications d'événements d'intégration Zero-ETL avec Amazon EventBridge](https://docs.aws.amazon.com/redshift/latest/mgmt/integration-event-notifications) dans le guide de *gestion Amazon Redshift*.
# Modification des intégrations zéro ETL Amazon RDS
Vous pouvez uniquement modifier le nom, la description et les options de filtrage des données pour une intégration zéro ETL dans un entrepôt de données pris en charge. Vous ne pouvez pas modifier la clé AWS KMS utilisée pour chiffrer l’intégration, ni les bases de données source ou cible.
Si vous ajoutez un filtre de données à une intégration existante, Amazon RDS réévalue le filtre comme s’il avait toujours existé. Il supprime toutes les données qui se trouvent actuellement dans l’entrepôt de données cible et qui ne correspondent pas aux nouveaux critères de filtrage. Si vous *supprimez* un filtre de données d’une intégration, il réplique toutes les données qui ne répondaient pas auparavant aux critères de filtrage (mais qui le sont désormais) dans l’entrepôt de données cible. Pour plus d’informations, consultez [Filtrage des données pour les intégrations zéro ETL Amazon RDS](zero-etl.filtering.md).
Vous pouvez modifier une intégration zéro ETL à l’aide de la AWS Management Console, de l’AWS CLI ou de l’API Amazon RDS.
## Console RDS
**Pour modifier une intégration zéro ETL**
1. Connectez-vous à la AWS Management Console et ouvrez la console Amazon RDS à l’adresse [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Dans le panneau de navigation, choisissez **intégrations zéro ETL**, puis l’intégration que vous souhaitez modifier.
1. Choisissez **Modifier** et apportez des modifications aux paramètres disponibles.
1. Une fois que toutes les modifications correspondent à vos attentes, choisissez **Modifier**.
## AWS CLI
Pour modifier une intégration zéro ETL à l’aide de AWS CLI, appelez la commande [modify-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-integration.html). Avec `--integration-identifier`, spécifiez l’une des options suivantes :
+ `--integration-name` : spécifiez un nouveau nom pour l’intégration.
+ `--description` : spécifiez une nouvelle description pour l’intégration.
+ `--data-filter` : spécifiez les options de filtrage des données pour l’intégration. Pour plus d’informations, consultez [Filtrage des données pour les intégrations zéro ETL Amazon RDS](zero-etl.filtering.md).
**Example**
La demande suivante modifie une intégration existante.
Pour Linux, macOS ou Unix :
```
aws rds modify-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 \
--integration-name my-renamed-integration
```
Pour Windows :
```
aws rds modify-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 ^
--integration-name my-renamed-integration
```
## API RDS
Pour modifier une intégration zéro ETL à l’aide de l’API RDS, appelez l’opération [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html). Spécifiez l’identifiant d’intégration et les paramètres que vous souhaitez modifier.
# Suppression d’intégrations zéro ETL Amazon RDS
Lorsque vous supprimez une intégration zéro ETL, Amazon RDS la supprime de la base de données source. Vos données transactionnelles ne sont pas supprimées d’Amazon RDS ou de la destination d’analytique, mais Amazon RDS n’envoie pas de nouvelles données à Amazon Redshift ou Amazon SageMaker.
Vous ne pouvez supprimer une intégration que si son état est `Active`, `Failed`, `Syncing` ou `Needs attention`.
Vous pouvez supprimer l’intégration zéro ETL à l’aide de la AWS Management Console, de l’AWS CLI ou de l’API RDS.
## Console
**Pour supprimer une intégration zéro ETL**
1. Connectez-vous à la AWS Management Console et ouvrez la console Amazon RDS à l’adresse [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Dans le panneau de navigation de gauche, choisissez **Intégrations zéro ETL**.
1. Sélectionnez l’intégration zéro ETL que vous souhaitez supprimer.
1. Choisissez **Actions** et **Supprimer**, puis confirmez la suppression.
## AWS CLI
Pour supprimer une intégration zéro ETL, utilisez la commande [delete-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-integration.html) et spécifiez l’option `--integration-identifier`.
**Example**
Pour Linux, macOS ou Unix :
```
aws rds delete-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Pour Windows :
```
aws rds delete-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
## API RDS
Pour supprimer une intégration zéro ETL à l’aide de l’API Amazon RDS, utilisez l’opération [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html) avec le paramètre `IntegrationIdentifier`.
# Résolution des problèmes liés aux intégrations zéro ETL Amazon RDS
Vous pouvez vérifier l’état d’une intégration zéro ETL en interrogeant la table système [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html) dans la destination d’analytique. Si la valeur de la colonne `state` est `ErrorState`, cela signifie que quelque chose ne va pas. Pour de plus amples informations, veuillez consulter [Surveillance des intégrations à l’aide des tables système pour Amazon Redshift](zero-etl.describingmonitoring.md#zero-etl.monitoring).
Utilisez les informations suivantes pour résoudre les problèmes courants liés aux intégrations zéro ETL Amazon RDS.
**Important**
Les opérations de resynchronisation et d’actualisation ne sont pas disponibles pour les intégrations zéro ETL à un Amazon SageMaker AI Lakehouse. En cas de problème avec une intégration, vous devez la supprimer et en créer une nouvelle. Vous ne pouvez pas actualiser ou resynchroniser une intégration existante.
**Topics**
+ [Je ne parviens pas à créer une intégration zéro ETL](#zero-etl.troubleshooting.creation)
+ [Mon intégration est bloquée à l’état de `Syncing`](#zero-etl.troubleshooting.syncing)
+ [Mes tables ne sont pas répliquées sur Amazon Redshift](#zero-etl.troubleshooting.primarykey)
+ [Une ou plusieurs de mes tables Amazon Redshift nécessitent une resynchronisation](#zero-etl.troubleshooting.resync)
+ [Problèmes d'intégration pour les intégrations Amazon SageMaker AI Lakehouse Zero-ETL](#zero-etl.troubleshooting.integration-issues)
## Je ne parviens pas à créer une intégration zéro ETL
Si vous ne pouvez pas créer une intégration zéro ETL, assurez-vous que les points suivants sont corrects pour votre base de données source :
+ La base de données source doit exécuter une version de 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 zéro ETL Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ Vous avez correctement configuré les paramètres de la base de données. Si les paramètres requis ne sont pas définis correctement ou ne sont pas associés à la base de données, la création échoue. Consultez [Étape 1 : Création d’un groupe de paramètres données personnalisé](zero-etl.setting-up.md#zero-etl.parameters).
En outre, assurez-vous que les informations suivantes sont correctes pour votre entrepôt de données cible :
+ La sensibilité à la casse est activée. Consultez [Activation de la sensibilité à la casse pour votre entrepôt de données](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity).
+ Vous avez ajouté le principal autorisé et la source d'intégration appropriés. Consultez [Configuration de l’autorisation pour votre entrepôt de données Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam).
+ L’entrepôt de données est chiffré (s’il s’agit d’un cluster provisionné). Consultez [Chiffrement de base de données Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
## Mon intégration est bloquée à l’état de `Syncing`
Il est possible que votre intégration affiche systématiquement le statut `Syncing` si vous modifiez la valeur de l’un des paramètres de base de données requis.
Pour résoudre ce problème, vérifiez les valeurs des paramètres du groupe de paramètres associé à la base de données source et assurez-vous qu’elles correspondent aux valeurs requises. Pour de plus amples informations, veuillez consulter [Étape 1 : Création d’un groupe de paramètres données personnalisé](zero-etl.setting-up.md#zero-etl.parameters).
Si vous modifiez des paramètres, veillez à redémarrer la base de données pour appliquer les modifications.
## Mes tables ne sont pas répliquées sur Amazon Redshift
Si vous n’avez pas de table reflétée dans Amazon Redshift, vous pouvez exécuter la commande suivante pour les resynchroniser :
```
ALTER DATABASE dbname INTEGRATION REFRESH TABLES table1, table2;
```
Pour plus d’informations, consultez [ALTER DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html) dans la référence SQL Amazon Redshift.
Vos données ne sont peut-être pas répliquées, car une ou plusieurs de vos tables sources ne possèdent pas de clé primaire. Le tableau de bord de surveillance d’Amazon Redshift affiche l’état de ces tables comme `Failed` et l’état de l’intégration zéro ETL globale passe à `Needs attention`. Pour résoudre ce problème, vous pouvez identifier une clé existante dans votre table qui peut devenir une clé primaire, ou vous pouvez ajouter une clé primaire synthétique. Pour des solutions détaillées, consultez [Gestion des tables sans clés primaires lors de la création d’intégrations zéro ETL Amazon Aurora MySQL ou Amazon RDS for MySQL avec Amazon Redshift](https://aws.amazon.com/blogs/database/handle-tables-without-primary-keys-while-creating-amazon-aurora-mysql-or-amazon-rds-for-mysql-zero-etl-integrations-with-amazon-redshift/).
## Une ou plusieurs de mes tables Amazon Redshift nécessitent une resynchronisation
L’exécution de certaines commandes sur votre instance de base de données source peut nécessiter la resynchronisation de vos tables. Dans ce cas, la vue système [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) affiche un `table_state` de `ResyncRequired`, ce qui signifie que l'intégration doit complètement recharger les données de cette table spécifique depuis MySQL vers Amazon Redshift.
Lorsque la table commence à se resynchroniser, elle passe à l'état `Syncing`. Aucune action manuelle n'est requise pour resynchroniser une table. Pendant la resynchronisation des données d’une table, vous ne pouvez pas accéder à ces données dans Amazon Redshift.
Vous trouverez ci-dessous quelques exemples d'opérations permettant de mettre une table dans un état `ResyncRequired` et les alternatives possibles à envisager.
| Opération | Exemple | Autrement |
| --- | --- | --- |
| Ajout d'une colonne à une position spécifique | ALTER TABLE table_name
ADD COLUMN column_name INTEGER
NOT NULL first;
| Amazon Redshift ne prend pas en charge l'ajout de colonnes à des positions spécifiques à l'aide des mots clés first et after. Si l'ordre des colonnes de la table cible n'est pas critique, ajoutez la colonne à la fin de la table à l'aide d'une commande plus simple :ALTER TABLE table_name
ADD COLUMN column_name column_type;
|
| Ajout d'une colonne d'horodatage avec la valeur par défaut de CURRENT\$1TIMESTAMP | ALTER TABLE table_name
ADD COLUMN column_name TIMESTAMP
NOT NULL DEFAULT CURRENT_TIMESTAMP;
| La valeur CURRENT\$1TIMESTAMP pour les lignes de la table existante est calculée par RDS for MySQL et ne peut pas être simulée dans Amazon Redshift sans une resynchronisation complète des données de la table. Si possible, remplacez la valeur par défaut par une constante littérale comme `2023-01-01 00:00:15` afin d'éviter toute latence dans la disponibilité de la table. |
| Réalisation d'opérations sur plusieurs colonnes au sein d'une seule commande | ALTER TABLE table_name
ADD COLUMN column_1,
RENAME COLUMN column_2 TO column_3;
| Envisagez de diviser la commande en deux opérations distinctes, ADD et RENAME, qui ne nécessiteront pas de resynchronisation. |
## Problèmes d'intégration pour les intégrations Amazon SageMaker AI Lakehouse Zero-ETL
Si vous rencontrez des problèmes avec une intégration Zero-ETL existante avec un Amazon SageMaker AI lakehouse, la seule solution consiste à supprimer l'intégration et à en créer une nouvelle. Contrairement à d'autres AWS services, les intégrations Zero-ETL ne prennent pas en charge les opérations d'actualisation ou de resynchronisation.
Pour résoudre les problèmes d’intégration :
1. Supprimez l’intégration zéro ETL à l’aide de la console, de l’interface de ligne de commande ou de l’API.
1. Vérifiez que les configurations de la base de données source et de l’entrepôt de données cible sont correctes.
1. Créez une nouvelle intégration zéro ETL à la configuration identique ou mise à jour.
Ce processus entraîne une réinitialisation complète du pipeline de données, ce qui peut prendre du temps en fonction de la taille de votre base de données source.