tutoriales de reseñas

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado validateCreateRule .actions.JSON.

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

2. Modifique y guarde el archivo JSON de los parámetros de ejecución. Por ejemplo, puedes reemplazar el contenido por algo como esto:

   Ejemplo de todos los parámetros:

   {
   "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. Envía la plantilla JSON a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre CreateListenerRuleRfc .json:

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

4. Modifica y guarda el CreateListenerRuleRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo de parámetros de ejecución y el validateCreateRule archivo:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}

CREACIÓN DE PLANTILLA:

1. Genera el esquema JSON de los parámetros de ejecución para este tipo de cambio; este ejemplo lo denomina Update VPCEndpoint PolicyParams .json:

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

2. Modifique y guarde el archivo JSON de los parámetros de ejecución. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Genera el archivo JSON de la plantilla RFC; este ejemplo lo denomina Update VPCEndpoint PolicyRFC.json:

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

4. Modifique y guarde el archivo Update PolicyRFC.json. VPCEndpoint Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el archivo VPCEndpoint RFC de la política de actualización y el archivo de actualización: VPCEndpoint PolicyParams

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON a un archivo de tu carpeta actual. Este ejemplo lo denomina Delete NATGateway Params.json.

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

2. Modifique y guarde el archivo Delete NATGateway Params.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía la plantilla RFC a un archivo de tu carpeta actual. En este ejemplo se llama Delete NATGateway RFC.json.

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

4. Modifique y guarde el archivo Delete NATGateway RFC.json.

   Las comillas internas de la extensión ExecutionParameters JSON deben ir precedidas de una barra invertida (\). Ejemplo:

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

5. Cree el RFC:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON; este ejemplo lo nombra UPdate EC2 ImdsRegionParams .json:

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

2. Modifique y guarde el UPdate EC2 ImdsRegionParams archivo, conservando solo los parámetros que desee cambiar. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

3. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre UPdate EC2 ImdsRegionRfc .json:

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

4. Modifique y guarde el UPdate EC2 ImdsRegionRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el UPdate EC2 ImdsRegionRfc archivo y el UPdate EC2 ImdsRegionParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\" } }"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo nombra ComputerObjectCreateSpnParams .json:

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

   Modifique y guarde el ComputerObjectCreateSpnParams archivo. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

2. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre ComputerObjectCreateSpnRfc .json:

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

3. Modifique y guarde el ComputerObjectCreateSpnRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

4. Cree el RFC, especificando el ComputerObjectCreateSpnRfc archivo y el ComputerObjectCreateSpnParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Genera los parámetros de ejecución del esquema JSON para este tipo de cambio en un archivo JSON; en este ejemplo se le asigna el nombre TgDeleteParams .json.

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

2. Modifique y guarde el TgDeleteParams archivo. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

3. Envía la plantilla RFC a un archivo de tu carpeta actual llamado TgDeleteRfc .json:

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

4. Modifique y guarde el TgDeleteRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el TgDeleteRfc archivo y el TgDeleteParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

CREACIÓN DE PLANTILLA:

1. Genere el esquema JSON de los parámetros de ejecución para este tipo de cambio en un archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

2. Modifique y guarde el CreateAlbParams archivo. Por ejemplo:

   {
   "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. Envía la plantilla RFC a un archivo de tu carpeta actual. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

4. Modifica y guarda el CreateAlbRfc archivo.json. Por ejemplo:

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

5. Cree el RFC, especificando el CreateAlbRfc archivo y el CreateAlbParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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"}}'

CREACIÓN DE PLANTILLA:

1. Genere el esquema JSON de los parámetros de ejecución para este tipo de cambio en un archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

2. Modifique y guarde el UpdateAlbParams archivo. Por ejemplo:

   {
   "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. Envía la plantilla RFC a un archivo de tu carpeta actual. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

4. Modifica y guarda el UpdateAlbRfc archivo.json. Por ejemplo:

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

5. Cree el RFC, especificando el UpdateAlbRfc archivo y el UpdateAlbParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

CREACIÓN DE PLANTILLA:

1. Genera los parámetros de ejecución del esquema JSON para este tipo de cambio en un archivo JSON; en este ejemplo se le asigna el nombre CreateListenerParams .json:

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

2. Modifique y guarde el CreateListenerParams archivo. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

3. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre CreateListenerRfc .json:

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

4. Modifique y guarde el CreateListenerRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el CreateListenerRfc archivo y el CreateListenerParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

   Próximos pasos: envíe un formulario de administración | Otros | Otros | Actualice el tipo de cambio para abrir los puertos y asociar los grupos de seguridad; consulte Otros | Otras solicitudes.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre CreateOnetierStackParams .json.

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

2. Modifique el esquema y reemplácelo según variables corresponda.

   {
       "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. Envía la plantilla CreateRfc JSON a un archivo de tu carpeta actual; el ejemplo la nombra CreateOnetierStackRfc .json:

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

4. Modifique la plantilla RFC según corresponda y guárdela. Restablezca las horas de inicio y finalización de una RFC programada o déjelas desactivadas para una RFC lo antes posible.

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

5. Cree el RFC especificando el archivo.json y el archivo de parámetros de ejecución CreateOnetierStackRfc .json: CreateOnetierStackParams

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá usarlo para enviar y monitorear el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; el ejemplo lo nombra CreateIamResourceParams .json:

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

2. Modifique y guarde el CreateIamResourceParams archivo; en el ejemplo, se crea un rol de IAM con los documentos de política pegados en línea.

   {
     "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. Transfiera el archivo JSON de la plantilla RFC a un archivo denominado .json: CreateIamResourceRfc

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

4. Modifique y guarde el CreateIamResourceRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el CreateIamResourceRfc archivo y el CreateIamResourceParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo de tu carpeta actual; este ejemplo lo nombra ContinueRollbackParams .json:

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

2. Modifica y guarda el ContinueRollbackParams archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía la plantilla JSON CreateRfc a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre ContinueRollbackRfc .json:

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

4. Modifica y guarda el ContinueRollbackRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el ContinueRollbackRfc archivo y el archivo de parámetros de ejecución:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"]}}"

CREACIÓN DE PLANTILLA:

1. Genera el esquema JSON de los parámetros de ejecución para este tipo de cambio; este ejemplo lo nombra ManageSubnetAutoAddressParams .json:

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

2. Modifique y guarde el archivo JSON de los parámetros de ejecución. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Genera el archivo JSON de la plantilla RFC; este ejemplo lo nombra ManageSubnetAutoAddressRfc .json:

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

4. Modifique y guarde el ManageSubnetAutoAddressRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el ManageSubnetAutoAddressRfc archivo y el ManageSubnetAutoAddressParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"]}}"

CREACIÓN DE PLANTILLA:

1. Genera los parámetros de ejecución del esquema JSON para este tipo de cambio en un archivo JSON; en este ejemplo se le asigna el nombre AddScheduleParams .json:

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

2. Modifique y guarde el AddScheduleParams archivo.

   {
     "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. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre AddScheduleRfc .json:

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

4. Modifique y guarde el AddScheduleRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el AddScheduleRfc archivo y el AddScheduleParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo nombra DeleteEbsSnpshtRrParams .json:

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

2. Modifique y guarde el DeleteEbsSnpshtRrParams archivo. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

3. Envía el archivo JSON de la plantilla RFC a un archivo; este ejemplo lo nombra DeleteEbsSnpshtRrRfc .json:

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

4. Modifique y guarde el DeleteEbsSnpshtRrRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el DeleteEbsSnpshtRrRfc archivo y el DeleteEbsSnpshtRrParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

INLINE CREATE (parámetros mínimos):

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

TEMPLATE CREATE (todos los parámetros):

1. Genera los parámetros de ejecución del esquema JSON para este tipo de cambio en un archivo; en este ejemplo se le asigna el nombre SnsUpdateParams .json.

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

2. Modifique y guarde el SnsUpdateParams archivo. Por ejemplo, puede reemplazar el contenido por algo como esto:

   {
     "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. Envía el archivo JSON de la plantilla RFC a un archivo llamado SnsUpdateRfc .json:

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

4. Modifique y guarde el SnsUpdateRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el archivo SnsUpdate Rfc y el SnsUpdateParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; en este ejemplo, se denomina 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. Modifique y guarde el archivo CreateS3. AccessPointParams

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

3. Extraiga el archivo JSON de la plantilla RFC a un archivo denominado CreateS3 .json: AccessPointRfc

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

4. Modifique y guarde el archivo CreateS3 .json. AccessPointRfc Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo CreateS3 y el AccessPointRfc archivo CreateS3: AccessPointParams

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo nombra RDSCreate ParameterGroupParams .json:

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

   Modifique y guarde el RDSCreate ParameterGroupParams archivo. Por ejemplo, puede reemplazar el contenido por algo como esto:

   {
     "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. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre RDSCreate ParameterGroupRfc .json:

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

3. Modifique y guarde el RDSCreate ParameterGroupRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

4. Cree el RFC, especificando el RDSCreate ParameterGroupRfc archivo y el GRDSCreate ParameterGroupParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\" } }"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo denomina AddEventNotification S3Params.json.

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

2. Modifique y guarde el archivo S3Params. AddEventNotification Por ejemplo, puede reemplazar el contenido por algo como esto:

   {
     "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. Envía el archivo JSON de la plantilla RFC a un archivo llamado AddEventNotification S3RFC.json:

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

4. Modifique y guarde el archivo AddS3 .json. LifecycleConfigRfc Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el archivo AddEventNotification S3Rfc y el archivo S3Params: AddEventNotification

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá usarlo para enviar y monitorear el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado CustomerCustomDenyActionsList .json.

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

2. Modifique y guarde los parámetros de ejecución en el archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre CustomerCustomDenyActionsListRfc .json:

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

4. Modifique y guarde el CustomerCustomDenyActionsListRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el CreateAcmPublicRfc archivo y el CreateAcmPublicParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

Solo parámetros obligatorios:

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

Todos los parámetros obligatorios y opcionales:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado CreateMigrateToRoute 53 RequiredParams .json.

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

2. Modifique y guarde el archivo JSON de los parámetros de ejecución. Por ejemplo, puedes reemplazar el contenido por algo como esto:

   {
     "Priority": "Medium"
   }

3. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre CreateMigrateToRoute 53 RequiredRfc .json:

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

4. Modifique y guarde el archivo CreateMigrateToRoute 53 RequiredRfc .json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el RequiredRfc archivo CreateMigrateToRoute 53 y el RequiredParams archivo CreateMigrateToRoute 53:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo nombra 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. Modifique y guarde el CreateAmiFromAsgParams archivo.json de los parámetros de ejecución. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía el archivo JSON de la plantilla RFC a un archivo de tu carpeta actual; este ejemplo lo nombra CreateAmiFromAsgRfc .json:

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

4. Modifique y guarde el CreateAmiFromAsgRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el CreateAmiFromAsgRfc archivo y el CreateAmiFromAsgParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado RotateRdsCertParams .json.

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

2. Modifique y guarde los parámetros de ejecución en el archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

   {
       "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. Envía la plantilla JSON a un archivo de tu carpeta actual; en este ejemplo se llama Update RDSEnhanced MonitoringRfc .json:

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

4. Modifica y guarda el archivo Update RDSEnhanced MonitoringRfc .json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo de parámetros de ejecución y el archivo de actualización RDSEnhancedMonitoringRfc :

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Genera el esquema JSON de los parámetros de ejecución para este tipo de cambio; este ejemplo lo nombra VPCAssociate ResolverRule .json:

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

2. Modifique y guarde los parámetros de ejecución como VPCAssociate ResolverRuleParams .json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Genera el archivo JSON de la plantilla RFC; este ejemplo lo nombra VPCAssociate ResolverRuleRfc .json:

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

4. Modifique y guarde el VPCAssociate ResolverRuleRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el VPCAssociate ResolverRuleRfc archivo y el VPCAssociate ResolverRuleParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Genera el esquema JSON de los parámetros de ejecución para este tipo de cambio; este ejemplo lo denomina Deploy AMSPatterns Params.json:

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

2. Modifique y guarde el archivo JSON de los parámetros de ejecución. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Genera el archivo JSON de la plantilla RFC; en este ejemplo se le llama Deploy AMSPatterns RFC.json:

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

4. Modifique y guarde el archivo Deploy RFC.jsonAMSPatterns. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo AMSPatterns Rfc de despliegue y el archivo de AMSPatterns parámetros de despliegue:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo nombra ShareKmsKeyParams .json:

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

   Modifique y guarde el ShareKmsKeyParams archivo. Por ejemplo, puede reemplazar el contenido por algo como esto:

   {
     "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. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre ShareKmsKeyParamsRfc .json:

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

3. Modifique y guarde el ShareKmsKeyParams archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

4. Cree el RFC, especificando el ShareKmsKeyParamsRfc archivo y el ShareKmsKeyParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

   Para iniciar sesión en la instancia a través de un bastión, siga el siguiente procedimiento (Ejemplos de acceso a la instancia).

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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"]}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo denomina Create ADTrust Params.json:

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

   Modifique y guarde el archivo Create ADTrust Params.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

   {
     "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. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se llama Create ADTrust RFC.json:

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

3. Modifique y guarde el archivo Create ADTrust RFC.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

4. Cree el RFC, especificando el archivo Create ADTrust Rfc y el archivo Create ADTrust Params:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo. En este ejemplo se le asigna el nombre OverrideStackAccessDurationParameters .json:

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

2. Modifique y guarde el OverrideStackAccessDurationParameters archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía el archivo JSON de la plantilla RFC a un archivo llamado OverrideStackAccessDuration .json:

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

4. Modifique y guarde el OverrideStackAccessDuration archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Crea el RFC:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Genera los parámetros de ejecución del esquema JSON para este tipo de cambio en un archivo; en este ejemplo se denomina EnableAutomated IAMProvisioning params.json.

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

2. Modifique y guarde el archivo EnableAutomated IAMProvisioning Params. Por ejemplo, puede reemplazar el contenido por algo como esto:

   {
     "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. Envía el archivo JSON de la plantilla RFC a un archivo llamado EnableAutomated IAMProvisioning RFC.json:

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

4. Modifique y guarde el archivo RFC.json EnableAutomatedIAMProvisioning. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el archivo UpdateSecurityPolicy Rfc y el UpdateSecurityPolicyParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Genera el esquema JSON de los parámetros de ejecución para este tipo de cambio; este ejemplo lo nombra EncryptAmiParams .json:

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

2. Modifique y guarde el AddStaticRouteParams archivo .json de ejecución. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Genera el archivo JSON de la plantilla RFC; este ejemplo lo nombra AddStaticRouteRfc .json:

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

4. Modifique y guarde el AddStaticRouteRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el AddStaticRouteRfc archivo y el AddStaticRouteParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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"]}}}]}"}]}}'

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; el ejemplo lo nombra CreateIamResourceParams .json:

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

2. Modifique y guarde el CreateIamResourceParams archivo; en el ejemplo, se crea un rol de IAM con los documentos de política pegados en línea.

   {
     "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. Transfiera el archivo JSON de la plantilla RFC a un archivo denominado .json: CreateIamResourceRfc

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

4. Modifique y guarde el CreateIamResourceRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el CreateIamResourceRfc archivo y el CreateIamResourceParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\\\"]}}}]}\"}]}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; el ejemplo lo nombra UpdateIamResourceParams .json:

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

2. Modifique y guarde el UpdateIamResourceParams archivo; en el ejemplo, se crea un rol de IAM con los documentos de política pegados en línea.

   {
     "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. Transfiera el archivo JSON de la plantilla RFC a un archivo denominado .json: UpdateIamResourceRfc

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

4. Modifique y guarde el UpdateIamResourceRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el UpdateIamResourceRfc archivo y el UpdateIamResourceParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"]}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; el ejemplo lo nombra DeleteIamResourceParams .json:

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

2. Modifique y guarde el DeleteIamResourceParams archivo; en el ejemplo, se crea un rol de IAM con los documentos de política pegados en línea.

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

3. Transfiera el archivo JSON de la plantilla RFC a un archivo denominado .json: DeleteIamResourceRfc

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

4. Modifique y guarde el DeleteIamResourceRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el DeleteIamResourceRfc archivo y el DeleteIamResourceParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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"]}}'

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON; en este ejemplo se le asigna el nombre UpdateEc 2 MonitoringParams .json:

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

2. Modifique y guarde el MonitoringParams archivo UpdateEc 2, conservando solo los parámetros que desee cambiar. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

3. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre UpdateEc 2 MonitoringRfc .json:

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

4. Modifique y guarde el archivo UpdateEc 2 MonitoringRfc .json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el MonitoringRfc archivo UpdateEc 2 y el MonitoringParams archivo UpdateEc 2:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"]}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo nombra DirectorySharingParams .json:

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

   Modifique y guarde el DirectorySharingParams archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

2. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre DirectorySharingRfc .json:

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

3. Modifique y guarde el DirectorySharingRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

4. Cree el RFC, especificando el DirectorySharingRfc archivo y el DirectorySharingParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"]}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo nombra DirectoryUnsharingParams .json:

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

   Modifique y guarde el DirectoryUnsharingParams archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

2. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre DirectoryUnsharingRfc .json:

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

3. Modifique y guarde el DirectoryUnsharingRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

4. Cree el RFC, especificando el DirectoryUnsharingRfc archivo y el DirectoryUnsharingParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

CREACIÓN DE PLANTILLA:

1. Genera el esquema JSON de los parámetros de ejecución para este tipo de cambio; este ejemplo lo nombra VPCEndpoint CreateParams .json:

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

2. Modifique y guarde los parámetros de ejecución como VPCEndpoint CreateParams .json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

   {
     "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. Genera el archivo JSON de la plantilla RFC; este ejemplo lo nombra VPCEndpoint CreateRfc .json:

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

4. Modifique y guarde el VPNGateway CreateRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el VPCEndpoint CreateRfc archivo y el VPCEndpoint CreateParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado UpdateStorageParams .json.

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

2. Modifique y guarde los parámetros de ejecución en el archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía la plantilla JSON a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre UpdateStorageRfc .json:

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

4. Modifica y guarda el UpdateStorageRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo de parámetros de ejecución y el UpdateStorageRfc archivo:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado UpdateMultipleAzParams .json.

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

2. Modifique y guarde los parámetros de ejecución en el archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía la plantilla JSON a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre UpdateMultipleAzRfc .json:

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

4. Modifica y guarda el UpdateMultipleAzRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo de parámetros de ejecución y el UpdateMultipleAzRfc archivo:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado UpdateInstanceTypeParams .json.

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

2. Modifique y guarde los parámetros de ejecución en el archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía la plantilla JSON a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre UpdateInstanceTypeRfc .json:

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

4. Modifica y guarda el UpdateInstanceTypeRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo de parámetros de ejecución y el UpdateInstanceTypeRfc archivo:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado UpdateBucketVersioningParams .json.

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

2. Modifique y guarde los parámetros de ejecución en el archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía la plantilla JSON a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre UpdateBucketVersioningRfc .json:

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

4. Modifica y guarda el UpdateBucketVersioningRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo de parámetros de ejecución y el UpdateRdsRfc archivo:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"]}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado UpdateBucketEncryptionParams .json.

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

2. Modifique y guarde los parámetros de ejecución en el archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía la plantilla JSON a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre UpdateBucketEncryptionRfc .json:

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

4. Modifica y guarda el UpdateBucketEncryptionRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo de parámetros de ejecución y el UpdateBucketEncryptionRfc archivo:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}""

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo nombra CreateAppAcctVpcParams .json:

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

2. Modifique y guarde el UpdateAppAcctParams archivo. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

3. Envía el archivo JSON de la plantilla RFC a un archivo; este ejemplo lo nombra UpdateAppAcctRfc .json:

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

4. Modifique y guarde el UpdateAppAcctRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el UpdateAppAcctRfc archivo y el UpdateAppAcctParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"]}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON; este ejemplo lo denomina AssociatePrivate IPAddresses params.json:

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

2. Modifique y guarde el archivo AssociatePrivate IPAddresses Params. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

3. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le da el nombre AssociatePrivate IPAddresses RFC.json:

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

4. Modifique y guarde el archivo RFC.json AssociatePrivateIPAddresses. Por ejemplo, puede reemplazar el contenido por algo como esto:.

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

5. Cree el RFC, especificando el archivo AssociatePrivate IPAddresses Rfc y el archivo AssociatePrivate IPAddresses Params:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá usarlo para enviar y monitorear el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON denominado CreateRdsOptionGroupParams .json.

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

2. Modifique y guarde los parámetros de ejecución en el archivo JSON. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

3. Envía la plantilla JSON a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre CreateRdsOptionGroupRfc .json:

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

4. Modifica y guarda el CreateRdsOptionGroupRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC especificando el archivo de parámetros de ejecución y el CreateRdsOptionGroupRfc archivo:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución del esquema JSON para este tipo de cambio a un archivo; este ejemplo lo nombra RemoveTgwStaticRouteParams .json:

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

2. Modifique y guarde el RemoveTgwStaticRouteParams archivo. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

3. Envía el archivo JSON de la plantilla RFC a un archivo; este ejemplo lo nombra RemoveTgwStaticRouteRfc .json:

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

4. Modifique y guarde el RemoveTgwStaticRouteRfc archivo.json. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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

5. Cree el RFC, especificando el RemoveTgwStaticRouteRfc archivo y el RemoveTgwStaticRouteParams archivo:

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

   Recibirá el ID de la nueva RFC en la respuesta y podrá utilizarla para enviar y supervisar la RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución incluidos en línea (comillas de escape al proporcionar los parámetros de ejecución en línea) y, a continuación, envíe el ID de RFC devuelto. Por ejemplo, puedes reemplazar el contenido por algo como esto:

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\"}"

CREACIÓN DE PLANTILLA:

1. Envía los parámetros de ejecución de este tipo de cambio a un archivo JSON; en este ejemplo se le asigna el nombre CreateEc 2 PreIngestParams .json:

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

2. Modifique y guarde el PreIngestParams archivo CreateEc 2. Por ejemplo, puede reemplazar el contenido por algo como esto:

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

3. Envía la plantilla RFC a un archivo de tu carpeta actual; en este ejemplo se le asigna el nombre CreateEc 2 PreIngestRfc .json:

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

4. Modifique y guarde el archivo CreateEc 2 PreIngestRfc .json. Por ejemplo, puede reemplazar el contenido por algo como esto:.

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

5. Cree el RFC, especificando el PreIngestRfc archivo CreateEc 2 y el PreIngestParams archivo CreateEc 2:

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

   Recibirá el ID del nuevo RFC en la respuesta y podrá utilizarlo para enviar y supervisar el RFC. Hasta que la envíe, la RFC permanece en estado de edición y no se inicia.

Para comprobar la versión del tipo de cambio, utilice este comando:

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