# Ejemplos de Amazon EMR que utilizan la AWS CLI
En los siguientes ejemplos de código se muestra cómo realizar acciones e implementar escenarios comunes usando AWS Command Line Interface con Amazon EMR.
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Acciones](#actions)
## Acciones
### `add-instance-fleet`
En el siguiente ejemplo de código, se muestra cómo utilizar `add-instance-fleet`.
**AWS CLI**
**Para agregar una flota de instancias de tarea a un clúster**
En este ejemplo, se agrega una nueva flota de instancias de tareas al clúster 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}']
```
Salida:
```
{
"ClusterId": "j-12ABCDEFGHI34JK",
"InstanceFleetId": "if-23ABCDEFGHI45JJ"
}
```
+ Para obtener información sobre la API, consulte [AddInstanceFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-instance-fleet.html) en la *Referencia de comandos de la AWS CLI*.
### `add-steps`
En el siguiente ejemplo de código, se muestra cómo utilizar `add-steps`.
**AWS CLI**
**1. Para agregar pasos JAR personalizado a un clúster**
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 requeridos:
```
Jar
```
Parámetros opcionales:
```
Type, Name, ActionOnFailure, Args
```
Salida:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**2. Para agregar pasos de transmisión a un clúster**
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 requeridos:
```
Type, Args
```
Parámetros opcionales:
```
Name, ActionOnFailure
```
Equivalente de JSON (contenido 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"
}
]
```
NOTA: Los argumentos de JSON deben incluir opciones y valores como elementos propios de la lista.
Comando (usando step.json):
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps file://./step.json
```
Salida:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**3. Para agregar un paso de transmisión con varios archivos a un clúster (solo JSON)**
JSON (multiplefiles.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 requeridos:
```
Type, Args
```
Parámetros opcionales:
```
Name, ActionOnFailure
```
Salida:
```
{
"StepIds":[
"s-XXXXXXXX",
]
}
```
**4. Para agregar pasos de Hive a un clúster**
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 requeridos:
```
Type, Args
```
Parámetros opcionales:
```
Name, ActionOnFailure
```
Salida:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**5. Para agregar pasos de Pig a un clúster**
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 requeridos:
```
Type, Args
```
Parámetros opcionales:
```
Name, ActionOnFailure
```
Salida:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**6. Para agregar pasos de Impala a un clúster**
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 requeridos:
```
Type, Args
```
Parámetros opcionales:
```
Name, ActionOnFailure
```
Salida:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
+ Para obtener información sobre la API, consulte [AddSteps](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-steps.html) en la *Referencia de comandos de la AWS CLI*.
### `add-tags`
En el siguiente ejemplo de código, se muestra cómo utilizar `add-tags`.
**AWS CLI**
**1. Para agregar etiquetas a un clúster**
Comando:
```
aws emr add-tags --resource-id j-xxxxxxx --tags name="John Doe" age=29 sex=male address="123 East NW Seattle"
```
Salida:
```
None
```
**2. Para enumerar las etiquetas de un clúster**
--Comando:
```
aws emr describe-cluster --cluster-id j-XXXXXXYY --query Cluster.Tags
```
Salida:
```
[
{
"Value": "male",
"Key": "sex"
},
{
"Value": "123 East NW Seattle",
"Key": "address"
},
{
"Value": "John Doe",
"Key": "name"
},
{
"Value": "29",
"Key": "age"
}
]
```
+ Para obtener información sobre la API, consulte [AddTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-tags.html) en la *Referencia de comandos de la AWS CLI*.
### `create-cluster-examples`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-cluster-examples`.
**AWS CLI**
En la mayoría de los ejemplos siguientes se supone que ha especificado el rol de servicio de Amazon EMR y el perfil de instancia de Amazon EC2. Si no lo ha hecho, debe especificar cada rol de IAM requerido o utilizar el parámetro `--use-default-roles` al crear el clúster. Para obtener información sobre cómo especificar roles de IAM, consulte [Configuración de los roles de servicio de IAM de los permisos de Amazon EMR para los servicios y recursos de AWS](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html) en la *Guía de administración de Amazon EMR*.
**Ejemplo 1: creación de un clúster**
En el siguiente ejemplo de `create-cluster`, se crea un clúster de EMR sencillo.
```
aws emr create-cluster \
--release-label emr-5.14.0 \
--instance-type m4.large \
--instance-count 2
```
Este comando no genera ninguna salida.
**Ejemplo 2: creación de un clúster de Amazon EMR con los roles ServiceRole e InstanceProfile predeterminados**
En el siguiente ejemplo de `create-cluster`, crea un clúster de Amazon EMR que usa la configuración de `--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
```
**Ejemplo 3: creación de un clúster de Amazon EMR que utiliza una flota de instancias**
En el siguiente ejemplo de `create-cluster`, se crea un clúster de Amazon EMR que usa la configuración de `--instance-fleets` y especifica dos tipos de instancias para cada flota y dos subredes de 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}'}
```
**Ejemplo 4: creación de un clúster con los roles predeterminados**
En el siguiente ejemplo de `create-cluster`, se utiliza el parámetro `--use-default-roles` para especificar el rol de servicio y el perfil de instancia predeterminados.
```
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
```
**Ejemplo 5: creación de un clúster y especificación de las aplicaciones que se instalarán**
En el siguiente ejemplo de `create-cluster`, se utiliza el parámetro `--applications` para especificar las aplicaciones que Amazon EMR instala. En este ejemplo, se instalan Hadoop, Hive y 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
```
**Ejemplo 6: creación un clúster que incluya Spark**
En el siguiente ejemplo, se instala 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
```
**Ejemplo 7: especificación de una AMI personalizada para utilizarla en las instancias de clúster**
En el siguiente ejemplo de `create-cluster`, se crea una instancia de clúster basada en la AMI de Amazon Linux con 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
```
**Ejemplo 8: personalización de las configuraciones de las aplicaciones**
En los ejemplos siguientes, se utiliza el parámetro `--configurations` para especificar un archivo de configuración JSON que contiene personalizaciones de aplicaciones para Hadoop. Para obtener más información, consulte [Configuración de aplicaciones](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) en la *Guía de publicación de Amazon EMR*.
Contenido 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"
}
}
]
}
]
```
En el siguiente ejemplo, se hace referencia a `configurations.json` como archivo 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
```
En el siguiente ejemplo, se hace referencia a `configurations.json` como archivo en 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
```
**Ejemplo 9: creación de un clúster con grupos de instancias maestras, principales y de tareas**
En el siguiente ejemplo de `create-cluster`, se utiliza `--instance-groups` para especificar el tipo y el número de instancias de EC2 que se utilizarán para grupos de instancias maestras, principales y de tareas.
```
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
```
**Ejemplo 10: especificación de que un clúster debe terminar después de completar todos los pasos**
En el siguiente ejemplo de `create-cluster`, se usa `--auto-terminate` para especificar que el clúster debe cerrarse automáticamente después de completar todos los pasos.
```
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
```
**Ejemplo 11: especificación de los detalles de la configuración del clúster, como el par de claves de Amazon EC2, la configuración de la red y los grupos de seguridad**
En el siguiente ejemplo de `create-cluster`, se crea un clúster con el nombre del par de claves de Amazon EC2 llamado `myKey` y perfil de instancia personalizado llamado `myProfile`. Los pares de claves se utilizan para autorizar las conexiones de SSH a los nodos de clúster, por lo general, al nodo maestro. Para obtener más información, consulte [Usar un par de claves de Amazon EC2 para credenciales de SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-access-ssh.html) en la *Guía de administración de 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
```
En el siguiente ejemplo, se crea un clúster una subred de 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
```
En el siguiente ejemplo, se crea un clúster en la zona de disponibilidad de `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
```
En el siguiente ejemplo, se crea un clúster y se especifican únicamente los grupos de seguridad administrados por 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
```
En el siguiente ejemplo, se crea un clúster y se especifican únicamente los grupos de seguridad de Amazon EC2 adicionales.
```
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
```
En el siguiente ejemplo, se crea un clúster y se especifican los grupos de seguridad administrados por EMR, así como los grupos de seguridad adicionales.
```
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
```
En el siguiente ejemplo, se crea un clúster en una subred privada de VPC y se utiliza un grupo de seguridad de Amazon EC2 específico para habilitar el acceso al servicio de Amazon EMR, que es necesario para los clústeres de las subredes 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
```
En el siguiente ejemplo, se especifican los parámetros de configuración del grupo de seguridad mediante un archivo JSON llamado `ec2_attributes.json` que se almacena localmente. NOTA: Los argumentos de JSON deben incluir opciones y valores como elementos propios de la 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
```
Contenido 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"]
}
]
```
**Ejemplo 12: habilitación de la depuración y especificación de un URI de registro**
En el siguiente ejemplo de `create-cluster`, se utiliza el parámetro `--enable-debugging`, que le permite ver los archivos de registro con mayor facilidad mediante la herramienta de depuración de la consola de Amazon EMR. El parámetro `--log-uri` es obligatorio con `--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
```
**Ejemplo 13: adición de etiquetas al crear un nuevo clúster**
Las etiquetas son pares clave-valor que le ayudan a identificar y administrar clústeres. En el siguiente ejemplo de `create-cluster`, se utiliza el parámetro `--tags` para crear tres etiquetas para un clúster: una con el nombre de clave `name` y el valor `Shirley Rodriguez`, una segunda con el nombre de clave `age` y el valor `29`, y una tercera etiqueta con el nombre de clave `department` y el 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
```
En el siguiente ejemplo, se enumeran las etiquetas aplicadas a un clúster.
```
aws emr describe-cluster \
--cluster-id j-XXXXXXYY \
--query Cluster.Tags
```
**Ejemplo 14: uso de una configuración de seguridad que habilite el cifrado y otras características de seguridad**
En el siguiente ejemplo de `create-cluster`, se utiliza el parámetro `--security-configuration` para especificar una configuración de seguridad para un clúster de EMR. Puede utilizar la configuraciones de seguridad con Amazon EMR versión 4.8.0 o versiones posteriores.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--security-configuration mySecurityConfiguration
```
**Ejemplo 15: creación de un clúster con volúmenes de almacenamiento de EBS adicionales configurados para los grupos de instancias**
Al especificar volúmenes de EBS adicionales, se requieren los siguientes argumentos: `VolumeType`, `SizeInGB` si se especifica `EbsBlockDeviceConfigs`.
En el siguiente ejemplo de `create-cluster`, se crea un clúster con varios volúmenes de EBS asociados a las instancias de EC2 del grupo de instancias 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
```
En el siguiente ejemplo, se crea un clúster con varios volúmenes de EBS asociados a las instancias de EC2 del grupo de instancias maestro.
```
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
```
**Ejemplo 16: creación de un clúster con una política de escalado automático**
Puede asociar políticas de escalado automático a grupos de instancias principales y de tareas mediante Amazon EMR versión 4.0 y versiones posteriores. La política de escalado automático agrega y elimina de manera dinámica instancias de EC2 en respuesta a una métrica de Amazon CloudWatch. Para obtener más información, consulte Uso del escalado automático en Amazon EMR `\$1 en la *Guía de administración de Amazon EMR.*
Al asociar una política de escalado automático, también debe especificar el rol predeterminado para el escalado automático mediante `--auto-scaling-role EMR_AutoScaling_DefaultRole`.
En el siguiente ejemplo de `create-cluster`, se especifica la política de escalado automático para el grupo de instancias de `CORE` mediante el argumento `AutoScalingPolicy` con una estructura JSON incrustada, que especifica la configuración de la política de escalado. Los grupos de instancias con una estructura de JSON incrustada deben tener toda la colección de argumentos entre comillas simples. El uso de comillas simples es opcional para los grupos de instancias sin una estructura de JSON incrustada.
```
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}]}}}]}'
```
En el siguiente ejemplo, se usa un archivo JSON, `instancegroupconfig.json`, para especificar la configuración de todos los grupos de instancias de un clúster. El archivo JSON especifica la configuración de la política de escalado automático para el grupo de instancias 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
```
Contenido 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}"
}
]
}
}
}
]
}
}
]
```
**Ejemplo 17: adición de pasos JAR personalizados al crear un clúster**
En el siguiente ejemplo de `create-cluster`, se agregan pasos especificando un archivo JAR almacenado en Amazon S3. Pasos para enviar trabajos a un clúster La función principal definida en el archivo JAR se ejecuta después del aprovisionamiento de las instancias EC2, de la ejecución de cualquier acción de arranque y de la instalación de las aplicaciones. Los pasos se especifican mediante `Type=CUSTOM_JAR`.
Los pasos JAR personalizados requieren el parámetro `Jar=`, que especifica la ruta y el nombre de archivo del JAR. Los parámetros opcionales son `Type`, `Name`, `ActionOnFailure`, `Args` y `MainClass`. Si no se especifica la clase principal, el archivo JAR debe especificar `Main-Class` en su archivo de manifiesto.
```
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
```
**Ejemplo 18: adición de pasos de transmisión al crear un clúster**
En los siguientes ejemplos de `create-cluster`, se agrega un paso de transmisión a un clúster que finaliza una vez se han ejecutado todos los pasos. Los pasos de transmisión requieren los parámetros `Type` y `Args`. Los parámetros opcionales de los pasos de transmisión son `Name` y `ActionOnFailure`.
En el siguiente ejemplo, se especifica el paso insertado.
```
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
```
En el siguiente ejemplo, se utiliza un archivo de configuración JSON almacenado localmente llamado `multiplefiles.json`. La configuración de JSON especifica varios archivos. Para especificar varios archivos en un paso, debe usar un archivo de configuración JSON para especificar el paso. Los argumentos de JSON deben incluir opciones y valores como elementos propios de la 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
```
Contenido 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"
}
]
```
**Ejemplo 19: adición de los pasos de Hive al crear un clúster**
En el siguiente ejemplo, se agregan los pasos de Hive al crear un clúster. Los pasos de Hive requieren los parámetros `Type` y `Args`. Los parámetros opcionales de los pasos de Hive son `Name` y `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
```
**Ejemplo 20: adición de los pasos de Pig al crear un clúster**
En el siguiente ejemplo, se agregan los pasos de Pig al crear un clúster. Los parámetros obligatorios de los pasos de Pig son `Type` y `Args`. Los parámetros opcionales de los pasos de Pig son `Name` y `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
```
**Ejemplo 21: adición de las acciones de arranque**
En el siguiente ejemplo de `create-cluster`, se ejecutan dos acciones de arranque definidas como scripts que se almacenan en 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
```
**Ejemplo 22: habilitación de la vista coherente de EMRFS y personalización de la configuración de RetryCount y RetryPeriod**
En el siguiente ejemplo de `create-cluster`, se especifica el recuento de reintentos y el período de reintentos para una vista coherente de EMRFS. El argumento `Consistent=true` es obligatorio.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs Consistent=true,RetryCount=6,RetryPeriod=30
```
En el siguiente ejemplo, se especifica la misma configuración de EMRFS que en el ejemplo anterior, utilizando un archivo de configuración JSON almacenado localmente llamado `emrfsconfig.json`.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs file://emrfsconfig.json
```
Contenido de `emrfsconfig.json`:
```
{
"Consistent": true,
"RetryCount": 6,
"RetryPeriod": 30
}
```
**Ejemplo 23: creación de un clúster con Kerberos configurado**
En los siguientes ejemplos de `create-cluster`, se crea un clúster mediante una configuración de seguridad con Kerberos activado y se establecen los parámetros de Kerberos para el clúster usando `--kerberos-attributes`.
El siguiente comando especifica los atributos de Kerberos para el clúster insertado.
```
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
```
El siguiente comando especifica los mismos atributos, pero hace referencia a un archivo JSON almacenado localmente llamado `kerberos_attributes.json`. En este ejemplo, el archivo se guarda en el mismo directorio en el que ejecuta el comando. También puede hacer referencia a un archivo de configuración guardado en 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
```
Contenido de `kerberos_attributes.json`:
```
{
"Realm": "EC2.INTERNAL",
"KdcAdminPassword": "123",
"CrossRealmTrustPrincipalPassword": "123",
}
```
En el siguiente ejemplo de `create-cluster`, se crea un clúster de Amazon EMR que utiliza la configuración de `--instance-groups` y tiene una política de escalado administrado.
```
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}'
```
En el siguiente ejemplo de `create-cluster`, se crea un clúster de Amazon EMR que utiliza --log-encryption-kms-key-id para definir el ID de clave de KMS utilizado para el cifrado de registros.
```
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
```
En el siguiente ejemplo de `create-cluster`, se crea un clúster de Amazon EMR que utiliza la configuración de --placement-group-configs para colocar los nodos maestros en un clúster de alta disponibilidad (HA) dentro de un grupo de ubicación de EC2 mediante una estrategia de ubicación de `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
```
En el siguiente ejemplo de `create-cluster`, se crea un clúster de Amazon EMR que utiliza la configuración de --auto-termination-policy para ubicar un umbral de terminación automática por inactividad para el clúster.
```
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
```
En el siguiente ejemplo de `create-cluster`, se crea un clúster de Amazon EMR que usa --os-release-label para definir una versión de Amazon Linux para el inicio del clúster.
```
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
```
**Ejemplo 24: especificación de los atributos de un volumen raíz de EBS: tamaño, IOPS y rendimiento para las instancias de clúster creadas con las versiones 6.15.0 y posteriores de EMR**
En el siguiente ejemplo de `create-cluster`, se crea un clúster de Amazon EMR que utiliza atributos de volumen raíz para configurar las especificaciones de los volúmenes raíz para las instancias de 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 obtener información sobre la API, consulte [CreateClusterExamples](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-cluster-examples.html) en la *Referencia de comandos de la AWS CLI*.
### `create-default-roles`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-default-roles`.
**AWS CLI**
**1. Para crear el rol de IAM predeterminado para EC2**
Comando:
```
aws emr create-default-roles
```
Salida:
```
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 obtener información sobre la API, consulte [CreateDefaultRoles](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-default-roles.html) en la *Referencia de comandos de la AWS CLI*.
### `create-security-configuration`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-security-configuration`.
**AWS CLI**
**1. Para crear una configuración de seguridad con cifrado en tránsito habilitado con PEM para el proveedor de certificados y el cifrado en reposo habilitado con SSE-S3 para cifrado de S3 y AWS-KMS para el proveedor de claves 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"
}
}
}
}'
```
Salida:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
Equivalente de JSON (contenido 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
```
Salida:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
**2. Para crear una configuración de seguridad con Kerberos habilitado mediante un KDC dedicado a clúster y la confianza entre dominios**
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"
}
}
}
}
}'
```
Salida:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
Equivalente de JSON (contenido 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
```
Salida:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
+ Para obtener información sobre la API, consulte [CreateSecurityConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-security-configuration.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-security-configuration`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-security-configuration`.
**AWS CLI**
**Para eliminar una configuración de seguridad en la región actual**
Comando:
```
aws emr delete-security-configuration --name MySecurityConfig
```
Salida:
```
None
```
+ Para obtener información sobre la API, consulte [DeleteSecurityConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/delete-security-configuration.html) en la *Referencia de comandos de la AWS CLI*.
### `describe-cluster`
En el siguiente ejemplo de código, se muestra cómo utilizar `describe-cluster`.
**AWS CLI**
Comando:
```
aws emr describe-cluster --cluster-id j-XXXXXXXX
```
Salida:
```
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"
}
}
```
+ Para obtener información sobre la API, consulte [DescribeCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-cluster.html) en la *Referencia de comandos de la AWS CLI*.
### `describe-step`
En el siguiente ejemplo de código, se muestra cómo utilizar `describe-step`.
**AWS CLI**
El siguiente comando describe un paso con el ID del paso `s-3LZC0QUT43AM` en un clúster con el ID de clúster `j-3SD91U2E1L2QX`:
```
aws emr describe-step --cluster-id j-3SD91U2E1L2QX --step-id s-3LZC0QUT43AM
```
Salida:
```
{
"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"
}
}
```
+ Para obtener información sobre la API, consulte [DescribeStep](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-step.html) en la *Referencia de comandos de la AWS CLI*.
### `get`
En el siguiente ejemplo de código, se muestra cómo utilizar `get`.
**AWS CLI**
A continuación, se descarga el archivo `hadoop-examples.jar` de la instancia maestra en un clúster con el ID del clúster`j-3SD91U2E1L2QX`:
```
aws emr get --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem --src /home/hadoop-examples.jar --dest ~
```
+ Para obtener información sobre la API, consulte [Get](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/get.html) en la *Referencia de comandos de la AWS CLI*.
### `list-clusters`
En el siguiente ejemplo de código, se muestra cómo utilizar `list-clusters`.
**AWS CLI**
El siguiente comando enumera todos los clústeres de EMR activos en la región actual:
```
aws emr list-clusters --active
```
Salida:
```
{
"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"
}
]
}
```
+ Para obtener información sobre la API, consulte [ListClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-clusters.html) en la *Referencia de comandos de la AWS CLI*.
### `list-instance-fleets`
En el siguiente ejemplo de código, se muestra cómo utilizar `list-instance-fleets`.
**AWS CLI**
**Para obtener los detalles de configuración de flotas de instancias en un clúster**
En este ejemplo, se muestran los detalles de las flotas de instancias del clúster especificado.
Comando:
```
list-instance-fleets --cluster-id 'j-12ABCDEFGHI34JK'
```
Salida:
```
{
"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 obtener información sobre la API, consulte [ListInstanceFleets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instance-fleets.html) en la *Referencia de comandos de la AWS CLI*.
### `list-instances`
En el siguiente ejemplo de código, se muestra cómo utilizar `list-instances`.
**AWS CLI**
El siguiente comando enumera todas las instancias de un clúster con el ID de clúster `j-3C6XNQ39VR9WL`:
```
aws emr list-instances --cluster-id j-3C6XNQ39VR9WL
```
Salida:
```
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 obtener información sobre la API, consulte [ListInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instances.html) en la *Referencia de comandos de la AWS CLI*.
### `list-security-configurations`
En el siguiente ejemplo de código, se muestra cómo utilizar `list-security-configurations`.
**AWS CLI**
**Para enumerar las configuraciones de seguridad de la región actual**
Comando:
```
aws emr list-security-configurations
```
Salida:
```
{
"SecurityConfigurations": [
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-1"
},
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-2"
}
]
}
```
+ Para obtener información sobre la API, consulte [ListSecurityConfigurations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-security-configurations.html) en la *Referencia de comandos de la AWS CLI*.
### `list-steps`
En el siguiente ejemplo de código, se muestra cómo utilizar `list-steps`.
**AWS CLI**
El siguiente comando muestra todos los pasos de un clúster con el ID del clúster `j-3SD91U2E1L2QX`:
```
aws emr list-steps --cluster-id j-3SD91U2E1L2QX
```
+ Para obtener información sobre la API, consulte [ListSteps](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-steps.html) en la *Referencia de comandos de la AWS CLI*.
### `modify-cluster-attributes`
En el siguiente ejemplo de código, se muestra cómo utilizar `modify-cluster-attributes`.
**AWS CLI**
El siguiente comando establece la visibilidad de un clúster de EMR con el ID `j-301CDNY0J5XM4` para todos los usuarios:
```
aws emr modify-cluster-attributes --cluster-id j-301CDNY0J5XM4 --visible-to-all-users
```
+ Para obtener información sobre la API, consulte [ModifyClusterAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-cluster-attributes.html) en la *Referencia de comandos de la AWS CLI*.
### `modify-instance-fleet`
En el siguiente ejemplo de código, se muestra cómo utilizar `modify-instance-fleet`.
**AWS CLI**
**Para cambiar las capacidades de destino de una flota de instancias**
En este ejemplo, se cambian las capacidades de destino bajo demanda y de spot a 1 para la flota de instancias especificada.
Comando:
```
aws emr modify-instance-fleet --cluster-id 'j-12ABCDEFGHI34JK' --instance-fleet InstanceFleetId='if-2ABC4DEFGHIJ4',TargetOnDemandCapacity=1,TargetSpotCapacity=1
```
+ Para obtener detalles sobre la API, consulte [ModifyInstanceFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-instance-fleet.html) en la *Referencia de comandos de la AWS CLI*.
### `put`
En el siguiente ejemplo de código, se muestra cómo utilizar `put`.
**AWS CLI**
El siguiente comando carga un archivo con el nombre `healthcheck.sh` de la instancia maestra de un clúster con el ID del clúster: `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 obtener información sobre la API, consulte [Put](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/put.html) en la *Referencia de comandos de la AWS CLI*.
### `remove-tags`
En el siguiente ejemplo de código, se muestra cómo utilizar `remove-tags`.
**AWS CLI**
El siguiente comando elimina una etiqueta con la clave `prod` de un clúster con el ID de clúster `j-3SD91U2E1L2QX`:
```
aws emr remove-tags --resource-id j-3SD91U2E1L2QX --tag-keys prod
```
+ Para obtener información sobre la API, consulte [RemoveTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/remove-tags.html) en la *Referencia de comandos de la AWS CLI*.
### `schedule-hbase-backup`
En el siguiente ejemplo de código, se muestra cómo utilizar `schedule-hbase-backup`.
**AWS CLI**
**Nota: Este comando solo se puede usar con HBase en las versiones 2.x y 3.x de AMI.**
**1. Para programar una copia de seguridad de HBase completa** >>>>>>> 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
```
Salida:
```
None
```
**2. Para programar una copia de seguridad de HBase incremental**
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
```
Salida:
```
None
```
+ Para obtener información sobre la API, consulte [ScheduleHbaseBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/schedule-hbase-backup.html) en la *Referencia de comandos de la AWS CLI*.
### `socks`
En el siguiente ejemplo de código, se muestra cómo utilizar `socks`.
**AWS CLI**
El siguiente comando abre una conexión de Socks con la instancia maestra en un clúster con el ID del clúster `j-3SD91U2E1L2QX`:
```
aws emr socks --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
La opción de archivo de par de claves toma una ruta local a un archivo de clave privada.
+ Para obtener información sobre la API, consulte [Socks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/socks.html) en la *Referencia de comandos de la AWS CLI*.
### `ssh`
En el siguiente ejemplo de código, se muestra cómo utilizar `ssh`.
**AWS CLI**
El siguiente comando abre una conexión ssh con la instancia maestra en un clúster con el ID de clúster `j-3SD91U2E1L2QX`:
```
aws emr ssh --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
La opción de archivo de par de claves toma una ruta local a un archivo de clave privada.
Salida:
```
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 obtener información sobre la API, consulte [Ssh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/ssh.html) en la *Referencia de comandos de la AWS CLI*.