Class: Aws::CloudFormation::Client

Inherits:
Seahorse::Client::Base
  • Object
show all
Includes:
Aws::ClientStubs
Defined in:
lib/aws-sdk-cloudformation/client.rb

Overview

An API client for CloudFormation. To construct a client, you need to configure a `:region` and `:credentials`.

client = Aws::CloudFormation::Client.new(
  region: region_name,
  credentials: credentials,
  # ...
)

For details on configuring region and credentials see the [developer guide](/sdk-for-ruby/v3/developer-guide/setup-config.html).

See #initialize for a full list of supported configuration options.

Class Attribute Summary collapse

API Operations collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :credentials (required, Aws::CredentialProvider)

    Your AWS credentials. This can be an instance of any one of the following classes:

    • `Aws::Credentials` - Used for configuring static, non-refreshing credentials.

    • `Aws::SharedCredentials` - Used for loading static credentials from a shared file, such as `~/.aws/config`.

    • `Aws::AssumeRoleCredentials` - Used when you need to assume a role.

    • `Aws::AssumeRoleWebIdentityCredentials` - Used when you need to assume a role after providing credentials via the web.

    • `Aws::SSOCredentials` - Used for loading credentials from AWS SSO using an access token generated from `aws login`.

    • `Aws::ProcessCredentials` - Used for loading credentials from a process that outputs to stdout.

    • `Aws::InstanceProfileCredentials` - Used for loading credentials from an EC2 IMDS on an EC2 instance.

    • `Aws::ECSCredentials` - Used for loading credentials from instances running in ECS.

    • `Aws::CognitoIdentityCredentials` - Used for loading credentials from the Cognito Identity service.

    When `:credentials` are not configured directly, the following locations will be searched for credentials:

    • `Aws.config`

    • The `:access_key_id`, `:secret_access_key`, and `:session_token` options.

    • ENV, ENV

    • `~/.aws/credentials`

    • `~/.aws/config`

    • EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of `Aws::InstanceProfileCredentails` or `Aws::ECSCredentials` to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting ENV to true.

  • :region (required, String)

    The AWS region to connect to. The configured `:region` is used to determine the service `:endpoint`. When not passed, a default `:region` is searched for in the following locations:

  • :access_key_id (String)
  • :active_endpoint_cache (Boolean) — default: false

    When set to `true`, a thread polling for endpoints will be running in the background every 60 secs (default). Defaults to `false`.

  • :adaptive_retry_wait_to_fill (Boolean) — default: true

    Used only in `adaptive` retry mode. When true, the request will sleep until there is sufficent client side capacity to retry the request. When false, the request will raise a `RetryCapacityNotAvailableError` and will not retry instead of sleeping.

  • :client_side_monitoring (Boolean) — default: false

    When `true`, client-side metrics will be collected for all API requests from this client.

  • :client_side_monitoring_client_id (String) — default: ""

    Allows you to provide an identifier for this client which will be attached to all generated client side metrics. Defaults to an empty string.

  • :client_side_monitoring_host (String) — default: "127.0.0.1"

    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_port (Integer) — default: 31000

    Required for publishing client metrics. The port that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher) — default: Aws::ClientSideMonitoring::Publisher

    Allows you to provide a custom client-side monitoring publisher class. By default, will use the Client Side Monitoring Agent Publisher.

  • :convert_params (Boolean) — default: true

    When `true`, an attempt is made to coerce request parameters into the required types.

  • :correct_clock_skew (Boolean) — default: true

    Used only in `standard` and adaptive retry modes. Specifies whether to apply a clock skew correction and retry requests with skewed client clocks.

  • :defaults_mode (String) — default: "legacy"

    See DefaultsModeConfiguration for a list of the accepted modes and the configuration defaults that are included.

  • :disable_host_prefix_injection (Boolean) — default: false

    Set to true to disable SDK automatically adding host prefix to default service endpoint when available.

  • :endpoint (String)

    The client endpoint is normally constructed from the `:region` option. You should only configure an `:endpoint` when connecting to test or custom endpoints. This should be a valid HTTP(S) URI.

  • :endpoint_cache_max_entries (Integer) — default: 1000

    Used for the maximum size limit of the LRU cache storing endpoints data for endpoint discovery enabled operations. Defaults to 1000.

  • :endpoint_cache_max_threads (Integer) — default: 10

    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

  • :endpoint_cache_poll_interval (Integer) — default: 60

    When :endpoint_discovery and :active_endpoint_cache is enabled, Use this option to config the time interval in seconds for making requests fetching endpoints information. Defaults to 60 sec.

  • :endpoint_discovery (Boolean) — default: false

    When set to `true`, endpoint discovery will be enabled for operations when available.

  • :log_formatter (Aws::Log::Formatter) — default: Aws::Log::Formatter.default

    The log formatter.

  • :log_level (Symbol) — default: :info

    The log level to send messages to the `:logger` at.

  • :logger (Logger)

    The Logger instance to send log messages to. If this option is not set, logging will be disabled.

  • :max_attempts (Integer) — default: 3

    An integer representing the maximum number attempts that will be made for a single request, including the initial attempt. For example, setting this value to 5 will result in a request being retried up to 4 times. Used in `standard` and `adaptive` retry modes.

  • :profile (String) — default: "default"

    Used when loading credentials from the shared credentials file at HOME/.aws/credentials. When not specified, 'default' is used.

  • :retry_backoff (Proc)

    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay. This option is only used in the `legacy` retry mode.

  • :retry_base_delay (Float) — default: 0.3

    The base delay in seconds used by the default backoff function. This option is only used in the `legacy` retry mode.

  • :retry_jitter (Symbol) — default: :none

    A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number. This option is only used in the `legacy` retry mode.

    @see www.awsarchitectureblog.com/2015/03/backoff.html

  • :retry_limit (Integer) — default: 3

    The maximum number of times to retry failed requests. Only ~ 500 level server errors and certain ~ 400 level client errors are retried. Generally, these are throttling errors, data checksum errors, networking errors, timeout errors, auth errors, endpoint discovery, and errors from expired credentials. This option is only used in the `legacy` retry mode.

  • :retry_max_delay (Integer) — default: 0

    The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function. This option is only used in the `legacy` retry mode.

  • :retry_mode (String) — default: "legacy"

    Specifies which retry algorithm to use. Values are:

    • `legacy` - The pre-existing retry behavior. This is default value if no retry mode is provided.

    • `standard` - A standardized set of retry rules across the AWS SDKs. This includes support for retry quotas, which limit the number of unsuccessful retries a client can make.

    • `adaptive` - An experimental retry mode that includes all the functionality of `standard` mode along with automatic client side throttling. This is a provisional mode that may change behavior in the future.

  • :secret_access_key (String)
  • :session_token (String)
  • :stub_responses (Boolean) — default: false

    Causes the client to return stubbed responses. By default fake responses are generated and returned. You can specify the response data to return or errors to raise by calling ClientStubs#stub_responses. See ClientStubs for more information.

    ** Please note ** When response stubbing is enabled, no HTTP requests are made, and retries are disabled.

  • :use_dualstack_endpoint (Boolean)

    When set to `true`, dualstack enabled endpoints (with `.aws` TLD) will be used if available.

  • :use_fips_endpoint (Boolean)

    When set to `true`, fips compatible endpoints will be used if available. When a `fips` region is used, the region is normalized and this config is set to `true`.

  • :validate_params (Boolean) — default: true

    When `true`, request parameters are validated before sending the request.

  • :http_proxy (URI::HTTP, String)

    A proxy to send requests through. Formatted like 'proxy.com:123'.

  • :http_open_timeout (Float) — default: 15

    The number of seconds to wait when opening a HTTP session before raising a `Timeout::Error`.

  • :http_read_timeout (Float) — default: 60

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_idle_timeout (Float) — default: 5

    The number of seconds a connection is allowed to sit idle before it is considered stale. Stale connections are closed and removed from the pool before making a request.

  • :http_continue_timeout (Float) — default: 1

    The number of seconds to wait for a 100-continue response before sending the request body. This option has no effect unless the request has “Expect” header set to “100-continue”. Defaults to `nil` which disables this behaviour. This value can safely be set per request on the session.

  • :ssl_timeout (Float) — default: nil

    Sets the SSL timeout in seconds.

  • :http_wire_trace (Boolean) — default: false

    When `true`, HTTP debug output will be sent to the `:logger`.

  • :ssl_verify_peer (Boolean) — default: true

    When `true`, SSL peer certificates are verified when establishing a connection.

  • :ssl_ca_bundle (String)

    Full path to the SSL certificate authority bundle file that should be used when verifying peer certificates. If you do not pass `:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.

  • :ssl_ca_directory (String)

    Full path of the directory that contains the unbundled SSL certificate authority files for verifying peer certificates. If you do not pass `:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.


344
345
346
# File 'lib/aws-sdk-cloudformation/client.rb', line 344

def initialize(*args)
  super
end

Class Attribute Details

.identifierObject (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.


6830
6831
6832
# File 'lib/aws-sdk-cloudformation/client.rb', line 6830

def identifier
  @identifier
end

Class Method Details

.errors_moduleObject

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.


6833
6834
6835
# File 'lib/aws-sdk-cloudformation/client.rb', line 6833

def errors_module
  Errors
end

Instance Method Details

#activate_type(params = {}) ⇒ Types::ActivateTypeOutput

Activates a public third-party extension, making it available for use in stack templates. For more information, see [Using public extensions] in the *CloudFormation User Guide*.

Once you have activated a public third-party extension in your account and region, use [SetTypeConfiguration](AWSCloudFormation/latest/APIReference/API_SetTypeConfiguration.html) to specify configuration properties for the extension. For more information, see [Configuring extensions at the account level] in the *CloudFormation User Guide*.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-public.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-register.html#registry-set-configuration

Examples:

Request syntax with placeholder values


resp = client.activate_type({
  type: "RESOURCE", # accepts RESOURCE, MODULE
  public_type_arn: "ThirdPartyTypeArn",
  publisher_id: "PublisherId",
  type_name: "TypeName",
  type_name_alias: "TypeName",
  auto_update: false,
  logging_config: {
    log_role_arn: "RoleArn", # required
    log_group_name: "LogGroupName", # required
  },
  execution_role_arn: "RoleArn",
  version_bump: "MAJOR", # accepts MAJOR, MINOR
  major_version: 1,
})

Response structure


resp.arn #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :type (String)

    The extension type.

    Conditional: You must specify `PublicTypeArn`, or `TypeName`, `Type`, and `PublisherId`.

  • :public_type_arn (String)

    The Amazon Resource Number (ARN) of the public extension.

    Conditional: You must specify `PublicTypeArn`, or `TypeName`, `Type`, and `PublisherId`.

  • :publisher_id (String)

    The ID of the extension publisher.

    Conditional: You must specify `PublicTypeArn`, or `TypeName`, `Type`, and `PublisherId`.

  • :type_name (String)

    The name of the extension.

    Conditional: You must specify `PublicTypeArn`, or `TypeName`, `Type`, and `PublisherId`.

  • :type_name_alias (String)

    An alias to assign to the public extension, in this account and region. If you specify an alias for the extension, CloudFormation treats the alias as the extension type name within this account and region. You must use the alias to refer to the extension in your templates, API calls, and CloudFormation console.

    An extension alias must be unique within a given account and region. You can activate the same public resource multiple times in the same account and region, using different type name aliases.

  • :auto_update (Boolean)

    Whether to automatically update the extension in this account and region when a new minor version is published by the extension publisher. Major versions released by the publisher must be manually updated.

    The default is `true`.

  • :logging_config (Types::LoggingConfig)

    Contains logging configuration information for an extension.

  • :execution_role_arn (String)

    The name of the IAM execution role to use to activate the extension.

  • :version_bump (String)

    Manually updates a previously-activated type to a new major or minor version, if available. You can also use this parameter to update the value of `AutoUpdate`.

    • `MAJOR`: CloudFormation updates the extension to the newest major version, if one is available.

    • `MINOR`: CloudFormation updates the extension to the newest minor version, if one is available.

  • :major_version (Integer)

    The major version of this extension you want to activate, if multiple major versions are available. The default is the latest major version. CloudFormation uses the latest available minor version of the major version selected.

    You can specify `MajorVersion` or `VersionBump`, but not both.

Returns:

See Also:


464
465
466
467
# File 'lib/aws-sdk-cloudformation/client.rb', line 464

def activate_type(params = {}, options = {})
  req = build_request(:activate_type, params)
  req.send_request(options)
end

#batch_describe_type_configurations(params = {}) ⇒ Types::BatchDescribeTypeConfigurationsOutput

Returns configuration data for the specified CloudFormation extensions, from the CloudFormation registry for the account and region.

For more information, see [Configuring extensions at the account level] in the *CloudFormation User Guide*.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-register.html#registry-set-configuration

Examples:

Request syntax with placeholder values


resp = client.batch_describe_type_configurations({
  type_configuration_identifiers: [ # required
    {
      type_arn: "TypeArn",
      type_configuration_alias: "TypeConfigurationAlias",
      type_configuration_arn: "TypeConfigurationArn",
      type: "RESOURCE", # accepts RESOURCE, MODULE
      type_name: "TypeName",
    },
  ],
})

Response structure


resp.errors #=> Array
resp.errors[0].error_code #=> String
resp.errors[0].error_message #=> String
resp.errors[0].type_configuration_identifier.type_arn #=> String
resp.errors[0].type_configuration_identifier.type_configuration_alias #=> String
resp.errors[0].type_configuration_identifier.type_configuration_arn #=> String
resp.errors[0].type_configuration_identifier.type #=> String, one of "RESOURCE", "MODULE"
resp.errors[0].type_configuration_identifier.type_name #=> String
resp.unprocessed_type_configurations #=> Array
resp.unprocessed_type_configurations[0].type_arn #=> String
resp.unprocessed_type_configurations[0].type_configuration_alias #=> String
resp.unprocessed_type_configurations[0].type_configuration_arn #=> String
resp.unprocessed_type_configurations[0].type #=> String, one of "RESOURCE", "MODULE"
resp.unprocessed_type_configurations[0].type_name #=> String
resp.type_configurations #=> Array
resp.type_configurations[0].arn #=> String
resp.type_configurations[0].alias #=> String
resp.type_configurations[0].configuration #=> String
resp.type_configurations[0].last_updated #=> Time
resp.type_configurations[0].type_arn #=> String
resp.type_configurations[0].type_name #=> String
resp.type_configurations[0].is_default_configuration #=> Boolean

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

Returns:

See Also:


532
533
534
535
# File 'lib/aws-sdk-cloudformation/client.rb', line 532

def batch_describe_type_configurations(params = {}, options = {})
  req = build_request(:batch_describe_type_configurations, params)
  req.send_request(options)
end

#build_request(operation_name, params = {}) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • params ({}) (defaults to: {})

6681
6682
6683
6684
6685
6686
6687
6688
6689
6690
6691
6692
# File 'lib/aws-sdk-cloudformation/client.rb', line 6681

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config)
  context[:gem_name] = 'aws-sdk-cloudformation'
  context[:gem_version] = '1.64.0'
  Seahorse::Client::Request.new(handlers, context)
end

#cancel_update_stack(params = {}) ⇒ Struct

Cancels an update on the specified stack. If the call completes successfully, the stack rolls back the update and reverts to the previous stack configuration.

<note markdown=“1”> You can cancel only stacks that are in the UPDATE_IN_PROGRESS state.

</note>

Examples:

Request syntax with placeholder values


resp = client.cancel_update_stack({
  stack_name: "StackName", # required
  client_request_token: "ClientRequestToken",
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or the unique stack ID that is associated with the stack.

  • :client_request_token (String)

    A unique identifier for this `CancelUpdateStack` request. Specify this token if you plan to retry requests so that CloudFormation knows that you're not attempting to cancel an update on a stack with the same name. You might retry `CancelUpdateStack` requests to ensure that CloudFormation successfully received them.

Returns:

  • (Struct)

    Returns an empty response.

See Also:


568
569
570
571
# File 'lib/aws-sdk-cloudformation/client.rb', line 568

def cancel_update_stack(params = {}, options = {})
  req = build_request(:cancel_update_stack, params)
  req.send_request(options)
end

#continue_update_rollback(params = {}) ⇒ Struct

For a specified stack that is in the `UPDATE_ROLLBACK_FAILED` state, continues rolling it back to the `UPDATE_ROLLBACK_COMPLETE` state. Depending on the cause of the failure, you can manually [ fix the error] and continue the rollback. By continuing the rollback, you can return your stack to a working state (the `UPDATE_ROLLBACK_COMPLETE` state), and then try to update the stack again.

A stack goes into the `UPDATE_ROLLBACK_FAILED` state when CloudFormation cannot roll back all changes after a failed stack update. For example, you might have a stack that is rolling back to an old database instance that was deleted outside of CloudFormation. Because CloudFormation doesn't know the database was deleted, it assumes that the database instance still exists and attempts to roll back to it, causing the update rollback to fail.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html#troubleshooting-errors-update-rollback-failed

Examples:

Request syntax with placeholder values


resp = client.continue_update_rollback({
  stack_name: "StackNameOrId", # required
  role_arn: "RoleARN",
  resources_to_skip: ["ResourceToSkip"],
  client_request_token: "ClientRequestToken",
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or the unique ID of the stack that you want to continue rolling back.

    <note markdown=“1”> Don't specify the name of a nested stack (a stack that was created by using the `AWS::CloudFormation::Stack` resource). Instead, use this operation on the parent stack (the stack that contains the `AWS::CloudFormation::Stack` resource).

    </note>
    
  • :role_arn (String)

    The Amazon Resource Name (ARN) of an Identity and Access Management (IAM) role that CloudFormation assumes to roll back the stack. CloudFormation uses the role's credentials to make calls on your behalf. CloudFormation always uses this role for all future operations on the stack. As long as users have permission to operate on the stack, CloudFormation uses this role even if the users don't have permission to pass it. Ensure that the role grants least privilege.

    If you don't specify a value, CloudFormation uses the role that was previously associated with the stack. If no role is available, CloudFormation uses a temporary session that is generated from your user credentials.

  • :resources_to_skip (Array<String>)

    A list of the logical IDs of the resources that CloudFormation skips during the continue update rollback operation. You can specify only resources that are in the `UPDATE_FAILED` state because a rollback failed. You can't specify resources that are in the `UPDATE_FAILED` state for other reasons, for example, because an update was cancelled. To check why a resource update failed, use the DescribeStackResources action, and view the resource status reason.

    Specify this property to skip rolling back resources that CloudFormation can't successfully roll back. We recommend that you [ troubleshoot] resources before skipping them. CloudFormation sets the status of the specified resources to `UPDATE_COMPLETE` and continues to roll back the stack. After the rollback is complete, the state of the skipped resources will be inconsistent with the state of the resources in the stack template. Before performing another stack update, you must update the stack or resources to be consistent with each other. If you don't, subsequent stack updates might fail, and the stack will become unrecoverable.

    Specify the minimum number of resources required to successfully roll back your stack. For example, a failed resource update might cause dependent resources to fail. In this case, it might not be necessary to skip the dependent resources.

    To skip resources that are part of nested stacks, use the following format: `NestedStackName.ResourceLogicalID`. If you want to specify the logical ID of a stack resource (`Type: AWS::CloudFormation::Stack`) in the `ResourcesToSkip` list, then its corresponding embedded stack must be in one of the following states: `DELETE_IN_PROGRESS`, `DELETE_COMPLETE`, or `DELETE_FAILED`.

    <note markdown=“1”> Don't confuse a child stack's name with its corresponding logical ID defined in the parent stack. For an example of a continue update rollback operation with nested stacks, see [Using ResourcesToSkip to recover a nested stacks hierarchy].

    </note>
    

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html#troubleshooting-errors-update-rollback-failed [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-continueupdaterollback.html#nested-stacks

  • :client_request_token (String)

    A unique identifier for this `ContinueUpdateRollback` request. Specify this token if you plan to retry requests so that CloudFormationknows that you're not attempting to continue the rollback to a stack with the same name. You might retry `ContinueUpdateRollback` requests to ensure that CloudFormation successfully received them.

Returns:

  • (Struct)

    Returns an empty response.

See Also:


684
685
686
687
# File 'lib/aws-sdk-cloudformation/client.rb', line 684

def continue_update_rollback(params = {}, options = {})
  req = build_request(:continue_update_rollback, params)
  req.send_request(options)
end

#create_change_set(params = {}) ⇒ Types::CreateChangeSetOutput

Creates a list of changes that will be applied to a stack so that you can review the changes before executing them. You can create a change set for a stack that doesn't exist or an existing stack. If you create a change set for a stack that doesn't exist, the change set shows all of the resources that CloudFormation will create. If you create a change set for an existing stack, CloudFormation compares the stack's information with the information that you submit in the change set and lists the differences. Use change sets to understand which resources CloudFormation will create or change, and how it will change resources in an existing stack, before you create or update a stack.

To create a change set for a stack that doesn't exist, for the `ChangeSetType` parameter, specify `CREATE`. To create a change set for an existing stack, specify `UPDATE` for the `ChangeSetType` parameter. To create a change set for an import operation, specify `IMPORT` for the `ChangeSetType` parameter. After the `CreateChangeSet` call successfully completes, CloudFormation starts creating the change set. To check the status of the change set or to review it, use the DescribeChangeSet action.

When you are satisfied with the changes the change set will make, execute the change set by using the ExecuteChangeSet action. CloudFormation doesn't make changes until you execute the change set.

To create a change set for the entire stack hierachy, set `IncludeNestedStacks` to `True`.

Examples:

Request syntax with placeholder values


resp = client.create_change_set({
  stack_name: "StackNameOrId", # required
  template_body: "TemplateBody",
  template_url: "TemplateURL",
  use_previous_template: false,
  parameters: [
    {
      parameter_key: "ParameterKey",
      parameter_value: "ParameterValue",
      use_previous_value: false,
      resolved_value: "ParameterValue",
    },
  ],
  capabilities: ["CAPABILITY_IAM"], # accepts CAPABILITY_IAM, CAPABILITY_NAMED_IAM, CAPABILITY_AUTO_EXPAND
  resource_types: ["ResourceType"],
  role_arn: "RoleARN",
  rollback_configuration: {
    rollback_triggers: [
      {
        arn: "Arn", # required
        type: "Type", # required
      },
    ],
    monitoring_time_in_minutes: 1,
  },
  notification_arns: ["NotificationARN"],
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  change_set_name: "ChangeSetName", # required
  client_token: "ClientToken",
  description: "Description",
  change_set_type: "CREATE", # accepts CREATE, UPDATE, IMPORT
  resources_to_import: [
    {
      resource_type: "ResourceType", # required
      logical_resource_id: "LogicalResourceId", # required
      resource_identifier: { # required
        "ResourceIdentifierPropertyKey" => "ResourceIdentifierPropertyValue",
      },
    },
  ],
  include_nested_stacks: false,
})

Response structure


resp.id #=> String
resp.stack_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or the unique ID of the stack for which you are creating a change set. CloudFormation generates the change set by comparing this stack's information with the information that you submit, such as a modified template or different parameter input values.

  • :template_body (String)

    A structure that contains the body of the revised template, with a minimum length of 1 byte and a maximum length of 51,200 bytes. CloudFormation generates the change set by comparing this template with the template of the stack that you specified.

    Conditional: You must specify only `TemplateBody` or `TemplateURL`.

  • :template_url (String)

    The location of the file that contains the revised template. The URL must point to a template (max size: 460,800 bytes) that is located in an S3 bucket or a Systems Manager document. CloudFormation generates the change set by comparing this template with the stack that you specified.

    Conditional: You must specify only `TemplateBody` or `TemplateURL`.

  • :use_previous_template (Boolean)

    Whether to reuse the template that is associated with the stack to create the change set.

  • :parameters (Array<Types::Parameter>)

    A list of `Parameter` structures that specify input parameters for the change set. For more information, see the Parameter data type.

  • :capabilities (Array<String>)

    In some cases, you must explicitly acknowledge that your stack template contains certain capabilities in order for CloudFormation to create the stack.

    • `CAPABILITY_IAM` and `CAPABILITY_NAMED_IAM`

      Some stack templates might include resources that can affect permissions in your Amazon Web Services account; for example, by creating new Identity and Access Management (IAM) users. For those stacks, you must explicitly acknowledge this by specifying one of these capabilities.

      The following IAM resources require you to specify either the `CAPABILITY_IAM` or `CAPABILITY_NAMED_IAM` capability.

      • If you have IAM resources, you can specify either capability.

      • If you have IAM resources with custom names, you must specify `CAPABILITY_NAMED_IAM`.

      • If you don't specify either of these capabilities, CloudFormation returns an `InsufficientCapabilities` error.

      If your stack template contains these resources, we recommend that you review all permissions associated with them and edit their permissions if necessary.

      • AWS::IAM::AccessKey][1
      • AWS::IAM::Group][2
      • AWS::IAM::InstanceProfile][3
      • AWS::IAM::Policy][4
      • AWS::IAM::Role][5
      • AWS::IAM::User][6
      • AWS::IAM::UserToGroupAddition][7

      For more information, see [Acknowledging IAM Resources in CloudFormation Templates].

    • `CAPABILITY_AUTO_EXPAND`

      Some template contain macros. Macros perform custom processing on templates; this can include simple actions like find-and-replace operations, all the way to extensive transformations of entire templates. Because of this, users typically create a change set from the processed template, so that they can review the changes resulting from the macros before actually creating the stack. If your stack template contains one or more macros, and you choose to create a stack directly from the processed template, without first reviewing the resulting changes in a change set, you must acknowledge this capability. This includes the [AWS::Include] and

      AWS::Serverless][10

      transforms, which are macros hosted by

      CloudFormation.

      <note markdown=“1”> This capacity does not apply to creating change sets, and specifying it when creating change sets has no effect.

      If you want to create a stack from a stack template that contains
      

      macros and nested stacks, you must create or update the stack directly from the template using the CreateStack or UpdateStack action, and specifying this capability.

      </note>
      

      For more information on macros, see [Using CloudFormation Macros to Perform Custom Processing on Templates].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html [3]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html [4]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html [5]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html [6]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html [7]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html [8]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities [9]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html [10]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html [11]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html

  • :resource_types (Array<String>)

    The template resource types that you have permissions to work with if you execute this change set, such as `AWS::EC2::Instance`, `AWS::EC2::*`, or `Custom::MyCustomInstance`.

    If the list of resource types doesn't include a resource type that you're updating, the stack update fails. By default, CloudFormation grants permissions to all resource types. Identity and Access Management (IAM) uses this parameter for condition keys in IAM policies for CloudFormation. For more information, see [Controlling Access with Identity and Access Management] in the CloudFormation User Guide.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html

  • :role_arn (String)

    The Amazon Resource Name (ARN) of an Identity and Access Management (IAM) role that CloudFormation assumes when executing the change set. CloudFormation uses the role's credentials to make calls on your behalf. CloudFormation uses this role for all future operations on the stack. As long as users have permission to operate on the stack, CloudFormation uses this role even if the users don't have permission to pass it. Ensure that the role grants least privilege.

    If you don't specify a value, CloudFormation uses the role that was previously associated with the stack. If no role is available, CloudFormation uses a temporary session that is generated from your user credentials.

  • :rollback_configuration (Types::RollbackConfiguration)

    The rollback triggers for CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards.

  • :notification_arns (Array<String>)

    The Amazon Resource Names (ARNs) of Amazon Simple Notification Service (Amazon SNS) topics that CloudFormation associates with the stack. To remove all associated notification topics, specify an empty list.

  • :tags (Array<Types::Tag>)

    Key-value pairs to associate with this stack. CloudFormation also propagates these tags to resources in the stack. You can specify a maximum of 50 tags.

  • :change_set_name (required, String)

    The name of the change set. The name must be unique among all change sets that are associated with the specified stack.

    A change set name can contain only alphanumeric, case sensitive characters and hyphens. It must start with an alphabetic character and cannot exceed 128 characters.

  • :client_token (String)

    A unique identifier for this `CreateChangeSet` request. Specify this token if you plan to retry requests so that CloudFormation knows that you're not attempting to create another change set with the same name. You might retry `CreateChangeSet` requests to ensure that CloudFormation successfully received them.

  • :description (String)

    A description to help you identify this change set.

  • :change_set_type (String)

    The type of change set operation. To create a change set for a new stack, specify `CREATE`. To create a change set for an existing stack, specify `UPDATE`. To create a change set for an import operation, specify `IMPORT`.

    If you create a change set for a new stack, CloudFormation creates a stack with a unique stack ID, but no template or resources. The stack will be in the [ `REVIEW_IN_PROGRESS` ][1] state until you execute the change set.

    By default, CloudFormation specifies `UPDATE`. You can't use the `UPDATE` type to create a change set for a new stack or the `CREATE` type to create a change set for an existing stack.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html#d0e11995

  • :resources_to_import (Array<Types::ResourceToImport>)

    The resources to import into your stack.

  • :include_nested_stacks (Boolean)

    Creates a change set for the all nested stacks specified in the template. The default behavior of this action is set to `False`. To include nested sets in a change set, specify `True`.

Returns:

See Also:


990
991
992
993
# File 'lib/aws-sdk-cloudformation/client.rb', line 990

def create_change_set(params = {}, options = {})
  req = build_request(:create_change_set, params)
  req.send_request(options)
end

#create_stack(params = {}) ⇒ Types::CreateStackOutput

Creates a stack as specified in the template. After the call completes successfully, the stack creation starts. You can check the status of the stack via the DescribeStacks API.

Examples:

Request syntax with placeholder values


resp = client.create_stack({
  stack_name: "StackName", # required
  template_body: "TemplateBody",
  template_url: "TemplateURL",
  parameters: [
    {
      parameter_key: "ParameterKey",
      parameter_value: "ParameterValue",
      use_previous_value: false,
      resolved_value: "ParameterValue",
    },
  ],
  disable_rollback: false,
  rollback_configuration: {
    rollback_triggers: [
      {
        arn: "Arn", # required
        type: "Type", # required
      },
    ],
    monitoring_time_in_minutes: 1,
  },
  timeout_in_minutes: 1,
  notification_arns: ["NotificationARN"],
  capabilities: ["CAPABILITY_IAM"], # accepts CAPABILITY_IAM, CAPABILITY_NAMED_IAM, CAPABILITY_AUTO_EXPAND
  resource_types: ["ResourceType"],
  role_arn: "RoleARN",
  on_failure: "DO_NOTHING", # accepts DO_NOTHING, ROLLBACK, DELETE
  stack_policy_body: "StackPolicyBody",
  stack_policy_url: "StackPolicyURL",
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  client_request_token: "ClientRequestToken",
  enable_termination_protection: false,
})

Response structure


resp.stack_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name that is associated with the stack. The name must be unique in the Region in which you are creating the stack.

    <note markdown=“1”> A stack name can contain only alphanumeric characters (case sensitive) and hyphens. It must start with an alphabetical character and cannot be longer than 128 characters.

    </note>
    
  • :template_body (String)

    Structure containing the template body with a minimum length of 1 byte and a maximum length of 51,200 bytes. For more information, go to

    Template Anatomy][1

    in the CloudFormation User Guide.

    Conditional: You must specify either the `TemplateBody` or the `TemplateURL` parameter, but not both.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :template_url (String)

    Location of file containing the template body. The URL must point to a template (max size: 460,800 bytes) that is located in an Amazon S3 bucket or a Systems Manager document. For more information, go to the

    Template Anatomy][1

    in the CloudFormation User Guide.

    Conditional: You must specify either the `TemplateBody` or the `TemplateURL` parameter, but not both.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :parameters (Array<Types::Parameter>)

    A list of `Parameter` structures that specify input parameters for the stack. For more information, see the [Parameter] data type.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html

  • :disable_rollback (Boolean)

    Set to `true` to disable rollback of the stack if stack creation failed. You can specify either `DisableRollback` or `OnFailure`, but not both.

    Default: `false`

  • :rollback_configuration (Types::RollbackConfiguration)

    The rollback triggers for CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards.

  • :timeout_in_minutes (Integer)

    The amount of time that can pass before the stack status becomes CREATE_FAILED; if `DisableRollback` is not set or is set to `false`, the stack will be rolled back.

  • :notification_arns (Array<String>)

    The Simple Notification Service (SNS) topic ARNs to publish stack related events. You can find your SNS topic ARNs using the SNS console or your Command Line Interface (CLI).

  • :capabilities (Array<String>)

    In some cases, you must explicitly acknowledge that your stack template contains certain capabilities in order for CloudFormation to create the stack.

    • `CAPABILITY_IAM` and `CAPABILITY_NAMED_IAM`

      Some stack templates might include resources that can affect permissions in your Amazon Web Services account; for example, by creating new Identity and Access Management (IAM) users. For those stacks, you must explicitly acknowledge this by specifying one of these capabilities.

      The following IAM resources require you to specify either the `CAPABILITY_IAM` or `CAPABILITY_NAMED_IAM` capability.

      • If you have IAM resources, you can specify either capability.

      • If you have IAM resources with custom names, you must specify `CAPABILITY_NAMED_IAM`.

      • If you don't specify either of these capabilities, CloudFormation returns an `InsufficientCapabilities` error.

      If your stack template contains these resources, we recommend that you review all permissions associated with them and edit their permissions if necessary.

      • AWS::IAM::AccessKey][1
      • AWS::IAM::Group][2
      • AWS::IAM::InstanceProfile][3
      • AWS::IAM::Policy][4
      • AWS::IAM::Role][5
      • AWS::IAM::User][6
      • AWS::IAM::UserToGroupAddition][7

      For more information, see [Acknowledging IAM Resources in CloudFormation Templates].

    • `CAPABILITY_AUTO_EXPAND`

      Some template contain macros. Macros perform custom processing on templates; this can include simple actions like find-and-replace operations, all the way to extensive transformations of entire templates. Because of this, users typically create a change set from the processed template, so that they can review the changes resulting from the macros before actually creating the stack. If your stack template contains one or more macros, and you choose to create a stack directly from the processed template, without first reviewing the resulting changes in a change set, you must acknowledge this capability. This includes the [AWS::Include] and

      AWS::Serverless][10

      transforms, which are macros hosted by

      CloudFormation.

      If you want to create a stack from a stack template that contains macros and nested stacks, you must create the stack directly from the template using this capability.

      You should only create stacks directly from a stack template that contains macros if you know what processing the macro performs.

      Each macro relies on an underlying Lambda service function for
      

      processing stack templates. Be aware that the Lambda function owner can update the function operation without CloudFormation being notified.

      For more information, see [Using CloudFormation Macros to Perform Custom Processing on Templates].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html [3]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html [4]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html [5]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html [6]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html [7]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html [8]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities [9]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html [10]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html [11]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html

  • :resource_types (Array<String>)

    The template resource types that you have permissions to work with for this create stack action, such as `AWS::EC2::Instance`, `AWS::EC2::*`, or `Custom::MyCustomInstance`. Use the following syntax to describe template resource types: `AWS::*` (for all Amazon Web Services resources), `Custom::*` (for all custom resources), `Custom::logical_ID ` (for a specific custom resource), `AWS::service_name::*` (for all resources of a particular Amazon Web Services service), and `AWS::service_name::resource_logical_ID ` (for a specific Amazon Web Services resource).

    If the list of resource types doesn't include a resource that you're creating, the stack creation fails. By default, CloudFormation grants permissions to all resource types. Identity and Access Management (IAM) uses this parameter for CloudFormation-specific condition keys in IAM policies. For more information, see [Controlling Access with Identity and Access Management].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html

  • :role_arn (String)

    The Amazon Resource Name (ARN) of an Identity and Access Management (IAM) role that CloudFormation assumes to create the stack. CloudFormation uses the role's credentials to make calls on your behalf. CloudFormation always uses this role for all future operations on the stack. As long as users have permission to operate on the stack, CloudFormation uses this role even if the users don't have permission to pass it. Ensure that the role grants least privilege.

    If you don't specify a value, CloudFormation uses the role that was previously associated with the stack. If no role is available, CloudFormation uses a temporary session that is generated from your user credentials.

  • :on_failure (String)

    Determines what action will be taken if stack creation fails. This must be one of: DO_NOTHING, ROLLBACK, or DELETE. You can specify either `OnFailure` or `DisableRollback`, but not both.

    Default: `ROLLBACK`

  • :stack_policy_body (String)

    Structure containing the stack policy body. For more information, go to [ Prevent Updates to Stack Resources] in the *CloudFormation User Guide*. You can specify either the `StackPolicyBody` or the `StackPolicyURL` parameter, but not both.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/protect-stack-resources.html

  • :stack_policy_url (String)

    Location of a file containing the stack policy. The URL must point to a policy (maximum size: 16 KB) located in an S3 bucket in the same Region as the stack. You can specify either the `StackPolicyBody` or the `StackPolicyURL` parameter, but not both.

  • :tags (Array<Types::Tag>)

    Key-value pairs to associate with this stack. CloudFormation also propagates these tags to the resources created in the stack. A maximum number of 50 tags can be specified.

  • :client_request_token (String)

    A unique identifier for this `CreateStack` request. Specify this token if you plan to retry requests so that CloudFormation knows that you're not attempting to create a stack with the same name. You might retry `CreateStack` requests to ensure that CloudFormation successfully received them.

    All events triggered by a given stack operation are assigned the same client request token, which you can use to track operations. For example, if you execute a `CreateStack` operation with the token `token1`, then all the `StackEvents` generated by that operation will have `ClientRequestToken` set as `token1`.

    In the console, stack operations display the client request token on the Events tab. Stack operations that are initiated from the console use the token format Console-StackOperation-ID, which helps you easily identify the stack operation . For example, if you create a stack using the console, each stack event would be assigned the same token in the following format: `Console-CreateStack-7f59c3cf-00d2-40c7-b2ff-e75db0987002`.

  • :enable_termination_protection (Boolean)

    Whether to enable termination protection on the specified stack. If a user attempts to delete a stack with termination protection enabled, the operation fails and the stack remains unchanged. For more information, see [Protecting a Stack From Being Deleted] in the *CloudFormation User Guide*. Termination protection is disabled on stacks by default.

    For [nested stacks], termination protection is set on the root stack and cannot be changed directly on the nested stack.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html

Returns:

See Also:


1308
1309
1310
1311
# File 'lib/aws-sdk-cloudformation/client.rb', line 1308

def create_stack(params = {}, options = {})
  req = build_request(:create_stack, params)
  req.send_request(options)
end

#create_stack_instances(params = {}) ⇒ Types::CreateStackInstancesOutput

Creates stack instances for the specified accounts, within the specified Regions. A stack instance refers to a stack in a specific account and Region. You must specify at least one value for either `Accounts` or `DeploymentTargets`, and you must specify at least one value for `Regions`.

Examples:

Request syntax with placeholder values


resp = client.create_stack_instances({
  stack_set_name: "StackSetName", # required
  accounts: ["Account"],
  deployment_targets: {
    accounts: ["Account"],
    accounts_url: "AccountsUrl",
    organizational_unit_ids: ["OrganizationalUnitId"],
  },
  regions: ["Region"], # required
  parameter_overrides: [
    {
      parameter_key: "ParameterKey",
      parameter_value: "ParameterValue",
      use_previous_value: false,
      resolved_value: "ParameterValue",
    },
  ],
  operation_preferences: {
    region_concurrency_type: "SEQUENTIAL", # accepts SEQUENTIAL, PARALLEL
    region_order: ["Region"],
    failure_tolerance_count: 1,
    failure_tolerance_percentage: 1,
    max_concurrent_count: 1,
    max_concurrent_percentage: 1,
  },
  operation_id: "ClientRequestToken",
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.operation_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set that you want to create stack instances from.

  • :accounts (Array<String>)

    [Self-managed permissions] The names of one or more Amazon Web Services accounts that you want to create stack instances in the specified Region(s) for.

    You can specify `Accounts` or `DeploymentTargets`, but not both.

  • :deployment_targets (Types::DeploymentTargets)

    [Service-managed permissions] The Organizations accounts for which to create stack instances in the specified Regions.

    You can specify `Accounts` or `DeploymentTargets`, but not both.

  • :regions (required, Array<String>)

    The names of one or more Regions where you want to create stack instances using the specified Amazon Web Services accounts.

  • :parameter_overrides (Array<Types::Parameter>)

    A list of stack set parameters whose values you want to override in the selected stack instances.

    Any overridden parameter values will be applied to all stack instances in the specified accounts and Regions. When specifying parameters and their values, be aware of how CloudFormation sets parameter values during stack instance operations:

    • To override the current value for a parameter, include the parameter and specify its value.

    • To leave an overridden parameter set to its present value, include the parameter and specify `UsePreviousValue` as `true`. (You cannot specify both a value and set `UsePreviousValue` to `true`.)

    • To set an overridden parameter back to the value specified in the stack set, specify a parameter list but do not include the parameter in the list.

    • To leave all parameters set to their present values, do not specify this property at all.

    During stack set updates, any parameter values overridden for a stack instance are not updated, but retain their overridden value.

    You can only override the parameter values that are specified in the stack set; to add or delete a parameter itself, use

    UpdateStackSet][1

    to update the stack set template.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html

  • :operation_preferences (Types::StackSetOperationPreferences)

    Preferences for how CloudFormation performs this stack set operation.

  • :operation_id (String)

    The unique identifier for this stack set operation.

    The operation ID also functions as an idempotency token, to ensure that CloudFormation performs the stack set operation only once, even if you retry the request multiple times. You might retry stack set operation requests to ensure that CloudFormation successfully received them.

    If you don't specify an operation ID, the SDK generates one automatically.

    Repeating this stack set operation with a new operation ID retries all stack instances whose status is `OUTDATED`.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


1460
1461
1462
1463
# File 'lib/aws-sdk-cloudformation/client.rb', line 1460

def create_stack_instances(params = {}, options = {})
  req = build_request(:create_stack_instances, params)
  req.send_request(options)
end

#create_stack_set(params = {}) ⇒ Types::CreateStackSetOutput

Creates a stack set.

Examples:

Request syntax with placeholder values


resp = client.create_stack_set({
  stack_set_name: "StackSetName", # required
  description: "Description",
  template_body: "TemplateBody",
  template_url: "TemplateURL",
  stack_id: "StackId",
  parameters: [
    {
      parameter_key: "ParameterKey",
      parameter_value: "ParameterValue",
      use_previous_value: false,
      resolved_value: "ParameterValue",
    },
  ],
  capabilities: ["CAPABILITY_IAM"], # accepts CAPABILITY_IAM, CAPABILITY_NAMED_IAM, CAPABILITY_AUTO_EXPAND
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  administration_role_arn: "RoleARN",
  execution_role_name: "ExecutionRoleName",
  permission_model: "SERVICE_MANAGED", # accepts SERVICE_MANAGED, SELF_MANAGED
  auto_deployment: {
    enabled: false,
    retain_stacks_on_account_removal: false,
  },
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
  client_request_token: "ClientRequestToken",
  managed_execution: {
    active: false,
  },
})

Response structure


resp.stack_set_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name to associate with the stack set. The name must be unique in the Region where you create your stack set.

    <note markdown=“1”> A stack name can contain only alphanumeric characters (case-sensitive) and hyphens. It must start with an alphabetic character and can't be longer than 128 characters.

    </note>
    
  • :description (String)

    A description of the stack set. You can use the description to identify the stack set's purpose or other important information.

  • :template_body (String)

    The structure that contains the template body, with a minimum length of 1 byte and a maximum length of 51,200 bytes. For more information, see [Template Anatomy] in the CloudFormation User Guide.

    Conditional: You must specify either the TemplateBody or the TemplateURL parameter, but not both.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :template_url (String)

    The location of the file that contains the template body. The URL must point to a template (maximum size: 460,800 bytes) that's located in an Amazon S3 bucket or a Systems Manager document. For more information, see [Template Anatomy] in the CloudFormation User Guide.

    Conditional: You must specify either the TemplateBody or the TemplateURL parameter, but not both.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :stack_id (String)

    The stack ID you are importing into a new stack set. Specify the Amazon Resource Number (ARN) of the stack.

  • :parameters (Array<Types::Parameter>)

    The input parameters for the stack set template.

  • :capabilities (Array<String>)

    In some cases, you must explicitly acknowledge that your stack set template contains certain capabilities in order for CloudFormation to create the stack set and related stack instances.

    • `CAPABILITY_IAM` and `CAPABILITY_NAMED_IAM`

      Some stack templates might include resources that can affect permissions in your Amazon Web Services account; for example, by creating new Identity and Access Management (IAM) users. For those stack sets, you must explicitly acknowledge this by specifying one of these capabilities.

      The following IAM resources require you to specify either the `CAPABILITY_IAM` or `CAPABILITY_NAMED_IAM` capability.

      • If you have IAM resources, you can specify either capability.

      • If you have IAM resources with custom names, you must specify `CAPABILITY_NAMED_IAM`.

      • If you don't specify either of these capabilities, CloudFormation returns an `InsufficientCapabilities` error.

      If your stack template contains these resources, we recommend that you review all permissions associated with them and edit their permissions if necessary.

      • AWS::IAM::AccessKey][1
      • AWS::IAM::Group][2
      • AWS::IAM::InstanceProfile][3
      • AWS::IAM::Policy][4
      • AWS::IAM::Role][5
      • AWS::IAM::User][6
      • AWS::IAM::UserToGroupAddition][7

      For more information, see [Acknowledging IAM Resources in CloudFormation Templates].

    • `CAPABILITY_AUTO_EXPAND`

      Some templates reference macros. If your stack set template references one or more macros, you must create the stack set directly from the processed template, without first reviewing the resulting changes in a change set. To create the stack set directly, you must acknowledge this capability. For more information, see [Using CloudFormation Macros to Perform Custom Processing on Templates].

      Stack sets with service-managed permissions do not currently support the use of macros in templates. (This includes the

      AWS::Include][10

      and [AWS::Serverless] transforms, which are

      macros hosted by CloudFormation.) Even if you specify this capability for a stack set with service-managed permissions, if you reference a macro in your template the stack set operation will fail.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html [3]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html [4]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html [5]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html [6]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html [7]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html [8]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities [9]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html [10]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html [11]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html

  • :tags (Array<Types::Tag>)

    The key-value pairs to associate with this stack set and the stacks created from it. CloudFormation also propagates these tags to supported resources that are created in the stacks. A maximum number of 50 tags can be specified.

    If you specify tags as part of a `CreateStackSet` action, CloudFormation checks to see if you have the required IAM permission to tag resources. If you don't, the entire `CreateStackSet` action fails with an `access denied` error, and the stack set is not created.

  • :administration_role_arn (String)

    The Amazon Resource Number (ARN) of the IAM role to use to create this stack set.

    Specify an IAM role only if you are using customized administrator roles to control which users or groups can manage specific stack sets within the same administrator account. For more information, see

    Prerequisites: Granting Permissions for Stack Set Operations][1

    in

    the *CloudFormation User Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs.html

  • :execution_role_name (String)

    The name of the IAM execution role to use to create the stack set. If you do not specify an execution role, CloudFormation uses the `AWSCloudFormationStackSetExecutionRole` role for the stack set operation.

    Specify an IAM role only if you are using customized execution roles to control which stack resources users and groups can include in their stack sets.

  • :permission_model (String)

    Describes how the IAM roles required for stack set operations are created. By default, `SELF-MANAGED` is specified.

    • With `self-managed` permissions, you must create the administrator and execution roles required to deploy to target accounts. For more information, see [Grant Self-Managed Stack Set Permissions].

    • With `service-managed` permissions, StackSets automatically creates the IAM roles required to deploy to accounts managed by Organizations. For more information, see [Grant Service-Managed Stack Set Permissions].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-service-managed.html

  • :auto_deployment (Types::AutoDeployment)

    Describes whether StackSets automatically deploys to Organizations accounts that are added to the target organization or organizational unit (OU). Specify only if `PermissionModel` is `SERVICE_MANAGED`.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • To create a stack set with service-managed permissions while signed in to the management account, specify `SELF`.

    • To create a stack set with service-managed permissions while signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated admin in the management account. For more information, see [Register a delegated administrator] in the *CloudFormation User Guide*.

    Stack sets with service-managed permissions are created in the management account, including stack sets that are created by delegated administrators.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

  • :client_request_token (String)

    A unique identifier for this `CreateStackSet` request. Specify this token if you plan to retry requests so that CloudFormation knows that you're not attempting to create another stack set with the same name. You might retry `CreateStackSet` requests to ensure that CloudFormation successfully received them.

    If you don't specify an operation ID, the SDK generates one automatically.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :managed_execution (Types::ManagedExecution)

    Describes whether StackSets performs non-conflicting operations concurrently and queues conflicting operations.

Returns:

See Also:


1741
1742
1743
1744
# File 'lib/aws-sdk-cloudformation/client.rb', line 1741

def create_stack_set(params = {}, options = {})
  req = build_request(:create_stack_set, params)
  req.send_request(options)
end

#deactivate_type(params = {}) ⇒ Struct

Deactivates a public extension that was previously activated in this account and region.

Once deactivated, an extension cannot be used in any CloudFormation operation. This includes stack update operations where the stack template includes the extension, even if no updates are being made to the extension. In addition, deactivated extensions are not automatically updated if a new version of the extension is released.

Examples:

Request syntax with placeholder values


resp = client.deactivate_type({
  type_name: "TypeName",
  type: "RESOURCE", # accepts RESOURCE, MODULE
  arn: "PrivateTypeArn",
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :type_name (String)

    The type name of the extension, in this account and region. If you specified a type name alias when enabling the extension, use the type name alias.

    Conditional: You must specify either `Arn`, or `TypeName` and `Type`.

  • :type (String)

    The extension type.

    Conditional: You must specify either `Arn`, or `TypeName` and `Type`.

  • :arn (String)

    The Amazon Resource Name (ARN) for the extension, in this account and region.

    Conditional: You must specify either `Arn`, or `TypeName` and `Type`.

Returns:

  • (Struct)

    Returns an empty response.

See Also:


1787
1788
1789
1790
# File 'lib/aws-sdk-cloudformation/client.rb', line 1787

def deactivate_type(params = {}, options = {})
  req = build_request(:deactivate_type, params)
  req.send_request(options)
end

#delete_change_set(params = {}) ⇒ Struct

Deletes the specified change set. Deleting change sets ensures that no one executes the wrong change set.

If the call successfully completes, CloudFormation successfully deleted the change set.

If `IncludeNestedStacks` specifies `True` during the creation of the nested change set, then `DeleteChangeSet` will delete all change sets that belong to the stacks hierarchy and will also delete all change sets for nested stacks with the status of `REVIEW_IN_PROGRESS`.

Examples:

Request syntax with placeholder values


resp = client.delete_change_set({
  change_set_name: "ChangeSetNameOrId", # required
  stack_name: "StackNameOrId",
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :change_set_name (required, String)

    The name or Amazon Resource Name (ARN) of the change set that you want to delete.

  • :stack_name (String)

    If you specified the name of a change set to delete, specify the stack name or ID (ARN) that is associated with it.

Returns:

  • (Struct)

    Returns an empty response.

See Also:


1824
1825
1826
1827
# File 'lib/aws-sdk-cloudformation/client.rb', line 1824

def delete_change_set(params = {}, options = {})
  req = build_request(:delete_change_set, params)
  req.send_request(options)
end

#delete_stack(params = {}) ⇒ Struct

Deletes a specified stack. Once the call completes successfully, stack deletion starts. Deleted stacks do not show up in the DescribeStacks API if the deletion has been completed successfully.

Examples:

Request syntax with placeholder values


resp = client.delete_stack({
  stack_name: "StackName", # required
  retain_resources: ["LogicalResourceId"],
  role_arn: "RoleARN",
  client_request_token: "ClientRequestToken",
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or the unique stack ID that is associated with the stack.

  • :retain_resources (Array<String>)

    For stacks in the `DELETE_FAILED` state, a list of resource logical IDs that are associated with the resources you want to retain. During deletion, CloudFormation deletes the stack but does not delete the retained resources.

    Retaining resources is useful when you cannot delete a resource, such as a non-empty S3 bucket, but you want to delete the stack.

  • :role_arn (String)

    The Amazon Resource Name (ARN) of an Identity and Access Management (IAM) role that CloudFormation assumes to delete the stack. CloudFormation uses the role's credentials to make calls on your behalf.

    If you don't specify a value, CloudFormation uses the role that was previously associated with the stack. If no role is available, CloudFormation uses a temporary session that is generated from your user credentials.

  • :client_request_token (String)

    A unique identifier for this `DeleteStack` request. Specify this token if you plan to retry requests so that CloudFormation knows that you're not attempting to delete a stack with the same name. You might retry `DeleteStack` requests to ensure that CloudFormation successfully received them.

    All events triggered by a given stack operation are assigned the same client request token, which you can use to track operations. For example, if you execute a `CreateStack` operation with the token `token1`, then all the `StackEvents` generated by that operation will have `ClientRequestToken` set as `token1`.

    In the console, stack operations display the client request token on the Events tab. Stack operations that are initiated from the console use the token format Console-StackOperation-ID, which helps you easily identify the stack operation . For example, if you create a stack using the console, each stack event would be assigned the same token in the following format: `Console-CreateStack-7f59c3cf-00d2-40c7-b2ff-e75db0987002`.

Returns:

  • (Struct)

    Returns an empty response.

See Also:


1892
1893
1894
1895
# File 'lib/aws-sdk-cloudformation/client.rb', line 1892

def delete_stack(params = {}, options = {})
  req = build_request(:delete_stack, params)
  req.send_request(options)
end

#delete_stack_instances(params = {}) ⇒ Types::DeleteStackInstancesOutput

Deletes stack instances for the specified accounts, in the specified Regions.

Examples:

Request syntax with placeholder values


resp = client.delete_stack_instances({
  stack_set_name: "StackSetName", # required
  accounts: ["Account"],
  deployment_targets: {
    accounts: ["Account"],
    accounts_url: "AccountsUrl",
    organizational_unit_ids: ["OrganizationalUnitId"],
  },
  regions: ["Region"], # required
  operation_preferences: {
    region_concurrency_type: "SEQUENTIAL", # accepts SEQUENTIAL, PARALLEL
    region_order: ["Region"],
    failure_tolerance_count: 1,
    failure_tolerance_percentage: 1,
    max_concurrent_count: 1,
    max_concurrent_percentage: 1,
  },
  retain_stacks: false, # required
  operation_id: "ClientRequestToken",
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.operation_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set that you want to delete stack instances for.

  • :accounts (Array<String>)

    [Self-managed permissions] The names of the Amazon Web Services accounts that you want to delete stack instances for.

    You can specify `Accounts` or `DeploymentTargets`, but not both.

  • :deployment_targets (Types::DeploymentTargets)

    [Service-managed permissions] The Organizations accounts from which to delete stack instances.

    You can specify `Accounts` or `DeploymentTargets`, but not both.

  • :regions (required, Array<String>)

    The Regions where you want to delete stack set instances.

  • :operation_preferences (Types::StackSetOperationPreferences)

    Preferences for how CloudFormation performs this stack set operation.

  • :retain_stacks (required, Boolean)

    Removes the stack instances from the specified stack set, but doesn't delete the stacks. You can't reassociate a retained stack or add an existing, saved stack to a new stack set.

    For more information, see [Stack set operation options].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html#stackset-ops-options

  • :operation_id (String)

    The unique identifier for this stack set operation.

    If you don't specify an operation ID, the SDK generates one automatically.

    The operation ID also functions as an idempotency token, to ensure that CloudFormation performs the stack set operation only once, even if you retry the request multiple times. You can retry stack set operation requests to ensure that CloudFormation successfully received them.

    Repeating this stack set operation with a new operation ID retries all stack instances whose status is `OUTDATED`.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


2009
2010
2011
2012
# File 'lib/aws-sdk-cloudformation/client.rb', line 2009

def delete_stack_instances(params = {}, options = {})
  req = build_request(:delete_stack_instances, params)
  req.send_request(options)
end

#delete_stack_set(params = {}) ⇒ Struct

Deletes a stack set. Before you can delete a stack set, all of its member stack instances must be deleted. For more information about how to do this, see DeleteStackInstances.

Examples:

Request syntax with placeholder values


resp = client.delete_stack_set({
  stack_set_name: "StackSetName", # required
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set that you're deleting. You can obtain this value by running ListStackSets.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

  • (Struct)

    Returns an empty response.

See Also:


2057
2058
2059
2060
# File 'lib/aws-sdk-cloudformation/client.rb', line 2057

def delete_stack_set(params = {}, options = {})
  req = build_request(:delete_stack_set, params)
  req.send_request(options)
end

#deregister_type(params = {}) ⇒ Struct

Marks an extension or extension version as `DEPRECATED` in the CloudFormation registry, removing it from active use. Deprecated extensions or extension versions cannot be used in CloudFormation operations.

To deregister an entire extension, you must individually deregister all active versions of that extension. If an extension has only a single active version, deregistering that version results in the extension itself being deregistered and marked as deprecated in the registry.

You cannot deregister the default version of an extension if there are other active version of that extension. If you do deregister the default version of an extension, the textensionype itself is deregistered as well and marked as deprecated.

To view the deprecation status of an extension or extension version, use [DescribeType].

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeType.html

Examples:

Request syntax with placeholder values


resp = client.deregister_type({
  arn: "PrivateTypeArn",
  type: "RESOURCE", # accepts RESOURCE, MODULE
  type_name: "TypeName",
  version_id: "TypeVersionId",
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :arn (String)

    The Amazon Resource Name (ARN) of the extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :type (String)

    The kind of extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :type_name (String)

    The name of the extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :version_id (String)

    The ID of a specific version of the extension. The version ID is the value at the end of the Amazon Resource Name (ARN) assigned to the extension version when it is registered.

Returns:

  • (Struct)

    Returns an empty response.

See Also:


2120
2121
2122
2123
# File 'lib/aws-sdk-cloudformation/client.rb', line 2120

def deregister_type(params = {}, options = {})
  req = build_request(:deregister_type, params)
  req.send_request(options)
end

#describe_account_limits(params = {}) ⇒ Types::DescribeAccountLimitsOutput

Retrieves your account's CloudFormation limits, such as the maximum number of stacks that you can create in your account. For more information about account limits, see [CloudFormation Limits] in the *CloudFormation User Guide*.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.({
  next_token: "NextToken",
})

Response structure


resp. #=> Array
resp.[0].name #=> String
resp.[0].value #=> Integer
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :next_token (String)

    A string that identifies the next page of limits that you want to retrieve.

Returns:

See Also:


2162
2163
2164
2165
# File 'lib/aws-sdk-cloudformation/client.rb', line 2162

def (params = {}, options = {})
  req = build_request(:describe_account_limits, params)
  req.send_request(options)
end

#describe_change_set(params = {}) ⇒ Types::DescribeChangeSetOutput

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.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html

The following waiters are defined for this operation (see #wait_until for detailed usage):

* change_set_create_complete

Examples:

Request syntax with placeholder values


resp = client.describe_change_set({
  change_set_name: "ChangeSetNameOrId", # required
  stack_name: "StackNameOrId",
  next_token: "NextToken",
})

Response structure


resp.change_set_name #=> String
resp.change_set_id #=> String
resp.stack_id #=> String
resp.stack_name #=> String
resp.description #=> String
resp.parameters #=> Array
resp.parameters[0].parameter_key #=> String
resp.parameters[0].parameter_value #=> String
resp.parameters[0].use_previous_value #=> Boolean
resp.parameters[0].resolved_value #=> String
resp.creation_time #=> Time
resp.execution_status #=> String, one of "UNAVAILABLE", "AVAILABLE", "EXECUTE_IN_PROGRESS", "EXECUTE_COMPLETE", "EXECUTE_FAILED", "OBSOLETE"
resp.status #=> String, one of "CREATE_PENDING", "CREATE_IN_PROGRESS", "CREATE_COMPLETE", "DELETE_PENDING", "DELETE_IN_PROGRESS", "DELETE_COMPLETE", "DELETE_FAILED", "FAILED"
resp.status_reason #=> String
resp.notification_arns #=> Array
resp.notification_arns[0] #=> String
resp.rollback_configuration.rollback_triggers #=> Array
resp.rollback_configuration.rollback_triggers[0].arn #=> String
resp.rollback_configuration.rollback_triggers[0].type #=> String
resp.rollback_configuration.monitoring_time_in_minutes #=> Integer
resp.capabilities #=> Array
resp.capabilities[0] #=> String, one of "CAPABILITY_IAM", "CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"
resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String
resp.changes #=> Array
resp.changes[0].type #=> String, one of "Resource"
resp.changes[0].resource_change.action #=> String, one of "Add", "Modify", "Remove", "Import", "Dynamic"
resp.changes[0].resource_change.logical_resource_id #=> String
resp.changes[0].resource_change.physical_resource_id #=> String
resp.changes[0].resource_change.resource_type #=> String
resp.changes[0].resource_change.replacement #=> String, one of "True", "False", "Conditional"
resp.changes[0].resource_change.scope #=> Array
resp.changes[0].resource_change.scope[0] #=> String, one of "Properties", "Metadata", "CreationPolicy", "UpdatePolicy", "DeletionPolicy", "Tags"
resp.changes[0].resource_change.details #=> Array
resp.changes[0].resource_change.details[0].target.attribute #=> String, one of "Properties", "Metadata", "CreationPolicy", "UpdatePolicy", "DeletionPolicy", "Tags"
resp.changes[0].resource_change.details[0].target.name #=> String
resp.changes[0].resource_change.details[0].target.requires_recreation #=> String, one of "Never", "Conditionally", "Always"
resp.changes[0].resource_change.details[0].evaluation #=> String, one of "Static", "Dynamic"
resp.changes[0].resource_change.details[0].change_source #=> String, one of "ResourceReference", "ParameterReference", "ResourceAttribute", "DirectModification", "Automatic"
resp.changes[0].resource_change.details[0].causing_entity #=> String
resp.changes[0].resource_change.change_set_id #=> String
resp.changes[0].resource_change.module_info.type_hierarchy #=> String
resp.changes[0].resource_change.module_info.logical_id_hierarchy #=> String
resp.next_token #=> String
resp.include_nested_stacks #=> Boolean
resp.parent_change_set_id #=> String
resp.root_change_set_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :change_set_name (required, String)

    The name or Amazon Resource Name (ARN) of the change set that you want to describe.

  • :stack_name (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.

  • :next_token (String)

    A string (provided by the DescribeChangeSet response output) that identifies the next page of information that you want to retrieve.

Returns:

See Also:


2278
2279
2280
2281
# File 'lib/aws-sdk-cloudformation/client.rb', line 2278

def describe_change_set(params = {}, options = {})
  req = build_request(:describe_change_set, params)
  req.send_request(options)
end

#describe_publisher(params = {}) ⇒ Types::DescribePublisherOutput

Returns information about a CloudFormation extension publisher.

If you do not supply a `PublisherId`, and you have registered as an extension publisher, `DescribePublisher` returns information about your own publisher account.

For more information on registering as a publisher, see:

  • RegisterPublisher][1
  • Publishing extensions to make them available for public use][2

    in

    the *CloudFormation CLI User Guide*

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_RegisterPublisher.html [2]: docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html

Examples:

Request syntax with placeholder values


resp = client.describe_publisher({
  publisher_id: "PublisherId",
})

Response structure


resp.publisher_id #=> String
resp.publisher_status #=> String, one of "VERIFIED", "UNVERIFIED"
resp.identity_provider #=> String, one of "AWS_Marketplace", "GitHub", "Bitbucket"
resp.publisher_profile #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :publisher_id (String)

    The ID of the extension publisher.

    If you do not supply a `PublisherId`, and you have registered as an extension publisher, `DescribePublisher` returns information about your own publisher account.

Returns:

See Also:


2332
2333
2334
2335
# File 'lib/aws-sdk-cloudformation/client.rb', line 2332

def describe_publisher(params = {}, options = {})
  req = build_request(:describe_publisher, params)
  req.send_request(options)
end

#describe_stack_drift_detection_status(params = {}) ⇒ Types::DescribeStackDriftDetectionStatusOutput

Returns information about a stack drift detection operation. A stack drift detection operation detects whether a stack's actual configuration differs, or has drifted, from it's expected configuration, as defined in the stack template and any values specified as template parameters. A stack is considered to have drifted if one or more of its resources have drifted. For more information on stack and resource drift, see [Detecting Unregulated Configuration Changes to Stacks and Resources].

Use DetectStackDrift to initiate a stack drift detection operation. `DetectStackDrift` returns a `StackDriftDetectionId` you can use to monitor the progress of the operation using `DescribeStackDriftDetectionStatus`. Once the drift detection operation has completed, use DescribeStackResourceDrifts to return drift information about the stack and its resources.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html

Examples:

Request syntax with placeholder values


resp = client.describe_stack_drift_detection_status({
  stack_drift_detection_id: "StackDriftDetectionId", # required
})

Response structure


resp.stack_id #=> String
resp.stack_drift_detection_id #=> String
resp.stack_drift_status #=> String, one of "DRIFTED", "IN_SYNC", "UNKNOWN", "NOT_CHECKED"
resp.detection_status #=> String, one of "DETECTION_IN_PROGRESS", "DETECTION_FAILED", "DETECTION_COMPLETE"
resp.detection_status_reason #=> String
resp.drifted_stack_resource_count #=> Integer
resp.timestamp #=> Time

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_drift_detection_id (required, String)

    The ID of the drift detection results of this operation.

    CloudFormation generates new results, with a new drift detection ID, each time this operation is run. However, the number of drift results CloudFormation retains for any given stack, and for how long, may vary.

Returns:

See Also:


2395
2396
2397
2398
# File 'lib/aws-sdk-cloudformation/client.rb', line 2395

def describe_stack_drift_detection_status(params = {}, options = {})
  req = build_request(:describe_stack_drift_detection_status, params)
  req.send_request(options)
end

#describe_stack_events(params = {}) ⇒ Types::DescribeStackEventsOutput

Returns all stack related events for a specified stack in reverse chronological order. For more information about a stack's event history, go to [Stacks] in the CloudFormation User Guide.

<note markdown=“1”> You can list events for stacks that have failed to create or have been deleted by specifying the unique stack identifier (stack ID).

</note>

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/concept-stack.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.describe_stack_events({
  stack_name: "StackName",
  next_token: "NextToken",
})

Response structure


resp.stack_events #=> Array
resp.stack_events[0].stack_id #=> String
resp.stack_events[0].event_id #=> String
resp.stack_events[0].stack_name #=> String
resp.stack_events[0].logical_resource_id #=> String
resp.stack_events[0].physical_resource_id #=> String
resp.stack_events[0].resource_type #=> String
resp.stack_events[0].timestamp #=> Time
resp.stack_events[0].resource_status #=> String, one of "CREATE_IN_PROGRESS", "CREATE_FAILED", "CREATE_COMPLETE", "DELETE_IN_PROGRESS", "DELETE_FAILED", "DELETE_COMPLETE", "DELETE_SKIPPED", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_COMPLETE", "IMPORT_FAILED", "IMPORT_COMPLETE", "IMPORT_IN_PROGRESS", "IMPORT_ROLLBACK_IN_PROGRESS", "IMPORT_ROLLBACK_FAILED", "IMPORT_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED", "ROLLBACK_IN_PROGRESS", "ROLLBACK_COMPLETE", "ROLLBACK_FAILED"
resp.stack_events[0].resource_status_reason #=> String
resp.stack_events[0].resource_properties #=> String
resp.stack_events[0].client_request_token #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (String)

    The name or the unique stack ID that is associated with the stack, which are not always interchangeable:

    • Running stacks: You can specify either the stack's name or its unique stack ID.

    • Deleted stacks: You must specify the unique stack ID.

    Default: There is no default value.

  • :next_token (String)

    A string that identifies the next page of events that you want to retrieve.

Returns:

See Also:


2462
2463
2464
2465
# File 'lib/aws-sdk-cloudformation/client.rb', line 2462

def describe_stack_events(params = {}, options = {})
  req = build_request(:describe_stack_events, params)
  req.send_request(options)
end

#describe_stack_instance(params = {}) ⇒ Types::DescribeStackInstanceOutput

Returns the stack instance that's associated with the specified stack set, Amazon Web Services account, and Region.

For a list of stack instances that are associated with a specific stack set, use ListStackInstances.

Examples:

Request syntax with placeholder values


resp = client.describe_stack_instance({
  stack_set_name: "StackSetName", # required
  stack_instance_account: "Account", # required
  stack_instance_region: "Region", # required
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.stack_instance.stack_set_id #=> String
resp.stack_instance.region #=> String
resp.stack_instance. #=> String
resp.stack_instance.stack_id #=> String
resp.stack_instance.parameter_overrides #=> Array
resp.stack_instance.parameter_overrides[0].parameter_key #=> String
resp.stack_instance.parameter_overrides[0].parameter_value #=> String
resp.stack_instance.parameter_overrides[0].use_previous_value #=> Boolean
resp.stack_instance.parameter_overrides[0].resolved_value #=> String
resp.stack_instance.status #=> String, one of "CURRENT", "OUTDATED", "INOPERABLE"
resp.stack_instance.stack_instance_status.detailed_status #=> String, one of "PENDING", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "INOPERABLE"
resp.stack_instance.status_reason #=> String
resp.stack_instance.organizational_unit_id #=> String
resp.stack_instance.drift_status #=> String, one of "DRIFTED", "IN_SYNC", "UNKNOWN", "NOT_CHECKED"
resp.stack_instance.last_drift_check_timestamp #=> Time

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or the unique stack ID of the stack set that you want to get stack instance information for.

  • :stack_instance_account (required, String)

    The ID of an Amazon Web Services account that's associated with this stack instance.

  • :stack_instance_region (required, String)

    The name of a Region that's associated with this stack instance.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


2541
2542
2543
2544
# File 'lib/aws-sdk-cloudformation/client.rb', line 2541

def describe_stack_instance(params = {}, options = {})
  req = build_request(:describe_stack_instance, params)
  req.send_request(options)
end

#describe_stack_resource(params = {}) ⇒ Types::DescribeStackResourceOutput

Returns a description of the specified resource in the specified stack.

For deleted stacks, DescribeStackResource returns resource information for up to 90 days after the stack has been deleted.

Examples:

Request syntax with placeholder values


resp = client.describe_stack_resource({
  stack_name: "StackName", # required
  logical_resource_id: "LogicalResourceId", # required
})

Response structure


resp.stack_resource_detail.stack_name #=> String
resp.stack_resource_detail.stack_id #=> String
resp.stack_resource_detail.logical_resource_id #=> String
resp.stack_resource_detail.physical_resource_id #=> String
resp.stack_resource_detail.resource_type #=> String
resp.stack_resource_detail.last_updated_timestamp #=> Time
resp.stack_resource_detail.resource_status #=> String, one of "CREATE_IN_PROGRESS", "CREATE_FAILED", "CREATE_COMPLETE", "DELETE_IN_PROGRESS", "DELETE_FAILED", "DELETE_COMPLETE", "DELETE_SKIPPED", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_COMPLETE", "IMPORT_FAILED", "IMPORT_COMPLETE", "IMPORT_IN_PROGRESS", "IMPORT_ROLLBACK_IN_PROGRESS", "IMPORT_ROLLBACK_FAILED", "IMPORT_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED", "ROLLBACK_IN_PROGRESS", "ROLLBACK_COMPLETE", "ROLLBACK_FAILED"
resp.stack_resource_detail.resource_status_reason #=> String
resp.stack_resource_detail.description #=> String
resp.stack_resource_detail. #=> String
resp.stack_resource_detail.drift_information.stack_resource_drift_status #=> String, one of "IN_SYNC", "MODIFIED", "DELETED", "NOT_CHECKED"
resp.stack_resource_detail.drift_information.last_check_timestamp #=> Time
resp.stack_resource_detail.module_info.type_hierarchy #=> String
resp.stack_resource_detail.module_info.logical_id_hierarchy #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or the unique stack ID that is associated with the stack, which are not always interchangeable:

    • Running stacks: You can specify either the stack's name or its unique stack ID.

    • Deleted stacks: You must specify the unique stack ID.

    Default: There is no default value.

  • :logical_resource_id (required, String)

    The logical name of the resource as specified in the template.

    Default: There is no default value.

Returns:

See Also:


2600
2601
2602
2603
# File 'lib/aws-sdk-cloudformation/client.rb', line 2600

def describe_stack_resource(params = {}, options = {})
  req = build_request(:describe_stack_resource, params)
  req.send_request(options)
end

#describe_stack_resource_drifts(params = {}) ⇒ Types::DescribeStackResourceDriftsOutput

Returns drift information for the resources that have been checked for drift in the specified stack. This includes actual and expected configuration values for resources where CloudFormation detects configuration drift.

For a given stack, there will be one `StackResourceDrift` for each stack resource that has been checked for drift. Resources that haven't yet been checked for drift are not included. Resources that do not currently support drift detection are not checked, and so not included. For a list of resources that support drift detection, see [Resources that Support Drift Detection].

Use DetectStackResourceDrift to detect drift on individual resources, or DetectStackDrift to detect drift on all supported resources for a given stack.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift-resource-list.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.describe_stack_resource_drifts({
  stack_name: "StackNameOrId", # required
  stack_resource_drift_status_filters: ["IN_SYNC"], # accepts IN_SYNC, MODIFIED, DELETED, NOT_CHECKED
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.stack_resource_drifts #=> Array
resp.stack_resource_drifts[0].stack_id #=> String
resp.stack_resource_drifts[0].logical_resource_id #=> String
resp.stack_resource_drifts[0].physical_resource_id #=> String
resp.stack_resource_drifts[0].physical_resource_id_context #=> Array
resp.stack_resource_drifts[0].physical_resource_id_context[0].key #=> String
resp.stack_resource_drifts[0].physical_resource_id_context[0].value #=> String
resp.stack_resource_drifts[0].resource_type #=> String
resp.stack_resource_drifts[0].expected_properties #=> String
resp.stack_resource_drifts[0].actual_properties #=> String
resp.stack_resource_drifts[0].property_differences #=> Array
resp.stack_resource_drifts[0].property_differences[0].property_path #=> String
resp.stack_resource_drifts[0].property_differences[0].expected_value #=> String
resp.stack_resource_drifts[0].property_differences[0].actual_value #=> String
resp.stack_resource_drifts[0].property_differences[0].difference_type #=> String, one of "ADD", "REMOVE", "NOT_EQUAL"
resp.stack_resource_drifts[0].stack_resource_drift_status #=> String, one of "IN_SYNC", "MODIFIED", "DELETED", "NOT_CHECKED"
resp.stack_resource_drifts[0].timestamp #=> Time
resp.stack_resource_drifts[0].module_info.type_hierarchy #=> String
resp.stack_resource_drifts[0].module_info.logical_id_hierarchy #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name of the stack for which you want drift information.

  • :stack_resource_drift_status_filters (Array<String>)

    The resource drift status values to use as filters for the resource drift results returned.

    • `DELETED`: The resource differs from its expected template configuration in that the resource has been deleted.

    • `MODIFIED`: One or more resource properties differ from their expected template values.

    • `IN_SYNC`: The resources's actual configuration matches its expected template configuration.

    • `NOT_CHECKED`: CloudFormation does not currently return this value.

  • :next_token (String)

    A string that identifies the next page of stack resource drift results.

  • :max_results (Integer)

    The maximum number of results to be returned with a single call. If the number of available results exceeds this maximum, the response includes a `NextToken` value that you can assign to the `NextToken` request parameter to get the next set of results.

Returns:

See Also:


2696
2697
2698
2699
# File 'lib/aws-sdk-cloudformation/client.rb', line 2696

def describe_stack_resource_drifts(params = {}, options = {})
  req = build_request(:describe_stack_resource_drifts, params)
  req.send_request(options)
end

#describe_stack_resources(params = {}) ⇒ Types::DescribeStackResourcesOutput

Returns Amazon Web Services resource descriptions for running and deleted stacks. If `StackName` is specified, all the associated resources that are part of the stack are returned. If `PhysicalResourceId` is specified, the associated resources of the stack that the resource belongs to are returned.

<note markdown=“1”> Only the first 100 resources will be returned. If your stack has more resources than this, you should use `ListStackResources` instead.

</note>

For deleted stacks, `DescribeStackResources` returns resource information for up to 90 days after the stack has been deleted.

You must specify either `StackName` or `PhysicalResourceId`, but not both. In addition, you can specify `LogicalResourceId` to filter the returned result. For more information about resources, the `LogicalResourceId` and `PhysicalResourceId`, go to the [CloudFormation User Guide].

<note markdown=“1”> A `ValidationError` is returned if you specify both `StackName` and `PhysicalResourceId` in the same request.

</note>

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/

Examples:

Request syntax with placeholder values


resp = client.describe_stack_resources({
  stack_name: "StackName",
  logical_resource_id: "LogicalResourceId",
  physical_resource_id: "PhysicalResourceId",
})

Response structure


resp.stack_resources #=> Array
resp.stack_resources[0].stack_name #=> String
resp.stack_resources[0].stack_id #=> String
resp.stack_resources[0].logical_resource_id #=> String
resp.stack_resources[0].physical_resource_id #=> String
resp.stack_resources[0].resource_type #=> String
resp.stack_resources[0].timestamp #=> Time
resp.stack_resources[0].resource_status #=> String, one of "CREATE_IN_PROGRESS", "CREATE_FAILED", "CREATE_COMPLETE", "DELETE_IN_PROGRESS", "DELETE_FAILED", "DELETE_COMPLETE", "DELETE_SKIPPED", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_COMPLETE", "IMPORT_FAILED", "IMPORT_COMPLETE", "IMPORT_IN_PROGRESS", "IMPORT_ROLLBACK_IN_PROGRESS", "IMPORT_ROLLBACK_FAILED", "IMPORT_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED", "ROLLBACK_IN_PROGRESS", "ROLLBACK_COMPLETE", "ROLLBACK_FAILED"
resp.stack_resources[0].resource_status_reason #=> String
resp.stack_resources[0].description #=> String
resp.stack_resources[0].drift_information.stack_resource_drift_status #=> String, one of "IN_SYNC", "MODIFIED", "DELETED", "NOT_CHECKED"
resp.stack_resources[0].drift_information.last_check_timestamp #=> Time
resp.stack_resources[0].module_info.type_hierarchy #=> String
resp.stack_resources[0].module_info.logical_id_hierarchy #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (String)

    The name or the unique stack ID that is associated with the stack, which are not always interchangeable:

    • Running stacks: You can specify either the stack's name or its unique stack ID.

    • Deleted stacks: You must specify the unique stack ID.

    Default: There is no default value.

    Required: Conditional. If you do not specify `StackName`, you must specify `PhysicalResourceId`.

  • :logical_resource_id (String)

    The logical name of the resource as specified in the template.

    Default: There is no default value.

  • :physical_resource_id (String)

    The name or unique identifier that corresponds to a physical instance ID of a resource supported by CloudFormation.

    For example, for an Amazon Elastic Compute Cloud (EC2) instance, `PhysicalResourceId` corresponds to the `InstanceId`. You can pass the EC2 `InstanceId` to `DescribeStackResources` to find which stack the instance belongs to and what other resources are part of the stack.

    Required: Conditional. If you do not specify `PhysicalResourceId`, you must specify `StackName`.

    Default: There is no default value.

Returns:

See Also:


2796
2797
2798
2799
# File 'lib/aws-sdk-cloudformation/client.rb', line 2796

def describe_stack_resources(params = {}, options = {})
  req = build_request(:describe_stack_resources, params)
  req.send_request(options)
end

#describe_stack_set(params = {}) ⇒ Types::DescribeStackSetOutput

Returns the description of the specified stack set.

Examples:

Request syntax with placeholder values


resp = client.describe_stack_set({
  stack_set_name: "StackSetName", # required
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.stack_set.stack_set_name #=> String
resp.stack_set.stack_set_id #=> String
resp.stack_set.description #=> String
resp.stack_set.status #=> String, one of "ACTIVE", "DELETED"
resp.stack_set.template_body #=> String
resp.stack_set.parameters #=> Array
resp.stack_set.parameters[0].parameter_key #=> String
resp.stack_set.parameters[0].parameter_value #=> String
resp.stack_set.parameters[0].use_previous_value #=> Boolean
resp.stack_set.parameters[0].resolved_value #=> String
resp.stack_set.capabilities #=> Array
resp.stack_set.capabilities[0] #=> String, one of "CAPABILITY_IAM", "CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"
resp.stack_set.tags #=> Array
resp.stack_set.tags[0].key #=> String
resp.stack_set.tags[0].value #=> String
resp.stack_set.stack_set_arn #=> String
resp.stack_set.administration_role_arn #=> String
resp.stack_set.execution_role_name #=> String
resp.stack_set.stack_set_drift_detection_details.drift_status #=> String, one of "DRIFTED", "IN_SYNC", "NOT_CHECKED"
resp.stack_set.stack_set_drift_detection_details.drift_detection_status #=> String, one of "COMPLETED", "FAILED", "PARTIAL_SUCCESS", "IN_PROGRESS", "STOPPED"
resp.stack_set.stack_set_drift_detection_details.last_drift_check_timestamp #=> Time
resp.stack_set.stack_set_drift_detection_details.total_stack_instances_count #=> Integer
resp.stack_set.stack_set_drift_detection_details.drifted_stack_instances_count #=> Integer
resp.stack_set.stack_set_drift_detection_details.in_sync_stack_instances_count #=> Integer
resp.stack_set.stack_set_drift_detection_details.in_progress_stack_instances_count #=> Integer
resp.stack_set.stack_set_drift_detection_details.failed_stack_instances_count #=> Integer
resp.stack_set.auto_deployment.enabled #=> Boolean
resp.stack_set.auto_deployment. #=> Boolean
resp.stack_set.permission_model #=> String, one of "SERVICE_MANAGED", "SELF_MANAGED"
resp.stack_set.organizational_unit_ids #=> Array
resp.stack_set.organizational_unit_ids[0] #=> String
resp.stack_set.managed_execution.active #=> Boolean

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set whose description you want.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


2878
2879
2880
2881
# File 'lib/aws-sdk-cloudformation/client.rb', line 2878

def describe_stack_set(params = {}, options = {})
  req = build_request(:describe_stack_set, params)
  req.send_request(options)
end

#describe_stack_set_operation(params = {}) ⇒ Types::DescribeStackSetOperationOutput

Returns the description of the specified stack set operation.

Examples:

Request syntax with placeholder values


resp = client.describe_stack_set_operation({
  stack_set_name: "StackSetName", # required
  operation_id: "ClientRequestToken", # required
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.stack_set_operation.operation_id #=> String
resp.stack_set_operation.stack_set_id #=> String
resp.stack_set_operation.action #=> String, one of "CREATE", "UPDATE", "DELETE", "DETECT_DRIFT"
resp.stack_set_operation.status #=> String, one of "RUNNING", "SUCCEEDED", "FAILED", "STOPPING", "STOPPED", "QUEUED"
resp.stack_set_operation.operation_preferences.region_concurrency_type #=> String, one of "SEQUENTIAL", "PARALLEL"
resp.stack_set_operation.operation_preferences.region_order #=> Array
resp.stack_set_operation.operation_preferences.region_order[0] #=> String
resp.stack_set_operation.operation_preferences.failure_tolerance_count #=> Integer
resp.stack_set_operation.operation_preferences.failure_tolerance_percentage #=> Integer
resp.stack_set_operation.operation_preferences.max_concurrent_count #=> Integer
resp.stack_set_operation.operation_preferences.max_concurrent_percentage #=> Integer
resp.stack_set_operation.retain_stacks #=> Boolean
resp.stack_set_operation.administration_role_arn #=> String
resp.stack_set_operation.execution_role_name #=> String
resp.stack_set_operation.creation_timestamp #=> Time
resp.stack_set_operation.end_timestamp #=> Time
resp.stack_set_operation.deployment_targets.accounts #=> Array
resp.stack_set_operation.deployment_targets.accounts[0] #=> String
resp.stack_set_operation.deployment_targets.accounts_url #=> String
resp.stack_set_operation.deployment_targets.organizational_unit_ids #=> Array
resp.stack_set_operation.deployment_targets.organizational_unit_ids[0] #=> String
resp.stack_set_operation.stack_set_drift_detection_details.drift_status #=> String, one of "DRIFTED", "IN_SYNC", "NOT_CHECKED"
resp.stack_set_operation.stack_set_drift_detection_details.drift_detection_status #=> String, one of "COMPLETED", "FAILED", "PARTIAL_SUCCESS", "IN_PROGRESS", "STOPPED"
resp.stack_set_operation.stack_set_drift_detection_details.last_drift_check_timestamp #=> Time
resp.stack_set_operation.stack_set_drift_detection_details.total_stack_instances_count #=> Integer
resp.stack_set_operation.stack_set_drift_detection_details.drifted_stack_instances_count #=> Integer
resp.stack_set_operation.stack_set_drift_detection_details.in_sync_stack_instances_count #=> Integer
resp.stack_set_operation.stack_set_drift_detection_details.in_progress_stack_instances_count #=> Integer
resp.stack_set_operation.stack_set_drift_detection_details.failed_stack_instances_count #=> Integer

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or the unique stack ID of the stack set for the stack operation.

  • :operation_id (required, String)

    The unique ID of the stack set operation.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


2962
2963
2964
2965
# File 'lib/aws-sdk-cloudformation/client.rb', line 2962

def describe_stack_set_operation(params = {}, options = {})
  req = build_request(:describe_stack_set_operation, params)
  req.send_request(options)
end

#describe_stacks(params = {}) ⇒ Types::DescribeStacksOutput

Returns the description for the specified stack; if no stack name was specified, then it returns the description for all the stacks created.

<note markdown=“1”> If the stack does not exist, an `ValidationError` is returned.

</note>

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

The following waiters are defined for this operation (see #wait_until for detailed usage):

* stack_create_complete
* stack_delete_complete
* stack_exists
* stack_import_complete
* stack_rollback_complete
* stack_update_complete

Examples:

Request syntax with placeholder values


resp = client.describe_stacks({
  stack_name: "StackName",
  next_token: "NextToken",
})

Response structure


resp.stacks #=> Array
resp.stacks[0].stack_id #=> String
resp.stacks[0].stack_name #=> String
resp.stacks[0].change_set_id #=> String
resp.stacks[0].description #=> String
resp.stacks[0].parameters #=> Array
resp.stacks[0].parameters[0].parameter_key #=> String
resp.stacks[0].parameters[0].parameter_value #=> String
resp.stacks[0].parameters[0].use_previous_value #=> Boolean
resp.stacks[0].parameters[0].resolved_value #=> String
resp.stacks[0].creation_time #=> Time
resp.stacks[0].deletion_time #=> Time
resp.stacks[0].last_updated_time #=> Time
resp.stacks[0].rollback_configuration.rollback_triggers #=> Array
resp.stacks[0].rollback_configuration.rollback_triggers[0].arn #=> String
resp.stacks[0].rollback_configuration.rollback_triggers[0].type #=> String
resp.stacks[0].rollback_configuration.monitoring_time_in_minutes #=> Integer
resp.stacks[0].stack_status #=> String, one of "CREATE_IN_PROGRESS", "CREATE_FAILED", "CREATE_COMPLETE", "ROLLBACK_IN_PROGRESS", "ROLLBACK_FAILED", "ROLLBACK_COMPLETE", "DELETE_IN_PROGRESS", "DELETE_FAILED", "DELETE_COMPLETE", "UPDATE_IN_PROGRESS", "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_COMPLETE", "UPDATE_FAILED", "UPDATE_ROLLBACK_IN_PROGRESS", "UPDATE_ROLLBACK_FAILED", "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE", "REVIEW_IN_PROGRESS", "IMPORT_IN_PROGRESS", "IMPORT_COMPLETE", "IMPORT_ROLLBACK_IN_PROGRESS", "IMPORT_ROLLBACK_FAILED", "IMPORT_ROLLBACK_COMPLETE"
resp.stacks[0].stack_status_reason #=> String
resp.stacks[0].disable_rollback #=> Boolean
resp.stacks[0].notification_arns #=> Array
resp.stacks[0].notification_arns[0] #=> String
resp.stacks[0].timeout_in_minutes #=> Integer
resp.stacks[0].capabilities #=> Array
resp.stacks[0].capabilities[0] #=> String, one of "CAPABILITY_IAM", "CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"
resp.stacks[0].outputs #=> Array
resp.stacks[0].outputs[0].output_key #=> String
resp.stacks[0].outputs[0].output_value #=> String
resp.stacks[0].outputs[0].description #=> String
resp.stacks[0].outputs[0].export_name #=> String
resp.stacks[0].role_arn #=> String
resp.stacks[0].tags #=> Array
resp.stacks[0].tags[0].key #=> String
resp.stacks[0].tags[0].value #=> String
resp.stacks[0].enable_termination_protection #=> Boolean
resp.stacks[0].parent_id #=> String
resp.stacks[0].root_id #=> String
resp.stacks[0].drift_information.stack_drift_status #=> String, one of "DRIFTED", "IN_SYNC", "UNKNOWN", "NOT_CHECKED"
resp.stacks[0].drift_information.last_check_timestamp #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (String)

    The name or the unique stack ID that is associated with the stack, which are not always interchangeable:

    • Running stacks: You can specify either the stack's name or its unique stack ID.

    • Deleted stacks: You must specify the unique stack ID.

    Default: There is no default value.

  • :next_token (String)

    A string that identifies the next page of stacks that you want to retrieve.

Returns:

See Also:


3060
3061
3062
3063
# File 'lib/aws-sdk-cloudformation/client.rb', line 3060

def describe_stacks(params = {}, options = {})
  req = build_request(:describe_stacks, params)
  req.send_request(options)
end

#describe_type(params = {}) ⇒ Types::DescribeTypeOutput

Returns detailed information about an extension that has been registered.

If you specify a `VersionId`, `DescribeType` returns information about that specific extension version. Otherwise, it returns information about the default extension version.

Examples:

Request syntax with placeholder values


resp = client.describe_type({
  type: "RESOURCE", # accepts RESOURCE, MODULE
  type_name: "TypeName",
  arn: "TypeArn",
  version_id: "TypeVersionId",
  publisher_id: "PublisherId",
  public_version_number: "PublicVersionNumber",
})

Response structure


resp.arn #=> String
resp.type #=> String, one of "RESOURCE", "MODULE"
resp.type_name #=> String
resp.default_version_id #=> String
resp.is_default_version #=> Boolean
resp.type_tests_status #=> String, one of "PASSED", "FAILED", "IN_PROGRESS", "NOT_TESTED"
resp.type_tests_status_description #=> String
resp.description #=> String
resp.schema #=> String
resp.provisioning_type #=> String, one of "NON_PROVISIONABLE", "IMMUTABLE", "FULLY_MUTABLE"
resp.deprecated_status #=> String, one of "LIVE", "DEPRECATED"
resp.logging_config.log_role_arn #=> String
resp.logging_config.log_group_name #=> String
resp.required_activated_types #=> Array
resp.required_activated_types[0].type_name_alias #=> String
resp.required_activated_types[0].original_type_name #=> String
resp.required_activated_types[0].publisher_id #=> String
resp.required_activated_types[0].supported_major_versions #=> Array
resp.required_activated_types[0].supported_major_versions[0] #=> Integer
resp.execution_role_arn #=> String
resp.visibility #=> String, one of "PUBLIC", "PRIVATE"
resp.source_url #=> String
resp.documentation_url #=> String
resp.last_updated #=> Time
resp.time_created #=> Time
resp.configuration_schema #=> String
resp.publisher_id #=> String
resp.original_type_name #=> String
resp.original_type_arn #=> String
resp.public_version_number #=> String
resp.latest_public_version #=> String
resp.is_activated #=> Boolean
resp.auto_update #=> Boolean

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :type (String)

    The kind of extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :type_name (String)

    The name of the extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :arn (String)

    The Amazon Resource Name (ARN) of the extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :version_id (String)

    The ID of a specific version of the extension. The version ID is the value at the end of the Amazon Resource Name (ARN) assigned to the extension version when it is registered.

    If you specify a `VersionId`, `DescribeType` returns information about that specific extension version. Otherwise, it returns information about the default extension version.

  • :publisher_id (String)

    The publisher ID of the extension publisher.

    Extensions provided by Amazon are not assigned a publisher ID.

  • :public_version_number (String)

    The version number of a public third-party extension.

Returns:

See Also:


3185
3186
3187
3188
# File 'lib/aws-sdk-cloudformation/client.rb', line 3185

def describe_type(params = {}, options = {})
  req = build_request(:describe_type, params)
  req.send_request(options)
end

#describe_type_registration(params = {}) ⇒ Types::DescribeTypeRegistrationOutput

Returns information about an extension's registration, including its current status and type and version identifiers.

When you initiate a registration request using ` RegisterType `, you can then use ` DescribeTypeRegistration ` to monitor the progress of that registration request.

Once the registration request has completed, use ` DescribeType ` to return detailed information about an extension.

The following waiters are defined for this operation (see #wait_until for detailed usage):

* type_registration_complete

Examples:

Request syntax with placeholder values


resp = client.describe_type_registration({
  registration_token: "RegistrationToken", # required
})

Response structure


resp.progress_status #=> String, one of "COMPLETE", "IN_PROGRESS", "FAILED"
resp.description #=> String
resp.type_arn #=> String
resp.type_version_arn #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :registration_token (required, String)

    The identifier for this registration request.

    This registration token is generated by CloudFormation when you initiate a registration request using ` RegisterType `.

Returns:

See Also:


3235
3236
3237
3238
# File 'lib/aws-sdk-cloudformation/client.rb', line 3235

def describe_type_registration(params = {}, options = {})
  req = build_request(:describe_type_registration, params)
  req.send_request(options)
end

#detect_stack_drift(params = {}) ⇒ Types::DetectStackDriftOutput

Detects whether a stack's actual configuration differs, or has drifted, from it's expected configuration, as defined in the stack template and any values specified as template parameters. For each resource in the stack that supports drift detection, CloudFormation compares the actual configuration of the resource with its expected template configuration. Only resource properties explicitly defined in the stack template are checked for drift. A stack is considered to have drifted if one or more of its resources differ from their expected template configurations. For more information, see [Detecting Unregulated Configuration Changes to Stacks and Resources].

Use `DetectStackDrift` to detect drift on all supported resources for a given stack, or DetectStackResourceDrift to detect drift on individual resources.

For a list of stack resources that currently support drift detection, see [Resources that Support Drift Detection].

`DetectStackDrift` can take up to several minutes, depending on the number of resources contained within the stack. Use DescribeStackDriftDetectionStatus to monitor the progress of a detect stack drift operation. Once the drift detection operation has completed, use DescribeStackResourceDrifts to return drift information about the stack and its resources.

When detecting drift on a stack, CloudFormation does not detect drift on any nested stacks belonging to that stack. Perform `DetectStackDrift` directly on the nested stack itself.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift-resource-list.html

Examples:

Request syntax with placeholder values


resp = client.detect_stack_drift({
  stack_name: "StackNameOrId", # required
  logical_resource_ids: ["LogicalResourceId"],
})

Response structure


resp.stack_drift_detection_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name of the stack for which you want to detect drift.

  • :logical_resource_ids (Array<String>)

    The logical names of any resources you want to use as filters.

Returns:

See Also:


3299
3300
3301
3302
# File 'lib/aws-sdk-cloudformation/client.rb', line 3299

def detect_stack_drift(params = {}, options = {})
  req = build_request(:detect_stack_drift, params)
  req.send_request(options)
end

#detect_stack_resource_drift(params = {}) ⇒ Types::DetectStackResourceDriftOutput

Returns information about whether a resource's actual configuration differs, or has drifted, from it's expected configuration, as defined in the stack template and any values specified as template parameters. This information includes actual and expected property values for resources in which CloudFormation detects drift. Only resource properties explicitly defined in the stack template are checked for drift. For more information about stack and resource drift, see [Detecting Unregulated Configuration Changes to Stacks and Resources].

Use `DetectStackResourceDrift` to detect drift on individual resources, or DetectStackDrift to detect drift on all resources in a given stack that support drift detection.

Resources that do not currently support drift detection cannot be checked. For a list of resources that support drift detection, see [Resources that Support Drift Detection].

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift-resource-list.html

Examples:

Request syntax with placeholder values


resp = client.detect_stack_resource_drift({
  stack_name: "StackNameOrId", # required
  logical_resource_id: "LogicalResourceId", # required
})

Response structure


resp.stack_resource_drift.stack_id #=> String
resp.stack_resource_drift.logical_resource_id #=> String
resp.stack_resource_drift.physical_resource_id #=> String
resp.stack_resource_drift.physical_resource_id_context #=> Array
resp.stack_resource_drift.physical_resource_id_context[0].key #=> String
resp.stack_resource_drift.physical_resource_id_context[0].value #=> String
resp.stack_resource_drift.resource_type #=> String
resp.stack_resource_drift.expected_properties #=> String
resp.stack_resource_drift.actual_properties #=> String
resp.stack_resource_drift.property_differences #=> Array
resp.stack_resource_drift.property_differences[0].property_path #=> String
resp.stack_resource_drift.property_differences[0].expected_value #=> String
resp.stack_resource_drift.property_differences[0].actual_value #=> String
resp.stack_resource_drift.property_differences[0].difference_type #=> String, one of "ADD", "REMOVE", "NOT_EQUAL"
resp.stack_resource_drift.stack_resource_drift_status #=> String, one of "IN_SYNC", "MODIFIED", "DELETED", "NOT_CHECKED"
resp.stack_resource_drift.timestamp #=> Time
resp.stack_resource_drift.module_info.type_hierarchy #=> String
resp.stack_resource_drift.module_info.logical_id_hierarchy #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name of the stack to which the resource belongs.

  • :logical_resource_id (required, String)

    The logical name of the resource for which to return drift information.

Returns:

See Also:


3370
3371
3372
3373
# File 'lib/aws-sdk-cloudformation/client.rb', line 3370

def detect_stack_resource_drift(params = {}, options = {})
  req = build_request(:detect_stack_resource_drift, params)
  req.send_request(options)
end

#detect_stack_set_drift(params = {}) ⇒ Types::DetectStackSetDriftOutput

Detect drift on a stack set. When CloudFormation performs drift detection on a stack set, it performs drift detection on the stack associated with each stack instance in the stack set. For more information, see [How CloudFormation Performs Drift Detection on a Stack Set].

`DetectStackSetDrift` returns the `OperationId` of the stack set drift detection operation. Use this operation id with ` DescribeStackSetOperation ` to monitor the progress of the drift detection operation. The drift detection operation may take some time, depending on the number of stack instances included in the stack set, as well as the number of resources included in each stack.

Once the operation has completed, use the following actions to return drift information:

  • Use ` DescribeStackSet ` to return detailed information about the stack set, including detailed information about the last completed drift operation performed on the stack set. (Information about drift operations that are in progress is not included.)

  • Use ` ListStackInstances ` to return a list of stack instances belonging to the stack set, including the drift status and last drift time checked of each instance.

  • Use ` DescribeStackInstance ` to return detailed information about a specific stack instance, including its drift status and last drift time checked.

For more information on performing a drift detection operation on a stack set, see [Detecting Unmanaged Changes in Stack Sets].

You can only run a single drift detection operation on a given stack set at one time.

To stop a drift detection stack set operation, use ` StopStackSetOperation `.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-drift.html

Examples:

Request syntax with placeholder values


resp = client.detect_stack_set_drift({
  stack_set_name: "StackSetNameOrId", # required
  operation_preferences: {
    region_concurrency_type: "SEQUENTIAL", # accepts SEQUENTIAL, PARALLEL
    region_order: ["Region"],
    failure_tolerance_count: 1,
    failure_tolerance_percentage: 1,
    max_concurrent_count: 1,
    max_concurrent_percentage: 1,
  },
  operation_id: "ClientRequestToken",
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.operation_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name of the stack set on which to perform the drift detection operation.

  • :operation_preferences (Types::StackSetOperationPreferences)

    The user-specified preferences for how CloudFormation performs a stack set operation.

    For more information on maximum concurrent accounts and failure tolerance, see [Stack set operation options].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html#stackset-ops-options

  • :operation_id (String)

    *The ID of the stack set operation.*

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


3488
3489
3490
3491
# File 'lib/aws-sdk-cloudformation/client.rb', line 3488

def detect_stack_set_drift(params = {}, options = {})
  req = build_request(:detect_stack_set_drift, params)
  req.send_request(options)
end

#estimate_template_cost(params = {}) ⇒ Types::EstimateTemplateCostOutput

Returns the estimated monthly cost of a template. The return value is an Amazon Web Services Simple Monthly Calculator URL with a query string that describes the resources required to run the template.

Examples:

Request syntax with placeholder values


resp = client.estimate_template_cost({
  template_body: "TemplateBody",
  template_url: "TemplateURL",
  parameters: [
    {
      parameter_key: "ParameterKey",
      parameter_value: "ParameterValue",
      use_previous_value: false,
      resolved_value: "ParameterValue",
    },
  ],
})

Response structure


resp.url #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :template_body (String)

    Structure containing the template body with a minimum length of 1 byte and a maximum length of 51,200 bytes. (For more information, go to

    Template Anatomy][1

    in the CloudFormation User Guide.)

    Conditional: You must pass `TemplateBody` or `TemplateURL`. If both are passed, only `TemplateBody` is used.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :template_url (String)

    Location of file containing the template body. The URL must point to a template that is located in an Amazon S3 bucket or a Systems Manager document. For more information, go to [Template Anatomy] in the CloudFormation User Guide.

    Conditional: You must pass `TemplateURL` or `TemplateBody`. If both are passed, only `TemplateBody` is used.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :parameters (Array<Types::Parameter>)

    A list of `Parameter` structures that specify input parameters.

Returns:

See Also:


3552
3553
3554
3555
# File 'lib/aws-sdk-cloudformation/client.rb', line 3552

def estimate_template_cost(params = {}, options = {})
  req = build_request(:estimate_template_cost, params)
  req.send_request(options)
end

#execute_change_set(params = {}) ⇒ Struct

Updates a stack using the input information that was provided when the specified change set was created. After the call successfully completes, CloudFormation starts updating the stack. Use the DescribeStacks action to view the status of the update.

When you execute a change set, CloudFormation deletes all other change sets associated with the stack because they aren't valid for the updated stack.

If a stack policy is associated with the stack, CloudFormation enforces the policy during the update. You can't specify a temporary stack policy that overrides the current policy.

To create a change set for the entire stack hierachy, `IncludeNestedStacks` must have been set to `True`.

Examples:

Request syntax with placeholder values


resp = client.execute_change_set({
  change_set_name: "ChangeSetNameOrId", # required
  stack_name: "StackNameOrId",
  client_request_token: "ClientRequestToken",
  disable_rollback: false,
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :change_set_name (required, String)

    The name or ARN of the change set that you want use to update the specified stack.

  • :stack_name (String)

    If you specified the name of a change set, specify the stack name or ID (ARN) that is associated with the change set you want to execute.

  • :client_request_token (String)

    A unique identifier for this `ExecuteChangeSet` request. Specify this token if you plan to retry requests so that CloudFormation knows that you're not attempting to execute a change set to update a stack with the same name. You might retry `ExecuteChangeSet` requests to ensure that CloudFormation successfully received them.

  • :disable_rollback (Boolean)

    Preserves the state of previously provisioned resources when an operation fails.

    Default: `True`

Returns:

  • (Struct)

    Returns an empty response.

See Also:


3609
3610
3611
3612
# File 'lib/aws-sdk-cloudformation/client.rb', line 3609

def execute_change_set(params = {}, options = {})
  req = build_request(:execute_change_set, params)
  req.send_request(options)
end

#get_stack_policy(params = {}) ⇒ Types::GetStackPolicyOutput

Returns the stack policy for a specified stack. If a stack doesn't have a policy, a null value is returned.

Examples:

Request syntax with placeholder values


resp = client.get_stack_policy({
  stack_name: "StackName", # required
})

Response structure


resp.stack_policy_body #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or unique stack ID that is associated with the stack whose policy you want to get.

Returns:

See Also:


3639
3640
3641
3642
# File 'lib/aws-sdk-cloudformation/client.rb', line 3639

def get_stack_policy(params = {}, options = {})
  req = build_request(:get_stack_policy, params)
  req.send_request(options)
end

#get_template(params = {}) ⇒ Types::GetTemplateOutput

Returns the template body for a specified stack. You can get the template for running or deleted stacks.

For deleted stacks, GetTemplate returns the template for up to 90 days after the stack has been deleted.

<note markdown=“1”> If the template does not exist, a `ValidationError` is returned.

</note>

Examples:

Request syntax with placeholder values


resp = client.get_template({
  stack_name: "StackName",
  change_set_name: "ChangeSetNameOrId",
  template_stage: "Original", # accepts Original, Processed
})

Response structure


resp.template_body #=> String
resp.stages_available #=> Array
resp.stages_available[0] #=> String, one of "Original", "Processed"

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (String)

    The name or the unique stack ID that is associated with the stack, which are not always interchangeable:

    • Running stacks: You can specify either the stack's name or its unique stack ID.

    • Deleted stacks: You must specify the unique stack ID.

    Default: There is no default value.

  • :change_set_name (String)

    The name or Amazon Resource Name (ARN) of a change set for which CloudFormation returns the associated template. If you specify a name, you must also specify the `StackName`.

  • :template_stage (String)

    For templates that include transforms, the stage of the template that CloudFormation returns. To get the user-submitted template, specify `Original`. To get the template after CloudFormation has processed all transforms, specify `Processed`.

    If the template doesn't include transforms, `Original` and `Processed` return the same template. By default, CloudFormation specifies `Processed`.

Returns:

See Also:


3703
3704
3705
3706
# File 'lib/aws-sdk-cloudformation/client.rb', line 3703

def get_template(params = {}, options = {})
  req = build_request(:get_template, params)
  req.send_request(options)
end

#get_template_summary(params = {}) ⇒ Types::GetTemplateSummaryOutput

Returns information about a new or existing template. The `GetTemplateSummary` action is useful for viewing parameter information, such as default parameter values and parameter types, before you create or update a stack or stack set.

You can use the `GetTemplateSummary` action when you submit a template, or you can get template information for a stack set, or a running or deleted stack.

For deleted stacks, `GetTemplateSummary` returns the template information for up to 90 days after the stack has been deleted. If the template does not exist, a `ValidationError` is returned.

Examples:

Request syntax with placeholder values


resp = client.get_template_summary({
  template_body: "TemplateBody",
  template_url: "TemplateURL",
  stack_name: "StackNameOrId",
  stack_set_name: "StackSetNameOrId",
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.parameters #=> Array
resp.parameters[0].parameter_key #=> String
resp.parameters[0].default_value #=> String
resp.parameters[0].parameter_type #=> String
resp.parameters[0].no_echo #=> Boolean
resp.parameters[0].description #=> String
resp.parameters[0].parameter_constraints.allowed_values #=> Array
resp.parameters[0].parameter_constraints.allowed_values[0] #=> String
resp.description #=> String
resp.capabilities #=> Array
resp.capabilities[0] #=> String, one of "CAPABILITY_IAM", "CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"
resp.capabilities_reason #=> String
resp.resource_types #=> Array
resp.resource_types[0] #=> String
resp.version #=> String
resp. #=> String
resp.declared_transforms #=> Array
resp.declared_transforms[0] #=> String
resp.resource_identifier_summaries #=> Array
resp.resource_identifier_summaries[0].resource_type #=> String
resp.resource_identifier_summaries[0].logical_resource_ids #=> Array
resp.resource_identifier_summaries[0].logical_resource_ids[0] #=> String
resp.resource_identifier_summaries[0].resource_identifiers #=> Array
resp.resource_identifier_summaries[0].resource_identifiers[0] #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :template_body (String)

    Structure containing the template body with a minimum length of 1 byte and a maximum length of 51,200 bytes. For more information about templates, see [Template Anatomy] in the CloudFormation User Guide.

    Conditional: You must specify only one of the following parameters: `StackName`, `StackSetName`, `TemplateBody`, or `TemplateURL`.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :template_url (String)

    Location of file containing the template body. The URL must point to a template (max size: 460,800 bytes) that is located in an Amazon S3 bucket or a Systems Manager document. For more information about templates, see [Template Anatomy] in the CloudFormation User Guide.

    Conditional: You must specify only one of the following parameters: `StackName`, `StackSetName`, `TemplateBody`, or `TemplateURL`.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :stack_name (String)

    The name or the stack ID that is associated with the stack, which are not always interchangeable. For running stacks, you can specify either the stack's name or its unique stack ID. For deleted stack, you must specify the unique stack ID.

    Conditional: You must specify only one of the following parameters: `StackName`, `StackSetName`, `TemplateBody`, or `TemplateURL`.

  • :stack_set_name (String)

    The name or unique ID of the stack set from which the stack was created.

    Conditional: You must specify only one of the following parameters: `StackName`, `StackSetName`, `TemplateBody`, or `TemplateURL`.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


3837
3838
3839
3840
# File 'lib/aws-sdk-cloudformation/client.rb', line 3837

def get_template_summary(params = {}, options = {})
  req = build_request(:get_template_summary, params)
  req.send_request(options)
end

#import_stacks_to_stack_set(params = {}) ⇒ Types::ImportStacksToStackSetOutput

Use the stack import operations for self-managed or service-managed StackSets. For self-managed StackSets, the import operation can import stacks in the administrator account or in different target accounts and Amazon Web Services Regions. For service-managed StackSets, the import operation can import any stack in the same AWS Organizations as the management account. The import operation can import up to 10 stacks using inline stack IDs or up to 10,000 stacks using an Amazon S3 object.

Examples:

Request syntax with placeholder values


resp = client.import_stacks_to_stack_set({
  stack_set_name: "StackSetNameOrId", # required
  stack_ids: ["StackId"],
  stack_ids_url: "StackIdsUrl",
  organizational_unit_ids: ["OrganizationalUnitId"],
  operation_preferences: {
    region_concurrency_type: "SEQUENTIAL", # accepts SEQUENTIAL, PARALLEL
    region_order: ["Region"],
    failure_tolerance_count: 1,
    failure_tolerance_percentage: 1,
    max_concurrent_count: 1,
    max_concurrent_percentage: 1,
  },
  operation_id: "ClientRequestToken",
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.operation_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name of the stack set. The name must be unique in the Region where you create your stack set.

  • :stack_ids (Array<String>)

    The IDs of the stacks you are importing into a stack set. You import up to 10 stacks per stack set at a time.

    Specify either `StackIds` or `StackIdsUrl`.

  • :stack_ids_url (String)

    The Amazon S3 URL which contains list of stack ids to be inputted.

    Specify either `StackIds` or `StackIdsUrl`.

  • :organizational_unit_ids (Array<String>)

    The list of OU ID’s to which the stacks being imported has to be mapped as deployment target.

  • :operation_preferences (Types::StackSetOperationPreferences)

    The user-specified preferences for how CloudFormation performs a stack set operation.

    For more information on maximum concurrent accounts and failure tolerance, see [Stack set operation options].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html#stackset-ops-options

  • :operation_id (String)

    A unique, user defined, identifier for the stack set operation.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :call_as (String)

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • For service managed stack sets, specify `DELEGATED_ADMIN`.

Returns:

See Also:


3926
3927
3928
3929
# File 'lib/aws-sdk-cloudformation/client.rb', line 3926

def import_stacks_to_stack_set(params = {}, options = {})
  req = build_request(:import_stacks_to_stack_set, params)
  req.send_request(options)
end

#list_change_sets(params = {}) ⇒ Types::ListChangeSetsOutput

Returns the ID and status of each active change set for a stack. For example, CloudFormation lists change sets that are in the `CREATE_IN_PROGRESS` or `CREATE_PENDING` state.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_change_sets({
  stack_name: "StackNameOrId", # required
  next_token: "NextToken",
})

Response structure


resp.summaries #=> Array
resp.summaries[0].stack_id #=> String
resp.summaries[0].stack_name #=> String
resp.summaries[0].change_set_id #=> String
resp.summaries[0].change_set_name #=> String
resp.summaries[0].execution_status #=> String, one of "UNAVAILABLE", "AVAILABLE", "EXECUTE_IN_PROGRESS", "EXECUTE_COMPLETE", "EXECUTE_FAILED", "OBSOLETE"
resp.summaries[0].status #=> String, one of "CREATE_PENDING", "CREATE_IN_PROGRESS", "CREATE_COMPLETE", "DELETE_PENDING", "DELETE_IN_PROGRESS", "DELETE_COMPLETE", "DELETE_FAILED", "FAILED"
resp.summaries[0].status_reason #=> String
resp.summaries[0].creation_time #=> Time
resp.summaries[0].description #=> String
resp.summaries[0].include_nested_stacks #=> Boolean
resp.summaries[0].parent_change_set_id #=> String
resp.summaries[0].root_change_set_id #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or the Amazon Resource Name (ARN) of the stack for which you want to list change sets.

  • :next_token (String)

    A string (provided by the ListChangeSets response output) that identifies the next page of change sets that you want to retrieve.

Returns:

See Also:


3978
3979
3980
3981
# File 'lib/aws-sdk-cloudformation/client.rb', line 3978

def list_change_sets(params = {}, options = {})
  req = build_request(:list_change_sets, params)
  req.send_request(options)
end

#list_exports(params = {}) ⇒ Types::ListExportsOutput

Lists all exported output values in the account and Region in which you call this action. Use this action to see the exported output values that you can import into other stacks. To import values, use the [ `Fn::ImportValue` ][1] function.

For more information, see [ CloudFormation Export Stack Output Values].

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-importvalue.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-exports.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_exports({
  next_token: "NextToken",
})

Response structure


resp.exports #=> Array
resp.exports[0].exporting_stack_id #=> String
resp.exports[0].name #=> String
resp.exports[0].value #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :next_token (String)

    A string (provided by the ListExports response output) that identifies the next page of exported output values that you asked to retrieve.

Returns:

See Also:


4025
4026
4027
4028
# File 'lib/aws-sdk-cloudformation/client.rb', line 4025

def list_exports(params = {}, options = {})
  req = build_request(:list_exports, params)
  req.send_request(options)
end

#list_imports(params = {}) ⇒ Types::ListImportsOutput

Lists all stacks that are importing an exported output value. To modify or remove an exported output value, first use this action to see which stacks are using it. To see the exported output values in your account, see ListExports.

For more information about importing an exported output value, see the

`Fn::ImportValue` ][1

function.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-importvalue.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_imports({
  export_name: "ExportName", # required
  next_token: "NextToken",
})

Response structure


resp.imports #=> Array
resp.imports[0] #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :export_name (required, String)

    The name of the exported output value. CloudFormation returns the stack names that are importing this value.

  • :next_token (String)

    A string (provided by the ListImports response output) that identifies the next page of stacks that are importing the specified exported output value.

Returns:

See Also:


4075
4076
4077
4078
# File 'lib/aws-sdk-cloudformation/client.rb', line 4075

def list_imports(params = {}, options = {})
  req = build_request(:list_imports, params)
  req.send_request(options)
end

#list_stack_instances(params = {}) ⇒ Types::ListStackInstancesOutput

Returns summary information about stack instances that are associated with the specified stack set. You can filter for stack instances that are associated with a specific Amazon Web Services account name or Region, or that have a specific status.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_stack_instances({
  stack_set_name: "StackSetName", # required
  next_token: "NextToken",
  max_results: 1,
  filters: [
    {
      name: "DETAILED_STATUS", # accepts DETAILED_STATUS
      values: "StackInstanceFilterValues",
    },
  ],
  stack_instance_account: "Account",
  stack_instance_region: "Region",
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.summaries #=> Array
resp.summaries[0].stack_set_id #=> String
resp.summaries[0].region #=> String
resp.summaries[0]. #=> String
resp.summaries[0].stack_id #=> String
resp.summaries[0].status #=> String, one of "CURRENT", "OUTDATED", "INOPERABLE"
resp.summaries[0].status_reason #=> String
resp.summaries[0].stack_instance_status.detailed_status #=> String, one of "PENDING", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "INOPERABLE"
resp.summaries[0].organizational_unit_id #=> String
resp.summaries[0].drift_status #=> String, one of "DRIFTED", "IN_SYNC", "UNKNOWN", "NOT_CHECKED"
resp.summaries[0].last_drift_check_timestamp #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set that you want to list stack instances for.

  • :next_token (String)

    If the previous request didn't return all of the remaining results, the response's `NextToken` parameter value is set to a token. To retrieve the next set of results, call `ListStackInstances` again and assign that token to the request object's `NextToken` parameter. If there are no remaining results, the previous response object's `NextToken` parameter is set to `null`.

  • :max_results (Integer)

    The maximum number of results to be returned with a single call. If the number of available results exceeds this maximum, the response includes a `NextToken` value that you can assign to the `NextToken` request parameter to get the next set of results.

  • :filters (Array<Types::StackInstanceFilter>)

    The status that stack instances are filtered by.

  • :stack_instance_account (String)

    The name of the Amazon Web Services account that you want to list stack instances for.

  • :stack_instance_region (String)

    The name of the Region where you want to list stack instances.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


4178
4179
4180
4181
# File 'lib/aws-sdk-cloudformation/client.rb', line 4178

def list_stack_instances(params = {}, options = {})
  req = build_request(:list_stack_instances, params)
  req.send_request(options)
end

#list_stack_resources(params = {}) ⇒ Types::ListStackResourcesOutput

Returns descriptions of all resources of the specified stack.

For deleted stacks, ListStackResources returns resource information for up to 90 days after the stack has been deleted.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_stack_resources({
  stack_name: "StackName", # required
  next_token: "NextToken",
})

Response structure


resp.stack_resource_summaries #=> Array
resp.stack_resource_summaries[0].logical_resource_id #=> String
resp.stack_resource_summaries[0].physical_resource_id #=> String
resp.stack_resource_summaries[0].resource_type #=> String
resp.stack_resource_summaries[0].last_updated_timestamp #=> Time
resp.stack_resource_summaries[0].resource_status #=> String, one of "CREATE_IN_PROGRESS", "CREATE_FAILED", "CREATE_COMPLETE", "DELETE_IN_PROGRESS", "DELETE_FAILED", "DELETE_COMPLETE", "DELETE_SKIPPED", "UPDATE_IN_PROGRESS", "UPDATE_FAILED", "UPDATE_COMPLETE", "IMPORT_FAILED", "IMPORT_COMPLETE", "IMPORT_IN_PROGRESS", "IMPORT_ROLLBACK_IN_PROGRESS", "IMPORT_ROLLBACK_FAILED", "IMPORT_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED", "ROLLBACK_IN_PROGRESS", "ROLLBACK_COMPLETE", "ROLLBACK_FAILED"
resp.stack_resource_summaries[0].resource_status_reason #=> String
resp.stack_resource_summaries[0].drift_information.stack_resource_drift_status #=> String, one of "IN_SYNC", "MODIFIED", "DELETED", "NOT_CHECKED"
resp.stack_resource_summaries[0].drift_information.last_check_timestamp #=> Time
resp.stack_resource_summaries[0].module_info.type_hierarchy #=> String
resp.stack_resource_summaries[0].module_info.logical_id_hierarchy #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or the unique stack ID that is associated with the stack, which are not always interchangeable:

    • Running stacks: You can specify either the stack's name or its unique stack ID.

    • Deleted stacks: You must specify the unique stack ID.

    Default: There is no default value.

  • :next_token (String)

    A string that identifies the next page of stack resources that you want to retrieve.

Returns:

See Also:


4236
4237
4238
4239
# File 'lib/aws-sdk-cloudformation/client.rb', line 4236

def list_stack_resources(params = {}, options = {})
  req = build_request(:list_stack_resources, params)
  req.send_request(options)
end

#list_stack_set_operation_results(params = {}) ⇒ Types::ListStackSetOperationResultsOutput

Returns summary information about the results of a stack set operation.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_stack_set_operation_results({
  stack_set_name: "StackSetName", # required
  operation_id: "ClientRequestToken", # required
  next_token: "NextToken",
  max_results: 1,
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.summaries #=> Array
resp.summaries[0]. #=> String
resp.summaries[0].region #=> String
resp.summaries[0].status #=> String, one of "PENDING", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED"
resp.summaries[0].status_reason #=> String
resp.summaries[0]..status #=> String, one of "SUCCEEDED", "FAILED", "SKIPPED"
resp.summaries[0]..status_reason #=> String
resp.summaries[0].organizational_unit_id #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set that you want to get operation results for.

  • :operation_id (required, String)

    The ID of the stack set operation.

  • :next_token (String)

    If the previous request didn't return all of the remaining results, the response object's `NextToken` parameter value is set to a token. To retrieve the next set of results, call `ListStackSetOperationResults` again and assign that token to the request object's `NextToken` parameter. If there are no remaining results, the previous response object's `NextToken` parameter is set to `null`.

  • :max_results (Integer)

    The maximum number of results to be returned with a single call. If the number of available results exceeds this maximum, the response includes a `NextToken` value that you can assign to the `NextToken` request parameter to get the next set of results.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


4321
4322
4323
4324
# File 'lib/aws-sdk-cloudformation/client.rb', line 4321

def list_stack_set_operation_results(params = {}, options = {})
  req = build_request(:list_stack_set_operation_results, params)
  req.send_request(options)
end

#list_stack_set_operations(params = {}) ⇒ Types::ListStackSetOperationsOutput

Returns summary information about operations performed on a stack set.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_stack_set_operations({
  stack_set_name: "StackSetName", # required
  next_token: "NextToken",
  max_results: 1,
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.summaries #=> Array
resp.summaries[0].operation_id #=> String
resp.summaries[0].action #=> String, one of "CREATE", "UPDATE", "DELETE", "DETECT_DRIFT"
resp.summaries[0].status #=> String, one of "RUNNING", "SUCCEEDED", "FAILED", "STOPPING", "STOPPED", "QUEUED"
resp.summaries[0].creation_timestamp #=> Time
resp.summaries[0].end_timestamp #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set that you want to get operation summaries for.

  • :next_token (String)

    If the previous paginated request didn't return all of the remaining results, the response object's `NextToken` parameter value is set to a token. To retrieve the next set of results, call `ListStackSetOperations` again and assign that token to the request object's `NextToken` parameter. If there are no remaining results, the previous response object's `NextToken` parameter is set to `null`.

  • :max_results (Integer)

    The maximum number of results to be returned with a single call. If the number of available results exceeds this maximum, the response includes a `NextToken` value that you can assign to the `NextToken` request parameter to get the next set of results.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


4399
4400
4401
4402
# File 'lib/aws-sdk-cloudformation/client.rb', line 4399

def list_stack_set_operations(params = {}, options = {})
  req = build_request(:list_stack_set_operations, params)
  req.send_request(options)
end

#list_stack_sets(params = {}) ⇒ Types::ListStackSetsOutput

Returns summary information about stack sets that are associated with the user.

  • [Self-managed permissions] If you set the `CallAs` parameter to `SELF` while signed in to your Amazon Web Services account, `ListStackSets` returns all self-managed stack sets in your Amazon Web Services account.

  • [Service-managed permissions] If you set the `CallAs` parameter to `SELF` while signed in to the organization's management account, `ListStackSets` returns all stack sets in the management account.

  • [Service-managed permissions] If you set the `CallAs` parameter to `DELEGATED_ADMIN` while signed in to your member account, `ListStackSets` returns all stack sets with service-managed permissions in the management account.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_stack_sets({
  next_token: "NextToken",
  max_results: 1,
  status: "ACTIVE", # accepts ACTIVE, DELETED
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.summaries #=> Array
resp.summaries[0].stack_set_name #=> String
resp.summaries[0].stack_set_id #=> String
resp.summaries[0].description #=> String
resp.summaries[0].status #=> String, one of "ACTIVE", "DELETED"
resp.summaries[0].auto_deployment.enabled #=> Boolean
resp.summaries[0].auto_deployment. #=> Boolean
resp.summaries[0].permission_model #=> String, one of "SERVICE_MANAGED", "SELF_MANAGED"
resp.summaries[0].drift_status #=> String, one of "DRIFTED", "IN_SYNC", "UNKNOWN", "NOT_CHECKED"
resp.summaries[0].last_drift_check_timestamp #=> Time
resp.summaries[0].managed_execution.active #=> Boolean
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :next_token (String)

    If the previous paginated request didn't return all of the remaining results, the response object's `NextToken` parameter value is set to a token. To retrieve the next set of results, call `ListStackSets` again and assign that token to the request object's `NextToken` parameter. If there are no remaining results, the previous response object's `NextToken` parameter is set to `null`.

  • :max_results (Integer)

    The maximum number of results to be returned with a single call. If the number of available results exceeds this maximum, the response includes a `NextToken` value that you can assign to the `NextToken` request parameter to get the next set of results.

  • :status (String)

    The status of the stack sets that you want to get summary information about.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


4496
4497
4498
4499
# File 'lib/aws-sdk-cloudformation/client.rb', line 4496

def list_stack_sets(params = {}, options = {})
  req = build_request(:list_stack_sets, params)
  req.send_request(options)
end

#list_stacks(params = {}) ⇒ Types::ListStacksOutput

Returns the summary information for stacks whose status matches the specified StackStatusFilter. Summary information for stacks that have been deleted is kept for 90 days after the stack is deleted. If no StackStatusFilter is specified, summary information for all stacks is returned (including existing stacks and stacks that have been deleted).

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_stacks({
  next_token: "NextToken",
  stack_status_filter: ["CREATE_IN_PROGRESS"], # accepts CREATE_IN_PROGRESS, CREATE_FAILED, CREATE_COMPLETE, ROLLBACK_IN_PROGRESS, ROLLBACK_FAILED, ROLLBACK_COMPLETE, DELETE_IN_PROGRESS, DELETE_FAILED, DELETE_COMPLETE, UPDATE_IN_PROGRESS, UPDATE_COMPLETE_CLEANUP_IN_PROGRESS, UPDATE_COMPLETE, UPDATE_FAILED, UPDATE_ROLLBACK_IN_PROGRESS, UPDATE_ROLLBACK_FAILED, UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS, UPDATE_ROLLBACK_COMPLETE, REVIEW_IN_PROGRESS, IMPORT_IN_PROGRESS, IMPORT_COMPLETE, IMPORT_ROLLBACK_IN_PROGRESS, IMPORT_ROLLBACK_FAILED, IMPORT_ROLLBACK_COMPLETE
})

Response structure


resp.stack_summaries #=> Array
resp.stack_summaries[0].stack_id #=> String
resp.stack_summaries[0].stack_name #=> String
resp.stack_summaries[0].template_description #=> String
resp.stack_summaries[0].creation_time #=> Time
resp.stack_summaries[0].last_updated_time #=> Time
resp.stack_summaries[0].deletion_time #=> Time
resp.stack_summaries[0].stack_status #=> String, one of "CREATE_IN_PROGRESS", "CREATE_FAILED", "CREATE_COMPLETE", "ROLLBACK_IN_PROGRESS", "ROLLBACK_FAILED", "ROLLBACK_COMPLETE", "DELETE_IN_PROGRESS", "DELETE_FAILED", "DELETE_COMPLETE", "UPDATE_IN_PROGRESS", "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_COMPLETE", "UPDATE_FAILED", "UPDATE_ROLLBACK_IN_PROGRESS", "UPDATE_ROLLBACK_FAILED", "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE", "REVIEW_IN_PROGRESS", "IMPORT_IN_PROGRESS", "IMPORT_COMPLETE", "IMPORT_ROLLBACK_IN_PROGRESS", "IMPORT_ROLLBACK_FAILED", "IMPORT_ROLLBACK_COMPLETE"
resp.stack_summaries[0].stack_status_reason #=> String
resp.stack_summaries[0].parent_id #=> String
resp.stack_summaries[0].root_id #=> String
resp.stack_summaries[0].drift_information.stack_drift_status #=> String, one of "DRIFTED", "IN_SYNC", "UNKNOWN", "NOT_CHECKED"
resp.stack_summaries[0].drift_information.last_check_timestamp #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :next_token (String)

    A string that identifies the next page of stacks that you want to retrieve.

  • :stack_status_filter (Array<String>)

    Stack status to use as a filter. Specify one or more stack status codes to list only stacks with the specified status codes. For a complete list of stack status codes, see the `StackStatus` parameter of the Stack data type.

Returns:

See Also:


4553
4554
4555
4556
# File 'lib/aws-sdk-cloudformation/client.rb', line 4553

def list_stacks(params = {}, options = {})
  req = build_request(:list_stacks, params)
  req.send_request(options)
end

#list_type_registrations(params = {}) ⇒ Types::ListTypeRegistrationsOutput

Returns a list of registration tokens for the specified extension(s).

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_type_registrations({
  type: "RESOURCE", # accepts RESOURCE, MODULE
  type_name: "TypeName",
  type_arn: "TypeArn",
  registration_status_filter: "COMPLETE", # accepts COMPLETE, IN_PROGRESS, FAILED
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.registration_token_list #=> Array
resp.registration_token_list[0] #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :type (String)

    The kind of extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :type_name (String)

    The name of the extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :type_arn (String)

    The Amazon Resource Name (ARN) of the extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :registration_status_filter (String)

    The current status of the extension registration request.

    The default is `IN_PROGRESS`.

  • :max_results (Integer)

    The maximum number of results to be returned with a single call. If the number of available results exceeds this maximum, the response includes a `NextToken` value that you can assign to the `NextToken` request parameter to get the next set of results.

  • :next_token (String)

    If the previous paginated request didn't return all of the remaining results, the response object's `NextToken` parameter value is set to a token. To retrieve the next set of results, call this action again and assign that token to the request object's `NextToken` parameter. If there are no remaining results, the previous response object's `NextToken` parameter is set to `null`.

Returns:

See Also:


4622
4623
4624
4625
# File 'lib/aws-sdk-cloudformation/client.rb', line 4622

def list_type_registrations(params = {}, options = {})
  req = build_request(:list_type_registrations, params)
  req.send_request(options)
end

#list_type_versions(params = {}) ⇒ Types::ListTypeVersionsOutput

Returns summary information about the versions of an extension.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_type_versions({
  type: "RESOURCE", # accepts RESOURCE, MODULE
  type_name: "TypeName",
  arn: "TypeArn",
  max_results: 1,
  next_token: "NextToken",
  deprecated_status: "LIVE", # accepts LIVE, DEPRECATED
  publisher_id: "PublisherId",
})

Response structure


resp.type_version_summaries #=> Array
resp.type_version_summaries[0].type #=> String, one of "RESOURCE", "MODULE"
resp.type_version_summaries[0].type_name #=> String
resp.type_version_summaries[0].version_id #=> String
resp.type_version_summaries[0].is_default_version #=> Boolean
resp.type_version_summaries[0].arn #=> String
resp.type_version_summaries[0].time_created #=> Time
resp.type_version_summaries[0].description #=> String
resp.type_version_summaries[0].public_version_number #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :type (String)

    The kind of the extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :type_name (String)

    The name of the extension for which you want version summary information.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :arn (String)

    The Amazon Resource Name (ARN) of the extension for which you want version summary information.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :max_results (Integer)

    The maximum number of results to be returned with a single call. If the number of available results exceeds this maximum, the response includes a `NextToken` value that you can assign to the `NextToken` request parameter to get the next set of results.

  • :next_token (String)

    If the previous paginated request didn't return all of the remaining results, the response object's `NextToken` parameter value is set to a token. To retrieve the next set of results, call this action again and assign that token to the request object's `NextToken` parameter. If there are no remaining results, the previous response object's `NextToken` parameter is set to `null`.

  • :deprecated_status (String)

    The deprecation status of the extension versions that you want to get summary information about.

    Valid values include:

    • `LIVE`: The extension version is registered and can be used in CloudFormation operations, dependent on its provisioning behavior and visibility scope.

    • `DEPRECATED`: The extension version has been deregistered and can no longer be used in CloudFormation operations.

    The default is `LIVE`.

  • :publisher_id (String)

    The publisher ID of the extension publisher.

    Extensions published by Amazon are not assigned a publisher ID.

Returns:

See Also:


4716
4717
4718
4719
# File 'lib/aws-sdk-cloudformation/client.rb', line 4716

def list_type_versions(params = {}, options = {})
  req = build_request(:list_type_versions, params)
  req.send_request(options)
end

#list_types(params = {}) ⇒ Types::ListTypesOutput

Returns summary information about extension that have been registered with CloudFormation.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_types({
  visibility: "PUBLIC", # accepts PUBLIC, PRIVATE
  provisioning_type: "NON_PROVISIONABLE", # accepts NON_PROVISIONABLE, IMMUTABLE, FULLY_MUTABLE
  deprecated_status: "LIVE", # accepts LIVE, DEPRECATED
  type: "RESOURCE", # accepts RESOURCE, MODULE
  filters: {
    category: "REGISTERED", # accepts REGISTERED, ACTIVATED, THIRD_PARTY, AWS_TYPES
    publisher_id: "PublisherId",
    type_name_prefix: "TypeNamePrefix",
  },
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.type_summaries #=> Array
resp.type_summaries[0].type #=> String, one of "RESOURCE", "MODULE"
resp.type_summaries[0].type_name #=> String
resp.type_summaries[0].default_version_id #=> String
resp.type_summaries[0].type_arn #=> String
resp.type_summaries[0].last_updated #=> Time
resp.type_summaries[0].description #=> String
resp.type_summaries[0].publisher_id #=> String
resp.type_summaries[0].original_type_name #=> String
resp.type_summaries[0].public_version_number #=> String
resp.type_summaries[0].latest_public_version #=> String
resp.type_summaries[0].publisher_identity #=> String, one of "AWS_Marketplace", "GitHub", "Bitbucket"
resp.type_summaries[0].publisher_name #=> String
resp.type_summaries[0].is_activated #=> Boolean
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :visibility (String)

    The scope at which the extensions are visible and usable in CloudFormation operations.

    Valid values include:

    • `PRIVATE`: Extensions that are visible and usable within this account and region. This includes:

      • Private extensions you have registered in this account and region.

      • Public extensions that you have activated in this account and region.

    • `PUBLIC`: Extensions that are publicly visible and available to be activated within any Amazon account. This includes extensions from Amazon, as well as third-party publishers.

    The default is `PRIVATE`.

  • :provisioning_type (String)

    For resource types, the provisioning behavior of the resource type. CloudFormation determines the provisioning type during registration, based on the types of handlers in the schema handler package submitted.

    Valid values include:

    • `FULLY_MUTABLE`: The resource type includes an update handler to process updates to the type during stack update operations.

    • `IMMUTABLE`: The resource type does not include an update handler, so the type cannot be updated and must instead be replaced during stack update operations.

    • `NON_PROVISIONABLE`: The resource type does not include create, read, and delete handlers, and therefore cannot actually be provisioned.

    The default is `FULLY_MUTABLE`.

  • :deprecated_status (String)

    The deprecation status of the extension that you want to get summary information about.

    Valid values include:

    • `LIVE`: The extension is registered for use in CloudFormation operations.

    • `DEPRECATED`: The extension has been deregistered and can no longer be used in CloudFormation operations.

  • :type (String)

    The type of extension.

  • :filters (Types::TypeFilters)

    Filter criteria to use in determining which extensions to return.

    Filters must be compatible with `Visibility` to return valid results. For example, specifying `AWS_TYPES` for `Category` and `PRIVATE` for `Visibility` returns an empty list of types, but specifying `PUBLIC` for `Visibility` returns the desired list.

  • :max_results (Integer)

    The maximum number of results to be returned with a single call. If the number of available results exceeds this maximum, the response includes a `NextToken` value that you can assign to the `NextToken` request parameter to get the next set of results.

  • :next_token (String)

    If the previous paginated request didn't return all of the remaining results, the response object's `NextToken` parameter value is set to a token. To retrieve the next set of results, call this action again and assign that token to the request object's `NextToken` parameter. If there are no remaining results, the previous response object's `NextToken` parameter is set to `null`.

Returns:

See Also:


4847
4848
4849
4850
# File 'lib/aws-sdk-cloudformation/client.rb', line 4847

def list_types(params = {}, options = {})
  req = build_request(:list_types, params)
  req.send_request(options)
end

#publish_type(params = {}) ⇒ Types::PublishTypeOutput

Publishes the specified extension to the CloudFormation registry as a public extension in this region. Public extensions are available for use by all CloudFormation users. For more information on publishing extensions, see [Publishing extensions to make them available for public use] in the *CloudFormation CLI User Guide*.

To publish an extension, you must be registered as a publisher with CloudFormation. For more information, see [RegisterPublisher].

[1]: docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_RegisterPublisher.html

Examples:

Request syntax with placeholder values


resp = client.publish_type({
  type: "RESOURCE", # accepts RESOURCE, MODULE
  arn: "PrivateTypeArn",
  type_name: "TypeName",
  public_version_number: "PublicVersionNumber",
})

Response structure


resp.public_type_arn #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :type (String)

    The type of the extension.

    Conditional: You must specify `Arn`, or `TypeName` and `Type`.

  • :arn (String)

    The Amazon Resource Number (ARN) of the extension.

    Conditional: You must specify `Arn`, or `TypeName` and `Type`.

  • :type_name (String)

    The name of the extension.

    Conditional: You must specify `Arn`, or `TypeName` and `Type`.

  • :public_version_number (String)

    The version number to assign to this version of the extension.

    Use the following format, and adhere to semantic versioning when assigning a version number to your extension:

    `MAJOR.MINOR.PATCH`

    For more information, see [Semantic Versioning 2.0.0].

    If you do not specify a version number, CloudFormation increments the version number by one minor version release.

    You cannot specify a version number the first time you publish a type. CloudFormation automatically sets the first version number to be `1.0.0`.

    [1]: semver.org/

Returns:

See Also:


4923
4924
4925
4926
# File 'lib/aws-sdk-cloudformation/client.rb', line 4923

def publish_type(params = {}, options = {})
  req = build_request(:publish_type, params)
  req.send_request(options)
end

#record_handler_progress(params = {}) ⇒ Struct

Reports progress of a resource handler to CloudFormation.

Reserved for use by the [CloudFormation CLI]. Do not use this API in your code.

[1]: docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html

Examples:

Request syntax with placeholder values


resp = client.record_handler_progress({
  bearer_token: "ClientToken", # required
  operation_status: "PENDING", # required, accepts PENDING, IN_PROGRESS, SUCCESS, FAILED
  current_operation_status: "PENDING", # accepts PENDING, IN_PROGRESS, SUCCESS, FAILED
  status_message: "StatusMessage",
  error_code: "NotUpdatable", # accepts NotUpdatable, InvalidRequest, AccessDenied, InvalidCredentials, AlreadyExists, NotFound, ResourceConflict, Throttling, ServiceLimitExceeded, NotStabilized, GeneralServiceException, ServiceInternalError, NetworkFailure, InternalFailure, InvalidTypeConfiguration
  resource_model: "ResourceModel",
  client_request_token: "ClientRequestToken",
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

Returns:

  • (Struct)

    Returns an empty response.

See Also:


5004
5005
5006
5007
# File 'lib/aws-sdk-cloudformation/client.rb', line 5004

def record_handler_progress(params = {}, options = {})
  req = build_request(:record_handler_progress, params)
  req.send_request(options)
end

#register_publisher(params = {}) ⇒ Types::RegisterPublisherOutput

Registers your account as a publisher of public extensions in the CloudFormation registry. Public extensions are available for use by all CloudFormation users. This publisher ID applies to your account in all Amazon Web Services Regions.

For information on requirements for registering as a public extension publisher, see [Registering your account to publish CloudFormation extensions] in the *CloudFormation CLI User Guide*.

[1]: docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html#publish-extension-prereqs

Examples:

Request syntax with placeholder values


resp = client.register_publisher({
  accept_terms_and_conditions: false,
  connection_arn: "ConnectionArn",
})

Response structure


resp.publisher_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

Returns:

See Also:


5067
5068
5069
5070
# File 'lib/aws-sdk-cloudformation/client.rb', line 5067

def register_publisher(params = {}, options = {})
  req = build_request(:register_publisher, params)
  req.send_request(options)
end

#register_type(params = {}) ⇒ Types::RegisterTypeOutput

Registers an extension with the CloudFormation service. Registering an extension makes it available for use in CloudFormation templates in your Amazon Web Services account, and includes:

  • Validating the extension schema

  • Determining which handlers, if any, have been specified for the extension

  • Making the extension available for use in your account

For more information on how to develop extensions and ready them for registeration, see [Creating Resource Providers] in the *CloudFormation CLI User Guide*.

You can have a maximum of 50 resource extension versions registered at a time. This maximum is per account and per region. Use [DeregisterType](AWSCloudFormation/latest/APIReference/API_DeregisterType.html) to deregister specific extension versions if necessary.

Once you have initiated a registration request using ` RegisterType `, you can use ` DescribeTypeRegistration ` to monitor the progress of the registration request.

Once you have registered a private extension in your account and region, use [SetTypeConfiguration](AWSCloudFormation/latest/APIReference/API_SetTypeConfiguration.html) to specify configuration properties for the extension. For more information, see [Configuring extensions at the account level] in the *CloudFormation User Guide*.

[1]: docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-types.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-register.html#registry-set-configuration

Examples:

Request syntax with placeholder values


resp = client.register_type({
  type: "RESOURCE", # accepts RESOURCE, MODULE
  type_name: "TypeName", # required
  schema_handler_package: "S3Url", # required
  logging_config: {
    log_role_arn: "RoleArn", # required
    log_group_name: "LogGroupName", # required
  },
  execution_role_arn: "RoleArn",
  client_request_token: "RequestToken",
})

Response structure


resp.registration_token #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :type (String)

    The kind of extension.

  • :type_name (required, String)

    The name of the extension being registered.

    We recommend that extension names adhere to the following patterns:

    • For resource types, *company_or_organization*::service::type.

    • For modules, *company_or_organization*::service::type::MODULE.

    <note markdown=“1”> The following organization namespaces are reserved and cannot be used in your extension names:

    * `Alexa`
    
    • `AMZN`

    • `Amazon`

    • `AWS`

    • `Custom`

    • `Dev`

    </note>
    
  • :schema_handler_package (required, String)

    A url to the S3 bucket containing the extension project package that contains the neccessary files for the extension you want to register.

    For information on generating a schema handler package for the extension you want to register, see [submit] in the *CloudFormation CLI User Guide*.

    <note markdown=“1”> The user registering the extension must be able to access the package in the S3 bucket. That is, the user needs to have [GetObject] permissions for the schema handler package. For more information, see

    Actions, Resources, and Condition Keys for Amazon S3][3

    in the

    *Identity and Access Management User Guide*.

    </note>
    

    [1]: docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-cli-submit.html [2]: docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html [3]: docs.aws.amazon.com/IAM/latest/UserGuide/list_amazons3.html

  • :logging_config (Types::LoggingConfig)

    Specifies logging configuration information for an extension.

  • :execution_role_arn (String)

    The Amazon Resource Name (ARN) of the IAM role for CloudFormation to assume when invoking the extension.

    For CloudFormation to assume the specified execution role, the role must contain a trust relationship with the CloudFormation service principle (`resources.cloudformation.amazonaws.com`). For more information on adding trust relationships, see [Modifying a role trust policy](IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-managingrole_edit-trust-policy) in the *Identity and Access Management User Guide*.

    If your extension calls Amazon Web Services APIs in any of its handlers, you must create an <a href=“https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html”>IAM execution role</a> that includes the necessary permissions to call those Amazon Web Services APIs, and provision that execution role in your account. When CloudFormation needs to invoke the resource type handler, CloudFormation assumes this execution role to create a temporary session token, which it then passes to the resource type handler, thereby supplying your resource type with the appropriate credentials.

  • :client_request_token (String)

    A unique identifier that acts as an idempotency key for this registration request. Specifying a client request token prevents CloudFormation from generating more than one version of an extension from the same registeration request, even if the request is submitted multiple times.

Returns:

See Also:


5219
5220
5221
5222
# File 'lib/aws-sdk-cloudformation/client.rb', line 5219

def register_type(params = {}, options = {})
  req = build_request(:register_type, params)
  req.send_request(options)
end

#rollback_stack(params = {}) ⇒ Types::RollbackStackOutput

When specifying `RollbackStack`, you preserve the state of previously provisioned resources when an operation fails. You can check the status of the stack through the DescribeStacks API.

Rolls back the specified stack to the last known stable state from `CREATE_FAILED` or `UPDATE_FAILED` stack statuses.

This operation will delete a stack if it doesn't contain a last known stable state. A last known stable state includes any status in a `*_COMPLETE`. This includes the following stack statuses.

  • `CREATE_COMPLETE`

  • `UPDATE_COMPLETE`

  • `UPDATE_ROLLBACK_COMPLETE`

  • `IMPORT_COMPLETE`

  • `IMPORT_ROLLBACK_COMPLETE`

Examples:

Request syntax with placeholder values


resp = client.rollback_stack({
  stack_name: "StackNameOrId", # required
  role_arn: "RoleARN",
  client_request_token: "ClientRequestToken",
})

Response structure


resp.stack_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name that is associated with the stack.

  • :role_arn (String)

    The Amazon Resource Name (ARN) of an Identity and Access Management role that CloudFormation assumes to rollback the stack.

  • :client_request_token (String)

    A unique identifier for this `RollbackStack` request.

Returns:

See Also:


5275
5276
5277
5278
# File 'lib/aws-sdk-cloudformation/client.rb', line 5275

def rollback_stack(params = {}, options = {})
  req = build_request(:rollback_stack, params)
  req.send_request(options)
end

#set_stack_policy(params = {}) ⇒ Struct

Sets a stack policy for a specified stack.

Examples:

Request syntax with placeholder values


resp = client.set_stack_policy({
  stack_name: "StackName", # required
  stack_policy_body: "StackPolicyBody",
  stack_policy_url: "StackPolicyURL",
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or unique stack ID that you want to associate a policy with.

  • :stack_policy_body (String)

    Structure containing the stack policy body. For more information, go to [ Prevent Updates to Stack Resources] in the CloudFormation User Guide. You can specify either the `StackPolicyBody` or the `StackPolicyURL` parameter, but not both.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/protect-stack-resources.html

  • :stack_policy_url (String)

    Location of a file containing the stack policy. The URL must point to a policy (maximum size: 16 KB) located in an S3 bucket in the same Region as the stack. You can specify either the `StackPolicyBody` or the `StackPolicyURL` parameter, but not both.

Returns:

  • (Struct)

    Returns an empty response.

See Also:


5315
5316
5317
5318
# File 'lib/aws-sdk-cloudformation/client.rb', line 5315

def set_stack_policy(params = {}, options = {})
  req = build_request(:set_stack_policy, params)
  req.send_request(options)
end

#set_type_configuration(params = {}) ⇒ Types::SetTypeConfigurationOutput

Specifies the configuration data for a registered CloudFormation extension, in the given account and region.

To view the current configuration data for an extension, refer to the `ConfigurationSchema` element of [DescribeType](AWSCloudFormation/latest/APIReference/API_DescribeType.html). For more information, see [Configuring extensions at the account level] in the *CloudFormation User Guide*.

It is strongly recommended that you use dynamic references to restrict sensitive configuration definitions, such as third-party credentials. For more details on dynamic references, see [Using dynamic references to specify template values] in the *CloudFormation User Guide*.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-register.html#registry-set-configuration [2]: docs.aws.amazon.com/

Examples:

Request syntax with placeholder values


resp = client.set_type_configuration({
  type_arn: "TypeArn",
  configuration: "TypeConfiguration", # required
  configuration_alias: "TypeConfigurationAlias",
  type_name: "TypeName",
  type: "RESOURCE", # accepts RESOURCE, MODULE
})

Response structure


resp.configuration_arn #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :type_arn (String)

    The Amazon Resource Name (ARN) for the extension, in this account and region.

    For public extensions, this will be the ARN assigned when you

    activate the type][1

    in this account and region. For private

    extensions, this will be the ARN assigned when you [register the type] in this account and region.

    Do not include the extension versions suffix at the end of the ARN. You can set the configuration for an extension, but not for a specific extension version.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ActivateType.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_RegisterType.html

  • :configuration (required, String)

    The configuration data for the extension, in this account and region.

    The configuration data must be formatted as JSON, and validate against the schema returned in the `ConfigurationSchema` response element of [API_DescribeType](AWSCloudFormation/latest/APIReference/API_DescribeType.html). For more information, see [Defining account-level configuration data for an extension] in the *CloudFormation CLI User Guide*.

    [1]: docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-model.html#resource-type-howto-configuration

  • :configuration_alias (String)

    An alias by which to refer to this extension configuration data.

    Conditional: Specifying a configuration alias is required when setting a configuration for a resource type extension.

  • :type_name (String)

    The name of the extension.

    Conditional: You must specify `ConfigurationArn`, or `Type` and `TypeName`.

  • :type (String)

    The type of extension.

    Conditional: You must specify `ConfigurationArn`, or `Type` and `TypeName`.

Returns:

See Also:


5410
5411
5412
5413
# File 'lib/aws-sdk-cloudformation/client.rb', line 5410

def set_type_configuration(params = {}, options = {})
  req = build_request(:set_type_configuration, params)
  req.send_request(options)
end

#set_type_default_version(params = {}) ⇒ Struct

Specify the default version of an extension. The default version of an extension will be used in CloudFormation operations.

Examples:

Request syntax with placeholder values


resp = client.set_type_default_version({
  arn: "PrivateTypeArn",
  type: "RESOURCE", # accepts RESOURCE, MODULE
  type_name: "TypeName",
  version_id: "TypeVersionId",
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :arn (String)

    The Amazon Resource Name (ARN) of the extension for which you want version summary information.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :type (String)

    The kind of extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :type_name (String)

    The name of the extension.

    Conditional: You must specify either `TypeName` and `Type`, or `Arn`.

  • :version_id (String)

    The ID of a specific version of the extension. The version ID is the value at the end of the Amazon Resource Name (ARN) assigned to the extension version when it is registered.

Returns:

  • (Struct)

    Returns an empty response.

See Also:


5454
5455
5456
5457
# File 'lib/aws-sdk-cloudformation/client.rb', line 5454

def set_type_default_version(params = {}, options = {})
  req = build_request(:set_type_default_version, params)
  req.send_request(options)
end

#signal_resource(params = {}) ⇒ Struct

Sends a signal to the specified resource with a success or failure status. You can use the SignalResource API in conjunction with a creation policy or update policy. CloudFormation doesn't proceed with a stack creation or update until resources receive the required number of signals or the timeout period is exceeded. The SignalResource API is useful in cases where you want to send signals from anywhere other than an Amazon EC2 instance.

Examples:

Request syntax with placeholder values


resp = client.signal_resource({
  stack_name: "StackNameOrId", # required
  logical_resource_id: "LogicalResourceId", # required
  unique_id: "ResourceSignalUniqueId", # required
  status: "SUCCESS", # required, accepts SUCCESS, FAILURE
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The stack name or unique stack ID that includes the resource that you want to signal.

  • :logical_resource_id (required, String)

    The logical ID of the resource that you want to signal. The logical ID is the name of the resource that given in the template.

  • :unique_id (required, String)

    A unique ID of the signal. When you signal Amazon EC2 instances or Auto Scaling groups, specify the instance ID that you are signaling as the unique ID. If you send multiple signals to a single resource (such as signaling a wait condition), each signal requires a different unique ID.

  • :status (required, String)

    The status of the signal, which is either success or failure. A failure signal causes CloudFormation to immediately fail the stack creation or update.

Returns:

  • (Struct)

    Returns an empty response.

See Also:


5502
5503
5504
5505
# File 'lib/aws-sdk-cloudformation/client.rb', line 5502

def signal_resource(params = {}, options = {})
  req = build_request(:signal_resource, params)
  req.send_request(options)
end

#stop_stack_set_operation(params = {}) ⇒ Struct

Stops an in-progress operation on a stack set and its associated stack instances.

Examples:

Request syntax with placeholder values


resp = client.stop_stack_set_operation({
  stack_set_name: "StackSetName", # required
  operation_id: "ClientRequestToken", # required
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set that you want to stop the operation for.

  • :operation_id (required, String)

    The ID of the stack operation.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

  • (Struct)

    Returns an empty response.

See Also:


5553
5554
5555
5556
# File 'lib/aws-sdk-cloudformation/client.rb', line 5553

def stop_stack_set_operation(params = {}, options = {})
  req = build_request(:stop_stack_set_operation, params)
  req.send_request(options)
end

#test_type(params = {}) ⇒ Types::TestTypeOutput

Tests a registered extension to make sure it meets all necessary requirements for being published in the CloudFormation registry.

  • For resource types, this includes passing all contracts tests defined for the type.

  • For modules, this includes determining if the module's model meets all necessary requirements.

For more information, see [Testing your public extension prior to publishing] in the *CloudFormation CLI User Guide*.

If you do not specify a version, CloudFormation uses the default version of the extension in your account and region for testing.

To perform testing, CloudFormation assumes the execution role specified when the type was registered. For more information, see [RegisterType](AWSCloudFormation/latest/APIReference/API_RegisterType.html).

Once you've initiated testing on an extension using `TestType`, you can use [DescribeType] to monitor the current test status and test status description for the extension.

An extension must have a test status of `PASSED` before it can be published. For more information, see [Publishing extensions to make them available for public use] in the *CloudFormation CLI User Guide*.

[1]: docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html#publish-extension-testing [2]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeType.html [3]: docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-publish.html

Examples:

Request syntax with placeholder values


resp = client.test_type({
  arn: "TypeArn",
  type: "RESOURCE", # accepts RESOURCE, MODULE
  type_name: "TypeName",
  version_id: "TypeVersionId",
  log_delivery_bucket: "S3Bucket",
})

Response structure


resp.type_version_arn #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :arn (String)

    The Amazon Resource Number (ARN) of the extension.

    Conditional: You must specify `Arn`, or `TypeName` and `Type`.

  • :type (String)

    The type of the extension to test.

    Conditional: You must specify `Arn`, or `TypeName` and `Type`.

  • :type_name (String)

    The name of the extension to test.

    Conditional: You must specify `Arn`, or `TypeName` and `Type`.

  • :version_id (String)

    The version of the extension to test.

    You can specify the version id with either `Arn`, or with `TypeName` and `Type`.

    If you do not specify a version, CloudFormation uses the default version of the extension in this account and region for testing.

  • :log_delivery_bucket (String)

    The S3 bucket to which CloudFormation delivers the contract test execution logs.

    CloudFormation delivers the logs by the time contract testing has completed and the extension has been assigned a test type status of `PASSED` or `FAILED`.

    The user calling `TestType` must be able to access items in the specified S3 bucket. Specifically, the user needs the following permissions:

    • GetObject

    • PutObject

    For more information, see [Actions, Resources, and Condition Keys for Amazon S3] in the *Amazon Web Services Identity and Access Management User Guide*.

    [1]: docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html

Returns:

See Also:


5662
5663
5664
5665
# File 'lib/aws-sdk-cloudformation/client.rb', line 5662

def test_type(params = {}, options = {})
  req = build_request(:test_type, params)
  req.send_request(options)
end

#update_stack(params = {}) ⇒ Types::UpdateStackOutput

Updates a stack as specified in the template. After the call completes successfully, the stack update starts. You can check the status of the stack via the DescribeStacks action.

To get a copy of the template for an existing stack, you can use the GetTemplate action.

For more information about creating an update template, updating a stack, and monitoring the progress of the update, see [Updating a Stack].

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks.html

Examples:

Request syntax with placeholder values


resp = client.update_stack({
  stack_name: "StackName", # required
  template_body: "TemplateBody",
  template_url: "TemplateURL",
  use_previous_template: false,
  stack_policy_during_update_body: "StackPolicyDuringUpdateBody",
  stack_policy_during_update_url: "StackPolicyDuringUpdateURL",
  parameters: [
    {
      parameter_key: "ParameterKey",
      parameter_value: "ParameterValue",
      use_previous_value: false,
      resolved_value: "ParameterValue",
    },
  ],
  capabilities: ["CAPABILITY_IAM"], # accepts CAPABILITY_IAM, CAPABILITY_NAMED_IAM, CAPABILITY_AUTO_EXPAND
  resource_types: ["ResourceType"],
  role_arn: "RoleARN",
  rollback_configuration: {
    rollback_triggers: [
      {
        arn: "Arn", # required
        type: "Type", # required
      },
    ],
    monitoring_time_in_minutes: 1,
  },
  stack_policy_body: "StackPolicyBody",
  stack_policy_url: "StackPolicyURL",
  notification_arns: ["NotificationARN"],
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  disable_rollback: false,
  client_request_token: "ClientRequestToken",
})

Response structure


resp.stack_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_name (required, String)

    The name or unique stack ID of the stack to update.

  • :template_body (String)

    Structure containing the template body with a minimum length of 1 byte and a maximum length of 51,200 bytes. (For more information, go to

    Template Anatomy][1

    in the CloudFormation User Guide.)

    Conditional: You must specify only one of the following parameters: `TemplateBody`, `TemplateURL`, or set the `UsePreviousTemplate` to `true`.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :template_url (String)

    Location of file containing the template body. The URL must point to a template that is located in an Amazon S3 bucket or a Systems Manager document. For more information, go to [Template Anatomy] in the CloudFormation User Guide.

    Conditional: You must specify only one of the following parameters: `TemplateBody`, `TemplateURL`, or set the `UsePreviousTemplate` to `true`.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :use_previous_template (Boolean)

    Reuse the existing template that is associated with the stack that you are updating.

    Conditional: You must specify only one of the following parameters: `TemplateBody`, `TemplateURL`, or set the `UsePreviousTemplate` to `true`.

  • :stack_policy_during_update_body (String)

    Structure containing the temporary overriding stack policy body. You can specify either the `StackPolicyDuringUpdateBody` or the `StackPolicyDuringUpdateURL` parameter, but not both.

    If you want to update protected resources, specify a temporary overriding stack policy during this update. If you do not specify a stack policy, the current policy that is associated with the stack will be used.

  • :stack_policy_during_update_url (String)

    Location of a file containing the temporary overriding stack policy. The URL must point to a policy (max size: 16KB) located in an S3 bucket in the same Region as the stack. You can specify either the `StackPolicyDuringUpdateBody` or the `StackPolicyDuringUpdateURL` parameter, but not both.

    If you want to update protected resources, specify a temporary overriding stack policy during this update. If you do not specify a stack policy, the current policy that is associated with the stack will be used.

  • :parameters (Array<Types::Parameter>)

    A list of `Parameter` structures that specify input parameters for the stack. For more information, see the [Parameter] data type.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html

  • :capabilities (Array<String>)

    In some cases, you must explicitly acknowledge that your stack template contains certain capabilities in order for CloudFormation to update the stack.

    • `CAPABILITY_IAM` and `CAPABILITY_NAMED_IAM`

      Some stack templates might include resources that can affect permissions in your Amazon Web Services account; for example, by creating new Identity and Access Management (IAM) users. For those stacks, you must explicitly acknowledge this by specifying one of these capabilities.

      The following IAM resources require you to specify either the `CAPABILITY_IAM` or `CAPABILITY_NAMED_IAM` capability.

      • If you have IAM resources, you can specify either capability.

      • If you have IAM resources with custom names, you must specify `CAPABILITY_NAMED_IAM`.

      • If you don't specify either of these capabilities, CloudFormation returns an `InsufficientCapabilities` error.

      If your stack template contains these resources, we recommend that you review all permissions associated with them and edit their permissions if necessary.

      • AWS::IAM::AccessKey][1
      • AWS::IAM::Group][2
      • AWS::IAM::InstanceProfile][3
      • AWS::IAM::Policy][4
      • AWS::IAM::Role][5
      • AWS::IAM::User][6
      • AWS::IAM::UserToGroupAddition][7

      For more information, see [Acknowledging IAM Resources in CloudFormation Templates].

    • `CAPABILITY_AUTO_EXPAND`

      Some template contain macros. Macros perform custom processing on templates; this can include simple actions like find-and-replace operations, all the way to extensive transformations of entire templates. Because of this, users typically create a change set from the processed template, so that they can review the changes resulting from the macros before actually updating the stack. If your stack template contains one or more macros, and you choose to update a stack directly from the processed template, without first reviewing the resulting changes in a change set, you must acknowledge this capability. This includes the [AWS::Include] and

      AWS::Serverless][10

      transforms, which are macros hosted by

      CloudFormation.

      If you want to update a stack from a stack template that contains macros and nested stacks, you must update the stack directly from the template using this capability.

      You should only update stacks directly from a stack template that contains macros if you know what processing the macro performs.

      Each macro relies on an underlying Lambda service function for
      

      processing stack templates. Be aware that the Lambda function owner can update the function operation without CloudFormation being notified.

      For more information, see [Using CloudFormation Macros to Perform Custom Processing on Templates].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html [3]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html [4]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html [5]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html [6]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html [7]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html [8]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities [9]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html [10]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html [11]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html

  • :resource_types (Array<String>)

    The template resource types that you have permissions to work with for this update stack action, such as `AWS::EC2::Instance`, `AWS::EC2::*`, or `Custom::MyCustomInstance`.

    If the list of resource types doesn't include a resource that you're updating, the stack update fails. By default, CloudFormation grants permissions to all resource types. Identity and Access Management (IAM) uses this parameter for CloudFormation-specific condition keys in IAM policies. For more information, see [Controlling Access with Identity and Access Management].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html

  • :role_arn (String)

    The Amazon Resource Name (ARN) of an Identity and Access Management (IAM) role that CloudFormation assumes to update the stack. CloudFormation uses the role's credentials to make calls on your behalf. CloudFormation always uses this role for all future operations on the stack. As long as users have permission to operate on the stack, CloudFormation uses this role even if the users don't have permission to pass it. Ensure that the role grants least privilege.

    If you don't specify a value, CloudFormation uses the role that was previously associated with the stack. If no role is available, CloudFormation uses a temporary session that is generated from your user credentials.

  • :rollback_configuration (Types::RollbackConfiguration)

    The rollback triggers for CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards.

  • :stack_policy_body (String)

    Structure containing a new stack policy body. You can specify either the `StackPolicyBody` or the `StackPolicyURL` parameter, but not both.

    You might update the stack policy, for example, in order to protect a new resource that you created during a stack update. If you do not specify a stack policy, the current policy that is associated with the stack is unchanged.

  • :stack_policy_url (String)

    Location of a file containing the updated stack policy. The URL must point to a policy (max size: 16KB) located in an S3 bucket in the same Region as the stack. You can specify either the `StackPolicyBody` or the `StackPolicyURL` parameter, but not both.

    You might update the stack policy, for example, in order to protect a new resource that you created during a stack update. If you do not specify a stack policy, the current policy that is associated with the stack is unchanged.

  • :notification_arns (Array<String>)

    Amazon Simple Notification Service topic Amazon Resource Names (ARNs) that CloudFormation associates with the stack. Specify an empty list to remove all notification topics.

  • :tags (Array<Types::Tag>)

    Key-value pairs to associate with this stack. CloudFormation also propagates these tags to supported resources in the stack. You can specify a maximum number of 50 tags.

    If you don't specify this parameter, CloudFormation doesn't modify the stack's tags. If you specify an empty value, CloudFormation removes all associated tags.

  • :disable_rollback (Boolean)

    Preserve the state of previously provisioned resources when an operation fails.

    Default: `False`

  • :client_request_token (String)

    A unique identifier for this `UpdateStack` request. Specify this token if you plan to retry requests so that CloudFormation knows that you're not attempting to update a stack with the same name. You might retry `UpdateStack` requests to ensure that CloudFormation successfully received them.

    All events triggered by a given stack operation are assigned the same client request token, which you can use to track operations. For example, if you execute a `CreateStack` operation with the token `token1`, then all the `StackEvents` generated by that operation will have `ClientRequestToken` set as `token1`.

    In the console, stack operations display the client request token on the Events tab. Stack operations that are initiated from the console use the token format Console-StackOperation-ID, which helps you easily identify the stack operation . For example, if you create a stack using the console, each stack event would be assigned the same token in the following format: `Console-CreateStack-7f59c3cf-00d2-40c7-b2ff-e75db0987002`.

Returns:

See Also:


5989
5990
5991
5992
# File 'lib/aws-sdk-cloudformation/client.rb', line 5989

def update_stack(params = {}, options = {})
  req = build_request(:update_stack, params)
  req.send_request(options)
end

#update_stack_instances(params = {}) ⇒ Types::UpdateStackInstancesOutput

Updates the parameter values for stack instances for the specified accounts, within the specified Regions. A stack instance refers to a stack in a specific account and Region.

You can only update stack instances in Regions and accounts where they already exist; to create additional stack instances, use [CreateStackInstances].

During stack set updates, any parameters overridden for a stack instance are not updated, but retain their overridden value.

You can only update the parameter values that are specified in the stack set; to add or delete a parameter itself, use

UpdateStackSet][2

to update the stack set template. If you add a

parameter to a template, before you can override the parameter value specified in the stack set you must first use [UpdateStackSet] to update all stack instances with the updated template and parameter value specified in the stack set. Once a stack instance has been updated with the new parameter, you can then override the parameter value using `UpdateStackInstances`.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStackInstances.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html

Examples:

Request syntax with placeholder values


resp = client.update_stack_instances({
  stack_set_name: "StackSetNameOrId", # required
  accounts: ["Account"],
  deployment_targets: {
    accounts: ["Account"],
    accounts_url: "AccountsUrl",
    organizational_unit_ids: ["OrganizationalUnitId"],
  },
  regions: ["Region"], # required
  parameter_overrides: [
    {
      parameter_key: "ParameterKey",
      parameter_value: "ParameterValue",
      use_previous_value: false,
      resolved_value: "ParameterValue",
    },
  ],
  operation_preferences: {
    region_concurrency_type: "SEQUENTIAL", # accepts SEQUENTIAL, PARALLEL
    region_order: ["Region"],
    failure_tolerance_count: 1,
    failure_tolerance_percentage: 1,
    max_concurrent_count: 1,
    max_concurrent_percentage: 1,
  },
  operation_id: "ClientRequestToken",
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
})

Response structure


resp.operation_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set associated with the stack instances.

  • :accounts (Array<String>)

    [Self-managed permissions] The names of one or more Amazon Web Services accounts for which you want to update parameter values for stack instances. The overridden parameter values will be applied to all stack instances in the specified accounts and Regions.

    You can specify `Accounts` or `DeploymentTargets`, but not both.

  • :deployment_targets (Types::DeploymentTargets)

    [Service-managed permissions] The Organizations accounts for which you want to update parameter values for stack instances. If your update targets OUs, the overridden parameter values only apply to the accounts that are currently in the target OUs and their child OUs. Accounts added to the target OUs and their child OUs in the future won't use the overridden values.

    You can specify `Accounts` or `DeploymentTargets`, but not both.

  • :regions (required, Array<String>)

    The names of one or more Regions in which you want to update parameter values for stack instances. The overridden parameter values will be applied to all stack instances in the specified accounts and Regions.

  • :parameter_overrides (Array<Types::Parameter>)

    A list of input parameters whose values you want to update for the specified stack instances.

    Any overridden parameter values will be applied to all stack instances in the specified accounts and Regions. When specifying parameters and their values, be aware of how CloudFormation sets parameter values during stack instance update operations:

    • To override the current value for a parameter, include the parameter and specify its value.

    • To leave an overridden parameter set to its present value, include the parameter and specify `UsePreviousValue` as `true`. (You cannot specify both a value and set `UsePreviousValue` to `true`.)

    • To set an overridden parameter back to the value specified in the stack set, specify a parameter list but do not include the parameter in the list.

    • To leave all parameters set to their present values, do not specify this property at all.

    During stack set updates, any parameter values overridden for a stack instance are not updated, but retain their overridden value.

    You can only override the parameter values that are specified in the stack set; to add or delete a parameter itself, use `UpdateStackSet` to update the stack set template. If you add a parameter to a template, before you can override the parameter value specified in the stack set you must first use [UpdateStackSet] to update all stack instances with the updated template and parameter value specified in the stack set. Once a stack instance has been updated with the new parameter, you can then override the parameter value using `UpdateStackInstances`.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html

  • :operation_preferences (Types::StackSetOperationPreferences)

    Preferences for how CloudFormation performs this stack set operation.

  • :operation_id (String)

    The unique identifier for this stack set operation.

    The operation ID also functions as an idempotency token, to ensure that CloudFormation performs the stack set operation only once, even if you retry the request multiple times. You might retry stack set operation requests to ensure that CloudFormation successfully received them.

    If you don't specify an operation ID, the SDK generates one automatically.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

Returns:

See Also:


6170
6171
6172
6173
# File 'lib/aws-sdk-cloudformation/client.rb', line 6170

def update_stack_instances(params = {}, options = {})
  req = build_request(:update_stack_instances, params)
  req.send_request(options)
end

#update_stack_set(params = {}) ⇒ Types::UpdateStackSetOutput

Updates the stack set, and associated stack instances in the specified accounts and Regions.

Even if the stack set operation created by updating the stack set fails (completely or partially, below or above a specified failure tolerance), the stack set is updated with your changes. Subsequent CreateStackInstances calls on the specified stack set use the updated stack set.

Examples:

Request syntax with placeholder values


resp = client.update_stack_set({
  stack_set_name: "StackSetName", # required
  description: "Description",
  template_body: "TemplateBody",
  template_url: "TemplateURL",
  use_previous_template: false,
  parameters: [
    {
      parameter_key: "ParameterKey",
      parameter_value: "ParameterValue",
      use_previous_value: false,
      resolved_value: "ParameterValue",
    },
  ],
  capabilities: ["CAPABILITY_IAM"], # accepts CAPABILITY_IAM, CAPABILITY_NAMED_IAM, CAPABILITY_AUTO_EXPAND
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  operation_preferences: {
    region_concurrency_type: "SEQUENTIAL", # accepts SEQUENTIAL, PARALLEL
    region_order: ["Region"],
    failure_tolerance_count: 1,
    failure_tolerance_percentage: 1,
    max_concurrent_count: 1,
    max_concurrent_percentage: 1,
  },
  administration_role_arn: "RoleARN",
  execution_role_name: "ExecutionRoleName",
  deployment_targets: {
    accounts: ["Account"],
    accounts_url: "AccountsUrl",
    organizational_unit_ids: ["OrganizationalUnitId"],
  },
  permission_model: "SERVICE_MANAGED", # accepts SERVICE_MANAGED, SELF_MANAGED
  auto_deployment: {
    enabled: false,
    retain_stacks_on_account_removal: false,
  },
  operation_id: "ClientRequestToken",
  accounts: ["Account"],
  regions: ["Region"],
  call_as: "SELF", # accepts SELF, DELEGATED_ADMIN
  managed_execution: {
    active: false,
  },
})

Response structure


resp.operation_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :stack_set_name (required, String)

    The name or unique ID of the stack set that you want to update.

  • :description (String)

    A brief description of updates that you are making.

  • :template_body (String)

    The structure that contains the template body, with a minimum length of 1 byte and a maximum length of 51,200 bytes. For more information, see [Template Anatomy] in the CloudFormation User Guide.

    Conditional: You must specify only one of the following parameters: `TemplateBody` or `TemplateURL`—or set `UsePreviousTemplate` to true.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :template_url (String)

    The location of the file that contains the template body. The URL must point to a template (maximum size: 460,800 bytes) that is located in an Amazon S3 bucket or a Systems Manager document. For more information, see [Template Anatomy] in the CloudFormation User Guide.

    Conditional: You must specify only one of the following parameters: `TemplateBody` or `TemplateURL`—or set `UsePreviousTemplate` to true.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :use_previous_template (Boolean)

    Use the existing template that's associated with the stack set that you're updating.

    Conditional: You must specify only one of the following parameters: `TemplateBody` or `TemplateURL`—or set `UsePreviousTemplate` to true.

  • :parameters (Array<Types::Parameter>)

    A list of input parameters for the stack set template.

  • :capabilities (Array<String>)

    In some cases, you must explicitly acknowledge that your stack template contains certain capabilities in order for CloudFormation to update the stack set and its associated stack instances.

    • `CAPABILITY_IAM` and `CAPABILITY_NAMED_IAM`

      Some stack templates might include resources that can affect permissions in your Amazon Web Services account; for example, by creating new Identity and Access Management (IAM) users. For those stacks sets, you must explicitly acknowledge this by specifying one of these capabilities.

      The following IAM resources require you to specify either the `CAPABILITY_IAM` or `CAPABILITY_NAMED_IAM` capability.

      • If you have IAM resources, you can specify either capability.

      • If you have IAM resources with custom names, you must specify `CAPABILITY_NAMED_IAM`.

      • If you don't specify either of these capabilities, CloudFormation returns an `InsufficientCapabilities` error.

      If your stack template contains these resources, we recommend that you review all permissions associated with them and edit their permissions if necessary.

      • AWS::IAM::AccessKey][1
      • AWS::IAM::Group][2
      • AWS::IAM::InstanceProfile][3
      • AWS::IAM::Policy][4
      • AWS::IAM::Role][5
      • AWS::IAM::User][6
      • AWS::IAM::UserToGroupAddition][7

      For more information, see [Acknowledging IAM Resources in CloudFormation Templates].

    • `CAPABILITY_AUTO_EXPAND`

      Some templates reference macros. If your stack set template references one or more macros, you must update the stack set directly from the processed template, without first reviewing the resulting changes in a change set. To update the stack set directly, you must acknowledge this capability. For more information, see [Using CloudFormation Macros to Perform Custom Processing on Templates].

      Stack sets with service-managed permissions do not currently support the use of macros in templates. (This includes the

      AWS::Include][10

      and [AWS::Serverless] transforms, which are

      macros hosted by CloudFormation.) Even if you specify this capability for a stack set with service-managed permissions, if you reference a macro in your template the stack set operation will fail.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html [3]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html [4]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html [5]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html [6]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html [7]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html [8]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities [9]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html [10]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html [11]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html

  • :tags (Array<Types::Tag>)

    The key-value pairs to associate with this stack set and the stacks created from it. CloudFormation also propagates these tags to supported resources that are created in the stacks. You can specify a maximum number of 50 tags.

    If you specify tags for this parameter, those tags replace any list of tags that are currently associated with this stack set. This means:

    • If you don't specify this parameter, CloudFormation doesn't modify the stack's tags.

    • If you specify any tags using this parameter, you must specify all the tags that you want associated with this stack set, even tags you've specifed before (for example, when creating the stack set or during a previous update of the stack set.). Any tags that you don't include in the updated list of tags are removed from the stack set, and therefore from the stacks and resources as well.

    • If you specify an empty value, CloudFormation removes all currently associated tags.

    If you specify new tags as part of an `UpdateStackSet` action, CloudFormation checks to see if you have the required IAM permission to tag resources. If you omit tags that are currently associated with the stack set from the list of tags you specify, CloudFormation assumes that you want to remove those tags from the stack set, and checks to see if you have permission to untag resources. If you don't have the necessary permission(s), the entire `UpdateStackSet` action fails with an `access denied` error, and the stack set is not updated.

  • :operation_preferences (Types::StackSetOperationPreferences)

    Preferences for how CloudFormation performs this stack set operation.

  • :administration_role_arn (String)

    The Amazon Resource Number (ARN) of the IAM role to use to update this stack set.

    Specify an IAM role only if you are using customized administrator roles to control which users or groups can manage specific stack sets within the same administrator account. For more information, see

    Granting Permissions for Stack Set Operations][1

    in the

    *CloudFormation User Guide*.

    If you specified a customized administrator role when you created the stack set, you must specify a customized administrator role, even if it is the same customized administrator role used with this stack set previously.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs.html

  • :execution_role_name (String)

    The name of the IAM execution role to use to update the stack set. If you do not specify an execution role, CloudFormation uses the `AWSCloudFormationStackSetExecutionRole` role for the stack set operation.

    Specify an IAM role only if you are using customized execution roles to control which stack resources users and groups can include in their stack sets.

    If you specify a customized execution role, CloudFormation uses that role to update the stack. If you do not specify a customized execution role, CloudFormation performs the update using the role previously associated with the stack set, so long as you have permissions to perform operations on the stack set.

  • :deployment_targets (Types::DeploymentTargets)

    [Service-managed permissions] The Organizations accounts in which to update associated stack instances.

    To update all the stack instances associated with this stack set, do not specify `DeploymentTargets` or `Regions`.

    If the stack set update includes changes to the template (that is, if `TemplateBody` or `TemplateURL` is specified), or the `Parameters`, CloudFormation marks all stack instances with a status of `OUTDATED` prior to updating the stack instances in the specified accounts and Regions. If the stack set update does not include changes to the template or parameters, CloudFormation updates the stack instances in the specified accounts and Regions, while leaving all other stack instances with their existing stack instance status.

  • :permission_model (String)

    Describes how the IAM roles required for stack set operations are created. You cannot modify `PermissionModel` if there are stack instances associated with your stack set.

    • With `self-managed` permissions, you must create the administrator and execution roles required to deploy to target accounts. For more information, see [Grant Self-Managed Stack Set Permissions].

    • With `service-managed` permissions, StackSets automatically creates the IAM roles required to deploy to accounts managed by Organizations. For more information, see [Grant Service-Managed Stack Set Permissions].

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-service-managed.html

  • :auto_deployment (Types::AutoDeployment)

    [Service-managed permissions] Describes whether StackSets automatically deploys to Organizations accounts that are added to a target organization or organizational unit (OU).

    If you specify `AutoDeployment`, do not specify `DeploymentTargets` or `Regions`.

  • :operation_id (String)

    The unique ID for this stack set operation.

    The operation ID also functions as an idempotency token, to ensure that CloudFormation performs the stack set operation only once, even if you retry the request multiple times. You might retry stack set operation requests to ensure that CloudFormation successfully received them.

    If you don't specify an operation ID, CloudFormation generates one automatically.

    Repeating this stack set operation with a new operation ID retries all stack instances whose status is `OUTDATED`.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :accounts (Array<String>)

    [Self-managed permissions] The accounts in which to update associated stack instances. If you specify accounts, you must also specify the Regions in which to update stack set instances.

    To update all the stack instances associated with this stack set, do not specify the `Accounts` or `Regions` properties.

    If the stack set update includes changes to the template (that is, if the `TemplateBody` or `TemplateURL` properties are specified), or the `Parameters` property, CloudFormation marks all stack instances with a status of `OUTDATED` prior to updating the stack instances in the specified accounts and Regions. If the stack set update does not include changes to the template or parameters, CloudFormation updates the stack instances in the specified accounts and Regions, while leaving all other stack instances with their existing stack instance status.

  • :regions (Array<String>)

    The Regions in which to update associated stack instances. If you specify Regions, you must also specify accounts in which to update stack set instances.

    To update all the stack instances associated with this stack set, do not specify the `Accounts` or `Regions` properties.

    If the stack set update includes changes to the template (that is, if the `TemplateBody` or `TemplateURL` properties are specified), or the `Parameters` property, CloudFormation marks all stack instances with a status of `OUTDATED` prior to updating the stack instances in the specified accounts and Regions. If the stack set update does not include changes to the template or parameters, CloudFormation updates the stack instances in the specified accounts and Regions, while leaving all other stack instances with their existing stack instance status.

  • :call_as (String)

    [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

    By default, `SELF` is specified. Use `SELF` for stack sets with self-managed permissions.

    • If you are signed in to the management account, specify `SELF`.

    • If you are signed in to a delegated administrator account, specify `DELEGATED_ADMIN`.

      Your Amazon Web Services account must be registered as a delegated administrator in the management account. For more information, see

      Register a delegated administrator][1

      in the *CloudFormation User

      Guide*.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html

  • :managed_execution (Types::ManagedExecution)

    Describes whether StackSets performs non-conflicting operations concurrently and queues conflicting operations.

Returns:

See Also:


6559
6560
6561
6562
# File 'lib/aws-sdk-cloudformation/client.rb', line 6559

def update_stack_set(params = {}, options = {})
  req = build_request(:update_stack_set, params)
  req.send_request(options)
end

#update_termination_protection(params = {}) ⇒ Types::UpdateTerminationProtectionOutput

Updates termination protection for the specified stack. If a user attempts to delete a stack with termination protection enabled, the operation fails and the stack remains unchanged. For more information, see [Protecting a Stack From Being Deleted] in the *CloudFormation User Guide*.

For [nested stacks], termination protection is set on the root stack and cannot be changed directly on the nested stack.

[1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html [2]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html

Examples:

Request syntax with placeholder values


resp = client.update_termination_protection({
  enable_termination_protection: false, # required
  stack_name: "StackNameOrId", # required
})

Response structure


resp.stack_id #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :enable_termination_protection (required, Boolean)

    Whether to enable termination protection on the specified stack.

  • :stack_name (required, String)

    The name or unique ID of the stack for which you want to set termination protection.

Returns:

See Also:


6604
6605
6606
6607
# File 'lib/aws-sdk-cloudformation/client.rb', line 6604

def update_termination_protection(params = {}, options = {})
  req = build_request(:update_termination_protection, params)
  req.send_request(options)
end

#validate_template(params = {}) ⇒ Types::ValidateTemplateOutput

Validates a specified template. CloudFormation first checks if the template is valid JSON. If it isn't, CloudFormation checks if the template is valid YAML. If both these checks fail, CloudFormation returns a template validation error.

Examples:

Request syntax with placeholder values


resp = client.validate_template({
  template_body: "TemplateBody",
  template_url: "TemplateURL",
})

Response structure


resp.parameters #=> Array
resp.parameters[0].parameter_key #=> String
resp.parameters[0].default_value #=> String
resp.parameters[0].no_echo #=> Boolean
resp.parameters[0].description #=> String
resp.description #=> String
resp.capabilities #=> Array
resp.capabilities[0] #=> String, one of "CAPABILITY_IAM", "CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"
resp.capabilities_reason #=> String
resp.declared_transforms #=> Array
resp.declared_transforms[0] #=> String

Parameters:

  • params (Hash) (defaults to: {})

    ({})

Options Hash (params):

  • :template_body (String)

    Structure containing the template body with a minimum length of 1 byte and a maximum length of 51,200 bytes. For more information, go to

    Template Anatomy][1

    in the CloudFormation User Guide.

    Conditional: You must pass `TemplateURL` or `TemplateBody`. If both are passed, only `TemplateBody` is used.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

  • :template_url (String)

    Location of file containing the template body. The URL must point to a template (max size: 460,800 bytes) that is located in an Amazon S3 bucket or a Systems Manager document. For more information, go to

    Template Anatomy][1

    in the CloudFormation User Guide.

    Conditional: You must pass `TemplateURL` or `TemplateBody`. If both are passed, only `TemplateBody` is used.

    [1]: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html

Returns:

See Also:


6672
6673
6674
6675
# File 'lib/aws-sdk-cloudformation/client.rb', line 6672

def validate_template(params = {}, options = {})
  req = build_request(:validate_template, params)
  req.send_request(options)
end

#wait_until(waiter_name, params = {}, options = {}) {|w.waiter| ... } ⇒ Boolean

Polls an API operation until a resource enters a desired state.

## Basic Usage

A waiter will call an API operation until:

  • It is successful

  • It enters a terminal state

  • It makes the maximum number of attempts

In between attempts, the waiter will sleep.

# polls in a loop, sleeping between attempts
client.wait_until(waiter_name, params)

## Configuration

You can configure the maximum number of polling attempts, and the delay (in seconds) between each polling attempt. You can pass configuration as the final arguments hash.

# poll for ~25 seconds
client.wait_until(waiter_name, params, {
  max_attempts: 5,
  delay: 5,
})

## Callbacks

You can be notified before each polling attempt and before each delay. If you throw `:success` or `:failure` from these callbacks, it will terminate the waiter.

started_at = Time.now
client.wait_until(waiter_name, params, {

  # disable max attempts
  max_attempts: nil,

  # poll for 1 hour, instead of a number of attempts
  before_wait: -> (attempts, response) do
    throw :failure if Time.now - started_at > 3600
  end
})

## Handling Errors

When a waiter is unsuccessful, it will raise an error. All of the failure errors extend from Waiters::Errors::WaiterFailed.

begin
  client.wait_until(...)
rescue Aws::Waiters::Errors::WaiterFailed
  # resource did not enter the desired state in time
end

## Valid Waiters

The following table lists the valid waiter names, the operations they call, and the default `:delay` and `:max_attempts` values.

| waiter_name | params | :delay | :max_attempts | | ————————– | ———————————– | ——– | ————- | | change_set_create_complete | #describe_change_set | 30 | 120 | | stack_create_complete | #describe_stacks | 30 | 120 | | stack_delete_complete | #describe_stacks | 30 | 120 | | stack_exists | #describe_stacks | 5 | 20 | | stack_import_complete | #describe_stacks | 30 | 120 | | stack_rollback_complete | #describe_stacks | 30 | 120 | | stack_update_complete | #describe_stacks | 30 | 120 | | type_registration_complete | #describe_type_registration | 30 | 120 |

Parameters:

  • waiter_name (Symbol)
  • params (Hash) (defaults to: {})

    ({})

  • options (Hash) (defaults to: {})

    ({})

Options Hash (options):

  • :max_attempts (Integer)
  • :delay (Integer)
  • :before_attempt (Proc)
  • :before_wait (Proc)

Yields:

  • (w.waiter)

Returns:

  • (Boolean)

    Returns `true` if the waiter was successful.

Raises:

  • (Errors::FailureStateError)

    Raised when the waiter terminates because the waiter has entered a state that it will not transition out of, preventing success.

  • (Errors::TooManyAttemptsError)

    Raised when the configured maximum number of attempts have been made, and the waiter is not yet successful.

  • (Errors::UnexpectedError)

    Raised when an error is encounted while polling for a resource that is not expected.

  • (Errors::NoSuchWaiterError)

    Raised when you request to wait for an unknown state.


6789
6790
6791
6792
6793
# File 'lib/aws-sdk-cloudformation/client.rb', line 6789

def wait_until(waiter_name, params = {}, options = {})
  w = waiter(waiter_name, options)
  yield(w.waiter) if block_given? # deprecated
  w.wait(params)
end

#waiter_namesObject

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Deprecated.

6797
6798
6799
# File 'lib/aws-sdk-cloudformation/client.rb', line 6797

def waiter_names
  waiters.keys
end