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.

Développement et test de scripts AWS de tâches Glue localement

Lorsque vous développez et testez vos scripts de travail AWS Glue for Spark, plusieurs options sont disponibles :

Vous pouvez choisir l'une des options ci-dessus en fonction de vos besoins.

Si vous préférez ne pas coder ou moins d'expérience en matière de code, l'éditeur visuel AWS Glue Studio est un bon choix.

Si vous préférez une expérience interactive, le bloc-notes AWS Glue Studio est un bon choix. Pour plus d'informations, consultez la section Utilisation de Notebooks avec AWS Glue Studio et AWS Glue. Si vous souhaitez utiliser votre propre environnement local, les sessions interactives constituent un bon choix. Pour plus d'informations, consultez la section Utilisation de sessions interactives avec AWS Glue.

Si vous préférez une expérience de développement local/à distance, l'image Docker est un bon choix. Cela vous permet de développer et de tester des scripts de travail AWS Glue for Spark où vous le souhaitez, sans encourir de frais liés à AWS Glue.

Si vous préférez le développement local sans Docker, l'installation du répertoire de la bibliothèque AWS Glue ETL localement est un bon choix.

Développement avec AWS Glue Studio

L'éditeur visuel AWS Glue Studio est une interface graphique qui facilite la création, l'exécution et le suivi de tâches d'extraction, de transformation et de chargement (ETL) dans AWS Glue. Vous pouvez composer visuellement des flux de travail de transformation des données et les exécuter de manière fluide sur le moteur AWS ETL sans serveur basé sur Apache Spark de Glue. Vous pouvez inspecter le schéma et les résultats des données à chaque étape de la tâche. Pour plus d'informations, consultez le guide de l'utilisateur de AWS Glue Studio.

Développement à l'aide de sessions interactives

Les sessions interactives vous permettent de créer et de tester des applications à partir de l'environnement de votre choix. Pour plus d'informations, consultez la section Utilisation de sessions interactives avec AWS Glue.

Développement à l'aide d'une image Docker

Pour une plate-forme de données prête pour la production, le processus de développement et le pipeline CI/CD pour les tâches AWS Glue constituent un sujet clé. Vous pouvez développer et tester des tâches AWS Glue de manière flexible dans un conteneur Docker. AWS Glue héberge des images Docker sur Docker Hub pour configurer votre environnement de développement avec des utilitaires supplémentaires. Vous pouvez utiliser votre IDE, bloc-notes ou REPL préféré à l'aide de la bibliothèque AWS Glue ETL. Cette rubrique explique comment développer et tester des jobs AWS Glue version 4.0 dans un conteneur Docker à l'aide d'une image Docker.

Les images Docker suivantes sont disponibles pour AWS Glue sur Docker Hub.

Ces images sont pour x86_64. Il est recommandé de tester sur cette architecture. Cependant, il peut être possible de retravailler une solution de développement locale sur des images de base non prises en charge.

Cet exemple décrit l'utilisation d'amazon/aws-glue-libs:glue_libs_4.0.0_image_01 et l'exécution du conteneur sur une machine locale. Cette image de conteneur a été testée pour une tâche Spark de AWS Glue version 3.3. Cette image contient les éléments suivants :

Complétez l'une des sections suivantes en fonction de vos besoins :

Prérequis

Avant de commencer, assurez-vous que Docker est installé et que le démon Docker est en cours d'exécution. Pour obtenir des instructions d'installation, consultez la documentation Docker pour Mac ou Linux. La machine qui exécute le Docker héberge le conteneur AWS Glue. Assurez-vous également que vous disposez d'au moins 7 Go d'espace disque pour l'image sur l'hôte exécutant Docker.

Pour plus d'informations sur les restrictions applicables au développement local du code AWS Glue, consultez la section Restrictions de développement locales.

Configuration AWS

Pour activer les appels AWS d'API depuis le conteneur, configurez les AWS informations d'identification en suivant les étapes suivantes. Dans les sections suivantes, nous utiliserons ce profil AWS nommé.

Vous devrez peut-être également définir la variable d' AWS_REGIONenvironnement pour spécifier Région AWS à qui envoyer les demandes.

Configuration et exécution du conteneur

La configuration du conteneur pour exécuter PySpark du code via la commande spark-submit inclut les étapes de haut niveau suivantes :

Extraction de l'image depuis Docker Hub

Exécutez la commande suivante pour extraire l'image de Docker Hub :

docker pull amazon/aws-glue-libs:glue_libs_4.0.0_image_01

Exécution du conteneur

Vous pouvez maintenant exécuter un conteneur en utilisant cette image. Vous pouvez choisir l'une des options suivantes en fonction de vos besoins.

spark-submit

Vous pouvez exécuter un script de tâche AWS Glue en exécutant la spark-submit commande sur le conteneur.

Shell REPL (Pyspark)

Vous pouvez exécuter le shell REPL (read-eval-print loops) pour le développement interactif.

Exécutez la commande suivante pour exécuter la PySpark commande sur le conteneur afin de démarrer le shell REPL :

$ docker run -it -v ~/.aws:/home/glue_user/.aws -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pyspark amazon/aws-glue-libs:glue_libs_4.0.0_image_01 pyspark
...
 ____ __
 / __/__ ___ _____/ /__
 _\ \/ _ \/ _ `/ __/ '_/
 /__ / .__/\_,_/_/ /_/\_\  version 3.1.1-amzn-0
 /_/

Using Python version 3.7.10 (default, Jun 3 2021 00:02:01)
Spark context Web UI available at http://56e99d000c99:4040
Spark context available as 'sc' (master = local[*], app id = local-1643011860812).
SparkSession available as 'spark'.
>>> 

Pytest

Pour les tests unitaires, vous pouvez utiliser pytest pour les scripts de travail AWS Glue Spark.

Exécutez les commandes suivantes pour la préparation.

$ WORKSPACE_LOCATION=/local_path_to_workspace
$ SCRIPT_FILE_NAME=sample.py
$ UNIT_TEST_FILE_NAME=test_sample.py
$ mkdir -p ${WORKSPACE_LOCATION}/tests
$ vim ${WORKSPACE_LOCATION}/tests/${UNIT_TEST_FILE_NAME}

Exécutez la commande suivante pour exécuter pytest sur la suite de tests :

$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pytest amazon/aws-glue-libs:glue_libs_4.0.0_image_01 -c "python3 -m pytest"
starting org.apache.spark.deploy.history.HistoryServer, logging to /home/glue_user/spark/logs/spark-glue_user-org.apache.spark.deploy.history.HistoryServer-1-5168f209bd78.out
*============================================================= test session starts =============================================================
*platform linux -- Python 3.7.10, pytest-6.2.3, py-1.11.0, pluggy-0.13.1
rootdir: /home/glue_user/workspace
plugins: anyio-3.4.0
*collected 1 item  *

tests/test_sample.py . [100%]

============================================================== warnings summary ===============================================================
tests/test_sample.py::test_counts
 /home/glue_user/spark/python/pyspark/sql/context.py:79: DeprecationWarning: Deprecated in 3.0.0. Use SparkSession.builder.getOrCreate() instead.
 DeprecationWarning)

-- Docs: https://docs.pytest.org/en/stable/warnings.html
======================================================== 1 passed, *1 warning* in 21.07s ========================================================

Jupyter Lab

Vous pouvez démarrer Jupyter pour le développement interactif et les requêtes ad-hoc sur des blocs-notes.

Configuration du conteneur pour utiliser Visual Studio Code

Prérequis :

Étapes :

Annexe : Exemple de code AWS Glue Job à tester

Cette annexe fournit des scripts sous forme d'exemple de code de tâche AWS Glue à des fins de test.

sample.py : exemple de code pour utiliser la bibliothèque ETL AWS Glue avec un appel d'API Amazon S3

import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions


class GluePythonSampleTest:
    def __init__(self):
        params = []
        if '--JOB_NAME' in sys.argv:
            params.append('JOB_NAME')
        args = getResolvedOptions(sys.argv, params)

        self.context = GlueContext(SparkContext.getOrCreate())
        self.job = Job(self.context)

        if 'JOB_NAME' in args:
            jobname = args['JOB_NAME']
        else:
            jobname = "test"
        self.job.init(jobname, args)

    def run(self):
        dyf = read_json(self.context, "s3://awsglue-datasets/examples/us-legislators/all/persons.json")
        dyf.printSchema()

        self.job.commit()


def read_json(glue_context, path):
    dynamicframe = glue_context.create_dynamic_frame.from_options(
        connection_type='s3',
        connection_options={
            'paths': [path],
            'recurse': True
        },
        format='json'
    )
    return dynamicframe


if __name__ == '__main__':
    GluePythonSampleTest().run()

Le code ci-dessus nécessite des autorisations Amazon S3 dans AWS IAM. Vous devez accorder la politique gérée IAM arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess ou une politique personnalisée IAM qui vous permet d'appeler ListBucket et GetObject pour le chemin Amazon S3.

test_sample.py : Exemple de code pour le test unitaire de sample.py.

import pytest
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
import sys
from src import sample


@pytest.fixture(scope="module", autouse=True)
def glue_context():
    sys.argv.append('--JOB_NAME')
    sys.argv.append('test_count')

    args = getResolvedOptions(sys.argv, ['JOB_NAME'])
    context = GlueContext(SparkContext.getOrCreate())
    job = Job(context)
    job.init(args['JOB_NAME'], args)

    yield(context)

    job.commit()


def test_counts(glue_context):
    dyf = sample.read_json(glue_context, "s3://awsglue-datasets/examples/us-legislators/all/persons.json")
    assert dyf.toDF().count() == 1961

Développement à l'aide de la bibliothèque ETL AWS Glue

La bibliothèque ETL AWS Glue est disponible dans un compartiment Amazon S3 public et peut être utilisée par le système de compilation Apache Maven. Cela vous permet de développer et de tester localement vos scripts ETL (extraction, transformation et chargement) Python et Scala sans avoir besoin de connexion réseau. Le développement local avec l’image Docker est recommandé, car il fournit un environnement correctement configuré pour l’utilisation de cette bibliothèque.

Le développement local est disponible pour toutes les versions de AWS Glue, y compris les versions 0.9, 1.0, 2.0 et ultérieures de AWS Glue. Pour plus d'informations sur les versions de Python et d'Apache Spark disponibles avec AWS Glue, consultez leGlue version job property.

La bibliothèque est publiée avec la licence Amazon Software (https://aws.amazon.com/asl).

Restrictions relatives au développement local

Tenez compte des restrictions suivantes lorsque vous utilisez la bibliothèque AWS Glue Scala pour développer localement.

Développement local avec Python

Effectuez certaines étapes préalables, puis utilisez les utilitaires AWS Glue pour tester et soumettre votre script ETL Python.

Prérequis pour le développement Python local

Procédez comme suit pour préparer un développement Python local :

Exécution de votre script ETL Python

Avec les fichiers jar AWS Glue disponibles pour le développement local, vous pouvez exécuter le package AWS Glue Python localement.

Utilisez les utilitaires et infrastructures suivants pour tester et exécuter votre script Python. Les commandes répertoriées dans le tableau suivant sont exécutées à partir du répertoire racine du package Python AWS Glue.

Développement local avec Scala

Exécutez certaines étapes prérequises, puis lancez une commande Maven pour exécuter localement votre script ETL Scala.

Prérequis pour le développement local Scala

Procédez comme suit pour vous préparer au développement local Scala.

Étape 1 : Installer le logiciel

Au cours de cette étape, vous installez le logiciel et définissez la variable d'environnement requise.

Étape 2 : Configurer votre projet Maven

Utilisez le fichier pom.xml suivant comme modèle pour vos applications Scala AWS Glue. Il contient les éléments dependencies, repositories et plugins requis. Remplacez la chaîne Glue version par l'une des actions suivantes :

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.amazonaws</groupId>
    <artifactId>AWSGlueApp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>${project.artifactId}</name>
    <description>AWS ETL application</description>

        <properties>
            <scala.version>2.11.1 for AWS Glue 2.0 or below, 2.12.7 for AWS Glue 3.0 and 4.0</scala.version>
            <glue.version>Glue version with three numbers (as mentioned earlier)</glue.version>
        </properties>
    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
			<!-- A "provided" dependency, this will be ignored when you package your application -->
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>AWSGlueETL</artifactId>
			<version>${glue.version}</version>
            <!-- A "provided" dependency, this will be ignored when you package your application -->
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <repositories>
        <repository>
            <id>aws-glue-etl-artifacts</id>
            <url>https://aws-glue-etl-artifacts.s3.amazonaws.com/release/</url>
        </repository>
    </repositories>
    <build>
        <sourceDirectory>src/main/scala</sourceDirectory>
        <plugins>
            <plugin>
                <!-- see http://davidb.github.com/scala-maven-plugin -->
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.4.0</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.6.0</version>
                <executions>
                    <execution>
                        <goals>
                        <goal>java</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                <systemProperties>
                    <systemProperty>
                        <key>spark.master</key>
                        <value>local[*]</value>
                    </systemProperty>
                    <systemProperty>
                        <key>spark.app.name</key>
                        <value>localrun</value>
                    </systemProperty>
                    <systemProperty>
                        <key>org.xerial.snappy.lib.name</key>
                        <value>libsnappyjava.jnilib</value>
                    </systemProperty>
                </systemProperties>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <version>3.0.0-M2</version>
                <executions>
                    <execution>
                        <id>enforce-maven</id>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <requireMavenVersion>
                                    <version>3.5.3</version>
                                </requireMavenVersion>
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
			<!-- The shade plugin will be helpful in building a uberjar or fatjar.
			You can use this jar in the AWS Glue runtime environment. For more information, see https://maven.apache.org/plugins/maven-shade-plugin/ -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <configuration>
                    <!-- any other shade configurations -->
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Exécution de votre script ETL Scala

Exécutez la commande suivante à partir du répertoire racine du projet Maven pour exécuter votre script ETL Scala.

mvn exec:java -Dexec.mainClass="mainClass" -Dexec.args="--JOB-NAME jobName"

Remplacez mainClass par le nom de classe complet de la classe principale du script. Remplacez jobName par le nom de tâche souhaité.

Configuration d'un environnement de test

Pour des exemples de configuration d'un environnement de test local, consultez les articles de blog suivants :

Si vous souhaitez utiliser des points de terminaison de développement ou des blocs-notes pour tester vos scripts ETL, consultez Développement de scripts à l'aide de points de terminaison de développement.