# AWS CLI를 사용한 Amazon EMR 예시
다음 코드 예시에서는 Amazon EMR과 함께 AWS Command Line Interface를 사용하여 작업을 수행하고 일반적인 시나리오를 구현하는 방법을 보여줍니다.
*작업*은 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 작업은 개별 서비스 함수를 직접적으로 호출하는 방법을 보여주며 관련 시나리오의 컨텍스트에 맞는 작업을 볼 수 있습니다.
각 예시에는 전체 소스 코드에 대한 링크가 포함되어 있으며, 여기에서 컨텍스트에 맞춰 코드를 설정하고 실행하는 방법에 대한 지침을 찾을 수 있습니다.
**Topics**
+ [작업](#actions)
## 작업
### `add-instance-fleet`
다음 코드 예시에서는 `add-instance-fleet` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**클러스터에 태스크 인스턴스 플릿 추가**
이 예시에서는 지정된 클러스터에 새 태스크 인스턴스 플릿을 추가합니다.
명령:
```
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}']
```
출력:
```
{
"ClusterId": "j-12ABCDEFGHI34JK",
"InstanceFleetId": "if-23ABCDEFGHI45JJ"
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [AddInstanceFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-instance-fleet.html) 섹션을 참조하세요.
### `add-steps`
다음 코드 예시에서는 `add-steps` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**1. 클러스터에 사용자 지정 JAR 단계를 추가하는 방법**
명령:
```
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
```
필요한 파라미터:
```
Jar
```
선택적 파라미터:
```
Type, Name, ActionOnFailure, Args
```
출력:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**2. 클러스터에 스트리밍 단계를 추가하는 방법**
명령:
```
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]
```
필요한 파라미터:
```
Type, Args
```
선택적 파라미터:
```
Name, ActionOnFailure
```
JSON과 동등(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"
}
]
```
참고: JSON 인수에는 목록의 고유한 항목으로 옵션과 값이 포함되어야 합니다.
명령(step.json 사용):
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps file://./step.json
```
출력:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**3. 클러스터에 여러 파일이 있는 스트리밍 단계를 추가하는 방법(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"]
}
]
```
명령:
```
aws emr add-steps --cluster-id j-XXXXXXXX --steps file://./multiplefiles.json
```
필요한 파라미터:
```
Type, Args
```
선택적 파라미터:
```
Name, ActionOnFailure
```
출력:
```
{
"StepIds":[
"s-XXXXXXXX",
]
}
```
**4. 클러스터에 Hive 단계 추가**
명령:
```
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]
```
필요한 파라미터:
```
Type, Args
```
선택적 파라미터:
```
Name, ActionOnFailure
```
출력:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**5. 클러스터에 Pig 단계 추가**
명령:
```
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]
```
필요한 파라미터:
```
Type, Args
```
선택적 파라미터:
```
Name, ActionOnFailure
```
출력:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
**6. 클러스터에 Impala 단계를 추가하는 방법**
명령:
```
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
```
필요한 파라미터:
```
Type, Args
```
선택적 파라미터:
```
Name, ActionOnFailure
```
출력:
```
{
"StepIds":[
"s-XXXXXXXX",
"s-YYYYYYYY"
]
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [AddSteps](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-steps.html) 섹션을 참조하세요.
### `add-tags`
다음 코드 예시에서는 `add-tags` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**1. 클러스터에 태그 추가**
명령:
```
aws emr add-tags --resource-id j-xxxxxxx --tags name="John Doe" age=29 sex=male address="123 East NW Seattle"
```
출력:
```
None
```
**2. 클러스터의 태그를 나열하는 방법**
--Command:
```
aws emr describe-cluster --cluster-id j-XXXXXXYY --query Cluster.Tags
```
출력:
```
[
{
"Value": "male",
"Key": "sex"
},
{
"Value": "123 East NW Seattle",
"Key": "address"
},
{
"Value": "John Doe",
"Key": "name"
},
{
"Value": "29",
"Key": "age"
}
]
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [AddTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/add-tags.html) 섹션을 참조하세요.
### `create-cluster-examples`
다음 코드 예시에서는 `create-cluster-examples` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 예시의 대부분은 Amazon EMR 서비스 역할과 Amazon EC2 인스턴스 프로파일을 지정했다고 가정합니다. 이렇게 하지 않은 경우 필요한 각 IAM 역할을 지정하거나 클러스터를 생성할 때 `--use-default-roles` 파라미터를 사용해야 합니다. IAM 역할 지정에 대한 자세한 내용은 *Amazon EMR 관리 안내서*의 [AWS 서비스에 대한 Amazon EMR 권한에 대한 IAM 역할 구성](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html)을 참조하세요.
**예시 1: 클러스터 생성**
다음 `create-cluster` 예시에서는 클러스터를 생성합니다.
```
aws emr create-cluster \
--release-label emr-5.14.0 \
--instance-type m4.large \
--instance-count 2
```
이 명령은 출력을 생성하지 않습니다.
**예시 2: 기본 ServiceRole 및 InstanceProfile 역할을 사용하여 Amazon EMR 클러스터를 생성하는 방법**
다음 `create-cluster` 예시에서는 `--instance-groups` 구성을 사용하는 Amazon EMR 클러스터를 생성합니다.
```
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
```
**예시 3: 인스턴스 플릿을 사용하는 Amazon EMR 클러스터 생성**
다음 `create-cluster` 예시에서는 `--instance-fleets` 구성을 사용하는 Amazon EMR 클러스터를 생성하여 각 플릿에 대해 두 개의 인스턴스 유형과 두 개의 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}'}
```
**예시 4: 기본 역할로 클러스터를 생성하는 방법**
다음 `create-cluster` 예시에서는 `--use-default-roles` 파라미터를 사용하여 기본 서비스 역할 및 인스턴스 프로파일을 지정합니다.
```
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
```
**예시 5: 클러스터를 생성하고 설치할 애플리케이션을 지정하는 방법**
다음 `create-cluster` 예시에서는 `--applications` 파라미터를 사용하여 Amazon EMR이 설치하는 애플리케이션을 지정합니다. 이 예시에서는 Hadoop, Hive 및 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
```
**예시 6: 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
```
**예시 7: 클러스터 인스턴스에 사용할 사용자 지정 AMI를 지정하는 방법**
다음 `create-cluster` 예시에서는 ID가 `ami-a518e6df`인 Amazon Linux AMI를 기반으로 클러스터 인스턴스를 생성합니다.
```
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
```
**예시 8: 애플리케이션 구성을 사용자 지정하는 방법**
다음 예시에서는 `--configurations` 파라미터를 사용하여 Hadoop에 대한 애플리케이션 사용자 지정이 포함된 JSON 구성 파일을 지정합니다. 자세한 내용은 *Amazon EMR 릴리스 안내서*의 [애플리케이션 구성](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html)을 참조하세요.
`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"
}
}
]
}
]
```
다음 예시에서는 `configurations.json` 파일을 로컬 파일로 참조합니다.
```
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
```
다음 예시에서는 `configurations.json` 파일을 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
```
**예시 9: 마스터, 코어 및 태스크 인스턴스 그룹을 사용하여 클러스터를 생성하는 방법**
다음 `create-cluster` 예시에서는 `--instance-groups`를 사용하여 마스터, 코어 및 태스크 인스턴스 그룹에 사용할 EC2 인스턴스의 유형과 수를 지정합니다.
```
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
```
**예시 10: 모든 단계를 완료한 후 클러스터를 종료하도록 지정하는 방법**
다음 `create-cluster` 예시에서는 `--auto-terminate`를 사용하여 모든 단계를 완료한 후 클러스터를 자동으로 종료하도록 지정합니다.
```
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
```
**예시 11: Amazon EC2 키 페어, 네트워크 구성 및 보안 그룹과 같은 클러스터 구성 세부 정보를 지정하는 방법**
다음 `create-cluster` 예시에서는 이름이 인 Amazon EC2 키 페어`myKey`와 이름이 인 사용자 지정 인스턴스 프로파일을 사용하여 클러스터를 생성합니다`myProfile`. 키 페어는 클러스터 노드에 대한 SSH 연결을 승인하는 데 사용되며, 대부분 마스터 노드입니다. 자세한 내용은 *Amazon EMR 관리 안내서*의 [Use an Amazon EC2 Key Pair for SSH Credentials](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-access-ssh.html)를 참조하세요.
```
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
```
다음 예시에서는 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
```
다음 예시에서는 `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
```
다음 예시에서는 클러스터를 생성하고 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
```
다음 예시에서는 클러스터를 생성하고 추가 Amazon EC2 보안 그룹만 지정합니다.
```
aws emr create-cluster \
--release-label emr-5.9.0 \
--service-role myServiceRole \
--ec2-attributes InstanceProfile=myRole,AdditionalMasterSecurityGroups=[sg-addMaster1,sg-addMaster2,sg-addMaster3,sg-addMaster4],AdditionalSlaveSecurityGroups=[sg-addSlave1,sg-addSlave2,sg-addSlave3,sg-addSlave4] \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.large InstanceGroupType=CORE,InstanceCount=2,InstanceType=m4.large
```
다음 예시에서는 클러스터를 생성하고 EMR 관리형 보안 그룹과 추가 보안 그룹을 지정합니다.
```
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
```
다음 예시는 VPC 프라이빗 서브넷에 클러스터를 생성하고 특정 Amazon EC2 보안 그룹을 사용하여 프라이빗 서브넷의 클러스터에 필요한 Amazon EMR 서비스 액세스를 활성화합니다.
```
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
```
다음 예시에서는 로컬에 저장된 `ec2_attributes.json`라는 JSON 파일을 사용하여 보안 그룹 구성 파라미터를 지정합니다. 참고: JSON 인수에는 목록의 고유한 항목으로 옵션과 값이 포함되어야 합니다.
```
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
```
`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"]
}
]
```
**예시 12: 디버깅을 활성화하고 로그 URI를 지정하는 방법**
다음 `create-cluster` 예시에서는 `--enable-debugging` 파라미터를 사용하여 Amazon EMR 콘솔에서 디버깅 도구를 사용하여 로그 파일을 더 쉽게 볼 수 있습니다. `--log-uri` 파라미터에 `--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
```
**예시 13: 클러스터를 생성할 때 태그를 추가하는 방법**
태그는 클러스터를 식별하고 관리하는 데 도움이 되는 키-값 페어입니다. 다음 `create-cluster` 예시에서는 `--tags` 파라미터를 사용하여 클러스터에 대한 세 개의 태그를 생성합니다. 하나는 키 이름이 `name`, 값이 `Shirley Rodriguez`인 태그와 키 이름이 `age`, 값이 `29`인 태그, 다른 하나는 키 이름이 `department`, 값이 `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
```
다음 예시에서는 클러스터에 적용된 태그를 나열합니다.
```
aws emr describe-cluster \
--cluster-id j-XXXXXXYY \
--query Cluster.Tags
```
**예시 14: 암호화 및 기타 보안 기능을 활성화하는 보안 구성을 사용하는 방법**
다음 `create-cluster` 예시에서는 `--security-configuration` 파라미터를 사용하여 EMR 클러스터에 대한 보안 구성을 지정합니다. Amazon EMR 버전 4.8.0 이상에서 보안 구성을 사용할 수 있습니다.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--security-configuration mySecurityConfiguration
```
**예시 15: 인스턴스 그룹에 대해 구성된 추가 EBS 스토리지 볼륨을 사용하여 클러스터를 생성하는 방법**
EBS 볼륨을 추가로 지정할 때는 `VolumeType` 인수가 필요하고 `EbsBlockDeviceConfigs`가 지정된 경우 `SizeInGB`입니다.
다음 `create-cluster` 예시에서는 코어 인스턴스 그룹에서 EC2 인스턴스에 연결된 여러 EBS 볼륨이 있는 클러스터를 생성합니다.
```
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
```
다음 예시에서는 마스터 인스턴스 그룹에서 EC2 인스턴스에 연결된 여러 EBS 볼륨이 있는 클러스터를 생성합니다.
```
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
```
**예시 16: 자동 조정 정책을 사용하여 클러스터를 생성하는 방법**
Amazon EMR 버전 4.0 이상을 사용하여 코어 및 태스크 인스턴스 그룹에 자동 조정 정책을 연결할 수 있습니다. 자동 조정 정책은 Amazon CloudWatch 지표에 대한 응답으로 EC2 인스턴스를 동적으로 추가하고 제거합니다. 자세한 내용은 *Amazon EMR 관리 안내서*의 Using Automatic Scaling in Amazon EMR`\$1을 참조하세요.
자동 조정 정책을 연결할 때 `--auto-scaling-role EMR_AutoScaling_DefaultRole`을 사용하여 자동 조정에 대한 기본 역할도 지정해야 합니다.
다음 `create-cluster` 예시에서는 확장 정책 구성을 지정하는 임베디드 JSON 구조의 `AutoScalingPolicy` 인수를 사용하여 `CORE` 인스턴스 그룹에 대한 자동 확장 정책을 지정합니다. 임베디드 JSON 구조가 있는 인스턴스 그룹에는 전체 인수 모음이 작은따옴표로 묶여 있어야 합니다. 포함된 JSON 구조가 없는 인스턴스 그룹의 경우 작은따옴표를 사용하는 것은 선택 사항입니다.
```
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}]}}}]}'
```
다음 예시에서는 JSON 파일, `instancegroupconfig.json`을 사용하여 클러스터의 모든 인스턴스 그룹의 구성을 지정합니다. JSON 파일은 코어 인스턴스 그룹에 대한 자동 조정 정책 구성을 지정합니다.
```
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
```
`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}"
}
]
}
}
}
]
}
}
]
```
**예시 17: 클러스터를 생성할 때 사용자 지정 JAR 단계 추가**
다음 `create-cluster` 예시에서는 Amazon S3에 저장된 JAR 파일을 지정하여 단계를 추가합니다. 단계는 클러스터에 작업을 제출합니다. JAR 파일에 정의된 기본 함수는 EC2 인스턴스가 프로비저닝되고 부트스트랩 작업이 실행되고 애플리케이션이 설치된 후 실행됩니다. 단계는 `Type=CUSTOM_JAR`를 사용하여 지정됩니다.
사용자 지정 JAR 단계에는 JAR의 경로와 파일 이름을 지정하는 `Jar=` 파라미터가 필요합니다. 선택적 파라미터는 `Type`, `Name`, `ActionOnFailure`, `Args`, `MainClass`입니다. 지정되지 않은 경우 JAR 파일이 매니페스트 파일의 `Main-Class`를 지정해야 합니다.
```
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
```
**예시 18: 클러스터를 생성할 때 스트리밍 단계 추가**
다음 `create-cluster` 예시에서는 모든 단계가 실행된 후 종료되는 스트리밍 단계를 클러스터에 추가합니다. 스트리밍 단계에는 파라미터 `Type` 및 `Args`가 필요합니다. 스트리밍 단계 선택적 파라미터는 `Name` 및 `ActionOnFailure`입니다.
다음 예시에서는 단계를 인라인으로 지정합니다.
```
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
```
다음 예시에서는 `multiplefiles.json`이라는 로컬로 저장된 JSON 구성 파일을 사용합니다. JSON 구성은 여러 파일을 지정합니다. 한 단계에서 여러 파일을 지정하려면 JSON 구성 파일을 사용하여 단계를 지정해야 합니다. JSON 인수에는 목록의 고유한 항목으로 옵션과 값이 포함되어야 합니다.
```
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
```
`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"
}
]
```
**예시 19: 클러스터 생성 시 Hive 단계 추가**
다음 예시에서는 클러스터를 생성할 때 Hive 단계를 추가합니다. Hive 단계에는 파라미터 `Type` 및 `Args`가 필요합니다. Hive 단계의 선택적 파라미터는 `Name` 및 `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
```
**예시 20: 클러스터를 생성할 때 피그 단계를 추가하는 방법**
다음 예시에서는 클러스터를 생성할 때 Pig 단계를 추가합니다. Pig 단계 필수 파라미터는 `Type` 및 `Args`입니다. Pig 단계 선택적 파라미터는 `Name` 및 `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
```
**예시 21: 부트스트랩 작업 추가**
다음 `create-cluster` 예시에서는 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
```
**예시 22: EMRFS 일관된 보기를 활성화하고 RetryCount 및 RetryPeriod 설정을 사용자 지정하는 방법**
다음 `create-cluster` 예시에서는 EMRFS 일관성 있는 보기에 대한 재시도 횟수 및 재시도 기간을 지정합니다. `Consistent=true` 인수는 필수입니다.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs Consistent=true,RetryCount=6,RetryPeriod=30
```
다음 예시에서는 `emrfsconfig.json`이라는 로컬로 저장된 JSON 구성 파일을 사용하여 이전 예시와 동일한 EMRFS 구성을 지정합니다.
```
aws emr create-cluster \
--instance-type m4.large \
--release-label emr-5.9.0 \
--emrfs file://emrfsconfig.json
```
`emrfsconfig.json`의 콘텐츠:
```
{
"Consistent": true,
"RetryCount": 6,
"RetryPeriod": 30
}
```
**예시 23: Kerberos가 구성된 클러스터 생성**
다음 `create-cluster` 예시에서는 Kerberos가 활성화된 보안 구성을 사용하여 클러스터를 생성하고 `--kerberos-attributes`를 사용하여 클러스터에 대한 Kerberos 파라미터를 설정합니다.
다음 명령은 클러스터 인라인에 대한 Kerberos 속성을 지정합니다.
```
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
```
다음 명령은 동일한 속성을 지정하지만 `kerberos_attributes.json`이라는 로컬로 저장된 JSON 파일을 참조합니다. 이 예시에서는 명령을 실행하는 디렉터리에 파일이 저장됩니다. 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
```
`kerberos_attributes.json`의 콘텐츠:
```
{
"Realm": "EC2.INTERNAL",
"KdcAdminPassword": "123",
"CrossRealmTrustPrincipalPassword": "123",
}
```
다음 `create-cluster` 예시에서는 `--instance-groups` 구성을 사용하고 관리형 크기 조정 정책이 있는 Amazon EMR 클러스터를 생성합니다.
```
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}'
```
다음 `create-cluster` 예시에서는 '--log-encryption-kms-key-id'를 사용하여 로그 암호화에 사용되는 KMS 키 ID를 정의하는 Amazon EMR 클러스터를 생성합니다.
```
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
```
다음 `create-cluster` 예시에서는 배치 `SPREAD` 전략을 사용하여 EC2 배치 그룹 내의 고가용성(HA) 클러스터에 마스터 노드를 배치하기 위해 “--placement-group-configs” 구성을 사용하는 Amazon EMR 클러스터를 생성합니다.
```
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
```
다음 `create-cluster` 예시에서는 '--auto-termination-policy' 구성을 사용하여 클러스터에 대한 자동 유휴 종료 임계값을 배치하는 Amazon EMR 클러스터를 생성합니다.
```
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
```
다음 `create-cluster` 예시에서는 '-os-release-label'을 사용하여 클러스터 시작을 위한 Amazon Linux 릴리스를 정의하는 Amazon EMR 클러스터를 생성합니다.
```
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
```
**예시 24: EBS 루트 볼륨 속성 지정: EMR 릴리스 6.15.0 이상으로 생성된 클러스터 인스턴스의 크기, iops 및 처리량**
다음 `create-cluster` 예시에서는 루트 볼륨 속성을 사용하여 EC2 인스턴스에 대한 루트 볼륨 사양을 구성하는 Amazon EMR 클러스터를 생성합니다.
```
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
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [CreateClusterExamples](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-cluster-examples.html) 섹션을 참조하세요.
### `create-default-roles`
다음 코드 예시에서는 `create-default-roles` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**1. EC2에 대한 기본 IAM 역할을 생성하는 방법**
명령:
```
aws emr create-default-roles
```
출력:
```
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"
}
}
]
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [CreateDefaultRoles](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-default-roles.html) 섹션을 참조하세요.
### `create-security-configuration`
다음 코드 예시에서는 `create-security-configuration` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**1. 인증서 공급자의 경우 PEM으로 전송 중 암호화를 활성화하고, S3의 경우 SSSE-S3로 저장 중 암호화를 활성화하고, 로컬 디스크 키 공급자의 경우 AWS-KMS로 보안 구성을 생성하는 방법**
명령:
```
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"
}
}
}
}'
```
출력:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
JSON과 동등(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"
}
}
}
}
```
명령(security\$1configuration.json 사용):
```
aws emr create-security-configuration --name "MySecurityConfig" --security-configuration file://./security_configuration.json
```
출력:
```
{
"CreationDateTime": 1474070889.129,
"Name": "MySecurityConfig"
}
```
**2. 클러스터 전용 KDC 및 교차 영역 신뢰를 사용하여 Kerberos가 활성화된 보안 구성을 생성하는 방법**
명령:
```
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"
}
}
}
}
}'
```
출력:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
JSON과 동등(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"
}
}
}
}
}
```
명령(security\$1configuration.json 사용):
```
aws emr create-security-configuration --name "MySecurityConfig" --security-configuration file://./security_configuration.json
```
출력:
```
{
"CreationDateTime": 1490225558.982,
"Name": "MySecurityConfig"
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [CreateSecurityConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-security-configuration.html) 섹션을 참조하세요.
### `delete-security-configuration`
다음 코드 예시에서는 `delete-security-configuration` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**현재 리전에서 보안 구성을 삭제하는 방법**
명령:
```
aws emr delete-security-configuration --name MySecurityConfig
```
출력:
```
None
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [DeleteSecurityConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/delete-security-configuration.html) 섹션을 참조하세요.
### `describe-cluster`
다음 코드 예시에서는 `describe-cluster` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
명령:
```
aws emr describe-cluster --cluster-id j-XXXXXXXX
```
출력:
```
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"
}
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [DescribeCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-cluster.html)를 참조하세요.
### `describe-step`
다음 코드 예시에서는 `describe-step` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 명령은 클러스터 ID가 `j-3SD91U2E1L2QX`인 클러스터에서 단계 ID가 `s-3LZC0QUT43AM`인 단계를 설명합니다.
```
aws emr describe-step --cluster-id j-3SD91U2E1L2QX --step-id s-3LZC0QUT43AM
```
출력:
```
{
"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"
}
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [DescribeStep](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/describe-step.html)을 참조하세요.
### `get`
다음 코드 예시에서는 `get` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음은 클러스터 ID가 `j-3SD91U2E1L2QX`인 클러스터의 마스터 인스턴스에서 `hadoop-examples.jar` 아카이브를 다운로드합니다.
```
aws emr get --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem --src /home/hadoop-examples.jar --dest ~
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [Get](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/get.html) 섹션을 참조하세요.
### `list-clusters`
다음 코드 예시에서는 `list-clusters` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 명령은 현재 리전의 모든 활성 EMR 클러스터를 나열합니다.
```
aws emr list-clusters --active
```
출력:
```
{
"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"
}
]
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [ListClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-clusters.html)를 참조하세요.
### `list-instance-fleets`
다음 코드 예시에서는 `list-instance-fleets` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**클러스터 내 인스턴스 플릿의 구성 세부 정보 가져오기**
이 예시에서는 지정된 클러스터의 인스턴스 플릿에 대한 세부 정보를 나열합니다.
명령:
```
list-instance-fleets --cluster-id 'j-12ABCDEFGHI34JK'
```
출력:
```
{
"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"
}
]
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [ListInstanceFleets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instance-fleets.html) 섹션을 참조하세요.
### `list-instances`
다음 코드 예시에서는 `list-instances` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 명령은 클러스터 ID가 `j-3C6XNQ39VR9WL`인 클러스터의 모든 인스턴스를 나열합니다.
```
aws emr list-instances --cluster-id j-3C6XNQ39VR9WL
```
출력:
```
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"
}
]
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [ListInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-instances.html) 섹션을 참조하세요.
### `list-security-configurations`
다음 코드 예시에서는 `list-security-configurations` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**현재 리전의 보안 구성을 나열하는 방법**
명령:
```
aws emr list-security-configurations
```
출력:
```
{
"SecurityConfigurations": [
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-1"
},
{
"CreationDateTime": 1473889697.417,
"Name": "MySecurityConfig-2"
}
]
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [ListSecurityConfigurations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-security-configurations.html) 섹션을 참조하세요.
### `list-steps`
다음 코드 예시에서는 `list-steps` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 명령은 클러스터 ID가 `j-3SD91U2E1L2QX`인 클러스터의 모든 단계를 나열합니다.
```
aws emr list-steps --cluster-id j-3SD91U2E1L2QX
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [ListSteps](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/list-steps.html)를 참조하세요.
### `modify-cluster-attributes`
다음 코드 예시에서는 `modify-cluster-attributes` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 명령은 ID가 `j-301CDNY0J5XM4`인 EMR 클러스터의 가시성을 모든 사용자에게 설정합니다.
```
aws emr modify-cluster-attributes --cluster-id j-301CDNY0J5XM4 --visible-to-all-users
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [ModifyClusterAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-cluster-attributes.html) 섹션을 참조하세요.
### `modify-instance-fleet`
다음 코드 예시에서는 `modify-instance-fleet` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**인스턴스 플릿의 대상 캐패시터를 변경하는 방법**
이 예시에서는 지정된 인스턴스 플릿에 대해 온디맨드 및 스팟 대상 용량을 1로 변경합니다.
명령:
```
aws emr modify-instance-fleet --cluster-id 'j-12ABCDEFGHI34JK' --instance-fleet InstanceFleetId='if-2ABC4DEFGHIJ4',TargetOnDemandCapacity=1,TargetSpotCapacity=1
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [ModifyInstanceFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/modify-instance-fleet.html) 섹션을 참조하세요.
### `put`
다음 코드 예시에서는 `put` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 명령은 클러스터 ID가 `j-3SD91U2E1L2QX`인 클러스터의 마스터 인스턴스에 `healthcheck.sh`라는 파일을 업로드합니다.
```
aws emr put --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem --src ~/scripts/healthcheck.sh --dest /home/hadoop/bin/healthcheck.sh
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [Put](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/put.html) 섹션을 참조하세요.
### `remove-tags`
다음 코드 예시에서는 `remove-tags` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 명령은 클러스터 ID가 `j-3SD91U2E1L2QX`인 클러스터에서 키가 `prod`인 태그를 제거합니다.
```
aws emr remove-tags --resource-id j-3SD91U2E1L2QX --tag-keys prod
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [RemoveTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/remove-tags.html) 섹션을 참조하세요.
### `schedule-hbase-backup`
다음 코드 예시에서는 `schedule-hbase-backup` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
**참고: 이 명령은 AMI 버전 2.x 및 3.x의 HBase에서만 사용할 수 있습니다.**
**1. 전체 HBase 백업을 예약하는 방법** >>>>>>> 06ab6d6e13564b5733d75abaf3b599f93cf39a23
명령:
```
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
```
출력:
```
None
```
**2. 증분 HBase 백업을 예약하는 방법**
명령:
```
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
```
출력:
```
None
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [ScheduleHbaseBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/schedule-hbase-backup.html) 섹션을 참조하세요.
### `socks`
다음 코드 예시에서는 `socks` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 명령은 클러스터 ID가 `j-3SD91U2E1L2QX`인 클러스터의 마스터 인스턴스와 양말 연결을 엽니다.
```
aws emr socks --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
키 페어 파일 옵션은 프라이빗 키 파일의 로컬 경로를 가져옵니다.
+ API 세부 정보는 *AWS CLI 명령 참조*의 [Socks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/socks.html) 섹션을 참조하세요.
### `ssh`
다음 코드 예시에서는 `ssh` 코드를 사용하는 방법을 보여줍니다.
**AWS CLI**
다음 명령은 클러스터 ID가 `j-3SD91U2E1L2QX`인 클러스터의 마스터 인스턴스와 ssh 연결을 엽니다.
```
aws emr ssh --cluster-id j-3SD91U2E1L2QX --key-pair-file ~/.ssh/mykey.pem
```
키 페어 파일 옵션은 프라이빗 키 파일의 로컬 경로를 가져옵니다.
출력:
```
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 세부 정보는 *AWS CLI 명령 참조*의 [Ssh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/ssh.html) 섹션을 참조하세요.