# Exemplos do Amazon EMR usando o AWS CLI
Os exemplos de código a seguir mostram como realizar ações e implementar cenários comuns usando o AWS Command Line Interface com o Amazon EMR.
*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.
Cada exemplo inclui um link para o código-fonte completo, em que você pode encontrar instruções sobre como configurar e executar o código.
**Topics**
+ [Ações](#actions)
## Ações
### `add-instance-fleet`
O código de exemplo a seguir mostra como usar `add-instance-fleet`.
**AWS CLI**
**Adicionar uma frota de instâncias de tarefa a um cluster**
Este exemplo adiciona uma nova frota de instâncias de tarefas ao cluster especificado.
Comando:
```
aws emr add-instance-fleet --cluster-id 'j-12ABCDEFGHI34JK' --instance-fleet InstanceFleetType=TASK,TargetSpotCapacity=1,LaunchSpecifications={SpotSpecification='{TimeoutDurationMinutes=20,TimeoutAction=TERMINATE_CLUSTER}'},InstanceTypeConfigs=['{InstanceType=m3.xlarge,BidPrice=0.5}']
```
Resultado:
```
{
"ClusterId": "j-12ABCDEFGHI34JK",
"InstanceFleetId": "if-23ABCDEFGHI45JJ"
}
```
+ Para ver detalhes da API, consulte [AddInstanceFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-instance-fleet.html) na *Referência de comandos da AWS CLI*.
### `add-steps`
O código de exemplo a seguir mostra como usar `add-steps`.
**AWS CLI**
**1. Adicionar uma etapa JAR personalizada a um cluster**
Comando:
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps Type=CUSTOM_JAR,Name=CustomJAR,ActionOnFailure=CONTINUE,Jar=s3://amzn-s3-demo-bucket/mytest.jar,Args=arg1,arg2,arg3 Type=CUSTOM_JAR,Name=CustomJAR,ActionOnFailure=CONTINUE,Jar=s3://amzn-s3-demo-bucket/mytest.jar,MainClass=mymainclass,Args=arg1,arg2,arg3
```
Parâmetros obrigatórios:
```
Jar
```
Parâmetros opcionais:
```
Type, Name, ActionOnFailure, Args
```
Resultado:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**2. Adicionar etapas de transmissão a um cluster**
Comando:
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps Type=STREAMING,Name='Streaming Program',ActionOnFailure=CONTINUE,Args=[-files,s3://elasticmapreduce/samples/wordcount/wordSplitter.py,-mapper,wordSplitter.py,-reducer,aggregate,-input,s3://elasticmapreduce/samples/wordcount/input,-output,s3://amzn-s3-demo-bucket/wordcount/output]
```
Parâmetros obrigatórios:
```
Type, Args
```
Parâmetros opcionais:
```
Name, ActionOnFailure
```
Equivalente em JSON (conteúdo de step.json):
```
[
{
"Name": "JSON Streaming Step",
"Args": ["-files","s3://elasticmapreduce/samples/wordcount/wordSplitter.py","-mapper","wordSplitter.py","-reducer","aggregate","-input","s3://elasticmapreduce/samples/wordcount/input","-output","s3://amzn-s3-demo-bucket/wordcount/output"],
"ActionOnFailure": "CONTINUE",
"Type": "STREAMING"
}
]
```
OBSERVAÇÃO: os argumentos JSON devem incluir opções e valores como seus próprios itens na lista.
Comando (usando step.json):
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps file://./step.json
```
Resultado:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**3. Adicionar uma etapa de transmissão com vários arquivos a um cluster (somente JSON)**
JSON (vários arquivos.json):
```
[
{
"Name": "JSON Streaming Step",
"Type": "STREAMING",
"ActionOnFailure": "CONTINUE",
"Args": [
"-files",
"s3://amzn-s3-demo-bucket/mapper.py,s3://amzn-s3-demo-bucket/reducer.py",
"-mapper",
"mapper.py",
"-reducer",
"reducer.py",
"-input",
"s3://amzn-s3-demo-bucket/input",
"-output",
"s3://amzn-s3-demo-bucket/output"]
}
]
```
Comando:
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps file://./multiplefiles.json
```
Parâmetros obrigatórios:
```
Type, Args
```
Parâmetros opcionais:
```
Name, ActionOnFailure
```
Resultado:
```
{
"StepIds":[
"s-XXXXXXXX",
]
}
```
**4. Adicionar etapas Hive a um cluster**
Comando:
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps Type=HIVE,Name='Hive program',ActionOnFailure=CONTINUE,Args=[-f,s3://amzn-s3-demo-bucket/myhivescript.q,-d,INPUT=s3://amzn-s3-demo-bucket/myhiveinput,-d,OUTPUT=s3://amzn-s3-demo-bucket/myhiveoutput,arg1,arg2] Type=HIVE,Name='Hive steps',ActionOnFailure=TERMINATE_CLUSTER,Args=[-f,s3://elasticmapreduce/samples/hive-ads/libs/model-build.q,-d,INPUT=s3://elasticmapreduce/samples/hive-ads/tables,-d,OUTPUT=s3://amzn-s3-demo-bucket/hive-ads/output/2014-04-18/11-07-32,-d,LIBS=s3://elasticmapreduce/samples/hive-ads/libs]
```
Parâmetros obrigatórios:
```
Type, Args
```
Parâmetros opcionais:
```
Name, ActionOnFailure
```
Resultado:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**5. Adicionar etapas Pig a um cluster**
Comando:
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps Type=PIG,Name='Pig program',ActionOnFailure=CONTINUE,Args=[-f,s3://amzn-s3-demo-bucket/mypigscript.pig,-p,INPUT=s3://amzn-s3-demo-bucket/mypiginput,-p,OUTPUT=s3://amzn-s3-demo-bucket/mypigoutput,arg1,arg2] Type=PIG,Name='Pig program',Args=[-f,s3://elasticmapreduce/samples/pig-apache/do-reports2.pig,-p,INPUT=s3://elasticmapreduce/samples/pig-apache/input,-p,OUTPUT=s3://amzn-s3-demo-bucket/pig-apache/output,arg1,arg2]
```
Parâmetros obrigatórios:
```
Type, Args
```
Parâmetros opcionais:
```
Name, ActionOnFailure
```
Resultado:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**6. Adicionar etapas Impala a um cluster**
Comando:
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps Type=IMPALA,Name='Impala program',ActionOnFailure=CONTINUE,Args=--impala-script,s3://myimpala/input,--console-output-path,s3://myimpala/output
```
Parâmetros obrigatórios:
```
Type, Args
```
Parâmetros opcionais:
```
Name, ActionOnFailure
```
Resultado:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
+ Para ver detalhes da API, consulte [AddSteps](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-steps.html) na *Referência de comandos da AWS CLI*.
### `add-tags`
O código de exemplo a seguir mostra como usar `add-tags`.
**AWS CLI**
**1. Adicionar tags a um cluster**
Comando:
```
aws emr add-tags --resource-id j-xxxxxxx --tags name="John Doe" age=29 sex=male address="123 East NW Seattle"
```
Resultado:
```
None
```
**2. Listar as tags de um cluster**
--Comando:
```
aws emr describe-cluster --cluster-id j-XXXXXXYY --query Cluster.Tags
```
Resultado:
```
[
{
"Value": "male",
"Key": "sex"
},
{
"Value": "123 East NW Seattle",
"Key": "address"
},
{
"Value": "John Doe",
"Key": "name"
},
{
"Value": "29",
"Key": "age"
}
]
```
+ Para ver detalhes da API, consulte [AddTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-tags.html) na *Referência de comandos da AWS CLI*.
### `create-cluster-examples`
O código de exemplo a seguir mostra como usar `create-cluster-examples`.
**AWS CLI**
A maioria dos exemplos a seguir pressupõe que você especificou seu perfil de serviço do Amazon EMR e o perfil de instância do Amazon EC2. Se você não tiver feito isso, deverá especificar cada perfil do IAM necessário ou usar o parâmetro `--use-default-roles` ao criar seu cluster. Para obter mais informações sobre a especificação de perfis do IAM, consulte [Configurar perfis do IAM para permissões do Amazon EMR em serviços da AWS](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html) no *Guia de Gerenciamento do Amazon EMR*.
**Exemplo 1: criar um cluster**
O exemplo `create-cluster` a seguir cria um cluster EMR simples.
```
aws emr create-cluster \
--release-label emr-5.14.0 \
--instance-type m4.large \
--instance-count 2
```
Este comando não produz saída.
**Exemplo 2: criar um cluster do Amazon EMR com os perfis padrão ServiceRole e InstanceProfile**
O exemplo `create-cluster` a seguir cria um cluster do Amazon EMR que usa a configuração `--instance-groups`.
```
aws emr create-cluster \
--release-label emr-5.14.0 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
**Exemplo 3: criar um cluster do Amazon EMR que usa uma frota de instâncias**
O exemplo `create-cluster` a seguir cria um cluster do Amazon EMR que usa a configuração `--instance-fleets`, especificando dois tipos de instância para cada frota e duas sub-redes EC2.
```
aws emr create-cluster \
--release-label emr-5.14.0 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetIds=['subnet-ab12345c','subnet-de67890f'] \
--instance-fleets InstanceFleetType=MASTER,TargetOnDemandCapacity=1,InstanceTypeConfigs=['{InstanceType=m4.large}'] InstanceFleetType=CORE,TargetSpotCapacity=11,InstanceTypeConfigs=['{InstanceType=m4.large,BidPrice=0.5,WeightedCapacity=3}','{InstanceType=m4.2xlarge,BidPrice=0.9,WeightedCapacity=5}'],LaunchSpecifications={SpotSpecification='{TimeoutDurationMinutes=120,TimeoutAction=SWITCH_TO_ON_DEMAND}'}
```
**Exemplo 4: criar um cluster com funções padrão**
O exemplo `create-cluster` a seguir usa o parâmetro `--use-default-roles` para especificar o perfil de serviço padrão e o perfil de instância.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--use-default-roles \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
**Exemplo 5: criar um cluster e especificar as aplicações a serem instaladas**
O exemplo `create-cluster` a seguir usa o parâmetro `--applications` para especificar as aplicações que o Amazon EMR instala. Este exemplo instala o Hadoop, o Hive e o Pig.
```
aws emr create-cluster \
--applications Name=Hadoop Name=Hive Name=Pig \
--release-label emr-5.9.0 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
**Exemplo 6: criar um cluster que inclua o Spark**
O exemplo a seguir instala o Spark.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--applications Name=Spark \
--ec2-attributes KeyName=myKey \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
**Exemplo 7: especificar uma AMI personalizada para usar em instâncias de cluster**
O exemplo `create-cluster` a seguir cria uma instância de cluster com base na Amazon Linux AMI com ID `ami-a518e6df`.
```
aws emr create-cluster \
--name "Cluster with My Custom AMI" \
--custom-ami-id ami-a518e6df \
--ebs-root-volume-size 20 \
--release-label emr-5.9.0 \
--use-default-roles \
--instance-count 2 \
--instance-type m4.large
```
**Exemplo 8: personalizar as configurações da aplicação**
Os exemplos a seguir usam o parâmetro `--configurations` para especificar um arquivo de configuração JSON que contém personalizações de aplicações para o Hadoop. Para obter mais informações, consulte [Configurar aplicações](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) no *Guia de versão do Amazon EMR*.
Conteúdo de `configurations.json`:
```
[
{
"Classification": "mapred-site",
"Properties": {
"mapred.tasktracker.map.tasks.maximum": 2
}
},
{
"Classification": "hadoop-env",
"Properties": {},
"Configurations": [
{
"Classification": "export",
"Properties": {
"HADOOP_DATANODE_HEAPSIZE": 2048,
"HADOOP_NAMENODE_OPTS": "-XX:GCTimeRatio=19"
}
}
]
}
]
```
O exemplo a seguir faz referência ao `configurations.json` como um arquivo local.
```
aws emr create-cluster \
--configurations file://configurations.json \
--release-label emr-5.9.0 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
O exemplo a seguir faz referência ao `configurations.json` como um arquivo no Amazon S3.
```
aws emr create-cluster \
--configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/configurations.json \
--release-label emr-5.9.0 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
**Exemplo 9: criar um cluster com grupos de instâncias mestre, principal e de tarefas**
O exemplo `create-cluster` a seguir usa `--instance-groups` para especificar o tipo e o número de instâncias do EC2 a serem usadas para grupos de instâncias principal, central e de tarefa.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--instance-groups Name=Master,InstanceGroupType=MASTER,InstanceType=m4.large,InstanceCount=1 Name=Core,InstanceGroupType=CORE,InstanceType=m4.large,InstanceCount=2 Name=Task,InstanceGroupType=TASK,InstanceType=m4.large,InstanceCount=2
```
**Exemplo 10: especificar que um cluster deve ser encerrado após a conclusão de todas as etapas**
O exemplo `create-cluster` a seguir usa `--auto-terminate` para especificar que o cluster deve ser desligado automaticamente após a conclusão de todas as etapas.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
**Exemplo 11: especificar detalhes da configuração do cluster, como o par de chaves do Amazon EC2, a configuração da rede e os grupos de segurança**
O exemplo `create-cluster` a seguir cria um cluster com o par de chaves do Amazon EC2 chamado `myKey` e um perfil de instância personalizado chamado `myProfile`. Os pares de chaves são usados para autorizar conexões SSH com os nós do cluster, geralmente o nó principal. Para obter mais informações, consulte [Usar um par de chaves Amazon EC2 para credenciais SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-access-ssh.html) no *Guia de gerenciamento do Amazon EMR*.
```
aws emr create-cluster \
--ec2-attributes KeyName=myKey,InstanceProfile=myProfile \
--release-label emr-5.9.0 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
O exemplo a seguir cria um cluster em uma sub-rede do Amazon VPC.
```
aws emr create-cluster \
--ec2-attributes SubnetId=subnet-xxxxx \
--release-label emr-5.9.0 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
O exemplo a seguir cria um cluster na zona de disponibilidade `us-east-1b`.
```
aws emr create-cluster \
--ec2-attributes AvailabilityZone=us-east-1b \
--release-label emr-5.9.0 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
O exemplo a seguir cria um cluster e especifica somente os grupos de segurança gerenciados pelo Amazon EMR.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--service-role myServiceRole \
--ec2-attributes InstanceProfile=myRole,EmrManagedMasterSecurityGroup=sg-master1,EmrManagedSlaveSecurityGroup=sg-slave1 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
O exemplo a seguir cria um cluster e especifica somente grupos de segurança adicionais do Amazon EC2.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--service-role myServiceRole \
--ec2-attributes InstanceProfile=myRole,AdditionalMasterSecurityGroups=[sg-addMaster1,sg-addMaster2,sg-addMaster3,sg-addMaster4],AdditionalSlaveSecurityGroups=[sg-addSlave1,sg-addSlave2,sg-addSlave3,sg-addSlave4] \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
O exemplo a seguir cria um cluster e especifica os grupos de segurança gerenciados pelo EMR, bem como grupos de segurança adicionais.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--service-role myServiceRole \
--ec2-attributes InstanceProfile=myRole,EmrManagedMasterSecurityGroup=sg-master1,EmrManagedSlaveSecurityGroup=sg-slave1,AdditionalMasterSecurityGroups=[sg-addMaster1,sg-addMaster2,sg-addMaster3,sg-addMaster4],AdditionalSlaveSecurityGroups=[sg-addSlave1,sg-addSlave2,sg-addSlave3,sg-addSlave4] \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
O exemplo a seguir cria um cluster em uma sub-rede privada VPC e usa um grupo de segurança específico do Amazon EC2 para permitir o acesso ao serviço Amazon EMR, o que é necessário para clusters em sub-redes privadas.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--service-role myServiceRole \
--ec2-attributes InstanceProfile=myRole,ServiceAccessSecurityGroup=sg-service-access,EmrManagedMasterSecurityGroup=sg-master,EmrManagedSlaveSecurityGroup=sg-slave \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
O exemplo a seguir especifica os parâmetros de configuração do grupo de segurança usando um arquivo JSON chamado `ec2_attributes.json` que é armazenado localmente. OBSERVAÇÃO: os argumentos JSON devem incluir opções e valores como seus próprios itens na lista.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--service-role myServiceRole \
--ec2-attributes file://ec2_attributes.json \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
Conteúdo de `ec2_attributes.json`:
```
[
{
"SubnetId": "subnet-xxxxx",
"KeyName": "myKey",
"InstanceProfile":"myRole",
"EmrManagedMasterSecurityGroup": "sg-master1",
"EmrManagedSlaveSecurityGroup": "sg-slave1",
"ServiceAccessSecurityGroup": "sg-service-access",
"AdditionalMasterSecurityGroups": ["sg-addMaster1","sg-addMaster2","sg-addMaster3","sg-addMaster4"],
"AdditionalSlaveSecurityGroups": ["sg-addSlave1","sg-addSlave2","sg-addSlave3","sg-addSlave4"]
}
]
```
**Exemplo 12: habilitar a depuração e especificar um URI de log**
O exemplo `create-cluster` a seguir usa o parâmetro `--enable-debugging`, que permite que você visualize arquivos de log com mais facilidade usando a ferramenta de depuração no console do Amazon EMR. O parâmetro `--log-uri` é obrigatório com o `--enable-debugging`.
```
aws emr create-cluster \
--enable-debugging \
--log-uri s3://amzn-s3-demo-bucket/myLog \
--release-label emr-5.9.0 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
**Exemplo 13: adicionar tags ao criar um cluster**
As tags são pares de chave-valor que ajudam você a identificar e gerenciar clusters. O exemplo `create-cluster` a seguir usa o parâmetro `--tags` para criar três tags para um cluster, uma com o nome da chave `name` e o valor `Shirley Rodriguez`, uma segunda com o nome da chave `age` e o valor `29` e uma terceira tag com o nome da chave `department` e o valor `Analytics`.
```
aws emr create-cluster \
--tags name="Shirley Rodriguez" age=29 department="Analytics" \
--release-label emr-5.32.0 \
--instance-type m5.xlarge \
--instance-count 3 \
--use-default-roles
```
O exemplo a seguir lista as tags aplicadas a um cluster.
```
aws emr describe-cluster \
--cluster-id j-XXXXXXYY \
--query Cluster.Tags
```
**Exemplo 14: usar uma configuração de segurança que habilite a criptografia e outros atributos de segurança**
O exemplo `create-cluster` a seguir usa o parâmetro `--security-configuration` para especificar uma configuração de segurança para um cluster do EMR. Você pode usar configurações de segurança com o Amazon EMR versão 4.8.0 ou posterior.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--security-configuration mySecurityConfiguration
```
**Exemplo 15: criar um cluster com volumes de armazenamento adicionais do EBS configurados para os grupos de instâncias**
Ao especificar volumes adicionais do EBS, os seguintes argumentos são obrigatórios: `VolumeType`, `SizeInGB` se `EbsBlockDeviceConfigs` for especificado.
O exemplo `create-cluster` a seguir cria um cluster com vários volumes do EBS anexados às instâncias do EC2 no grupo de instâncias principal.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--use-default-roles \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=d2.xlarge 'InstanceGroupType=CORE,InstanceCount=2,InstanceType=d2.xlarge,EbsConfiguration={EbsOptimized=true,EbsBlockDeviceConfigs=[{VolumeSpecification={VolumeType=gp2,SizeInGB=100}},{VolumeSpecification={VolumeType=io1,SizeInGB=100,Iops=100},VolumesPerInstance=4}]}' \
--auto-terminate
```
O exemplo a seguir cria um cluster com vários volumes do EBS anexados às instâncias do EC2 no grupo de instâncias mestre.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--use-default-roles \
--instance-groups 'InstanceGroupType=MASTER, InstanceCount=1, InstanceType=d2.xlarge, EbsConfiguration={EbsOptimized=true, EbsBlockDeviceConfigs=[{VolumeSpecification={VolumeType=io1, SizeInGB=100, Iops=100}},{VolumeSpecification={VolumeType=standard,SizeInGB=50},VolumesPerInstance=3}]}' InstanceGroupType=CORE,InstanceCount=2,InstanceType=d2.xlarge \
--auto-terminate
```
**Exemplo 16: criar um cluster com uma política de escala automática**
Você pode anexar políticas de escala automática a grupos de instâncias principais e de tarefas usando o Amazon EMR versão 4.0 e versões posteriores. A política de escala automática adiciona e remove dinamicamente instâncias do EC2 em resposta a uma métrica do Amazon CloudWatch. Para obter mais informações, consulte Uso da escalabilidade automática no Amazon EMR `\$1 no *Guia de gerenciamento do Amazon EMR*.
Ao anexar uma política de escala automática, você também deve especificar o perfil padrão para a escala automática usando o `--auto-scaling-role EMR_AutoScaling_DefaultRole`.
O exemplo `create-cluster` a seguir especifica a política de escala automática para o grupo de instâncias `CORE` usando o argumento `AutoScalingPolicy` com uma estrutura JSON incorporada, que especifica a configuração da política de escala. Grupos de instâncias com uma estrutura JSON incorporada devem ter toda a coleção de argumentos entre aspas simples. Usar aspas simples é opcional para grupos de instâncias sem uma estrutura JSON incorporada.
```
aws emr create-cluster
--release-label emr-5.9.0 \
--use-default-roles --auto-scaling-role EMR_AutoScaling_DefaultRole \
--instance-groups InstanceGroupType=MASTER,InstanceType=d2.xlarge,InstanceCount=1 'InstanceGroupType=CORE,InstanceType=d2.xlarge,InstanceCount=2,AutoScalingPolicy={Constraints={MinCapacity=1,MaxCapacity=5},Rules=[{Name=TestRule,Description=TestDescription,Action={Market=ON_DEMAND,SimpleScalingPolicyConfiguration={AdjustmentType=EXACT_CAPACITY,ScalingAdjustment=2}},Trigger={CloudWatchAlarmDefinition={ComparisonOperator=GREATER_THAN,EvaluationPeriods=5,MetricName=TestMetric,Namespace=EMR,Period=3,Statistic=MAXIMUM,Threshold=4.5,Unit=NONE,Dimensions=[{Key=TestKey,Value=TestValue}]}}}]}'
```
O exemplo a seguir usa um arquivo JSON, `instancegroupconfig.json`, para especificar a configuração de todos os grupos de instâncias em um cluster. O arquivo JSON especifica a configuração automática da política de escalabilidade para o grupo de instâncias principal.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole \
--instance-groups file://myfolder/instancegroupconfig.json \
--auto-scaling-role EMR_AutoScaling_DefaultRole
```
Conteúdo de `instancegroupconfig.json`:
```
[
{
"InstanceCount": 1,
"Name": "MyMasterIG",
"InstanceGroupType": "MASTER",
"InstanceType": "m4.large"
},
{
"InstanceCount": 2,
"Name": "MyCoreIG",
"InstanceGroupType": "CORE",
"InstanceType": "m4.large",
"AutoScalingPolicy": {
"Constraints": {
"MinCapacity": 2,
"MaxCapacity": 10
},
"Rules": [
{
"Name": "Default-scale-out",
"Description": "Replicates the default scale-out rule in the console for YARN memory.",
"Action": {
"SimpleScalingPolicyConfiguration": {
"AdjustmentType": "CHANGE_IN_CAPACITY",
"ScalingAdjustment": 1,
"CoolDown": 300
}
},
"Trigger": {
"CloudWatchAlarmDefinition": {
"ComparisonOperator": "LESS_THAN",
"EvaluationPeriods": 1,
"MetricName": "YARNMemoryAvailablePercentage",
"Namespace": "AWS/ElasticMapReduce",
"Period": 300,
"Threshold": 15,
"Statistic": "AVERAGE",
"Unit": "PERCENT",
"Dimensions": [
{
"Key": "JobFlowId",
"Value": "${emr.clusterId}"
}
]
}
}
}
]
}
}
]
```
**Exemplo 17: adicionar etapas JAR personalizadas ao criar um cluster**
O exemplo `create-cluster` a seguir adiciona etapas especificando um arquivo JAR armazenado no Amazon S3. Etapas para enviar trabalhos a um cluster. A função principal definida no arquivo JAR é executada depois que as instâncias do EC2 são provisionadas, todas as ações de bootstrap são executadas e as aplicações são instaladas. As etapas são especificadas usando `Type=CUSTOM_JAR`.
As etapas personalizadas do JAR exigem o parâmetro `Jar=`, que especifica o caminho e o nome do arquivo do JAR. Os parâmetros opcionais são `Type`, `Name`, `ActionOnFailure`, `Args` e `MainClass`. Se uma classe principal não for especificada, o arquivo JAR deverá especificar `Main-Class` em seu arquivo manifesto.
```
aws emr create-cluster \
--steps Type=CUSTOM_JAR,Name=CustomJAR,ActionOnFailure=CONTINUE,Jar=s3://amzn-s3-demo-bucket/mytest.jar,Args=arg1,arg2,arg3 Type=CUSTOM_JAR,Name=CustomJAR,ActionOnFailure=CONTINUE,Jar=s3://amzn-s3-demo-bucket/mytest.jar,MainClass=mymainclass,Args=arg1,arg2,arg3 \
--release-label emr-5.3.1 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
**Exemplo 18: adicionar etapas de transmissão ao criar um cluster**
Os exemplos `create-cluster` a seguir adicionam uma etapa de transmissão a um cluster que termina após a execução de todas as etapas. As etapas de transmissão exigem parâmetros `Type` e `Args`. Os parâmetros opcionais das etapas de transmissão são `Name` e `ActionOnFailure`.
O exemplo a seguir especifica a etapa na linha.
```
aws emr create-cluster \
--steps Type=STREAMING,Name='Streaming Program',ActionOnFailure=CONTINUE,Args=[-files,s3://elasticmapreduce/samples/wordcount/wordSplitter.py,-mapper,wordSplitter.py,-reducer,aggregate,-input,s3://elasticmapreduce/samples/wordcount/input,-output,s3://amzn-s3-demo-bucket/wordcount/output] \
--release-label emr-5.3.1 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
O exemplo a seguir usa um arquivo de configuração JSON armazenado localmente chamado `multiplefiles.json`. A configuração JSON especifica vários arquivos. Para especificar vários arquivos em uma etapa, você deve usar um arquivo de configuração JSON para especificar a etapa. Os argumentos JSON devem incluir opções e valores como seus próprios itens na lista.
```
aws emr create-cluster \
--steps file://./multiplefiles.json \
--release-label emr-5.9.0 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
Conteúdo de `multiplefiles.json`:
```
[
{
"Name": "JSON Streaming Step",
"Args": [
"-files",
"s3://elasticmapreduce/samples/wordcount/wordSplitter.py",
"-mapper",
"wordSplitter.py",
"-reducer",
"aggregate",
"-input",
"s3://elasticmapreduce/samples/wordcount/input",
"-output",
"s3://amzn-s3-demo-bucket/wordcount/output"
],
"ActionOnFailure": "CONTINUE",
"Type": "STREAMING"
}
]
```
**Exemplo 19: adicionar etapas do Hive ao criar um cluster**
O exemplo a seguir adiciona etapas do Hive ao criar um cluster. As etapas do Hive requerem os parâmetros `Type` e `Args`. Os parâmetros opcionais das etapas do Hive são `Name` e `ActionOnFailure`.
```
aws emr create-cluster \
--steps Type=HIVE,Name='Hive program',ActionOnFailure=CONTINUE,ActionOnFailure=TERMINATE_CLUSTER,Args=[-f,s3://elasticmapreduce/samples/hive-ads/libs/model-build.q,-d,INPUT=s3://elasticmapreduce/samples/hive-ads/tables,-d,OUTPUT=s3://amzn-s3-demo-bucket/hive-ads/output/2014-04-18/11-07-32,-d,LIBS=s3://elasticmapreduce/samples/hive-ads/libs] \
--applications Name=Hive \
--release-label emr-5.3.1 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
**Exemplo 20: adicionar etapas do Pig ao criar um cluster**
O exemplo a seguir adiciona etapas do Pig ao criar um cluster. Os parâmetros necessários para as etapas do Pig são `Type` e `Args`. Os parâmetros opcionais das etapas do Pig são `Name` e `ActionOnFailure`.
```
aws emr create-cluster \
--steps Type=PIG,Name='Pig program',ActionOnFailure=CONTINUE,Args=[-f,s3://elasticmapreduce/samples/pig-apache/do-reports2.pig,-p,INPUT=s3://elasticmapreduce/samples/pig-apache/input,-p,OUTPUT=s3://amzn-s3-demo-bucket/pig-apache/output] \
--applications Name=Pig \
--release-label emr-5.3.1 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
**Exemplo 21: adicionar ações de bootstrap**
O exemplo `create-cluster` a seguir executa duas ações de bootstrap definidas como scripts que são armazenados no Amazon S3.
```
aws emr create-cluster \
--bootstrap-actions Path=s3://amzn-s3-demo-bucket/myscript1,Name=BootstrapAction1,Args=[arg1,arg2] Path=s3://amzn-s3-demo-bucket/myscript2,Name=BootstrapAction2,Args=[arg1,arg2] \
--release-label emr-5.3.1 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large \
--auto-terminate
```
**Exemplo 22: habilitar a visualização consistente do EMRFS e personalizar as configurações de RetryCount e RetryPeriod**
O exemplo `create-cluster` a seguir especifica a contagem e o período de novas tentativas para a visualização consistente do EMRFS. O argumento `Consistent=true` é obrigatório.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs Consistent=true,RetryCount=6,RetryPeriod=30
```
O exemplo a seguir especifica a mesma configuração do EMRFS do exemplo anterior, usando um arquivo de configuração JSON armazenado localmente chamado `emrfsconfig.json`.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs file://emrfsconfig.json
```
Conteúdo de `emrfsconfig.json`:
```
{
"Consistent": true,
"RetryCount": 6,
"RetryPeriod": 30
}
```
**Exemplo 23: criar um cluster com o Kerberos configurado**
Os exemplos `create-cluster` a seguir criam um cluster usando uma configuração de segurança com o Kerberos habilitado e estabelecem os parâmetros do Kerberos para o cluster usando `--kerberos-attributes`.
O comando a seguir especifica os atributos do Kerberos para o cluster em linha.
```
aws emr create-cluster \
--instance-type m3.xlarge \
--release-label emr-5.10.0 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole \
--security-configuration mySecurityConfiguration \
--kerberos-attributes Realm=EC2.INTERNAL,KdcAdminPassword=123,CrossRealmTrustPrincipalPassword=123
```
O comando a seguir especifica os mesmos atributos, mas faz referência a um arquivo JSON armazenado localmente chamado `kerberos_attributes.json`. Neste exemplo, o arquivo é salvo no mesmo diretório em que você executa o comando. Você também pode fazer referência a um arquivo de configuração salvo no Amazon S3.
```
aws emr create-cluster \
--instance-type m3.xlarge \
--release-label emr-5.10.0 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole \
--security-configuration mySecurityConfiguration \
--kerberos-attributes file://kerberos_attributes.json
```
Conteúdo de `kerberos_attributes.json`:
```
{
"Realm": "EC2.INTERNAL",
"KdcAdminPassword": "123",
"CrossRealmTrustPrincipalPassword": "123",
}
```
O exemplo `create-cluster` a seguir cria um cluster do Amazon EMR que usa a configuração `--instance-groups` e tem uma política de escala gerenciada.
```
aws emr create-cluster \
--release-label emr-5.30.0 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
--managed-scaling-policy ComputeLimits='{MinimumCapacityUnits=2,MaximumCapacityUnits=4,UnitType=Instances}'
```
O exemplo `create-cluster` a seguir cria um cluster do Amazon EMR que usa o “--log-encryption-kms-key-id” para definir o ID da chave KMS utilizado para criptografia de log.
```
aws emr create-cluster \
--release-label emr-5.30.0 \
--log-uri s3://amzn-s3-demo-bucket/myLog \
--log-encryption-kms-key-id arn:aws:kms:us-east-1:110302272565:key/dd559181-283e-45d7-99d1-66da348c4d33 \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
O exemplo `create-cluster` a seguir cria um cluster do Amazon EMR que usa a configuração “--placement-group-configs” para colocar nós principais em um cluster de alta disponibilidade (HA) dentro de um grupo de posicionamento do EC2 usando a estratégia de posicionamento `SPREAD`.
```
aws emr create-cluster \
--release-label emr-5.30.0 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole \
--instance-groups InstanceGroupType=MASTER,InstanceCount=3,InstanceType=m4.largeInstanceGroupType=CORE,InstanceCount=1,InstanceType=m4.large \
--placement-group-configs InstanceRole=MASTER
```
O exemplo `create-cluster` a seguir cria um cluster do Amazon EMR que usa a configuração “--auto-termination-policy” para estabelecer um limite automático de encerramento ocioso para o cluster.
```
aws emr create-cluster \
--release-label emr-5.34.0 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=1,InstanceType=m4.large \
--auto-termination-policy IdleTimeout=100
```
O exemplo `create-cluster` a seguir cria um cluster do Amazon EMR que usa o “--os-release-label” para definir uma versão do Amazon Linux para lançamento do cluster
```
aws emr create-cluster \
--release-label emr-6.6.0 \
--os-release-label 2.0.20220406.1 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=1,InstanceType=m4.large
```
**Exemplo 24: especificar atributos de volume raiz do EBS: tamanho, iops e taxa de throughput para instâncias de cluster criadas com o EMR versões 6.15.0 e posteriores**
O exemplo `create-cluster` a seguir cria um cluster do Amazon EMR que usa atributos de volume raiz para configurar especificações de volumes raiz para as instâncias do EC2.
```
aws emr create-cluster \
--name "Cluster with My Custom AMI" \
--custom-ami-id ami-a518e6df \
--ebs-root-volume-size 20 \
--ebs-root-volume-iops 3000 \
--ebs-root-volume-throughput 125 \
--release-label emr-6.15.0 \
--use-default-roles \
--instance-count 2 \
--instance-type m4.large
```
+ Para ver detalhes da API, consulte [CreateClusterExamples](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-cluster-examples.html) na *Referência de comandos da AWS CLI*.
### `create-default-roles`
O código de exemplo a seguir mostra como usar `create-default-roles`.
**AWS CLI**
**1. Criar o perfil do IAM padrão para o EC2**
Comando:
```
aws emr create-default-roles
```
Resultado:
```
If the role already exists then the command returns nothing.
If the role does not exist then the output will be:
[
{
"RolePolicy": {
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudwatch:*",
"dynamodb:*",
"ec2:Describe*",
"elasticmapreduce:Describe*",
"elasticmapreduce:ListBootstrapActions",
"elasticmapreduce:ListClusters",
"elasticmapreduce:ListInstanceGroups",
"elasticmapreduce:ListInstances",
"elasticmapreduce:ListSteps",
"kinesis:CreateStream",
"kinesis:DeleteStream",
"kinesis:DescribeStream",
"kinesis:GetRecords",
"kinesis:GetShardIterator",
"kinesis:MergeShards",
"kinesis:PutRecord",
"kinesis:SplitShard",
"rds:Describe*",
"s3:*",
"sdb:*",
"sns:*",
"sqs:*"
],
"Resource": "*",
"Effect": "Allow"
}
]
},
"Role": {
"AssumeRolePolicyDocument": {
"Version":"2012-10-17",
"Statement": [
{
"Action": "sts:AssumeRole",
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
}
}
]
},
"RoleId": "AROAIQ5SIQUGL5KMYBJX6",
"CreateDate": "2015-06-09T17:09:04.602Z",
"RoleName": "EMR_EC2_DefaultRole",
"Path": "/",
"Arn": "arn:aws:iam::176430881729:role/EMR_EC2_DefaultRole"
}
},
{
"RolePolicy": {
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ec2:AuthorizeSecurityGroupIngress",
"ec2:CancelSpotInstanceRequests",
"ec2:CreateSecurityGroup",
"ec2:CreateTags",
"ec2:DeleteTags",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeAccountAttributes",
"ec2:DescribeInstances",
"ec2:DescribeInstanceStatus",
"ec2:DescribeKeyPairs",
"ec2:DescribePrefixLists",
"ec2:DescribeRouteTables",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSpotInstanceRequests",
"ec2:DescribeSpotPriceHistory",
"ec2:DescribeSubnets",
"ec2:DescribeVpcAttribute",
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcEndpointServices",
"ec2:DescribeVpcs",
"ec2:ModifyImageAttribute",
"ec2:ModifyInstanceAttribute",
"ec2:RequestSpotInstances",
"ec2:RunInstances",
"ec2:TerminateInstances",
"iam:GetRole",
"iam:GetRolePolicy",
"iam:ListInstanceProfiles",
"iam:ListRolePolicies",
"iam:PassRole",
"s3:CreateBucket",
"s3:Get*",
"s3:List*",
"sdb:BatchPutAttributes",
"sdb:Select",
"sqs:CreateQueue",
"sqs:Delete*",
"sqs:GetQueue*",
"sqs:ReceiveMessage"
],
"Resource": "*",
"Effect": "Allow"
}
]
},
"Role": {
"AssumeRolePolicyDocument": {
"Version":"2012-10-17",
"Statement": [
{
"Action": "sts:AssumeRole",
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "elasticmapreduce.amazonaws.com"
}
}
]
},
"RoleId": "AROAI3SRVPPVSRDLARBPY",
"CreateDate": "2015-06-09T17:09:10.401Z",
"RoleName": "EMR_DefaultRole",
"Path": "/",
"Arn": "arn:aws:iam::176430881729:role/EMR_DefaultRole"
}
}
]
```
+ Para ver detalhes da API, consulte [CreateDefaultRoles](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-default-roles.html) na *Referência de comandos da AWS CLI*.
### `create-security-configuration`
O código de exemplo a seguir mostra como usar `create-security-configuration`.
**AWS CLI**
**1. Criar uma configuração de segurança com criptografia em trânsito habilitada com PEM para provedor de certificados e criptografia em repouso habilitada com SSE-S3 para criptografia S3 e AWS-KMS para provedor de chave de disco local**
Comando:
```
aws emr create-security-configuration --name MySecurityConfig --security-configuration '{
"EncryptionConfiguration": {
"EnableInTransitEncryption" : true,
"EnableAtRestEncryption" : true,
"InTransitEncryptionConfiguration" : {
"TLSCertificateConfiguration" : {
"CertificateProviderType" : "PEM",
"S3Object" : "s3://mycertstore/artifacts/MyCerts.zip"
}
},
"AtRestEncryptionConfiguration" : {
"S3EncryptionConfiguration" : {
"EncryptionMode" : "SSE-S3"
},
"LocalDiskEncryptionConfiguration" : {
"EncryptionKeyProviderType" : "AwsKms",
"AwsKmsKey" : "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
}
}
}
}'
```
Resultado:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
Equivalente em JSON (conteúdo de security\$1configuration.json):
```
{
"EncryptionConfiguration": {
"EnableInTransitEncryption": true,
"EnableAtRestEncryption": true,
"InTransitEncryptionConfiguration": {
"TLSCertificateConfiguration": {
"CertificateProviderType": "PEM",
"S3Object": "s3://mycertstore/artifacts/MyCerts.zip"
}
},
"AtRestEncryptionConfiguration": {
"S3EncryptionConfiguration": {
"EncryptionMode": "SSE-S3"
},
"LocalDiskEncryptionConfiguration": {
"EncryptionKeyProviderType": "AwsKms",
"AwsKmsKey": "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
}
}
}
}
```
Comando (usando security\$1configuration.json):
```
aws emr create-security-configuration --name "MySecurityConfig" --security-configuration file://./security_configuration.json
```
Resultado:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
**2. Criar uma configuração de segurança com o Kerberos habilitado usando KDC dedicado ao cluster e confiança entre regiões**
Comando:
```
aws emr create-security-configuration --name MySecurityConfig --security-configuration '{
"AuthenticationConfiguration": {
"KerberosConfiguration": {
"Provider": "ClusterDedicatedKdc",
"ClusterDedicatedKdcConfiguration": {
"TicketLifetimeInHours": 24,
"CrossRealmTrustConfiguration": {
"Realm": "AD.DOMAIN.COM",
"Domain": "ad.domain.com",
"AdminServer": "ad.domain.com",
"KdcServer": "ad.domain.com"
}
}
}
}
}'
```
Resultado:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
Equivalente em JSON (conteúdo de security\$1configuration.json):
```
{
"AuthenticationConfiguration": {
"KerberosConfiguration": {
"Provider": "ClusterDedicatedKdc",
"ClusterDedicatedKdcConfiguration": {
"TicketLifetimeInHours": 24,
"CrossRealmTrustConfiguration": {
"Realm": "AD.DOMAIN.COM",
"Domain": "ad.domain.com",
"AdminServer": "ad.domain.com",
"KdcServer": "ad.domain.com"
}
}
}
}
}
```
Comando (usando security\$1configuration.json):
```
aws emr create-security-configuration --name "MySecurityConfig" --security-configuration file://./security_configuration.json
```
Resultado:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
+ Para ver detalhes da API, consulte [CreateSecurityConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-security-configuration.html) na *Referência de comandos da AWS CLI*.
### `delete-security-configuration`
O código de exemplo a seguir mostra como usar `delete-security-configuration`.
**AWS CLI**
**Excluir uma configuração de segurança na região atual**
Comando:
```
aws emr delete-security-configuration --name MySecurityConfig
```
Resultado:
```
None
```
+ Para ver detalhes da API, consulte [DeleteSecurityConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/delete-security-configuration.html) na *Referência de comandos da AWS CLI*.
### `describe-cluster`
O código de exemplo a seguir mostra como usar `describe-cluster`.
**AWS CLI**
Comando:
```
aws emr describe-cluster --cluster-id j-XXXXXXXX
```
Resultado:
```
For release-label based uniform instance groups cluster:
{
"Cluster": {
"Status": {
"Timeline": {
"ReadyDateTime": 1436475075.199,
"CreationDateTime": 1436474656.563,
},
"State": "WAITING",
"StateChangeReason": {
"Message": "Waiting for steps to run"
}
},
"Ec2InstanceAttributes": {
"ServiceAccessSecurityGroup": "sg-xxxxxxxx",
"EmrManagedMasterSecurityGroup": "sg-xxxxxxxx",
"IamInstanceProfile": "EMR_EC2_DefaultRole",
"Ec2KeyName": "myKey",
"Ec2AvailabilityZone": "us-east-1c",
"EmrManagedSlaveSecurityGroup": "sg-yyyyyyyyy"
},
"Name": "My Cluster",
"ServiceRole": "EMR_DefaultRole",
"Tags": [],
"TerminationProtected": true,
"UnhealthyNodeReplacement": true,
"ReleaseLabel": "emr-4.0.0",
"NormalizedInstanceHours": 96,
"InstanceGroups": [
{
"RequestedInstanceCount": 2,
"Status": {
"Timeline": {
"ReadyDateTime": 1436475074.245,
"CreationDateTime": 1436474656.564,
"EndDateTime": 1436638158.387
},
"State": "RUNNING",
"StateChangeReason": {
"Message": "",
}
},
"Name": "CORE",
"InstanceGroupType": "CORE",
"Id": "ig-YYYYYYY",
"Configurations": [],
"InstanceType": "m3.large",
"Market": "ON_DEMAND",
"RunningInstanceCount": 2
},
{
"RequestedInstanceCount": 1,
"Status": {
"Timeline": {
"ReadyDateTime": 1436475074.245,
"CreationDateTime": 1436474656.564,
"EndDateTime": 1436638158.387
},
"State": "RUNNING",
"StateChangeReason": {
"Message": "",
}
},
"Name": "MASTER",
"InstanceGroupType": "MASTER",
"Id": "ig-XXXXXXXXX",
"Configurations": [],
"InstanceType": "m3.large",
"Market": "ON_DEMAND",
"RunningInstanceCount": 1
}
],
"Applications": [
{
"Name": "Hadoop"
}
],
"VisibleToAllUsers": true,
"BootstrapActions": [],
"MasterPublicDnsName": "ec2-54-147-144-78.compute-1.amazonaws.com",
"AutoTerminate": false,
"Id": "j-XXXXXXXX",
"Configurations": [
{
"Properties": {
"fs.s3.consistent.retryPeriodSeconds": "20",
"fs.s3.enableServerSideEncryption": "true",
"fs.s3.consistent": "false",
"fs.s3.consistent.retryCount": "2"
},
"Classification": "emrfs-site"
}
]
}
}
For release-label based instance fleet cluster:
{
"Cluster": {
"Status": {
"Timeline": {
"ReadyDateTime": 1487897289.705,
"CreationDateTime": 1487896933.942
},
"State": "WAITING",
"StateChangeReason": {
"Message": "Waiting for steps to run"
}
},
"Ec2InstanceAttributes": {
"EmrManagedMasterSecurityGroup": "sg-xxxxx",
"RequestedEc2AvailabilityZones": [],
"RequestedEc2SubnetIds": [],
"IamInstanceProfile": "EMR_EC2_DefaultRole",
"Ec2AvailabilityZone": "us-east-1a",
"EmrManagedSlaveSecurityGroup": "sg-xxxxx"
},
"Name": "My Cluster",
"ServiceRole": "EMR_DefaultRole",
"Tags": [],
"TerminationProtected": false,
"UnhealthyNodeReplacement": false,
"ReleaseLabel": "emr-5.2.0",
"NormalizedInstanceHours": 472,
"InstanceCollectionType": "INSTANCE_FLEET",
"InstanceFleets": [
{
"Status": {
"Timeline": {
"ReadyDateTime": 1487897212.74,
"CreationDateTime": 1487896933.948
},
"State": "RUNNING",
"StateChangeReason": {
"Message": ""
}
},
"ProvisionedSpotCapacity": 1,
"Name": "MASTER",
"InstanceFleetType": "MASTER",
"LaunchSpecifications": {
"SpotSpecification": {
"TimeoutDurationMinutes": 60,
"TimeoutAction": "TERMINATE_CLUSTER"
}
},
"TargetSpotCapacity": 1,
"ProvisionedOnDemandCapacity": 0,
"InstanceTypeSpecifications": [
{
"BidPrice": "0.5",
"InstanceType": "m3.xlarge",
"WeightedCapacity": 1
}
],
"Id": "if-xxxxxxx",
"TargetOnDemandCapacity": 0
}
],
"Applications": [
{
"Version": "2.7.3",
"Name": "Hadoop"
}
],
"ScaleDownBehavior": "TERMINATE_AT_INSTANCE_HOUR",
"VisibleToAllUsers": true,
"BootstrapActions": [],
"MasterPublicDnsName": "ec2-xxx-xx-xxx-xx.compute-1.amazonaws.com",
"AutoTerminate": false,
"Id": "j-xxxxx",
"Configurations": []
}
}
For ami based uniform instance group cluster:
{
"Cluster": {
"Status": {
"Timeline": {
"ReadyDateTime": 1399400564.432,
"CreationDateTime": 1399400268.62
},
"State": "WAITING",
"StateChangeReason": {
"Message": "Waiting for steps to run"
}
},
"Ec2InstanceAttributes": {
"IamInstanceProfile": "EMR_EC2_DefaultRole",
"Ec2AvailabilityZone": "us-east-1c"
},
"Name": "My Cluster",
"Tags": [],
"TerminationProtected": true,
"UnhealthyNodeReplacement": true,
"RunningAmiVersion": "2.5.4",
"InstanceGroups": [
{
"RequestedInstanceCount": 1,
"Status": {
"Timeline": {
"ReadyDateTime": 1399400558.848,
"CreationDateTime": 1399400268.621
},
"State": "RUNNING",
"StateChangeReason": {
"Message": ""
}
},
"Name": "Master instance group",
"InstanceGroupType": "MASTER",
"InstanceType": "m1.small",
"Id": "ig-ABCD",
"Market": "ON_DEMAND",
"RunningInstanceCount": 1
},
{
"RequestedInstanceCount": 2,
"Status": {
"Timeline": {
"ReadyDateTime": 1399400564.439,
"CreationDateTime": 1399400268.621
},
"State": "RUNNING",
"StateChangeReason": {
"Message": ""
}
},
"Name": "Core instance group",
"InstanceGroupType": "CORE",
"InstanceType": "m1.small",
"Id": "ig-DEF",
"Market": "ON_DEMAND",
"RunningInstanceCount": 2
}
],
"Applications": [
{
"Version": "1.0.3",
"Name": "hadoop"
}
],
"BootstrapActions": [],
"VisibleToAllUsers": false,
"RequestedAmiVersion": "2.4.2",
"LogUri": "s3://myLogUri/",
"AutoTerminate": false,
"Id": "j-XXXXXXXX"
}
}
```
+ Consulte detalhes da API em [DescribeCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-cluster.html) na *Referência de comandos da AWS CLI*.
### `describe-step`
O código de exemplo a seguir mostra como usar `describe-step`.
**AWS CLI**
O seguinte comando descreve uma etapa com o ID de etapa `s-3LZC0QUT43AM` em um cluster com o ID de cluster `j-3SD91U2E1L2QX`:
```
aws emr describe-step --cluster-id j-3SD91U2E1L2QX --step-id s-3LZC0QUT43AM
```
Resultado:
```
{
"Step": {
"Status": {
"Timeline": {
"EndDateTime": 1433200470.481,
"CreationDateTime": 1433199926.597,
"StartDateTime": 1433200404.959
},
"State": "COMPLETED",
"StateChangeReason": {}
},
"Config": {
"Args": [
"s3://us-west-2.elasticmapreduce/libs/hive/hive-script",
"--base-path",
"s3://us-west-2.elasticmapreduce/libs/hive/",
"--install-hive",
"--hive-versions",
"0.13.1"
],
"Jar": "s3://us-west-2.elasticmapreduce/libs/script-runner/script-runner.jar",
"Properties": {}
},
"Id": "s-3LZC0QUT43AM",
"ActionOnFailure": "TERMINATE_CLUSTER",
"Name": "Setup hive"
}
}
```
+ Consulte detalhes da API em [DescribeStep](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-step.html) na *Referência de comandos da AWS CLI*.
### `get`
O código de exemplo a seguir mostra como usar `get`.
**AWS CLI**
O seguinte baixa o arquivo `hadoop-examples.jar` da instância principal em um cluster com o ID do cluster`j-3SD91U2E1L2QX`:
```
aws emr get --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem --src /home/hadoop-examples.jar --dest ~
```
+ Para ver detalhes da API, consulte [Get](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/get.html) na *Referência de comandos da AWS CLI*.
### `list-clusters`
O código de exemplo a seguir mostra como usar `list-clusters`.
**AWS CLI**
O comando a seguir lista todos os clusters ativos do EMR na região atual:
```
aws emr list-clusters --active
```
Resultado:
```
{
"Clusters": [
{
"Status": {
"Timeline": {
"ReadyDateTime": 1433200405.353,
"CreationDateTime": 1433199926.596
},
"State": "WAITING",
"StateChangeReason": {
"Message": "Waiting after step completed"
}
},
"NormalizedInstanceHours": 6,
"Id": "j-3SD91U2E1L2QX",
"Name": "my-cluster"
}
]
}
```
+ Consulte detalhes da API em [ListClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-clusters.html) na *Referência de comandos da AWS CLI*.
### `list-instance-fleets`
O código de exemplo a seguir mostra como usar `list-instance-fleets`.
**AWS CLI**
**Obter detalhes da configuração de frotas de instâncias em um cluster**
Este exemplo lista os detalhes de frotas de instâncias no cluster especificado.
Comando:
```
list-instance-fleets --cluster-id 'j-12ABCDEFGHI34JK'
```
Resultado:
```
{
"InstanceFleets": [
{
"Status": {
"Timeline": {
"ReadyDateTime": 1488759094.637,
"CreationDateTime": 1488758719.817
},
"State": "RUNNING",
"StateChangeReason": {
"Message": ""
}
},
"ProvisionedSpotCapacity": 6,
"Name": "CORE",
"InstanceFleetType": "CORE",
"LaunchSpecifications": {
"SpotSpecification": {
"TimeoutDurationMinutes": 60,
"TimeoutAction": "TERMINATE_CLUSTER"
}
},
"ProvisionedOnDemandCapacity": 2,
"InstanceTypeSpecifications": [
{
"BidPrice": "0.5",
"InstanceType": "m3.xlarge",
"WeightedCapacity": 2
}
],
"Id": "if-1ABC2DEFGHIJ3"
},
{
"Status": {
"Timeline": {
"ReadyDateTime": 1488759058.598,
"CreationDateTime": 1488758719.811
},
"State": "RUNNING",
"StateChangeReason": {
"Message": ""
}
},
"ProvisionedSpotCapacity": 0,
"Name": "MASTER",
"InstanceFleetType": "MASTER",
"ProvisionedOnDemandCapacity": 1,
"InstanceTypeSpecifications": [
{
"BidPriceAsPercentageOfOnDemandPrice": 100.0,
"InstanceType": "m3.xlarge",
"WeightedCapacity": 1
}
],
"Id": "if-2ABC4DEFGHIJ4"
}
]
}
```
+ Para ver detalhes da API, consulte [ListInstanceFleets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instance-fleets.html) na *Referência de comandos da AWS CLI*.
### `list-instances`
O código de exemplo a seguir mostra como usar `list-instances`.
**AWS CLI**
O seguinte comando lista todas as instâncias em um cluster com o ID de cluster `j-3C6XNQ39VR9WL`:
```
aws emr list-instances --cluster-id j-3C6XNQ39VR9WL
```
Resultado:
```
For a uniform instance group based cluster
{
"Instances": [
{
"Status": {
"Timeline": {
"ReadyDateTime": 1433200400.03,
"CreationDateTime": 1433199960.152
},
"State": "RUNNING",
"StateChangeReason": {}
},
"Ec2InstanceId": "i-f19ecfee",
"PublicDnsName": "ec2-52-52-41-150.us-west-2.compute.amazonaws.com",
"PrivateDnsName": "ip-172-21-11-216.us-west-2.compute.internal",
"PublicIpAddress": "52.52.41.150",
"Id": "ci-3NNHQUQ2TWB6Y",
"PrivateIpAddress": "172.21.11.216"
},
{
"Status": {
"Timeline": {
"ReadyDateTime": 1433200400.031,
"CreationDateTime": 1433199949.102
},
"State": "RUNNING",
"StateChangeReason": {}
},
"Ec2InstanceId": "i-1feee4c2",
"PublicDnsName": "ec2-52-63-246-32.us-west-2.compute.amazonaws.com",
"PrivateDnsName": "ip-172-31-24-130.us-west-2.compute.internal",
"PublicIpAddress": "52.63.246.32",
"Id": "ci-GAOCMKNKDCV7",
"PrivateIpAddress": "172.21.11.215"
},
{
"Status": {
"Timeline": {
"ReadyDateTime": 1433200400.031,
"CreationDateTime": 1433199949.102
},
"State": "RUNNING",
"StateChangeReason": {}
},
"Ec2InstanceId": "i-15cfeee3",
"PublicDnsName": "ec2-52-25-246-63.us-west-2.compute.amazonaws.com",
"PrivateDnsName": "ip-172-31-24-129.us-west-2.compute.internal",
"PublicIpAddress": "52.25.246.63",
"Id": "ci-2W3TDFFB47UAD",
"PrivateIpAddress": "172.21.11.214"
}
]
}
For a fleet based cluster:
{
"Instances": [
{
"Status": {
"Timeline": {
"ReadyDateTime": 1487810810.878,
"CreationDateTime": 1487810588.367,
"EndDateTime": 1488022990.924
},
"State": "TERMINATED",
"StateChangeReason": {
"Message": "Instance was terminated."
}
},
"Ec2InstanceId": "i-xxxxx",
"InstanceFleetId": "if-xxxxx",
"EbsVolumes": [],
"PublicDnsName": "ec2-xx-xxx-xxx-xxx.compute-1.amazonaws.com",
"InstanceType": "m3.xlarge",
"PrivateDnsName": "ip-xx-xx-xxx-xx.ec2.internal",
"Market": "SPOT",
"PublicIpAddress": "xx.xx.xxx.xxx",
"Id": "ci-xxxxx",
"PrivateIpAddress": "10.47.191.80"
}
]
}
```
+ Para ver detalhes da API, consulte [ListInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instances.html) na *Referência de comandos da AWS CLI*.
### `list-security-configurations`
O código de exemplo a seguir mostra como usar `list-security-configurations`.
**AWS CLI**
**Listar as configurações de segurança na região atual**
Comando:
```
aws emr list-security-configurations
```
Resultado:
```
{
"SecurityConfigurations": [
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-1"
},
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-2"
}
]
}
```
+ Para ver detalhes da API, consulte [ListSecurityConfigurations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-security-configurations.html) na *Referência de comandos da AWS CLI*.
### `list-steps`
O código de exemplo a seguir mostra como usar `list-steps`.
**AWS CLI**
O seguinte comando lista todas as etapas em um cluster com o ID de cluster `j-3SD91U2E1L2QX`:
```
aws emr list-steps --cluster-id j-3SD91U2E1L2QX
```
+ Consulte detalhes da API em [ListSteps](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-steps.html) na *Referência de comandos da AWS CLI*.
### `modify-cluster-attributes`
O código de exemplo a seguir mostra como usar `modify-cluster-attributes`.
**AWS CLI**
O comando a seguir define a visibilidade de um cluster do EMR com o ID `j-301CDNY0J5XM4` para todos os usuários:
```
aws emr modify-cluster-attributes --cluster-id j-301CDNY0J5XM4 --visible-to-all-users
```
+ Para ver detalhes da API, consulte [ModifyClusterAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-cluster-attributes.html) na *Referência de comandos da AWS CLI*.
### `modify-instance-fleet`
O código de exemplo a seguir mostra como usar `modify-instance-fleet`.
**AWS CLI**
**Alterar as capacidades desejadas de uma frota de instâncias**
Este exemplo altera as capacidades alvo Sob Demanda e Spot para 1 para a frota de instâncias especificada.
Comando:
```
aws emr modify-instance-fleet --cluster-id 'j-12ABCDEFGHI34JK' --instance-fleet InstanceFleetId='if-2ABC4DEFGHIJ4',TargetOnDemandCapacity=1,TargetSpotCapacity=1
```
+ Para ver detalhes da API, consulte [ModifyInstanceFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-instance-fleet.html) na *Referência de comandos da AWS CLI*.
### `put`
O código de exemplo a seguir mostra como usar `put`.
**AWS CLI**
O comando a seguir envia um arquivo chamado `healthcheck.sh` para a instância principal em um cluster com o ID do cluster `j-3SD91U2E1L2QX`:
```
aws emr put --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem --src ~/scripts/healthcheck.sh --dest /home/hadoop/bin/healthcheck.sh
```
+ Para ver detalhes da API, consulte [Put](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/put.html) na *Referência de comandos da AWS CLI*.
### `remove-tags`
O código de exemplo a seguir mostra como usar `remove-tags`.
**AWS CLI**
O comando a seguir remove uma tag com a chave `prod` de um cluster com o ID do cluster `j-3SD91U2E1L2QX`:
```
aws emr remove-tags --resource-id j-3SD91U2E1L2QX --tag-keys prod
```
+ Para ver detalhes da API, consulte [RemoveTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/remove-tags.html) na *Referência de comandos da AWS CLI*.
### `schedule-hbase-backup`
O código de exemplo a seguir mostra como usar `schedule-hbase-backup`.
**AWS CLI**
**Observação: esse comando só pode ser usado com o HBase na AMI versão 2.x e 3.x**
**1. Agendar um backup completo do HBase** >>>>>> 06ab6d6e13564b5733d75abaf3b599f93cf39a23
Comando:
```
aws emr schedule-hbase-backup --cluster-id j-XXXXXXYY --type full --dir
s3://amzn-s3-demo-bucket/backup --interval 10 --unit hours --start-time
2014-04-21T05:26:10Z --consistent
```
Resultado:
```
None
```
**2. Agendar um backup incremental do HBase**
Comando:
```
aws emr schedule-hbase-backup --cluster-id j-XXXXXXYY --type incremental
--dir s3://amzn-s3-demo-bucket/backup --interval 30 --unit minutes --start-time
2014-04-21T05:26:10Z --consistent
```
Resultado:
```
None
```
+ Para ver detalhes da API, consulte [ScheduleHbaseBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/schedule-hbase-backup.html) na *Referência de comandos da AWS CLI*.
### `socks`
O código de exemplo a seguir mostra como usar `socks`.
**AWS CLI**
O comando a seguir abre uma conexão socks com a instância mestre em um cluster com o ID do cluster `j-3SD91U2E1L2QX`:
```
aws emr socks --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
A opção do arquivo de par de chaves usa um caminho local para um arquivo de chave privada.
+ Para ver detalhes da API, consulte [Socks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/socks.html) na *Referência de comandos da AWS CLI*.
### `ssh`
O código de exemplo a seguir mostra como usar `ssh`.
**AWS CLI**
O comando a seguir abre uma conexão ssh com a instância principal em um cluster com o ID do cluster `j-3SD91U2E1L2QX`:
```
aws emr ssh --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
A opção do arquivo de par de chaves usa um caminho local para um arquivo de chave privada.
Resultado:
```
ssh -o StrictHostKeyChecking=no -o ServerAliveInterval=10 -i /home/local/user/.ssh/mykey.pem hadoop@ec2-52-52-41-150.us-west-2.compute.amazonaws.com
Warning: Permanently added 'ec2-52-52-41-150.us-west-2.compute.amazonaws.com,52.52.41.150' (ECDSA) to the list of known hosts.
Last login: Mon Jun 1 23:15:38 2015
__| __|_ )
_| ( / Amazon Linux AMI
___|\___|___|
https://aws.amazon.com/amazon-linux-ami/2015.03-release-notes/
26 package(s) needed for security, out of 39 available
Run "sudo yum update" to apply all updates.
--------------------------------------------------------------------------------
Welcome to Amazon Elastic MapReduce running Hadoop and Amazon Linux.
Hadoop is installed in /home/hadoop. Log files are in /mnt/var/log/hadoop. Check
/mnt/var/log/hadoop/steps for diagnosing step failures.
The Hadoop UI can be accessed via the following commands:
ResourceManager lynx http://ip-172-21-11-216:9026/
NameNode lynx http://ip-172-21-11-216:9101/
--------------------------------------------------------------------------------
[hadoop@ip-172-31-16-216 ~]$
```
+ Para ver detalhes da API, consulte [Ssh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/ssh.html) na *Referência de comandos da AWS CLI*.