Simplifiez et accélérez les applications Apache Spark sur les données Amazon Redshift avec l'intégration Amazon Redshift pour Apache Spark

Les clients utilisent Redshift d'Amazon pour exécuter leurs analyses critiques sur des pétaoctets de données structurées et semi-structurées. Apache Spark est un framework populaire que vous pouvez utiliser pour créer des applications pour des cas d'utilisation tels que l'ETL (extraction, transformation et chargement), l'analyse interactive et l'apprentissage automatique (ML). Apache Spark vous permet de créer des applications dans divers langages, tels que Java, Scala et Python, en accédant aux données de votre entrepôt de données Amazon Redshift.

L'intégration d'Amazon Redshift pour Apache Spark aide les développeurs à créer et exécuter de manière transparente des applications Apache Spark sur les données Amazon Redshift. Les développeurs peuvent utiliser AWS Analytics et les services ML tels que Amazon DME, Colle AWSet Amazon Sage Maker pour créer sans effort des applications Apache Spark qui lisent et écrivent dans leur entrepôt de données Amazon Redshift. Vous pouvez le faire sans compromettre les performances de vos applications ou la cohérence transactionnelle de vos données.

Dans cet article, nous expliquons pourquoi l'intégration d'Amazon Redshift pour Apache Spark est essentielle et efficace pour l'analyse et le ML. En outre, nous discutons des cas d'utilisation qui utilisent l'intégration d'Amazon Redshift avec Apache Spark pour générer un impact commercial. Enfin, nous vous expliquons étape par étape comment utiliser ce connecteur AWS officiel dans une application Apache Spark.

Intégration Amazon Redshift pour Apache Spark

L'intégration d'Amazon Redshift pour Apache Spark minimise le processus fastidieux et souvent manuel de configuration d'un connecteur spark-redshift (version communautaire) et raccourcit le temps nécessaire à la préparation des tâches d'analyse et de ML. Il vous suffit de spécifier la connexion à votre entrepôt de données et vous pouvez commencer à travailler avec les données Amazon Redshift à partir de vos applications basées sur Apache Spark en quelques minutes.

Vous pouvez utiliser plusieurs fonctionnalités de refoulement pour des opérations telles que les fonctions de tri, d'agrégation, de limitation, de jointure et scalaire afin que seules les données pertinentes soient déplacées de votre entrepôt de données Amazon Redshift vers l'application Apache Spark consommatrice. Cela vous permet d'améliorer les performances de vos applications. Les administrateurs Amazon Redshift peuvent facilement identifier le SQL généré à partir des applications basées sur Spark. Dans cet article, nous montrons comment vous pouvez trouver le SQL généré par le travail Apache Spark.

De plus, l'intégration d'Amazon Redshift pour Apache Spark utilise le format de fichier Parquet lors de la mise en scène des données dans un répertoire temporaire. Amazon Redshift utilise l'instruction SQL UNLOAD pour stocker ces données temporaires sur Service de stockage simple Amazon (Amazon S3). L'application Apache Spark récupère les résultats du répertoire temporaire (stocké au format de fichier Parquet), ce qui améliore les performances.

Vous pouvez également aider à rendre vos applications plus sécurisées en utilisant Gestion des identités et des accès AWS (IAM) des informations d'identification pour se connecter à Amazon Redshift.

L'intégration d'Amazon Redshift pour Apache Spark est basée sur le connecteur spark-redshift (version communautaire) et l'améliore en termes de performances et de sécurité, vous permettant d'obtenir des performances applicatives jusqu'à 10 fois plus rapides.

Cas d'utilisation pour l'intégration Amazon Redshift avec Apache Spark

Pour notre cas d'utilisation, la direction de l'entreprise axée sur les produits souhaite connaître les ventes de chaque produit sur plusieurs marchés. Comme les ventes de l'entreprise fluctuent de manière dynamique, il est devenu difficile pour la direction de suivre les ventes sur plusieurs marchés. Cependant, les ventes globales sont en baisse et la direction de l'entreprise veut savoir quels marchés ne fonctionnent pas afin de pouvoir cibler ces marchés pour des campagnes de promotion.

Pour les ventes sur plusieurs marchés, les données de vente de produits telles que les commandes, les transactions et les données d'expédition sont disponibles sur Amazon S3 dans le lac de données. L'équipe d'ingénierie des données peut utiliser Apache Spark avec Amazon EMR ou AWS Glue pour analyser ces données dans Amazon S3.

Les données d'inventaire sont disponibles dans Amazon Redshift. De même, l'équipe d'ingénierie des données peut analyser ces données avec Apache Spark à l'aide d'Amazon EMR ou d'une tâche AWS Glue en utilisant l'intégration Amazon Redshift pour Apache Spark afin d'effectuer des agrégations et des transformations. L'ensemble de données agrégé et transformé peut être stocké dans Amazon Redshift à l'aide de l'intégration Amazon Redshift pour Apache Spark.

L'utilisation d'un framework distribué comme Apache Spark avec l'intégration Amazon Redshift pour Apache Spark peut fournir la visibilité sur le lac de données et l'entrepôt de données pour générer des informations sur les ventes. Ces informations peuvent être mises à la disposition des parties prenantes et des utilisateurs métier d'Amazon Redshift afin de prendre des décisions éclairées pour exécuter des promotions ciblées pour les segments de marché à faible revenu.

De plus, nous pouvons utiliser l'intégration Amazon Redshift avec Apache Spark dans les cas d'utilisation suivants :

• Un client Amazon EMR ou AWS Glue exécutant des tâches Apache Spark souhaite transformer des données et les écrire dans Amazon Redshift dans le cadre de son pipeline ETL
• Un client ML utilise Apache Spark avec SageMaker pour l'ingénierie des fonctionnalités afin d'accéder aux données et de les transformer dans Amazon Redshift
• Un client Amazon EMR, AWS Glue ou SageMaker utilise Apache Spark pour une analyse de données interactive avec des données sur Amazon Redshift provenant de blocs-notes

Exemples d'intégration Amazon Redshift pour Apache Spark dans une application Apache Spark

Dans cet article, nous montrons les étapes pour connecter Amazon Redshift à partir d'Amazon EMR sur Cloud de calcul élastique Amazon (Amazon EC2), Amazon EMR sans serveuret AWS Glue à l'aide d'un script commun. Dans l'exemple de code suivant, nous générons un rapport indiquant les ventes trimestrielles pour l'année 2008. Pour ce faire, nous joignons deux tables Amazon Redshift à l'aide d'un Apache Spark DataFrame, exécutons un refoulement de prédicat, agrégeons et trions les données, et écrivons la transformée les données vers Amazon Redshift. Le script utilise PySpark

Le script utilise Authentification basée sur IAM pour Amazon Redshift. Les rôles IAM utilisés par Amazon EMR et AWS Glue doivent disposer des autorisations appropriées pour authentifier Amazon Redshift et accéder à un compartiment S3 pour le stockage temporaire des données.

L'exemple de stratégie suivant permet au rôle IAM d'appeler le GetClusterCredentials opérations:

{ "Version": "2012-10-17", "Statement": { "Effect": "Allow", "Action": "redshift:GetClusterCredentials", "Resource": "arn:aws:redshift:<aws_region_name>:xxxxxxxxxxxx:dbuser:*/temp_*" }
}

L'exemple de stratégie suivant autorise l'accès à un compartiment S3 pour le stockage de données temporaire :

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "s3:PutObject", "s3:GetObject", "s3:ListBucket" ], "Resource": "arn:aws:s3:::<s3_bucket_name>" } ]
}

Le script complet est le suivant :

from pyspark.sql import SparkSession
from pyspark.sql.functions import col # Initiate Apache Spark session
spark = SparkSession .builder .appName("SparkRedshiftConnector") .enableHiveSupport() .getOrCreate() # Set connection options for Amazon Redshift
jdbc_iam_url = "jdbc:redshift:iam://redshift-spark-connector-1.xxxxxxxxxxx.<aws_region_name>.redshift.amazonaws.com:5439/sample_data_dev"
temp_dir = 's3://<s3_bucket_name>/redshift-temp-dir/'
aws_role = 'arn:aws:iam::xxxxxxxxxxxx:role/redshift-s3' # Set query group for the query. More details on Amazon Redshift WLM https://docs.aws.amazon.com/redshift/latest/dg/cm-c-executing-queries.html
queryGroup = "emr-redshift"
jdbc_iam_url_withQueryGroup = jdbc_iam_url+'?queryGroup='+queryGroup # Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url_withQueryGroup+';user='+userName # Define the Amazon Redshift context
redshiftOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Create the sales DataFrame from Amazon Redshift table using io.github.spark_redshift_community.spark.redshift class
sales_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.sales") .load()
) # Create the date Data Frame from Amazon Redshift table
date_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.date") .load()
) # Assign a Data Frame to the above output which will be written back to Amazon Redshift
output_df= sales_df.join(date_df, sales_df.dateid == date_df.dateid, 'inner').where( col("year") == 2008).groupBy("qtr").sum("qtysold").select( col("qtr"), col("sum(qtysold)")).sort(["qtr"], ascending=[1]).withColumnRenamed("sum(qtysold)","total_quantity_sold") # Display the output
output_df.show() ## Lets drop the queryGroup for easy validation of push down queries
# Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url+'?user='+userName # Define the Amazon Redshift context
redshiftWriteOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Write the Data Frame back to Amazon Redshift
output_df.write .format("io.github.spark_redshift_community.spark.redshift") .mode("overwrite") .options(**redshiftWriteOptions) .option("dbtable", "tickit.test") .save()

Si vous envisagez d'utiliser le script précédent dans votre environnement, assurez-vous de remplacer les valeurs des variables suivantes par les valeurs appropriées pour votre environnement : jdbc_iam_url, temp_diret aws_role.

Dans la section suivante, nous passons en revue les étapes d'exécution de ce script pour agréger un exemple d'ensemble de données mis à disposition dans Amazon Redshift.

Pré-requis

Avant de commencer, assurez-vous que les conditions préalables suivantes sont remplies :

Déployer des ressources à l'aide d'AWS CloudFormation

Effectuez les étapes suivantes pour déployer la pile CloudFormation :

1. Connectez-vous à la Console de gestion AWS, puis lancez la pile CloudFormation :
   

Vous pouvez aussi vous télécharger le modèle CloudFormation pour créer les ressources mentionnées dans cet article via l'infrastructure en tant que code (IaC). Utilisez ce modèle lors du lancement d'une nouvelle pile CloudFormation.

2. Faites défiler vers le bas de la page pour sélectionner Je reconnais qu'AWS CloudFormation peut créer des ressources IAM sous Compétences, Puis choisissez Créer une pile.
   

Le processus de création de la pile prend 15 à 20 minutes. Le modèle CloudFormation crée les ressources suivantes :

• • Un Amazon VPC avec les sous-réseaux, les tables de routage et la passerelle NAT nécessaires
  • Un compartiment S3 portant le nom redshift-spark-databucket-xxxxxxx (notez que xxxxxxx est une chaîne aléatoire pour rendre le nom du compartiment unique)
  • Un cluster Amazon Redshift avec des exemples de données chargés dans la base de données dev et l'utilisateur principal redshiftmasteruser. Aux fins de cet article de blog, redshiftmasteruser avec des autorisations administratives est utilisé. Cependant, il est recommandé d'utiliser un utilisateur avec un contrôle d'accès précis dans l'environnement de production.
  • Un rôle IAM à utiliser pour Amazon Redshift avec la possibilité de demander des informations d'identification temporaires à partir de la base de données de développement du cluster Amazon Redshift
  • Amazon EMRStudio avec les rôles IAM nécessaires
  • Amazon EMR publie la version 6.9.0 sur un cluster EC2 avec les rôles IAM nécessaires
  • Une application Amazon EMR Serverless version 6.9.0
  • Une connexion AWS Glue et une tâche AWS Glue version 4.0
  • A Carnet Jupyter pour s'exécuter à l'aide d'Amazon EMR Studio à l'aide d'Amazon EMR sur un cluster EC2
  • Un script PySpark à exécuter avec Amazon EMR Studio et Amazon EMR Serverless

3. Une fois la création de la pile terminée, choisissez le nom de la pile redshift-spark et naviguer vers le Sortie

Nous utilisons ces valeurs de sortie plus loin dans cet article.

Dans les sections suivantes, nous montrons les étapes de l'intégration d'Amazon Redshift pour Apache Spark à partir d'Amazon EMR sur Amazon EC2, Amazon EMR sans serveur et AWS Glue.

Utiliser l'intégration Amazon Redshift avec Apache Spark sur Amazon EMR sur EC2

À partir de la version 6.9.0 et ultérieure d'Amazon EMR, le connecteur utilisant l'intégration Amazon Redshift pour Apache Spark et le pilote Amazon Redshift JDBC est disponible localement sur Amazon EMR. Ces fichiers se trouvent sous le /usr/share/aws/redshift/ annuaire. Cependant, dans les versions précédentes d'Amazon EMR, le Communautés version de l' spark-redshift connecteur est disponible.

L'exemple suivant montre comment connecter Amazon Redshift à l'aide d'un noyau PySpark via un Amazon EMRStudio carnet de notes. La pile CloudFormation a créé Amazon EMR Studio, Amazon EMR sur un cluster EC2 et un bloc-notes Jupyter disponible pour exécution. Pour parcourir cet exemple, procédez comme suit :

1. Téléchargez le notebook Jupyter mis à disposition dans le bucket S3 pour vous :
   • Dans les sorties de la pile CloudFormation, recherchez la valeur de EMRStudioNotebook, qui doit pointer vers redshift-spark-emr.ipynb ordinateur portable disponible dans le compartiment S3.
   • Choisissez le lien ou ouvrez le lien dans un nouvel onglet en copiant l'URL du bloc-notes.
   • Après avoir ouvert le lien, téléchargez le bloc-notes en choisissant Télécharger, qui enregistrera le fichier localement sur votre ordinateur.
     

2. Accédez à Amazon EMR Studio en choisissant ou en copiant le lien fourni dans les sorties de la pile CloudFormation pour la clé EMRStudioURL.
3. Dans le volet de navigation, choisissez Espaces de travail.
   
4. Selectionnez Créer un espace de travail.
   
5. Indiquez un nom pour l'espace de travail, par exemple redshift-spark.
6. Élargir la Configuration avancée section et sélectionnez Attacher Workspace à un cluster EMR.
7. Sous Attacher à un cluster EMR, choisissez le cluster EMR portant le nom emrCluster-Redshift-Spark.
8. Selectionnez Créer un espace de travail.
   
9. Une fois l'espace de travail Amazon EMR Studio créé et à l'état Attaché, vous pouvez accéder à l'espace de travail en choisissant le nom de l'espace de travail.

Cela devrait ouvrir l'espace de travail dans un nouvel onglet. Notez que si vous avez un bloqueur de pop-up, vous devrez peut-être autoriser l'espace de travail à ouvrir ou désactiver le bloqueur de pop-up.

Dans l'espace de travail Amazon EMR Studio, nous chargeons maintenant le bloc-notes Jupyter que nous avons téléchargé précédemment.

10. Selectionnez Téléchargement pour parcourir votre système de fichiers local et télécharger le bloc-notes Jupyter (redshift-spark-emr.ipynb).
    
11. Choisissez (double-clic) le redshift-spark-emr.ipynb bloc-notes dans l'espace de travail pour ouvrir le bloc-notes.
    

Le bloc-notes fournit les détails des différentes tâches qu'il effectue. A noter que dans la rubrique Définir les variables à connecter au cluster Amazon Redshift, vous n'avez pas besoin de mettre à jour les valeurs pour jdbc_iam_url, temp_diret aws_role car ceux-ci sont mis à jour pour vous par AWS CloudFormation. AWS CloudFormation a également effectué les étapes mentionnées dans le Pré-requis section du cahier.

Vous pouvez maintenant commencer à exécuter le notebook.

12. Exécutez les cellules individuelles en les sélectionnant, puis en choisissant Jouez.

Vous pouvez également utiliser la combinaison de touches de Maj + Entrée or Maj+Retour. Alternativement, vous pouvez exécuter toutes les cellules en choisissant Exécuter toutes les cellules sur le Courir menu.

13. Recherchez l'opération de refoulement de prédicat effectuée sur le cluster Amazon Redshift par l'intégration Amazon Redshift pour Apache Spark.

On peut également voir les données temporaires stockées sur Amazon S3 au format Parquet optimisé. La sortie peut être vue en exécutant la cellule dans la section Obtenir la dernière requête exécutée sur Amazon Redshift.

14. Pour valider la table créée par la tâche à partir d'Amazon EMR sur Amazon EC2, accédez à la console Amazon Redshift et choisissez le cluster redshift-spark-redshift-cluster sur le Tableau de bord des clusters provisionnés .
    
15. Dans les détails du cluster, sur le Données de requête menu, choisissez Requête dans l'éditeur de requête v2.
    
16. Choisissez le cluster dans le volet de navigation et connectez-vous au cluster Amazon Redshift lorsqu'il demande une authentification.
17. Sélectionnez Identifiants temporaires.
18. Pour Base de données, Entrer dev.
19. Pour nom d'utilisateur, Entrer redshiftmasteruser.
20. Selectionnez Épargnez.
    
21. Dans le volet de navigation, développez le cluster redshift-spark-redshift-cluster, développez la base de données de développement, développez tickit, et développez Tables pour lister toutes les tables à l'intérieur du schéma tickit.

Vous devriez trouver le tableau test_emr.

22. Choisissez (clic droit) le tableau test_emr, Puis choisissez Sélectionnez une table pour interroger la table.
    
23. Selectionnez Courir pour exécuter l'instruction SQL.
    

Utiliser l'intégration Amazon Redshift avec Apache Spark sur Amazon EMR Serverless

La version 6.9.0 et ultérieure d'Amazon EMR fournit l'intégration d'Amazon Redshift pour les fichiers JAR Apache Spark (géré par Amazon Redshift) et les fichiers JAR Amazon Redshift JDBC localement sur Amazon EMR sans serveur également. Ces fichiers se trouvent sous le /usr/share/aws/redshift/ annuaire. Dans l'exemple suivant, nous utilisons le script Python mis à disposition dans le compartiment S3 par la pile CloudFormation que nous avons créée précédemment.

1. Dans les sorties de la pile CloudFormation, notez la valeur de EMRServerlessExecutionScript, qui correspond à l'emplacement du script Python dans le compartiment S3.
2. Notez également la valeur de EMRServerlessJobExecutionRole, qui est le rôle IAM à utiliser avec l'exécution de la tâche sans serveur Amazon EMR.
3. Accédez à Amazon EMR Studio en choisissant ou en copiant le lien fourni dans les sorties de la pile CloudFormation pour la clé EMRStudioURL.
4. Selectionnez Applications sous Sans serveur dans le volet de navigation.
   

Vous trouverez une application EMR créée par la pile CloudFormation avec le nom emr-spark-redshift.

5. Choisissez le nom de l'application pour soumettre un travail.
   
6. Selectionnez Soumettre le travail.
   
7. Sous Détails du poste, Pour Nom, entrez un nom identifiable pour le travail.
8. Pour Rôle d'exécution, choisissez le rôle IAM que vous avez noté précédemment dans la sortie de la pile CloudFormation.
9. Pour Emplacement des scripts, fournissez le chemin d'accès au script Python que vous avez noté précédemment à partir de la sortie de la pile CloudFormation.
10. Agrandir la rubrique Propriétés de l'étincelle Et choisissez le Modifier dans le texte
11. Entrez la valeur suivante dans la zone de texte, qui fournit le chemin d'accès au redshift-connector, pilote Amazon Redshift JDBC, spark-avro JAR, et minimal-json Fichiers JAR :

    --jars /usr/share/aws/redshift/jdbc/RedshiftJDBC.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-redshift.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-avro.jar,/usr/share/aws/redshift/spark-redshift/lib/minimal-json.jar

    

12. Selectionnez Soumettre le travail.
13. Attendez que le travail soit terminé et que l'état d'exécution s'affiche comme en ligne.
14. Accédez à l'éditeur de requête Amazon Redshift pour voir si la table a été créée avec succès.
    
15. Vérifier les requêtes déroulantes exécutées pour le groupe de requêtes Amazon Redshift emr-serverless-redshift. Vous pouvez exécuter l'instruction SQL suivante sur la base de données dev:

    SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'emr-serverless-redshift' ORDER BY start_time DESC LIMIT 1

    

Vous pouvez voir que la requête déroulante et les résultats renvoyés sont stockés au format de fichier Parquet sur Amazon S3.

Utiliser l'intégration Amazon Redshift avec Apache Spark sur AWS Glue

À partir d'AWS Glue version 4.0 et ultérieure, les tâches Apache Spark se connectant à Amazon Redshift peuvent utiliser l'intégration Amazon Redshift pour Apache Spark et le pilote Amazon Redshift JDBC. Les tâches AWS Glue existantes qui utilisent déjà Amazon Redshift comme source ou cible peuvent être mises à niveau vers AWS Glue 4.0 pour tirer parti de ce nouveau connecteur. Le modèle CloudFormation fourni avec cette publication crée les ressources AWS Glue suivantes :

• Connexion AWS Glue pour Amazon Redshift – La connexion pour établir la connexion d'AWS Glue à Amazon Redshift à l'aide de l'intégration Amazon Redshift pour Apache Spark
• Rôle IAM attaché à la tâche AWS Glue – Le rôle IAM pour gérer les autorisations d'exécution de la tâche AWS Glue
• Tâche AWS Glue – Le script du travail AWS Glue effectuant des transformations et des agrégations à l'aide de l'intégration Amazon Redshift pour Apache Spark

L'exemple suivant utilise la connexion AWS Glue attachée à la tâche AWS Glue avec PySpark et comprend les étapes suivantes :

1. Sur la console AWS Glue, choisissez Connexions dans le volet de navigation.
   
2. Sous Connexions , choisissez la connexion AWS Glue pour Amazon Redshift créée par le modèle CloudFormation.
   
3. Vérifiez les détails de connexion.
   

Vous pouvez désormais réutiliser cette connexion au sein d'une tâche ou dans plusieurs tâches.

4. Sur le Connecteurs RF page, choisissez la tâche AWS Glue créée par la pile CloudFormation sous Vos emplois, ou accédez à la tâche AWS Glue en utilisant l'URL fournie pour la clé GlueJob dans la sortie de la pile CloudFormation.
   
5. Accédez au script de la tâche AWS Glue et vérifiez-le.
   
6. Sur le Détails du poste onglet, assurez-vous que Version colle est fixé à Colle 4.0.

Cela garantit que le travail utilise la dernière redshift-spark connecteur.

7. Développer vous Propriétés avancées et dans le Connexions , vérifiez que la connexion créée par la pile CloudFormation est attachée.
   
8. Vérifiez les paramètres de tâche ajoutés pour la tâche AWS Glue. Ces valeurs sont également disponibles dans la sortie de la pile CloudFormation.
   
9. Selectionnez Épargnez et alors Courir.

Vous pouvez afficher l'état de la tâche exécutée sur le Courir languette.

10. Une fois l'exécution de la tâche terminée, vous pouvez vérifier la sortie de la table test-glue créée par la tâche AWS Glue.
    
11. Nous vérifions les requêtes déroulantes exécutées pour le groupe de requêtes Amazon Redshift glue-redshift. Vous pouvez exécuter l'instruction SQL suivante sur la base de données dev:

    SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'glue-redshift' ORDER BY start_time DESC LIMIT 1

    

des pratiques d’excellence;

Gardez à l'esprit les bonnes pratiques suivantes :

• Envisagez d'utiliser l'intégration Amazon Redshift pour Apache Spark d'Amazon EMR au lieu d'utiliser le redshift-spark connecteur (version communautaire) pour vos nouveaux jobs Apache Spark.
• Si vous avez des travaux Apache Spark existants utilisant le redshift-spark connecteur (version communautaire), envisagez de les mettre à niveau pour utiliser l'intégration Amazon Redshift pour Apache Spark
• L'intégration Amazon Redshift pour Apache Spark applique automatiquement le refoulement des prédicats et des requêtes pour optimiser les performances. Nous vous recommandons d'utiliser les fonctions prises en charge (autopushdown) dans votre requête. L'intégration Amazon Redshift pour Apache Spark transformera la fonction en une requête SQL et exécutera la requête dans Amazon Redshift. Cette optimisation entraîne la récupération des données requises, afin qu'Apache Spark puisse traiter moins de données et avoir de meilleures performances.
  • Envisagez d'utiliser des fonctions de refoulement agrégées telles que avg, count, max, minet sum pour récupérer les données filtrées pour le traitement des données.
  • Envisagez d'utiliser des opérateurs de refoulement booléens comme in, isnull, isnotnull, contains, endswithet startswith pour récupérer les données filtrées pour le traitement des données.
  • Envisagez d'utiliser des opérateurs de refoulement logiques tels que and, oret not (ou !) pour récupérer les données filtrées pour le traitement des données.
• Il est recommandé de transmettre un rôle IAM à l'aide du paramètre aws_iam_role pour l'authentification Amazon Redshift depuis votre application Apache Spark sur Amazon EMR ou AWS Glue. Le rôle IAM doit disposer des autorisations nécessaires pour récupérer les informations d'identification IAM temporaires afin de s'authentifier auprès d'Amazon Redshift, comme indiqué dans la section « Exemples d'intégration Amazon Redshift pour Apache Spark dans une application Apache Spark » de ce blog.
• Avec cette fonctionnalité, vous n'avez pas besoin de conserver votre nom d'utilisateur et votre mot de passe Amazon Redshift dans le gestionnaire de secrets et la base de données Amazon Redshift.
• Amazon Redshift utilise l'instruction SQL UNLOAD pour stocker ces données temporaires sur Amazon S3. L'application Apache Spark récupère les résultats du répertoire temporaire (stocké au format de fichier Parquet). Ce répertoire temporaire sur Amazon S3 n'est pas nettoyé automatiquement et peut donc entraîner des coûts supplémentaires. Nous recommandons d'utiliser Politiques de cycle de vie Amazon S3 pour définir les règles de conservation pour le compartiment S3.
• Il est recommandé d'activer Journalisation d'audit Amazon Redshift pour enregistrer les informations sur les connexions et les activités des utilisateurs dans votre base de données.
• Il est recommandé d'activer Chiffrement au repos d'Amazon Redshift pour chiffrer vos données au fur et à mesure qu'Amazon Redshift les écrit dans ses centres de données et les déchiffrer pour vous lorsque vous y accédez.
• Il est recommandé de mettre à niveau vers AWS Glue v4.0 et versions ultérieures pour utiliser l'intégration Amazon Redshift pour Apache Spark, qui est disponible prête à l'emploi. La mise à niveau vers cette version d'AWS Glue utilisera automatiquement cette fonctionnalité.
• Il est recommandé de mettre à niveau vers Amazon EMR v6.9.0 et versions ultérieures pour utiliser l'intégration Amazon Redshift pour Apache Spark. Vous n'avez pas à gérer explicitement les pilotes ou les fichiers JAR.
• Envisagez d'utiliser des blocs-notes Amazon EMR Studio pour interagir avec vos données Amazon Redshift dans votre application Apache Spark.
• Envisagez d'utiliser AWS Glue Studio pour créer des tâches Apache Spark à l'aide d'une interface visuelle. Vous pouvez également passer à l'écriture de code Apache Spark dans Scala ou PySpark dans AWS Glue Studio.

Nettoyer

Effectuez les étapes suivantes pour nettoyer les ressources créées dans le cadre du modèle CloudFormation afin de vous assurer que vous n'êtes pas facturé pour les ressources si vous ne les utilisez plus :

1. Arrêtez l'application Amazon EMR Serverless :
   • Accédez à Amazon EMR Studio en choisissant ou en copiant le lien fourni dans les sorties de la pile CloudFormation pour la clé EMRStudioURL.
   • Selectionnez Applications sous Sans serveur dans le volet de navigation.
     

Vous trouverez une application EMR créée par la pile CloudFormation avec le nom emr-spark-redshift.

• • Si l'état de l'application indique Arrêté, vous pouvez passer aux étapes suivantes. Toutefois, si le statut de l'application est Démarré, choisissez le nom de l'application, puis choisissez Arrêter l'application ainsi que le Arrêter l'application encore une fois pour confirmer.

2. Supprimez l'espace de travail Amazon EMR Studio :
   • Accédez à Amazon EMR Studio en choisissant ou en copiant le lien fourni dans les sorties de la pile CloudFormation pour la clé EMRStudioURL.
   • Selectionnez Espaces de travail dans le volet de navigation.
     
   • Sélectionnez l'espace de travail que vous avez créé et choisissez Supprimer, Puis choisissez Supprimer encore une fois pour confirmer.
     
3. Supprimez la pile CloudFormation :

• • Sur la console AWS CloudFormation, accédez à la pile que vous avez créée précédemment.
  • Choisissez le nom de la pile, puis choisissez Supprimer pour supprimer la pile et supprimer les ressources créées dans le cadre de cet article.
  • Sur l'écran de confirmation, choisissez Supprimer la pile.
    

Conclusion

Dans cet article, nous avons expliqué comment vous pouvez utiliser l'intégration Amazon Redshift pour Apache Spark pour créer et déployer des applications avec Amazon EMR sur Amazon EC2, Amazon EMR Serverless et AWS Glue pour appliquer automatiquement le prédicat et le refoulement des requêtes afin d'optimiser les performances des requêtes pour les données. dans Amazon Redshift. Il est fortement recommandé d'utiliser l'intégration Amazon Redshift pour Apache Spark pour une connexion transparente et sécurisée à Amazon Redshift depuis votre Amazon EMR ou AWS Glue.

Voici ce que certains de nos clients ont à dire sur l'intégration d'Amazon Redshift pour Apache Spark :

« Nous donnons à nos ingénieurs les moyens de créer leurs pipelines de données et leurs applications avec Apache Spark en utilisant Python et Scala. Nous voulions une solution sur mesure qui simplifiait les opérations et livrait plus rapidement et plus efficacement à nos clients, et c'est ce que nous obtenons avec la nouvelle intégration Amazon Redshift pour Apache Spark.

—Consultation Huron

« GE Aerospace utilise AWS Analytics et Amazon Redshift pour obtenir des informations commerciales critiques qui conduisent à des décisions commerciales importantes. Grâce à la prise en charge de la copie automatique depuis Amazon S3, nous pouvons créer des pipelines de données plus simples pour déplacer les données d'Amazon S3 vers Amazon Redshift. Cela accélère la capacité de nos équipes de produits de données à accéder aux données et à fournir des informations aux utilisateurs finaux. Nous passons plus de temps à ajouter de la valeur grâce aux données et moins de temps aux intégrations. »

—GE Aérospatiale

« Notre objectif est de fournir un accès en libre-service aux données pour tous nos utilisateurs chez Goldman Sachs. Grâce à Legend, notre plateforme open source de gestion et de gouvernance des données, nous permettons aux utilisateurs de développer des applications centrées sur les données et d'obtenir des informations basées sur les données lors de notre collaboration dans le secteur des services financiers. Avec l'intégration d'Amazon Redshift pour Apache Spark, notre équipe de plateforme de données pourra accéder aux données d'Amazon Redshift avec un minimum d'étapes manuelles, permettant un ETL sans code qui augmentera notre capacité à permettre aux ingénieurs de se concentrer plus facilement sur le perfectionnement de leur flux de travail en tant que ils collectent des informations complètes et opportunes. Nous nous attendons à voir une amélioration des performances des applications et une sécurité améliorée, car nos utilisateurs peuvent désormais accéder facilement aux dernières données d'Amazon Redshift.

-Goldman Sachs

À propos des auteurs

Gagan Brahmi est un architecte de solutions spécialisé principal spécialisé dans l'analyse de données volumineuses et la plate-forme AI/ML chez Amazon Web Services. Gagan a plus de 18 ans d'expérience dans les technologies de l'information. Il aide les clients à concevoir et à créer des solutions basées sur le cloud hautement évolutives, performantes et sécurisées sur AWS. Dans ses temps libres, il passe du temps avec sa famille et explore de nouveaux endroits.

Vivek Gautam est un architecte de données spécialisé dans les lacs de données chez AWS Professional Services. Il travaille avec des entreprises clientes qui créent des produits de données, des plateformes d'analyse et des solutions sur AWS. Lorsqu'il ne construit pas et ne conçoit pas de lacs de données, Vivek est un passionné de gastronomie qui aime également explorer de nouvelles destinations de voyage et faire des randonnées.

Naresh Gautam est un leader de l'analyse de données et de l'IA/ML chez AWS avec 20 ans d'expérience, qui aime aider les clients à concevoir des solutions d'analyse de données et d'IA/ML hautement disponibles, performantes et rentables pour permettre aux clients de prendre des décisions basées sur les données . Pendant son temps libre, il aime méditer et cuisiner.

Beaux Sharifi est ingénieur en développement logiciel au sein de l'équipe de pilotes Amazon Redshift où il dirige le développement de l'intégration Amazon Redshift avec le connecteur Apache Spark. Il a plus de 20 ans d'expérience dans la création de plateformes axées sur les données dans plusieurs secteurs. Dans ses temps libres, il aime passer du temps avec sa famille et surfer.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• Platoblockchain. Intelligence métaverse Web3. Connaissance Amplifiée. Accéder ici.
• Frapper l'avenir avec Adryenn Ashley. Accéder ici.
• La source: https://aws.amazon.com/blogs/big-data/simplify-and-speed-up-apache-spark-applications-on-amazon-redshift-data-with-amazon-redshift-integration-for-apache-spark/