Amazon Glue

Un service ETL sans serveur qui simplifie la préparation et le chargement des données pour l'analyse, avec découverte automatique des schémas.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'Amazon Glue ?

Imaginez que vous ayez des données provenant de différentes sources et stockées dans divers formats. Avant de pouvoir les analyser efficacement, vous devez les collecter, les nettoyer et les uniformiser. C'est exactement ce que fait Amazon Glue.

Amazon Glue est un service qui automatise le processus ETL (Extraction, Transformation, Chargement) de vos données. Il découvre vos données, les catalogue, les transforme et les prépare pour l'analyse, sans que vous ayez besoin de gérer une infrastructure.

Pourquoi utiliser Glue ?

Automatisation

Automatise la découverte, la transformation et la préparation des données, vous libérant des tâches manuelles fastidieuses.

Analyse simplifiée

Prépare vos données pour l'analyse en les convertissant dans des formats optimisés qui facilitent l'extraction d'insights métier.

En résumé, Glue agit comme un assistant intelligent qui s'occupe des aspects techniques complexes de la préparation des données, vous permettant de vous concentrer sur l'analyse et la valorisation de ces informations pour votre entreprise.

Pour les développeurs

Fonctionnement technique

Amazon Glue est un service ETL sans serveur qui facilite la découverte, la préparation et la combinaison des données pour l'analyse, le machine learning et le développement d'applications.

Composants principaux

Data Catalog

Référentiel central de métadonnées qui stocke les informations structurelles sur les données dans différentes sources. Il maintient les schémas, les statistiques et la localisation des données.

Intégration avec Lake Formation pour la gouvernance des données
Compatible avec le Hive Metastore pour l'intégration avec Spark, Hive et Presto
Interface avec Amazon Athena pour les requêtes SQL

Crawlers

Automatisent la découverte et le catalogage des métadonnées de vos données. Les crawlers parcourent vos sources de données, détectent les schémas et remplissent le Data Catalog.

Définition d'un Crawler avec AWS CDK

// Définition d'un Crawler avec AWS CDK
const { Stack, Duration } = require('aws-cdk-lib');
const { Role, ServicePrincipal, ManagedPolicy } = require('aws-cdk-lib/aws-iam');
const { CfnCrawler } = require('aws-cdk-lib/aws-glue');
const { Bucket } = require('aws-cdk-lib/aws-s3');

class DataLakeStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Bucket S3 qui contiendra les données brutes
    const rawDataBucket = new Bucket(this, 'RawDataBucket', {
      bucketName: 'my-company-raw-data'
    });

    // Rôle IAM pour le crawler Glue
    const glueRole = new Role(this, 'GlueServiceRole', {
      assumedBy: new ServicePrincipal('glue.amazonaws.com'),
      managedPolicies: [
        ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole')
      ]
    });
    
    // Ajouter les permissions pour S3
    rawDataBucket.grantRead(glueRole);
    
    // Définition du crawler Glue
    const crawler = new CfnCrawler(this, 'SalesDataCrawler', {
      name: 'sales-data-crawler',
      role: glueRole.roleArn,
      databaseName: 'sales_db',
      targets: {
        s3Targets: [
          {
            path: 's3://' + rawDataBucket.bucketName + '/sales/'
          }
        ]
      },
      schedule: {
        scheduleExpression: 'cron(0 0 * * ? *)'  // Exécution quotidienne à minuit
      },
      tablePrefix: 'raw_',
      schemaChangePolicy: {
        updateBehavior: 'UPDATE_IN_DATABASE',
        deleteBehavior: 'DELETE_FROM_DATABASE'
      },
      configuration: JSON.stringify({
        Version: 1.0,
        CrawlerOutput: {
          Partitions: { AddOrUpdateBehavior: 'InheritFromTable' },
          Tables: { AddOrUpdateBehavior: 'MergeNewColumns' }
        }
      })
    });
  }
}

Jobs ETL

Tâches qui exécutent le code nécessaire pour extraire les données de leurs sources, les transformer et les charger dans leurs destinations. Les jobs Glue utilisent Apache Spark sous le capot.

Création d'un Job ETL avec le SDK AWS

// Définition d'un Job ETL Glue avec AWS SDK
const { GlueClient, CreateJobCommand } = require('@aws-sdk/client-glue');

// Créer un client Glue
const glueClient = new GlueClient({ region: 'eu-west-1' });

async function createGlueJob() {
  const params = {
    Name: 'sales-data-transformation',
    Description: 'Transforme les données de ventes brutes en format optimisé pour l'analyse',
    Role: 'arn:aws:iam::123456789012:role/GlueServiceRole',
    ExecutionProperty: {
      MaxConcurrentRuns: 1
    },
    Command: {
      Name: 'glueetl',  // Utilise le service ETL de Glue
      ScriptLocation: 's3://my-company-glue-scripts/sales-transformation.py',
      PythonVersion: '3'
    },
    DefaultArguments: {
      '--job-language': 'python',
      '--job-bookmark-option': 'job-bookmark-enable',
      '--enable-metrics': '',
      '--enable-continuous-cloudwatch-log': 'true',
      '--source-database': 'sales_db',
      '--source-table': 'raw_sales_data',
      '--target-bucket': 'my-company-analytics-data',
      '--target-prefix': 'processed/sales/'
    },
    MaxRetries: 2,
    Timeout: 60,  // 60 minutes
    GlueVersion: '2.0',
    NumberOfWorkers: 5,
    WorkerType: 'G.1X'  // 1 DPU (4 vCPU, 16 Go) par worker
  };

  try {
    const data = await glueClient.send(new CreateJobCommand(params));
    console.log('Job créé avec succès, nom:', params.Name);
    return data;
  } catch (err) {
    console.error('Erreur lors de la création du job:', err);
    throw err;
  }
}

Scripts ETL

Le code qui définit la logique de transformation. Glue génère automatiquement des scripts Python ou Scala, que vous pouvez personnaliser.

Script Python ETL pour Glue

# Script Glue ETL pour transformer les données de ventes
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from pyspark.sql import functions as F
from pyspark.sql.types import *

# Initialisation du contexte Glue
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)

# Récupération des paramètres
args = getResolvedOptions(sys.argv, [
    'JOB_NAME',
    'source-database',
    'source-table',
    'target-bucket',
    'target-prefix'
])

job.init(args['JOB_NAME'], args)

# Extraction - Lecture des données source depuis le catalogue Glue
source_dyf = glueContext.create_dynamic_frame.from_catalog(
    database=args['source-database'],
    table_name=args['source-table'],
    transformation_ctx='source_dyf'
)

# Afficher le schéma des données source
print("Schéma des données source:")
print(source_dyf.printSchema())

# Transformation - Nettoyage et enrichissement des données
# 1. Supprimer les colonnes inutiles
sourceDf = source_dyf.toDF()
filteredDf = sourceDf.drop('_corrupt_record', 'notes')

# 2. Réaliser des transformations métier
transformedDf = filteredDf    .withColumn('total_amount', F.col('price') * F.col('quantity'))    .withColumn('date_formatted', F.to_date(F.col('transaction_date'), 'yyyy-MM-dd'))    .withColumn('year', F.year(F.col('date_formatted')))    .withColumn('month', F.month(F.col('date_formatted')))    .withColumn('day', F.dayofmonth(F.col('date_formatted')))    .filter(F.col('total_amount') > 0)  # Éliminer les transactions négatives ou nulles

# 3. Agrégation pour analytique
aggregatedDf = transformedDf.groupBy('product_id', 'year', 'month')    .agg(
        F.sum('total_amount').alias('monthly_revenue'),
        F.sum('quantity').alias('monthly_units_sold'),
        F.avg('price').alias('average_price'),
        F.countDistinct('customer_id').alias('unique_customers')
    )

# Conversion en DynamicFrame pour écriture
transformed_dyf = DynamicFrame.fromDF(aggregatedDf, glueContext, 'transformed_dyf')

# Chargement - Écriture des données transformées au format Parquet
output_path = f"s3://{args['target-bucket']}/{args['target-prefix']}"

# Partitionnement des données par année et mois
glueContext.write_dynamic_frame.from_options(
    frame=transformed_dyf,
    connection_type="s3",
    connection_options={
        "path": output_path,
        "partitionKeys": ["year", "month"]
    },
    format="parquet",
    transformation_ctx="output_data"
)

job.commit()

Déclencheurs (Triggers)

Mécanismes qui démarrent les jobs ETL selon différentes conditions : planification, événements ou à la demande.

Déclenchement d'un job Glue à la demande

// Déclenchement d'un job Glue via AWS SDK
const { GlueClient, StartJobRunCommand } = require('@aws-sdk/client-glue');

// Créer un client Glue
const glueClient = new GlueClient({ region: 'eu-west-1' });

async function triggerGlueJob() {
  const params = {
    JobName: 'sales-data-transformation',
    Arguments: {
      '--data-source': 's3://my-company-raw-data/sales/2023/05/', // Paramètre spécifique à cette exécution
      '--execution-date': new Date().toISOString()
    }
  };

  try {
    const data = await glueClient.send(new StartJobRunCommand(params));
    console.log('Job démarré avec succès, ID d'exécution:', data.JobRunId);
    return data.JobRunId;
  } catch (err) {
    console.error('Erreur lors du démarrage du job:', err);
    throw err;
  }
}

Caractéristiques techniques

Sans serveur - Aucune infrastructure à gérer, facturation à la seconde
Évolutivité automatique - Adapte les ressources en fonction de la charge de travail
Basé sur Apache Spark - Exploite la puissance du traitement distribué
Support de plusieurs sources et destinations - Compatible avec S3, RDS, DynamoDB, Redshift, et bien d'autres
Gestion automatique des dépendances - Bibliothèques et environnements gérés
Intégration native - Fonctionne de manière transparente avec d'autres services AWS
Support des bookmarks - Traite uniquement les nouvelles données depuis la dernière exécution

Applications concrètes

Cas d'usage

Construction de lacs de données

Création et alimentation de lacs de données S3 avec catalogage automatique, permettant l'analyse avec Athena, Redshift Spectrum ou EMR.

Chargement d'entrepôts de données

Transformation et chargement régulier de données dans Amazon Redshift pour l'analyse d'entreprise et le reporting.

Préparation de données pour le ML

Nettoyage, normalisation et enrichissement des données pour les rendre exploitables par les algorithmes de machine learning comme AWS Bedrock et AWS Comprehend.