CloudFormation / Client / describe_change_set

describe_change_set#

CloudFormation.Client.describe_change_set(**kwargs)#

Returns the inputs for the change set and a list of changes that CloudFormation will make if you execute the change set. For more information, see Updating Stacks Using Change Sets in the CloudFormation User Guide.

Request Syntax

response = client.describe_change_set(
    ChangeSetName='string',
    StackName='string',
    NextToken='string'
)

Parameters:

ChangeSetName (string) –
[REQUIRED]

The name or Amazon Resource Name (ARN) of the change set that you want to describe.
StackName (string) – If you specified the name of a change set, specify the stack name or ID (ARN) of the change set you want to describe.
NextToken (string) – A string (provided by the DescribeChangeSet response output) that identifies the next page of information that you want to retrieve.

Return type:

dict

Returns:

Response Syntax

{
    'ChangeSetName': 'string',
    'ChangeSetId': 'string',
    'StackId': 'string',
    'StackName': 'string',
    'Description': 'string',
    'Parameters': [
        {
            'ParameterKey': 'string',
            'ParameterValue': 'string',
            'UsePreviousValue': True|False,
            'ResolvedValue': 'string'
        },
    ],
    'CreationTime': datetime(2015, 1, 1),
    'ExecutionStatus': 'UNAVAILABLE'|'AVAILABLE'|'EXECUTE_IN_PROGRESS'|'EXECUTE_COMPLETE'|'EXECUTE_FAILED'|'OBSOLETE',
    'Status': 'CREATE_PENDING'|'CREATE_IN_PROGRESS'|'CREATE_COMPLETE'|'DELETE_PENDING'|'DELETE_IN_PROGRESS'|'DELETE_COMPLETE'|'DELETE_FAILED'|'FAILED',
    'StatusReason': 'string',
    'NotificationARNs': [
        'string',
    ],
    'RollbackConfiguration': {
        'RollbackTriggers': [
            {
                'Arn': 'string',
                'Type': 'string'
            },
        ],
        'MonitoringTimeInMinutes': 123
    },
    'Capabilities': [
        'CAPABILITY_IAM'|'CAPABILITY_NAMED_IAM'|'CAPABILITY_AUTO_EXPAND',
    ],
    'Tags': [
        {
            'Key': 'string',
            'Value': 'string'
        },
    ],
    'Changes': [
        {
            'Type': 'Resource',
            'HookInvocationCount': 123,
            'ResourceChange': {
                'Action': 'Add'|'Modify'|'Remove'|'Import'|'Dynamic',
                'LogicalResourceId': 'string',
                'PhysicalResourceId': 'string',
                'ResourceType': 'string',
                'Replacement': 'True'|'False'|'Conditional',
                'Scope': [
                    'Properties'|'Metadata'|'CreationPolicy'|'UpdatePolicy'|'DeletionPolicy'|'Tags',
                ],
                'Details': [
                    {
                        'Target': {
                            'Attribute': 'Properties'|'Metadata'|'CreationPolicy'|'UpdatePolicy'|'DeletionPolicy'|'Tags',
                            'Name': 'string',
                            'RequiresRecreation': 'Never'|'Conditionally'|'Always'
                        },
                        'Evaluation': 'Static'|'Dynamic',
                        'ChangeSource': 'ResourceReference'|'ParameterReference'|'ResourceAttribute'|'DirectModification'|'Automatic',
                        'CausingEntity': 'string'
                    },
                ],
                'ChangeSetId': 'string',
                'ModuleInfo': {
                    'TypeHierarchy': 'string',
                    'LogicalIdHierarchy': 'string'
                }
            }
        },
    ],
    'NextToken': 'string',
    'IncludeNestedStacks': True|False,
    'ParentChangeSetId': 'string',
    'RootChangeSetId': 'string',
    'OnStackFailure': 'DO_NOTHING'|'ROLLBACK'|'DELETE'
}

Response Structure

(dict) –

The output for the DescribeChangeSet action.
- ChangeSetName (string) –
  
  The name of the change set.
- ChangeSetId (string) –
  
  The Amazon Resource Name (ARN) of the change set.
- StackId (string) –
  
  The Amazon Resource Name (ARN) of the stack that’s associated with the change set.
- StackName (string) –
  
  The name of the stack that’s associated with the change set.
- Description (string) –
  
  Information about the change set.
- Parameters (list) –
  
  A list of Parameter structures that describes the input parameters and their values used to create the change set. For more information, see the Parameter data type.
  - (dict) –
    
    The Parameter data type.
    - ParameterKey (string) –
      
      The key associated with the parameter. If you don’t specify a key and value for a particular parameter, CloudFormation uses the default value that’s specified in your template.
    - ParameterValue (string) –
      
      The input value associated with the parameter.
    - UsePreviousValue (boolean) –
      
      During a stack update, use the existing parameter value that the stack is using for a given parameter key. If you specify true, do not specify a parameter value.
    - ResolvedValue (string) –
      
      Read-only. The value that corresponds to a SSM parameter key. This field is returned only for SSM parameter types in the template.
- CreationTime (datetime) –
  
  The start time when the change set was created, in UTC.
- ExecutionStatus (string) –
  
  If the change set execution status is AVAILABLE, you can execute the change set. If you can’t execute the change set, the status indicates why. For example, a change set might be in an UNAVAILABLE state because CloudFormation is still creating it or in an OBSOLETE state because the stack was already updated.
- Status (string) –
  
  The current status of the change set, such as CREATE_IN_PROGRESS, CREATE_COMPLETE, or FAILED.
- StatusReason (string) –
  
  A description of the change set’s status. For example, if your attempt to create a change set failed, CloudFormation shows the error message.
- NotificationARNs (list) –
  
  The ARNs of the Amazon Simple Notification Service (Amazon SNS) topics that will be associated with the stack if you execute the change set.
  - (string) –
- RollbackConfiguration (dict) –
  
  The rollback triggers for CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards.
  - RollbackTriggers (list) –
    
    The triggers to monitor during stack creation or update actions.
    
    By default, CloudFormation saves the rollback triggers specified for a stack and applies them to any subsequent update operations for the stack, unless you specify otherwise. If you do specify rollback triggers for this parameter, those triggers replace any list of triggers previously specified for the stack. This means:
    - To use the rollback triggers previously specified for this stack, if any, don’t specify this parameter.
    - To specify new or updated rollback triggers, you must specify all the triggers that you want used for this stack, even triggers you’ve specified before (for example, when creating the stack or during a previous stack update). Any triggers that you don’t include in the updated list of triggers are no longer applied to the stack.
    - To remove all currently specified triggers, specify an empty list for this parameter.
    If a specified trigger is missing, the entire stack operation fails and is rolled back.
    - (dict) –
      
      A rollback trigger CloudFormation monitors during creation and updating of stacks. If any of the alarms you specify goes to ALARM state during the stack operation or within the specified monitoring period afterwards, CloudFormation rolls back the entire stack operation.
      - Arn (string) –
        
        The Amazon Resource Name (ARN) of the rollback trigger.
        
        If a specified trigger is missing, the entire stack operation fails and is rolled back.
      - Type (string) –
        
        The resource type of the rollback trigger. Specify either AWS::CloudWatch::Alarm or AWS::CloudWatch::CompositeAlarm resource types.
  - MonitoringTimeInMinutes (integer) –
    
    The amount of time, in minutes, during which CloudFormation should monitor all the rollback triggers after the stack creation or update operation deploys all necessary resources.
    
    The default is 0 minutes.
    
    If you specify a monitoring period but don’t specify any rollback triggers, CloudFormation still waits the specified period of time before cleaning up old resources after update operations. You can use this monitoring period to perform any manual stack validation desired, and manually cancel the stack creation or update (using CancelUpdateStack, for example) as necessary.
    
    If you specify 0 for this parameter, CloudFormation still monitors the specified rollback triggers during stack creation and update operations. Then, for update operations, it begins disposing of old resources immediately once the operation completes.
- Capabilities (list) –
  
  If you execute the change set, the list of capabilities that were explicitly acknowledged when the change set was created.
  - (string) –
- Tags (list) –
  
  If you execute the change set, the tags that will be associated with the stack.
  - (dict) –
    
    The Tag type enables you to specify a key-value pair that can be used to store information about an CloudFormation stack.
    - Key (string) –
      
      Required. A string used to identify this tag. You can specify a maximum of 128 characters for a tag key. Tags owned by Amazon Web Services (Amazon Web Services) have the reserved prefix: aws:.
    - Value (string) –
      
      Required. A string containing the value for this tag. You can specify a maximum of 256 characters for a tag value.
- Changes (list) –
  
  A list of Change structures that describes the resources CloudFormation changes if you execute the change set.
  - (dict) –
    
    The Change structure describes the changes CloudFormation will perform if you execute the change set.
    - Type (string) –
      
      The type of entity that CloudFormation changes. Currently, the only entity type is Resource.
    - HookInvocationCount (integer) –
      
      Is either null, if no hooks invoke for the resource, or contains the number of hooks that will invoke for the resource.
    - ResourceChange (dict) –
      
      A ResourceChange structure that describes the resource and action that CloudFormation will perform.
      - Action (string) –
        
        The action that CloudFormation takes on the resource, such as Add (adds a new resource), Modify (changes a resource), Remove (deletes a resource), Import (imports a resource), or Dynamic (exact action for the resource can’t be determined).
      - LogicalResourceId (string) –
        
        The resource’s logical ID, which is defined in the stack’s template.
      - PhysicalResourceId (string) –
        
        The resource’s physical ID (resource name). Resources that you are adding don’t have physical IDs because they haven’t been created.
      - ResourceType (string) –
        
        The type of CloudFormation resource, such as AWS::S3::Bucket.
      - Replacement (string) –
        
        For the Modify action, indicates whether CloudFormation will replace the resource by creating a new one and deleting the old one. This value depends on the value of the RequiresRecreation property in the ResourceTargetDefinition structure. For example, if the RequiresRecreation field is Always and the Evaluation field is Static, Replacement is True. If the RequiresRecreation field is Always and the Evaluation field is Dynamic, Replacement is Conditionally.
        
        If you have multiple changes with different RequiresRecreation values, the Replacement value depends on the change with the most impact. A RequiresRecreation value of Always has the most impact, followed by Conditionally, and then Never.
      - Scope (list) –
        
        For the Modify action, indicates which resource attribute is triggering this update, such as a change in the resource attribute’s Metadata, Properties, or Tags.
        
        (string) –
      - Details (list) –
        
        For the Modify action, a list of ResourceChangeDetail structures that describes the changes that CloudFormation will make to the resource.
        
        (dict) –
        
        For a resource with Modify as the action, the ResourceChange structure describes the changes CloudFormation will make to that resource.
        
        Target (dict) –
        
        A ResourceTargetDefinition structure that describes the field that CloudFormation will change and whether the resource will be recreated.
        
        Attribute (string) –
        
        Indicates which resource attribute is triggering this update, such as a change in the resource attribute’s Metadata, Properties, or Tags.
        
        Name (string) –
        
        If the Attribute value is Properties, the name of the property. For all other attributes, the value is null.
        
        RequiresRecreation (string) –
        
        If the Attribute value is Properties, indicates whether a change to this property causes the resource to be recreated. The value can be Never, Always, or Conditionally. To determine the conditions for a Conditionally recreation, see the update behavior for that property in the CloudFormation User Guide.
        
        Evaluation (string) –
        
        Indicates whether CloudFormation can determine the target value, and whether the target value will change before you execute a change set.
        
        For Static evaluations, CloudFormation can determine that the target value will change, and its value. For example, if you directly modify the InstanceType property of an EC2 instance, CloudFormation knows that this property value will change, and its value, so this is a Static evaluation.
        
        For Dynamic evaluations, can’t determine the target value because it depends on the result of an intrinsic function, such as a Ref or Fn::GetAtt intrinsic function, when the stack is updated. For example, if your template includes a reference to a resource that’s conditionally recreated, the value of the reference (the physical ID of the resource) might change, depending on if the resource is recreated. If the resource is recreated, it will have a new physical ID, so all references to that resource will also be updated.
        
        ChangeSource (string) –
        
        The group to which the CausingEntity value belongs. There are five entity groups:
        
        ResourceReference entities are Ref intrinsic functions that refer to resources in the template, such as { "Ref" : "MyEC2InstanceResource" }.
        
        ParameterReference entities are Ref intrinsic functions that get template parameter values, such as { "Ref" : "MyPasswordParameter" }.
        
        ResourceAttribute entities are Fn::GetAtt intrinsic functions that get resource attribute values, such as { "Fn::GetAtt" : [ "MyEC2InstanceResource", "PublicDnsName" ] }.
        
        DirectModification entities are changes that are made directly to the template.
        
        Automatic entities are AWS::CloudFormation::Stack resource types, which are also known as nested stacks. If you made no changes to the AWS::CloudFormation::Stack resource, CloudFormation sets the ChangeSource to Automatic because the nested stack’s template might have changed. Changes to a nested stack’s template aren’t visible to CloudFormation until you run an update on the parent stack.
        
        CausingEntity (string) –
        
        The identity of the entity that triggered this change. This entity is a member of the group that’s specified by the ChangeSource field. For example, if you modified the value of the KeyPairName parameter, the CausingEntity is the name of the parameter ( KeyPairName).
        
        If the ChangeSource value is DirectModification, no value is given for CausingEntity.
      - ChangeSetId (string) –
        
        The change set ID of the nested change set.
      - ModuleInfo (dict) –
        
        Contains information about the module from which the resource was created, if the resource was created from a module included in the stack template.
        
        TypeHierarchy (string) –
        
        A concatenated list of the module type or types containing the resource. Module types are listed starting with the inner-most nested module, and separated by /.
        
        In the following example, the resource was created from a module of type AWS::First::Example::MODULE, that’s nested inside a parent module of type AWS::Second::Example::MODULE.
        
        AWS::First::Example::MODULE/AWS::Second::Example::MODULE
        
        LogicalIdHierarchy (string) –
        
        A concatenated list of the logical IDs of the module or modules containing the resource. Modules are listed starting with the inner-most nested module, and separated by /.
        
        In the following example, the resource was created from a module, moduleA, that’s nested inside a parent module, moduleB.
        
        moduleA/moduleB
        
        For more information, see Referencing resources in a module in the CloudFormation User Guide.
- NextToken (string) –
  
  If the output exceeds 1 MB, a string that identifies the next page of changes. If there is no additional page, this value is null.
- IncludeNestedStacks (boolean) –
  
  Verifies if IncludeNestedStacks is set to True.
- ParentChangeSetId (string) –
  
  Specifies the change set ID of the parent change set in the current nested change set hierarchy.
- RootChangeSetId (string) –
  
  Specifies the change set ID of the root change set in the current nested change set hierarchy.
- OnStackFailure (string) –
  
  Determines what action will be taken if stack creation fails. When this parameter is specified, the DisableRollback parameter to the ExecuteChangeSet API operation must not be specified. This must be one of these values:
  - DELETE - Deletes the change set if the stack creation fails. This is only valid when the ChangeSetType parameter is set to CREATE. If the deletion of the stack fails, the status of the stack is DELETE_FAILED.
  - DO_NOTHING - if the stack creation fails, do nothing. This is equivalent to specifying true for the DisableRollback parameter to the ExecuteChangeSet API operation.
  - ROLLBACK - if the stack creation fails, roll back the stack. This is equivalent to specifying false for the DisableRollback parameter to the ExecuteChangeSet API operation.

Exceptions

CloudFormation.Client.exceptions.ChangeSetNotFoundException