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.
# Connexions Redshift
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans les tables des bases de données Amazon Redshift. Lors de la connexion aux bases de données Amazon Redshift, AWS Glue déplace les données via Amazon S3 pour atteindre un débit maximal, en utilisant le code SQL et les commandes Amazon Redshift. `COPY` `UNLOAD` Dans AWS Glue 4.0 et versions ultérieures, vous pouvez utiliser l'[intégration Amazon Redshift pour Apache Spark pour](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) lire et écrire avec des optimisations et des fonctionnalités spécifiques à Amazon Redshift, au-delà de celles disponibles lors de la connexion via les versions précédentes.
Découvrez comment AWS Glue facilite plus que jamais la migration des utilisateurs d'Amazon Redshift vers AWS Glue pour l'intégration des données sans serveur et l'ETL.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/ZapycBq8TKU)
## Configuration des connexions Redshift
Pour utiliser les clusters Amazon Redshift dans AWS Glue, vous devez remplir certaines conditions préalables :
+ Un répertoire Amazon S3 à utiliser pour le stockage temporaire lors de la lecture et de l'écriture dans la base de données.
+ Un Amazon VPC permettant la communication entre votre cluster Amazon Redshift, votre tâche AWS Glue et votre répertoire Amazon S3.
+ Autorisations IAM appropriées sur le job AWS Glue et le cluster Amazon Redshift.
### Configuration des rôles IAM
**Configurer le rôle pour le cluster Amazon Redshift**
Votre cluster Amazon Redshift doit être capable de lire et d'écrire sur Amazon S3 pour pouvoir s'intégrer aux tâches AWS Glue. Pour autoriser cela, vous pouvez associer des rôles IAM au cluster Amazon Redshift auquel vous souhaitez vous connecter. Votre rôle doit disposer d'une politique autorisant la lecture et l'écriture dans votre répertoire temporaire Amazon S3. Votre rôle doit avoir une relation de confiance permettant au service `redshift.amazonaws.com` de `AssumeRole`.
**Pour associer un rôle IAM à Amazon Redshift**
1. **Conditions préalables :** un compartiment ou un répertoire Amazon S3 utilisé pour le stockage temporaire de fichiers.
1. Identifiez les autorisations Amazon S3 dont votre cluster Amazon Redshift aura besoin. Lors du déplacement de données vers et depuis un cluster Amazon Redshift, les tâches AWS Glue émettent des instructions COPY et UNLOAD à l'encontre d'Amazon Redshift. Si votre tâche modifie une table dans Amazon Redshift, AWS Glue émettra également des instructions CREATE LIBRARY. Pour plus d'informations sur les autorisations Amazon S3 spécifiques requises pour qu'Amazon Redshift exécute ces instructions, consultez la documentation Amazon Redshift : [Amazon Redshift :](https://docs.aws.amazon.com/redshift/latest/dg/copy-usage_notes-access-permissions.html) Permissions to access other Resources. AWS
1. Dans la console IAM, créez une politique IAM avec les autorisations nécessaires. Pour plus d'informations sur la création de politiques, consultez [Création de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
1. Dans la console IAM, créez un rôle et une relation de confiance permettant à Amazon Redshift d'assumer ce rôle. Suivez les instructions de la documentation IAM [pour créer un rôle pour un AWS service (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console)
+ Lorsqu'on vous demande de choisir un cas d'utilisation du AWS service, choisissez « Redshift - Personnalisable ».
+ Lorsque vous êtes invité à joindre une politique, choisissez celle que vous avez définie précédemment.
**Note**
Pour plus d'informations sur la configuration des rôles pour Amazon Redshift, consultez la section [Autoriser Amazon Redshift à accéder à d'autres AWS services en votre nom dans la](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) documentation Amazon Redshift.
1. Dans la console Amazon Redshift, associez le rôle à votre cluster Amazon Redshift. Suivez les instructions de la [documentation Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html).
Sélectionnez l'option en surbrillance dans la console Amazon Redshift pour configurer ce paramètre :
![\[Un exemple de l'endroit où gérer les autorisations IAM dans la console Amazon Redshift.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/RS-role-config.png)
**Note**
Par défaut, les tâches AWS Glue transmettent les informations d'identification temporaires Amazon Redshift créées à l'aide du rôle que vous avez spécifié pour exécuter la tâche. Nous vous déconseillons d'utiliser ces informations d'identification. Pour des raisons de sécurité, ces informations d'identification expirent au bout d'une heure.
**Configuration du rôle pour la tâche AWS Glue**
La tâche AWS Glue a besoin d'un rôle pour accéder au compartiment Amazon S3. Vous n'avez pas besoin d'autorisations IAM pour le cluster Amazon Redshift. Votre accès est contrôlé par la connectivité dans Amazon VPC et par les informations d'identification de votre base de données.
### Configurer Amazon VPC
**Pour configurer l'accès pour les magasins de données Amazon Redshift**
1. Connectez-vous à la console Amazon Redshift AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)
1. Dans le volet de navigation de gauche, choisissez **Clusters**.
1. Choisissez le nom du cluster auquel vous souhaitez accéder à partir d'AWS Glue.
1. Dans la section **Cluster Properties (Propriétés du cluster)**, choisissez un groupe de sécurité dans **VPC security groups (Groupes de sécurité VPC)** afin de permettre à AWS Glue de l'utiliser. Enregistrez le nom du groupe de sécurité que vous avez choisi pour référence ultérieure. Lorsque vous choisissez le groupe de sécurité, la liste des **groupes de sécurité** de la console Amazon EC2 s'ouvre.
1. Choisissez le groupe de sécurité à modifier et accédez à l'onglet **Inbound** (Entrant).
1. Ajoutez une règle avec référence circulaire afin de permettre aux composants AWS Glue de communiquer. Plus spécifiquement, ajoutez ou confirmez qu'il existe une règle **Type** `All TCP`, que **Protocol** (Protocole) est `TCP`, que **Port Range** (Plage de ports) comprend tous les ports et que la valeur de **Source** est le même nom de groupe de sécurité que la valeur de **Group ID** (ID du groupe).
La règle entrante ressemble à ce qui suit :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
Par exemple :
![\[Exemple de règle de trafic entrant avec référence circulaire.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/SetupSecurityGroup-Start.png)
1. Ajoutez également une règle pour le trafic sortant. Ouvrez le trafic sortant pour tous les ports, par exemple :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
Ou créez une règle avec référence circulaire où **Type** est `All TCP`, **Protocol (Protocole)** est `TCP`, **Port Range (Plage de ports)** comprend tous les ports et dont la valeur de **Destination** est le même nom de groupe de sécurité que la valeur de **Group ID (ID du groupe)**. Si vous utilisez un point de terminaison d'un VPC Amazon S3, ajoutez également une règle HTTPS pour l'accès à Amazon S3. Le *s3-prefix-list-id* est requis dans la règle du groupe de sécurité pour autoriser le trafic entre le VPC et le point de terminaison Amazon S3 VPC.
Par exemple :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
### Configurer AWS Glue
Vous devez créer une connexion AWS Glue Data Catalog qui fournit les informations de connexion Amazon VPC.
**Pour configurer la connectivité Amazon Redshift entre Amazon VPC et Glue dans la console AWS**
1. Créez une connexion au catalogue de données en suivant les étapes décrites dans :[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour l'étape suivante. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez **Amazon Redshift**.
+ Lorsque vous sélectionnez un **cluster Redshift**, sélectionnez le nom de votre cluster.
+ Fournissez les informations de connexion par défaut pour un utilisateur Amazon Redshift sur votre cluster.
+ Vos paramètres Amazon VPC seront automatiquement configurés.
**Note**
Vous devrez fournir `PhysicalConnectionRequirements` manuellement pour votre Amazon VPC lorsque vous créez une connexion **Amazon Redshift** via le kit AWS SDK.
1. Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
## Exemple : lecture à partir de tables Amazon Redshift
Vous pouvez lire à partir de clusters Amazon Redshift et des environnements Amazon Redshift sans serveur.
**Conditions préalables :** une table Amazon Redshift à partir de laquelle vous souhaitez lire. Suivez les étapes décrites dans la section précédente, [Configuration des connexions Redshift](#aws-glue-programming-etl-connect-redshift-configure) après quoi vous devriez avoir l'URI Amazon S3 pour un répertoire temporaire *temp-s3-dir* et un rôle IAM (dans le compte*role-account-id*). *rs-role-name*
------
#### [ Using the Data Catalog ]
**Conditions préalables supplémentaires :** une base de données et une table de catalogue de données pour la table Amazon Redshift à partir de laquelle vous souhaitez lire. Pour plus d'informations sur le catalogue de données, consultez [Découverte et catalogage des données dans AWS Glue](catalog-and-crawler.md). Après avoir créé une entrée pour votre table Amazon Redshift, vous identifierez votre connexion à l'aide d'un *redshift-dc-database-name* et. *redshift-table-name*
**Configuration :** dans les options de votre fonction, vous identifierez votre table de catalogue de données avec les paramètres `database` et `table_name`. Vous identifierez votre répertoire temporaire Amazon S3 avec `redshift_tmp_dir`. Vous fournirez également *rs-role-name* en utilisant la `aws_iam_role` clé dans le `additional_options` paramètre.
```
glueContext.create_dynamic_frame.from_catalog(
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"})
```
------
#### [ Connecting directly ]
**Conditions préalables supplémentaires :** vous aurez besoin du nom de votre table Amazon Redshift (. *redshift-table-name* Vous aurez besoin des informations de connexion JDBC pour le cluster Amazon Redshift qui stocke cette table. Vous fournirez vos informations de connexion avec *host**port*,*redshift-database-name*, *username* et*password*.
Vous pouvez récupérer vos informations de connexion depuis la console Amazon Redshift lorsque vous travaillez avec des clusters Amazon Redshift. Pour l'utilisation d'Amazon Redshift sans serveur, consultez [Connexion à Amazon Redshift sans serveur](https://docs.aws.amazon.com//redshift/latest/mgmt/serverless-connecting.html) dans la documentation Amazon Redshift.
**Configuration :** dans les options de votre fonction, vous identifierez vos paramètres de connexions avec `url`, `dbtable`, `user` et `password`. Vous identifierez votre répertoire temporaire Amazon S3 avec `redshift_tmp_dir`. Vous pouvez spécifier votre rôle IAM en utilisant `aws_iam_role` lorsque vous utilisez `from_options`. La syntaxe est similaire à celle de la connexion via le catalogue de données, mais vous placez les paramètres sur la carte `connection_options`.
C'est une mauvaise pratique de coder en dur les mots de passe dans les scripts AWS Glue. Envisagez de stocker vos mots de passe AWS Secrets Manager et de les récupérer dans votre script avec le SDK for Python (Boto3).
```
my_conn_options = {
"url": "jdbc:redshift://host:port/redshift-database-name",
"dbtable": "redshift-table-name",
"user": "username",
"password": "password",
"redshiftTmpDir": args["temp-s3-dir"],
"aws_iam_role": "arn:aws:iam::account id:role/rs-role-name"
}
df = glueContext.create_dynamic_frame.from_options("redshift", my_conn_options)
```
------
## Exemple : écrire sur des tables Amazon Redshift
Vous pouvez sur des clusters Amazon Redshift et des environnements Amazon Redshift sans serveur.
**Conditions préalables :** un cluster Amazon Redshift et suivez les étapes de la [Configuration des connexions Redshift](#aws-glue-programming-etl-connect-redshift-configure) section précédente, après quoi vous devriez avoir l'URI Amazon S3 pour un répertoire temporaire et un rôle IAM*temp-s3-dir*,*rs-role-name*, (dans le compte). *role-account-id* Vous aurez également besoin d'un `DynamicFrame` dont vous souhaitez écrire le contenu dans la base de données.
------
#### [ Using the Data Catalog ]
**Conditions préalables supplémentaires :** une base de données de catalogue de données pour le cluster Amazon Redshift et la table sur laquelle vous souhaitez écrire. Pour plus d'informations sur le catalogue de données, consultez [Découverte et catalogage des données dans AWS Glue](catalog-and-crawler.md). Vous allez identifier votre connexion avec *redshift-dc-database-name* et la table cible avec*redshift-table-name*.
**Configuration :** dans les options de votre fonction, vous identifierez votre base de données de catalogue de données avec les paramètres `database`, puis vous fournirez votre table avec `table_name`. Vous identifierez votre répertoire temporaire Amazon S3 avec `redshift_tmp_dir`. Vous fournirez également *rs-role-name* en utilisant la `aws_iam_role` clé dans le `additional_options` paramètre.
```
glueContext.write_dynamic_frame.from_catalog(
frame = input dynamic frame,
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::account-id:role/rs-role-name"})
```
------
#### [ Connecting through a AWS Glue connection ]
Vous pouvez vous connecter directement à Amazon Redshift à l'aide de la méthode `write_dynamic_frame.from_options`. Toutefois, plutôt que d'insérer vos informations de connexion directement dans votre script, vous pouvez référencer les informations de connexion stockés dans une connexion au catalogue de données à l'aide de la méthode `from_jdbc_conf`. Vous pouvez le faire sans indexation de site web ou sans créer de tables de catalogue de données pour votre base de données. Pour plus d'informations sur les connexions au catalogue de données, consultez [Connexion aux données](glue-connections.md).
**Conditions préalables supplémentaires :** une base au catalogue de données pour votre base de données, une table Amazon Redshift à partir de laquelle vous souhaitez lire.
**Configuration :** vous allez identifier votre connexion au catalogue de données avec*dc-connection-name*. Vous identifierez votre base de données et votre table Amazon Redshift avec *redshift-table-name* et. *redshift-database-name* Vous fournirez les informations de connexion à votre catalogue de données avec `catalog_connection` et vos informations Amazon Redshift avec `dbtable` et `database`. La syntaxe est similaire à celle de la connexion via le catalogue de données, mais vous placez les paramètres sur la carte `connection_options`.
```
my_conn_options = {
"dbtable": "redshift-table-name",
"database": "redshift-database-name",
"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"
}
glueContext.write_dynamic_frame.from_jdbc_conf(
frame = input dynamic frame,
catalog_connection = "dc-connection-name",
connection_options = my_conn_options,
redshift_tmp_dir = args["temp-s3-dir"])
```
------
## Référence des options de connexion Amazon Redshift
Les options de connexion de base utilisées pour toutes les connexions JDBC AWS Glue afin de configurer des informations telles que`url`, `user` et `password` sont cohérentes entre tous les types de JDBC. Pour plus d'informations sur les paramètres JDBC standards, consultez [Référence des options de connexion JDBC](aws-glue-programming-etl-connect-jdbc-home.md#aws-glue-programming-etl-connect-jdbc).
Le type de connexion Amazon Redshift propose des options de connexion supplémentaires :
+ `"redshiftTmpDir"` : (obligatoire) chemin Amazon S3 où les données temporaires peuvent être stockées lors de la copie à partir de la base de données.
+ `"aws_iam_role"` : (facultatif) ARN pour un rôle IAM. La tâche AWS Glue transmettra ce rôle au cluster Amazon Redshift pour accorder au cluster les autorisations nécessaires pour exécuter les instructions de la tâche.
### Options de connexion supplémentaires disponibles dans AWS Glue 4.0\$1
Vous pouvez également transmettre les options du nouveau connecteur Amazon Redshift via les options de connexion AWS Glue. Pour obtenir la liste complète des options de connecteur prises en charge, consultez la section relative aux *paramètres SQL de Spark* dans [Intégration Amazon Redshift pour Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html).
Pour vous faciliter la tâche, nous vous rappelons ici certaines nouvelles options :
| Nom | Obligatoire | Par défaut | Description |
| --- | --- | --- | --- |
| autopushdown | Non | TRUE | Applique le pushdown des prédicats et des requêtes en capturant et en analysant les plans logiques de Spark pour les opérations SQL. Les opérations sont traduites en une requête SQL, puis exécutées dans Amazon Redshift pour améliorer les performances. |
| autopushdown.s3\$1result\$1cache | Non | FALSE | Met en cache la requête SQL pour décharger les données du mappage des chemins Amazon S3 en mémoire, afin que la même requête n'ait pas besoin de s'exécuter à nouveau dans la même session Spark. Pris en charge uniquement lorsqu'`autopushdown` est activé. |
| unload\$1s3\$1format | Non | PARQUET | PARQUET : décharge les résultats de la requête au format Parquet. TEXTE : décharge les résultats de la requête séparés par une barre verticale au format texte. |
| sse\$1kms\$1key | Non | N/A | La clé AWS SSE-KMS à utiliser pour le chiffrement pendant les `UNLOAD` opérations au lieu du chiffrement par défaut pour. AWS |
| extracopyoptions | Non | N/A | Une liste d'options supplémentaires à ajouter à la commande `COPY` d'Amazon Redshift lors du chargement de données, telles que `TRUNCATECOLUMNS` ou `MAXERROR n` (pour en savoir plus sur les autres options, voir [COPY : paramètres facultatifs](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax-overview-optional-parameters)). Notez que ces options étant ajoutées à la fin de la commande `COPY`, seules des options qui ont du sens peuvent être utilisées à la fin de la commande. Cela devrait couvrir la plupart des cas d'utilisation possibles. |
| csvnullstring (expérimental) | Non | NULL | La valeur de chaîne à écrire pour les valeurs nulles lors de l'utilisation du `tempformat` CSV. Il doit s'agir d'une valeur qui n'apparaît pas dans vos données réelles. |
Ces nouveaux paramètres peuvent être utilisés comme suit.
**Nouvelles options destinées à améliorer les performances**
Le nouveau connecteur intègre de nouvelles options d'amélioration des performances :
+ `autopushdown` : activée par défaut.
+ `autopushdown.s3_result_cache` : désactivée par défaut.
+ `unload_s3_format` : `PARQUET` par défaut.
Pour plus d'informations sur l'utilisation de ces options, consultez [Intégration Amazon Redshift pour Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). Nous vous recommandons de ne pas activer ` autopushdown.s3_result_cache` lorsque vous effectuez des opérations mixtes (lecture et écriture), car les résultats mis en cache peuvent contenir des informations périmées. L'option `unload_s3_format` est définie sur `PARQUET` par défaut pour la commande `UNLOAD`, afin d'améliorer les performances et de réduire les coûts de stockage. Pour utiliser le comportement par défaut de la commande `UNLOAD`, réinitialisez l'option sur `TEXT`.
**Nouvelle option de chiffrement pour la lecture**
Par défaut, les données du dossier temporaire que AWS Glue utilise lors de la lecture des données de la table Amazon Redshift sont chiffrées à l'aide du chiffrement `SSE-S3`. Pour utiliser les clés gérées par le client à partir de AWS Key Management Service (AWS KMS) pour chiffrer vos données, vous pouvez définir d'`("sse_kms_key" → kmsKey)`où KSMKey est l'[ID de clé AWS KMS, au lieu de](https://docs.aws.amazon.com/kms/latest/developerguide/find-cmk-id-arn.html) l'ancienne option `("extraunloadoptions" → s"ENCRYPTED KMS_KEY_ID '$kmsKey'")` de configuration de la version 3.0. AWS Glue
```
datasource0 = glueContext.create_dynamic_frame.from_catalog(
database = "database-name",
table_name = "table-name",
redshift_tmp_dir = args["TempDir"],
additional_options = {"sse_kms_key":""},
transformation_ctx = "datasource0"
)
```
**Prise en charge de l'URL JDBC basée sur IAM**
Le nouveau connecteur prend en charge une URL JDBC basée sur IAM, vous n'avez donc pas besoin de transmettre un code secret. user/password Avec une URL JDBC basée sur IAM, le connecteur utilise le rôle d'exécution des tâches pour accéder à la source de données Amazon Redshift.
Étape 1 : associez la politique minimale requise suivante à votre rôle d'exécution de tâches AWS Glue.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "redshift:GetClusterCredentials",
"Resource": [
"arn:aws:redshift:us-east-1:111122223333:dbgroup:/*",
"arn:aws:redshift:*:111122223333:dbuser:*/*",
"arn:aws:redshift:us-east-1:111122223333:dbname:/"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "redshift:DescribeClusters",
"Resource": "*"
}
]
}
```
------
Étape 2 : utilisez l'URL JDBC basée sur IAM comme suit. Spécifiez une nouvelle option `DbUser` avec le nom d'utilisateur Amazon Redshift qui permet de vous connecter.
```
conn_options = {
// IAM-based JDBC URL
"url": "jdbc:redshift:iam://:/",
"dbtable": dbtable,
"redshiftTmpDir": redshiftTmpDir,
"aws_iam_role": aws_iam_role,
"DbUser": "" // required for IAM-based JDBC URL
}
redshift_write = glueContext.write_dynamic_frame.from_options(
frame=dyf,
connection_type="redshift",
connection_options=conn_options
)
redshift_read = glueContext.create_dynamic_frame.from_options(
connection_type="redshift",
connection_options=conn_options
)
```
**Note**
`DynamicFrame` ne prend actuellement en charge qu'une URL JDBC basée sur IAM avec un ` DbUser` dans le flux de travail `GlueContext.create_dynamic_frame.from_options`.
## Migration de AWS Glue version 3.0 vers la version 4.0
Dans AWS Glue 4.0, les tâches ETL ont accès à un nouveau connecteur Amazon Redshift Spark et à un nouveau pilote JDBC avec différentes options et configurations. Le nouveau connecteur et le nouveau pilote Amazon Redshift ont été conçus dans un souci de performance et garantissent la cohérence transactionnelle de vos données. Ces produits sont décrits dans la documentation Amazon Redshift. Pour en savoir plus, consultez :
+ [Intégration Amazon Redshift pour Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html)
+ [Pilote Amazon Redshift JDBC, version 2.1](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-download-driver.html)
**Restriction portant sur les noms et les identifiants des tables et des colonnes**
Concernant le nom de la table Redshift, les exigences du nouveau connecteur et du nouveau pilote Amazon Redshift Spark sont plus restreintes. Pour plus d'informations, consultez la section [Noms et identifiants](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) qui explique comment définir le nom de votre table Amazon Redshift. Le flux de travail des signets de tâches peut ne pas fonctionner avec un nom de table non conforme aux règles et avec certains caractères (l'espace, par exemple).
Si vous utilisez d'anciennes tables dont les noms ne sont pas conformes aux règles relatives aux [noms et identifiants](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) et que vous rencontrez des problèmes liés aux signets (tâches dédiées au retraitement des données d'anciennes tables Amazon Redshift), nous vous recommandons de renommer vos tables. Pour plus d'informations, consultez les [exemples d'utilisation de la commande ALTER TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_TABLE_examples_basic.html).
**Modification de tempformat par défaut dans le Dataframe**
Le connecteur Spark de AWS Glue version 3.0 définit par défaut le `tempformat` sur CSV lors de l'écriture dans Amazon Redshift. Par souci de cohérence, dans AWS Glue version 3.0, ` DynamicFrame` définit toujours par défaut le `tempformat` de manière à utiliser le format `CSV`. Si vous avez déjà utilisé Spark Dataframe APIs directement avec le connecteur Amazon Redshift Spark, vous pouvez définir explicitement le format CSV dans `tempformat` `DataframeReader` les options/. `Writer` Sinon, `tempformat` est défini par défaut sur `AVRO` dans le nouveau connecteur Spark.
**Changement de comportement : mapper le type de données Amazon Redshift REAL sur le type de données FLOAT de Spark au lieu de DOUBLE**
Dans AWS Glue version 3.0, Amazon Redshift `REAL` est converti en type ` DOUBLE` de Spark. Le nouveau connecteur Amazon Redshift Spark a mis à jour le comportement afin que le type Amazon Redshift ` REAL` soit converti en type `FLOAT` de Spark et inversement. Si, conformément à un ancien cas d'utilisation, vous souhaitez toujours que le type `REAL` Amazon Redshift soit mappé sur un type Spark `DOUBLE`, vous pouvez utiliser la solution alternative suivante :
+ Pour un `DynamicFrame`, mappez le type `Float` sur un type `Double` avec `DynamicFrame.ApplyMapping`. Pour un `Dataframe`, vous devez utiliser `cast`.
Exemple de code :
```
dyf_cast = dyf.apply_mapping([('a', 'long', 'a', 'long'), ('b', 'float', 'b', 'double')])
```
**Gestion du type de données VARBYTE**
Lorsque vous travaillez avec les types de données AWS Glue 3.0 et Amazon Redshift, AWS Glue 3.0 convertit Amazon `VARBYTE` Redshift en type Spark. `STRING` Cependant, le dernier connecteur Amazon Redshift Spark ne prend pas en charge le type de données `VARBYTE`. Pour contourner cette restriction, vous pouvez [créer une vue Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_VIEW.html) qui transforme les colonnes `VARBYTE` en type de données compatible. Utilisez ensuite le nouveau connecteur pour charger les données à partir de cette vue au lieu de la table d’origine, ce qui garantit la compatibilité tout en maintenant l’accès à vos données `VARBYTE`.
Exemple de requête Redshift :
```
CREATE VIEW view_name AS SELECT FROM_VARBYTE(varbyte_column, 'hex') FROM table_name
```