评论攻略

要检查更改类型版本，请使用以下命令：

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-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 的 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. 创建 RFC，指定执行参数文件和 validateCreateRule文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 架构；此示例将其命名为 U VPCEndpoint PolicyParams pdate .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 文件；此示例将其命名为 Update p VPCEndpoint olicyrfc.json：

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

4. 修改并保存更新VPCEndpoint政策 rfc.json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 Update p VPCEndpoint olicyRFC 文件和更新文件：VPCEndpointPolicyParams

   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

内联创建：

使用内联提供的执行参数发出 create 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 架构输出到当前文件夹中的一个文件中。此示例将其命名为 Delete NATGateway params.json。

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

2. 修改并保存 Delete NATGateway params.json 文件。例如，你可以用这样的东西替换内容：

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

3. 将 RFC 模板输出到当前文件夹中的一个文件中。此示例将其命名为 Delete NATGateway rfc.json。

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

4. 修改并保存 “删除 NATGateway rfc.json” 文件。

   ExecutionParametersJSON 扩展中的内部引号必须使用反斜杠 (\) 进行转义。示例：

   {
   "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

内联创建：

使用内联提供的执行参数发出 create 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 文件；此示例将其命名为 UPdate EC2 ImdsRegionParams .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 模板输出到当前文件夹中的一个文件中；此示例将其命名为 UPdate EC2 ImdsRegionRfc .json：

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

4. 修改并保存 UPdate EC2 ImdsRegionRfc .json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 UPdateEC2ImdsRegionRfc 文件和 UPdateEC2ImdsRegionParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 ComputerObjectCreateSpnRfc 文件和 ComputerObjectCreateSpnParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 TgDeleteRfc 文件和 TgDeleteParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 CreateAlbRfc 文件和 CreateAlbParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 UpdateAlbRfc 文件和 UpdateAlbParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 CreateListenerRfc 文件和 CreateListenerParams 文件：

   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. 修改架构，根据需要variables替换。

   {
       "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. 创建 RFC，指定 CreateOnetierStackRfc .json 文件和.js CreateOnetierStackParams on 执行参数文件：

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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. 创建 RFC，指定 CreateIamResourceRfc 文件和 CreateIamResourceParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 将的 JSON 模板输出 CreateRfc 到当前文件夹中的一个文件中；此示例将其命名为 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. 创建 RFC，指定 ContinueRollbackRfc 文件和执行参数文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 ManageSubnetAutoAddressRfc 文件和 ManageSubnetAutoAddressParams 文件：

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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. 创建 RFC，指定 AddScheduleRfc 文件和 AddScheduleParams 文件：

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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. 创建 RFC，指定 DeleteEbsSnpshtRrRfc 文件和 DeleteEbsSnpshtRrParams 文件：

   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. 创建 RFC，指定 SnsUpdate Rfc 文件和文件： SnsUpdateParams

   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

内联创建：

使用内联提供的执行参数发出 create 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 架构输出到文件中；此示例将其命名为 createS3 AccessPointParams .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. 修改并保存 createS3 AccessPointParams 文件。

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

3. 将 RFC 模板 JSON 文件输出到名为 createS3 .json AccessPointRfc 的文件中：

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

4. 修改并保存 createS3 AccessPointRfc .json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 createS3 AccessPointRfc 文件和 create AccessPointParams S3 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 架构输出到文件中；此示例将其命名为 RDSCreate ParameterGroupParams .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 模板输出到当前文件夹中的一个文件中；此示例将其命名为 RDSCreate ParameterGroupRfc .json：

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

3. 修改并保存 RDSCreate ParameterGroupRfc .json 文件。例如，你可以用这样的东西替换内容：

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

4. 创建 RFC，指定 RDSCreateParameterGroupRfc 文件和 GRDSCreateParameterGroupParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 架构输出到文件中；此示例将其命名为 AddEventNotification s3Params.json。

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

2. 修改并保存 AddEventNotification S3Params 文件。例如，你可以用这样的东西替换内容：

   {
     "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 文件输出到名为 s3rfc.j AddEventNotification son 的文件中：

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

4. 修改并保存 addS3 LifecycleConfigRfc .json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 S3Rfc 文件和 AddEventNotification S3Params 文件： AddEventNotification

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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 的 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. 创建 RFC，指定 CreateAcmPublicRfc 文件和 CreateAcmPublicParams 文件：

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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. 将此更改类型的执行参数输出到名为 CreateMigrateToRoute 5 RequiredParams 3.json 的 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 模板输出到当前文件夹中的一个文件中；此示例将其命名为 CreateMigrateToRoute 53 RequiredRfc .json：

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

4. 修改并保存 CreateMigrateToRoute 53 RequiredRfc .json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 CreateMigrateToRoute 53 RequiredRfc 文件和 CreateMigrateToRoute 53 RequiredParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 CreateAmiFromAsgRfc 文件和 CreateAmiFromAsgParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 的 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 模板输出到当前文件夹中的一个文件中；此示例将其命名为 U RDSEnhanced MonitoringRfc pdate .json：

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

4. 修改并保存更新 RDSEnhanced MonitoringRfc .json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定执行参数文件和更新RDSEnhancedMonitoringRfc 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 架构；此示例将其命名为 VPCAssociate ResolverRule .json：

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

2. 修改执行参数并将其保存为 VPCAssociate ResolverRuleParams .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 文件；此示例将其命名为 VPCAssociate ResolverRuleRfc .json：

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

4. 修改并保存 VPCAssociate ResolverRuleRfc .json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 VPCAssociateResolverRuleRfc 文件和 VPCAssociateResolverRuleParams文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 架构；此示例将其命名为 Deploy AMSPatterns params.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 文件；此示例将其命名为 Deploy r AMSPatterns fc.json：

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

4. 修改并保存 Deploy AMSPatterns rfc.json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 Deploy AMSPatterns Rfc 文件和部署AMSPatterns参数文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 ShareKmsKeyParamsRfc 文件和 ShareKmsKeyParams 文件：

   aws amscm create-rfc --cli-input-json file://ShareKmsKeyParamsRfc.json --execution-parameters file://ShareKmsKeyParams.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-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 架构输出到文件中；此示例将其命名为 Create ADTrust params.json：

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

   修改并保存创建 ADTrust params.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 模板输出到当前文件夹中的一个文件中；此示例将其命名为 Create r ADTrust fc.json：

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

3. 修改并保存创建 ADTrust rfc.json 文件。例如，你可以用这样的东西替换内容：

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

4. 创建 RFC，指定创建 ADTrust Rfc 文件和创建ADTrust参数文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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 架构输出到文件中；此示例将其命名为 EnableAutomated IAMProvisioning params.json。

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

2. 修改并保存 EnableAutomated IAMProvisioning Params 文件。例如，你可以用这样的东西替换内容：

   {
     "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 文件输出到名为 EnableAutomated IAMProvisioning rfc.json 的文件中：

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

4. 修改并保存 EnableAutomated IAMProvisioning rfc.json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 UpdateSecurityPolicy Rfc 文件和文件： UpdateSecurityPolicyParams

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 AddStaticRouteRfc 文件和 AddStaticRouteParams 文件：

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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. 创建 RFC，指定 CreateIamResourceRfc 文件和 CreateIamResourceParams 文件：

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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. 创建 RFC，指定 UpdateIamResourceRfc 文件和 UpdateIamResourceParams 文件：

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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. 创建 RFC，指定 DeleteIamResourceRfc 文件和 DeleteIamResourceParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 文件；此示例将其命名为 UpdateEc 2 MonitoringParams .json：

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

2. 修改并保存 UpdateEc 2 MonitoringParams 文件，仅保留要更改的参数。例如，你可以用这样的东西替换内容：

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

3. 将 RFC 模板输出到当前文件夹中的一个文件中；此示例将其命名为 UpdateEc 2 MonitoringRfc .json：

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

4. 修改并保存 UpdateEc 2 MonitoringRfc .json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 UpdateEc 2 MonitoringRfc 文件和 UpdateEc 2 MonitoringParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 DirectorySharingRfc 文件和 DirectorySharingParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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. 创建 RFC，指定 DirectoryUnsharingRfc 文件和 DirectoryUnsharingParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 架构；此示例将其命名为 VPCEndpoint CreateParams .json：

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

2. 修改执行参数并将其保存为 VPCEndpoint CreateParams .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 文件；此示例将其命名为 VPCEndpoint CreateRfc .json：

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

4. 修改并保存 VPNGateway CreateRfc .json 文件。例如，你可以用这样的东西替换内容：

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

5. 创建 RFC，指定 VPCEndpointCreateRfc 文件和 VPCEndpointCreateParams文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 的 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. 创建 RFC，指定执行参数文件和 UpdateStorageRfc 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 的 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. 创建 RFC，指定执行参数文件和 UpdateMultipleAzRfc 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 的 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. 创建 RFC，指定执行参数文件和 UpdateInstanceTypeRfc 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 的 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. 创建 RFC，指定执行参数文件和 UpdateRdsRfc 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 的 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. 创建 RFC，指定执行参数文件和 UpdateBucketEncryptionRfc 文件：

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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. 创建 RFC，指定 UpdateAppAcctRfc 文件和 UpdateAppAcctParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 文件；此示例将其命名为 AssociatePrivate IPAddresses params.json：

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

2. 修改并保存 AssociatePrivate IPAddresses Params 文件。例如，你可以用这样的东西替换内容：

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

3. 将 RFC 模板输出到当前文件夹中的一个文件中；此示例将其命名为 r AssociatePrivate IPAddresses fc.json：

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

4. 修改并保存 AssociatePrivate IPAddresses rfc.json 文件。例如，你可以用这样的东西替换内容：。

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

5. 创建 RFC，指定 AssociatePrivate IPAddresses Rfc 文件和 AssociatePrivate IPAddresses Params 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 的 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. 创建 RFC，指定执行参数文件和 CreateRdsOptionGroupRfc 文件：

   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

内联创建：

使用内联提供的执行参数（内联提供执行参数时使用转义引号）发出 create 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. 创建 RFC，指定 RemoveTgwStaticRouteRfc 文件和 RemoveTgwStaticRouteParams 文件：

   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

内联创建：

使用内联提供的执行参数发出 create 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 文件；此示例将其命名为 CreateEc 2 PreIngestParams .json：

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

2. 修改并保存 CreateEc 2 PreIngestParams 文件。例如，你可以用这样的东西替换内容：

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

3. 将 RFC 模板输出到当前文件夹中的一个文件中；此示例将其命名为 CreateEc 2 PreIngestRfc .json：

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

4. 修改并保存 CreateEc 2 PreIngestRfc .json 文件。例如，你可以用这样的东西替换内容：。

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

5. 创建 RFC，指定 CreateEc 2 PreIngestRfc 文件和 CreateEc 2 PreIngestParams 文件：

   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