Como Usar APIs do EMR: Guia Completo

TL;DR

As APIs do AWS EMR (Elastic MapReduce) gerenciam clusters de big data executando Hadoop, Spark, Hive e Presto. Você cria clusters, envia trabalhos como etapas, autoescalona com base na carga de trabalho e encerra quando concluído. A autenticação usa o AWS IAM. Para testes, use o Apidog para validar configurações de cluster, testar envios de trabalhos contra a estrutura da API e documentar seus pipelines de dados.

Introdução

AWS EMR é o serviço gerenciado de Hadoop/Spark na AWS. Ele processa petabytes de dados para análises, machine learning e pipelines de ETL. Em vez de gerenciar seu próprio cluster Hadoop, você permite que a AWS cuide da infraestrutura.

O EMR é executado em instâncias EC2 em um cluster. Você especifica:

Tipos de instância (master, core, nós de tarefa)
Aplicações (Spark, Hadoop, Hive, Presto, HBase)
Ações de bootstrap (scripts de configuração)
Etapas (trabalhos a serem executados)

A API do EMR permite automatizar tudo isso. Você pode criar clusters programaticamente, enviar trabalhos, monitorar o progresso e integrar com outros serviços da AWS.

💡

Se você está construindo pipelines de dados, o Apidog ajuda a testar configurações de cluster, validar definições de trabalhos e documentar seus fluxos de trabalho EMR antes de executar trabalhos de processamento de dados caros.

botão

Teste APIs AWS com Apidog - grátis

Ao final deste guia, você será capaz de:

Criar e configurar clusters EMR via API
Enviar trabalhos como etapas
Gerenciar o autoescalamento
Monitorar a saúde do cluster e o progresso dos trabalhos
Otimizar custos com frotas de instâncias e instâncias spot

Autenticação com AWS

O EMR usa autenticação padrão da AWS com IAM.

Abordagem AWS SDK (recomendado)

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 direta com SigV4

O EMR requer a AWS Signature Version 4. Use SDKs ou ferramentas como boto3, AWS CLI, ou gere assinaturas manualmente.

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

Permissões IAM

Política mínima para gerenciamento de EMR:

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

Criando um cluster

Criação básica de cluster

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 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" }
  ]
}

Resposta:

{
  "JobFlowId": "j-ABC123DEF456"
}

Grupos de instâncias vs. Frotas de instâncias

Grupos de instâncias: Tipos de instância fixos por grupo (master, core, task).

Frotas de instâncias: Múltiplos tipos/opções de instância por grupo. O EMR escolhe com base na disponibilidade e preço.

{
  "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"
          }
        }
      }
    ]
  }
}

Enviando trabalhos como etapas

O EMR executa trabalhos como “etapas” em sequência.

Adicionar uma etapa 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 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/"
        ]
      }
    }
  ]
}

Opções de ActionOnFailure

TERMINATE_CLUSTER: Parar o cluster em caso de falha
CANCEL_AND_WAIT: Cancelar as etapas restantes, manter o cluster em execução
CONTINUE: Continuar com a próxima etapa

Etapa Hive

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

Autoescalamento

O EMR pode adicionar/remover nós de tarefa com base na carga.

Criar política de autoescalamento

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étricas para autoescalamento

MemoryAvailableMB: Memória livre
MemoryTotalMB: Memória total
HDFSUtilization: Espaço HDFS utilizado
AppsRunning: Aplicações YARN em execução
AppsPending: Aplicações YARN esperando

Monitoramento e registro (logging)

Listar clusters

aws emr list-clusters --states RUNNING

Descrever cluster

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

A resposta inclui:

{
  "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"
  }
}

Listar etapas

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

Status da etapa

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

Integração com CloudWatch

O EMR publica métricas no CloudWatch:

JobsFailed
JobsRunning
MemoryAvailableMB
MemoryTotalMB
HDFSUtilization

Otimização de custos

Usar instâncias spot

Nós de tarefa são perfeitos para instâncias spot. Se forem encerrados, o trabalho continua nos nós restantes.

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

Clusters transientes

Crie clusters, execute trabalhos, encerre automaticamente:

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

O cluster é encerrado após todas as etapas serem concluídas.

Frotas de instâncias com múltiplas opções

Deixe o EMR escolher o mais barato disponível:

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

Testando com Apidog

Clusters EMR são caros. Teste as configurações cuidadosamente.

1. Validar configurações de cluster

Salve os modelos de cluster no 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. Testar definições de etapas

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. Variáveis de ambiente

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

Teste APIs AWS com Apidog - grátis

Erros comuns e soluções

ValidationError: ServiceRole não é válido

Causa: A função IAM não existe ou não está configurada para EMR.

Solução: Crie a função de serviço no console IAM ou use o padrão da AWS: EMR_DefaultRole_V2.

Falha ao provisionar instâncias EC2

Causa: Tipo de instância indisponível na sua AZ, ou limites de serviço atingidos.

Solução:

Use frotas de instâncias com múltiplos tipos de instância
Solicite aumento de limite
Tente outros tipos de instância

Etapa falhou com código de saída de aplicação 1

Causa: O trabalho Spark/Hadoop real falhou.

Solução: Verifique os logs no S3 (caminho LogUri). Olhe para stderr e stdout da etapa.

Cluster travado no estado STARTING

Causa: Ações de bootstrap falhando, ou problema de permissões.

Solução: Verifique a saída do console da instância EC2. Verifique o acesso S3 para os scripts de bootstrap.

Alternativas e comparações

Funcionalidade	AWS EMR	Google Dataproc	Azure HDInsight	Databricks
Hadoop/Spark Gerenciado	✓	✓	✓	Somente Spark
Integração AWS	Excelente	Limitado	Limitado	Bom
Opção Serverless	EMR Serverless	Dataproc Serverless	Limitado	✓
Custo	Suporte a Spot	VMs Preemptíveis	Instâncias Spot	Bom
Suporte ML	EMR Studio	Vertex AI	Synapse	MLflow integrado

O EMR possui a integração mais profunda com a AWS. O Databricks tem melhores ferramentas Spark. O Dataproc é mais barato para usuários GCP.

Casos de uso reais

ETL de data lake. Uma empresa de varejo processa dados de vendas diárias. Clusters EMR ingerem arquivos CSV do S3, transformam com Spark e gravam Parquet no data lake. Os clusters são executados por 2 horas diárias e encerram.

Análise de logs. Uma empresa SaaS processa logs de aplicações. O Spark lê logs do S3, agrega métricas e grava em um data warehouse. O autoescalamento adiciona nós de tarefa durante picos de volume de logs.

Pipeline de machine learning. Uma equipe de ciência de dados treina modelos no EMR. O Spark lê features do S3, treina modelos com MLlib e exporta para o SageMaker para servir.

Conclusão

Aqui está o que você aprendeu:

Criar clusters com a API RunJobFlow
Enviar trabalhos como etapas
Usar autoescalamento para eficiência de custos
Monitorar com CloudWatch
Otimizar custos com instâncias spot e clusters transientes

Seus próximos passos:

Configurar funções IAM para EMR
Criar um cluster de teste
Enviar um trabalho Spark simples
Revisar logs no S3
Implementar estratégias de economia de custos

Teste APIs AWS com Apidog - grátis

botão

FAQ

Qual a diferença entre nós master, core e task?

Master: Executa o gerenciador de cluster (YARN ResourceManager, HDFS NameNode)
Core: Executa o processamento de dados e armazena dados HDFS
Task: Executa apenas o processamento de dados, sem dados HDFS (bom para instâncias spot)

Como faço SSH no nó master?

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

Posso executar notebooks Jupyter no EMR?Sim. Use o EMR Studio ou habilite a aplicação JupyterHub. Ou use os EMR Notebooks (Jupyter gerenciado).

O que é EMR Serverless?Uma opção serverless onde você envia trabalhos Spark/Hive sem gerenciar clusters. Pague por execução de trabalho. Bom para cargas de trabalho esporádicas.

Como faço para ler do DynamoDB?Use o conector 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

Qual rótulo de versão devo usar?A mais recente estável (emr-7.x para Spark 3.x). Use versões consistentes entre os ambientes. Verifique a compatibilidade da aplicação nas notas de lançamento.

Como solucionar problemas de etapas que falharam?

Verifique o status da etapa: aws emr describe-step
Visualize os logs no S3: s3://your-log-bucket/logs/j-ABC123/steps/s-DEF123/
Faça SSH no master e verifique /mnt/var/log/