Sono disponibili altri esempi AWS SDK nel repository [AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples) Examples. GitHub
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esempi di utilizzo di Amazon EMR AWS CLI
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando Amazon EMR. AWS Command Line Interface
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `add-instance-fleet`
Il seguente esempio di codice mostra come usare`add-instance-fleet`.
**AWS CLI**
**Come aggiungere un parco istanze di attività a un cluster**
Questo esempio aggiunge un nuovo parco istanze di attività al cluster specificato.
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}']
```
Output:
```
{
"ClusterId": "j-12ABCDEFGHI34JK",
"InstanceFleetId": "if-23ABCDEFGHI45JJ"
}
```
+ Per i dettagli sull'API, consulta [AddInstanceFleet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-instance-fleet.html)*Command Reference*.
### `add-steps`
Il seguente esempio di codice mostra come utilizzare`add-steps`.
**AWS CLI**
**1. Come aggiungere fasi JAR personalizzate a un 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
```
Parametri obbligatori:
```
Jar
```
Parametri facoltativi:
```
Type, Name, ActionOnFailure, Args
```
Output:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**2. Come aggiungere fasi di streaming a un 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]
```
Parametri obbligatori:
```
Type, Args
```
Parametri facoltativi:
```
Name, ActionOnFailure
```
Equivalente a JSON (contenuto di 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: gli argomenti JSON devono includere opzioni e valori come elementi propri nell’elenco.
Comando (utilizzando step.json):
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps file://./step.json
```
Output:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**3. Come aggiungere una fase di streaming con più file a un cluster (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
```
Parametri obbligatori:
```
Type, Args
```
Parametri facoltativi:
```
Name, ActionOnFailure
```
Output:
```
{
"StepIds":[
"s-XXXXXXXX",
]
}
```
**4. Come aggiungere fasi Hive a un 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]
```
Parametri obbligatori:
```
Type, Args
```
Parametri facoltativi:
```
Name, ActionOnFailure
```
Output:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**5. Come aggiungere fasi Pig a un 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]
```
Parametri obbligatori:
```
Type, Args
```
Parametri facoltativi:
```
Name, ActionOnFailure
```
Output:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**6. Come aggiungere fasi Impala a un 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
```
Parametri obbligatori:
```
Type, Args
```
Parametri facoltativi:
```
Name, ActionOnFailure
```
Output:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
+ Per i dettagli sull'API, vedere [AddSteps](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-steps.html)in *AWS CLI Command Reference*.
### `add-tags`
Il seguente esempio di codice mostra come utilizzare`add-tags`.
**AWS CLI**
**1. Come aggiungere tag a un cluster**
Comando:
```
aws emr add-tags --resource-id j-xxxxxxx --tags name="John Doe" age=29 sex=male address="123 East NW Seattle"
```
Output:
```
None
```
**2. Come elencare i tag di un cluster**
Comando:
```
aws emr describe-cluster --cluster-id j-XXXXXXYY --query Cluster.Tags
```
Output:
```
[
{
"Value": "male",
"Key": "sex"
},
{
"Value": "123 East NW Seattle",
"Key": "address"
},
{
"Value": "John Doe",
"Key": "name"
},
{
"Value": "29",
"Key": "age"
}
]
```
+ Per i dettagli sull'API, consulta [AddTags AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-tags.html)*Command Reference*.
### `create-cluster-examples`
Il seguente esempio di codice mostra come utilizzare`create-cluster-examples`.
**AWS CLI**
La maggior parte degli esempi seguenti presuppone che siano stati specificati il ruolo di servizio Amazon EMR e il profilo dell’istanza Amazon EC2. In caso contrario, devi specificare ogni ruolo IAM richiesto o utilizzare il parametro `--use-default-roles` durante la creazione del cluster. Per ulteriori informazioni sulla specificazione dei ruoli IAM, consulta [Configure IAM Roles for Amazon EMR Permissions AWS to](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html) Services nella *Amazon EMR* Management Guide.
**Esempio 1: come creare un cluster**
L’esempio `create-cluster` seguente crea un cluster EMR semplice.
```
aws emr create-cluster \
--release-label emr-5.14.0 \
--instance-type m4.large \
--instance-count 2
```
Questo comando non produce alcun output.
**Esempio 2: creare un cluster Amazon EMR con impostazioni predefinite ServiceRole e ruoli InstanceProfile **
L’esempio `create-cluster` seguente crea un cluster Amazon EMR che utilizza la configurazione `--instance-groups` e include una policy di dimensionamento gestito.
```
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
```
**Esempio 3: come creare un cluster Amazon EMR che utilizza un parco istanze**
L’esempio `create-cluster` seguente crea un cluster Amazon EMR che utilizza la configurazione `--instance-fleets`, specificando due tipi di istanza per ogni parco e due sottoreti 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}'}
```
**Esempio 4: come creare un cluster con ruoli predefiniti**
L’esempio `create-cluster` seguente utilizza il parametro `--use-default-roles` per specificare il ruolo di servizio e il profilo dell’istanza predefiniti.
```
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
```
**Esempio 5: come creare un cluster e specificare le applicazioni da installare**
L’esempio `create-cluster` seguente utilizza il parametro `--applications` per specificare le applicazioni installate da Amazon EMR. Questo esempio installa Hadoop, Hive e 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
```
**Esempio 6: come creare un cluster che include Spark**
L’esempio seguente installa 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
```
**Esempio 7: come specificare un’AMI personalizzata da utilizzare per le istanze del cluster**
L’esempio `create-cluster` seguente crea un’istanza del cluster basata sull’AMI 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
```
**Esempio 8: come personalizzare le configurazioni delle applicazioni**
Gli esempi seguenti utilizzano il parametro `--configurations` per specificare un file di configurazione JSON che contiene personalizzazioni delle applicazioni per Hadoop. Per ulteriori informazioni, consulta [Configurazione delle applicazioni](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) nella *Guida alle versioni di Amazon EMR*.
Contenuto di `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"
}
}
]
}
]
```
L’esempio seguente fa riferimento a `configurations.json` come file locale.
```
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
```
L’esempio seguente fa riferimento a `configurations.json` come file in 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
```
**Esempio 9: come creare un cluster con gruppi di istanze master, principali e di attività**
L’esempio `create-cluster` seguente utilizza `--instance-groups` per specificare il tipo e il numero di istanze EC2 da utilizzare per gruppi di istanze master, principali e di attività.
```
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
```
**Esempio 10: come specificare che un cluster deve essere terminato dopo il completamento di tutte le fasi**
L’esempio `create-cluster` seguente utilizza `--auto-terminate` per specificare che il cluster deve arrestarsi automaticamente dopo il completamento di tutte le fasi.
```
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
```
**Esempio 11: come specificare i dettagli di configurazione del cluster, come la coppia di chiavi Amazon EC2, la configurazione di rete e i gruppi di sicurezza**
L’esempio `create-cluster` seguente crea un cluster con la coppia di chiavi Amazon EC2 denominata `myKey` e un profilo di istanza personalizzato denominato `myProfile`. Le coppie di chiavi vengono utilizzate per autorizzare connessioni SSH ai nodi del cluster, molto spesso al nodo principale. Per ulteriori informazioni, consulta [Utilizzare una coppia di chiavi Amazon EC2 per le credenziali SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-access-ssh.html) nella *Guida alla gestione di 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
```
L’esempio seguente crea un cluster in una sottorete 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
```
L’esempio seguente crea un cluster nella zona di disponibilità `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
```
L’esempio seguente crea un cluster e specifica solo i gruppi di sicurezza gestiti da 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
```
L’esempio seguente crea un cluster e specifica solo gruppi di sicurezza Amazon EC2 aggiuntivi.
```
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
```
L’esempio seguente crea un cluster e specifica i gruppi di sicurezza gestiti da EMR, insieme a gruppi di sicurezza aggiuntivi.
```
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
```
L’esempio seguente crea un cluster in una sottorete privata VPC e utilizza un gruppo di sicurezza Amazon EC2 specifico per abilitare l’accesso al servizio Amazon EMR, necessario per i cluster in sottoreti private.
```
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
```
L’esempio seguente specifica i parametri di configurazione del gruppo di sicurezza utilizzando un file JSON denominato `ec2_attributes.json` archiviato in locale. NOTA: gli argomenti JSON devono includere opzioni e valori come elementi propri nell’elenco.
```
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
```
Contenuto di `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"]
}
]
```
**Esempio 12: come abilitare il debug e specificare un URI di log**
L’esempio `create-cluster` seguente utilizza il parametro `--enable-debugging`, che permette di visualizzare i file di log più facilmente utilizzando lo strumento di debug nella console Amazon EMR. Il parametro `--log-uri` è obbligatorio 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
```
**Esempio 13: come aggiungere tag durante la creazione di un cluster**
I tag sono coppie chiave-valore che permettono di individuare e gestire i cluster. L’esempio `create-cluster` seguente utilizza il parametro `--tags` per creare tre tag per un cluster, uno con il nome di chiave `name` e il valore `Shirley Rodriguez`, un secondo con il nome di chiave `age` e il valore `29` e un terzo tag con il nome di chiave `department` e il valore `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
```
L’esempio seguente elenca i tag applicati a un cluster.
```
aws emr describe-cluster \
--cluster-id j-XXXXXXYY \
--query Cluster.Tags
```
**Esempio 14: come utilizzare una configurazione di sicurezza che abilita la crittografia e altre funzionalità di sicurezza**
L’esempio `create-cluster` seguente utilizza il parametro `--security-configuration` per specificare una configurazione di sicurezza per un cluster EMR. Puoi utilizzare configurazioni di sicurezza con Amazon EMR versione 4.8.0 o successive.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--security-configuration mySecurityConfiguration
```
**Esempio 15: come creare un cluster con volumi di archiviazione EBS aggiuntivi configurati per i gruppi di istanze**
Per specificare volumi EBS aggiuntivi, sono necessari questi argomenti: `VolumeType` e `SizeInGB` se è specificato `EbsBlockDeviceConfigs`.
L’esempio `create-cluster` seguente crea un cluster con più volumi EBS collegati a istanze EC2 nel gruppo di istanze principali.
```
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
```
L’esempio seguente crea un cluster con più volumi EBS collegati a istanze EC2 nel gruppo di istanze master.
```
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
```
**Esempio 16: come creare un cluster con una policy di dimensionamento automatico**
Puoi collegare policy di dimensionamento automatico a gruppi di istanze principali e di attività utilizzando Amazon EMR versione 4.0 e successive. La policy di scalabilità automatica aggiunge e rimuove dinamicamente le istanze EC2 in risposta a un parametro Amazon. CloudWatch *Per ulteriori informazioni, consulta Using Automatic Scaling in Amazon EMR https://docs.aws.amazon.com/emr/ latest/ManagementGuide/emr < -automatic-scaling.html>`\$1 nella Amazon EMR Management Guide.*
Per collegare una policy di dimensionamento automatico, devi specificare anche il ruolo predefinito per il dimensionamento automatico utilizzando `--auto-scaling-role EMR_AutoScaling_DefaultRole`.
L’esempio `create-cluster` seguente specifica la policy di dimensionamento automatico per il gruppo di istanze `CORE` utilizzando l’argomento `AutoScalingPolicy` con una struttura JSON incorporata, che specifica la configurazione della policy di dimensionamento. Per i gruppi di istanze con una struttura JSON incorporata, l’intera raccolta di argomenti deve essere racchiusa tra virgolette singole. L’utilizzo delle virgolette singole è facoltativo per i gruppi di istanze senza una struttura JSON incorporata.
```
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}]}}}]}'
```
L’esempio seguente utilizza un file JSON denominato `instancegroupconfig.json` per specificare la configurazione di tutti i gruppi di istanze in un cluster. Il file JSON specifica la configurazione della policy di dimensionamento automatico per il gruppo di istanze principali.
```
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
```
Contenuto di `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}"
}
]
}
}
}
]
}
}
]
```
**Esempio 17: aggiunge fasi JAR personalizzate durante la creazione di un cluster**
L’esempio `create-cluster` seguente aggiunge fasi specificando un file JAR archiviato in Amazon S3. Le fasi inviano il lavoro a un cluster. La funzione principale definita nel file JAR viene eseguita dopo il provisioning delle istanze EC2, l’esecuzione di eventuali azioni di bootstrap e l’installazione delle applicazioni. Le fasi vengono specificate utilizzando `Type=CUSTOM_JAR`.
Le fasi JAR personalizzate richiedono il parametro `Jar=`, che specifica il percorso e il nome del file JAR. I parametri facoltativi sono `Type`, `Name`, `ActionOnFailure`, `Args` e `MainClass`. Se non è indicata la classe principale, il file JAR deve specificare `Main-Class` nel proprio file 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
```
**Esempio 18: come aggiungere fasi di streaming durante la creazione di un cluster**
Gli esempi `create-cluster` seguenti aggiungono una fase di streaming a un cluster che viene terminato dopo l’esecuzione di tutte le fasi. Le fasi di streaming richiedono i parametri `Type` e `Args`. I parametri facoltativi per le fasi di streaming sono `Name` e `ActionOnFailure`.
L’esempio seguente specifica la fase inline.
```
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
```
L’esempio seguente utilizza un file di configurazione JSON archiviato in locale denominato `multiplefiles.json`. La configurazione JSON specifica più file. Per specificare più file all’interno di una fase, devi utilizzare un file di configurazione JSON per specificare la fase. Gli argomenti JSON devono includere opzioni e valori come elementi propri nell’elenco.
```
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
```
Contenuto di `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"
}
]
```
**Esempio 19: come aggiungere fasi Hive durante la creazione di un cluster**
L’esempio seguente aggiunge fasi Hive durante la creazione di un cluster. Le fasi Hive richiedono i parametri `Type` e `Args`. I parametri facoltativi per le fasi Hive sono `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
```
**Esempio 20: come aggiungere fasi Pig durante la creazione di un cluster**
L’esempio seguente aggiunge fasi Pig durante la creazione di un cluster. I parametri obbligatori per le fasi Pig sono `Type` e `Args`. I parametri facoltativi per le fasi Pig sono `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
```
**Esempio 21: come aggiungere azioni di bootstrap**
L’esempio `create-cluster` seguente esegue due azioni di bootstrap definite come script archiviati in 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
```
**Esempio 22: per abilitare la visualizzazione coerente di EMRFS e personalizzare le impostazioni e RetryCount RetryPeriod **
L’esempio `create-cluster` seguente specifica il numero e il periodo di nuovi tentativi per la visualizzazione EMRFS coerente. L’argomento `Consistent=true` è obbligatorio.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs Consistent=true,RetryCount=6,RetryPeriod=30
```
L’esempio seguente specifica la stessa configurazione EMRFS dell’esempio precedente, utilizzando un file di configurazione JSON archiviato in locale denominato `emrfsconfig.json`.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs file://emrfsconfig.json
```
Contenuto di `emrfsconfig.json`:
```
{
"Consistent": true,
"RetryCount": 6,
"RetryPeriod": 30
}
```
**Esempio 23: come creare un cluster con Kerberos configurato**
Gli esempi `create-cluster` seguenti creano un cluster utilizzando una configurazione di sicurezza con Kerberos abilitato e definiscono i parametri Kerberos per il cluster utilizzando `--kerberos-attributes`.
Il comando seguente specifica gli attributi Kerberos per il cluster inline.
```
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
```
Il comando seguente specifica gli stessi attributi, ma fa riferimento a un file JSON archiviato in locale denominato `kerberos_attributes.json`. In questo esempio il file viene salvato nella stessa directory in cui viene eseguito il comando. Puoi fare riferimento anche a un file di configurazione salvato in 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
```
Contenuto di `kerberos_attributes.json`:
```
{
"Realm": "EC2.INTERNAL",
"KdcAdminPassword": "123",
"CrossRealmTrustPrincipalPassword": "123",
}
```
L’esempio `create-cluster` seguente crea un cluster Amazon EMR che utilizza la configurazione `--instance-groups` e include una policy di dimensionamento gestito.
```
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}'
```
L'`create-cluster`esempio seguente crea un cluster Amazon EMR che utilizza «-- log-encryption-kms-key -id» per definire l'ID della chiave KMS utilizzato per la crittografia dei 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
```
L'`create-cluster`esempio seguente crea un cluster Amazon EMR che utilizza la configurazione «--placement-group-configs" per posizionare i nodi master in un cluster ad alta disponibilità (HA) all'interno di un gruppo di collocamento EC2 utilizzando la strategia di posizionamento. `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
```
L'`create-cluster`esempio seguente crea un cluster Amazon EMR che utilizza la configurazione «--auto-termination-policy" per impostare una soglia di terminazione automatica dei periodi di inattività per il 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
```
L'`create-cluster`esempio seguente crea un cluster Amazon EMR che utilizza il «--os-release-label" per definire una versione di Amazon Linux per il lancio del 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
```
**Esempio 24: come specificare gli attributi di un volume root EBS size, iops e throughput per le istanze del cluster create con EMR versione 6.15.0 e successive**
L’esempio `create-cluster` seguente crea un cluster Amazon EMR che utilizza attributi per i volumi root per configurare le specifiche dei volumi root per le istanze 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
```
+ Per i dettagli sull'API, consulta [CreateClusterExamples AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-cluster-examples.html)*Command Reference.*
### `create-default-roles`
Il seguente esempio di codice mostra come utilizzare`create-default-roles`.
**AWS CLI**
**1. Come creare il ruolo IAM predefinito per EC2**
Comando:
```
aws emr create-default-roles
```
Output:
```
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"
}
}
]
```
+ Per i dettagli sull'API, consulta [CreateDefaultRoles AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-default-roles.html)*Command Reference*.
### `create-security-configuration`
Il seguente esempio di codice mostra come utilizzare`create-security-configuration`.
**AWS CLI**
**1. Per creare una configurazione di sicurezza con crittografia in transito abilitata con PEM per il fornitore di certificati e crittografia a riposo abilitata con SSE-S3 per la crittografia S3 e -KMS per il provider di chiavi del disco locale AWS**
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"
}
}
}
}'
```
Output:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
Equivalente JSON (contenuto di 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 (utilizzando security\$1configuration.json):
```
aws emr create-security-configuration --name "MySecurityConfig" --security-configuration file://./security_configuration.json
```
Output:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
**2. Come creare una configurazione di sicurezza con Kerberos abilitato utilizzando KDC dedicato per il cluster e attendibilità tra domini**
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"
}
}
}
}
}'
```
Output:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
Equivalente JSON (contenuto di 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 (utilizzando security\$1configuration.json):
```
aws emr create-security-configuration --name "MySecurityConfig" --security-configuration file://./security_configuration.json
```
Output:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
+ Per i dettagli sull'API, consulta [CreateSecurityConfiguration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-security-configuration.html)*Command Reference*.
### `delete-security-configuration`
Il seguente esempio di codice mostra come utilizzare`delete-security-configuration`.
**AWS CLI**
**Come eliminare una configurazione di sicurezza nella Regione corrente**
Comando:
```
aws emr delete-security-configuration --name MySecurityConfig
```
Output:
```
None
```
+ Per i dettagli sull'API, consulta [DeleteSecurityConfiguration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/delete-security-configuration.html)*Command Reference*.
### `describe-cluster`
Il seguente esempio di codice mostra come utilizzare`describe-cluster`.
**AWS CLI**
Comando:
```
aws emr describe-cluster --cluster-id j-XXXXXXXX
```
Output:
```
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"
}
}
```
+ Per i dettagli sull'API, consulta [DescribeCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-cluster.html)*Command Reference*.
### `describe-step`
Il seguente esempio di codice mostra come utilizzare`describe-step`.
**AWS CLI**
Il comando seguente descrive una fase con ID fase `s-3LZC0QUT43AM` in un cluster con ID cluster `j-3SD91U2E1L2QX`.
```
aws emr describe-step --cluster-id j-3SD91U2E1L2QX --step-id s-3LZC0QUT43AM
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [DescribeStep AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-step.html)*Command Reference*.
### `get`
Il seguente esempio di codice mostra come utilizzare`get`.
**AWS CLI**
Il comando seguente scarica l’archivio `hadoop-examples.jar` dall’istanza master in un cluster con ID cluster `j-3SD91U2E1L2QX`:
```
aws emr get --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem --src /home/hadoop-examples.jar --dest ~
```
+ Per informazioni dettagliate sull’API, consulta [Get](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/get.html) in *AWS CLI Command Reference*.
### `list-clusters`
Il seguente esempio di codice mostra come utilizzare`list-clusters`.
**AWS CLI**
Il comando seguente elenca tutti i cluster EMR attivi nella Regione corrente:
```
aws emr list-clusters --active
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListClusters AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-clusters.html)*Command Reference*.
### `list-instance-fleets`
Il seguente esempio di codice mostra come utilizzare`list-instance-fleets`.
**AWS CLI**
**Come ottenere i dettagli di configurazione dei parchi istanze in un cluster**
Questo esempio elenca i dettagli dei parchi istanze nel cluster specificato.
Comando:
```
list-instance-fleets --cluster-id 'j-12ABCDEFGHI34JK'
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListInstanceFleets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instance-fleets.html)*Command Reference*.
### `list-instances`
Il seguente esempio di codice mostra come utilizzare`list-instances`.
**AWS CLI**
Il comando seguente elenca tutte le istanze in un cluster con ID cluster `j-3C6XNQ39VR9WL`:
```
aws emr list-instances --cluster-id j-3C6XNQ39VR9WL
```
Output:
```
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"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instances.html)*Command Reference*.
### `list-security-configurations`
Il seguente esempio di codice mostra come utilizzare`list-security-configurations`.
**AWS CLI**
**Come elencare le configurazioni di sicurezza nella Regione corrente**
Comando:
```
aws emr list-security-configurations
```
Output:
```
{
"SecurityConfigurations": [
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-1"
},
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-2"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListSecurityConfigurations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-security-configurations.html)*Command Reference*.
### `list-steps`
Il seguente esempio di codice mostra come utilizzare`list-steps`.
**AWS CLI**
Il comando seguente elenca tutte le fasi di un cluster con ID cluster `j-3SD91U2E1L2QX`:
```
aws emr list-steps --cluster-id j-3SD91U2E1L2QX
```
+ Per i dettagli sull'API, consulta [ListSteps AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-steps.html)*Command Reference*.
### `list-studios`
Il seguente esempio di codice mostra come utilizzare`list-studios`.
**AWS CLI**
**Per elencare gli EMR Studios disponibili**
L'`list-studios`esempio seguente elenca gli EMR Studios presenti nell' AWS account. :
```
aws emr list-studios
```
Output:
```
{
"Studios": [
{
"StudioId": "es-XXXXXXX132E0X7R0W7GAS1MVB",
"Name": "My_EMR_Studio",
"Url": "https://es-XXXXXXX132E0X7R0W7GAS1MVB.emrstudio-prod.us-east-1.amazonaws.com",
"AuthMode": "IAM",
"CreationTime": 1761664173.624
}
]
}
```
Per ulteriori informazioni, consulta [Monitoraggio, aggiornamento ed eliminazione delle risorse di Amazon EMR Studio](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-manage-studio.html) nella Amazon *EMR Management Guide.*
+ Per i dettagli sull'API, consulta *AWS CLI Command [ListStudios](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-studios.html)Reference*.
### `modify-cluster-attributes`
Il seguente esempio di codice mostra come utilizzare`modify-cluster-attributes`.
**AWS CLI**
Il comando seguente imposta la visibilità di un cluster EMR con ID `j-301CDNY0J5XM4` per tutti gli utenti:
```
aws emr modify-cluster-attributes --cluster-id j-301CDNY0J5XM4 --visible-to-all-users
```
+ Per i dettagli sull'API, consulta [ModifyClusterAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-cluster-attributes.html)*Command Reference*.
### `modify-instance-fleet`
Il seguente esempio di codice mostra come utilizzare`modify-instance-fleet`.
**AWS CLI**
**Come modificare le capacità delle destinazioni di un parco istanze**
Questo esempio modifica a 1 le capacità delle destinazioni on-demand e spot per il parco istanze specificato.
Comando:
```
aws emr modify-instance-fleet --cluster-id 'j-12ABCDEFGHI34JK' --instance-fleet InstanceFleetId='if-2ABC4DEFGHIJ4',TargetOnDemandCapacity=1,TargetSpotCapacity=1
```
+ Per i dettagli sull'API, consulta [ModifyInstanceFleet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-instance-fleet.html)*Command Reference*.
### `put`
Il seguente esempio di codice mostra come utilizzare`put`.
**AWS CLI**
Il comando seguente carica un file denominato `healthcheck.sh` nell’istanza master in un cluster con ID 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
```
+ Per informazioni dettagliate sull’API, consulta [Put](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/put.html) in *AWS CLI Command Reference*.
### `remove-tags`
Il seguente esempio di codice mostra come utilizzare`remove-tags`.
**AWS CLI**
Il comando seguente rimuove un tag con la chiave `prod` da un cluster con ID cluster `j-3SD91U2E1L2QX`:
```
aws emr remove-tags --resource-id j-3SD91U2E1L2QX --tag-keys prod
```
+ Per i dettagli sull'API, consulta [RemoveTags AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/remove-tags.html)*Command Reference*.
### `schedule-hbase-backup`
Il seguente esempio di codice mostra come utilizzare`schedule-hbase-backup`.
**AWS CLI**
**Nota: questo comando può essere utilizzato solo con le HBase versioni AMI 2.x e 3.x**
**1. Per pianificare un HBase backup completo** >>>>>> 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
```
Output:
```
None
```
**2. Per pianificare un backup incrementale 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
```
Output:
```
None
```
+ Per i dettagli sull'API, consulta [ScheduleHbaseBackup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/schedule-hbase-backup.html)*Command Reference.*
### `socks`
Il seguente esempio di codice mostra come utilizzare`socks`.
**AWS CLI**
Il comando seguente apre una connessione SOCKS con l’istanza master in un cluster con ID cluster `j-3SD91U2E1L2QX`:
```
aws emr socks --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
L’opzione key pair file richiede un percorso locale a un file di chiave privata.
+ Per informazioni dettagliate sull’API, consulta [Socks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/socks.html) in *AWS CLI Command Reference*.
### `ssh`
Il seguente esempio di codice mostra come utilizzare`ssh`.
**AWS CLI**
Il comando seguente apre una connessione SSH con l’istanza master in un cluster con ID cluster `j-3SD91U2E1L2QX`:
```
aws emr ssh --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
L’opzione key pair file richiede un percorso locale a un file di chiave privata.
Output:
```
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 ~]$
```
+ Per informazioni dettagliate sull’API, consulta [Ssh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/ssh.html) in *AWS CLI Command Reference*.