# Standard Stacks Subcategory
**Topics**
+ [Stack \$1 Delete](management-standard-stack-delete.md)
+ [Stack \$1 Reboot](management-standard-stack-reboot.md)
+ [Stack \$1 Remediate Drift](management-standard-stack-remediate-drift.md)
+ [Stack \$1 Remediate Drift (Managed Automation)](management-standard-stack-remediate-drift-managed-automation.md)
+ [Stack \$1 Remove Stack Resources](management-standard-stack-remove-stack-resources.md)
+ [Stack \$1 Start](management-standard-stack-start.md)
+ [Stack \$1 Stop](management-standard-stack-stop.md)
+ [Stack \$1 Update Termination Protection](management-standard-stack-update-termination-protection.md)
# Stack \$1 Delete
Delete an existing stack and its resources from your account. The effects of deleting a resource vary. For details, see the appropriate AWS documentation for the resource. Note that termination protection on a resource in the stack causes the RFC to fail. To check for a resource's termination protection status, see the corresponding AWS console.
**Full classification:** Management \$1 Standard stacks \$1 Stack \$1 Delete
## Change Type Details
****
| | |
| --- |--- |
| Change type ID | ct-0q0bic0ywqk6c |
| Current version | 1.0 |
| Expected execution duration | 60 minutes |
| AWS approval | Required |
| Customer approval | Not required |
| Execution mode | Automated |
## Additional Information
### Delete stack
#### Deleting a Stack with the Console
Screenshot of this change type in the AMS console:
![\[Delete stack change type details showing ID, version, and execution mode.\]](http://docs.aws.amazon.com/managedservices/latest/ctref/images/guiStackDeleteCT.png)
How it works:
1. Navigate to the **Create RFC** page: In the left navigation pane of the AMS console click **RFCs** to open the RFCs list page, and then click **Create RFC**.
1. Choose a popular change type (CT) in the default **Browse change types** view, or select a CT in the **Choose by category** view.
+ **Browse by change type**: You can click on a popular CT in the **Quick create** area to immediately open the **Run RFC** page. Note that you cannot choose an older CT version with quick create.
To sort CTs, use the **All change types** area in either the **Card** or **Table** view. In either view, select a CT and then click **Create RFC** to open the **Run RFC** page. If applicable, a **Create with older version** option appears next to the **Create RFC** button.
+ **Choose by category**: Select a category, subcategory, item, and operation and the CT details box opens with an option to **Create with older version** if applicable. Click **Create RFC** to open the **Run RFC** page.
1. On the **Run RFC** page, open the CT name area to see the CT details box. A **Subject** is required (this is filled in for you if you choose your CT in the **Browse change types** view). Open the **Additional configuration** area to add information about the RFC.
In the **Execution configuration** area, use available drop-down lists or enter values for the required parameters. To configure optional execution parameters, open the **Additional configuration** area.
1. When finished, click **Run**. If there are no errors, the **RFC successfully created** page displays with the submitted RFC details, and the initial **Run output**.
1. Open the **Run parameters** area to see the configurations you submitted. Refresh the page to update the RFC execution status. Optionally, cancel the RFC or create a copy of it with the options at the top of the page.
#### Deleting a Stack with the CLI
How it works:
1. Use either the Inline Create (you issue a `create-rfc` command with all RFC and execution parameters included), or Template Create (you create two JSON files, one for the RFC parameters and one for the execution parameters) and issue the `create-rfc` command with the two files as input. Both methods are described here.
1. Submit the RFC: `aws amscm submit-rfc --rfc-id ID` command with the returned RFC ID.
Monitor the RFC: `aws amscm get-rfc --rfc-id ID` command.
To check the change type version, use this command:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID
```
**Note**
You can use any `CreateRfc` parameters with any RFC whether or not they are part of the schema for the change type. For example, to get notifications when the RFC status changes, add this line, `--notification "{\"Email\": {\"EmailRecipients\" : [\"email@example.com\"]}}"` to the RFC parameters part of the request (not the execution parameters). For a list of all CreateRfc parameters, see the [AMS Change Management API Reference](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_CreateRfc.html).
*INLINE CREATE*:
Issue the create RFC command with execution parameters provided inline (escape quotation marks when providing execution parameters inline), and then submit the returned RFC ID. For example, you can replace the contents with something like this:
```
aws amscm create-rfc --change-type-id "ct-0q0bic0ywqk6c" --change-type-version "1.0" --title "Delete My Stack" --execution-parameters "{\"StackId\":\"STACK_ID\"}"
```
*TEMPLATE CREATE*:
1. Output the RFC template to a file in your current folder; this example names it DeleteStackRfc.json:
```
aws amscm create-rfc --generate-cli-skeleton > DeleteStackRfc.json
```
1. Modify and save the DeleteStackRfc.json file.
The internal quotation marks in the ExecutionParameters JSON extension must be escaped with a backslash (\$1). Example without start and end time:
```
{
"ChangeTypeVersion": "1.0",
"ChangeTypeId": "ct-0q0bic0ywqk6c",
"Title": "Delete-My-Stack-RFC"
"ExecutionParameters": "{
\"StackId\":\"STACK_ID\"}"
}
```
1. Create the RFC:
```
aws amscm create-rfc --cli-input-json file://DeleteStackRfc.json
```
You receive the ID of the new RFC in the response and can use it to submit and monitor the RFC. Until you submit it, the RFC remains in the editing state and does not start.
#### Tips
**Note**
If deleting an S3 bucket, it must be emptied of objects first.
**Important**
Deleting stacks can have unwanted and unanticipated consequences. For important caveats, see RFC Troubleshooting section [RFCs for Delete Stack](https://docs.aws.amazon.com/managedservices/latest/ctref/rfc-failures.html#rfc-delete-stack-fail).
## Execution Input Parameters
For detailed information about the execution input parameters, see [Schema for Change Type ct-0q0bic0ywqk6c](schemas.md#ct-0q0bic0ywqk6c-schema-section).
## Example: Required Parameters
```
Example not available.
```
## Example: All Parameters
```
{
"StackId": "stack-a1b2c3d4e5f67890e",
"TimeoutInMinutes": 720
}
```
# Stack \$1 Reboot
Use to reboot all running EC2 and RDS DB instances in the specified stack.
**Full classification:** Management \$1 Standard stacks \$1 Stack \$1 Reboot
## Change Type Details
****
| | |
| --- |--- |
| Change type ID | ct-02u0hoaa9grat |
| Current version | 1.0 |
| Expected execution duration | 60 minutes |
| AWS approval | Required |
| Customer approval | Not required |
| Execution mode | Automated |
## Additional Information
### Reboot stack
#### Rebooting a Stack with the Console
Screenshot of this change type in the AMS console:
![\[Change type details for "Reboot stack" including description, ID, version, and execution mode.\]](http://docs.aws.amazon.com/managedservices/latest/ctref/images/guiStackRebootCT.png)
How it works:
1. Navigate to the **Create RFC** page: In the left navigation pane of the AMS console click **RFCs** to open the RFCs list page, and then click **Create RFC**.
1. Choose a popular change type (CT) in the default **Browse change types** view, or select a CT in the **Choose by category** view.
+ **Browse by change type**: You can click on a popular CT in the **Quick create** area to immediately open the **Run RFC** page. Note that you cannot choose an older CT version with quick create.
To sort CTs, use the **All change types** area in either the **Card** or **Table** view. In either view, select a CT and then click **Create RFC** to open the **Run RFC** page. If applicable, a **Create with older version** option appears next to the **Create RFC** button.
+ **Choose by category**: Select a category, subcategory, item, and operation and the CT details box opens with an option to **Create with older version** if applicable. Click **Create RFC** to open the **Run RFC** page.
1. On the **Run RFC** page, open the CT name area to see the CT details box. A **Subject** is required (this is filled in for you if you choose your CT in the **Browse change types** view). Open the **Additional configuration** area to add information about the RFC.
In the **Execution configuration** area, use available drop-down lists or enter values for the required parameters. To configure optional execution parameters, open the **Additional configuration** area.
1. When finished, click **Run**. If there are no errors, the **RFC successfully created** page displays with the submitted RFC details, and the initial **Run output**.
1. Open the **Run parameters** area to see the configurations you submitted. Refresh the page to update the RFC execution status. Optionally, cancel the RFC or create a copy of it with the options at the top of the page.
#### Rebooting a Stack with the CLI
How it works:
1. Use either the Inline Create (you issue a `create-rfc` command with all RFC and execution parameters included), or Template Create (you create two JSON files, one for the RFC parameters and one for the execution parameters) and issue the `create-rfc` command with the two files as input. Both methods are described here.
1. Submit the RFC: `aws amscm submit-rfc --rfc-id ID` command with the returned RFC ID.
Monitor the RFC: `aws amscm get-rfc --rfc-id ID` command.
To check the change type version, use this command:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID
```
**Note**
You can use any `CreateRfc` parameters with any RFC whether or not they are part of the schema for the change type. For example, to get notifications when the RFC status changes, add this line, `--notification "{\"Email\": {\"EmailRecipients\" : [\"email@example.com\"]}}"` to the RFC parameters part of the request (not the execution parameters). For a list of all CreateRfc parameters, see the [AMS Change Management API Reference](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_CreateRfc.html).
*INLINE CREATE*:
Issue the create RFC command with execution parameters provided inline (escape quotation marks when providing execution parameters inline), and then submit the returned RFC ID. For example, you can replace the contents with something like this:
```
aws amscm create-rfc --change-type-id "ct-02u0hoaa9grat" --change-type-version "1.0" --title "Reboot My Stack" --execution-parameters "{\"StackId\":\"STACK_ID\"}"
```
*TEMPLATE CREATE*:
1. Output the RFC template to a file in your current folder. This example names it RebootStackRfc.json. Note that since there is only one execution parameter for stopping (rebooting, or starting) an instance, the execution parameter can be in the schema JSON file itself and there is no need to create a separate execution parameters JSON file.
```
aws amscm create-rfc --generate-cli-skeleton > StopInstanceRfc.json
```
1. Modify and save the RebootStackRfc.json file.
The internal quotation marks in the `ExecutionParameters` JSON extension must be escaped with a backslash (\$1). Example:
```
{
"ChangeTypeId": "ct-02u0hoaa9grat",
"Title": "Reboot-My-EC2-RFC",
"TimeoutInMinutes": 60,
"ExecutionParameters": "{
\"StackId\":\"STACK_ID\"
}"
}
```
1. Create the RFC:
```
aws amscm create-rfc --cli-input-json file://RebootStackRfc.json
```
You receive the ID of the new RFC in the response and can use it to submit and monitor the RFC. Until you submit it, the RFC remains in the editing state and does not start.
#### Tips
For information about Application Load Balancers, see [Application Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html).
## Execution Input Parameters
For detailed information about the execution input parameters, see [Schema for Change Type ct-02u0hoaa9grat](schemas.md#ct-02u0hoaa9grat-schema-section).
## Example: Required Parameters
```
Example not available.
```
## Example: All Parameters
```
{
"StackId": "stack-f16bbbeea61df041f"
}
```
# Stack \$1 Remediate Drift
Remediate the drift (out-of-band changes) in a stack, bringing the stack in sync and enabling you to perform future updates using the available Update CTs. Note: up to 10 drifted resources will be remediated per RFC.
**Full classification:** Management \$1 Standard stacks \$1 Stack \$1 Remediate drift
## Change Type Details
****
| | |
| --- |--- |
| Change type ID | ct-3kinq0u4l33zf |
| Current version | 1.0 |
| Expected execution duration | 60 minutes |
| AWS approval | Required |
| Customer approval | Not required |
| Execution mode | Automated |
## Additional Information
### Remediate stack drift
#### Drift remediation supported resources (ct-3kinq0u4l33zf)
These are the resources that are supported by the drift remediation change type, (ct-3kinq0u4l33zf). For remediation of any resource, use the "managed automation" (ct-34sxfo53yuzah) change type instead.
```
AWS::EC2::Instance
AWS::EC2::SecurityGroup
AWS::EC2::VPC
AWS::EC2::Subnet
AWS::EC2::NetworkInterface
AWS::EC2::EIP
AWS::EC2::InternetGateway
AWS::EC2::NatGateway
AWS::EC2::NetworkAcl
AWS::EC2::RouteTable
AWS::EC2::Volume
AWS::AutoScaling::AutoScalingGroup
AWS::AutoScaling::LaunchConfiguration
AWS::AutoScaling::LifecycleHook
AWS::AutoScaling::ScalingPolicy
AWS::AutoScaling::ScheduledAction
AWS::ElasticLoadBalancing::LoadBalancer
AWS::ElasticLoadBalancingV2::Listener
AWS::ElasticLoadBalancingV2::ListenerRule
AWS::ElasticLoadBalancingV2::LoadBalancer
AWS::CloudWatch::Alarm
```
#### Remediating Stack Drift with the Console
Screenshot of this change type in the AMS console:
![\[Description of Remediate Stack Drift change type with ID and version details.\]](http://docs.aws.amazon.com/managedservices/latest/ctref/images/guiStackRemediateDriftCT.png)
How it works:
1. Navigate to the **Create RFC** page: In the left navigation pane of the AMS console click **RFCs** to open the RFCs list page, and then click **Create RFC**.
1. Choose a popular change type (CT) in the default **Browse change types** view, or select a CT in the **Choose by category** view.
+ **Browse by change type**: You can click on a popular CT in the **Quick create** area to immediately open the **Run RFC** page. Note that you cannot choose an older CT version with quick create.
To sort CTs, use the **All change types** area in either the **Card** or **Table** view. In either view, select a CT and then click **Create RFC** to open the **Run RFC** page. If applicable, a **Create with older version** option appears next to the **Create RFC** button.
+ **Choose by category**: Select a category, subcategory, item, and operation and the CT details box opens with an option to **Create with older version** if applicable. Click **Create RFC** to open the **Run RFC** page.
1. On the **Run RFC** page, open the CT name area to see the CT details box. A **Subject** is required (this is filled in for you if you choose your CT in the **Browse change types** view). Open the **Additional configuration** area to add information about the RFC.
In the **Execution configuration** area, use available drop-down lists or enter values for the required parameters. To configure optional execution parameters, open the **Additional configuration** area.
1. When finished, click **Run**. If there are no errors, the **RFC successfully created** page displays with the submitted RFC details, and the initial **Run output**.
1. Open the **Run parameters** area to see the configurations you submitted. Refresh the page to update the RFC execution status. Optionally, cancel the RFC or create a copy of it with the options at the top of the page.
#### Remediating Stack Drift with the CLI
How it works:
1. Use either the Inline Create (you issue a `create-rfc` command with all RFC and execution parameters included), or Template Create (you create two JSON files, one for the RFC parameters and one for the execution parameters) and issue the `create-rfc` command with the two files as input. Both methods are described here.
1. Submit the RFC: `aws amscm submit-rfc --rfc-id ID` command with the returned RFC ID.
Monitor the RFC: `aws amscm get-rfc --rfc-id ID` command.
To check the change type version, use this command:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID
```
**Note**
You can use any `CreateRfc` parameters with any RFC whether or not they are part of the schema for the change type. For example, to get notifications when the RFC status changes, add this line, `--notification "{\"Email\": {\"EmailRecipients\" : [\"email@example.com\"]}}"` to the RFC parameters part of the request (not the execution parameters). For a list of all CreateRfc parameters, see the [AMS Change Management API Reference](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_CreateRfc.html).
*INLINE CREATE*:
Issue the create RFC command with execution parameters provided inline (escape quotation marks when providing execution parameters inline), and then submit the returned RFC ID. For example, you can replace the contents with something like this:
```
aws amscm create-rfc --change-type-id "ct-3kinq0u4l33zf" --change-type-version "1.0" --title "Remediate Stack Drift, no ops review" --execution-parameters "{\"DocumentName\": \"AWSManagedServices-StartDriftRemediation\", \"Region\": \"us-east-1\", \"Parameters\": {\"StackName\": [\"stack-xxxxxxxxxxxxxxxxx\"]}}"
```
*TEMPLATE CREATE*:
1. Output the execution parameters JSON schema for this change type to a file; this example names it RemediateDriftNrrParams.json:
```
aws amscm create-rfc --generate-cli-skeleton > RemediateDriftNrrParams.json
```
1. Modify and save the RemediateDriftNrrParams file. For example, you can replace the contents with something like this:
```
{
"DocumentName": "AWSManagedServices-StartDriftRemediation",
"Region": "us-east-1",
"Parameters": {
"StackName": [
"stack-xxxxxxxxxxxxxxxxx"
]
}
}
```
1. Output the RFC template JSON file to a file; this example names it RemediateDriftNrrRfc.json:
```
aws amscm create-rfc --generate-cli-skeleton > RemediateDriftNrrRfc.json
```
1. Modify and save the RemediateDriftNrrRfc.json file. For example, you can replace the contents with something like this:
```
{
"ChangeTypeId": "ct-3kinq0u4l33zf",
"ChangeTypeVersion": "1.0",
"Title": "Remediate stack drift, no ops review"
}
```
1. Create the RFC, specifying the RemediateDriftNrrRfc file and the RemediateDriftNrrParams file:
```
aws amscm create-rfc --cli-input-json file://RemediateDriftNrrRfc.json --execution-parameters file://RemediateDriftNrrParams.json
```
You receive the ID of the new RFC in the response and can use it to submit and monitor the RFC. Until you submit it, the RFC remains in the editing state and does not start.
#### Tips
**Important**
Stack remediation modifies the stack template and/or parameter values. Once remediation is complete, you must update your local template repositories, or any automation, that would be updating the remediated stack, with the latest template and parameters provided in the RFC summary of the remeditation. It is very important to do this, because using the old template and/or parameters can cause destructive changes on the stack resources.
For more details, including a list of *Limitations*, see [Drift remediation FAQs](https://docs.aws.amazon.com/managedservices/latest/userguide/ex-rfc-updates-and-dd.html#drift-remeditate-faqs).
**Note**
When using manual CTs, AMS recommends that you use the ASAP **Scheduling** option (choose **ASAP** in the console, leave start and end time blank in the API/CLI) as these CTs require an AMS operator to examine the RFC, and possibly communicate with you before it can be approved and run. If you schedule these RFCs, be sure to allow at least 24 hours. If approval does not happen before the scheduled start time, the RFC is rejected automatically.
## Execution Input Parameters
For detailed information about the execution input parameters, see [Schema for Change Type ct-3kinq0u4l33zf](schemas.md#ct-3kinq0u4l33zf-schema-section).
## Example: Required Parameters
```
Example not available.
```
## Example: All Parameters
```
{
"DocumentName": "AWSManagedServices-StartDriftRemediation",
"Region": "us-east-1",
"Parameters": {
"StackName": ["stack-a1b2c3d4e5f678900"],
"DryRun": ["true"]
}
}
```
# Stack \$1 Remediate Drift (Managed Automation)
Remediate the drift (out-of-band changes) in a stack, bringing the stack in sync and enabling you to perform future updates using the available Update CTs. Drift remediation can be performed on EC2 resource types.
**Full classification:** Management \$1 Standard stacks \$1 Stack \$1 Remediate drift (managed automation)
## Change Type Details
****
| | |
| --- |--- |
| Change type ID | ct-34sxfo53yuzah |
| Current version | 1.0 |
| Expected execution duration | 240 minutes |
| AWS approval | Required |
| Customer approval | Not required if submitter |
| Execution mode | Manual |
## Additional Information
### Remediate stack drift (Managed Automation)
#### Remediating Stack Drift (Managed Automation) with the Console
Screenshot of this change type in the AMS console:
![\[alt text not found\]](http://docs.aws.amazon.com/managedservices/latest/ctref/images/guiStackRemediateDriftRrCT.png)
How it works:
1. Navigate to the **Create RFC** page: In the left navigation pane of the AMS console click **RFCs** to open the RFCs list page, and then click **Create RFC**.
1. Choose a popular change type (CT) in the default **Browse change types** view, or select a CT in the **Choose by category** view.
+ **Browse by change type**: You can click on a popular CT in the **Quick create** area to immediately open the **Run RFC** page. Note that you cannot choose an older CT version with quick create.
To sort CTs, use the **All change types** area in either the **Card** or **Table** view. In either view, select a CT and then click **Create RFC** to open the **Run RFC** page. If applicable, a **Create with older version** option appears next to the **Create RFC** button.
+ **Choose by category**: Select a category, subcategory, item, and operation and the CT details box opens with an option to **Create with older version** if applicable. Click **Create RFC** to open the **Run RFC** page.
1. On the **Run RFC** page, open the CT name area to see the CT details box. A **Subject** is required (this is filled in for you if you choose your CT in the **Browse change types** view). Open the **Additional configuration** area to add information about the RFC.
In the **Execution configuration** area, use available drop-down lists or enter values for the required parameters. To configure optional execution parameters, open the **Additional configuration** area.
1. When finished, click **Run**. If there are no errors, the **RFC successfully created** page displays with the submitted RFC details, and the initial **Run output**.
1. Open the **Run parameters** area to see the configurations you submitted. Refresh the page to update the RFC execution status. Optionally, cancel the RFC or create a copy of it with the options at the top of the page.
#### Remediating Stack Drift (Managed Automation) with the CLI
How it works:
1. Use either the Inline Create (you issue a `create-rfc` command with all RFC and execution parameters included), or Template Create (you create two JSON files, one for the RFC parameters and one for the execution parameters) and issue the `create-rfc` command with the two files as input. Both methods are described here.
1. Submit the RFC: `aws amscm submit-rfc --rfc-id ID` command with the returned RFC ID.
Monitor the RFC: `aws amscm get-rfc --rfc-id ID` command.
To check the change type version, use this command:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID
```
**Note**
You can use any `CreateRfc` parameters with any RFC whether or not they are part of the schema for the change type. For example, to get notifications when the RFC status changes, add this line, `--notification "{\"Email\": {\"EmailRecipients\" : [\"email@example.com\"]}}"` to the RFC parameters part of the request (not the execution parameters). For a list of all CreateRfc parameters, see the [AMS Change Management API Reference](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_CreateRfc.html).
*INLINE CREATE*:
Issue the create RFC command with execution parameters provided inline (escape quotation marks when providing execution parameters inline), and then submit the returned RFC ID. For example, you can replace the contents with something like this:
```
aws amscm create-rfc --change-type-id "ct-34sxfo53yuzah" --change-type-version "1.0" --title "Remediate stack drift" --execution-parameters '{"StackName":"stack-a1b2c3d4e5f67890e","DryRun":false}'
```
*TEMPLATE CREATE*:
1. Output the execution parameters JSON schema for this change type to a file; this example names it RemediateDriftParams.json:
```
aws amscm create-rfc --generate-cli-skeleton > RemediateDriftParams.json
```
1. Modify and save the RemediateDriftParams file. For example, you can replace the contents with something like this:
```
{
"StackName" : "stack-a1b2c3d4e5f67890e",
"DryRun" : false
}
```
1. Output the RFC template JSON file to a file; this example names it RemediateDriftRfc.json:
```
aws amscm create-rfc --generate-cli-skeleton > RemediateDriftRfc.json
```
1. Modify and save the RemediateDriftRfc.json file. For example, you can replace the contents with something like this:
```
{
"ChangeTypeId": "ct-34sxfo53yuzah",
"ChangeTypeVersion": "1.0",
"Title": "Remediate stack drift"
}
```
1. Create the RFC, specifying the RemediateDriftRfc file and the RemediateDriftParams file:
```
aws amscm create-rfc --cli-input-json file://RemediateDriftRfc.json --execution-parameters file://RemediateDriftParams.json
```
You receive the ID of the new RFC in the response and can use it to submit and monitor the RFC. Until you submit it, the RFC remains in the editing state and does not start.
#### Tips
This is a manual change type (an AMS operator must review and run the CT), which means that the RFC can take longer to run and you might have to communicate with AMS through the RFC details page correspondance option. Additionally, if you schedule a manual change type RFC, be sure to allow at least 24 hours, if approval does not happen before the scheduled start time, the RFC is rejected automatically.
**Note**
When using manual CTs, AMS recommends that you use the ASAP **Scheduling** option (choose **ASAP** in the console, leave start and end time blank in the API/CLI) as these CTs require an AMS operator to examine the RFC, and possibly communicate with you before it can be approved and run. If you schedule these RFCs, be sure to allow at least 24 hours. If approval does not happen before the scheduled start time, the RFC is rejected automatically.
+ There is an automated version of this change type that runs more quickly, though there are some limitations. For more details, see [Stack \$1 Remediate Drift](https://docs.aws.amazon.com/managedservices/latest/ctref/management-standard-stack-remediate-drift-rr-auto.html).
+ Stack remediation modifies the stack template and/or parameter values. Once remediation is complete, you must update your local template repositories, or any automation, that would be updating the remediated stack, with the latest template and parameters provided in the RFC summary of the remeditation. It is very important to do this, because using the old template and/or parameters can cause destructive changes on the stack resources.
For more details, see [Drift remediation FAQs](https://docs.aws.amazon.com/managedservices/latest/userguide/drift-rr-remediate-faqs.html).
## Execution Input Parameters
For detailed information about the execution input parameters, see [Schema for Change Type ct-34sxfo53yuzah](schemas.md#ct-34sxfo53yuzah-schema-section).
## Example: Required Parameters
```
{
"StackName": "stack-a1b2c3d4e5f678900"
}
```
## Example: All Parameters
```
{
"StackName": "stack-a1b2c3d4e5f678900",
"DryRun": false,
"Priority": "Medium"
}
```
# Stack \$1 Remove Stack Resources
Remove resources from a CloudFormation stack using a change set. If you set AllowResourceDeletion to 'true', CloudFormation deletes the physical resources (unless they have a retention policy). If you set AllowResourceDeletion to 'false', the CT adds a DeletionPolicy of 'Retain' to preserve the physical resources. Supports JSON CloudFormation templates up to 51,200 bytes.
**Full classification:** Management \$1 Standard stacks \$1 Stack \$1 Remove stack resources
## Change Type Details
****
| | |
| --- |--- |
| Change type ID | ct-03mv2mypai537 |
| Current version | 1.0 |
| Expected execution duration | 60 minutes |
| AWS approval | Required |
| Customer approval | Not required |
| Execution mode | Automated |
## Additional Information
### Remove Stack Resources
#### Removing Stack Resources with the Console
Screenshot of this change type in the AMS console:
![\[alt text not found\]](http://docs.aws.amazon.com/managedservices/latest/ctref/images/guiRemoveStackResourcesCT.png)
How it works:
1. Navigate to the **Create RFC** page: In the left navigation pane of the AMS console click **RFCs** to open the RFCs list page, and then click **Create RFC**.
1. Choose a popular change type (CT) in the default **Browse change types** view, or select a CT in the **Choose by category** view.
+ **Browse by change type**: You can click on a popular CT in the **Quick create** area to immediately open the **Run RFC** page. Note that you cannot choose an older CT version with quick create.
To sort CTs, use the **All change types** area in either the **Card** or **Table** view. In either view, select a CT and then click **Create RFC** to open the **Run RFC** page. If applicable, a **Create with older version** option appears next to the **Create RFC** button.
+ **Choose by category**: Select a category, subcategory, item, and operation and the CT details box opens with an option to **Create with older version** if applicable. Click **Create RFC** to open the **Run RFC** page.
1. On the **Run RFC** page, open the CT name area to see the CT details box. A **Subject** is required (this is filled in for you if you choose your CT in the **Browse change types** view). Open the **Additional configuration** area to add information about the RFC.
In the **Execution configuration** area, use available drop-down lists or enter values for the required parameters. To configure optional execution parameters, open the **Additional configuration** area.
1. When finished, click **Run**. If there are no errors, the **RFC successfully created** page displays with the submitted RFC details, and the initial **Run output**.
1. Open the **Run parameters** area to see the configurations you submitted. Refresh the page to update the RFC execution status. Optionally, cancel the RFC or create a copy of it with the options at the top of the page.
#### Removing Stack Resources with the CLI
How it works:
1. Use either the Inline Create (you issue a `create-rfc` command with all RFC and execution parameters included), or Template Create (you create two JSON files, one for the RFC parameters and one for the execution parameters) and issue the `create-rfc` command with the two files as input. Both methods are described here.
1. Submit the RFC: `aws amscm submit-rfc --rfc-id ID` command with the returned RFC ID.
Monitor the RFC: `aws amscm get-rfc --rfc-id ID` command.
To check the change type version, use this command:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID
```
**Note**
You can use any `CreateRfc` parameters with any RFC whether or not they are part of the schema for the change type. For example, to get notifications when the RFC status changes, add this line, `--notification "{\"Email\": {\"EmailRecipients\" : [\"email@example.com\"]}}"` to the RFC parameters part of the request (not the execution parameters). For a list of all CreateRfc parameters, see the [AMS Change Management API Reference](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_CreateRfc.html).
*INLINE CREATE*:
Issue the create RFC command with execution parameters provided inline (escape quotation marks when providing execution parameters inline) and then submit the returned RFC ID. For example, you can replace the contents with something like this:
```
aws amscm create-rfc --change-type-id "ct-03mv2mypai537" --change-type-version "1.0" --title "Remove Stack Resources" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-HandleRemoveStackResources-Admin\",\"Parameters\":{\"StackName\":[\"STACK_NAME\"],\"LogicalResourceIds\":[\"LOGICAL_RESOURCE_ID\"],\"AllowResourceDeletion\":[\"false\"]},\"Region\":\"REGION\"}"
```
```
aws amscm create-rfc --change-type-id "ct-03mv2mypai537" --change-type-version "1.0" --title "Remove Stack Resources" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-HandleRemoveStackResources-Admin\",\"Parameters\":{\"StackName\":[\"STACK_NAME\"],\"LogicalResourceIds\":[\"LOGICAL_RESOURCE_ID_1\",\"LOGICAL_RESOURCE_ID_2\"],\"AllowResourceDeletion\":[\"true\"]},\"Region\":\"REGION\"}"
```
*TEMPLATE CREATE*:
1. Output the execution parameters JSON schema for this change type; this example names it validateRemoveStackResources.json:
```
aws amscm get-change-type-version --change-type-id "ct-03mv2mypai537" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > validateRemoveStackResources.json
```
1. Modify and save the execution parameters JSON file. For example, you can replace the contents with something like this:
```
{
"DocumentName": "AWSManagedServices-HandleRemoveStackResources-Admin",
"Region": "REGION",
"Parameters": {
"StackName": ["STACK_NAME"],
"LogicalResourceIds": ["LOGICAL_RESOURCE_ID"],
"AllowResourceDeletion": ["false"]
}
}
```
```
{
"DocumentName": "AWSManagedServices-HandleRemoveStackResources-Admin",
"Parameters": {
"StackName": [
"STACK_NAME"
],
"LogicalResourceIds": [
"LOGICAL_RESOURCE_ID_1",
"LOGICAL_RESOURCE_ID_2"
],
"AllowResourceDeletion": [
"true"
]
},
"Region": "REGION"
}
```
1. Output the RFC template JSON file; this example names it RemoveStackResourcesRfc.json:
```
aws amscm create-rfc --generate-cli-skeleton > RemoveStackResourcesRfc.json
```
1. Modify and save the RemoveStackResourcesRfc.json file. For example, you can replace the contents with something like this:
```
{
"ChangeTypeVersion": "1.0",
"ChangeTypeId": "ct-03mv2mypai537",
"Title": "Remove Stack Resources"
}
```
1. Create the RFC, specifying the RemoveStackResourcesRfc file and the validateRemoveStackResources file:
```
aws amscm create-rfc --cli-input-json file://RemoveStackResourcesRfc.json --execution-parameters file://validateRemoveStackResources.json
```
You receive the ID of the new RFC in the response and can use it to submit and monitor the RFC. Until you submit it, the RFC remains in the editing state and does not start.
#### Tips
## Execution Input Parameters
For detailed information about the execution input parameters, see [Schema for Change Type ct-03mv2mypai537](schemas.md#ct-03mv2mypai537-schema-section).
## Example: Required Parameters
```
{
"DocumentName": "AWSManagedServices-HandleRemoveStackResources-Admin",
"Region": "us-east-1",
"Parameters": {
"StackName": ["stack-0123456789abc"],
"LogicalResourceIds": ["PrimaryInstance"]
}
}
```
## Example: All Parameters
```
{
"DocumentName": "AWSManagedServices-HandleRemoveStackResources-Admin",
"Region": "us-east-1",
"Parameters": {
"StackName": ["stack-abc0123456789"],
"LogicalResourceIds": ["SecondaryInstance"],
"AllowResourceDeletion": true
}
}
```
# Stack \$1 Start
Use to start all stopped EC2 instances in the specified stack.
**Full classification:** Management \$1 Standard stacks \$1 Stack \$1 Start
## Change Type Details
****
| | |
| --- |--- |
| Change type ID | ct-1h5xgl9cr4bzy |
| Current version | 1.0 |
| Expected execution duration | 60 minutes |
| AWS approval | Required |
| Customer approval | Not required |
| Execution mode | Automated |
## Additional Information
### Start stack
#### Starting a Stack with the Console
Screenshot of this change type in the AMS console:
![\[Change type details for "Start stack" with description, ID, version, and execution mode.\]](http://docs.aws.amazon.com/managedservices/latest/ctref/images/guiStackStartCT.png)
How it works:
1. Navigate to the **Create RFC** page: In the left navigation pane of the AMS console click **RFCs** to open the RFCs list page, and then click **Create RFC**.
1. Choose a popular change type (CT) in the default **Browse change types** view, or select a CT in the **Choose by category** view.
+ **Browse by change type**: You can click on a popular CT in the **Quick create** area to immediately open the **Run RFC** page. Note that you cannot choose an older CT version with quick create.
To sort CTs, use the **All change types** area in either the **Card** or **Table** view. In either view, select a CT and then click **Create RFC** to open the **Run RFC** page. If applicable, a **Create with older version** option appears next to the **Create RFC** button.
+ **Choose by category**: Select a category, subcategory, item, and operation and the CT details box opens with an option to **Create with older version** if applicable. Click **Create RFC** to open the **Run RFC** page.
1. On the **Run RFC** page, open the CT name area to see the CT details box. A **Subject** is required (this is filled in for you if you choose your CT in the **Browse change types** view). Open the **Additional configuration** area to add information about the RFC.
In the **Execution configuration** area, use available drop-down lists or enter values for the required parameters. To configure optional execution parameters, open the **Additional configuration** area.
1. When finished, click **Run**. If there are no errors, the **RFC successfully created** page displays with the submitted RFC details, and the initial **Run output**.
1. Open the **Run parameters** area to see the configurations you submitted. Refresh the page to update the RFC execution status. Optionally, cancel the RFC or create a copy of it with the options at the top of the page.
#### Starting a Stack with the CLI
How it works:
1. Use either the Inline Create (you issue a `create-rfc` command with all RFC and execution parameters included), or Template Create (you create two JSON files, one for the RFC parameters and one for the execution parameters) and issue the `create-rfc` command with the two files as input. Both methods are described here.
1. Submit the RFC: `aws amscm submit-rfc --rfc-id ID` command with the returned RFC ID.
Monitor the RFC: `aws amscm get-rfc --rfc-id ID` command.
To check the change type version, use this command:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID
```
**Note**
You can use any `CreateRfc` parameters with any RFC whether or not they are part of the schema for the change type. For example, to get notifications when the RFC status changes, add this line, `--notification "{\"Email\": {\"EmailRecipients\" : [\"email@example.com\"]}}"` to the RFC parameters part of the request (not the execution parameters). For a list of all CreateRfc parameters, see the [AMS Change Management API Reference](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_CreateRfc.html).
*INLINE CREATE*:
Issue the create RFC command with execution parameters provided inline (escape quotation marks when providing execution parameters inline), and then submit the returned RFC ID. For example, you can replace the contents with something like this:
```
aws amscm create-rfc --change-type-id "ct-1h5xgl9cr4bzy" --change-type-version "1.0" --title "Start My Stack" --execution-parameters "{\"StackId\":\"STACK_ID\"}"
```
*TEMPLATE CREATE*:
1. Output the RFC template to a file in your current folder. This example names it StartInstanceRfc.json. Note that since there is only one execution parameter for starting a stack, the execution parameter can be in the schema JSON file itself and there is no need to create a separate execution parameters JSON file.
```
aws amscm create-rfc --generate-cli-skeleton > StartStackRfc.json
```
1. Modify and save the StartStackRfc.json file. For example, you can replace the contents with something like this:
```
{
"ChangeTypeId": "ct-1h5xgl9cr4bzy",
"Title": "Start-My-EC2-RFC",
"TimeoutInMinutes": 60,
"ExecutionParameters": "{
\"StackId\":\"STACK_ID\"
}"
}
```
1. Create the RFC:
```
aws amscm create-rfc --cli-input-json file://StartStackRfc.json
```
You receive the ID of the new RFC in the response and can use it to submit and monitor the RFC. Until you submit it, the RFC remains in the editing state and does not start.
#### Tips
For information about Application Load Balancers, see [Application Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html).
## Execution Input Parameters
For detailed information about the execution input parameters, see [Schema for Change Type ct-1h5xgl9cr4bzy](schemas.md#ct-1h5xgl9cr4bzy-schema-section).
## Example: Required Parameters
```
Example not available.
```
## Example: All Parameters
```
{
"StackId": "stack-f16bbbeea61df041f"
}
```
# Stack \$1 Stop
Use to stop all running EC2 instances in the specified stack.
**Full classification:** Management \$1 Standard stacks \$1 Stack \$1 Stop
## Change Type Details
****
| | |
| --- |--- |
| Change type ID | ct-3dgbnh6gpst4d |
| Current version | 1.0 |
| Expected execution duration | 60 minutes |
| AWS approval | Required |
| Customer approval | Not required |
| Execution mode | Automated |
## Additional Information
### Stop stack
#### Stopping an EC2 instance with the console
The following shows this change type in the AMS console.
![\[Description of EC2 instance stopping functionality, with ID and version details.\]](http://docs.aws.amazon.com/managedservices/latest/ctref/images/guiEc2StopCT.png)
How it works:
1. Navigate to the **Create RFC** page: In the left navigation pane of the AMS console click **RFCs** to open the RFCs list page, and then click **Create RFC**.
1. Choose a popular change type (CT) in the default **Browse change types** view, or select a CT in the **Choose by category** view.
+ **Browse by change type**: You can click on a popular CT in the **Quick create** area to immediately open the **Run RFC** page. Note that you cannot choose an older CT version with quick create.
To sort CTs, use the **All change types** area in either the **Card** or **Table** view. In either view, select a CT and then click **Create RFC** to open the **Run RFC** page. If applicable, a **Create with older version** option appears next to the **Create RFC** button.
+ **Choose by category**: Select a category, subcategory, item, and operation and the CT details box opens with an option to **Create with older version** if applicable. Click **Create RFC** to open the **Run RFC** page.
1. On the **Run RFC** page, open the CT name area to see the CT details box. A **Subject** is required (this is filled in for you if you choose your CT in the **Browse change types** view). Open the **Additional configuration** area to add information about the RFC.
In the **Execution configuration** area, use available drop-down lists or enter values for the required parameters. To configure optional execution parameters, open the **Additional configuration** area.
1. When finished, click **Run**. If there are no errors, the **RFC successfully created** page displays with the submitted RFC details, and the initial **Run output**.
1. Open the **Run parameters** area to see the configurations you submitted. Refresh the page to update the RFC execution status. Optionally, cancel the RFC or create a copy of it with the options at the top of the page.
#### Stopping an EC2 instance with the CLI
How it works:
1. Use either the Inline Create (you issue a `create-rfc` command with all RFC and execution parameters included), or Template Create (you create two JSON files, one for the RFC parameters and one for the execution parameters) and issue the `create-rfc` command with the two files as input. Both methods are described here.
1. Submit the RFC: `aws amscm submit-rfc --rfc-id ID` command with the returned RFC ID.
Monitor the RFC: `aws amscm get-rfc --rfc-id ID` command.
To check the change type version, use this command:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID
```
**Note**
You can use any `CreateRfc` parameters with any RFC whether or not they are part of the schema for the change type. For example, to get notifications when the RFC status changes, add this line, `--notification "{\"Email\": {\"EmailRecipients\" : [\"email@example.com\"]}}"` to the RFC parameters part of the request (not the execution parameters). For a list of all CreateRfc parameters, see the [AMS Change Management API Reference](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_CreateRfc.html).
*INLINE CREATE*:
Issue the create RFC command with execution parameters provided inline (escape quotation marks when providing execution parameters inline), and then submit the returned RFC ID. For example, you can replace the contents with something like this:
```
aws amscm create-rfc --change-type-id "ct-3mvvt2zkyveqj" --change-type-version "3.0" --title "Stop EC2 Instances" --execution-parameters "{\"DocumentName\":\"AWSManagedServices-StopInstances\",\"Region\":\"us-east-1\",\"Parameters\":{\"InstanceIds\":[\"i-1234567890abcdef0\", \"i-1234567890abcdef1\"],\"ForceStop\":[\"false\"],\"StopASGInServiceInstances\":[\"false\"]}}"
```
*TEMPLATE CREATE*:
1. Output the execution parameters JSON schema for this change type to a JSON file; this example names it StopEC2Params.json:
```
aws amscm get-change-type-version --change-type-id "ct-3mvvt2zkyveqj" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > StopEC2Params.json
```
1. Modify and save the StopEC2Params file.
```
{
"DocumentName" : "AWSManagedServices-StopInstances",
"Region" : "us-east-1",
"Parameters" : {
"InstanceIds" : [
"i-1234567890abcdef0",
"i-1234567890abcdef1"
],
"ForceStop": [
"false"
],
"StopASGInServiceInstances": [
"false"
]
}
}
```
1. Output the RFC template to a file in your current folder; this example names it StopEC2Rfc.json:
```
aws amscm create-rfc --generate-cli-skeleton > StopEC2Rfc.json
```
1. Modify and save the StopEC2Rfc.json file. For example, you can replace the contents with something like this:
```
{
"ChangeTypeVersion": "3.0",
"ChangeTypeId": "ct-3mvvt2zkyveqj",
"Title": "Stop EC2 Instances"
}
```
1. Create the RFC, specifying the StopEC2Rfc file and the StopEC2Params file:
```
aws amscm create-rfc --cli-input-json file://StopEC2Rfc.json --execution-parameters file://StopEC2Params.json
```
You receive the ID of the new RFC in the response and can use it to submit and monitor the RFC. Until you submit it, the RFC remains in the editing state and does not start.
#### Tips
**Note**
This change type is now at version 3.0. The schema has been changed so you can stop up to fifty instances.
## Execution Input Parameters
For detailed information about the execution input parameters, see [Schema for Change Type ct-3dgbnh6gpst4d](schemas.md#ct-3dgbnh6gpst4d-schema-section).
## Example: Required Parameters
```
Example not available.
```
## Example: All Parameters
```
{
"StackId": "stack-f16bbbeea61df041f"
}
```
# Stack \$1 Update Termination Protection
Update existing defined termination protection for stacks.
**Full classification:** Management \$1 Standard stacks \$1 Stack \$1 Update termination protection
## Change Type Details
****
| | |
| --- |--- |
| Change type ID | ct-2uzbqr7x7mekd |
| Current version | 1.0 |
| Expected execution duration | 10 minutes |
| AWS approval | Required |
| Customer approval | Not required |
| Execution mode | Automated |
## Additional Information
### Update CloudFormation stacks termination protection
#### Updating an CloudFormation termination protection stack with the console
The following shows this change type in the AMS console.
![\[Update Termination Protection interface showing description, ID, and version fields.\]](http://docs.aws.amazon.com/managedservices/latest/ctref/images/guiCfnProTermUpdateCT.png)
How it works:
1. Navigate to the **Create RFC** page: In the left navigation pane of the AMS console click **RFCs** to open the RFCs list page, and then click **Create RFC**.
1. Choose a popular change type (CT) in the default **Browse change types** view, or select a CT in the **Choose by category** view.
+ **Browse by change type**: You can click on a popular CT in the **Quick create** area to immediately open the **Run RFC** page. Note that you cannot choose an older CT version with quick create.
To sort CTs, use the **All change types** area in either the **Card** or **Table** view. In either view, select a CT and then click **Create RFC** to open the **Run RFC** page. If applicable, a **Create with older version** option appears next to the **Create RFC** button.
+ **Choose by category**: Select a category, subcategory, item, and operation and the CT details box opens with an option to **Create with older version** if applicable. Click **Create RFC** to open the **Run RFC** page.
1. On the **Run RFC** page, open the CT name area to see the CT details box. A **Subject** is required (this is filled in for you if you choose your CT in the **Browse change types** view). Open the **Additional configuration** area to add information about the RFC.
In the **Execution configuration** area, use available drop-down lists or enter values for the required parameters. To configure optional execution parameters, open the **Additional configuration** area.
1. When finished, click **Run**. If there are no errors, the **RFC successfully created** page displays with the submitted RFC details, and the initial **Run output**.
1. Open the **Run parameters** area to see the configurations you submitted. Refresh the page to update the RFC execution status. Optionally, cancel the RFC or create a copy of it with the options at the top of the page.
#### Updating an CloudFormation stack termination protection with the CLI
How it works:
1. Use either the Inline Create (you issue a `create-rfc` command with all RFC and execution parameters included), or Template Create (you create two JSON files, one for the RFC parameters and one for the execution parameters) and issue the `create-rfc` command with the two files as input. Both methods are described here.
1. Submit the RFC: `aws amscm submit-rfc --rfc-id ID` command with the returned RFC ID.
Monitor the RFC: `aws amscm get-rfc --rfc-id ID` command.
To check the change type version, use this command:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=CT_ID
```
**Note**
You can use any `CreateRfc` parameters with any RFC whether or not they are part of the schema for the change type. For example, to get notifications when the RFC status changes, add this line, `--notification "{\"Email\": {\"EmailRecipients\" : [\"email@example.com\"]}}"` to the RFC parameters part of the request (not the execution parameters). For a list of all CreateRfc parameters, see the [AMS Change Management API Reference](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_CreateRfc.html).
Only specify the parameters you want to change. Absent parameters retain the existing values.
*INLINE CREATE*:
Issue the create RFC command with execution parameters provided inline (escape quotation marks when providing execution parameters inline), and then submit the returned RFC ID. For example, you can replace the contents with something like this:
```
aws amscm create-rfc \
--change-type-id "ct-2uzbqr7x7mekd" \
--change-type-version "1.0" \
--title "Enable termination protection on CFN stack" \
--execution-parameters "{\"DocumentName\":\"AWSManagedServices-ManageResourceTerminationProtection\",\"Region\":\"us-east-1\",\"Parameters\":{\"ResourceId\":[\"stack-psvnq6cupymio3enl\"],\"TerminationProtectionDesiredState\":[\"enabled\"]}}"
```
*TEMPLATE CREATE*:
1. Output the execution parameters for this change type to a JSON file; this example names it EnableTermProCFNParams.json:
```
aws amscm get-change-type-version --change-type-id "ct-2uzbqr7x7mekd" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > EnableTermProCFNParams.json
```
1. Modify and save the EnableTermProCFNParams file, retaining only the parameters that you want to change. For example, you can replace the contents with something like this:
```
{
"DocumentName": "AWSManagedServices-ManageResourceTerminationProtection",
"Region": "us-east-1",
"Parameters": {
"ResourceId": ["stack-psvnq6cupymio3enl"],
"TerminationProtectionDesiredState": ["enabled"]
}
}
```
1. Output the RFC template to a file in your current folder; this example names it EnableTermProCFNRfc.json:
```
aws amscm create-rfc --generate-cli-skeleton > EnableTermProCFNRfc.json
```
1. Modify and save the EnableTermProCFNRfc.json file. For example, you can replace the contents with something like this:
```
{
"ChangeTypeId": "ct-2uzbqr7x7mekd",
"ChangeTypeVersion": "1.0",
"Title": "Enable termination protection on CFN instance"
}
```
1. Create the RFC, specifying the EnableTermProCFNRfc file and the EnableTermProCFNParams file:
```
aws amscm create-rfc --cli-input-json file://EnableTermProCFNRfc.json --execution-parameters file://EnableTermProCFNParams.json
```
You receive the ID of the new RFC in the response and can use it to submit and monitor the RFC. Until you submit it, the RFC remains in the editing state and does not start.
#### Tips
**Note**
There is a related CT for Amazon EC2, [EC2 stack: Updating termination protection](https://docs.aws.amazon.com/managedservices/latest/ctref/ex-ec2-term-pro-update-col.html).
To learn more about termination protection, see [ Protecting a stack from being deleted](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html).
## Execution Input Parameters
For detailed information about the execution input parameters, see [Schema for Change Type ct-2uzbqr7x7mekd](schemas.md#ct-2uzbqr7x7mekd-schema-section).
## Example: Required Parameters
```
Example not available.
```
## Example: All Parameters
```
{
"DocumentName": "AWSManagedServices-ManageResourceTerminationProtection",
"Region": "eu-west-1",
"Parameters": {
"ResourceId": ["stack-1234567890abcd"],
"TerminationProtectionDesiredState": ["enabled"]
}
}
```