Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Amazon EMR-Beispiele mit AWS CLI
Die folgenden Codebeispiele zeigen Ihnen, wie Sie AWS Command Line Interface mit Amazon EMR Aktionen ausführen und allgemeine Szenarien implementieren.
*Aktionen* sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.
Jedes Beispiel enthält einen Link zum vollständigen Quellcode, wo Sie Anweisungen zum Einrichten und Ausführen des Codes im Kodex finden.
**Topics**
+ [Aktionen](#actions)
## Aktionen
### `add-instance-fleet`
Das folgende Codebeispiel zeigt, wie Sie`add-instance-fleet`.
**AWS CLI**
**So fügen Sie einem Cluster eine Aufgaben-Instance-Flotte hinzu**
In diesem Beispiel wird dem angegebenen Cluster eine neue Aufgaben-Instance-Flotte hinzugefügt.
Befehl:
```
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}']
```
Ausgabe:
```
{
"ClusterId": "j-12ABCDEFGHI34JK",
"InstanceFleetId": "if-23ABCDEFGHI45JJ"
}
```
+ Einzelheiten zur API finden Sie [AddInstanceFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-instance-fleet.html)in der *AWS CLI Befehlsreferenz*.
### `add-steps`
Das folgende Codebeispiel zeigt die Verwendung`add-steps`.
**AWS CLI**
**1. So fügen Sie einem Cluster benutzerdefinierte JAR-Schritte hinzu**
Befehl:
```
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
```
Erforderliche Parameter:
```
Jar
```
Optionale Parameter:
```
Type, Name, ActionOnFailure, Args
```
Ausgabe:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**2. So fügen Sie einem Cluster Streaming-Schritte hinzu**
Befehl:
```
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]
```
Erforderliche Parameter:
```
Type, Args
```
Optionale Parameter:
```
Name, ActionOnFailure
```
JSON-Äquivalent (Inhalt von 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"
}
]
```
HINWEIS: JSON-Argumente müssen Optionen und Werte als eigene Elemente in der Liste enthalten.
Befehl (mit step.json):
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps file://./step.json
```
Ausgabe:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**3. So fügen Sie einem Cluster einen Streaming-Schritt mit mehreren Dateien hinzu (nur 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"]
}
]
```
Befehl:
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps file://./multiplefiles.json
```
Erforderliche Parameter:
```
Type, Args
```
Optionale Parameter:
```
Name, ActionOnFailure
```
Ausgabe:
```
{
"StepIds":[
"s-XXXXXXXX",
]
}
```
**4. So fügen Sie einem Cluster Hive-Schritte hinzu**
Befehl:
```
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]
```
Erforderliche Parameter:
```
Type, Args
```
Optionale Parameter:
```
Name, ActionOnFailure
```
Ausgabe:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**5. So fügen Sie einem Cluster Pig-Schritte hinzu**
Befehl:
```
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]
```
Erforderliche Parameter:
```
Type, Args
```
Optionale Parameter:
```
Name, ActionOnFailure
```
Ausgabe:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**6. So fügen Sie einem Cluster Impala-Schritte hinzu**
Befehl:
```
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
```
Erforderliche Parameter:
```
Type, Args
```
Optionale Parameter:
```
Name, ActionOnFailure
```
Ausgabe:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
+ Einzelheiten zur API finden Sie [AddSteps](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-steps.html)in der *AWS CLI Befehlsreferenz*.
### `add-tags`
Das folgende Codebeispiel zeigt die Verwendung`add-tags`.
**AWS CLI**
**1. So fügen Sie einem Cluster Tags hinzu**
Befehl:
```
aws emr add-tags --resource-id j-xxxxxxx --tags name="John Doe" age=29 sex=male address="123 East NW Seattle"
```
Ausgabe:
```
None
```
**2. So listen Sie die Tags eines Clusters auf**
--Befehl:
```
aws emr describe-cluster --cluster-id j-XXXXXXYY --query Cluster.Tags
```
Ausgabe:
```
[
{
"Value": "male",
"Key": "sex"
},
{
"Value": "123 East NW Seattle",
"Key": "address"
},
{
"Value": "John Doe",
"Key": "name"
},
{
"Value": "29",
"Key": "age"
}
]
```
+ Einzelheiten zur API finden Sie [AddTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-tags.html)in der *AWS CLI Befehlsreferenz*.
### `create-cluster-examples`
Das folgende Codebeispiel zeigt die Verwendung`create-cluster-examples`.
**AWS CLI**
In den meisten der folgenden Beispiele wird davon ausgegangen, dass Sie die Amazon-EMR-Servicerolle und das Amazon-EC2-Instance-Profil angegeben haben. Falls nicht, müssen Sie jede erforderliche IAM-Rolle angeben oder den Parameter `--use-default-roles` verwenden, wenn Sie den Cluster erstellen. Weitere Informationen zur Angabe von IAM-Rollen finden [Sie unter Configure IAM-Rollen for Amazon EMR Permissions to AWS Services](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html) im *Amazon EMR* Management Guide.
**Beispiel 1: So erstellen Sie einen Cluster**
Im folgenden Beispiel für `create-cluster` wird ein einfacher EMR-Cluster erstellt.
```
aws emr create-cluster \
--release-label emr-5.14.0 \
--instance-type m4.large \
--instance-count 2
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
**Beispiel 2: So erstellen Sie einen Amazon EMR-Cluster mit Standard ServiceRole und Rollen InstanceProfile **
Im folgenden Beispiel für `create-cluster` wird ein Amazon-EMR-Cluster erstellt, der die Konfiguration `--instance-groups` verwendet.
```
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
```
**Beispiel 3: So erstellen Sie einen Amazon-EMR-Cluster, der eine Instance-Flotte verwendet**
Im folgenden Beispiel für `create-cluster` wird ein Amazon-EMR-Cluster erstellt, der die Konfiguration `--instance-fleets` verwendet und zwei Instance-Typen für jede Flotte und zwei EC2-Subnetze angibt.
```
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}'}
```
**Beispiel 4: So erstellen Sie einen Cluster mit Standardrollen**
Im folgenden Beispiel für `create-cluster` wird der Parameter `--use-default-roles` verwendet, um die standardmäßige Servicerolle und das standardmäßige Instance-Profil anzugeben.
```
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
```
**Beispiel 5: So erstellen Sie einen Cluster und geben die zu installierenden Anwendungen an**
Im folgenden Beispiel für `create-cluster` wird der Parameter `--applications` verwendet, um die Anwendungen anzugeben, die von Amazon EMR installiert werden. In diesem Beispiel werden Hadoop, Hive und Pig installiert.
```
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
```
**Beispiel 6: So erstellen Sie einen Cluster, der Spark enthält**
Im folgenden Beispiel wird Spark installiert.
```
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
```
**Beispiel 7: So geben Sie ein benutzerdefiniertes AMI an, das für Cluster-Instances verwendet werden soll**
Im folgenden Beispiel für `create-cluster` wird eine Cluster-Instance erstellt, die auf dem Amazon Linux AMI mit der ID `ami-a518e6df` basiert.
```
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
```
**Beispiel 8: So passen Sie Anwendungskonfigurationen an**
In den folgenden Beispielen wird der Parameter `--configurations` verwendet, um eine JSON-Konfigurationsdatei anzugeben, die Anwendungsanpassungen für Hadoop enthält. Weitere Informationen finden Sie unter [Konfigurieren von Anwendungen](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) in den *Amazon EMR-Versionshinweisen*.
Inhalt von `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"
}
}
]
}
]
```
Im folgenden Beispiel wird `configurations.json` als lokale Datei referenziert.
```
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
```
Im folgenden Beispiel wird `configurations.json` als eine Datei in Amazon S3 referenziert.
```
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
```
**Beispiel 9: So erstellen Sie einen Cluster mit Master-, Core- und Aufgaben-Instance-Gruppen**
Im folgenden Beispiel für `create-cluster` wird `--instance-groups` verwendet, um Typ und Anzahl der EC2-Instances anzugeben, die für Master-, Core- und Aufgaben-Instance-Gruppen verwendet werden sollen.
```
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
```
**Beispiel 10: So geben Sie an, dass ein Cluster nach Abschluss aller Schritte beendet werden soll**
Im folgenden Beispiel für `create-cluster` wird `--auto-terminate` verwendet, um anzugeben, dass der Cluster nach Abschluss aller Schritte automatisch heruntergefahren werden soll.
```
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
```
**Beispiel 11: So geben Sie Cluster-Konfigurationsdetails wie das Amazon-EC2-Schlüsselpaar, die Netzwerkkonfiguration und Sicherheitsgruppen an**
Im folgenden Beispiel für `create-cluster` wird ein Cluster mit dem Amazon-EC2-Schlüsselpaar `myKey` und einem benutzerdefinierten Instance-Profil namens `myProfile` erstellt. Schlüsselpaare werden verwendet, um SSH-Verbindungen zu Cluster-Knoten, hauptsächlich dem Hauptknoten, zu autorisieren. Weitere Informationen finden Sie unter [Verwenden eines Amazon-EC2-Schlüsselpaars für SSH-Anmeldeinformationen](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-access-ssh.html) im *Verwaltungshandbuch für 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
```
Im folgenden Beispiel wird ein Cluster in einem Amazon-VPC-Subnetz erstellt.
```
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
```
Im folgenden Beispiel wird ein Cluster in der Availability Zone `us-east-1b` erstellt.
```
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
```
Im folgenden Beispiel wird ein Cluster erstellt, bei dem nur die von Amazon EMR verwalteten Sicherheitsgruppen angegeben werden.
```
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
```
Im folgenden Beispiel wird ein Cluster erstellt, bei dem nur zusätzliche Amazon-EC2-Sicherheitsgruppen angegeben werden.
```
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
```
Im folgenden Beispiel wird ein Cluster erstellt, bei dem sowohl die von EMR verwalteten als auch zusätzliche Sicherheitsgruppen angegeben werden.
```
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
```
Im folgenden Beispiel wird ein Cluster in einem privaten VPC-Subnetz erstellt und eine bestimmte Amazon-EC2-Sicherheitsgruppe verwendet, um den Amazon-EMR-Servicezugriff zu aktivieren, der für Cluster in privaten Subnetzen erforderlich ist.
```
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
```
Im folgenden Beispiel werden Konfigurationsparameter für Sicherheitsgruppen mithilfe einer lokal gespeicherten JSON-Datei namens `ec2_attributes.json` spezifiziert. HINWEIS: JSON-Argumente müssen Optionen und Werte als eigene Elemente in der Liste enthalten.
```
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
```
Inhalt von `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"]
}
]
```
**Beispiel 12: So aktivieren Sie das Debugging und geben eine Protokoll-URI an**
Im folgenden Beispiel für `create-cluster` wird der Parameter `--enable-debugging` verwendet, mit dem Protokolldateien über das Debugging-Tool in der Amazon-EMR-Konsole einfacher angezeigt werden können. Der Parameter `--log-uri` ist für `--enable-debugging` erforderlich.
```
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
```
**Beispiel 13: So fügen Sie Tags beim Erstellen eines Clusters hinzu**
Tags sind Schlüssel-Wert-Paare, mit deren Hilfe Cluster identifiziert und verwaltet werden können. Im folgenden Beispiel für `create-cluster` wird der Parameter `--tags` verwendet, um drei Tags für einen Cluster zu erstellen, eines mit dem Schlüsselnamen `name` und dem Wert `Shirley Rodriguez`, ein zweites mit dem Schlüsselnamen `age` und dem Wert `29` und ein drittes Tag mit dem Schlüsselnamen `department` und dem Wert `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
```
Im folgenden Beispiel werden die Tags aufgelistet, die auf einen Cluster angewendet wurden.
```
aws emr describe-cluster \
--cluster-id j-XXXXXXYY \
--query Cluster.Tags
```
**Beispiel 14: So verwenden Sie eine Sicherheitskonfiguration, die Verschlüsselung und andere Sicherheitsfunktionen aktiviert**
Im folgenden Beispiel für `create-cluster` wird der Parameter `--security-configuration` verwendet, um eine Sicherheitskonfiguration für einen EMR-Cluster anzugeben. Sicherheitskonfigurationen können ab Amazon-EMR-Version 4.8.0 verwendet werden.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--security-configuration mySecurityConfiguration
```
**Beispiel 15: So erstellen Sie einen Cluster mit zusätzlichen EBS-Speichervolumen, die für die Instance-Gruppen konfiguriert sind**
Bei der Angabe zusätzlicher EBS-Volumes sind die folgenden Argumente erforderlich: `VolumeType`, `SizeInGB`, falls `EbsBlockDeviceConfigs` angegeben ist.
Im folgenden Beispiel für `create-cluster` wird ein Cluster mit mehreren EBS-Volumes erstellt, die mit EC2-Instances in der Core-Instance-Gruppe verbunden sind.
```
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
```
Im folgenden Beispiel wird ein Cluster mit mehreren EBS-Volumes erstellt, die mit EC2-Instances in der Master-Instance-Gruppe verbunden sind.
```
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
```
**Beispiel 16: So erstellen Sie einen Cluster mit einer Auto-Scaling-Richtlinie**
Mit Amazon EMR Version 4.0 und höher können Sie Core- und Aufgaben-Instance-Gruppen Auto-Scaling-Richtlinien zuweisen. Die automatische Skalierungsrichtlinie fügt EC2-Instances als Reaktion auf eine CloudWatch Amazon-Metrik dynamisch hinzu und entfernt sie. *Weitere Informationen finden Sie unter Using Automatic Scaling in Amazon EMR < https://docs.aws.amazon.com/emr/ latest/ManagementGuide/emr -automatic-scaling.html>`\$1 im Amazon EMR Management Guide.*
Wenn Sie eine Richtlinie für Auto Scaling anfügen, müssen Sie auch mittels `--auto-scaling-role EMR_AutoScaling_DefaultRole` die Standardrolle für die automatische Skalierung angeben.
Im folgenden Beispiel für `create-cluster` wird die Auto-Scaling-Richtlinie für die `CORE`-Instance-Gruppe festgelegt. Dazu wird das Argument `AutoScalingPolicy` mit einer eingebetteten JSON-Struktur verwendet, das die Konfiguration der Skalierungsrichtlinie spezifiziert. Bei Instance-Gruppen mit einer eingebetteten JSON-Struktur muss die gesamte Sammlung von Argumenten in einfache Anführungszeichen eingeschlossen sein. Die Verwendung von einfachen Anführungszeichen ist für Instance-Gruppen ohne eingebettete JSON-Struktur optional.
```
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}]}}}]}'
```
Im folgenden Beispiel wird die JSON-Datei `instancegroupconfig.json` verwendet, um die Konfiguration aller Instance-Gruppen in einem Cluster anzugeben. Die JSON-Datei gibt die Konfiguration der Auto-Scaling-Richtlinie für die Core-Instance-Gruppe an.
```
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
```
Inhalt von `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}"
}
]
}
}
}
]
}
}
]
```
**Beispiel 17: So fügen Sie beim Erstellen eines Clusters benutzerdefinierte JAR-Schritte hinzu**
Im folgenden Beispiel für `create-cluster` werden Schritte hinzugefügt, indem eine in Amazon S3 gespeicherte JAR-Datei angegeben wird. Mit Schritten wird Arbeit an einen Cluster übermittelt. Die in der JAR-Datei definierte Hauptfunktion wird ausgeführt, nachdem EC2-Instances bereitgestellt, alle Bootstrap-Aktionen ausgeführt und Anwendungen installiert wurden. Die Schritte werden mithilfe von `Type=CUSTOM_JAR` angegeben.
Für benutzerdefinierte JAR-Schritte ist der Parameter `Jar=` erforderlich, der den Pfad und den Dateinamen der JAR angibt. Optionale Parameter sind `Type`, `Name`, `ActionOnFailure`, `Args` und `MainClass`. Wenn keine Hauptklasse angegeben ist, sollte die JAR-Datei `Main-Class` in ihrer Manifestdatei angeben.
```
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
```
**Beispiel 18: So fügen Sie beim Erstellen eines Clusters Streaming-Schritte hinzu**
In den folgenden Beispielen für `create-cluster` wird einem Cluster ein Streaming-Schritt hinzugefügt, der beendet wird, nachdem alle Schritte ausgeführt wurden. Für Streaming-Schritte sind die Parameter `Type` und `Args` erforderlich. Optionale Parameter für Streaming-Schritte sind `Name` und `ActionOnFailure`.
Im folgenden Beispiel wird der Schritt inline angegeben.
```
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
```
Im folgenden Beispiel wird eine lokal gespeicherte JSON-Konfigurationsdatei namens `multiplefiles.json` verwendet. Die JSON-Konfiguration gibt mehrere Dateien an. Um mehrere Dateien in einem Schritt anzugeben, müssen Sie eine JSON-Konfigurationsdatei verwenden, um den Schritt anzugeben. JSON-Argumente müssen Optionen und Werte als eigene Elemente in der Liste enthalten.
```
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
```
Inhalt von `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"
}
]
```
**Beispiel 19: So fügen Sie beim Erstellen eines Clusters Hive-Schritte hinzu**
Im folgenden Beispiel werden beim Erstellen eines Clusters Hive-Schritte hinzugefügt. Für Hive-Schritte sind die Parameter `Type` und `Args` erforderlich. Optionale Parameter für Hive-Schritte sind `Name` und `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
```
**Beispiel 20: So fügen Sie beim Erstellen eines Clusters Pig-Schritte hinzu**
Im folgenden Beispiel werden beim Erstellen eines Clusters Pig-Schritte hinzugefügt. Für Pig-Schritte sind die Parameter `Type` und `Args` erforderlich. Optionale Parameter für Pig-Schritte sind `Name` und `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
```
**Beispiel 21: So fügen Sie Bootstrap-Aktionen hinzu**
Im folgenden Beispiel für `create-cluster` werden zwei Bootstrap-Aktionen ausgeführt, die als Scripts definiert sind und in Amazon S3 gespeichert sind.
```
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
```
**Beispiel 22: Um EMRFS Consistent View zu aktivieren und die Einstellungen anzupassen RetryCount RetryPeriod **
Im folgenden Beispiel für `create-cluster` werden die Anzahl der Wiederholungen und der Wiederholungszeitraum für die konsistente Ansicht in EMRFS angegeben. Das Argument `Consistent=true` ist erforderlich.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs Consistent=true,RetryCount=6,RetryPeriod=30
```
Im folgenden Beispiel wird dieselbe EMRFS-Konfiguration wie im vorherigen Beispiel angegeben, wobei eine lokal gespeicherte JSON-Konfigurationsdatei namens `emrfsconfig.json` verwendet wird.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs file://emrfsconfig.json
```
Inhalt von `emrfsconfig.json`:
```
{
"Consistent": true,
"RetryCount": 6,
"RetryPeriod": 30
}
```
**Beispiel 23: So erstellen Sie einen Cluster mit konfiguriertem Kerberos**
In den folgenden Beispielen für `create-cluster` wird ein Cluster mithilfe einer Sicherheitskonfiguration mit aktiviertem Kerberos erstellt. Gleichzeitig werden mithilfe von `--kerberos-attributes` Kerberos-Parameter für den Cluster festgelegt.
Mit dem folgenden Befehl werden Kerberos-Attribute für den Cluster angegeben.
```
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
```
Mit dem folgenden Befehl werden dieselben Attribute angegeben, er verweist jedoch auf eine lokal gespeicherte JSON-Datei mit dem Namen `kerberos_attributes.json`. In diesem Beispiel ist die Datei im selben Verzeichnis gespeichert, in dem der Befehl ausgeführt wird. Sie können auch eine in Amazon S3 gespeicherte Konfigurationsdatei referenzieren.
```
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
```
Inhalt von `kerberos_attributes.json`:
```
{
"Realm": "EC2.INTERNAL",
"KdcAdminPassword": "123",
"CrossRealmTrustPrincipalPassword": "123",
}
```
Im folgenden Beispiel für `create-cluster` wird ein Amazon-EMR-Cluster erstellt, der die Konfiguration `--instance-groups` verwendet und eine verwaltete Skalierungsrichtlinie hat.
```
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}'
```
Im folgenden `create-cluster` Beispiel wird ein Amazon EMR-Cluster erstellt, der die „-- log-encryption-kms-key -ID“ verwendet, um die für die Protokollverschlüsselung verwendete KMS-Schlüssel-ID zu definieren.
```
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
```
Im folgenden `create-cluster` Beispiel wird ein Amazon EMR-Cluster erstellt, der die Konfiguration „--placement-group-configs“ verwendet, um Master-Knoten mithilfe `SPREAD` der Platzierungsstrategie in einem Hochverfügbarkeits-Cluster (HA) innerhalb einer EC2-Platzierungsgruppe zu platzieren.
```
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
```
Im folgenden `create-cluster` Beispiel wird ein Amazon EMR-Cluster erstellt, der die Konfiguration „--auto-termination-policy“ verwendet, um einen Schwellenwert für die automatische Beendigung des Leerlaufs für den Cluster festzulegen.
```
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
```
Im folgenden `create-cluster` Beispiel wird ein Amazon EMR-Cluster erstellt, der „--os-release-label“ verwendet, um eine Amazon Linux-Version für den Clusterstart zu definieren
```
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
```
**Beispiel 24: So geben Sie die Attribute eines EBS-Stamm-Volumes an: Größe, IOPS und Durchsatz für Cluster-Instances, die mit EMR-Versionen 6.15.0 und höher erstellt wurden**
Im folgenden Beispiel für `create-cluster` wird ein Amazon-EMR-Cluster erstellt, der Stamm-Volume-Attribute verwendet, um Stamm-Volume-Spezifikationen für die EC2-Instances zu konfigurieren.
```
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
```
+ Einzelheiten zur API finden Sie [CreateClusterExamples](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-cluster-examples.html)in der *AWS CLI Befehlsreferenz.*
### `create-default-roles`
Das folgende Codebeispiel zeigt die Verwendung`create-default-roles`.
**AWS CLI**
**1. So erstellen Sie die Standard-IAM-Rolle für EC2**
Befehl:
```
aws emr create-default-roles
```
Ausgabe:
```
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"
}
}
]
```
+ Einzelheiten zur API finden Sie [CreateDefaultRoles](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-default-roles.html)in der *AWS CLI Befehlsreferenz*.
### `create-security-configuration`
Das folgende Codebeispiel zeigt die Verwendung`create-security-configuration`.
**AWS CLI**
**1. Um eine Sicherheitskonfiguration zu erstellen, bei der die Verschlüsselung während der Übertragung mit PEM für den Zertifikatsanbieter und die Verschlüsselung im Ruhezustand mit SSE-S3 für S3-Verschlüsselung und AWS-KMS für den lokalen Festplattenschlüsselanbieter aktiviert ist**
Befehl:
```
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"
}
}
}
}'
```
Ausgabe:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
JSON-Äquivalent (Inhalt von 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"
}
}
}
}
```
Befehl (mit security\$1configuration.json):
```
aws emr create-security-configuration --name "MySecurityConfig" --security-configuration file://./security_configuration.json
```
Ausgabe:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
**2. So erstellen Sie eine Sicherheitskonfiguration mit aktiviertem Kerberos unter Verwendung von Cluster-spezifischem KDC und bereichsübergreifenden Vertrauensbeziehungen**
Befehl:
```
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"
}
}
}
}
}'
```
Ausgabe:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
JSON-Äquivalent (Inhalt von 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"
}
}
}
}
}
```
Befehl (mit security\$1configuration.json):
```
aws emr create-security-configuration --name "MySecurityConfig" --security-configuration file://./security_configuration.json
```
Ausgabe:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
+ Einzelheiten zur API finden Sie [CreateSecurityConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-security-configuration.html)in der *AWS CLI Befehlsreferenz*.
### `delete-security-configuration`
Das folgende Codebeispiel zeigt die Verwendung`delete-security-configuration`.
**AWS CLI**
**So löschen Sie eine Sicherheitskonfiguration in der aktuellen Region**
Befehl:
```
aws emr delete-security-configuration --name MySecurityConfig
```
Ausgabe:
```
None
```
+ Einzelheiten zur API finden Sie [DeleteSecurityConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/delete-security-configuration.html)in der *AWS CLI Befehlsreferenz*.
### `describe-cluster`
Das folgende Codebeispiel zeigt die Verwendung`describe-cluster`.
**AWS CLI**
Befehl:
```
aws emr describe-cluster --cluster-id j-XXXXXXXX
```
Ausgabe:
```
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"
}
}
```
+ Einzelheiten zur API finden Sie [DescribeCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-cluster.html)in der *AWS CLI Befehlsreferenz*.
### `describe-step`
Das folgende Codebeispiel zeigt die Verwendung`describe-step`.
**AWS CLI**
Mit dem folgenden Befehl wird ein Schritt mit der Schritt-ID `s-3LZC0QUT43AM` in einem Cluster mit der Cluster-ID `j-3SD91U2E1L2QX` beschrieben:
```
aws emr describe-step --cluster-id j-3SD91U2E1L2QX --step-id s-3LZC0QUT43AM
```
Ausgabe:
```
{
"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"
}
}
```
+ Einzelheiten zur API finden Sie [DescribeStep](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-step.html)in der *AWS CLI Befehlsreferenz*.
### `get`
Das folgende Codebeispiel zeigt die Verwendung`get`.
**AWS CLI**
Im folgenden Beispiel wird das Archiv `hadoop-examples.jar` von der Master-Instance in einem Cluster mit der Cluster-ID `j-3SD91U2E1L2QX` heruntergeladen:
```
aws emr get --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem --src /home/hadoop-examples.jar --dest ~
```
+ Weitere API-Informationen finden Sie unter [Get](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/get.html) in der *AWS CLI -Befehlsreferenz*.
### `list-clusters`
Das folgende Codebeispiel zeigt die Verwendung`list-clusters`.
**AWS CLI**
Mit dem folgenden Befehl werden alle aktiven EMR-Cluster in der aktuellen Region aufgelistet:
```
aws emr list-clusters --active
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-clusters.html)in der *AWS CLI Befehlsreferenz*.
### `list-instance-fleets`
Das folgende Codebeispiel zeigt die Verwendung`list-instance-fleets`.
**AWS CLI**
**So rufen Sie Konfigurationsdetails der Instance-Flotten in einem Cluster ab**
In diesem Beispiel werden die Details der Instance-Flotten im angegebenen Cluster aufgelistet.
Befehl:
```
list-instance-fleets --cluster-id 'j-12ABCDEFGHI34JK'
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListInstanceFleets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instance-fleets.html)in der *AWS CLI Befehlsreferenz*.
### `list-instances`
Das folgende Codebeispiel zeigt die Verwendung`list-instances`.
**AWS CLI**
Mit dem folgenden Befehl werden alle Instances in einem Cluster mit der Cluster-ID `j-3C6XNQ39VR9WL` aufgelistet:
```
aws emr list-instances --cluster-id j-3C6XNQ39VR9WL
```
Ausgabe:
```
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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instances.html)in der *AWS CLI Befehlsreferenz*.
### `list-security-configurations`
Das folgende Codebeispiel zeigt die Verwendung`list-security-configurations`.
**AWS CLI**
**So listen Sie Sicherheitskonfigurationen in der aktuellen Region auf**
Befehl:
```
aws emr list-security-configurations
```
Ausgabe:
```
{
"SecurityConfigurations": [
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-1"
},
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-2"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListSecurityConfigurations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-security-configurations.html)in der *AWS CLI Befehlsreferenz*.
### `list-steps`
Das folgende Codebeispiel zeigt die Verwendung`list-steps`.
**AWS CLI**
Mit dem folgenden Befehl werden alle Schritte in einem Cluster mit der Cluster-ID `j-3SD91U2E1L2QX` aufgelistet:
```
aws emr list-steps --cluster-id j-3SD91U2E1L2QX
```
+ Einzelheiten zur API finden Sie [ListSteps](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-steps.html)in der *AWS CLI Befehlsreferenz*.
### `list-studios`
Das folgende Codebeispiel zeigt die Verwendung`list-studios`.
**AWS CLI**
**Zur Liste der verfügbaren EMR Studios**
Das folgende `list-studios` Beispiel listet die EMR Studios im AWS Konto auf. :
```
aws emr list-studios
```
Ausgabe:
```
{
"Studios": [
{
"StudioId": "es-XXXXXXX132E0X7R0W7GAS1MVB",
"Name": "My_EMR_Studio",
"Url": "https://es-XXXXXXX132E0X7R0W7GAS1MVB.emrstudio-prod.us-east-1.amazonaws.com",
"AuthMode": "IAM",
"CreationTime": 1761664173.624
}
]
}
```
Weitere Informationen finden Sie unter [Überwachen, Aktualisieren und Löschen von Amazon EMR Studio-Ressourcen](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-manage-studio.html) im *Amazon EMR Management Guide*.
+ Einzelheiten zur API finden Sie [ListStudios](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-studios.html)in der *AWS CLI Befehlsreferenz*.
### `modify-cluster-attributes`
Das folgende Codebeispiel zeigt die Verwendung`modify-cluster-attributes`.
**AWS CLI**
Mit dem folgenden Befehl wird die Sichtbarkeit eines EMR-Clusters mit der ID `j-301CDNY0J5XM4` für alle Benutzer festgelegt:
```
aws emr modify-cluster-attributes --cluster-id j-301CDNY0J5XM4 --visible-to-all-users
```
+ Einzelheiten zur API finden Sie [ModifyClusterAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-cluster-attributes.html)in der *AWS CLI Befehlsreferenz*.
### `modify-instance-fleet`
Das folgende Codebeispiel zeigt die Verwendung`modify-instance-fleet`.
**AWS CLI**
**So ändern Sie die Zielkapazitäten einer Instance-Flotte**
In diesem Beispiel werden die Zielkapazitäten On-Demand und Spot für die angegebene Instance-Flotte auf 1 geändert.
Befehl:
```
aws emr modify-instance-fleet --cluster-id 'j-12ABCDEFGHI34JK' --instance-fleet InstanceFleetId='if-2ABC4DEFGHIJ4',TargetOnDemandCapacity=1,TargetSpotCapacity=1
```
+ Einzelheiten zur API finden Sie [ModifyInstanceFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-instance-fleet.html)in der *AWS CLI Befehlsreferenz*.
### `put`
Das folgende Codebeispiel zeigt die Verwendung`put`.
**AWS CLI**
Mit dem folgenden Befehl wird eine Datei namens `healthcheck.sh` in die Master-Instance in einem Cluster mit der Cluster-ID `j-3SD91U2E1L2QX` hochgeladen:
```
aws emr put --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem --src ~/scripts/healthcheck.sh --dest /home/hadoop/bin/healthcheck.sh
```
+ Weitere API-Informationen finden Sie unter [Put](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/put.html) in der *AWS CLI -Befehlsreferenz*.
### `remove-tags`
Das folgende Codebeispiel zeigt die Verwendung`remove-tags`.
**AWS CLI**
Mit dem folgenden Befehl wird ein Tag mit dem Schlüssel `prod` aus einem Cluster mit der Cluster-ID `j-3SD91U2E1L2QX` entfernt:
```
aws emr remove-tags --resource-id j-3SD91U2E1L2QX --tag-keys prod
```
+ Einzelheiten zur API finden Sie [RemoveTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/remove-tags.html)in der *AWS CLI Befehlsreferenz*.
### `schedule-hbase-backup`
Das folgende Codebeispiel zeigt die Verwendung`schedule-hbase-backup`.
**AWS CLI**
**Hinweis: Dieser Befehl kann nur mit HBase AMI-Versionen 2.x und 3.x verwendet werden**
**1. Um ein vollständiges HBase Backup zu planen >>>>>>> 06ab6d6e13564b5733d75abaf3b599f93cf39a23**
Befehl:
```
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
```
Ausgabe:
```
None
```
**2. Um ein inkrementelles Backup HBase zu planen**
Befehl:
```
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
```
Ausgabe:
```
None
```
+ Einzelheiten zur API finden Sie [ScheduleHbaseBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/schedule-hbase-backup.html)in der *AWS CLI Befehlsreferenz.*
### `socks`
Das folgende Codebeispiel zeigt die Verwendung`socks`.
**AWS CLI**
Mit dem folgenden Befehl wird eine SOCKS-Verbindung zur Master-Instance in einem Cluster mit der Cluster-ID `j-3SD91U2E1L2QX` geöffnet:
```
aws emr socks --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
Bei der optionalen Schlüsselpaardatei wird ein lokaler Pfad zu einer privaten Schlüsseldatei verwendet.
+ Weitere API-Informationen finden Sie unter [Socks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/socks.html) in der *AWS CLI -Befehlsreferenz*.
### `ssh`
Das folgende Codebeispiel zeigt die Verwendung`ssh`.
**AWS CLI**
Mit dem folgenden Befehl wird eine SSH-Verbindung zur Master-Instance in einem Cluster mit der Cluster-ID `j-3SD91U2E1L2QX` geöffnet:
```
aws emr ssh --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
Bei der optionalen Schlüsselpaardatei wird ein lokaler Pfad zu einer privaten Schlüsseldatei verwendet.
Ausgabe:
```
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 ~]$
```
+ API-Details finden Sie unter [Ssh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/ssh.html) in der *AWS CLI -Befehlsreferenz*.