Comment utiliser les APIs EMR ?

En bref

Les API AWS EMR (Elastic MapReduce) gèrent des clusters de big data exécutant Hadoop, Spark, Hive et Presto. Vous créez des clusters, soumettez des tâches par étapes, auto-échelonnez en fonction de la charge de travail et terminez les clusters une fois le travail accompli. L'authentification utilise AWS IAM. Pour les tests, utilisez Apidog pour valider les configurations de cluster, tester les soumissions de tâches par rapport à la structure de l'API et documenter vos pipelines de données.

Introduction

AWS EMR est le service Hadoop/Spark géré sur AWS. Il traite des pétaoctets de données pour l'analyse, l'apprentissage automatique et les pipelines ETL. Au lieu de gérer votre propre cluster Hadoop, vous laissez AWS gérer l'infrastructure.

EMR s'exécute sur des instances EC2 au sein d'un cluster. Vous spécifiez :

Types d'instances (nœuds maître, cœur, tâche)
Applications (Spark, Hadoop, Hive, Presto, HBase)
Actions d'amorçage (scripts de configuration)
Étapes (tâches à exécuter)

L'API EMR vous permet d'automatiser tout cela. Vous pouvez créer des clusters par programme, soumettre des tâches, surveiller la progression et intégrer d'autres services AWS.

💡

Si vous construisez des pipelines de données, Apidog vous aide à tester les configurations de cluster, à valider les définitions de tâches et à documenter vos flux de travail EMR avant d'exécuter des tâches de traitement de données coûteuses.

bouton

Testez les API AWS avec Apidog - gratuit

À la fin de ce guide, vous serez en mesure de :

Créer et configurer des clusters EMR via l'API
Soumettre des tâches par étapes
Gérer l'auto-échelonnement
Surveiller l'état du cluster et la progression des tâches
Optimiser les coûts avec les flottes d'instances et les instances spot

Authentification avec AWS

EMR utilise l'authentification AWS standard avec IAM.

Approche AWS SDK (recommandée)

import { EMRClient, RunJobFlowCommand } from '@aws-sdk/client-emr'

const client = new EMRClient({
  region: 'us-east-1',
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
  }
})

API directe avec SigV4

EMR nécessite la version 4 de la signature AWS. Utilisez les SDK ou des outils comme boto3, AWS CLI, ou générez les signatures manuellement.

aws emr list-clusters --region us-east-1

Autorisations IAM

Politique minimale pour la gestion d'EMR :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "elasticmapreduce:*",
        "ec2:Describe*",
        "s3:GetObject",
        "s3:PutObject",
        "s3:DeleteObject",
        "s3:ListBucket"
      ],
      "Resource": "*"
    }
  ]
}

Création d'un cluster

Création de cluster de base

aws emr create-cluster \
  --name "My Spark Cluster" \
  --release-label emr-7.0.0 \
  --applications Name=Spark Name=Hadoop \
  --instance-type m5.xlarge \
  --instance-count 3 \
  --service-role EMR_DefaultRole \
  --job-flow-role EMR_EC2_DefaultRole

Via l'API (RunJobFlow)

{
  "Name": "Data Processing Cluster",
  "ReleaseLabel": "emr-7.0.0",
  "Applications": [
    { "Name": "Spark" },
    { "Name": "Hadoop" },
    { "Name": "Hive" }
  ],
  "Instances": {
    "MasterInstanceType": "m5.xlarge",
    "SlaveInstanceType": "m5.xlarge",
    "InstanceCount": 3,
    "KeepJobFlowAliveWhenNoSteps": true,
    "TerminationProtected": false
  },
  "Steps": [],
  "ServiceRole": "EMR_DefaultRole",
  "JobFlowRole": "EMR_EC2_DefaultRole",
  "LogUri": "s3://my-bucket/emr-logs/",
  "Tags": [
    { "Key": "Environment", "Value": "Production" }
  ]
}

Réponse :

{
  "JobFlowId": "j-ABC123DEF456"
}

Groupes d'instances vs flottes d'instances

Groupes d'instances : Types d'instances fixes par groupe (maître, cœur, tâche).

Flottes d'instances : Plusieurs types/options d'instances par groupe. EMR choisit en fonction de la disponibilité et du prix.

{
  "Instances": {
    "InstanceFleets": [
      {
        "Name": "MasterFleet",
        "InstanceFleetType": "MASTER",
        "TargetOnDemandCapacity": 1,
        "InstanceTypeConfigs": [
          {
            "InstanceType": "m5.xlarge"
          },
          {
            "InstanceType": "m4.xlarge"
          }
        ]
      },
      {
        "Name": "CoreFleet",
        "InstanceFleetType": "CORE",
        "TargetOnDemandCapacity": 2,
        "TargetSpotCapacity": 4,
        "InstanceTypeConfigs": [
          {
            "InstanceType": "m5.2xlarge"
          },
          {
            "InstanceType": "m4.2xlarge"
          }
        ],
        "LaunchSpecifications": {
          "SpotSpecification": {
            "TimeoutDurationMinutes": 60,
            "TimeoutAction": "SWITCH_TO_ON_DEMAND"
          }
        }
      }
    ]
  }
}

Soumission de tâches par étapes

EMR exécute les tâches sous forme d'« étapes » en séquence.

Ajouter une étape Spark

aws emr add-steps \
  --cluster-id j-ABC123DEF456 \
  --steps '[
    {
      "Name": "Process Data",
      "ActionOnFailure": "CONTINUE",
      "HadoopJarStep": {
        "Jar": "command-runner.jar",
        "Args": [
          "spark-submit",
          "--deploy-mode",
          "cluster",
          "--class",
          "com.example.DataProcessor",
          "s3://my-bucket/jars/processor.jar",
          "s3://my-bucket/input/",
          "s3://my-bucket/output/"
        ]
      }
    }
  ]'

Via l'API (AddJobFlowSteps)

{
  "JobFlowId": "j-ABC123DEF456",
  "Steps": [
    {
      "Name": "Spark ETL Job",
      "ActionOnFailure": "CONTINUE",
      "HadoopJarStep": {
        "Jar": "command-runner.jar",
        "Args": [
          "spark-submit",
          "--executor-memory",
          "4g",
          "--executor-cores",
          "2",
          "s3://my-bucket/scripts/process.py",
          "--input",
          "s3://my-bucket/input/",
          "--output",
          "s3://my-bucket/output/"
        ]
      }
    }
  ]
}

Options ActionOnFailure

TERMINATE_CLUSTER : Arrête le cluster en cas d'échec
CANCEL_AND_WAIT : Annule les étapes restantes, maintient le cluster en cours d'exécution
CONTINUE : Continue avec l'étape suivante

Étape Hive

{
  "Name": "Hive Query",
  "HadoopJarStep": {
    "Jar": "command-runner.jar",
    "Args": [
      "hive-script",
      "--run-hive-script",
      "--args",
      "-f",
      "s3://my-bucket/scripts/transform.q"
    ]
  }
}

Mise à l'échelle automatique

EMR peut ajouter/supprimer des nœuds de tâche en fonction de la charge.

Créer une politique de mise à l'échelle automatique

aws emr put-auto-scaling-policy \
  --cluster-id j-ABC123DEF456 \
  --instance-group-id ig-ABC123 \
  --auto-scaling-policy '{
    "Constraints": {
      "MinCapacity": 2,
      "MaxCapacity": 10
    },
    "Rules": [
      {
        "Name": "ScaleOut",
        "Description": "Add nodes when memory is high",
        "Action": {
          "SimpleScalingPolicyConfiguration": {
            "AdjustmentType": "CHANGE_IN_CAPACITY",
            "ScalingAdjustment": 2,
            "CoolDown": 300
          }
        },
        "Trigger": {
          "CloudWatchAlarmDefinition": {
            "ComparisonOperator": "GREATER_THAN",
            "EvaluationPeriods": 3,
            "MetricName": "MemoryAvailableMB",
            "Namespace": "AWS/ElasticMapReduce",
            "Period": 300,
            "Threshold": 2000,
            "Statistic": "AVERAGE"
          }
        }
      }
    ]
  }'

Métriques pour la mise à l'échelle

MemoryAvailableMB : Mémoire libre
MemoryTotalMB : Mémoire totale
HDFSUtilization : Espace HDFS utilisé
AppsRunning : Applications YARN en cours d'exécution
AppsPending : Applications YARN en attente

Surveillance et journalisation

Lister les clusters

aws emr list-clusters --states RUNNING

Décrire un cluster

aws emr describe-cluster --cluster-id j-ABC123DEF456

La réponse inclut :

{
  "Cluster": {
    "Id": "j-ABC123DEF456",
    "Name": "My Cluster",
    "Status": {
      "State": "RUNNING",
      "StateChangeReason": {},
      "Timeline": {
        "CreationDateTime": "2026-03-24T10:00:00.000Z"
      }
    },
    "Applications": [
      { "Name": "Spark", "Version": "3.5.0" }
    ],
    "InstanceCollectionType": "INSTANCE_GROUP",
    "LogUri": "s3://my-bucket/emr-logs/",
    "MasterPublicDnsName": "ec2-12-34-56-78.compute-1.amazonaws.com"
  }
}

Lister les étapes

aws emr list-steps --cluster-id j-ABC123DEF456

Statut de l'étape

{
  "Id": "s-ABC123",
  "Name": "Process Data",
  "Status": {
    "State": "COMPLETED",
    "Timeline": {
      "StartDateTime": "2026-03-24T10:05:00.000Z",
      "EndDateTime": "2026-03-24T11:30:00.000Z"
    }
  }
}

Intégration CloudWatch

EMR publie des métriques vers CloudWatch :

JobsFailed
JobsRunning
MemoryAvailableMB
MemoryTotalMB
HDFSUtilization

Optimisation des coûts

Utiliser les instances spot

Les nœuds de tâche sont parfaits pour les instances spot. S'ils sont arrêtés, la tâche continue sur les nœuds restants.

{
  "Name": "TaskGroup",
  "InstanceRole": "TASK",
  "InstanceType": "m5.2xlarge",
  "InstanceCount": 4,
  "Market": "SPOT",
  "BidPrice": "0.10"
}

Clusters transitoires

Créez des clusters, exécutez des tâches, terminez automatiquement :

{
  "KeepJobFlowAliveWhenNoSteps": false,
  "Steps": [
    { ... step 1 ... },
    { ... step 2 ... }
  ]
}

Le cluster se termine une fois toutes les étapes achevées.

Flottes d'instances avec plusieurs options

Laissez EMR choisir l'option la moins chère disponible :

{
  "InstanceTypeConfigs": [
    {
      "InstanceType": "m5.2xlarge",
      "BidPrice": "0.15"
    },
    {
      "InstanceType": "m4.2xlarge",
      "BidPrice": "0.12"
    },
    {
      "InstanceType": "c5.2xlarge",
      "BidPrice": "0.10"
    }
  ]
}

Test avec Apidog

Les clusters EMR sont coûteux. Testez soigneusement les configurations.

1. Valider les configurations de cluster

Enregistrez les modèles de cluster dans Apidog :

pm.test('Cluster has required applications', () => {
  const config = pm.request.body.toJSON()
  const apps = config.Applications.map(a => a.Name)
  pm.expect(apps).to.include('Spark')
})

pm.test('Instance types are valid', () => {
  const config = pm.request.body.toJSON()
  const types = ['m5.xlarge', 'm5.2xlarge', 'm4.xlarge']
  pm.expect(types).to.include(config.Instances.MasterInstanceType)
})

2. Tester les définitions d'étapes

pm.test('Spark step has valid args', () => {
  const step = pm.request.body.toJSON().Steps[0]
  const args = step.HadoopJarStep.Args
  pm.expect(args[0]).to.eql('spark-submit')
  pm.expect(args).to.include('--deploy-mode')
})

3. Variables d'environnement

AWS_REGION: us-east-1
EMR_SERVICE_ROLE: EMR_DefaultRole
EMR_EC2_ROLE: EMR_EC2_DefaultRole
S3_LOG_BUCKET: my-emr-logs
S3_SCRIPTS_BUCKET: my-emr-scripts

Testez les API AWS avec Apidog - gratuit

Erreurs courantes et correctifs

ValidationError : ServiceRole n'est pas valide

Cause : Le rôle IAM n'existe pas ou n'est pas configuré pour EMR.

Correctif : Créez un rôle de service dans la console IAM ou utilisez le rôle par défaut d'AWS : EMR_DefaultRole_V2.

Échec du provisionnement des instances EC2

Cause : Le type d'instance n'est pas disponible dans votre zone de disponibilité, ou les limites de service sont atteintes.

Correctif :

Utilisez des flottes d'instances avec plusieurs types d'instances
Demandez une augmentation de limite
Essayez différents types d'instances

Échec de l'étape avec le code de sortie d'application 1

Cause : La tâche Spark/Hadoop a échoué.

Correctif : Vérifiez les logs dans S3 (chemin LogUri). Examinez stderr et stdout pour l'étape.

Cluster bloqué à l'état DÉMARRAGE

Cause : Les actions d'amorçage échouent, ou il y a un problème d'autorisations.

Correctif : Vérifiez la sortie de la console de l'instance EC2. Vérifiez l'accès à S3 pour les scripts d'amorçage.

Alternatives et comparaisons

Fonctionnalité	AWS EMR	Google Dataproc	Azure HDInsight	Databricks
Hadoop/Spark géré	✓	✓	✓	Spark uniquement
Intégration AWS	Excellent	Limité	Limité	Bon
Option sans serveur	EMR Serverless	Dataproc Serverless	Limité	✓
Coût	Support Spot	VMs préemptibles	Instances Spot	Bon
Support ML	EMR Studio	Vertex AI	Synapse	MLflow intégré

EMR offre l'intégration AWS la plus profonde. Databricks dispose de meilleurs outils Spark. Dataproc est moins cher pour les utilisateurs de GCP.

Cas d'utilisation concrets

ETL de lac de données. Une entreprise de vente au détail traite les données de ventes quotidiennes. Les clusters EMR ingèrent des fichiers CSV depuis S3, les transforment avec Spark et écrivent au format Parquet dans le lac de données. Les clusters s'exécutent pendant 2 heures par jour et se terminent.

Analyse de logs. Une entreprise SaaS traite les logs d'applications. Spark lit les logs depuis S3, agrège les métriques et écrit dans un entrepôt de données. L'auto-échelonnement ajoute des nœuds de tâche pendant les pics de volume de logs.

Pipeline d'apprentissage automatique. Une équipe de science des données entraîne des modèles sur EMR. Spark lit les fonctionnalités depuis S3, entraîne les modèles avec MLlib et les exporte vers SageMaker pour la diffusion.

En résumé

Voici ce que vous avez appris :

Créer des clusters avec l'API RunJobFlow
Soumettre des tâches par étapes
Utiliser l'auto-échelonnement pour l'efficacité des coûts
Surveiller avec CloudWatch
Optimiser les coûts avec les instances spot et les clusters transitoires

Vos prochaines étapes :

Mettre en place des rôles IAM pour EMR
Créer un cluster de test
Soumettre une tâche Spark simple
Vérifier les logs dans S3
Mettre en œuvre des stratégies d'économie de coûts

Testez les API AWS avec Apidog - gratuit

bouton

FAQ

Quelle est la différence entre les nœuds maître, cœur et tâche ?

Maître : Exécute le gestionnaire de cluster (YARN ResourceManager, HDFS NameNode)
Cœur : Exécute le traitement des données et stocke les données HDFS
Tâche : Exécute le traitement des données uniquement, sans données HDFS (idéal pour les instances spot)

Comment puis-je me connecter en SSH au nœud maître ?

aws emr ssh --cluster-id j-ABC123DEF456 --key-pair-file my-key.pem

Puis-je exécuter des notebooks Jupyter sur EMR ?Oui. Utilisez EMR Studio ou activez l'application JupyterHub. Ou utilisez les EMR Notebooks (Jupyter géré).

Qu'est-ce qu'EMR Serverless ?Une option sans serveur où vous soumettez des tâches Spark/Hive sans gérer de clusters. Payez par exécution de tâche. Idéal pour les charges de travail sporadiques.

Comment lire à partir de DynamoDB ?Utilisez le connecteur DynamoDB :

spark-submit --conf spark.hadoop.dynamodb.servicename=dynamodb \
  --conf spark.hadoop.dynamodb.input.tableName=MyTable \
  --conf spark.hadoop.dynamodb.output.tableName=MyTable \
  --conf spark.hadoop.dynamodb.region=us-east-1 \
  my-job.jar

Quel label de version dois-je utiliser ?La dernière version stable (emr-7.x pour Spark 3.x). Utilisez des versions cohérentes entre les environnements. Vérifiez la compatibilité des applications dans les notes de version.

Comment dépanner les étapes échouées ?

Vérifiez le statut de l'étape : aws emr describe-step
Consultez les logs dans S3 : s3://your-log-bucket/logs/j-ABC123/steps/s-DEF123/
Connectez-vous en SSH au nœud maître et vérifiez /mnt/var/log/