procédures pas à pas

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé validateCreateRule .actions.JSON.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   Exemple de tous les paramètres :

   {
   "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. Exportez le modèle JSON dans un fichier de votre dossier actuel ; cet exemple le nomme CreateListenerRuleRfc .json :

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

4. Modifiez et enregistrez le fichier CreateListenerRuleRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le fichier de paramètres d'exécution et le validateCreateRule fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Produisez le schéma JSON des paramètres d'exécution pour ce type de modification ; cet exemple le nomme Update VPCEndpoint PolicyParams .json :

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Sortez le fichier JSON du modèle RFC ; cet exemple le nomme Update VPCEndpoint PolicyRFC.json :

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

4. Modifiez et enregistrez le fichier Update VPCEndpoint PolicyRFC.json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez le RFC en spécifiant le fichier Update VPCEndpoint PolicyRFC et le fichier de mise à jour : VPCEndpoint PolicyParams

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution dans un fichier de votre dossier actuel. Cet exemple le nomme Delete NATGateway Params.json.

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

2. Modifiez et enregistrez le fichier Delete NATGateway Params.json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle RFC dans un fichier de votre dossier actuel. Cet exemple le nomme Delete NATGateway RFC.json.

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

4. Modifiez et enregistrez le fichier Delete NATGateway RFC.json.

   Les guillemets internes de l'extension ExecutionParameters JSON doivent être masqués par une barre oblique inverse (\). Exemple :

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

5. Créez le RFC :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution de ce type de modification dans un fichier JSON ; cet exemple le nomme UPdate EC2 ImdsRegionParams .json :

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

2. Modifiez et enregistrez le UPdate EC2 ImdsRegionParams fichier en ne conservant que les paramètres que vous souhaitez modifier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme UPdate EC2 ImdsRegionRfc .json :

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

4. Modifiez et enregistrez le fichier UPdate EC2 ImdsRegionRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le UPdate EC2 ImdsRegionRfc fichier et le UPdate EC2 ImdsRegionParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme ComputerObjectCreateSpnParams .json :

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

   Modifiez et enregistrez le ComputerObjectCreateSpnParams fichier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

2. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme ComputerObjectCreateSpnRfc .json :

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

3. Modifiez et enregistrez le fichier ComputerObjectCreateSpnRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

4. Créez la RFC en spécifiant le ComputerObjectCreateSpnRfc fichier et le ComputerObjectCreateSpnParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier JSON ; cet exemple le nomme TgDeleteParams .json.

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

2. Modifiez et enregistrez le TgDeleteParams fichier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle RFC dans un fichier de votre dossier actuel nommé TgDeleteRfc .json :

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

4. Modifiez et enregistrez le fichier TgDeleteRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le TgDeleteRfc fichier et le TgDeleteParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier JSON. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

2. Modifiez et enregistrez le CreateAlbParams fichier. Exemples :

   {
   "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. Exportez le modèle RFC dans un fichier de votre dossier actuel. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

4. Modifiez et enregistrez le fichier CreateAlbRfc .json. Exemples :

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

5. Créez la RFC en spécifiant le CreateAlbRfc fichier et le CreateAlbParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier JSON. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

2. Modifiez et enregistrez le UpdateAlbParams fichier. Exemples :

   {
   "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. Exportez le modèle RFC dans un fichier de votre dossier actuel. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

4. Modifiez et enregistrez le fichier UpdateAlbRfc .json. Exemples :

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

5. Créez la RFC en spécifiant le UpdateAlbRfc fichier et le UpdateAlbParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier JSON ; cet exemple le nomme CreateListenerParams .json :

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

2. Modifiez et enregistrez le CreateListenerParams fichier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme CreateListenerRfc .json :

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

4. Modifiez et enregistrez le fichier CreateListenerRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le CreateListenerRfc fichier et le CreateListenerParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

   Étapes suivantes : Soumettre un type de modification de gestion | Autre | Autre | Mettre à jour pour ouvrir des ports et associer des groupes de sécurité, voir Autre | Autres demandes.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier de votre dossier actuel ; cet exemple le nomme CreateOnetierStackParams .json.

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

2. Modifiez le schéma en le remplaçant variables comme il convient.

   {
       "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. Exportez le modèle CreateRfc JSON dans un fichier de votre dossier actuel ; l'exemple le nomme CreateOnetierStackRfc .json :

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

4. Modifiez le modèle RFC comme il convient et enregistrez-le. Réinitialisez les heures de début et de fin d'un RFC planifié, ou arrêtez-le pour un RFC ASAP.

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

5. Créez la RFC en spécifiant le fichier CreateOnetierStackRfc .json et le fichier de paramètres d'exécution CreateOnetierStackParams .json :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; l'exemple le nomme CreateIamResourceParams .json :

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

2. Modifiez et enregistrez le CreateIamResourceParams fichier ; par exemple, crée un rôle IAM avec des documents de politique collés en ligne.

   {
     "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. Exportez le fichier JSON du modèle RFC dans un fichier nommé CreateIamResourceRfc .json :

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

4. Modifiez et enregistrez le fichier CreateIamResourceRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le CreateIamResourceRfc fichier et le CreateIamResourceParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Publiez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier de votre dossier actuel ; cet exemple le nomme ContinueRollbackParams .json :

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

2. Modifiez et enregistrez le fichier ContinueRollbackParams .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle JSON CreateRfc pour un fichier de votre dossier actuel ; cet exemple le nomme ContinueRollbackRfc .json :

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

4. Modifiez et enregistrez le fichier ContinueRollbackRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le ContinueRollbackRfc fichier et le fichier de paramètres d'exécution :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification ; cet exemple le nomme ManageSubnetAutoAddressParams .json :

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Sortez le fichier JSON du modèle RFC ; cet exemple le nomme ManageSubnetAutoAddressRfc .json :

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

4. Modifiez et enregistrez le fichier ManageSubnetAutoAddressRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le ManageSubnetAutoAddressRfc fichier et le ManageSubnetAutoAddressParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier JSON ; cet exemple le nomme AddScheduleParams .json :

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

2. Modifiez et enregistrez le AddScheduleParams fichier.

   {
     "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. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme AddScheduleRfc .json :

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

4. Modifiez et enregistrez le fichier AddScheduleRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le AddScheduleRfc fichier et le AddScheduleParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme DeleteEbsSnpshtRrParams .json :

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

2. Modifiez et enregistrez le DeleteEbsSnpshtRrParams fichier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le fichier JSON du modèle RFC dans un fichier ; cet exemple le nomme DeleteEbsSnpshtRrRfc .json :

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

4. Modifiez et enregistrez le fichier DeleteEbsSnpshtRrRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le DeleteEbsSnpshtRrRfc fichier et le DeleteEbsSnpshtRrParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

INLINE CREATE (paramètres minimaux) :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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 (tous les paramètres) :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme SnsUpdateParams .json.

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

2. Modifiez et enregistrez le SnsUpdateParams fichier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   {
     "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. Exportez le fichier JSON du modèle RFC dans un fichier nommé SnsUpdateRfc .json :

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

4. Modifiez et enregistrez le fichier SnsUpdateRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez le RFC en spécifiant le fichier SnsUpdate RFC et le SnsUpdateParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme 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. Modifiez et enregistrez le fichier CreateS3AccessPointParams .

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

3. Exportez le fichier JSON du modèle RFC dans un fichier nommé AccessPointRfc CreateS3 .json :

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

4. Modifiez et enregistrez le fichier CreateS3 AccessPointRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le fichier CreateS3 et le AccessPointRfc fichier CreateS3 : AccessPointParams

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme RDSCreate ParameterGroupParams .json :

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

   Modifiez et enregistrez le RDSCreate ParameterGroupParams fichier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   {
     "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. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme RDSCreate ParameterGroupRfc .json :

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

3. Modifiez et enregistrez le fichier RDSCreate ParameterGroupRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

4. Créez la RFC en spécifiant le RDSCreate ParameterGroupRfc fichier et le GRDSCreate ParameterGroupParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme AddEventNotification S3Params.json.

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

2. Modifiez et enregistrez le fichier AddEventNotification S3Params. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   {
     "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. Exportez le fichier JSON du modèle RFC dans un fichier nommé AddEventNotification S3RFC.json :

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

4. Modifiez et enregistrez le fichier AddS3 LifecycleConfigRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez le RFC en spécifiant le fichier AddEventNotification S3Rfc et le fichier S3Params : AddEventNotification

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé CustomerCustomDenyActionsList .json.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme CustomerCustomDenyActionsListRfc .json :

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

4. Modifiez et enregistrez le fichier CustomerCustomDenyActionsListRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le CreateAcmPublicRfc fichier et le CreateAcmPublicParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

Paramètres obligatoires uniquement :

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

Tous les paramètres obligatoires et facultatifs :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé CreateMigrateToRoute 53 RequiredParams .json.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   {
     "Priority": "Medium"
   }

3. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme CreateMigrateToRoute 53 RequiredRfc .json :

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

4. Modifiez et enregistrez le fichier CreateMigrateToRoute 53 RequiredRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le RequiredRfc fichier CreateMigrateToRoute 53 et le RequiredParams fichier CreateMigrateToRoute 53 :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme 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. Modifiez et enregistrez le fichier CreateAmiFromAsgParams .json des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le fichier JSON du modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme CreateAmiFromAsgRfc .json :

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

4. Modifiez et enregistrez le fichier CreateAmiFromAsgRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le CreateAmiFromAsgRfc fichier et le CreateAmiFromAsgParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé RotateRdsCertParams .json.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   {
       "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. Exportez le modèle JSON dans un fichier de votre dossier actuel ; cet exemple le nomme Update RDSEnhanced MonitoringRfc .json :

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

4. Modifiez et enregistrez le fichier Update RDSEnhanced MonitoringRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le fichier de paramètres d'exécution et le fichier de mise à jour RDSEnhanced MonitoringRfc  :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification ; cet exemple le nomme VPCAssociate ResolverRule .json :

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

2. Modifiez et enregistrez les paramètres d'exécution au format VPCAssociate ResolverRuleParams .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Sortez le fichier JSON du modèle RFC ; cet exemple le nomme VPCAssociate ResolverRuleRfc .json :

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

4. Modifiez et enregistrez le fichier VPCAssociate ResolverRuleRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le VPCAssociate ResolverRuleRfc fichier et le VPCAssociate ResolverRuleParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Produisez le schéma JSON des paramètres d'exécution pour ce type de modification ; cet exemple le nomme Deploy AMSPatterns Params.json :

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Sortez le fichier JSON du modèle RFC ; cet exemple le nomme Deploy AMSPatterns RFC.json :

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

4. Modifiez et enregistrez le fichier Deploy AMSPatterns RFC.json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez le RFC en spécifiant le fichier Deploy AMSPatterns Rfc et le fichier Deploy AMSPatterns Params :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme ShareKmsKeyParams .json :

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

   Modifiez et enregistrez le ShareKmsKeyParams fichier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   {
     "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. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme ShareKmsKeyParamsRfc .json :

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

3. Modifiez et enregistrez le fichier ShareKmsKeyParams .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

4. Créez la RFC en spécifiant le ShareKmsKeyParamsRfc fichier et le ShareKmsKeyParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

   Pour vous connecter à l'instance via un bastion, suivez la procédure suivante, intitulée Exemples d'accès aux instances.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme Create ADTrust Params.json :

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

   Modifiez et enregistrez le fichier Create ADTrust Params.json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   {
     "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. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme Create ADTrust RFC.json :

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

3. Modifiez et enregistrez le fichier Create ADTrust RFC.json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

4. Créez le RFC en spécifiant le fichier Create ADTrust Rfc et le fichier Create ADTrust Params :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier. Cet exemple le nomme OverrideStackAccessDurationParameters .json :

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

2. Modifiez et enregistrez le fichier OverrideStackAccessDurationParameters .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le fichier JSON du modèle RFC dans un fichier nommé OverrideStackAccessDuration .json :

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

4. Modifiez et enregistrez le fichier OverrideStackAccessDuration .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez le RFC :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme EnableAutomated IAMProvisioning Params.JSON.

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

2. Modifiez et enregistrez le fichier de EnableAutomated IAMProvisioning paramètres. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   {
     "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. Exportez le fichier JSON du modèle RFC dans un fichier nommé EnableAutomated IAMProvisioning RFC.json :

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

4. Modifiez et enregistrez le fichier EnableAutomated IAMProvisioning RFC.json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez le RFC en spécifiant le fichier UpdateSecurityPolicy RFC et le UpdateSecurityPolicyParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification ; cet exemple le nomme EncryptAmiParams .json :

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

2. Modifiez et enregistrez le fichier d'exécution AddStaticRouteParams .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Sortez le fichier JSON du modèle RFC ; cet exemple le nomme AddStaticRouteRfc .json :

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

4. Modifiez et enregistrez le fichier AddStaticRouteRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le AddStaticRouteRfc fichier et le AddStaticRouteParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; l'exemple le nomme CreateIamResourceParams .json :

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

2. Modifiez et enregistrez le CreateIamResourceParams fichier ; par exemple, crée un rôle IAM avec des documents de politique collés en ligne.

   {
     "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. Exportez le fichier JSON du modèle RFC dans un fichier nommé CreateIamResourceRfc .json :

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

4. Modifiez et enregistrez le fichier CreateIamResourceRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le CreateIamResourceRfc fichier et le CreateIamResourceParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; l'exemple le nomme UpdateIamResourceParams .json :

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

2. Modifiez et enregistrez le UpdateIamResourceParams fichier ; par exemple, crée un rôle IAM avec des documents de politique collés en ligne.

   {
     "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. Exportez le fichier JSON du modèle RFC dans un fichier nommé UpdateIamResourceRfc .json :

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

4. Modifiez et enregistrez le fichier UpdateIamResourceRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le UpdateIamResourceRfc fichier et le UpdateIamResourceParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; l'exemple le nomme DeleteIamResourceParams .json :

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

2. Modifiez et enregistrez le DeleteIamResourceParams fichier ; par exemple, crée un rôle IAM avec des documents de politique collés en ligne.

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

3. Exportez le fichier JSON du modèle RFC dans un fichier nommé DeleteIamResourceRfc .json :

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

4. Modifiez et enregistrez le fichier DeleteIamResourceRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le DeleteIamResourceRfc fichier et le DeleteIamResourceParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution de ce type de modification dans un fichier JSON ; cet exemple le nomme UpdateEc 2 MonitoringParams .json :

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

2. Modifiez et enregistrez le MonitoringParams fichier UpdateEc 2 en ne conservant que les paramètres que vous souhaitez modifier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme UpdateEc 2 MonitoringRfc .json :

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

4. Modifiez et enregistrez le fichier UpdateEc 2 MonitoringRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le MonitoringRfc fichier UpdateEc 2 et le MonitoringParams fichier UpdateEc 2 :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme DirectorySharingParams .json :

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

   Modifiez et enregistrez le fichier DirectorySharingParams .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

2. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme DirectorySharingRfc .json :

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

3. Modifiez et enregistrez le fichier DirectorySharingRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

4. Créez la RFC en spécifiant le DirectorySharingRfc fichier et le DirectorySharingParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme DirectoryUnsharingParams .json :

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

   Modifiez et enregistrez le fichier DirectoryUnsharingParams .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

2. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme DirectoryUnsharingRfc .json :

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

3. Modifiez et enregistrez le fichier DirectoryUnsharingRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

4. Créez la RFC en spécifiant le DirectoryUnsharingRfc fichier et le DirectoryUnsharingParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification ; cet exemple le nomme VPCEndpoint CreateParams .json :

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

2. Modifiez et enregistrez les paramètres d'exécution au format VPCEndpoint CreateParams .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

   {
     "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. Sortez le fichier JSON du modèle RFC ; cet exemple le nomme VPCEndpoint CreateRfc .json :

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

4. Modifiez et enregistrez le fichier VPNGateway CreateRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le VPCEndpoint CreateRfc fichier et le VPCEndpoint CreateParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé UpdateStorageParams .json.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle JSON dans un fichier de votre dossier actuel ; cet exemple le nomme UpdateStorageRfc .json :

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

4. Modifiez et enregistrez le fichier UpdateStorageRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le fichier de paramètres d'exécution et le UpdateStorageRfc fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé UpdateMultipleAzParams .json.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle JSON dans un fichier de votre dossier actuel ; cet exemple le nomme UpdateMultipleAzRfc .json :

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

4. Modifiez et enregistrez le fichier UpdateMultipleAzRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le fichier de paramètres d'exécution et le UpdateMultipleAzRfc fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé UpdateInstanceTypeParams .json.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle JSON dans un fichier de votre dossier actuel ; cet exemple le nomme UpdateInstanceTypeRfc .json :

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

4. Modifiez et enregistrez le fichier UpdateInstanceTypeRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le fichier de paramètres d'exécution et le UpdateInstanceTypeRfc fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé UpdateBucketVersioningParams .json.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle JSON dans un fichier de votre dossier actuel ; cet exemple le nomme UpdateBucketVersioningRfc .json :

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

4. Modifiez et enregistrez le fichier UpdateBucketVersioningRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le fichier de paramètres d'exécution et le UpdateRdsRfc fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé UpdateBucketEncryptionParams .json.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle JSON dans un fichier de votre dossier actuel ; cet exemple le nomme UpdateBucketEncryptionRfc .json :

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

4. Modifiez et enregistrez le fichier UpdateBucketEncryptionRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le fichier de paramètres d'exécution et le UpdateBucketEncryptionRfc fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme CreateAppAcctVpcParams .json :

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

2. Modifiez et enregistrez le UpdateAppAcctParams fichier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le fichier JSON du modèle RFC dans un fichier ; cet exemple le nomme UpdateAppAcctRfc .json :

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

4. Modifiez et enregistrez le fichier UpdateAppAcctRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le UpdateAppAcctRfc fichier et le UpdateAppAcctParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution de ce type de modification dans un fichier JSON ; cet exemple le nomme AssociatePrivate IPAddresses Params.json :

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

2. Modifiez et enregistrez le fichier de AssociatePrivate IPAddresses paramètres. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme AssociatePrivate IPAddresses RFC.json :

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

4. Modifiez et enregistrez le fichier AssociatePrivate IPAddresses RFC.json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez le RFC en spécifiant le fichier AssociatePrivate IPAddresses RFC et le fichier AssociatePrivate IPAddresses Params :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution pour ce type de modification dans un fichier JSON nommé CreateRdsOptionGroupParams .json.

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

2. Modifiez et enregistrez le fichier JSON des paramètres d'exécution. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle JSON dans un fichier de votre dossier actuel ; cet exemple le nomme CreateRdsOptionGroupRfc .json :

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

4. Modifiez et enregistrez le fichier CreateRdsOptionGroupRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le fichier de paramètres d'exécution et le CreateRdsOptionGroupRfc fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Afficher le schéma JSON des paramètres d'exécution pour ce type de modification dans un fichier ; cet exemple le nomme RemoveTgwStaticRouteParams .json :

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

2. Modifiez et enregistrez le RemoveTgwStaticRouteParams fichier. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le fichier JSON du modèle RFC dans un fichier ; cet exemple le nomme RemoveTgwStaticRouteRfc .json :

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

4. Modifiez et enregistrez le fichier RemoveTgwStaticRouteRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le RemoveTgwStaticRouteRfc fichier et le RemoveTgwStaticRouteParams fichier :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne), puis soumettez l'ID RFC renvoyé. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

CRÉATION D'UN MODÈLE :

1. Exportez les paramètres d'exécution de ce type de modification dans un fichier JSON ; cet exemple le nomme CreateEc 2 PreIngestParams .json :

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

2. Modifiez et enregistrez le PreIngestParams fichier CreateEc 2. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

3. Exportez le modèle RFC dans un fichier de votre dossier actuel ; cet exemple le nomme CreateEc 2 PreIngestRfc .json :

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

4. Modifiez et enregistrez le fichier CreateEc 2 PreIngestRfc .json. Par exemple, vous pouvez remplacer le contenu par quelque chose comme ceci :

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

5. Créez la RFC en spécifiant le PreIngestRfc fichier CreateEc 2 et le PreIngestParams fichier CreateEc 2 :

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

   Vous recevez l'identifiant de la nouvelle RFC dans la réponse et vous pouvez l'utiliser pour soumettre et surveiller la RFC. Tant que vous ne l'avez pas soumise, la RFC reste en cours d'édition et ne démarre pas.

Pour vérifier la version du type de modification, utilisez cette commande :

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