검토-실습

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-18weo4vv83ynk" --change-type-version "1.0" --title "Create ALB Listener Rule" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-CreateListenerRule\",\"Parameters\":{\"ListenerArn\":[\"LISTENER_ARN\"],\"Conditions\":[\"{\\\"Field\\\":\\\"path-pattern\\\",\\\"PathPatternConfig\\\":{\\\"Values\\\":[\\\"/img/*\\\"]}}\"],\"RuleType\":[\"redirect\"],\"Priority\":[\"200\"],\"TargetGroups\":[\"{}\"],\"TargetGroupStickinessConfig\":[\"\"],\"TargetGroupStickinessDuration\":[\"\"],\"RedirectProtocol\":[\"HTTP\"],\"RedirectPort\":[\"85\"],\"RedirectHost\":[\"www.example.com\"],\"RedirectPath\":[\"/new-path\"],\"RedirectQuery\":[\"page1\"],\"RedirectStatusCode\":[\"HTTP_301\"]},\"Region\":\"REGION\""}"

aws amscm create-rfc --change-type-id "ct-18weo4vv83ynk" --change-type-version "1.0" --title "Create ALB Listener Rule" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-CreateListenerRule\",\"Parameters\":{\"ListenerArn\":[\"LISTENER_ARN\"],\"Conditions\":[\"{\\\"Field\\\":\\\"path-pattern\\\",\\\"PathPatternConfig\\\":{\\\"Values\\\":[\\\"/img/*\\\"]}}\"],\"RuleType\":[\"forward\"],\"Priority\":[\"125\"],\"TargetGroups\":[\"{\\\"TargetGroupArn\\\":\\\"TARGET_GROUP_ARN\\\",\\\"Weight\\\":\\\"20\\\"}\"],\"TargetGroupStickinessConfig\":[\"Enabled\"],\"TargetGroupStickinessDuration\":[\"15\"],\"RedirectProtocol\":[\"\"],\"RedirectPort\":[\"\"],\"RedirectHost\":[\"\"],\"RedirectPath\":[\"\"],\"RedirectQuery\":[\"\"],\"RedirectStatusCode\":[\"\"]},\"Region\":\"REGION\"}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 validateCreateRule.Actions.json.

   aws amscm get-change-type-version --change-type-id "ct-18weo4vv83ynk" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > validateCreateRule.Actions.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   모든 파라미터 예제:

   {
   "DocumentName": "AWSManagedServices-CreateListenerRule",
   "Region": "us-west-2",
   "Parameters": {
     "ListenerArn": ["LISTENER_ARN"],
     "Conditions": ["{\"Field\":\"host-header\",\"HostHeaderConfig\":{\"Values\":[\"example.com\"]}}"],
     "RuleType": ["forward"],
     "Priority": ["200"],
     "TargetGroups": ["{\"TargetGroupArn\":\"TARGET_GROUP_ARN\",\"Weight\":\"100\"}"],
     "TargetGroupStickinessConfig": ["Enabled"],
     "TargetGroupStickinessDuration": ["86400"],
     "RedirectProtocol": [""],
     "RedirectPort": [""],
     "RedirectHost": [""],
     "RedirectPath": [""],
     "RedirectQuery": [""],
     "RedirectStatusCode": [""],
     "Priority": "High"
   }
   }  

   {
   "DocumentName": "AWSManagedServices-CreateListenerRule",
   "Parameters": {
     "ListenerArn": [
       "LISTENER_ARN"
     ],
     "Conditions": [
       "{\"Field\":\"path-pattern\",\"PathPatternConfig\":{\"Values\":[\"/img/*\"]}}"
     ],
     "RuleType": [
       "forward"
     ],
     "Priority": [
       "125"
     ],
     "TargetGroups": [
       "{\"TargetGroupArn\":\"TARGET_GROUP_ARN\",\"Weight\":\"20\"}"
     ],
     "TargetGroupStickinessConfig": [
       "Enabled"
     ],
     "TargetGroupStickinessDuration": [
       "15"
     ],
     "RedirectProtocol": [
       ""
     ],
     "RedirectPort": [
       ""
     ],
     "RedirectHost": [
       ""
     ],
     "RedirectPath": [
       ""
     ],
     "RedirectQuery": [
       ""
     ],
     "RedirectStatusCode": [
       ""
     ]
   },
   "Region": "REGION",
   "Priority": "High"
   }

3. JSON 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 CreateListenerRuleRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateListenerRuleRfc.json

4. CreateListenerRuleRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion": "1.0",
   "ChangeTypeId": "ct-18weo4vv83ynk",
   "Title": "Create ALB Listener Rule"
   }

5. 실행 파라미터 파일과 validateCreateRule 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateListenerRuleRfc.json  --execution-parameters file://validateCreateRule.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-128mp7mbxobd0" --change-type-version "1.0" --title "Update VPC Endpoint Policy" --execution-parameters "{\"Region\":\"us-east-1\",\"VpcEndpointId\":\"vpce-1a2b3c4d5e6f7g8h9\",\"PolicyDocument\":\"Example endpoint policy\",\"PolicyAction\":\"Append\",\"Priority\":\"High\"}

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 출력합니다.이 예제에서는 이름을 UpdateVPCEndpointPolicyParams.json:으로 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-128mp7mbxobd0" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateVPCEndpointPolicyParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "Region": "us-east-1",
   "VpcEndpointId": "vpce-1a2b3c4d5e6f7g8h9",
   "PolicyDocument":"Example endpoint policy"
   "PolicyAction" : "Append",
   "Priority": "High"
   }

3. RFC 템플릿 JSON 파일을 출력합니다.이 예제에서는 이름을 UpdateVPCEndpointPolicyRFC.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateVPCEndpointPolicyRFC.json

4. UpdateVPCEndpointPolicyRFC.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion": "1.0",
   "ChangeTypeId": "ct-128mp7mbxobd0",
   "Title": "Update VPC Endpoint Policy"
   }  

5. UpdateVPCEndpointPolicyRFC 파일과 UpdateVPCEndpointPolicyParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateVPCEndpointPolicyRFC.json --execution-parameters file://UpdateVPCEndpointPolicyParams.json
   

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-1rexstryxye1b" --change-type-version "1.0" --title "Delete NAT Gateway" --execution-parameters "{\"Region\":\"us-east-1\",\"NatGatewayId\":[\"nat-1234567890abcdef0\"],\"Priority\":\"High\"}"

템플릿 생성:

1. 실행 파라미터 JSON 스키마를 현재 폴더의 파일로 출력합니다. 이 예제에서는 DeleteNATGatewayParams.json.

   aws amscm get-change-type-version --change-type-id "ct-1rexstryxye1b" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DeleteNATGatewayParams.json
   

2. DeleteNATGatewayParams.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "Region": "us-west-1",
   "NatGatewayId": "nat-1234567890abcdef0"
   "Priority": "High"
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다. 이 예제에서는 DeleteNATGatewayRfc.json.

   aws amscm create-rfc --generate-cli-skeleton > DeleteNATGatewayRfc.json

4. DeleteNATGatewayRfc.json 파일을 수정하고 저장합니다.

   ExecutionParameters JSON 확장의 내부 따옴표는 백슬래시(\)로 이스케이프 처리해야 합니다. 예시

   {
   "ChangeTypeVersion": "1.0",
   "ChangeTypeId": "ct-1rexstryxye1b",
   "Title": "Delete-NAT-Gateway"
   }

5. RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://DeleteNATGatewayRfc.json  --execution-parameters file://DeleteNATGatewayParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-2o1knqxw39mkc" --change-type-version "1.0" --title "Update IMDS region-level default settings" --execution-parameters "{\"Region\":\"us-west-2\",\"HttpEndpoint\":\"Enabled\",\"HttpTokens\":\"Required\",\"InstanceMetadataTags\":\"Enabled\",\"HttpPutResponseHopLimit\":1,\"Priority\":\"High\"}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 JSON 파일로 출력합니다.이 예제에서는 이름을 UPdateEC2ImdsRegionParams.json:으로 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-2o1knqxw39mkc" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateEC2ImdsRegionParams.json

2. 변경하려는 파라미터만 유지하면서 UPdateEC2ImdsRegionParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "Region": "us-west-2",
   "HttpEndpoint": "Enabled",
   "HttpTokens":"Required"
   "InstanceMetadataTags" : "Enabled",
   "HttpPutResponseHopLimit": 1,
   "Priority": "High"
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 이름을 UPdateEC2ImdsRegionRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UPdateEC2ImdsRegionRfc.json

4. UPdateEC2ImdsRegionRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion": "1.0",
   "ChangeTypeId": "ct-2o1knqxw39mkc",
   "Title": "Update IMDS region-level default settings"
   }

5. UPdateEC2ImdsRegionRfc 파일과 UPdateEC2ImdsRegionParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UPdateEC2ImdsRegionRfc.json  --execution-parameters file://UPdateEC2ImdsRegionParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-0ulaleq7ohuyq" --change-type-version "1.0" --title "Create service principal names" --execution-parameters "{ \"DocumentName\": \"AWSManagedServices-CreateADSPN-Admin\", \"Region\": \"us-east-1\", \"Parameters\": { \"ServiceType\": \"MSSQLSvc\", \"Hostnames\": \"server1,server2\", \"ServiceAccountName\": \"gmsa_sql\" } }"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 이름을 ComputerObjectCreateSpnParams.json:으로 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-0ulaleq7ohuyq" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > ComputerObjectCreateSpnParams.json

   ComputerObjectCreateSpnParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "DocumentName": "AWSManagedServices-CreateADSPN-Admin",
       "Region": "us-east-1",
       "Parameters": {
         "ServiceType": ["HOST"],
         "Hostnames": "server1",
         "ServiceAccountName": "gmsa_host",
         "Port": ["1433"],
         "ApplicationAccountId": "123456789012"
       }
   }

2. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 ComputerObjectCreateSpnRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > ComputerObjectCreateSpnRfc.json

3. ComputerObjectCreateSpnRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion": "1.0",
   "ChangeTypeId": "ct-0ulaleq7ohuyq",
   "Title": "Create service principal names"
   }

4. ComputerObjectCreateSpnRfc 파일과 ComputerObjectCreateSpnParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://ComputerObjectCreateSpnRfc.json --execution-parameters file://ComputerObjectCreateSpnParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-0akjahmgqhu4u" --change-type-version "1.0" --title "Delete Target Group" --execution-parameters "{\"Region\":\"us-west-2\",\"TargetGroupArns\":[\"arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067\"],\"Priority\":\"High\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 JSON 파일로 출력합니다.이 예제에서는 이름을 TgDeleteParams.json.

   aws amscm get-change-type-version --change-type-id "ct-0akjahmgqhu4u" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > TgDeleteParams.json

2. TgDeleteParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "Region": "us-west-2",
   "TargetGroupArns": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067"
   "Priority": "High"
   }

3. RFC 템플릿을 TgDeleteRfc.json:이라는 현재 폴더의 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > TgDeleteRfc.json

4. TgDeleteRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion": "1.0",
   "ChangeTypeId": "ct-0akjahmgqhu4u",
   "Title": "Delete Target Group"
   }

5. TgDeleteRfc 파일과 TgDeleteParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://TgDeleteRfc.json --execution-parameters file://TgDeleteParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm  --profile saml --region us-east-1 create-rfc --change-type-id "ct-111r1yayblnw4" --change-type-version "3.0" --title 'Create ALB' --description "My Test ALB"  --execution-parameters ""{\"Description\":\"Test ALB\",\"VpcId\":\"VPC_ID\",\"Name\":\"TestStack\",\"StackTemplateId\":\"stm-sd7uv500000000000\",\"TimeoutInMinutes\":360,\"LoadBalancer\":{\"SecurityGroups\":[\"SG_ID\"],\"SubnetIds\":[\"SUBNET_ID\",\"SUBNET_ID\"]},\"Listener1\":{\"Port\":\"443\",\"Protocol\":\"HTTPS\"}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 JSON 파일로 출력합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   aws amscm get-change-type-version --change-type-id "ct-111r1yayblnw4" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateAlbParams.json

2. CreateAlbParams 파일을 수정하고 저장합니다. 예:

   {
   "Description":      "ALB-Create", 
   "VpcId":            "VPC_ID",
   "Name":             "My-ALB",
   "StackTemplateId":  "stm-sd7uv500000000000",
   "TimeoutInMinutes" : 360,
   "LoadBalancer" : {
       "SecurityGroups" : ["SG_ID"],
       "SubnetIds" : ["SUBNET_ID", "SUBNET_ID"]
     },
     "Listener1" : {
       "Port" : "443",
       "Protocol" : "HTTPS"
     }
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateAlbRfc.json

4. CreateAlbRfc.json 파일을 수정하고 저장합니다. 예:

   {
   "ChangeTypeVersion":    "3.0",	
   "ChangeTypeId":         "ct-111r1yayblnw4",
   "Title":                "ALB-Create-RFC"
   }

5. CreateAlbRfc 파일과 CreateAlbParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateAlbRfc.json --execution-parameters file://CreateAlbParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --title Test-Update-ALB --change-type-id ct-1a1zzgi2nb83d --change-type-version 3.0 --execution-parameters '{"Description":"Updating Test ALB","VpcId":"VPC_ID","StackTemplateId":"stm-sd7uv500000000000","Name":"Test-Application-LoadBalancer","TimeoutInMinutes":360,"Parameters":{"TargetGroupHealthCheckPath": "/myAppHealth"}}'

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 JSON 파일로 출력합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   aws amscm get-change-type-version --change-type-id "ct-111r1yayblnw4" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateAlbParams.json

2. UpdateAlbParams 파일을 수정하고 저장합니다. 예:

   {
   "Description":      "ALB-Update", 
   "VpcId":            "VPC_ID",
   "Name":             "My-ALB",
   "StackTemplateId":  "stm-sd7uv500000000000",
   "TimeoutInMinutes" : 360,
   "Parameters": {
       "LoadBalancerSecurityGroups": [
         "sg-1234567890abcdef0"
       ],
       "LoadBalancerSubnetIds": [
         "subnet-1234567890abcdef0",
         "subnet-1234567890abcdef1"
       ],
       "LoadBalancerDeletionProtection": "false",
       "LoadBalancerIdleTimeout": "60",
       "Listener1Port": "443",
       "Listener1Protocol": "HTTPS",
       "Listener1SSLCertificateArn": "arn:aws:acm:ap-southeast-2:012345678912:certificate/e23c3545-e92d-4542-83b8-63483505b5a5",
       "Listener1SSLPolicy": "ELBSecurityPolicy-TLS-1-2-Ext-2018-06",
       "Listener2Port": "8080",
       "Listener2Protocol": "HTTP",
       "TargetGroupHealthCheckInterval": "10",
       "TargetGroupHealthCheckPath": "/thing/index.html",
       "TargetGroupHealthCheckPort": "8080",
       "TargetGroupHealthCheckProtocol": "HTTP",
       "TargetGroupHealthCheckTimeout": "10",
       "TargetGroupHealthyThreshold": "2",
       "TargetGroupUnhealthyThreshold": "10",
       "TargetGroupValidHTTPCode": "200",
       "TargetGroupDeregistrationDelayTimeout": "300",
       "TargetGroupSlowStartDuration": "30",
       "TargetGroupCookieExpirationPeriod": "20"
     }
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateAlbRfc.json

4. UpdateAlbRfc.json 파일을 수정하고 저장합니다. 예:

   {
   "ChangeTypeVersion":    "3.0",	
   "ChangeTypeId":         "ct-111r1yayblnw4",
   "Title":                "ALB-Update-RFC"
   }

5. UpdateAlbRfc 파일과 UpdateAlbParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateAlbRfc.json --execution-parameters file://UpdateAlbParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws --profile saml --region us-east-1 amscm create-rfc --change-type-id "ct-14yjom3kvpinu" --change-type-version "2.0" --title "TITLE" --execution-parameters "{\"Description\":\"DESCRIPTION\", \"VpcId\":\"VPC_ID\", \"StackTemplateId\": \"stm-u5n0r6aacdvdwthhm\", \"Name\":\"NAME\", \"TimeoutInMinutes\":60, \"Parameters\": {\"LoadBalancerArn\":\"LB-ARN",\"DefaultActionTargetGroupArn\":\"TARGET-GROUP-ARN",\"Port\":\"80\",\"Protocol\":\"HTTP\"}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 JSON 파일로 출력합니다.이 예제에서는 CreateListenerParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-14yjom3kvpinu" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateListenerParams.json

2. CreateListenerParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "Description":      "Listener-Create", 
   "VpcId":            "VPC_ID", 
   "StackTemplateId":  "stm-u5n0r6aacdvdwthhm", 
   "Name":             "My-Listener",
   
   "Parameters":   {
       "LoadBalancerArn":               ARN,
       "DefaultActionTargetGroupArn":   ARN,
       "Port":                          PORT,
       "Protocol":                     Protocol"
       }
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 CreateListenerRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateListenerRfc.json

4. CreateListenerRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "2.0",	
   "ChangeTypeId":         "ct-14yjom3kvpinu",
   "Title":                "Listener-Create-RFC"
   }

5. CreateListenerRfc 파일과 CreateListenerParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateListenerRfc.json --execution-parameters file://CreateListenerParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

   다음 단계: 관리 제출 | 기타 | 기타 | 변경 유형을 업데이트하여 포트를 열고 보안 그룹을 연결합니다. 기타 | 기타 요청을 참조하세요.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 현재 폴더의 파일로 출력합니다.이 예제에서는 CreateOnetierStackParams.json.

   aws amscm get-change-type-version --change-type-id "ct-09t6q7j9v5hrn" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateOnetierStackParams.json

2. 스키마를 수정하여 변수를 적절하게 바꿉니다.

   {
       "Description":          "HA-One-Tier-Stack",
       "Name":                 "One-Tier-Stack",
       "TimeoutInMinutes":     "360",
       "VpcId":                "VPC_ID",
       "ApplicationLoadBalancer": {
           "SubnetIds": [
                     "SUBNET_ID",
                     "SUBNET_ID"
           ]
       },
       "AutoScalingGroup": {
           "AmiId": "AMI-ID"
           "SubnetIds": [
                    "SUBNET_ID",
                    "SUBNET_ID"
           ]
       }
   }

3. CreateRfc JSON 템플릿을 현재 폴더의 파일로 출력합니다. 예제 이름은 CreateOnetierStackRfc.json:.

   aws amscm create-rfc --generate-cli-skeleton > CreateOnetierStackRfc.json

4. RFC 템플릿을 적절하게 수정하고 저장합니다. 예약된 RFC의 시작 및 종료 시간을 재설정하거나 ASAP RFC의 경우 종료합니다.

   {
   "ChangeTypeVersion":    2.0",
   "ChangeTypeId":         "ct-09t6q7j9v5hrn",
   "Title":                "HA-One-Tier-RFC",
   "RequestedStartTime":   "2019-04-28T22:45:00Z",
   "RequestedEndTime":     "2019-04-28T22:45:00Z"
   }

5. CreateOnetierStackRfc.json 파일과 CreateOnetierStackParams.json 실행 파라미터 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateOnetierStackRfc.json --execution-parameters file://CreateOnetierStackParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-3dpd8mdd9jn1r" --change-type-version "1.0" --title "TestIamCreate" --execution-parameters "{\"UseCase\":\"IAM_RESOURCE_DETAILS\",\"IAM Role\":[{\"RoleName\":\"ROLE_NAME\",\"TrustPolicy\":\"TRUST_POLICY\",\"RolePermissions\":\"ROLE_PERMISSIONS\"}],\"Operation\":\"Create\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다. 예제 이름은 CreateIamResourceParams.json:.

   aws amscm get-change-type-version --change-type-id "ct-3dpd8mdd9jn1r" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateIamResourceParams.json

2. CreateIamResourceParams 파일을 수정하고 저장합니다. 예제에서는 정책 문서를 인라인으로 붙여넣은 IAM 역할을 생성합니다.

   {
     "UseCase": "IAM_RESOURCE_DETAILS",
     "IAM Role": [
       {
         "RoleName": "codebuild_ec2_test_role",
         "TrustPolicy": {
           "Version": "2008-10-17",
           "Statement": [
             {
               "Effect": "Allow",
               "Principal": {
                 "Service": "codebuild.amazonaws.com"
               },
               "Action": "sts:AssumeRole"
             }
           ]
         },
         "RolePermissions": {
           "Version": "2012-10-17",
           "Statement": [
             {
               "Effect": "Allow",
               "Action": [
                 "ec2:DescribeInstanceStatus"
               ],
               "Resource": "*"
             }
           ]
         }
       }
     ],
     "Operation": "Create"
   }

3. RFC 템플릿 JSON 파일을 CreateIamResourceRfc.json:이라는 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateIamResourceRfc.json

4. CreateIamResourceRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion": "1.0",
   "ChangeTypeId": "ct-3dpd8mdd9jn1r",
   "Title": "Create IAM Role"
   }

5. CreateIamResourceRfc 파일과 CreateIamResourceParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateIamResourceRfc.json  --execution-parameters file://CreateIamResourceParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-32r1igwrwag4i" --change-type-version "1.0" --title "Continue Update Rollback" --execution-parameters "{\"StackId\":\"STACK_ID\",\"Region\":\"REGION\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 현재 폴더의 파일로 출력합니다.이 예제에서는 ContinueRollbackParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-32r1igwrwag4i" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > ContinueRollbackParams.json

2. ContinueRollbackParams.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "StackId": "stack-a1b2c3d4e5f67890e",
       "Region": "us-east-1",
       "Priority": "High"
   }

3. CreateRfc용 JSON 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 ContinueRollbackRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > ContinueRollbackRfc.json

4. ContinueRollbackRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion": "1.0",
     "ChangeTypeId": "ct-32r1igwrwag4i",
     "Title": "Continue Update Rollback"
   }

5. ContinueRollbackRfc 파일과 실행 파라미터 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://ContinueRollbackRfc.json --execution-parameters file://ContinueRollbackParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프 표시)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-1pqxczuw5uwu6" --change-type-version "1.0" --title "AWSManagedServices-ManageSubnetPublicIpv4AutoAssign" --execution-parameters "{\"DocumentName\": \"AWSManagedServices-ManageSubnetPublicIpv4AutoAssign\",\"Region\": \"us-east-1\",\"Parameters\": {\"SubnetId\": \"subnet-0a1b2c3d4e5f67890\", \"MapPublicIpOnLaunch\": true, \"AcknowledgeNetworkImpact\": [\"Yes\"]}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 출력합니다.이 예제에서는 ManageSubnetAutoAddressParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-1pqxczuw5uwu6" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > ManageSubnetAutoAddressParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
    "DocumentName": "AWSManagedServices-ManageSubnetPublicIpv4AutoAssign",
    "Region": "us-east-1",
    "Parameters": {
        "SubnetId": "subnet-0a1b2c3d4e5f67890",
        "MapPublicIpOnLaunch": true,
        "AcknowledgeNetworkImpact": [
            "Yes"
        ]
    }
   }

3. RFC 템플릿 JSON 파일을 출력합니다.이 예제에서는 ManageSubnetAutoAddressRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > ManageSubnetAutoAddressRfc.json

4. ManageSubnetAutoAddressRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion" : "1.0",
     "ChangeTypeId" : "ct-1pqxczuw5uwu6",
     "Title" : "ManageSubnetAutoAddress"
   }

5. ManageSubnetAutoAddressRfc 파일과 ManageSubnetAutoAddressParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://ManageSubnetAutoAddressRfc.json  --execution-parameters file://ManageSubnetAutoAddressParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-2bxelbn765ive" --change-type-version "1.0" --title "Add a schedule for AMS Resource Scheduler" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-AddOrUpdateSchedule\",\"Region\":\"us-east-1\",\"Parameters\":{\"Action\":[\"add\"],\"Name\":[\"Schedule01\"],\"Description\":[\"Test schedule\"],\"Hibernate\":[\"true\"],\"Enforced\":[\"false\"],\"OverrideStatus\":[\"running\"],\"Periods\":[\"period01\",\"period02\"],\"RetainRunning\":[\"false\"],\"StopNewInstances\":[\"true\"],\"SSMMaintenanceWindow\":[\"window01\"],\"TimeZone\":[\"Australia/Sydney\"],\"UseMaintenanceWindow\":[\"true\"],\"UseMetrics\":[\"false\"]}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 JSON 파일로 출력합니다.이 예제에서는 AddScheduleParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-2bxelbn765ive" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > AddScheduleParams.json

2. AddScheduleParams 파일을 수정하고 저장합니다.

   {
     "DocumentName" : "AWSManagedServices-AddOrUpdateSchedule",
     "Region" : "us-east-1",
     "Parameters" : {
       "Action" : ["add"],
       "Name" : ["Schedule01"],
       "Description" : ["Test schedule"],
       "Hibernate" : ["true"],
       "Enforced" : ["false"],
       "OverrideStatus" : ["running"],
       "Periods" : [
         "period01",
         "period02"
       ],
       "RetainRunning" : ["false"],
       "StopNewInstances" : ["true"],
       "SSMMaintenanceWindow" : ["window01"],
       "TimeZone" : ["Australia/Sydney"],
       "UseMaintenanceWindow" : ["true"],
       "UseMetrics" : ["false"]
     }
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 AddScheduleRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > AddScheduleRfc.json

4. AddScheduleRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-2bxelbn765ive",
   "Title":                "Add a schedule for AMS Resource Scheduler"
   }

5. AddScheduleRfc 파일과 AddScheduleParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://AddScheduleRfc.json --execution-parameters file://AddScheduleParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-1vrnixswq1uwf" --change-type-version "1.0" --title "Delete EBS Snapshot (Review Required)" --execution-parameters "{\"SnapshotIds\": [\"snap-0a1b2c3d4e5f67890\",\"snap-1a2b3c4d5e6f78901\"], \"AMI\": \"No\", \"Region\": \"us-east-1\", \"Priority\": \"Medium\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 DeleteEbsSnpshtRrParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-1vrnixswq1uwf" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DeleteEbsSnpshtRrParams.json

2. DeleteEbsSnpshtRrParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "SnapshotIds": [
       "snap-0a1b2c3d4e5f67890",
       "snap-1a2b3c4d5e6f78901"
     ],
     "AMI": "No",
     "Region": "us-east-1",
     "Priority": "Medium"
   }

3. RFC 템플릿 JSON 파일을 파일로 출력합니다.이 예제에서는 파일 이름을 DeleteEbsSnpshtRrRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > DeleteEbsSnpshtRrRfc.json

4. DeleteEbsSnpshtRrRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-1vrnixswq1uwf",
   "Title":                "EBS-Snapshot-Delete-RR-RFC"
   }

5. DeleteEbsSnpshtRrRfc 파일과 DeleteEbsSnpshtRrParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://DeleteEbsSnpshtRrRfc.json  --execution-parameters file://DeleteEbsSnpshtRrParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 CREATE(최소 파라미터):

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-0zzf0fjz76jmb" --change-type-version "1.0" --title "Update SNS Topic" --execution-parameters "{\"TopicArn\": \"arn:aws:sns:us-east-1:123456789101:My-SNS-Topic\", \"Priority\": \"Medium\", \"Parameters\": {\"DisplayName\": \"My-SNS-Topic\", \"KmsMasterKeyId\": \"arn:aws:kms:us-east-1:123456789101:key/cfe0542d-3be9-4166-9eac-d0cd6af61445\"}}"

템플릿 생성(모든 파라미터):

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 파일 이름을 SnsUpdateParams.json.

   aws amscm get-change-type-version --change-type-id "ct-3rcl9u1k017wu" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > SnsUpdateParams.json

2. SnsUpdateParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "TopicArn": "arn:aws:sns:us-east-1:123456789101:Test-Stack",
     "Parameters": {
       "DisplayName": "My-Test-Stack",
       "DeliveryPolicy": "{\"http\":{\"defaultHealthyRetryPolicy\":{\"minDelayTarget\":20,\"maxDelayTarget\":20,\"numRetries\":3,\"numMaxDelayRetries\":0,\"numNoDelayRetries\":0,\"numMinDelayRetries\":0,\"backoffFunction\":\"linear\"},\"disableSubscriptionOverrides\":false,\"defaultRequestPolicy\":{\"headerContentType\":\"text/plain; charset=UTF-8\"}}}",
       "DataProtectionPolicy": "{\"Name\":\"__example_data_protection_policy\",\"Description\":\"Exampledataprotectionpolicy\",\"Version\":\"2021-06-01\",\"Statement\":[{\"DataDirection\":\"Inbound\",\"Principal\":[\"arn:aws:iam::123456789101:user/ExampleUser\"],\"DataIdentifier\":[\"arn:aws:dataprotection::aws:data-identifier/CreditCardNumber\"],\"Operation\":{\"Deidentify\":{\"MaskConfig\":{\"MaskWithCharacter\":\"#\"}}}}]}",
       "KmsMasterKeyARN": "arn:aws:kms:ap-southeast-2:123456789101:key/bb43bd18-3a75-482e-822d-d0d3a5544dc8",
       "TracingConfig": "Active"
     },
     "Priority": "Medium"
   }

3. RFC 템플릿 JSON 파일을 SnsUpdateRfc.json:이라는 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > SnsUpdateRfc.json

4. SnsUpdateRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-0zzf0fjz76jmb",
   "Title":                "Update-SNS-RFC"
   }

5. SnsUpdate Rfc 파일과 SnsUpdateParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://SnsUpdateRfc.json  --execution-parameters file://SnsUpdateParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --title="Add Static Route" --description="Create an access point and associate it with the specified S3 bucket." --ct-id="ct-1elb1vtam0ka5" --ct-version="1.0" --input-params="{\"Access Point Name\":\"accesspoint1\",\"Bucket Name\":\"s3bucket1\",\"Network Origin\":\"VPC\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 CreateS3AccessPointParams.json.

   aws amscm get-change-type-version --change-type-id "ct-1elb1vtam0ka5" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateS3AccessPointParams.json\"Access Point Policy\":\"Example access point policy\"

2. CreateS3AccessPointParams 파일을 수정하고 저장합니다.

   {
   "Access Point Name": "accesspoint1",
   "Bucket Name": "s3bucket1",
   "Network Origin": "VPC",
   "Vpc Id": "vpc-12345678"
   "Access Point Policy": "Example access point policy"
   }

3. RFC 템플릿 JSON 파일을 CreateS3AccessPointRfc.json:이라는 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateS3AccessPointRfc.json

4. CreateS3AccessPointRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-1elb1vtam0ka5",
   "Title":                "S3-Accesspoint-Create-RFC"
   }

5. CreateS3AccessPointRfc 파일과 CreateS3AccessPointParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateS3AccesspointRfc.json  --execution-parameters file://CreateS3AccesspointParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-3da2lxapopb86" --change-type-version "1.0" --title "Create Custom RDS Parameter Group" --execution-parameters "{\"ParameterGroupName\": \"my-db-parameter-group\", \"ParameterGroupFamily\": \"mysql5.6\", \"Description\": \"A meaningful description of the parameter group\", \"Priority\": \"Medium\", \"Parameters\": [{\"ParameterName\": \"max_connections\", \"ParameterValue\": \"100\"}], \"RDSInstanceName\": \"my-test-db\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 RDSCreateParameterGroupParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-3da2lxapopb86" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > RDSCreateParameterGroupParams.json

   RDSCreateParameterGroupParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ParameterGroupName": "my-db-parameter-group",
     "ParameterGroupFamily": "mysql5.6",
     "Description": "A meaningful description of the parameter group",
     "Priority": "Medium",
     "Parameters": [
       {
         "ParameterName": "max_connections",
         "ParameterValue": "100"
       }
     ],
     "RDSInstanceName": "my-test-db"
   }

2. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는이 템플릿의 이름을 RDSCreateParameterGroupRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > RDSCreateParameterGroupRfc.json

3. RDSCreateParameterGroupRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeId":         "ct-3da2lxapopb86",
   "ChangeTypeVersion":    "1.0",
   "Title":                "Create Custom RDS Parameter Group"
   }

4. RDSCreateParameterGroupRfc 파일과 GRDSCreateParameterGroupParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://RDSCreateParameterGroupRfc.json --execution-parameters file://RDSCreateParameterGroupParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-0o4zi9bzg74lp" --change-type-version "1.0" --title "Add event notification" --execution-parameters "{ \"DocumentName\": \"AWSManagedServices-AddBucketEventNotification\", \"Region\": \"us-east-1\", \"Parameters\": { \"BucketName\": \"bucketname\", \"EventName\": \"eventname\", \"Prefix\": \"foo\", \"Suffix\": \".bar\", \"EventTypes\": [ \"s3:ObjectCreated:Post\", \"s3:ObjectCreated:Put\" ], \"DestinationARN\": \"arn:aws:lambda:us-east-1:123456789012:function:functionname\" } }"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 AddEventNotificationS3Params.json.

   aws amscm get-change-type-version --change-type-id "ct-220bdb8blaixf" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > AddEventNotificationS3Params.json

2. AddEventNotificationS3Params 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-AddBucketEventNotification",
     "Region": "us-east-1",
     "Parameters": {
       "BucketName": "bucketname",
       "EventName": "eventname",
       "Prefix": "foo",
       "Suffix": ".bar",
       "EventTypes": [
         "s3:ObjectCreated:Post",
         "s3:ObjectCreated:Put"
       ],
       "DestinationARN": "arn:aws:lambda:us-east-1:123456789012:function:functionname"
     }
   }

3. RFC 템플릿 JSON 파일을 AddEventNotificationS3Rfc.json:이라는 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > AddEventNotificationS3Rfc.json

4. AddS3LifecycleConfigRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion": "1.0",
   "ChangeTypeId": "ct-0o4zi9bzg74lp",
   "Title": "Add Event Notification"
   }

5. AddEventNotificationS3Rfc 파일과 AddEventNotificationS3Params 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://AddEventNotificationS3Rfc.json --execution-parameters file://AddEventNotificationS3Params.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-2r9xvd3sdsic0" --change-type-version "1.0" --title "Update custom deny list for Automated IAM Provisioning" --execution-parameters "{\"CustomerCustomDenyActionsList1\":\"ec2:RunInstances,s3:PutBucket,sagemaker:*\",\"Priority\":\"High\"}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 CustomerCustomDenyActionsList.json.

   aws amscm get-change-type-version --change-type-id "ct-2r9xvd3sdsic0" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CustomerCustomDenyActionsList.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "DocumentName": "AWSManagedServices-CustomerCustomDenyActionsList",
       "Region": "us-east-1",
       "Parameters": {
     "CustomerCustomDenyActionsList1": "ec2:RunInstances,s3:PutBucket,sagemaker:*",
     "Priority": "High"
   }
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 CustomerCustomDenyActionsListRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > CustomerCustomDenyActionsListRfc.json

4. CustomerCustomDenyActionsListRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion": "1.0",
     "ChangeTypeId": "ct-2r9xvd3sdsic0",
     "Title": "Update custom deny list for Automated IAM Provisioning"
   }

5. CreateAcmPublicRfc 파일과 CreateAcmPublicParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CustomerCustomDenyActionsListRfc.json  --execution-parameters file://CustomerCustomDenyActionsListParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

필수 파라미터만 해당:

aws amscm create-rfc --change-type-id "ct-2tqi3kjcusen4" --change-type-version "1.0" --title "Migrate AWS managed Microsoft AD to Route 53 DNS resolver for SALZ accounts" --execution-parameters "{}"

모든 필수 및 선택적 파라미터:

aws amscm create-rfc --change-type-id "ct-2tqi3kjcusen4" --change-type-version "1.0" --title "Migrate AWS managed Microsoft AD to Route 53 DNS resolver for SALZ accounts" --execution-parameters "{\"Priority\":\"Medium\"}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 CreateMigrateToRoute53RequiredParams.json.

   aws amscm get-change-type-version --change-type-id "ct-2tqi3kjcusen4" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateMigrateToRoute53RequiredParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "Priority": "Medium"
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 CreateMigrateToRoute53RequiredRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateMigrateToRoute53RequiredRfc.json

4. CreateMigrateToRoute53RequiredRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeId":         "ct-2tqi3kjcusen4",
   "ChangeTypeVersion":    "1.0",
   "Title":                "Migrate AWS managed Microsoft AD to Route 53 DNS resolver for SALZ accounts"
   }

5. CreateMigrateToRoute53RequiredRfc 파일과 CreateMigrateToRoute53RequiredParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateMigrateToRoute53RequiredRfc.json  --execution-parameters file://CreateMigrateToRoute53RequiredParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws --profile saml --region us-east-1 amscm create-rfc --change-type-id "ct-3e3prksxmdhw8" --change-type-version "2.0" --title "AMI-Create-IC" --execution-parameters "{\"AMIName\":\"MyAmi\",\"VpcId\":\"VPC_ID\",\"EC2InstanceId\":\"INSTANCE_ID\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 CreateAmiFromAsgParams.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --change-type-id "ct-3e3prksxmdhw8" --change-type-version "1.0" --title "Create AMI from an Auto Scaling group" --execution-parameters "{\"DocumentName\": \"AWSManagedServices-CreateAmiInAutoScalingGroup\",\"Region\": \"us-east-1\",\"Parameters\": {\"AutoScalingGroupName\": [\"stack-ab0123cdef-ASG-1ABC2345\"],\"Sysprep\": [\"False\"],\"StopInstance\": [\"False\"]}}"

2. 실행 파라미터 CreateAmiFromAsgParams.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-CreateAmiInAutoScalingGroup",
     "Region": "us-east-1",
     "Parameters": {
       "AutoScalingGroupName": [
         "stack-ab0123cdef-ASG-1ABC2345"
       ],
       "Sysprep": [
         "False"
       ],
       "StopInstance": [
         "False"
       ]
     }
   }

3. RFC 템플릿 JSON 파일을 현재 폴더의 파일로 출력합니다.이 예제에서는 CreateAmiFromAsgRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateAmiFromAsgRfc.json

4. CreateAmiFromAsgRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion": "1.0",
     "ChangeTypeId": "ct-3e3prksxmdhw8",
     "Title": "Create AMI from an Auto Scaling group"
   }

5. CreateAmiFromAsgRfc 파일과 CreateAmiFromAsgParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateAmiFromAsgRfc.json  --execution-parameters file://CreateAmiFromAsgParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-3jx80fquylzhf" --change-type-version "1.0" --title "Update Enhanced Monitoring" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-UpdateRDSEnhancedMonitoring\",\"Region\":\"us-east-1\",\"Parameters\": {\"DBIdentifierArn\":[\"arn:aws:rds:us-east-1:000000000000:db:testdbinstance\"], \"MonitoringInterval\": [\"60\"],,\"MonitoringRoleName\": \"ds-monitoring-role\"}}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 RotateRdsCertParams.json.

   aws amscm get-change-type-version --change-type-id "ct-3jx80fquylzhf" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateRDSEnhancedMonitoringParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "DocumentName": "AWSManagedServices-UpdateRDSEnhancedMonitoring",
       "Region": "us-east-1",
       "Parameters": {
           "DBIdentifierArn": "arn:aws:rds:us-east-1:000000000000:db:testdbinstance",
           "MonitoringInterval": "60",
           "MonitoringRoleName": [
               "rds-monitoring-role"
           ]
       }
   }

3. JSON 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 이름을 UpdateRDSEnhancedMonitoringRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateRDSEnhancedMonitoringRfc.json

4. UpdateRDSEnhancedMonitoringRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-3jx80fquylzhf",
   "Title":                "Update Enhanced Monitoring"
   }
   

5. 실행 파라미터 파일과 UpdateRDSEnhancedMonitoringRfc 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateRDSEnhancedMonitoringRfc.json --execution-parameters file://UpdateRDSEnhancedMonitoringParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프 표시)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --title="Associate VPC with Resolver Rule" --ct-id="ct-2pbqoffhclpek" --ct-version="1.0" --execution-parameters "{\"Description\":\"Associate VPC with Resolver Rule\",\"ResolverRuleId\":\"rslvr-rr-974b1666869a4d27b\",\"VPCId\":\"vpc-02a18ed0cd3c17e71\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 출력합니다.이 예제에서는 VPCAssociateResolverRule.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-2pbqoffhclpek" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > VPCAssociateResolverRule.json

2. 실행 파라미터를 수정하고 VPCAssociateResolverRuleParams.json. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-AssociateVPCWithResolverRule",
     "Region": "us-east-1",
     "Parameters": {
       "Name": "resolver-rule-associate-vpc-test",
       "ResolverRuleId": "rslvr-rr-1234567890abcdefg",
       "VPCId": "vpc-1a2b3c4d"
     }
   }

3. RFC 템플릿 JSON 파일을 출력합니다.이 예제에서는 VPCAssociateResolverRuleRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > VPCAssociateResolverRuleRfc.json

4. VPCAssociateResolverRuleRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion" : "1.0",
     "ChangeTypeId" : "ct-2pbqoffhclpek",
     "Title" : "Associate VPC with Resolver Rule "
   }

5. VPCAssociateResolverRuleRfc 파일과 VPCAssociateResolverRuleParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://VPCAssociateResolverRuleRfc.json  --execution-parameters file:/VPCAssociateResolverRuleParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-2jndrh7uit8uf" --change-type-version "1.0" --title "Deploy AMS Patterns" --execution-parameters "{\"PatternName\": \"amsEbsVolumeSnapshotTagger\",\"PatternParameters\": "{\"ExcludedTags\":\"BackupProd,Backup\",\"ASMGuardRail\":\"enabled\"}", \"OrganizationalUnit\": \"ou-9dyd-s2vptest\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 출력합니다.이 예제에서는 DeployAMSPatternsParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-2jndrh7uit8uf" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DeployAMSPatternsParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "PatternName": "amsEbsVolumeSnapshotTagger",
     "ExcludeAccounts": ["123456789012"],
     "OrganizationalUnitIds": ["ou-9dyd-jvsei4yg"],
     "Priority": "Medium",
     "PatternParameters": [
       {
         "Name": "Foo",
         "Value": "Bar"
       }
     ]
   }

3. RFC 템플릿 JSON 파일을 출력합니다.이 예제에서는 DeployAMSPatternsRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > DeployAMSPatternsRfc.json

4. DeployAMSPatternsRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-2jndrh7uit8uf",
   "Title":                "Deploy AMS Patterns"
   }

5. DeployAMSPatternsRfc 파일과 DeployAMSPatternsParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://DeployAMSPatternsRfc.json --execution-parameters file://DeployAMSPatternsParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --title="Add Static Route" --description="Share KMS Key" --ct-id="ct-05yb337abq3x5" --ct-version="1.0" --input-params="{\"KMSKeyArn\":\"arn:aws:kms:us-east-1:111122223333:key/06506094-64e2-47f3-94bd-f919eefa22f5\",\"TargetAccountId\":\"000000000000\",\"IncludeKeyGrantOperations\":\"false\",\"IAMUserOrRole\":\"arn:aws:iam::000000000000:role/role-name\", \"Priority\":\"High\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 ShareKmsKeyParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-05yb337abq3x5" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > ShareKmsKeyParams.json

   ShareKmsKeyParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "Description": "Share KMS Key",
     "Parameters": {
       "KMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/06506094-64e2-47f3-94bd-f919eefa22f5",
       "TargetAccountId": "000000000000",
       "IncludeKeyGrantOperations": "false"
       "IAMUserOrRole": "arn:aws:iam::000000000000:role/role-name"
     }
   }

2. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 이름을 ShareKmsKeyParamsRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > ShareKmsKeyParamsRfc.json

3. ShareKmsKeyParams.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeId": {
     "ChangeTypeVersion":    "1.0",
     "ChangeTypeId":         "ct-05yb337abq3x5",
     "Title":                "Share KMS Key"
   }

4. ShareKmsKeyParamsRfc 파일과 ShareKmsKeyParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://ShareKmsKeyParamsRfc.json --execution-parameters file://ShareKmsKeyParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

   Bastion을 통해 인스턴스에 로그인하려면 다음 절차인 인스턴스 액세스 예제를 따릅니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-0x6dylrnfjgz5" --change-type-version "1.0" --title "Create AD Trust" --execution-parameters ' 
{"DocumentName":"AWSManagedServices-CreateADTrust","Region":"ap-southeast-2","Parameters":{"DirectoryId":["d-976774e42f"],"RemoteDomainName":["onprem.local"],"SecretArn":["arn:aws:secretsmanager:ap-southeast-2:996606605561:secret:customer-shared/CorrectTPW-BI79uu"],"TrustType":["External"],"ConditionalForwarderIpAddresses":["10.153.28.39"]}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 CreateADTrustParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-0x6dylrnfjgz5" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateADTrustParams.json

   CreateADTrustParams.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-CreateADTrust",
     "Region": "ap-southeast-2",
     "Parameters": {
       "DirectoryId": [
         "d-976774e42f"
       ],
       "RemoteDomainName": [
         "onprem.local"
       ],
       "SecretArn": [
         "arn:aws:secretsmanager:ap-southeast-2:996606605561:secret:customer-shared/CorrectTPW-BI79uu"
       ],
       "TrustType": [
         "External"
       ],
       "ConditionalForwarderIpAddresses": [
         "10.153.28.39"
       ]
     }
   }

2. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 CreateADTrustRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateADTrustRfc.json

3. CreateADTrustRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeId": "ct-0x6dylrnfjgz5",
     "ChangeTypeVersion": "1.0",
     "Title": "Active Directory Trust"
   }

4. CreateADTrustRfc 파일과 CreateADTrustParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateADTrustRfc.json --execution-parameters file://CreateADTrustParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --title="Override Stack Access Duration" --description="Override Stack Access Duration" --ct-id="ct-0jb01cofkhwk1" --ct-version="1.0" --input-params="{\"TimeRequestedInHours\": 15,\"Priority\":\"High\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다. 이 예제에서는 OverrideStackAccessDurationParameters.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-0jb01cofkhwk1" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > OverrideStackAccessDurationParameters.json

2. OverrideStackAccessDurationParameters.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "TimeRequestedInHours": 15,
     "Priority": "High"
   }

3. RFC 템플릿 JSON 파일을 OverrideStackAccessDuration.json:이라는 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > OverrideStackAccessDuration.json

4. OverrideStackAccessDuration.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion": "1.0",
     "ChangeTypeId": "ct-0jb01cofkhwk1",
     "Title": "Override Stack Access Duration"
   }

5. RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://OverrideStackAccessDuration.json --execution-parameters file://OverrideStackAccessDurationParameters.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-1706xvvk6j9hf" --change-type-version "1.0" --title "Enable (review required)" --execution-parameters "{\"SAMLIdentityProviderArns\": [\"arn:aws:iam::123456789012:saml-provider/customer-saml\"], \"IamEntityArns\": [\"arn:aws:iam::123456789012:role/test-role-one\", \"arn:aws:iam::123456789012:role/test-role-two\"], \"Priority\": \"High\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 EnableAutomatedIAMProvisioningParams.json.

   aws amscm get-change-type-version --change-type-id "ct-1706xvvk6j9hf" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > EnableAutomatedIAMProvisioningParams.json

2. EnableAutomatedIAMProvisioningParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "SAMLIdentityProviderArns": ["arn:aws:iam::123456789012:saml-provider/customer-saml"],
     "IamEntityArns": ["arn:aws:iam::123456789012:role/test-role-one", "arn:aws:iam::123456789012:role/test-role-two"],
     "Priority": "High"
   }

3. RFC 템플릿 JSON 파일을 EnableAutomatedIAMProvisioningRfc.json:이라는 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > EnableAutomatedIAMProvisioningRfc.json

4. EnableAutomatedIAMProvisioningRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-1706xvvk6j9hf",
   "Title":                "Enable-Automated-IAM-Provisioning-RFC"
   }

5. UpdateSecurityPolicy Rfc 파일과 UpdateSecurityPolicyParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://EnableAutomatedIAMProvisioningRfc.json  --execution-parameters file://EnableAutomatedIAMProvisioningParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프 표시)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --title="Add Static Route" --description="Add static route" --ct-id="ct-06bwg93ukgg8t" --ct-version="1.0" --input-params="{\"RouteTableId\":\"rtb-0123abcd\",\"DestinationCidrBlock\":\"172.31.0.0/16\",\"Target\":\"pcx-0123456789abcdefg\",\"Priority\":\"High\"}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 출력합니다.이 예제에서는 EncryptAmiParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-06bwg93ukgg8t" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > AddStaticRouteParams.json

2. 실행 AddStaticRouteParams.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "RouteTableId": "rtb-0123abcd",
       "DestinationCidrBlock": "172.31.0.0/16",
       "Target": "pcx-0123456789abcdefg",
       "Priority": "High"
   }

3. RFC 템플릿 JSON 파일을 출력합니다.이 예제에서는 AddStaticRouteRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > AddStaticRouteRfc.json

4. AddStaticRouteRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion": "1.0",
     "ChangeTypeId": "ct-06bwg93ukgg8t",
     "Title": "Add static route"
   }

5. AddStaticRouteRfc 파일과 AddStaticRouteParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://AddStaticRouteRfc.json  --execution-parameters file://AddStaticRouteParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-1n9gfnog5x7fl" --change-type-version "1.0" --title "Create role or policy" --execution-parameters '{"DocumentName":"AWSManagedServices-HandleAutomatedIAMProvisioningCreate-Admin","Region":"us-east-1","Parameters":{"ValidateOnly":"No"},"RoleDetails":{"Roles":[{"RoleName":"RoleTest01","Description":"This is a test role","AssumeRolePolicyDocument":"{"Version": "2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":"arn:aws:iam::123456789012:root"},"Action":"sts:AssumeRole"}]}","ManagedPolicyArns":["arn:aws:iam::123456789012:policy/policy01","arn:aws:iam::123456789012:policy/policy02"],"Path":"/","MaxSessionDuration":"7200","PermissionsBoundary":"arn:aws:iam::123456789012:policy/permission_boundary01","InstanceProfile":"No"}]},"ManagedPolicyDetails":{"Policies":[{"ManagedPolicyName":"TestPolicy01","Description":"This is customer policy","Path":"/test/","PolicyDocument":"{"Version":"2012-10-17","Statement":[{"Sid":"AllQueueActions","Effect":"Allow","Action":"sqs:ListQueues","Resource":"*","Condition":{"ForAllValues:StringEquals":{"aws:tagKeys":["temporary"]}}}]}"}]}}'

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다. 예제 이름은 CreateIamResourceParams.json:.

   aws amscm get-change-type-version --change-type-id "ct-1n9gfnog5x7fl" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateIamResourceParams.json

2. CreateIamResourceParams 파일을 수정하고 저장합니다. 예제에서는 정책 문서가 인라인으로 붙여넣어진 IAM 역할을 생성합니다.

   {
     "DocumentName": "AWSManagedServices-HandleAutomatedIAMProvisioningCreate-Admin",
     "Region": "us-east-1",
     "Parameters": {
       "ValidateOnly": "No"
     },
     "RoleDetails": {
       "Roles": [
         {
           "RoleName": "RoleTest01",
           "Description": "This is a test role",
           "AssumeRolePolicyDocument": {
             "Version": "2012-10-17",
             "Statement": [
               {
                 "Effect": "Allow",
                 "Principal": {
                   "AWS": "arn:aws:iam::123456789012:root"
                 },
                 "Action": "sts:AssumeRole"
               }
             ]
           },
           "ManagedPolicyArns": [
             "arn:aws:iam::123456789012:policy/policy01",
             "arn:aws:iam::123456789012:policy/policy02"
           ],
           "Path": "/",
           "MaxSessionDuration": "7200",
           "PermissionsBoundary": "arn:aws:iam::123456789012:policy/permission_boundary01",
           "InstanceProfile": "No"
         }
       ]
     },
     "ManagedPolicyDetails": {
       "Policies": [
         {
           "ManagedPolicyName": "TestPolicy01",
           "Description": "This is customer policy",
           "Path": "/test/",
           "PolicyDocument": {
             "Version": "2012-10-17",
             "Statement": [
               {
                 "Sid": "AllQueueActions",
                 "Effect": "Allow",
                 "Action": "sqs:ListQueues",
                 "Resource": "*",
                 "Condition": {
                   "ForAllValues:StringEquals": {
                     "aws:tagKeys": [
                       "temporary"
                     ]
                   }
                 }
               }
             ]
           }
         }
       ]
     }
   }

3. RFC 템플릿 JSON 파일을 CreateIamResourceRfc.json:이라는 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateIamResourceRfc.json

4. CreateIamResourceRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion": "1.0",
     "ChangeTypeId": "ct-1n9gfnog5x7fl",
     "Title": "Create entity or policy (read-write permissions)"
   }

5. CreateIamResourceRfc 파일과 CreateIamResourceParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateIamResourceRfc.json  --execution-parameters file://CreateIamResourceParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-1e0xmuy1diafq" --change-type-version "1.0" --title "Update role or policy" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-HandleAutomatedIAMProvisioningUpdate-Admin\",\"Region\":\"us-east-1\",\"Parameters\":{\"ValidateOnly\":\"No\"},\"RoleDetails\":{\"Roles\":[{\"RoleName\":\"RoleTest01\",\"Description\":\"This is a test role\",\"AssumeRolePolicyDocument\":\"{\\\"Version\\\":\\\"2012-10-17\\\",\\\"Statement\\\":[{\\\"Effect\\\":\\\"Allow\\\",\\\"Principal\\\":{\\\"AWS\\\":\\\"arn:aws:iam::123456789012:root\\\"},\\\"Action\\\":\\\"sts:AssumeRole\\\"}]}\",\"ManagedPolicyArns\":[\"arn:aws:iam::123456789012:policy/policy01\",\"arn:aws:iam::123456789012:policy/policy02\"],\"MaxSessionDuration\":\"7200\",\"PermissionsBoundary\":\"arn:aws:iam::123456789012:policy/permission_boundary01\"}]},\"ManagedPolicyDetails\":{\"Policies\":[{\"ManagedPolicyName\":\"TestPolicy01\",\"PolicyDocument\":\"{\\\"Version\\\":\\\"2012-10-17\\\",\\\"Statement\\\":[{\\\"Sid\\\":\\\"AllQueueActions\\\",\\\"Effect\\\":\\\"Allow\\\",\\\"Action\\\":\\\"sqs:ListQueues\\\",\\\"Resource\\\":\\\"*\\\",\\\"Condition\\\":{\\\"ForAllValues:StringEquals\\\":{\\\"aws:tagKeys\\\":[\\\"temporary\\\"]}}}]}\"}]}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다. 예제 이름은 UpdateIamResourceParams.json:입니다.

   aws amscm get-change-type-version --change-type-id "ct-1e0xmuy1diafq" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateIamResourceParams.json

2. UpdateIamResourceParams 파일을 수정하고 저장합니다. 예제에서는 정책 문서를 인라인으로 붙여넣어 IAM 역할을 생성합니다.

   {
     "DocumentName": "AWSManagedServices-HandleAutomatedIAMProvisioningUpdate-Admin",
     "Region": "us-east-1",
     "Parameters": {
       "ValidateOnly": "No"
     },
     "RoleDetails": {
       "Roles": [
         {
           "RoleName": "RoleTest01",
           "Description": "This is a test role",
           "AssumeRolePolicyDocument": {"Version": "2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":"arn:aws:iam::123456789012:root"},"Action":"sts:AssumeRole"}]},
           "ManagedPolicyArns": [
             "arn:aws:iam::123456789012:policy/policy01",
             "arn:aws:iam::123456789012:policy/policy02"
           ],
           "MaxSessionDuration": "7200",
           "PermissionsBoundary": "arn:aws:iam::123456789012:policy/permission_boundary01"
         }
       ]
     },
     "ManagedPolicyDetails": {
       "Policies": [
         {
           "ManagedPolicyName": "TestPolicy01",
           "PolicyDocument": {"Version": "2012-10-17","Statement":[{"Sid":"AllQueueActions","Effect":"Allow","Action":"sqs:ListQueues","Resource":"*","Condition":{"ForAllValues:StringEquals":{"aws:tagKeys":["temporary"]}}}]}
         }
       ]
     }
   }

3. RFC 템플릿 JSON 파일을 UpdateIamResourceRfc.json:이라는 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateIamResourceRfc.json

4. UpdateIamResourceRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "ChangeTypeVersion": "1.0",
       "ChangeTypeId": "ct-1e0xmuy1diafq",
       "Title": "Update entity or policy (read-write permissions)"
   }

5. UpdateIamResourceRfc 파일과 UpdateIamResourceParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateIamResourceRfc.json  --execution-parameters file://UpdateIamResourceParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-17cj84y7632o6" --change-type-version "1.0" --title "Delete role or policy" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-HandleAutomatedIAMProvisioningDelete-Admin\",\"Region\":\"us-east-1\",\"Parameters\":{\"RoleName\":[\"TestRole01\",\"TestRole02\"],\"ManagedPolicyName\":[\"TestPolicy01\",\"TestPolicy02\"]}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다. 예제DeleteIamResourceParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-17cj84y7632o6" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DeleteIamResourceParams.json

2. DeleteIamResourceParams 파일을 수정하고 저장합니다. 예제에서는 정책 문서를 인라인으로 붙여넣어 IAM 역할을 생성합니다.

   {
     "DocumentName" : "AWSManagedServices-HandleAutomatedIAMProvisioningDelete-Admin",
     "Region" : "us-east-1",
     "Parameters": {
       "RoleName": ["TestRole01", "TestRole02"],
       "ManagedPolicyName": ["TestPolicy01", "TestPolicy02"]
     }
   }

3. RFC 템플릿 JSON 파일을 DeleteIamResourceRfc.json:이라는 파일로 출력합니다.

   aws amscm create-rfc --generate-cli-skeleton > DeleteIamResourceRfc.json

4. DeleteIamResourceRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "ChangeTypeVersion": "1.0",
       "ChangeTypeId": "ct-17cj84y7632o6",
       "Title": "Delete entity or policy (read-write permissions)"
   }

5. DeleteIamResourceRfc 파일과 DeleteIamResourceParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://DeleteIamResourceRfc.json  --execution-parameters file://DeleteIamResourceParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --title "Update EC2 detailed monitoring" -update --change-type-id ct-0tmpmp1wpgkr9 --change-type-version 1.0 --execution-parameters '{"DocumentName":"AWSManagedServices-UpdateInstanceEnhancedMonitoring","Region":"us-east-1","Parameters":{"InstanceIds":["i-09d65b13db992e8d4","i-0cdbd78ad80d2378c"]}}'

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 JSON 파일로 출력합니다.이 예제에서는 UpdateEc2MonitoringParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-0tmpmp1wpgkr9" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateEc2MonitoringParams.json

2. 변경하려는 파라미터만 유지하여 UpdateEc2MonitoringParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-UpdateInstanceEnhancedMonitoring",
     "Region": "us-east-1",
     "Parameters": {
       "InstanceIds": [
         "i-09d65b13db992e8d4",
         "i-0cdbd78ad80d2378c"
       ],
       "MonitoringValue": "enabled"
     }
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 이름을 UpdateEc2MonitoringRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateEc2MonitoringRfc.json

4. UpdateEc2MonitoringRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-0tmpmp1wpgkr9",
   "Title":                "EC2 Update Detailed Monitoring"
   }

5. UpdateEc2MonitoringRfc 파일과 UpdateEc2MonitoringParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateEc2MonitoringRfc.json  --execution-parameters file://UpdateEc2MonitoringParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm  create-rfc --change-type-id "ct-369odosk0pd9w" --change-type-version "1.0" --title "Share Directory" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-ShareDirectory\",\"Region\":\"ap-southeast-2\",\"Parameters\":{\"DirectoryId\":[\"d-123456ab7c\"],\"TargetAccountId\":[\"012345678912\"]}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 DirectorySharingParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-369odosk0pd9w" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DirectorySharingParams.json

   DirectorySharingParams.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-ShareDirectory",
     "Region": "us-east-1",
     "Parameters": {
       "DirectoryId": [
         "d-123456ab7c"
       ],
       "TargetAccountId": [
         "012345678912"
       ]
     }
   }

2. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 DirectorySharingRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > DirectorySharingRfc.json

3. DirectorySharingRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeId": "ct-369odosk0pd9w",
     "ChangeTypeVersion": "1.0",
     "Title": "Share Directory"
   }

4. DirectorySharingRfc 파일과 DirectorySharingParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://DirectorySharingRfc.json --execution-parameters file://DirectorySharingParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm  create-rfc --change-type-id "ct-2xd2anlb5hbzo" --change-type-version "1.0" --title "Unshare Directory" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-ShareDirectory\",\"Region\":\"ap-southeast-2\",\"Parameters\":{\"DirectoryId\":[\"d-123456ab7c\"],\"UnshareTarget\":[\"012345678912\"]}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 DirectoryUnsharingParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-2xd2anlb5hbzo" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DirectoryUnsharingParams.json

   DirectoryUnsharingParams.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-UnshareDirectory",
     "Region": "us-east-1",
     "Parameters": {
       "DirectoryId": [
         "d-123456ab7c"
       ],
       "UnshareTarget": [
         "012345678912"
       ]
     }
   }

2. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 DirectoryUnsharingRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > DirectoryUnsharingRfc.json

3. DirectoryUnsharingRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeId": "ct-2xd2anlb5hbzo",
     "ChangeTypeVersion": "1.0", 
     "Title": "Unshare Directory"
   }

4. DirectoryUnsharingRfc 파일과 DirectoryUnsharingParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://DirectoryUnsharingRfc.json --execution-parameters file://DirectoryUnsharingParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프 표시)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-3oafsdbzjtuqp" --change-type-version "1.0" --title "Create VPC Endpoint" --execution-parameters "{\"Description\":\"VPC endpoint interface\",\"VpcId\":\"vpc-1234567890abcdef0\",\"Name\":\"VPC endpoint interface\",\"StackTemplateId\":\"stm-f0cumpt1rfc1p1739\",\"TimeoutInMinutes\":60,\"Parameters\":{\"VpcId\":\"vpc-1234567890abcdef0\",\"ServiceName\":\"com.amazonaws.us-east-1.codedeploy\",\"SecurityGroups\":[\"sg-1234567890abcdef0\",\"sg-1234567890abcdef1\"],\"SubnetIds\":[\"subnet-1234567890abcdef0\",\"subnet-1234567890abcdef1\"],\"EnablePrivateDns\":\"false\"}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 출력합니다.이 예제에서는 VPCEndpointCreateParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-3oafsdbzjtuqp" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > VPCEndpointCreateParams.json

2. 실행 파라미터를 수정하고 VPCEndpointCreateParams.json. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "Description": "VPC endpoint interface",
     "VpcId": "vpc-1234567890abcdef0",
     "Name": "VPC endpoint interface",
     "StackTemplateId": "stm-f0cumpt1rfc1p1739",
     "TimeoutInMinutes": 60,
     "Parameters": {
       "VpcId": "vpc-1234567890abcdef0",
       "ServiceName": "com.amazonaws.us-east-1.codedeploy",
       "SecurityGroups": [
         "sg-1234567890abcdef0",
         "sg-1234567890abcdef1"
       ],
       "SubnetIds": [
         "subnet-1234567890abcdef0",
         "subnet-1234567890abcdef1"
       ],
       "EnablePrivateDns": "false"
     }
   }

3. RFC 템플릿 JSON 파일을 출력합니다.이 예제에서는 VPCEndpointCreateRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > VPCEndpointCreateRfc.json

4. VPNGatewayCreateRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion" : "1.0",
     "ChangeTypeId" : "ct-3oafsdbzjtuqp",
     "Title" : "Create VPC Endpoint "
   }

5. VPCEndpointCreateRfc 파일과 VPCEndpointCreateParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://VPCEndpointCreateRfc.json  --execution-parameters file://VPCEndpointCreateParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-0loed9dzig1ze" --change-type-version "1.0" --title "Update RDS storage" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-UpdateRDSStorage\",\"Region\":\"us-east-1\",\"Parameters\": {\"DBInstanceIdentifier\":[\"rt123456789\"], \"AllocatedStorage\": [\"100\"],,\"ApplyImmediately\": \"true\"}}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 UpdateStorageParams.json.

   aws amscm get-change-type-version --change-type-id "ct-0loed9dzig1ze" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateStorageParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-UpdateRDSStorage",
     "Region": "us-east-1",
     "Parameters": {
       "DBInstanceIdentifier": [
         "rt123456789"
       ],
       "AllocatedStorage": [
         "100"
       ],
       "ApplyImmediately": "false"
     }
   }

3. JSON 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 이름을 UpdateStorageRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateStorageRfc.json

4. UpdateStorageRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-0loed9dzig1ze",
   "Title":                "Update RDS storage"
   }

5. 실행 파라미터 파일과 UpdateStorageRfc 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateStorageRfc.json --execution-parameters file://UpdateStorageParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-36jq7gvwyty8h" --change-type-version "1.0" --title "Update RDS Multiple AZ" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-UpdateRDSMultiAZ\",\"Region\":\"us-east-1\",\"Parameters\": {\"DBInstanceIdentifier\":[\"rt123456789\"], \"MultiAZ\": \"true\",\"ApplyImmediately\": \"true\"}}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 UpdateMultipleAzParams.json.

   aws amscm get-change-type-version --change-type-id "ct-36jq7gvwyty8h" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateMultipleAzParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-UpdateRDSMultiAZ",
     "Region": "us-east-1",
     "Parameters": {
       "DBInstanceIdentifier": [
         "rt123456789"
       ],
       "MultiAZ": "true",
       "ApplyImmediately": "false"
     }
   }

3. JSON 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 이름을 UpdateMultipleAzRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateMultipleAzRfc.json

4. UpdateMultipleAzRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-36jq7gvwyty8h",
   "Title":                "Update RDS Multiple AZ"
   }

5. 실행 파라미터 파일과 UpdateMultipleAzRfc 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateMultipleAzRfc.json --execution-parameters file://UpdateMultipleAzParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-13swbwdxg106z" --change-type-version "1.0" --title "Update rds instance type" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-UpdateRDSInstanceType\",\"Region\":\"us-east-1\",\"Parameters\": {\"DBInstanceIdentifier\":[\"rt123456789\"], \"DBInstanceClass\": [\"db.m4.large\"],\"ApplyImmediately\": \"true\"}}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 UpdateInstanceTypeParams.json.

   aws amscm get-change-type-version --change-type-id "ct-13swbwdxg106z" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateInstanceTypeParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-UpdateRDSInstanceType",
     "Region": "us-east-1",
     "Parameters": {
       "DBInstanceIdentifier": [
         "rt123456789"
       ],
       "DBInstanceClass": [
         "db.m4.large"
       ],
       "ApplyImmediately": "false"
     }
   }

3. JSON 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 이름을 UpdateInstanceTypeRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateInstanceTypeRfc.json

4. UpdateInstanceTypeRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-13swbwdxg106z",
   "Title":                "Update RDS instance type"
   }

5. 실행 파라미터 파일과 UpdateInstanceTypeRfc 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateInstanceTypeRfc.json --execution-parameters file://UpdateInstanceTypeParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-2hh93eyzmwbkd" --change-type-version "1.0" --title "Update bucket versioning" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-UpdateBucketVersioning\",\"Region\":\"us-east-1\",\"Parameters\":{\"BucketName\":[\"BucketName\"],\"Versioning\": \"Enabled\"}}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 UpdateBucketVersioningParams.json.

   aws amscm get-change-type-version --change-type-id "ct-2hh93eyzmwbkd" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateBucketVersioningParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-UpdateBucketVersioning",
     "Region": "us-east-1",
     "Parameters": {
       "BucketName": [
         "BucketName"
       ],
       "Versioning": "Enabled"
     }
   }

3. JSON 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 이름을 UpdateBucketVersioningRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateBucketVersioningRfc.json

4. UpdateBucketVersioningRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-2hh93eyzmwbkd",
   "Title":                "Update bucket versioning"
   }

5. 실행 파라미터 파일과 UpdateRdsRfc 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateBucketVersioningRfc.json --execution-parameters file://UpdateBucketVersioningParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-128svy9nn2yj8" --change-type-version "1.0" --title "Update bucket encryption" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-UpdateBucketEncryption\",\"Region\":\"us-east-1\",\"Parameters\":{\"BucketName\":[\"BucketName\"],\"ServerSideEncryption\": \"KmsManagedKeys\",\"KMSKeyId\":[\"01234567-abcd-abcd-abcd-0123456789ab\"]}}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 UpdateBucketEncryptionParams.json.

   aws amscm get-change-type-version --change-type-id "ct-128svy9nn2yj8" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateBucketEncryptionParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-UpdateBucketEncryption",
     "Region": "us-east-1",
     "Parameters": {
       "BucketName": [
         "BucketName"
       ],
       "ServerSideEncryption": "KmsManagedKeys",
       "KMSKeyId": [
         "01234567-abcd-abcd-abcd-0123456789ab"
       ]
     }
   }

3. JSON 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 이름을 UpdateBucketEncryptionRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateBucketEncryptionRfc.json

4. UpdateBucketEncryptionRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-128svy9nn2yj8",
   "Title":                "Update bucket encryption"
   }

5. 실행 파라미터 파일과 UpdateBucketEncryptionRfc 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateBucketEncryptionRfc.json --execution-parameters file://UpdateBucketEncryptionParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-0fuztxgwy37rf" --change-type-version "1.0" --title "Child Application Account RFC" --execution-parameters ""{\"RfcId\":\"7cc277c6-9b55-1f63-361b-5811fce9f830\",\"Comment\":\"test RFC\"}""

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 CreateAppAcctVpcParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-0fuztxgwy37rf" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > UpdateAppAcctParams.json

2. UpdateAppAcctParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "RfcId": "7cc277c6-9b55-1f63-361b-5811fce9f830",
     "Comment": "test RFC"
   }

3. RFC 템플릿 JSON 파일을 파일로 출력합니다.이 예제에서는 파일 이름을 UpdateAppAcctRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > UpdateAppAcctRfc.json

4. UpdateAppAcctRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-0fuztxgwy37rf",
   "Title":                "Child Application Account RFC"
   }

5. UpdateAppAcctRfc 파일과 UpdateAppAcctParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://UpdateAppAcctRfc.json  --execution-parameters file://UpdateAppAcctParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --title="Associate Private IP Addresses" --description="Associate Private IP Addresses" --ct-id="ct-1pvlhug439gl2" --ct-version="1.0" --input-params="{\"NetworkInterfaceId\":\"eni-0123456789abcdef0\",\"PrivateIpAddresses\":[\"10.0.0.82\",\"10.0.0.83\"]}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 JSON 파일로 출력합니다.이 예제에서는 AssociatePrivateIPAddressesParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-1pvlhug439gl2" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > AssociatePrivateIPAddressesParams.json

2. AssociatePrivateIPAddressesParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "NetworkInterfaceId": "eni-0123456789abcdef0",
       "PrivateIpAddresses": ["10.0.0.82", "10.0.0.83"]
     }
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 AssociatePrivateIPAddressesRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > AssociatePrivateIPAddressesRfc.json

4. AssociatePrivateIPAddressesRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion": "1.0",
     "ChangeTypeId": "ct-1pvlhug439gl2",
     "Title": "Associate Private IP Addresses"
   }

5. AssociatePrivateIPAddressesRfc 파일과 AssociatePrivateIPAddressesParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://AssociatePrivateIPAddressesRfc.json  --execution-parameters file://AssociatePrivateIPAddressesParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-10yi1sd9nst1c" --change-type-version "1.0" --title "Create option group (review required)" --execution-parameters "{\"OptionGroupName\": \"CreatingTheOptionGroup\", \"Description\": \"RDS option group\", \"EngineName\": \"sqlserver-ee\", \"MajorEngineVersion\": \"10.01\", \"DBInstanceName\": \"database-1\", \"Priority\": \"Medium\"}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 CreateRdsOptionGroupParams.json.

   aws amscm get-change-type-version --change-type-id "ct-10yi1sd9nst1c" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateRdsOptionGroupParams.json

2. 실행 파라미터 JSON 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "OptionGroupName": "OptionGroup",
     "EngineName": "sqlserver-ee",
     "MajorEngineVersion": "10.01"
   }

3. JSON 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 CreateRdsOptionGroupRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateRdsOptionGroupRfc.json

4. CreateRdsOptionGroupRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
   "ChangeTypeVersion":    "1.0",
   "ChangeTypeId":         "ct-10yi1sd9nst1c",
   "Title":                "RDS-Create-RFC"
   }

5. 실행 파라미터 파일과 CreateRdsOptionGroupRfc 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateRdsOptionGroupRfc.json --execution-parameters file://CreateRdsOptionGroupParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 따옴표 이스케이프)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-0rmgrnr9w8mzh" --change-type-version "1.0" --title "Remove TGW Static Route" --execution-parameters "{\"DocumentName\": \"AWSManagedServices-RemoveRouteFromTGWRouteTable\",\"Region\": \"us-east-1\",\"Parameters\": {\"TransitGatewayRouteTableId\": \"tgw-rtb-06ddc751c0c0c881c\", \"DestinationCidrBlock\": \"10.16.1.0/24\"}}"

템플릿 생성:

1. 이 변경 유형에 대한 실행 파라미터 JSON 스키마를 파일로 출력합니다.이 예제에서는 파일 이름을 RemoveTgwStaticRouteParams.json:으로 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-0rmgrnr9w8mzh" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > RemoveTgwStaticRouteParams.json

2. RemoveTgwStaticRouteParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "DocumentName": "AWSManagedServices-RemoveRouteFromTGWRouteTable",
     "Region": "us-east-1",
     "Parameters": {
       "TransitGatewayRouteTableId": "tgw-rtb-06ddc751c0c0c881c",
       "DestinationCidrBlock": "10.16.1.0/24"
     }
   }

3. RFC 템플릿 JSON 파일을 파일로 출력합니다.이 예제에서는 파일 이름을 RemoveTgwStaticRouteRfc.json:으로 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > RemoveTgwStaticRouteRfc.json

4. RemoveTgwStaticRouteRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
     "ChangeTypeVersion": "1.0",
     "ChangeTypeId": "ct-0rmgrnr9w8mzh",
     "Title": "Remove TGW Static Route"
   }

5. RemoveTgwStaticRouteRfc 파일과 RemoveTgwStaticRouteParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://RemoveTgwStaticRouteRfc.json  --execution-parameters file://RemoveTgwStaticRouteParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID

인라인 생성:

인라인으로 제공된 실행 파라미터(실행 파라미터를 인라인으로 제공할 때 이스케이프 따옴표)로 RFC 생성 명령을 실행한 다음 반환된 RFC ID를 제출합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

aws amscm create-rfc --change-type-id "ct-36emj2uapfbu8" --change-type-version "2.0" --title "Create Pre-Ingestion Instance" --execution-parameters "{\"InstanceVpcId\": \"vpc-1234567890abcdef0\",\"InstanceAmiId\": \"ami-1234567890abcdef0\",\"InstanceEBSOptimized\": false,\"InstanceRootVolumeSize\": 60,\"InstanceNameTagValue\": \"temp-wigs\",\"InstanceType\": \"t3.large\",\"InstanceSubnetId\": \"subnet-0bb1c79de3EXAMPLE\"}"

템플릿 생성:

1. 이 변경 유형의 실행 파라미터를 JSON 파일로 출력합니다.이 예제에서는 CreateEc2PreIngestParams.json:이라는 이름을 지정합니다.

   aws amscm get-change-type-version --change-type-id "ct-36emj2uapfbu8" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateEc2PreIngestParams.json

2. CreateEc2PreIngestParams 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "InstanceVpcId": "vpc-1234567890abcdef0",
       "InstanceAmiId": "ami-1234567890abcdef0",
       "InstanceEBSOptimized": false,    
       "InstanceRootVolumeSize": 60,
       "InstanceSubnetId": "subnet-1234567890abcdef0",
       "InstanceType": "t3.large",
       "InstanceNameTagValue": "temp-wigs",   
     }
   }

3. RFC 템플릿을 현재 폴더의 파일로 출력합니다.이 예제에서는 CreateEc2PreIngestRfc.json:이라는 이름을 지정합니다.

   aws amscm create-rfc --generate-cli-skeleton > CreateEc2PreIngestRfc.json

4. CreateEc2PreIngestRfc.json 파일을 수정하고 저장합니다. 예를 들어 콘텐츠를 다음과 같은 내용으로 바꿀 수 있습니다.

   {
       "ChangeTypeVersion": "2.0",
       "ChangeTypeId": "ct-36emj2uapfbu8",
       "Title": "Create Pre-Ingestion Instance"
   }

5. CreateEc2PreIngestRfc 파일과 CreateEc2PreIngestParams 파일을 지정하여 RFC를 생성합니다.

   aws amscm create-rfc --cli-input-json file://CreateEc2PreIngestRfc.json  --execution-parameters file://CreateEc2PreIngestParams.json

   응답에서 새 RFC의 ID를 수신하고 이를 사용하여 RFC를 제출하고 모니터링할 수 있습니다. 제출하기 전까지는 RFC가 편집 상태로 유지되고 시작되지 않습니다.

변경 유형 버전을 확인하려면 다음 명령을 사용합니다.

aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID