Class: Aws::Imagebuilder::Client

Inherits:
Seahorse::Client::Base show all
Includes:
ClientStubs
Defined in:
gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb

Overview

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

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

For details on configuring region and credentials see the developer guide.

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

Instance Attribute Summary

Attributes inherited from Seahorse::Client::Base

#config, #handlers

API Operations collapse

Instance Method Summary collapse

Methods included from ClientStubs

#api_requests, #stub_data, #stub_responses

Methods inherited from Seahorse::Client::Base

add_plugin, api, clear_plugins, define, new, #operation_names, plugins, remove_plugin, set_api, set_plugins

Methods included from Seahorse::Client::HandlerBuilder

#handle, #handle_request, #handle_response

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :plugins (Array<Seahorse::Client::Plugin>) — default: []] —

    A list of plugins to apply to the client. Each plugin is either a class name or an instance of a plugin class.

  • :credentials (required, Aws::CredentialProvider) —

    Your AWS credentials used for authentication. This can be any class that includes and implements Aws::CredentialProvider, or 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[:credentials]

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

    • ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'], ENV['AWS_SESSION_TOKEN'], and ENV['AWS_ACCOUNT_ID'].

    • ~/.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::InstanceProfileCredentials or Aws::ECSCredentials to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting ENV['AWS_EC2_METADATA_DISABLED'] 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:

    • Aws.config[:region]
    • ENV['AWS_REGION']
    • ENV['AMAZON_REGION']
    • ENV['AWS_DEFAULT_REGION']
    • ~/.aws/credentials
    • ~/.aws/config
  • :access_key_id (String)
  • :account_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.

  • :auth_scheme_preference (Array<String>) —

    A list of preferred authentication schemes to use when making a request. Supported values are: sigv4, sigv4a, httpBearerAuth, and noAuth. When set using ENV['AWS_AUTH_SCHEME_PREFERENCE'] or in shared config as auth_scheme_preference, the value should be a comma-separated list.

  • :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 —

    When true, the SDK will not prepend the modeled host prefix to the endpoint.

  • :disable_request_compression (Boolean) — default: false —

    When set to 'true' the request body will not be compressed for supported operations.

  • :endpoint (String, URI::HTTPS, URI::HTTP) —

    Normally you should not configure the :endpoint option directly. This is normally constructed from the :region option. Configuring :endpoint is normally reserved for connecting to test or custom endpoints. The endpoint should be a URI formatted like:

    'http://example.com'
'https://example.com'
'http://example.com:123'
  • :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.

  • :ignore_configured_endpoint_urls (Boolean) —

    Setting to true disables use of endpoint URLs provided via environment variables and the shared configuration file.

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

  • :request_checksum_calculation (String) — default: "when_supported" —

    Determines when a checksum will be calculated for request payloads. Values are:

    • when_supported - (default) When set, a checksum will be calculated for all request payloads of operations modeled with the httpChecksum trait where requestChecksumRequired is true and/or a requestAlgorithmMember is modeled.
    • when_required - When set, a checksum will only be calculated for request payloads of operations modeled with the httpChecksum trait where requestChecksumRequired is true or where a requestAlgorithmMember is modeled and supplied.
  • :request_min_compression_size_bytes (Integer) — default: 10240 —

    The minimum size in bytes that triggers compression for request bodies. The value must be non-negative integer value between 0 and 10485780 bytes inclusive.

  • :response_checksum_validation (String) — default: "when_supported" —

    Determines when checksum validation will be performed on response payloads. Values are:

    • when_supported - (default) When set, checksum validation is performed on all response payloads of operations modeled with the httpChecksum trait where responseAlgorithms is modeled, except when no modeled checksum algorithms are supported.
    • when_required - When set, checksum validation is not performed on response payloads of operations unless the checksum algorithm is supported and the requestValidationModeMember member is set to ENABLED.
  • :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 https://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.

  • :sdk_ua_app_id (String) —

    A unique and opaque application ID that is appended to the User-Agent header as app/sdk_ua_app_id. It should have a maximum length of 50. This variable is sourced from environment variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.

  • :secret_access_key (String)
  • :session_token (String)
  • :sigv4a_signing_region_set (Array) —

    A list of regions that should be signed with SigV4a signing. When not passed, a default :sigv4a_signing_region_set is searched for in the following locations:

    • Aws.config[:sigv4a_signing_region_set]
    • ENV['AWS_SIGV4A_SIGNING_REGION_SET']
    • ~/.aws/config
  • :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.

  • :telemetry_provider (Aws::Telemetry::TelemetryProviderBase) — default: Aws::Telemetry::NoOpTelemetryProvider —

    Allows you to provide a telemetry provider, which is used to emit telemetry data. By default, uses NoOpTelemetryProvider which will not record or emit any telemetry data. The SDK supports the following telemetry providers:

    • OpenTelemetry (OTel) - To use the OTel provider, install and require the opentelemetry-sdk gem and then, pass in an instance of a Aws::Telemetry::OTelProvider for telemetry provider.
  • :token_provider (Aws::TokenProvider) —

    Your Bearer token used for authentication. This can be any class that includes and implements Aws::TokenProvider, or instance of any one of the following classes:

    • Aws::StaticTokenProvider - Used for configuring static, non-refreshing tokens.

    • Aws::SSOTokenProvider - Used for loading tokens from AWS SSO using an access token generated from aws login.

    When :token_provider is not configured directly, the Aws::TokenProviderChain will be used to search for tokens configured for your profile in shared configuration files.

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

  • :endpoint_provider (Aws::Imagebuilder::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to #resolve_endpoint(parameters) where parameters is a Struct similar to Aws::Imagebuilder::EndpointParameters.

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

  • :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_open_timeout (Float) — default: 15 —

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

  • :http_proxy (URI::HTTP, String) —

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

  • :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_wire_trace (Boolean) — default: false —

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

  • :on_chunk_received (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the response body is received. It provides three arguments: the chunk, the number of bytes received, and the total number of bytes in the response (or nil if the server did not send a content-length).

  • :on_chunk_sent (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the request body is sent. It provides three arguments: the chunk, the number of bytes read from the body, and the total number of bytes in the body.

  • :raise_response_errors (Boolean) — default: true —

    When true, response errors are raised.

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

  • :ssl_ca_store (String) —

    Sets the X509::Store to verify peer certificate.

  • :ssl_cert (OpenSSL::X509::Certificate) —

    Sets a client certificate when creating http connections.

  • :ssl_key (OpenSSL::PKey) —

    Sets a client key when creating http connections.

  • :ssl_timeout (Float) —

    Sets the SSL timeout in seconds

  • :ssl_verify_peer (Boolean) — default: true —

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



473
474
475
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 473

def initialize(*args)
  super
end

Instance Method Details

#cancel_image_creation(params = {}) ⇒ Types::CancelImageCreationResponse

CancelImageCreation cancels the creation of Image. This operation can only be used on images in a non-terminal state.

Examples:

Request syntax with placeholder values


resp = client.cancel_image_creation({
  image_build_version_arn: "ImageBuildVersionArn", # required
  client_token: "ClientToken", # required
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.image_build_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_build_version_arn (required, String) —

    The Amazon Resource Name (ARN) of the image that you want to cancel creation for.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



521
522
523
524
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 521

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

#cancel_lifecycle_execution(params = {}) ⇒ Types::CancelLifecycleExecutionResponse

Cancel a specific image lifecycle policy runtime instance.

Examples:

Request syntax with placeholder values


resp = client.cancel_lifecycle_execution({
  lifecycle_execution_id: "LifecycleExecutionId", # required
  client_token: "ClientToken", # required
})

Response structure


resp.lifecycle_execution_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :lifecycle_execution_id (required, String) —

    Identifies the specific runtime instance of the image lifecycle to cancel.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



563
564
565
566
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 563

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

#create_component(params = {}) ⇒ Types::CreateComponentResponse

Creates a new component that can be used to build, validate, test, and assess your image. The component is based on a YAML document that you specify using exactly one of the following methods:

  • Inline, using the data property in the request body.

  • A URL that points to a YAML document file stored in Amazon S3, using the uri property in the request body.

Examples:

Request syntax with placeholder values


resp = client.create_component({
  name: "ResourceName", # required
  semantic_version: "VersionNumber", # required
  description: "NonEmptyString",
  change_description: "NonEmptyString",
  platform: "Windows", # required, accepts Windows, Linux, macOS
  supported_os_versions: ["OsVersion"],
  data: "InlineComponentData",
  uri: "Uri",
  kms_key_id: "NonEmptyString",
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
  dry_run: false,
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.component_build_version_arn #=> String
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the component.

  • :semantic_version (required, String) —

    The semantic version of the component. This version follows the semantic version syntax.

    The semantic version has four nodes: <major>.<minor>.<patch>/<build>. You can assign values for the first three, and can filter on all of them.

    Assignment: For the first three nodes you can assign any positive integer value, including zero, with an upper limit of 230-1, or 1073741823 for each node. Image Builder automatically assigns the build number to the fourth node.

    Patterns: You can use any numeric pattern that adheres to the assignment requirements for the nodes that you can assign. For example, you might choose a software version pattern, such as 1.0.0, or a date, such as 2021.01.01.

  • :description (String) —

    Describes the contents of the component.

  • :change_description (String) —

    The change description of the component. Describes what change has been made in this version, or what makes this version different from other versions of the component.

  • :platform (required, String) —

    The operating system platform of the component.

  • :supported_os_versions (Array<String>) —

    The operating system (OS) version supported by the component. If the OS information is available, a prefix match is performed against the base image OS version during image recipe creation.

  • :data (String) —

    Component data contains inline YAML document content for the component. Alternatively, you can specify the uri of a YAML document file stored in Amazon S3. However, you cannot specify both properties.

  • :uri (String) —

    The uri of a YAML component document file. This must be an S3 URL (s3://bucket/key), and the requester must have permission to access the S3 bucket it points to. If you use Amazon S3, you can specify component content up to your service quota.

    Alternatively, you can specify the YAML document inline, using the component data property. You cannot specify both properties.

  • :kms_key_id (String) —

    The Amazon Resource Name (ARN) that uniquely identifies the KMS key used to encrypt this component. This can be either the Key ARN or the Alias ARN. For more information, see Key identifiers (KeyId) in the Key Management Service Developer Guide.

  • :tags (Hash<String,String>) —

    The tags that apply to the component.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

  • :dry_run (Boolean) —

    Validates the required permissions for the operation and the request parameters, without actually making the request, and provides an error response. Upon a successful request, the error response is DryRunOperationException.

Returns:

See Also:



701
702
703
704
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 701

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

#create_container_recipe(params = {}) ⇒ Types::CreateContainerRecipeResponse

Creates a new container recipe. Container recipes define how images are configured, tested, and assessed.

Examples:

Request syntax with placeholder values


resp = client.create_container_recipe({
  container_type: "DOCKER", # required, accepts DOCKER
  name: "ResourceName", # required
  description: "NonEmptyString",
  semantic_version: "WildcardVersionNumber", # required
  components: [
    {
      component_arn: "ComponentVersionArnOrBuildVersionArn", # required
      parameters: [
        {
          name: "ComponentParameterName", # required
          value: ["ComponentParameterValue"], # required
        },
      ],
    },
  ],
  instance_configuration: {
    image: "NonEmptyString",
    block_device_mappings: [
      {
        device_name: "NonEmptyString",
        ebs: {
          encrypted: false,
          delete_on_termination: false,
          iops: 1,
          kms_key_id: "NonEmptyString",
          snapshot_id: "NonEmptyString",
          volume_size: 1,
          volume_type: "standard", # accepts standard, io1, io2, gp2, gp3, sc1, st1
          throughput: 1,
        },
        virtual_name: "NonEmptyString",
        no_device: "EmptyString",
      },
    ],
  },
  dockerfile_template_data: "InlineDockerFileTemplate",
  dockerfile_template_uri: "Uri",
  platform_override: "Windows", # accepts Windows, Linux, macOS
  image_os_version_override: "NonEmptyString",
  parent_image: "NonEmptyString", # required
  tags: {
    "TagKey" => "TagValue",
  },
  working_directory: "NonEmptyString",
  target_repository: { # required
    service: "ECR", # required, accepts ECR
    repository_name: "NonEmptyString", # required
  },
  kms_key_id: "NonEmptyString",
  client_token: "ClientToken", # required
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.container_recipe_arn #=> String
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :container_type (required, String) —

    The type of container to create.

  • :name (required, String) —

    The name of the container recipe.

  • :description (String) —

    The description of the container recipe.

  • :semantic_version (required, String) —

    The semantic version of the container recipe. This version follows the semantic version syntax.

    The semantic version has four nodes: <major>.<minor>.<patch>/<build>. You can assign values for the first three, and can filter on all of them.

    Assignment: For the first three nodes you can assign any positive integer value, including zero, with an upper limit of 230-1, or 1073741823 for each node. Image Builder automatically assigns the build number to the fourth node.

    Patterns: You can use any numeric pattern that adheres to the assignment requirements for the nodes that you can assign. For example, you might choose a software version pattern, such as 1.0.0, or a date, such as 2021.01.01.

  • :components (Array<Types::ComponentConfiguration>) —

    The components included in the container recipe.

  • :instance_configuration (Types::InstanceConfiguration) —

    A group of options that can be used to configure an instance for building and testing container images.

  • :dockerfile_template_data (String) —

    The Dockerfile template used to build your image as an inline data blob.

  • :dockerfile_template_uri (String) —

    The Amazon S3 URI for the Dockerfile that will be used to build your container image.

  • :platform_override (String) —

    Specifies the operating system platform when you use a custom base image.

  • :image_os_version_override (String) —

    Specifies the operating system version for the base image.

  • :parent_image (required, String) —

    The base image for the container recipe.

  • :tags (Hash<String,String>) —

    Tags that are attached to the container recipe.

  • :working_directory (String) —

    The working directory for use during build and test workflows.

  • :target_repository (required, Types::TargetContainerRepository) —

    The destination repository for the container image.

  • :kms_key_id (String) —

    The Amazon Resource Name (ARN) that uniquely identifies which KMS key is used to encrypt the Dockerfile template. This can be either the Key ARN or the Alias ARN. For more information, see Key identifiers (KeyId) in the Key Management Service Developer Guide.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



870
871
872
873
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 870

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

#create_distribution_configuration(params = {}) ⇒ Types::CreateDistributionConfigurationResponse

Creates a new distribution configuration. Distribution configurations define and configure the outputs of your pipeline.

Examples:

Request syntax with placeholder values


resp = client.create_distribution_configuration({
  name: "ResourceName", # required
  description: "NonEmptyString",
  distributions: [ # required
    {
      region: "NonEmptyString", # required
      ami_distribution_configuration: {
        name: "AmiNameString",
        description: "NonEmptyString",
        target_account_ids: ["AccountId"],
        ami_tags: {
          "TagKey" => "TagValue",
        },
        kms_key_id: "NonEmptyString",
        launch_permission: {
          user_ids: ["AccountId"],
          user_groups: ["NonEmptyString"],
          organization_arns: ["OrganizationArn"],
          organizational_unit_arns: ["OrganizationalUnitArn"],
        },
      },
      container_distribution_configuration: {
        description: "NonEmptyString",
        container_tags: ["NonEmptyString"],
        target_repository: { # required
          service: "ECR", # required, accepts ECR
          repository_name: "NonEmptyString", # required
        },
      },
      license_configuration_arns: ["LicenseConfigurationArn"],
      launch_template_configurations: [
        {
          launch_template_id: "LaunchTemplateId", # required
          account_id: "AccountId",
          set_default_version: false,
        },
      ],
      s3_export_configuration: {
        role_name: "NonEmptyString", # required
        disk_image_format: "VMDK", # required, accepts VMDK, RAW, VHD
        s3_bucket: "NonEmptyString", # required
        s3_prefix: "NonEmptyString",
      },
      fast_launch_configurations: [
        {
          enabled: false, # required
          snapshot_configuration: {
            target_resource_count: 1,
          },
          max_parallel_launches: 1,
          launch_template: {
            launch_template_id: "LaunchTemplateId",
            launch_template_name: "NonEmptyString",
            launch_template_version: "NonEmptyString",
          },
          account_id: "AccountId",
        },
      ],
      ssm_parameter_configurations: [
        {
          ami_account_id: "AccountId",
          parameter_name: "SsmParameterName", # required
          data_type: "text", # accepts text, aws:ec2:image
        },
      ],
    },
  ],
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.distribution_configuration_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the distribution configuration.

  • :description (String) —

    The description of the distribution configuration.

  • :distributions (required, Array<Types::Distribution>) —

    The distributions of the distribution configuration.

  • :tags (Hash<String,String>) —

    The tags of the distribution configuration.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



993
994
995
996
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 993

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

#create_image(params = {}) ⇒ Types::CreateImageResponse

Creates a new image. This request will create a new image along with all of the configured output resources defined in the distribution configuration. You must specify exactly one recipe for your image, using either a ContainerRecipeArn or an ImageRecipeArn.

Examples:

Request syntax with placeholder values


resp = client.create_image({
  image_recipe_arn: "ImageRecipeArn",
  container_recipe_arn: "ContainerRecipeArn",
  distribution_configuration_arn: "DistributionConfigurationArn",
  infrastructure_configuration_arn: "InfrastructureConfigurationArn", # required
  image_tests_configuration: {
    image_tests_enabled: false,
    timeout_minutes: 1,
  },
  enhanced_image_metadata_enabled: false,
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
  image_scanning_configuration: {
    image_scanning_enabled: false,
    ecr_configuration: {
      repository_name: "NonEmptyString",
      container_tags: ["NonEmptyString"],
    },
  },
  workflows: [
    {
      workflow_arn: "WorkflowVersionArnOrBuildVersionArn", # required
      parameters: [
        {
          name: "WorkflowParameterName", # required
          value: ["WorkflowParameterValue"], # required
        },
      ],
      parallel_group: "ParallelGroup",
      on_failure: "CONTINUE", # accepts CONTINUE, ABORT
    },
  ],
  execution_role: "RoleNameOrArn",
  logging_configuration: {
    log_group_name: "LogGroupName",
  },
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.image_build_version_arn #=> String
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_recipe_arn (String) —

    The Amazon Resource Name (ARN) of the image recipe that defines how images are configured, tested, and assessed.

  • :container_recipe_arn (String) —

    The Amazon Resource Name (ARN) of the container recipe that defines how images are configured and tested.

  • :distribution_configuration_arn (String) —

    The Amazon Resource Name (ARN) of the distribution configuration that defines and configures the outputs of your pipeline.

  • :infrastructure_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the infrastructure configuration that defines the environment in which your image will be built and tested.

  • :image_tests_configuration (Types::ImageTestsConfiguration) —

    The image tests configuration of the image.

  • :enhanced_image_metadata_enabled (Boolean) —

    Collects additional information about the image being created, including the operating system (OS) version and package list. This information is used to enhance the overall experience of using EC2 Image Builder. Enabled by default.

  • :tags (Hash<String,String>) —

    The tags of the image.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

  • :image_scanning_configuration (Types::ImageScanningConfiguration) —

    Contains settings for vulnerability scans.

  • :workflows (Array<Types::WorkflowConfiguration>) —

    Contains an array of workflow configuration objects.

  • :execution_role (String) —

    The name or Amazon Resource Name (ARN) for the IAM role you create that grants Image Builder access to perform workflow actions.

  • :logging_configuration (Types::ImageLoggingConfiguration) —

    Define logging configuration for the image build process.

Returns:

See Also:



1120
1121
1122
1123
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1120

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

#create_image_pipeline(params = {}) ⇒ Types::CreateImagePipelineResponse

Creates a new image pipeline. Image pipelines enable you to automate the creation and distribution of images.

Examples:

Request syntax with placeholder values


resp = client.create_image_pipeline({
  name: "ResourceName", # required
  description: "NonEmptyString",
  image_recipe_arn: "ImageRecipeArn",
  container_recipe_arn: "ContainerRecipeArn",
  infrastructure_configuration_arn: "InfrastructureConfigurationArn", # required
  distribution_configuration_arn: "DistributionConfigurationArn",
  image_tests_configuration: {
    image_tests_enabled: false,
    timeout_minutes: 1,
  },
  enhanced_image_metadata_enabled: false,
  schedule: {
    schedule_expression: "NonEmptyString",
    timezone: "Timezone",
    pipeline_execution_start_condition: "EXPRESSION_MATCH_ONLY", # accepts EXPRESSION_MATCH_ONLY, EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE
    auto_disable_policy: {
      failure_count: 1, # required
    },
  },
  status: "DISABLED", # accepts DISABLED, ENABLED
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
  image_scanning_configuration: {
    image_scanning_enabled: false,
    ecr_configuration: {
      repository_name: "NonEmptyString",
      container_tags: ["NonEmptyString"],
    },
  },
  workflows: [
    {
      workflow_arn: "WorkflowVersionArnOrBuildVersionArn", # required
      parameters: [
        {
          name: "WorkflowParameterName", # required
          value: ["WorkflowParameterValue"], # required
        },
      ],
      parallel_group: "ParallelGroup",
      on_failure: "CONTINUE", # accepts CONTINUE, ABORT
    },
  ],
  execution_role: "RoleNameOrArn",
  logging_configuration: {
    image_log_group_name: "LogGroupName",
    pipeline_log_group_name: "LogGroupName",
  },
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.image_pipeline_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the image pipeline.

  • :description (String) —

    The description of the image pipeline.

  • :image_recipe_arn (String) —

    The Amazon Resource Name (ARN) of the image recipe that will be used to configure images created by this image pipeline.

  • :container_recipe_arn (String) —

    The Amazon Resource Name (ARN) of the container recipe that is used to configure images created by this container pipeline.

  • :infrastructure_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the infrastructure configuration that will be used to build images created by this image pipeline.

  • :distribution_configuration_arn (String) —

    The Amazon Resource Name (ARN) of the distribution configuration that will be used to configure and distribute images created by this image pipeline.

  • :image_tests_configuration (Types::ImageTestsConfiguration) —

    The image test configuration of the image pipeline.

  • :enhanced_image_metadata_enabled (Boolean) —

    Collects additional information about the image being created, including the operating system (OS) version and package list. This information is used to enhance the overall experience of using EC2 Image Builder. Enabled by default.

  • :schedule (Types::Schedule) —

    The schedule of the image pipeline.

  • :status (String) —

    The status of the image pipeline.

  • :tags (Hash<String,String>) —

    The tags of the image pipeline.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

  • :image_scanning_configuration (Types::ImageScanningConfiguration) —

    Contains settings for vulnerability scans.

  • :workflows (Array<Types::WorkflowConfiguration>) —

    Contains an array of workflow configuration objects.

  • :execution_role (String) —

    The name or Amazon Resource Name (ARN) for the IAM role you create that grants Image Builder access to perform workflow actions.

  • :logging_configuration (Types::PipelineLoggingConfiguration) —

    Define logging configuration for the image build process.

Returns:

See Also:



1264
1265
1266
1267
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1264

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

#create_image_recipe(params = {}) ⇒ Types::CreateImageRecipeResponse

Creates a new image recipe. Image recipes define how images are configured, tested, and assessed.

Examples:

Request syntax with placeholder values


resp = client.create_image_recipe({
  name: "ResourceName", # required
  description: "NonEmptyString",
  semantic_version: "WildcardVersionNumber", # required
  components: [
    {
      component_arn: "ComponentVersionArnOrBuildVersionArn", # required
      parameters: [
        {
          name: "ComponentParameterName", # required
          value: ["ComponentParameterValue"], # required
        },
      ],
    },
  ],
  parent_image: "NonEmptyString", # required
  block_device_mappings: [
    {
      device_name: "NonEmptyString",
      ebs: {
        encrypted: false,
        delete_on_termination: false,
        iops: 1,
        kms_key_id: "NonEmptyString",
        snapshot_id: "NonEmptyString",
        volume_size: 1,
        volume_type: "standard", # accepts standard, io1, io2, gp2, gp3, sc1, st1
        throughput: 1,
      },
      virtual_name: "NonEmptyString",
      no_device: "EmptyString",
    },
  ],
  tags: {
    "TagKey" => "TagValue",
  },
  working_directory: "NonEmptyString",
  additional_instance_configuration: {
    systems_manager_agent: {
      uninstall_after_build: false,
    },
    user_data_override: "UserDataOverride",
  },
  ami_tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.image_recipe_arn #=> String
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the image recipe.

  • :description (String) —

    The description of the image recipe.

  • :semantic_version (required, String) —

    The semantic version of the image recipe. This version follows the semantic version syntax.

    The semantic version has four nodes: <major>.<minor>.<patch>/<build>. You can assign values for the first three, and can filter on all of them.

    Assignment: For the first three nodes you can assign any positive integer value, including zero, with an upper limit of 230-1, or 1073741823 for each node. Image Builder automatically assigns the build number to the fourth node.

    Patterns: You can use any numeric pattern that adheres to the assignment requirements for the nodes that you can assign. For example, you might choose a software version pattern, such as 1.0.0, or a date, such as 2021.01.01.

  • :components (Array<Types::ComponentConfiguration>) —

    The components included in the image recipe.

  • :parent_image (required, String) —

    The base image for customizations specified in the image recipe. You can specify the parent image using one of the following options:

    • AMI ID

    • Image Builder image Amazon Resource Name (ARN)

    • Amazon Web Services Systems Manager (SSM) Parameter Store Parameter, prefixed by ssm:, followed by the parameter name or ARN.

    • Amazon Web Services Marketplace product ID

    If you enter an AMI ID or an SSM parameter that contains the AMI ID, you must have access to the AMI, and the AMI must be in the source Region.

  • :block_device_mappings (Array<Types::InstanceBlockDeviceMapping>) —

    The block device mappings of the image recipe.

  • :tags (Hash<String,String>) —

    The tags of the image recipe.

  • :working_directory (String) —

    The working directory used during build and test workflows.

  • :additional_instance_configuration (Types::AdditionalInstanceConfiguration) —

    Specify additional settings and launch scripts for your build instances.

  • :ami_tags (Hash<String,String>) —

    Tags that are applied to the AMI that Image Builder creates during the Build phase prior to image distribution.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



1419
1420
1421
1422
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1419

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

#create_infrastructure_configuration(params = {}) ⇒ Types::CreateInfrastructureConfigurationResponse

Creates a new infrastructure configuration. An infrastructure configuration defines the environment in which your image will be built and tested.

Examples:

Request syntax with placeholder values


resp = client.create_infrastructure_configuration({
  name: "ResourceName", # required
  description: "NonEmptyString",
  instance_types: ["InstanceType"],
  instance_profile_name: "InstanceProfileNameType", # required
  security_group_ids: ["NonEmptyString"],
  subnet_id: "NonEmptyString",
  logging: {
    s3_logs: {
      s3_bucket_name: "NonEmptyString",
      s3_key_prefix: "NonEmptyString",
    },
  },
  key_pair: "NonEmptyString",
  terminate_instance_on_failure: false,
  sns_topic_arn: "SnsTopicArn",
  resource_tags: {
    "TagKey" => "TagValue",
  },
  instance_metadata_options: {
    http_tokens: "HttpTokens",
    http_put_response_hop_limit: 1,
  },
  tags: {
    "TagKey" => "TagValue",
  },
  placement: {
    availability_zone: "NonEmptyString",
    tenancy: "default", # accepts default, dedicated, host
    host_id: "NonEmptyString",
    host_resource_group_arn: "NonEmptyString",
  },
  client_token: "ClientToken", # required
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.infrastructure_configuration_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the infrastructure configuration.

  • :description (String) —

    The description of the infrastructure configuration.

  • :instance_types (Array<String>) —

    The instance types of the infrastructure configuration. You can specify one or more instance types to use for this build. The service will pick one of these instance types based on availability.

  • :instance_profile_name (required, String) —

    The instance profile to associate with the instance used to customize your Amazon EC2 AMI.

  • :security_group_ids (Array<String>) —

    The security group IDs to associate with the instance used to customize your Amazon EC2 AMI.

  • :subnet_id (String) —

    The subnet ID in which to place the instance used to customize your Amazon EC2 AMI.

  • :logging (Types::Logging) —

    The logging configuration of the infrastructure configuration.

  • :key_pair (String) —

    The key pair of the infrastructure configuration. You can use this to log on to and debug the instance used to create your image.

  • :terminate_instance_on_failure (Boolean) —

    The terminate instance on failure setting of the infrastructure configuration. Set to false if you want Image Builder to retain the instance used to configure your AMI if the build or test phase of your workflow fails.

  • :sns_topic_arn (String) —

    The Amazon Resource Name (ARN) for the SNS topic to which we send image build event notifications.

    EC2 Image Builder is unable to send notifications to SNS topics that are encrypted using keys from other accounts. The key that is used to encrypt the SNS topic must reside in the account that the Image Builder service runs under.

  • :resource_tags (Hash<String,String>) —

    The metadata tags to assign to the Amazon EC2 instance that Image Builder launches during the build process. Tags are formatted as key value pairs.

  • :instance_metadata_options (Types::InstanceMetadataOptions) —

    The instance metadata options that you can set for the HTTP requests that pipeline builds use to launch EC2 build and test instances.

  • :tags (Hash<String,String>) —

    The metadata tags to assign to the infrastructure configuration resource that Image Builder creates as output. Tags are formatted as key value pairs.

  • :placement (Types::Placement) —

    The instance placement settings that define where the instances that are launched from your image will run.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



1558
1559
1560
1561
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1558

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

#create_lifecycle_policy(params = {}) ⇒ Types::CreateLifecyclePolicyResponse

Create a lifecycle policy resource.

Examples:

Request syntax with placeholder values


resp = client.create_lifecycle_policy({
  name: "ResourceName", # required
  description: "NonEmptyString",
  status: "DISABLED", # accepts DISABLED, ENABLED
  execution_role: "RoleNameOrArn", # required
  resource_type: "AMI_IMAGE", # required, accepts AMI_IMAGE, CONTAINER_IMAGE
  policy_details: [ # required
    {
      action: { # required
        type: "DELETE", # required, accepts DELETE, DEPRECATE, DISABLE
        include_resources: {
          amis: false,
          snapshots: false,
          containers: false,
        },
      },
      filter: { # required
        type: "AGE", # required, accepts AGE, COUNT
        value: 1, # required
        unit: "DAYS", # accepts DAYS, WEEKS, MONTHS, YEARS
        retain_at_least: 1,
      },
      exclusion_rules: {
        tag_map: {
          "TagKey" => "TagValue",
        },
        amis: {
          is_public: false,
          regions: ["NonEmptyString"],
          shared_accounts: ["AccountId"],
          last_launched: {
            value: 1, # required
            unit: "DAYS", # required, accepts DAYS, WEEKS, MONTHS, YEARS
          },
          tag_map: {
            "TagKey" => "TagValue",
          },
        },
      },
    },
  ],
  resource_selection: { # required
    recipes: [
      {
        name: "ResourceName", # required
        semantic_version: "VersionNumber", # required
      },
    ],
    tag_map: {
      "TagKey" => "TagValue",
    },
  },
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
})

Response structure


resp.client_token #=> String
resp.lifecycle_policy_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the lifecycle policy to create.

  • :description (String) —

    Optional description for the lifecycle policy.

  • :status (String) —

    Indicates whether the lifecycle policy resource is enabled.

  • :execution_role (required, String) —

    The name or Amazon Resource Name (ARN) for the IAM role you create that grants Image Builder access to run lifecycle actions.

  • :resource_type (required, String) —

    The type of Image Builder resource that the lifecycle policy applies to.

  • :policy_details (required, Array<Types::LifecyclePolicyDetail>) —

    Configuration details for the lifecycle policy rules.

  • :resource_selection (required, Types::LifecyclePolicyResourceSelection) —

    Selection criteria for the resources that the lifecycle policy applies to.

  • :tags (Hash<String,String>) —

    Tags to apply to the lifecycle policy resource.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



1678
1679
1680
1681
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1678

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

#create_workflow(params = {}) ⇒ Types::CreateWorkflowResponse

Create a new workflow or a new version of an existing workflow.

Examples:

Request syntax with placeholder values


resp = client.create_workflow({
  name: "ResourceName", # required
  semantic_version: "VersionNumber", # required
  description: "NonEmptyString",
  change_description: "NonEmptyString",
  data: "InlineWorkflowData",
  uri: "Uri",
  kms_key_id: "NonEmptyString",
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
  type: "BUILD", # required, accepts BUILD, TEST, DISTRIBUTION
  dry_run: false,
})

Response structure


resp.client_token #=> String
resp.workflow_build_version_arn #=> String
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the workflow to create.

  • :semantic_version (required, String) —

    The semantic version of this workflow resource. The semantic version syntax adheres to the following rules.

    The semantic version has four nodes: <major>.<minor>.<patch>/<build>. You can assign values for the first three, and can filter on all of them.

    Assignment: For the first three nodes you can assign any positive integer value, including zero, with an upper limit of 230-1, or 1073741823 for each node. Image Builder automatically assigns the build number to the fourth node.

    Patterns: You can use any numeric pattern that adheres to the assignment requirements for the nodes that you can assign. For example, you might choose a software version pattern, such as 1.0.0, or a date, such as 2021.01.01.

  • :description (String) —

    Describes the workflow.

  • :change_description (String) —

    Describes what change has been made in this version of the workflow, or what makes this version different from other versions of the workflow.

  • :data (String) —

    Contains the UTF-8 encoded YAML document content for the workflow. Alternatively, you can specify the uri of a YAML document file stored in Amazon S3. However, you cannot specify both properties.

  • :uri (String) —

    The uri of a YAML component document file. This must be an S3 URL (s3://bucket/key), and the requester must have permission to access the S3 bucket it points to. If you use Amazon S3, you can specify component content up to your service quota.

    Alternatively, you can specify the YAML document inline, using the component data property. You cannot specify both properties.

  • :kms_key_id (String) —

    The Amazon Resource Name (ARN) that uniquely identifies the KMS key used to encrypt this workflow resource. This can be either the Key ARN or the Alias ARN. For more information, see Key identifiers (KeyId) in the Key Management Service Developer Guide.

  • :tags (Hash<String,String>) —

    Tags that apply to the workflow resource.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

  • :type (required, String) —

    The phase in the image build process for which the workflow resource is responsible.

  • :dry_run (Boolean) —

    Validates the required permissions for the operation and the request parameters, without actually making the request, and provides an error response. Upon a successful request, the error response is DryRunOperationException.

Returns:

See Also:



1802
1803
1804
1805
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1802

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

#delete_component(params = {}) ⇒ Types::DeleteComponentResponse

Deletes a component build version.

Examples:

Request syntax with placeholder values


resp = client.delete_component({
  component_build_version_arn: "ComponentBuildVersionArn", # required
})

Response structure


resp.request_id #=> String
resp.component_build_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :component_build_version_arn (required, String) —

    The Amazon Resource Name (ARN) of the component build version to delete.

Returns:

See Also:



1833
1834
1835
1836
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1833

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

#delete_container_recipe(params = {}) ⇒ Types::DeleteContainerRecipeResponse

Deletes a container recipe.

Examples:

Request syntax with placeholder values


resp = client.delete_container_recipe({
  container_recipe_arn: "ContainerRecipeArn", # required
})

Response structure


resp.request_id #=> String
resp.container_recipe_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :container_recipe_arn (required, String) —

    The Amazon Resource Name (ARN) of the container recipe to delete.

Returns:

See Also:



1863
1864
1865
1866
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1863

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

#delete_distribution_configuration(params = {}) ⇒ Types::DeleteDistributionConfigurationResponse

Deletes a distribution configuration.

Examples:

Request syntax with placeholder values


resp = client.delete_distribution_configuration({
  distribution_configuration_arn: "DistributionConfigurationArn", # required
})

Response structure


resp.request_id #=> String
resp.distribution_configuration_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :distribution_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the distribution configuration to delete.

Returns:

See Also:



1894
1895
1896
1897
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1894

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

#delete_image(params = {}) ⇒ Types::DeleteImageResponse

Deletes an Image Builder image resource. This does not delete any EC2 AMIs or ECR container images that are created during the image build process. You must clean those up separately, using the appropriate Amazon EC2 or Amazon ECR console actions, or API or CLI commands.

Examples:

Request syntax with placeholder values


resp = client.delete_image({
  image_build_version_arn: "ImageBuildVersionArn", # required
})

Response structure


resp.request_id #=> String
resp.image_build_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_build_version_arn (required, String) —

    The Amazon Resource Name (ARN) of the Image Builder image resource to delete.

Returns:

See Also:



1943
1944
1945
1946
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1943

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

#delete_image_pipeline(params = {}) ⇒ Types::DeleteImagePipelineResponse

Deletes an image pipeline.

Examples:

Request syntax with placeholder values


resp = client.delete_image_pipeline({
  image_pipeline_arn: "ImagePipelineArn", # required
})

Response structure


resp.request_id #=> String
resp.image_pipeline_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_pipeline_arn (required, String) —

    The Amazon Resource Name (ARN) of the image pipeline to delete.

Returns:

See Also:



1973
1974
1975
1976
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 1973

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

#delete_image_recipe(params = {}) ⇒ Types::DeleteImageRecipeResponse

Deletes an image recipe.

Examples:

Request syntax with placeholder values


resp = client.delete_image_recipe({
  image_recipe_arn: "ImageRecipeArn", # required
})

Response structure


resp.request_id #=> String
resp.image_recipe_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_recipe_arn (required, String) —

    The Amazon Resource Name (ARN) of the image recipe to delete.

Returns:

See Also:



2003
2004
2005
2006
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2003

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

#delete_infrastructure_configuration(params = {}) ⇒ Types::DeleteInfrastructureConfigurationResponse

Deletes an infrastructure configuration.

Examples:

Request syntax with placeholder values


resp = client.delete_infrastructure_configuration({
  infrastructure_configuration_arn: "InfrastructureConfigurationArn", # required
})

Response structure


resp.request_id #=> String
resp.infrastructure_configuration_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :infrastructure_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the infrastructure configuration to delete.

Returns:

See Also:



2034
2035
2036
2037
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2034

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

#delete_lifecycle_policy(params = {}) ⇒ Types::DeleteLifecyclePolicyResponse

Delete the specified lifecycle policy resource.

Examples:

Request syntax with placeholder values


resp = client.delete_lifecycle_policy({
  lifecycle_policy_arn: "LifecyclePolicyArn", # required
})

Response structure


resp.lifecycle_policy_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :lifecycle_policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the lifecycle policy resource to delete.

Returns:

See Also:



2063
2064
2065
2066
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2063

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

#delete_workflow(params = {}) ⇒ Types::DeleteWorkflowResponse

Deletes a specific workflow resource.

Examples:

Request syntax with placeholder values


resp = client.delete_workflow({
  workflow_build_version_arn: "WorkflowBuildVersionArn", # required
})

Response structure


resp.workflow_build_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :workflow_build_version_arn (required, String) —

    The Amazon Resource Name (ARN) of the workflow resource to delete.

Returns:

See Also:



2091
2092
2093
2094
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2091

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

#distribute_image(params = {}) ⇒ Types::DistributeImageResponse

DistributeImage distributes existing AMIs to additional regions and accounts without rebuilding the image.

Examples:

Request syntax with placeholder values


resp = client.distribute_image({
  source_image: "NonEmptyString", # required
  distribution_configuration_arn: "DistributionConfigurationArn", # required
  execution_role: "RoleNameOrArn", # required
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
  logging_configuration: {
    log_group_name: "LogGroupName",
  },
})

Response structure


resp.client_token #=> String
resp.image_build_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :source_image (required, String) —

    The source image Amazon Resource Name (ARN) to distribute.

  • :distribution_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the distribution configuration to use.

  • :execution_role (required, String) —

    The IAM role to use for the distribution.

  • :tags (Hash<String,String>) —

    The tags to apply to the distributed image.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

  • :logging_configuration (Types::ImageLoggingConfiguration) —

    The logging configuration for the distribution.

Returns:

See Also:



2156
2157
2158
2159
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2156

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

#get_component(params = {}) ⇒ Types::GetComponentResponse

Gets a component object.

Examples:

Request syntax with placeholder values


resp = client.get_component({
  component_build_version_arn: "ComponentVersionArnOrBuildVersionArn", # required
})

Response structure


resp.request_id #=> String
resp.component.arn #=> String
resp.component.name #=> String
resp.component.version #=> String
resp.component.description #=> String
resp.component.change_description #=> String
resp.component.type #=> String, one of "BUILD", "TEST"
resp.component.platform #=> String, one of "Windows", "Linux", "macOS"
resp.component.supported_os_versions #=> Array
resp.component.supported_os_versions[0] #=> String
resp.component.state.status #=> String, one of "DEPRECATED", "DISABLED", "ACTIVE"
resp.component.state.reason #=> String
resp.component.parameters #=> Array
resp.component.parameters[0].name #=> String
resp.component.parameters[0].type #=> String
resp.component.parameters[0].default_value #=> Array
resp.component.parameters[0].default_value[0] #=> String
resp.component.parameters[0].description #=> String
resp.component.owner #=> String
resp.component.data #=> String
resp.component.kms_key_id #=> String
resp.component.encrypted #=> Boolean
resp.component.date_created #=> String
resp.component.tags #=> Hash
resp.component.tags["TagKey"] #=> String
resp.component.publisher #=> String
resp.component.obfuscate #=> Boolean
resp.component.product_codes #=> Array
resp.component.product_codes[0].product_code_id #=> String
resp.component.product_codes[0].product_code_type #=> String, one of "marketplace"
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :component_build_version_arn (required, String) —

    The Amazon Resource Name (ARN) of the component that you want to get. Regex requires the suffix /\d+$.

Returns:

See Also:



2220
2221
2222
2223
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2220

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

#get_component_policy(params = {}) ⇒ Types::GetComponentPolicyResponse

Gets a component policy.

Examples:

Request syntax with placeholder values


resp = client.get_component_policy({
  component_arn: "ComponentBuildVersionArn", # required
})

Response structure


resp.request_id #=> String
resp.policy #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :component_arn (required, String) —

    The Amazon Resource Name (ARN) of the component whose policy you want to retrieve.

Returns:

See Also:



2251
2252
2253
2254
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2251

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

#get_container_recipe(params = {}) ⇒ Types::GetContainerRecipeResponse

Retrieves a container recipe.

Examples:

Request syntax with placeholder values


resp = client.get_container_recipe({
  container_recipe_arn: "ContainerRecipeArn", # required
})

Response structure


resp.request_id #=> String
resp.container_recipe.arn #=> String
resp.container_recipe.container_type #=> String, one of "DOCKER"
resp.container_recipe.name #=> String
resp.container_recipe.description #=> String
resp.container_recipe.platform #=> String, one of "Windows", "Linux", "macOS"
resp.container_recipe.owner #=> String
resp.container_recipe.version #=> String
resp.container_recipe.components #=> Array
resp.container_recipe.components[0].component_arn #=> String
resp.container_recipe.components[0].parameters #=> Array
resp.container_recipe.components[0].parameters[0].name #=> String
resp.container_recipe.components[0].parameters[0].value #=> Array
resp.container_recipe.components[0].parameters[0].value[0] #=> String
resp.container_recipe.instance_configuration.image #=> String
resp.container_recipe.instance_configuration.block_device_mappings #=> Array
resp.container_recipe.instance_configuration.block_device_mappings[0].device_name #=> String
resp.container_recipe.instance_configuration.block_device_mappings[0].ebs.encrypted #=> Boolean
resp.container_recipe.instance_configuration.block_device_mappings[0].ebs.delete_on_termination #=> Boolean
resp.container_recipe.instance_configuration.block_device_mappings[0].ebs.iops #=> Integer
resp.container_recipe.instance_configuration.block_device_mappings[0].ebs.kms_key_id #=> String
resp.container_recipe.instance_configuration.block_device_mappings[0].ebs.snapshot_id #=> String
resp.container_recipe.instance_configuration.block_device_mappings[0].ebs.volume_size #=> Integer
resp.container_recipe.instance_configuration.block_device_mappings[0].ebs.volume_type #=> String, one of "standard", "io1", "io2", "gp2", "gp3", "sc1", "st1"
resp.container_recipe.instance_configuration.block_device_mappings[0].ebs.throughput #=> Integer
resp.container_recipe.instance_configuration.block_device_mappings[0].virtual_name #=> String
resp.container_recipe.instance_configuration.block_device_mappings[0].no_device #=> String
resp.container_recipe.dockerfile_template_data #=> String
resp.container_recipe.kms_key_id #=> String
resp.container_recipe.encrypted #=> Boolean
resp.container_recipe.parent_image #=> String
resp.container_recipe.date_created #=> String
resp.container_recipe.tags #=> Hash
resp.container_recipe.tags["TagKey"] #=> String
resp.container_recipe.working_directory #=> String
resp.container_recipe.target_repository.service #=> String, one of "ECR"
resp.container_recipe.target_repository.repository_name #=> String
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :container_recipe_arn (required, String) —

    The Amazon Resource Name (ARN) of the container recipe to retrieve.

Returns:

See Also:



2321
2322
2323
2324
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2321

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

#get_container_recipe_policy(params = {}) ⇒ Types::GetContainerRecipePolicyResponse

Retrieves the policy for a container recipe.

Examples:

Request syntax with placeholder values


resp = client.get_container_recipe_policy({
  container_recipe_arn: "ContainerRecipeArn", # required
})

Response structure


resp.request_id #=> String
resp.policy #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :container_recipe_arn (required, String) —

    The Amazon Resource Name (ARN) of the container recipe for the policy being requested.

Returns:

See Also:



2352
2353
2354
2355
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2352

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

#get_distribution_configuration(params = {}) ⇒ Types::GetDistributionConfigurationResponse

Gets a distribution configuration.

Examples:

Request syntax with placeholder values


resp = client.get_distribution_configuration({
  distribution_configuration_arn: "DistributionConfigurationArn", # required
})

Response structure


resp.request_id #=> String
resp.distribution_configuration.arn #=> String
resp.distribution_configuration.name #=> String
resp.distribution_configuration.description #=> String
resp.distribution_configuration.distributions #=> Array
resp.distribution_configuration.distributions[0].region #=> String
resp.distribution_configuration.distributions[0].ami_distribution_configuration.name #=> String
resp.distribution_configuration.distributions[0].ami_distribution_configuration.description #=> String
resp.distribution_configuration.distributions[0].ami_distribution_configuration. #=> Array
resp.distribution_configuration.distributions[0].ami_distribution_configuration.[0] #=> String
resp.distribution_configuration.distributions[0].ami_distribution_configuration.ami_tags #=> Hash
resp.distribution_configuration.distributions[0].ami_distribution_configuration.ami_tags["TagKey"] #=> String
resp.distribution_configuration.distributions[0].ami_distribution_configuration.kms_key_id #=> String
resp.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.user_ids #=> Array
resp.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.user_ids[0] #=> String
resp.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.user_groups #=> Array
resp.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.user_groups[0] #=> String
resp.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.organization_arns #=> Array
resp.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.organization_arns[0] #=> String
resp.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.organizational_unit_arns #=> Array
resp.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.organizational_unit_arns[0] #=> String
resp.distribution_configuration.distributions[0].container_distribution_configuration.description #=> String
resp.distribution_configuration.distributions[0].container_distribution_configuration.container_tags #=> Array
resp.distribution_configuration.distributions[0].container_distribution_configuration.container_tags[0] #=> String
resp.distribution_configuration.distributions[0].container_distribution_configuration.target_repository.service #=> String, one of "ECR"
resp.distribution_configuration.distributions[0].container_distribution_configuration.target_repository.repository_name #=> String
resp.distribution_configuration.distributions[0].license_configuration_arns #=> Array
resp.distribution_configuration.distributions[0].license_configuration_arns[0] #=> String
resp.distribution_configuration.distributions[0].launch_template_configurations #=> Array
resp.distribution_configuration.distributions[0].launch_template_configurations[0].launch_template_id #=> String
resp.distribution_configuration.distributions[0].launch_template_configurations[0]. #=> String
resp.distribution_configuration.distributions[0].launch_template_configurations[0].set_default_version #=> Boolean
resp.distribution_configuration.distributions[0].s3_export_configuration.role_name #=> String
resp.distribution_configuration.distributions[0].s3_export_configuration.disk_image_format #=> String, one of "VMDK", "RAW", "VHD"
resp.distribution_configuration.distributions[0].s3_export_configuration.s3_bucket #=> String
resp.distribution_configuration.distributions[0].s3_export_configuration.s3_prefix #=> String
resp.distribution_configuration.distributions[0].fast_launch_configurations #=> Array
resp.distribution_configuration.distributions[0].fast_launch_configurations[0].enabled #=> Boolean
resp.distribution_configuration.distributions[0].fast_launch_configurations[0].snapshot_configuration.target_resource_count #=> Integer
resp.distribution_configuration.distributions[0].fast_launch_configurations[0].max_parallel_launches #=> Integer
resp.distribution_configuration.distributions[0].fast_launch_configurations[0].launch_template.launch_template_id #=> String
resp.distribution_configuration.distributions[0].fast_launch_configurations[0].launch_template.launch_template_name #=> String
resp.distribution_configuration.distributions[0].fast_launch_configurations[0].launch_template.launch_template_version #=> String
resp.distribution_configuration.distributions[0].fast_launch_configurations[0]. #=> String
resp.distribution_configuration.distributions[0].ssm_parameter_configurations #=> Array
resp.distribution_configuration.distributions[0].ssm_parameter_configurations[0]. #=> String
resp.distribution_configuration.distributions[0].ssm_parameter_configurations[0].parameter_name #=> String
resp.distribution_configuration.distributions[0].ssm_parameter_configurations[0].data_type #=> String, one of "text", "aws:ec2:image"
resp.distribution_configuration.timeout_minutes #=> Integer
resp.distribution_configuration.date_created #=> String
resp.distribution_configuration.date_updated #=> String
resp.distribution_configuration.tags #=> Hash
resp.distribution_configuration.tags["TagKey"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :distribution_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the distribution configuration that you want to retrieve.

Returns:

See Also:



2434
2435
2436
2437
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2434

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

#get_image(params = {}) ⇒ Types::GetImageResponse

Gets an image.

Examples:

Request syntax with placeholder values


resp = client.get_image({
  image_build_version_arn: "ImageVersionArnOrBuildVersionArn", # required
})

Response structure


resp.request_id #=> String
resp.image.arn #=> String
resp.image.type #=> String, one of "AMI", "DOCKER"
resp.image.name #=> String
resp.image.version #=> String
resp.image.platform #=> String, one of "Windows", "Linux", "macOS"
resp.image.enhanced_image_metadata_enabled #=> Boolean
resp.image.os_version #=> String
resp.image.state.status #=> String, one of "PENDING", "CREATING", "BUILDING", "TESTING", "DISTRIBUTING", "INTEGRATING", "AVAILABLE", "CANCELLED", "FAILED", "DEPRECATED", "DELETED", "DISABLED"
resp.image.state.reason #=> String
resp.image.image_recipe.arn #=> String
resp.image.image_recipe.type #=> String, one of "AMI", "DOCKER"
resp.image.image_recipe.name #=> String
resp.image.image_recipe.description #=> String
resp.image.image_recipe.platform #=> String, one of "Windows", "Linux", "macOS"
resp.image.image_recipe.owner #=> String
resp.image.image_recipe.version #=> String
resp.image.image_recipe.components #=> Array
resp.image.image_recipe.components[0].component_arn #=> String
resp.image.image_recipe.components[0].parameters #=> Array
resp.image.image_recipe.components[0].parameters[0].name #=> String
resp.image.image_recipe.components[0].parameters[0].value #=> Array
resp.image.image_recipe.components[0].parameters[0].value[0] #=> String
resp.image.image_recipe.parent_image #=> String
resp.image.image_recipe.block_device_mappings #=> Array
resp.image.image_recipe.block_device_mappings[0].device_name #=> String
resp.image.image_recipe.block_device_mappings[0].ebs.encrypted #=> Boolean
resp.image.image_recipe.block_device_mappings[0].ebs.delete_on_termination #=> Boolean
resp.image.image_recipe.block_device_mappings[0].ebs.iops #=> Integer
resp.image.image_recipe.block_device_mappings[0].ebs.kms_key_id #=> String
resp.image.image_recipe.block_device_mappings[0].ebs.snapshot_id #=> String
resp.image.image_recipe.block_device_mappings[0].ebs.volume_size #=> Integer
resp.image.image_recipe.block_device_mappings[0].ebs.volume_type #=> String, one of "standard", "io1", "io2", "gp2", "gp3", "sc1", "st1"
resp.image.image_recipe.block_device_mappings[0].ebs.throughput #=> Integer
resp.image.image_recipe.block_device_mappings[0].virtual_name #=> String
resp.image.image_recipe.block_device_mappings[0].no_device #=> String
resp.image.image_recipe.date_created #=> String
resp.image.image_recipe.tags #=> Hash
resp.image.image_recipe.tags["TagKey"] #=> String
resp.image.image_recipe.working_directory #=> String
resp.image.image_recipe.additional_instance_configuration.systems_manager_agent.uninstall_after_build #=> Boolean
resp.image.image_recipe.additional_instance_configuration.user_data_override #=> String
resp.image.image_recipe.ami_tags #=> Hash
resp.image.image_recipe.ami_tags["TagKey"] #=> String
resp.image.container_recipe.arn #=> String
resp.image.container_recipe.container_type #=> String, one of "DOCKER"
resp.image.container_recipe.name #=> String
resp.image.container_recipe.description #=> String
resp.image.container_recipe.platform #=> String, one of "Windows", "Linux", "macOS"
resp.image.container_recipe.owner #=> String
resp.image.container_recipe.version #=> String
resp.image.container_recipe.components #=> Array
resp.image.container_recipe.components[0].component_arn #=> String
resp.image.container_recipe.components[0].parameters #=> Array
resp.image.container_recipe.components[0].parameters[0].name #=> String
resp.image.container_recipe.components[0].parameters[0].value #=> Array
resp.image.container_recipe.components[0].parameters[0].value[0] #=> String
resp.image.container_recipe.instance_configuration.image #=> String
resp.image.container_recipe.instance_configuration.block_device_mappings #=> Array
resp.image.container_recipe.instance_configuration.block_device_mappings[0].device_name #=> String
resp.image.container_recipe.instance_configuration.block_device_mappings[0].ebs.encrypted #=> Boolean
resp.image.container_recipe.instance_configuration.block_device_mappings[0].ebs.delete_on_termination #=> Boolean
resp.image.container_recipe.instance_configuration.block_device_mappings[0].ebs.iops #=> Integer
resp.image.container_recipe.instance_configuration.block_device_mappings[0].ebs.kms_key_id #=> String
resp.image.container_recipe.instance_configuration.block_device_mappings[0].ebs.snapshot_id #=> String
resp.image.container_recipe.instance_configuration.block_device_mappings[0].ebs.volume_size #=> Integer
resp.image.container_recipe.instance_configuration.block_device_mappings[0].ebs.volume_type #=> String, one of "standard", "io1", "io2", "gp2", "gp3", "sc1", "st1"
resp.image.container_recipe.instance_configuration.block_device_mappings[0].ebs.throughput #=> Integer
resp.image.container_recipe.instance_configuration.block_device_mappings[0].virtual_name #=> String
resp.image.container_recipe.instance_configuration.block_device_mappings[0].no_device #=> String
resp.image.container_recipe.dockerfile_template_data #=> String
resp.image.container_recipe.kms_key_id #=> String
resp.image.container_recipe.encrypted #=> Boolean
resp.image.container_recipe.parent_image #=> String
resp.image.container_recipe.date_created #=> String
resp.image.container_recipe.tags #=> Hash
resp.image.container_recipe.tags["TagKey"] #=> String
resp.image.container_recipe.working_directory #=> String
resp.image.container_recipe.target_repository.service #=> String, one of "ECR"
resp.image.container_recipe.target_repository.repository_name #=> String
resp.image.source_pipeline_name #=> String
resp.image.source_pipeline_arn #=> String
resp.image.infrastructure_configuration.arn #=> String
resp.image.infrastructure_configuration.name #=> String
resp.image.infrastructure_configuration.description #=> String
resp.image.infrastructure_configuration.instance_types #=> Array
resp.image.infrastructure_configuration.instance_types[0] #=> String
resp.image.infrastructure_configuration.instance_profile_name #=> String
resp.image.infrastructure_configuration.security_group_ids #=> Array
resp.image.infrastructure_configuration.security_group_ids[0] #=> String
resp.image.infrastructure_configuration.subnet_id #=> String
resp.image.infrastructure_configuration.logging.s3_logs.s3_bucket_name #=> String
resp.image.infrastructure_configuration.logging.s3_logs.s3_key_prefix #=> String
resp.image.infrastructure_configuration.key_pair #=> String
resp.image.infrastructure_configuration.terminate_instance_on_failure #=> Boolean
resp.image.infrastructure_configuration.sns_topic_arn #=> String
resp.image.infrastructure_configuration.date_created #=> String
resp.image.infrastructure_configuration.date_updated #=> String
resp.image.infrastructure_configuration.resource_tags #=> Hash
resp.image.infrastructure_configuration.resource_tags["TagKey"] #=> String
resp.image.infrastructure_configuration.instance_metadata_options.http_tokens #=> String
resp.image.infrastructure_configuration.instance_metadata_options.http_put_response_hop_limit #=> Integer
resp.image.infrastructure_configuration.tags #=> Hash
resp.image.infrastructure_configuration.tags["TagKey"] #=> String
resp.image.infrastructure_configuration.placement.availability_zone #=> String
resp.image.infrastructure_configuration.placement.tenancy #=> String, one of "default", "dedicated", "host"
resp.image.infrastructure_configuration.placement.host_id #=> String
resp.image.infrastructure_configuration.placement.host_resource_group_arn #=> String
resp.image.distribution_configuration.arn #=> String
resp.image.distribution_configuration.name #=> String
resp.image.distribution_configuration.description #=> String
resp.image.distribution_configuration.distributions #=> Array
resp.image.distribution_configuration.distributions[0].region #=> String
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.name #=> String
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.description #=> String
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration. #=> Array
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.[0] #=> String
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.ami_tags #=> Hash
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.ami_tags["TagKey"] #=> String
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.kms_key_id #=> String
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.user_ids #=> Array
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.user_ids[0] #=> String
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.user_groups #=> Array
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.user_groups[0] #=> String
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.organization_arns #=> Array
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.organization_arns[0] #=> String
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.organizational_unit_arns #=> Array
resp.image.distribution_configuration.distributions[0].ami_distribution_configuration.launch_permission.organizational_unit_arns[0] #=> String
resp.image.distribution_configuration.distributions[0].container_distribution_configuration.description #=> String
resp.image.distribution_configuration.distributions[0].container_distribution_configuration.container_tags #=> Array
resp.image.distribution_configuration.distributions[0].container_distribution_configuration.container_tags[0] #=> String
resp.image.distribution_configuration.distributions[0].container_distribution_configuration.target_repository.service #=> String, one of "ECR"
resp.image.distribution_configuration.distributions[0].container_distribution_configuration.target_repository.repository_name #=> String
resp.image.distribution_configuration.distributions[0].license_configuration_arns #=> Array
resp.image.distribution_configuration.distributions[0].license_configuration_arns[0] #=> String
resp.image.distribution_configuration.distributions[0].launch_template_configurations #=> Array
resp.image.distribution_configuration.distributions[0].launch_template_configurations[0].launch_template_id #=> String
resp.image.distribution_configuration.distributions[0].launch_template_configurations[0]. #=> String
resp.image.distribution_configuration.distributions[0].launch_template_configurations[0].set_default_version #=> Boolean
resp.image.distribution_configuration.distributions[0].s3_export_configuration.role_name #=> String
resp.image.distribution_configuration.distributions[0].s3_export_configuration.disk_image_format #=> String, one of "VMDK", "RAW", "VHD"
resp.image.distribution_configuration.distributions[0].s3_export_configuration.s3_bucket #=> String
resp.image.distribution_configuration.distributions[0].s3_export_configuration.s3_prefix #=> String
resp.image.distribution_configuration.distributions[0].fast_launch_configurations #=> Array
resp.image.distribution_configuration.distributions[0].fast_launch_configurations[0].enabled #=> Boolean
resp.image.distribution_configuration.distributions[0].fast_launch_configurations[0].snapshot_configuration.target_resource_count #=> Integer
resp.image.distribution_configuration.distributions[0].fast_launch_configurations[0].max_parallel_launches #=> Integer
resp.image.distribution_configuration.distributions[0].fast_launch_configurations[0].launch_template.launch_template_id #=> String
resp.image.distribution_configuration.distributions[0].fast_launch_configurations[0].launch_template.launch_template_name #=> String
resp.image.distribution_configuration.distributions[0].fast_launch_configurations[0].launch_template.launch_template_version #=> String
resp.image.distribution_configuration.distributions[0].fast_launch_configurations[0]. #=> String
resp.image.distribution_configuration.distributions[0].ssm_parameter_configurations #=> Array
resp.image.distribution_configuration.distributions[0].ssm_parameter_configurations[0]. #=> String
resp.image.distribution_configuration.distributions[0].ssm_parameter_configurations[0].parameter_name #=> String
resp.image.distribution_configuration.distributions[0].ssm_parameter_configurations[0].data_type #=> String, one of "text", "aws:ec2:image"
resp.image.distribution_configuration.timeout_minutes #=> Integer
resp.image.distribution_configuration.date_created #=> String
resp.image.distribution_configuration.date_updated #=> String
resp.image.distribution_configuration.tags #=> Hash
resp.image.distribution_configuration.tags["TagKey"] #=> String
resp.image.image_tests_configuration.image_tests_enabled #=> Boolean
resp.image.image_tests_configuration.timeout_minutes #=> Integer
resp.image.date_created #=> String
resp.image.output_resources.amis #=> Array
resp.image.output_resources.amis[0].region #=> String
resp.image.output_resources.amis[0].image #=> String
resp.image.output_resources.amis[0].name #=> String
resp.image.output_resources.amis[0].description #=> String
resp.image.output_resources.amis[0].state.status #=> String, one of "PENDING", "CREATING", "BUILDING", "TESTING", "DISTRIBUTING", "INTEGRATING", "AVAILABLE", "CANCELLED", "FAILED", "DEPRECATED", "DELETED", "DISABLED"
resp.image.output_resources.amis[0].state.reason #=> String
resp.image.output_resources.amis[0]. #=> String
resp.image.output_resources.containers #=> Array
resp.image.output_resources.containers[0].region #=> String
resp.image.output_resources.containers[0].image_uris #=> Array
resp.image.output_resources.containers[0].image_uris[0] #=> String
resp.image.tags #=> Hash
resp.image.tags["TagKey"] #=> String
resp.image.build_type #=> String, one of "USER_INITIATED", "SCHEDULED", "IMPORT", "IMPORT_ISO"
resp.image.image_source #=> String, one of "AMAZON_MANAGED", "AWS_MARKETPLACE", "IMPORTED", "CUSTOM"
resp.image.scan_state.status #=> String, one of "PENDING", "SCANNING", "COLLECTING", "COMPLETED", "ABANDONED", "FAILED", "TIMED_OUT"
resp.image.scan_state.reason #=> String
resp.image.image_scanning_configuration.image_scanning_enabled #=> Boolean
resp.image.image_scanning_configuration.ecr_configuration.repository_name #=> String
resp.image.image_scanning_configuration.ecr_configuration.container_tags #=> Array
resp.image.image_scanning_configuration.ecr_configuration.container_tags[0] #=> String
resp.image.deprecation_time #=> Time
resp.image.lifecycle_execution_id #=> String
resp.image.execution_role #=> String
resp.image.workflows #=> Array
resp.image.workflows[0].workflow_arn #=> String
resp.image.workflows[0].parameters #=> Array
resp.image.workflows[0].parameters[0].name #=> String
resp.image.workflows[0].parameters[0].value #=> Array
resp.image.workflows[0].parameters[0].value[0] #=> String
resp.image.workflows[0].parallel_group #=> String
resp.image.workflows[0].on_failure #=> String, one of "CONTINUE", "ABORT"
resp.image.logging_configuration.log_group_name #=> String
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_build_version_arn (required, String) —

    The Amazon Resource Name (ARN) of the image that you want to get.

Returns:

See Also:



2664
2665
2666
2667
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2664

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

#get_image_pipeline(params = {}) ⇒ Types::GetImagePipelineResponse

Gets an image pipeline.

Examples:

Request syntax with placeholder values


resp = client.get_image_pipeline({
  image_pipeline_arn: "ImagePipelineArn", # required
})

Response structure


resp.request_id #=> String
resp.image_pipeline.arn #=> String
resp.image_pipeline.name #=> String
resp.image_pipeline.description #=> String
resp.image_pipeline.platform #=> String, one of "Windows", "Linux", "macOS"
resp.image_pipeline.enhanced_image_metadata_enabled #=> Boolean
resp.image_pipeline.image_recipe_arn #=> String
resp.image_pipeline.container_recipe_arn #=> String
resp.image_pipeline.infrastructure_configuration_arn #=> String
resp.image_pipeline.distribution_configuration_arn #=> String
resp.image_pipeline.image_tests_configuration.image_tests_enabled #=> Boolean
resp.image_pipeline.image_tests_configuration.timeout_minutes #=> Integer
resp.image_pipeline.schedule.schedule_expression #=> String
resp.image_pipeline.schedule.timezone #=> String
resp.image_pipeline.schedule.pipeline_execution_start_condition #=> String, one of "EXPRESSION_MATCH_ONLY", "EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE"
resp.image_pipeline.schedule.auto_disable_policy.failure_count #=> Integer
resp.image_pipeline.status #=> String, one of "DISABLED", "ENABLED"
resp.image_pipeline.date_created #=> String
resp.image_pipeline.date_updated #=> String
resp.image_pipeline.date_last_run #=> String
resp.image_pipeline.last_run_status #=> String, one of "PENDING", "CREATING", "BUILDING", "TESTING", "DISTRIBUTING", "INTEGRATING", "AVAILABLE", "CANCELLED", "FAILED", "DEPRECATED", "DELETED", "DISABLED"
resp.image_pipeline.date_next_run #=> String
resp.image_pipeline.tags #=> Hash
resp.image_pipeline.tags["TagKey"] #=> String
resp.image_pipeline.image_scanning_configuration.image_scanning_enabled #=> Boolean
resp.image_pipeline.image_scanning_configuration.ecr_configuration.repository_name #=> String
resp.image_pipeline.image_scanning_configuration.ecr_configuration.container_tags #=> Array
resp.image_pipeline.image_scanning_configuration.ecr_configuration.container_tags[0] #=> String
resp.image_pipeline.execution_role #=> String
resp.image_pipeline.workflows #=> Array
resp.image_pipeline.workflows[0].workflow_arn #=> String
resp.image_pipeline.workflows[0].parameters #=> Array
resp.image_pipeline.workflows[0].parameters[0].name #=> String
resp.image_pipeline.workflows[0].parameters[0].value #=> Array
resp.image_pipeline.workflows[0].parameters[0].value[0] #=> String
resp.image_pipeline.workflows[0].parallel_group #=> String
resp.image_pipeline.workflows[0].on_failure #=> String, one of "CONTINUE", "ABORT"
resp.image_pipeline.logging_configuration.image_log_group_name #=> String
resp.image_pipeline.logging_configuration.pipeline_log_group_name #=> String
resp.image_pipeline.consecutive_failures #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :image_pipeline_arn (required, String) —

    The Amazon Resource Name (ARN) of the image pipeline that you want to retrieve.

Returns:

See Also:



2733
2734
2735
2736
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2733

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

#get_image_policy(params = {}) ⇒ Types::GetImagePolicyResponse

Gets an image policy.

Examples:

Request syntax with placeholder values


resp = client.get_image_policy({
  image_arn: "ImageBuildVersionArn", # required
})

Response structure


resp.request_id #=> String
resp.policy #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_arn (required, String) —

    The Amazon Resource Name (ARN) of the image whose policy you want to retrieve.

Returns:

See Also:



2764
2765
2766
2767
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2764

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

#get_image_recipe(params = {}) ⇒ Types::GetImageRecipeResponse

Gets an image recipe.

Examples:

Request syntax with placeholder values


resp = client.get_image_recipe({
  image_recipe_arn: "ImageRecipeArn", # required
})

Response structure


resp.request_id #=> String
resp.image_recipe.arn #=> String
resp.image_recipe.type #=> String, one of "AMI", "DOCKER"
resp.image_recipe.name #=> String
resp.image_recipe.description #=> String
resp.image_recipe.platform #=> String, one of "Windows", "Linux", "macOS"
resp.image_recipe.owner #=> String
resp.image_recipe.version #=> String
resp.image_recipe.components #=> Array
resp.image_recipe.components[0].component_arn #=> String
resp.image_recipe.components[0].parameters #=> Array
resp.image_recipe.components[0].parameters[0].name #=> String
resp.image_recipe.components[0].parameters[0].value #=> Array
resp.image_recipe.components[0].parameters[0].value[0] #=> String
resp.image_recipe.parent_image #=> String
resp.image_recipe.block_device_mappings #=> Array
resp.image_recipe.block_device_mappings[0].device_name #=> String
resp.image_recipe.block_device_mappings[0].ebs.encrypted #=> Boolean
resp.image_recipe.block_device_mappings[0].ebs.delete_on_termination #=> Boolean
resp.image_recipe.block_device_mappings[0].ebs.iops #=> Integer
resp.image_recipe.block_device_mappings[0].ebs.kms_key_id #=> String
resp.image_recipe.block_device_mappings[0].ebs.snapshot_id #=> String
resp.image_recipe.block_device_mappings[0].ebs.volume_size #=> Integer
resp.image_recipe.block_device_mappings[0].ebs.volume_type #=> String, one of "standard", "io1", "io2", "gp2", "gp3", "sc1", "st1"
resp.image_recipe.block_device_mappings[0].ebs.throughput #=> Integer
resp.image_recipe.block_device_mappings[0].virtual_name #=> String
resp.image_recipe.block_device_mappings[0].no_device #=> String
resp.image_recipe.date_created #=> String
resp.image_recipe.tags #=> Hash
resp.image_recipe.tags["TagKey"] #=> String
resp.image_recipe.working_directory #=> String
resp.image_recipe.additional_instance_configuration.systems_manager_agent.uninstall_after_build #=> Boolean
resp.image_recipe.additional_instance_configuration.user_data_override #=> String
resp.image_recipe.ami_tags #=> Hash
resp.image_recipe.ami_tags["TagKey"] #=> String
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_recipe_arn (required, String) —

    The Amazon Resource Name (ARN) of the image recipe that you want to retrieve.

Returns:

See Also:



2833
2834
2835
2836
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2833

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

#get_image_recipe_policy(params = {}) ⇒ Types::GetImageRecipePolicyResponse

Gets an image recipe policy.

Examples:

Request syntax with placeholder values


resp = client.get_image_recipe_policy({
  image_recipe_arn: "ImageRecipeArn", # required
})

Response structure


resp.request_id #=> String
resp.policy #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_recipe_arn (required, String) —

    The Amazon Resource Name (ARN) of the image recipe whose policy you want to retrieve.

Returns:

See Also:



2864
2865
2866
2867
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2864

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

#get_infrastructure_configuration(params = {}) ⇒ Types::GetInfrastructureConfigurationResponse

Gets an infrastructure configuration.

Examples:

Request syntax with placeholder values


resp = client.get_infrastructure_configuration({
  infrastructure_configuration_arn: "InfrastructureConfigurationArn", # required
})

Response structure


resp.request_id #=> String
resp.infrastructure_configuration.arn #=> String
resp.infrastructure_configuration.name #=> String
resp.infrastructure_configuration.description #=> String
resp.infrastructure_configuration.instance_types #=> Array
resp.infrastructure_configuration.instance_types[0] #=> String
resp.infrastructure_configuration.instance_profile_name #=> String
resp.infrastructure_configuration.security_group_ids #=> Array
resp.infrastructure_configuration.security_group_ids[0] #=> String
resp.infrastructure_configuration.subnet_id #=> String
resp.infrastructure_configuration.logging.s3_logs.s3_bucket_name #=> String
resp.infrastructure_configuration.logging.s3_logs.s3_key_prefix #=> String
resp.infrastructure_configuration.key_pair #=> String
resp.infrastructure_configuration.terminate_instance_on_failure #=> Boolean
resp.infrastructure_configuration.sns_topic_arn #=> String
resp.infrastructure_configuration.date_created #=> String
resp.infrastructure_configuration.date_updated #=> String
resp.infrastructure_configuration.resource_tags #=> Hash
resp.infrastructure_configuration.resource_tags["TagKey"] #=> String
resp.infrastructure_configuration.instance_metadata_options.http_tokens #=> String
resp.infrastructure_configuration.instance_metadata_options.http_put_response_hop_limit #=> Integer
resp.infrastructure_configuration.tags #=> Hash
resp.infrastructure_configuration.tags["TagKey"] #=> String
resp.infrastructure_configuration.placement.availability_zone #=> String
resp.infrastructure_configuration.placement.tenancy #=> String, one of "default", "dedicated", "host"
resp.infrastructure_configuration.placement.host_id #=> String
resp.infrastructure_configuration.placement.host_resource_group_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :infrastructure_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the infrastructure configuration that you want to retrieve.

Returns:

See Also:



2920
2921
2922
2923
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2920

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

#get_lifecycle_execution(params = {}) ⇒ Types::GetLifecycleExecutionResponse

Get the runtime information that was logged for a specific runtime instance of the lifecycle policy.

Examples:

Request syntax with placeholder values


resp = client.get_lifecycle_execution({
  lifecycle_execution_id: "LifecycleExecutionId", # required
})

Response structure


resp.lifecycle_execution.lifecycle_execution_id #=> String
resp.lifecycle_execution.lifecycle_policy_arn #=> String
resp.lifecycle_execution.resources_impacted_summary.has_impacted_resources #=> Boolean
resp.lifecycle_execution.state.status #=> String, one of "IN_PROGRESS", "CANCELLED", "CANCELLING", "FAILED", "SUCCESS", "PENDING"
resp.lifecycle_execution.state.reason #=> String
resp.lifecycle_execution.start_time #=> Time
resp.lifecycle_execution.end_time #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :lifecycle_execution_id (required, String) —

    Use the unique identifier for a runtime instance of the lifecycle policy to get runtime details.

Returns:

See Also:



2956
2957
2958
2959
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 2956

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

#get_lifecycle_policy(params = {}) ⇒ Types::GetLifecyclePolicyResponse

Get details for the specified image lifecycle policy.

Examples:

Request syntax with placeholder values


resp = client.get_lifecycle_policy({
  lifecycle_policy_arn: "LifecyclePolicyArn", # required
})

Response structure


resp.lifecycle_policy.arn #=> String
resp.lifecycle_policy.name #=> String
resp.lifecycle_policy.description #=> String
resp.lifecycle_policy.status #=> String, one of "DISABLED", "ENABLED"
resp.lifecycle_policy.execution_role #=> String
resp.lifecycle_policy.resource_type #=> String, one of "AMI_IMAGE", "CONTAINER_IMAGE"
resp.lifecycle_policy.policy_details #=> Array
resp.lifecycle_policy.policy_details[0].action.type #=> String, one of "DELETE", "DEPRECATE", "DISABLE"
resp.lifecycle_policy.policy_details[0].action.include_resources.amis #=> Boolean
resp.lifecycle_policy.policy_details[0].action.include_resources.snapshots #=> Boolean
resp.lifecycle_policy.policy_details[0].action.include_resources.containers #=> Boolean
resp.lifecycle_policy.policy_details[0].filter.type #=> String, one of "AGE", "COUNT"
resp.lifecycle_policy.policy_details[0].filter.value #=> Integer
resp.lifecycle_policy.policy_details[0].filter.unit #=> String, one of "DAYS", "WEEKS", "MONTHS", "YEARS"
resp.lifecycle_policy.policy_details[0].filter.retain_at_least #=> Integer
resp.lifecycle_policy.policy_details[0].exclusion_rules.tag_map #=> Hash
resp.lifecycle_policy.policy_details[0].exclusion_rules.tag_map["TagKey"] #=> String
resp.lifecycle_policy.policy_details[0].exclusion_rules.amis.is_public #=> Boolean
resp.lifecycle_policy.policy_details[0].exclusion_rules.amis.regions #=> Array
resp.lifecycle_policy.policy_details[0].exclusion_rules.amis.regions[0] #=> String
resp.lifecycle_policy.policy_details[0].exclusion_rules.amis.shared_accounts #=> Array
resp.lifecycle_policy.policy_details[0].exclusion_rules.amis.shared_accounts[0] #=> String
resp.lifecycle_policy.policy_details[0].exclusion_rules.amis.last_launched.value #=> Integer
resp.lifecycle_policy.policy_details[0].exclusion_rules.amis.last_launched.unit #=> String, one of "DAYS", "WEEKS", "MONTHS", "YEARS"
resp.lifecycle_policy.policy_details[0].exclusion_rules.amis.tag_map #=> Hash
resp.lifecycle_policy.policy_details[0].exclusion_rules.amis.tag_map["TagKey"] #=> String
resp.lifecycle_policy.resource_selection.recipes #=> Array
resp.lifecycle_policy.resource_selection.recipes[0].name #=> String
resp.lifecycle_policy.resource_selection.recipes[0].semantic_version #=> String
resp.lifecycle_policy.resource_selection.tag_map #=> Hash
resp.lifecycle_policy.resource_selection.tag_map["TagKey"] #=> String
resp.lifecycle_policy.date_created #=> Time
resp.lifecycle_policy.date_updated #=> Time
resp.lifecycle_policy.date_last_run #=> Time
resp.lifecycle_policy.tags #=> Hash
resp.lifecycle_policy.tags["TagKey"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :lifecycle_policy_arn (required, String) —

    Specifies the Amazon Resource Name (ARN) of the image lifecycle policy resource to get.

Returns:

See Also:



3020
3021
3022
3023
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3020

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

#get_marketplace_resource(params = {}) ⇒ Types::GetMarketplaceResourceResponse

Verify the subscription and perform resource dependency checks on the requested Amazon Web Services Marketplace resource. For Amazon Web Services Marketplace components, the response contains fields to download the components and their artifacts.

Examples:

Request syntax with placeholder values


resp = client.get_marketplace_resource({
  resource_type: "COMPONENT_DATA", # required, accepts COMPONENT_DATA, COMPONENT_ARTIFACT
  resource_arn: "ImageBuilderArn", # required
  resource_location: "MarketplaceResourceLocation",
})

Response structure


resp.resource_arn #=> String
resp.url #=> String
resp.data #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :resource_type (required, String) —

    Specifies which type of Amazon Web Services Marketplace resource Image Builder retrieves.

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) that uniquely identifies an Amazon Web Services Marketplace resource.

  • :resource_location (String) —

    The bucket path that you can specify to download the resource from Amazon S3.

Returns:

See Also:



3066
3067
3068
3069
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3066

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

#get_workflow(params = {}) ⇒ Types::GetWorkflowResponse

Get a workflow resource object.

Examples:

Request syntax with placeholder values


resp = client.get_workflow({
  workflow_build_version_arn: "WorkflowVersionArnOrBuildVersionArn", # required
})

Response structure


resp.workflow.arn #=> String
resp.workflow.name #=> String
resp.workflow.version #=> String
resp.workflow.description #=> String
resp.workflow.change_description #=> String
resp.workflow.type #=> String, one of "BUILD", "TEST", "DISTRIBUTION"
resp.workflow.state.status #=> String, one of "DEPRECATED"
resp.workflow.state.reason #=> String
resp.workflow.owner #=> String
resp.workflow.data #=> String
resp.workflow.kms_key_id #=> String
resp.workflow.date_created #=> String
resp.workflow.tags #=> Hash
resp.workflow.tags["TagKey"] #=> String
resp.workflow.parameters #=> Array
resp.workflow.parameters[0].name #=> String
resp.workflow.parameters[0].type #=> String
resp.workflow.parameters[0].default_value #=> Array
resp.workflow.parameters[0].default_value[0] #=> String
resp.workflow.parameters[0].description #=> String
resp.latest_version_references.latest_version_arn #=> String
resp.latest_version_references.latest_major_version_arn #=> String
resp.latest_version_references.latest_minor_version_arn #=> String
resp.latest_version_references.latest_patch_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :workflow_build_version_arn (required, String) —

    The Amazon Resource Name (ARN) of the workflow resource that you want to get.

Returns:

See Also:



3119
3120
3121
3122
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3119

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

#get_workflow_execution(params = {}) ⇒ Types::GetWorkflowExecutionResponse

Get the runtime information that was logged for a specific runtime instance of the workflow.

Examples:

Request syntax with placeholder values


resp = client.get_workflow_execution({
  workflow_execution_id: "WorkflowExecutionId", # required
})

Response structure


resp.request_id #=> String
resp.workflow_build_version_arn #=> String
resp.workflow_execution_id #=> String
resp.image_build_version_arn #=> String
resp.type #=> String, one of "BUILD", "TEST", "DISTRIBUTION"
resp.status #=> String, one of "PENDING", "SKIPPED", "RUNNING", "COMPLETED", "FAILED", "ROLLBACK_IN_PROGRESS", "ROLLBACK_COMPLETED", "CANCELLED"
resp.message #=> String
resp.total_step_count #=> Integer
resp.total_steps_succeeded #=> Integer
resp.total_steps_failed #=> Integer
resp.total_steps_skipped #=> Integer
resp.start_time #=> String
resp.end_time #=> String
resp.parallel_group #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :workflow_execution_id (required, String) —

    Use the unique identifier for a runtime instance of the workflow to get runtime details.

Returns:

See Also:



3175
3176
3177
3178
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3175

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

#get_workflow_step_execution(params = {}) ⇒ Types::GetWorkflowStepExecutionResponse

Get the runtime information that was logged for a specific runtime instance of the workflow step.

Examples:

Request syntax with placeholder values


resp = client.get_workflow_step_execution({
  step_execution_id: "WorkflowStepExecutionId", # required
})

Response structure


resp.request_id #=> String
resp.step_execution_id #=> String
resp.workflow_build_version_arn #=> String
resp.workflow_execution_id #=> String
resp.image_build_version_arn #=> String
resp.name #=> String
resp.description #=> String
resp.action #=> String
resp.status #=> String, one of "PENDING", "SKIPPED", "RUNNING", "COMPLETED", "FAILED", "CANCELLED"
resp.rollback_status #=> String, one of "RUNNING", "COMPLETED", "SKIPPED", "FAILED"
resp.message #=> String
resp.inputs #=> String
resp.outputs #=> String
resp.start_time #=> String
resp.end_time #=> String
resp.on_failure #=> String
resp.timeout_seconds #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :step_execution_id (required, String) —

    Use the unique identifier for a specific runtime instance of the workflow step to get runtime details for that step.

Returns:

See Also:



3237
3238
3239
3240
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3237

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

#import_component(params = {}) ⇒ Types::ImportComponentResponse

Imports a component and transforms its data into a component document.

Examples:

Request syntax with placeholder values


resp = client.import_component({
  name: "ResourceName", # required
  semantic_version: "VersionNumber", # required
  description: "NonEmptyString",
  change_description: "NonEmptyString",
  type: "BUILD", # required, accepts BUILD, TEST
  format: "SHELL", # required, accepts SHELL
  platform: "Windows", # required, accepts Windows, Linux, macOS
  data: "NonEmptyString",
  uri: "Uri",
  kms_key_id: "NonEmptyString",
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.component_build_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the component.

  • :semantic_version (required, String) —

    The semantic version of the component. This version follows the semantic version syntax.

    The semantic version has four nodes: <major>.<minor>.<patch>/<build>. You can assign values for the first three, and can filter on all of them.

    Filtering: With semantic versioning, you have the flexibility to use wildcards (x) to specify the most recent versions or nodes when selecting the base image or components for your recipe. When you use a wildcard in any node, all nodes to the right of the first wildcard must also be wildcards.

  • :description (String) —

    The description of the component. Describes the contents of the component.

  • :change_description (String) —

    The change description of the component. This description indicates the change that has been made in this version, or what makes this version different from other versions of the component.

  • :type (required, String) —

    The type of the component denotes whether the component is used to build the image, or only to test it.

  • :format (required, String) —

    The format of the resource that you want to import as a component.

  • :platform (required, String) —

    The platform of the component.

  • :data (String) —

    The data of the component. Used to specify the data inline. Either data or uri can be used to specify the data within the component.

  • :uri (String) —

    The uri of the component. Must be an Amazon S3 URL and the requester must have permission to access the Amazon S3 bucket. If you use Amazon S3, you can specify component content up to your service quota. Either data or uri can be used to specify the data within the component.

  • :kms_key_id (String) —

    The Amazon Resource Name (ARN) that uniquely identifies the KMS key used to encrypt this component. This can be either the Key ARN or the Alias ARN. For more information, see Key identifiers (KeyId) in the Key Management Service Developer Guide.

  • :tags (Hash<String,String>) —

    The tags of the component.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



3352
3353
3354
3355
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3352

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

#import_disk_image(params = {}) ⇒ Types::ImportDiskImageResponse

Import a Windows operating system image from a verified Microsoft ISO disk file. The following disk images are supported:

  • Windows 11 Enterprise

^

Examples:

Request syntax with placeholder values


resp = client.import_disk_image({
  name: "NonEmptyString", # required
  semantic_version: "VersionNumber", # required
  description: "NonEmptyString",
  platform: "NonEmptyString", # required
  os_version: "OsVersion", # required
  execution_role: "RoleNameOrArn",
  infrastructure_configuration_arn: "InfrastructureConfigurationArn", # required
  uri: "Uri", # required
  logging_configuration: {
    log_group_name: "LogGroupName",
  },
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
})

Response structure


resp.client_token #=> String
resp.image_build_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the image resource that's created from the import.

  • :semantic_version (required, String) —

    The semantic version to attach to the image that's created during the import process. This version follows the semantic version syntax.

  • :description (String) —

    The description for your disk image import.

  • :platform (required, String) —

    The operating system platform for the imported image. Allowed values include the following: Windows.

  • :os_version (required, String) —

    The operating system version for the imported image. Allowed values include the following: Microsoft Windows 11.

  • :execution_role (String) —

    The name or Amazon Resource Name (ARN) for the IAM role you create that grants Image Builder access to perform workflow actions to import an image from a Microsoft ISO file.

  • :infrastructure_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the infrastructure configuration resource that's used for launching the EC2 instance on which the ISO image is built.

  • :uri (required, String) —

    The uri of the ISO disk file that's stored in Amazon S3.

  • :logging_configuration (Types::ImageLoggingConfiguration) —

    Define logging configuration for the image build process.

  • :tags (Hash<String,String>) —

    Tags that are attached to image resources created from the import.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



3447
3448
3449
3450
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3447

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

#import_vm_image(params = {}) ⇒ Types::ImportVmImageResponse

When you export your virtual machine (VM) from its virtualization environment, that process creates a set of one or more disk container files that act as snapshots of your VM’s environment, settings, and data. The Amazon EC2 API ImportImage action uses those files to import your VM and create an AMI. To import using the CLI command, see import-image

You can reference the task ID from the VM import to pull in the AMI that the import created as the base image for your Image Builder recipe.

Examples:

Request syntax with placeholder values


resp = client.import_vm_image({
  name: "NonEmptyString", # required
  semantic_version: "VersionNumber", # required
  description: "NonEmptyString",
  platform: "Windows", # required, accepts Windows, Linux, macOS
  os_version: "OsVersion",
  vm_import_task_id: "NonEmptyString", # required
  logging_configuration: {
    log_group_name: "LogGroupName",
  },
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken", # required
})

Response structure


resp.request_id #=> String
resp.image_arn #=> String
resp.client_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the base image that is created by the import process.

  • :semantic_version (required, String) —

    The semantic version to attach to the base image that was created during the import process. This version follows the semantic version syntax.

    The semantic version has four nodes: <major>.<minor>.<patch>/<build>. You can assign values for the first three, and can filter on all of them.

    Assignment: For the first three nodes you can assign any positive integer value, including zero, with an upper limit of 230-1, or 1073741823 for each node. Image Builder automatically assigns the build number to the fourth node.

    Patterns: You can use any numeric pattern that adheres to the assignment requirements for the nodes that you can assign. For example, you might choose a software version pattern, such as 1.0.0, or a date, such as 2021.01.01.

  • :description (String) —

    The description for the base image that is created by the import process.

  • :platform (required, String) —

    The operating system platform for the imported VM.

  • :os_version (String) —

    The operating system version for the imported VM.

  • :vm_import_task_id (required, String) —

    The importTaskId (API) or ImportTaskId (CLI) from the Amazon EC2 VM import process. Image Builder retrieves information from the import process to pull in the AMI that is created from the VM source as the base image for your recipe.

  • :logging_configuration (Types::ImageLoggingConfiguration) —

    Define logging configuration for the image build process.

  • :tags (Hash<String,String>) —

    Tags that are attached to the import resources.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



3560
3561
3562
3563
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3560

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

#list_component_build_versions(params = {}) ⇒ Types::ListComponentBuildVersionsResponse

Returns the list of component build versions for the specified component version Amazon Resource Name (ARN).

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_component_build_versions({
  component_version_arn: "ComponentVersionArn",
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.component_summary_list #=> Array
resp.component_summary_list[0].arn #=> String
resp.component_summary_list[0].name #=> String
resp.component_summary_list[0].version #=> String
resp.component_summary_list[0].platform #=> String, one of "Windows", "Linux", "macOS"
resp.component_summary_list[0].supported_os_versions #=> Array
resp.component_summary_list[0].supported_os_versions[0] #=> String
resp.component_summary_list[0].state.status #=> String, one of "DEPRECATED", "DISABLED", "ACTIVE"
resp.component_summary_list[0].state.reason #=> String
resp.component_summary_list[0].type #=> String, one of "BUILD", "TEST"
resp.component_summary_list[0].owner #=> String
resp.component_summary_list[0].description #=> String
resp.component_summary_list[0].change_description #=> String
resp.component_summary_list[0].date_created #=> String
resp.component_summary_list[0].tags #=> Hash
resp.component_summary_list[0].tags["TagKey"] #=> String
resp.component_summary_list[0].publisher #=> String
resp.component_summary_list[0].obfuscate #=> Boolean
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :component_version_arn (String) —

    The component version Amazon Resource Name (ARN) whose versions you want to list.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



3622
3623
3624
3625
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3622

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

#list_components(params = {}) ⇒ Types::ListComponentsResponse

Returns the list of components that can be filtered by name, or by using the listed filters to streamline results. Newly created components can take up to two minutes to appear in the ListComponents API Results.

The semantic version has four nodes: <major>.<minor>.<patch>/<build>. You can assign values for the first three, and can filter on all of them.

Filtering: With semantic versioning, you have the flexibility to use wildcards (x) to specify the most recent versions or nodes when selecting the base image or components for your recipe. When you use a wildcard in any node, all nodes to the right of the first wildcard must also be wildcards.

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_components({
  owner: "Self", # accepts Self, Shared, Amazon, ThirdParty, AWSMarketplace
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  by_name: false,
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.component_version_list #=> Array
resp.component_version_list[0].arn #=> String
resp.component_version_list[0].name #=> String
resp.component_version_list[0].version #=> String
resp.component_version_list[0].description #=> String
resp.component_version_list[0].platform #=> String, one of "Windows", "Linux", "macOS"
resp.component_version_list[0].supported_os_versions #=> Array
resp.component_version_list[0].supported_os_versions[0] #=> String
resp.component_version_list[0].type #=> String, one of "BUILD", "TEST"
resp.component_version_list[0].owner #=> String
resp.component_version_list[0].date_created #=> String
resp.component_version_list[0].status #=> String, one of "DEPRECATED", "DISABLED", "ACTIVE"
resp.component_version_list[0].product_codes #=> Array
resp.component_version_list[0].product_codes[0].product_code_id #=> String
resp.component_version_list[0].product_codes[0].product_code_type #=> String, one of "marketplace"
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :owner (String) —

    Filters results based on the type of owner for the component. By default, this request returns a list of components that your account owns. To see results for other types of owners, you can specify components that Amazon manages, third party components, or components that other accounts have shared with you.

  • :filters (Array<Types::Filter>) —

    Use the following filters to streamline results:

    • description

    • name

    • platform

    • supportedOsVersion

    • type

    • version

  • :by_name (Boolean) —

    Returns the list of components for the specified name.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



3723
3724
3725
3726
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3723

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

#list_container_recipes(params = {}) ⇒ Types::ListContainerRecipesResponse

Returns a list of container recipes.

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_container_recipes({
  owner: "Self", # accepts Self, Shared, Amazon, ThirdParty, AWSMarketplace
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  max_results: 1,
  next_token: "NonEmptyString",
})

Response structure


resp.request_id #=> String
resp.container_recipe_summary_list #=> Array
resp.container_recipe_summary_list[0].arn #=> String
resp.container_recipe_summary_list[0].container_type #=> String, one of "DOCKER"
resp.container_recipe_summary_list[0].name #=> String
resp.container_recipe_summary_list[0].platform #=> String, one of "Windows", "Linux", "macOS"
resp.container_recipe_summary_list[0].owner #=> String
resp.container_recipe_summary_list[0].parent_image #=> String
resp.container_recipe_summary_list[0].date_created #=> String
resp.container_recipe_summary_list[0].instance_image #=> String
resp.container_recipe_summary_list[0].tags #=> Hash
resp.container_recipe_summary_list[0].tags["TagKey"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :owner (String) —

    Returns container recipes belonging to the specified owner, that have been shared with you. You can omit this field to return container recipes belonging to your account.

  • :filters (Array<Types::Filter>) —

    Use the following filters to streamline results:

    • containerType

    • name

    • parentImage

    • platform

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



3795
3796
3797
3798
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3795

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

#list_distribution_configurations(params = {}) ⇒ Types::ListDistributionConfigurationsResponse

Returns a list of distribution configurations.

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_distribution_configurations({
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.distribution_configuration_summary_list #=> Array
resp.distribution_configuration_summary_list[0].arn #=> String
resp.distribution_configuration_summary_list[0].name #=> String
resp.distribution_configuration_summary_list[0].description #=> String
resp.distribution_configuration_summary_list[0].date_created #=> String
resp.distribution_configuration_summary_list[0].date_updated #=> String
resp.distribution_configuration_summary_list[0].tags #=> Hash
resp.distribution_configuration_summary_list[0].tags["TagKey"] #=> String
resp.distribution_configuration_summary_list[0].regions #=> Array
resp.distribution_configuration_summary_list[0].regions[0] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :filters (Array<Types::Filter>) —

    You can filter on name to streamline results.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



3852
3853
3854
3855
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3852

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

#list_image_build_versions(params = {}) ⇒ Types::ListImageBuildVersionsResponse

Returns a list of image build versions.

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_image_build_versions({
  image_version_arn: "ImageVersionArn",
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.image_summary_list #=> Array
resp.image_summary_list[0].arn #=> String
resp.image_summary_list[0].name #=> String
resp.image_summary_list[0].type #=> String, one of "AMI", "DOCKER"
resp.image_summary_list[0].version #=> String
resp.image_summary_list[0].platform #=> String, one of "Windows", "Linux", "macOS"
resp.image_summary_list[0].os_version #=> String
resp.image_summary_list[0].state.status #=> String, one of "PENDING", "CREATING", "BUILDING", "TESTING", "DISTRIBUTING", "INTEGRATING", "AVAILABLE", "CANCELLED", "FAILED", "DEPRECATED", "DELETED", "DISABLED"
resp.image_summary_list[0].state.reason #=> String
resp.image_summary_list[0].owner #=> String
resp.image_summary_list[0].date_created #=> String
resp.image_summary_list[0].output_resources.amis #=> Array
resp.image_summary_list[0].output_resources.amis[0].region #=> String
resp.image_summary_list[0].output_resources.amis[0].image #=> String
resp.image_summary_list[0].output_resources.amis[0].name #=> String
resp.image_summary_list[0].output_resources.amis[0].description #=> String
resp.image_summary_list[0].output_resources.amis[0].state.status #=> String, one of "PENDING", "CREATING", "BUILDING", "TESTING", "DISTRIBUTING", "INTEGRATING", "AVAILABLE", "CANCELLED", "FAILED", "DEPRECATED", "DELETED", "DISABLED"
resp.image_summary_list[0].output_resources.amis[0].state.reason #=> String
resp.image_summary_list[0].output_resources.amis[0]. #=> String
resp.image_summary_list[0].output_resources.containers #=> Array
resp.image_summary_list[0].output_resources.containers[0].region #=> String
resp.image_summary_list[0].output_resources.containers[0].image_uris #=> Array
resp.image_summary_list[0].output_resources.containers[0].image_uris[0] #=> String
resp.image_summary_list[0].tags #=> Hash
resp.image_summary_list[0].tags["TagKey"] #=> String
resp.image_summary_list[0].build_type #=> String, one of "USER_INITIATED", "SCHEDULED", "IMPORT", "IMPORT_ISO"
resp.image_summary_list[0].image_source #=> String, one of "AMAZON_MANAGED", "AWS_MARKETPLACE", "IMPORTED", "CUSTOM"
resp.image_summary_list[0].deprecation_time #=> Time
resp.image_summary_list[0].lifecycle_execution_id #=> String
resp.image_summary_list[0].logging_configuration.log_group_name #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_version_arn (String) —

    The Amazon Resource Name (ARN) of the image whose build versions you want to retrieve.

  • :filters (Array<Types::Filter>) —

    Use the following filters to streamline results:

    • name

    • osVersion

    • platform

    • type

    • version

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



3944
3945
3946
3947
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3944

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

#list_image_packages(params = {}) ⇒ Types::ListImagePackagesResponse

List the Packages that are associated with an Image Build Version, as determined by Amazon Web Services Systems Manager Inventory at build time.

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_image_packages({
  image_build_version_arn: "ImageBuildVersionArn", # required
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.image_package_list #=> Array
resp.image_package_list[0].package_name #=> String
resp.image_package_list[0].package_version #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_build_version_arn (required, String) —

    Filter results for the ListImagePackages request by the Image Build Version ARN

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



3992
3993
3994
3995
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 3992

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

#list_image_pipeline_images(params = {}) ⇒ Types::ListImagePipelineImagesResponse

Returns a list of images created by the specified pipeline.

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_image_pipeline_images({
  image_pipeline_arn: "ImagePipelineArn", # required
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.image_summary_list #=> Array
resp.image_summary_list[0].arn #=> String
resp.image_summary_list[0].name #=> String
resp.image_summary_list[0].type #=> String, one of "AMI", "DOCKER"
resp.image_summary_list[0].version #=> String
resp.image_summary_list[0].platform #=> String, one of "Windows", "Linux", "macOS"
resp.image_summary_list[0].os_version #=> String
resp.image_summary_list[0].state.status #=> String, one of "PENDING", "CREATING", "BUILDING", "TESTING", "DISTRIBUTING", "INTEGRATING", "AVAILABLE", "CANCELLED", "FAILED", "DEPRECATED", "DELETED", "DISABLED"
resp.image_summary_list[0].state.reason #=> String
resp.image_summary_list[0].owner #=> String
resp.image_summary_list[0].date_created #=> String
resp.image_summary_list[0].output_resources.amis #=> Array
resp.image_summary_list[0].output_resources.amis[0].region #=> String
resp.image_summary_list[0].output_resources.amis[0].image #=> String
resp.image_summary_list[0].output_resources.amis[0].name #=> String
resp.image_summary_list[0].output_resources.amis[0].description #=> String
resp.image_summary_list[0].output_resources.amis[0].state.status #=> String, one of "PENDING", "CREATING", "BUILDING", "TESTING", "DISTRIBUTING", "INTEGRATING", "AVAILABLE", "CANCELLED", "FAILED", "DEPRECATED", "DELETED", "DISABLED"
resp.image_summary_list[0].output_resources.amis[0].state.reason #=> String
resp.image_summary_list[0].output_resources.amis[0]. #=> String
resp.image_summary_list[0].output_resources.containers #=> Array
resp.image_summary_list[0].output_resources.containers[0].region #=> String
resp.image_summary_list[0].output_resources.containers[0].image_uris #=> Array
resp.image_summary_list[0].output_resources.containers[0].image_uris[0] #=> String
resp.image_summary_list[0].tags #=> Hash
resp.image_summary_list[0].tags["TagKey"] #=> String
resp.image_summary_list[0].build_type #=> String, one of "USER_INITIATED", "SCHEDULED", "IMPORT", "IMPORT_ISO"
resp.image_summary_list[0].image_source #=> String, one of "AMAZON_MANAGED", "AWS_MARKETPLACE", "IMPORTED", "CUSTOM"
resp.image_summary_list[0].deprecation_time #=> Time
resp.image_summary_list[0].lifecycle_execution_id #=> String
resp.image_summary_list[0].logging_configuration.log_group_name #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_pipeline_arn (required, String) —

    The Amazon Resource Name (ARN) of the image pipeline whose images you want to view.

  • :filters (Array<Types::Filter>) —

    Use the following filters to streamline results:

    • name

    • version

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4078
4079
4080
4081
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4078

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

#list_image_pipelines(params = {}) ⇒ Types::ListImagePipelinesResponse

Returns a list of image pipelines.

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_image_pipelines({
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.image_pipeline_list #=> Array
resp.image_pipeline_list[0].arn #=> String
resp.image_pipeline_list[0].name #=> String
resp.image_pipeline_list[0].description #=> String
resp.image_pipeline_list[0].platform #=> String, one of "Windows", "Linux", "macOS"
resp.image_pipeline_list[0].enhanced_image_metadata_enabled #=> Boolean
resp.image_pipeline_list[0].image_recipe_arn #=> String
resp.image_pipeline_list[0].container_recipe_arn #=> String
resp.image_pipeline_list[0].infrastructure_configuration_arn #=> String
resp.image_pipeline_list[0].distribution_configuration_arn #=> String
resp.image_pipeline_list[0].image_tests_configuration.image_tests_enabled #=> Boolean
resp.image_pipeline_list[0].image_tests_configuration.timeout_minutes #=> Integer
resp.image_pipeline_list[0].schedule.schedule_expression #=> String
resp.image_pipeline_list[0].schedule.timezone #=> String
resp.image_pipeline_list[0].schedule.pipeline_execution_start_condition #=> String, one of "EXPRESSION_MATCH_ONLY", "EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE"
resp.image_pipeline_list[0].schedule.auto_disable_policy.failure_count #=> Integer
resp.image_pipeline_list[0].status #=> String, one of "DISABLED", "ENABLED"
resp.image_pipeline_list[0].date_created #=> String
resp.image_pipeline_list[0].date_updated #=> String
resp.image_pipeline_list[0].date_last_run #=> String
resp.image_pipeline_list[0].last_run_status #=> String, one of "PENDING", "CREATING", "BUILDING", "TESTING", "DISTRIBUTING", "INTEGRATING", "AVAILABLE", "CANCELLED", "FAILED", "DEPRECATED", "DELETED", "DISABLED"
resp.image_pipeline_list[0].date_next_run #=> String
resp.image_pipeline_list[0].tags #=> Hash
resp.image_pipeline_list[0].tags["TagKey"] #=> String
resp.image_pipeline_list[0].image_scanning_configuration.image_scanning_enabled #=> Boolean
resp.image_pipeline_list[0].image_scanning_configuration.ecr_configuration.repository_name #=> String
resp.image_pipeline_list[0].image_scanning_configuration.ecr_configuration.container_tags #=> Array
resp.image_pipeline_list[0].image_scanning_configuration.ecr_configuration.container_tags[0] #=> String
resp.image_pipeline_list[0].execution_role #=> String
resp.image_pipeline_list[0].workflows #=> Array
resp.image_pipeline_list[0].workflows[0].workflow_arn #=> String
resp.image_pipeline_list[0].workflows[0].parameters #=> Array
resp.image_pipeline_list[0].workflows[0].parameters[0].name #=> String
resp.image_pipeline_list[0].workflows[0].parameters[0].value #=> Array
resp.image_pipeline_list[0].workflows[0].parameters[0].value[0] #=> String
resp.image_pipeline_list[0].workflows[0].parallel_group #=> String
resp.image_pipeline_list[0].workflows[0].on_failure #=> String, one of "CONTINUE", "ABORT"
resp.image_pipeline_list[0].logging_configuration.image_log_group_name #=> String
resp.image_pipeline_list[0].logging_configuration.pipeline_log_group_name #=> String
resp.image_pipeline_list[0].consecutive_failures #=> Integer
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :filters (Array<Types::Filter>) —

    Use the following filters to streamline results:

    • description

    • distributionConfigurationArn

    • imageRecipeArn

    • infrastructureConfigurationArn

    • name

    • status

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4177
4178
4179
4180
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4177

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

#list_image_recipes(params = {}) ⇒ Types::ListImageRecipesResponse

Returns a list of image recipes.

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_image_recipes({
  owner: "Self", # accepts Self, Shared, Amazon, ThirdParty, AWSMarketplace
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.image_recipe_summary_list #=> Array
resp.image_recipe_summary_list[0].arn #=> String
resp.image_recipe_summary_list[0].name #=> String
resp.image_recipe_summary_list[0].platform #=> String, one of "Windows", "Linux", "macOS"
resp.image_recipe_summary_list[0].owner #=> String
resp.image_recipe_summary_list[0].parent_image #=> String
resp.image_recipe_summary_list[0].date_created #=> String
resp.image_recipe_summary_list[0].tags #=> Hash
resp.image_recipe_summary_list[0].tags["TagKey"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :owner (String) —

    You can specify the recipe owner to filter results by that owner. By default, this request will only show image recipes owned by your account. To filter by a different owner, specify one of the Valid Values that are listed for this parameter.

  • :filters (Array<Types::Filter>) —

    Use the following filters to streamline results:

    • name

    • parentImage

    • platform

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4246
4247
4248
4249
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4246

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

#list_image_scan_finding_aggregations(params = {}) ⇒ Types::ListImageScanFindingAggregationsResponse

Returns a list of image scan aggregations for your account. You can filter by the type of key that Image Builder uses to group results. For example, if you want to get a list of findings by severity level for one of your pipelines, you might specify your pipeline with the imagePipelineArn filter. If you don't specify a filter, Image Builder returns an aggregation for your account.

To streamline results, you can use the following filters in your request:

  • accountId

  • imageBuildVersionArn

  • imagePipelineArn

  • vulnerabilityId

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_image_scan_finding_aggregations({
  filter: {
    name: "FilterName",
    values: ["FilterValue"],
  },
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.aggregation_type #=> String
resp.responses #=> Array
resp.responses[0].. #=> String
resp.responses[0]..severity_counts.all #=> Integer
resp.responses[0]..severity_counts.critical #=> Integer
resp.responses[0]..severity_counts.high #=> Integer
resp.responses[0]..severity_counts.medium #=> Integer
resp.responses[0].image_aggregation.image_build_version_arn #=> String
resp.responses[0].image_aggregation.severity_counts.all #=> Integer
resp.responses[0].image_aggregation.severity_counts.critical #=> Integer
resp.responses[0].image_aggregation.severity_counts.high #=> Integer
resp.responses[0].image_aggregation.severity_counts.medium #=> Integer
resp.responses[0].image_pipeline_aggregation.image_pipeline_arn #=> String
resp.responses[0].image_pipeline_aggregation.severity_counts.all #=> Integer
resp.responses[0].image_pipeline_aggregation.severity_counts.critical #=> Integer
resp.responses[0].image_pipeline_aggregation.severity_counts.high #=> Integer
resp.responses[0].image_pipeline_aggregation.severity_counts.medium #=> Integer
resp.responses[0].vulnerability_id_aggregation.vulnerability_id #=> String
resp.responses[0].vulnerability_id_aggregation.severity_counts.all #=> Integer
resp.responses[0].vulnerability_id_aggregation.severity_counts.critical #=> Integer
resp.responses[0].vulnerability_id_aggregation.severity_counts.high #=> Integer
resp.responses[0].vulnerability_id_aggregation.severity_counts.medium #=> Integer
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :filter (Types::Filter) —

    A filter name and value pair that is used to return a more specific list of results from a list operation. Filters can be used to match a set of resources by specific criteria, such as tags, attributes, or IDs.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4329
4330
4331
4332
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4329

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

#list_image_scan_findings(params = {}) ⇒ Types::ListImageScanFindingsResponse

Returns a list of image scan findings for your 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_image_scan_findings({
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.findings #=> Array
resp.findings[0]. #=> String
resp.findings[0].image_build_version_arn #=> String
resp.findings[0].image_pipeline_arn #=> String
resp.findings[0].type #=> String
resp.findings[0].description #=> String
resp.findings[0].title #=> String
resp.findings[0].remediation.recommendation.text #=> String
resp.findings[0].remediation.recommendation.url #=> String
resp.findings[0].severity #=> String
resp.findings[0].first_observed_at #=> Time
resp.findings[0].updated_at #=> Time
resp.findings[0].inspector_score #=> Float
resp.findings[0].inspector_score_details.adjusted_cvss.score_source #=> String
resp.findings[0].inspector_score_details.adjusted_cvss.cvss_source #=> String
resp.findings[0].inspector_score_details.adjusted_cvss.version #=> String
resp.findings[0].inspector_score_details.adjusted_cvss.score #=> Float
resp.findings[0].inspector_score_details.adjusted_cvss.scoring_vector #=> String
resp.findings[0].inspector_score_details.adjusted_cvss.adjustments #=> Array
resp.findings[0].inspector_score_details.adjusted_cvss.adjustments[0].metric #=> String
resp.findings[0].inspector_score_details.adjusted_cvss.adjustments[0].reason #=> String
resp.findings[0].package_vulnerability_details.vulnerability_id #=> String
resp.findings[0].package_vulnerability_details.vulnerable_packages #=> Array
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].name #=> String
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].version #=> String
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].source_layer_hash #=> String
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].epoch #=> Integer
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].release #=> String
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].arch #=> String
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].package_manager #=> String
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].file_path #=> String
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].fixed_in_version #=> String
resp.findings[0].package_vulnerability_details.vulnerable_packages[0].remediation #=> String
resp.findings[0].package_vulnerability_details.source #=> String
resp.findings[0].package_vulnerability_details.cvss #=> Array
resp.findings[0].package_vulnerability_details.cvss[0].base_score #=> Float
resp.findings[0].package_vulnerability_details.cvss[0].scoring_vector #=> String
resp.findings[0].package_vulnerability_details.cvss[0].version #=> String
resp.findings[0].package_vulnerability_details.cvss[0].source #=> String
resp.findings[0].package_vulnerability_details.related_vulnerabilities #=> Array
resp.findings[0].package_vulnerability_details.related_vulnerabilities[0] #=> String
resp.findings[0].package_vulnerability_details.source_url #=> String
resp.findings[0].package_vulnerability_details.vendor_severity #=> String
resp.findings[0].package_vulnerability_details.vendor_created_at #=> Time
resp.findings[0].package_vulnerability_details.vendor_updated_at #=> Time
resp.findings[0].package_vulnerability_details.reference_urls #=> Array
resp.findings[0].package_vulnerability_details.reference_urls[0] #=> String
resp.findings[0].fix_available #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :filters (Array<Types::ImageScanFindingsFilter>) —

    An array of name value pairs that you can use to filter your results. You can use the following filters to streamline results:

    • imageBuildVersionArn

    • imagePipelineArn

    • vulnerabilityId

    • severity

    If you don't request a filter, then all findings in your account are listed.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4436
4437
4438
4439
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4436

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

#list_images(params = {}) ⇒ Types::ListImagesResponse

Returns the list of images that you have access to. Newly created images can take up to two minutes to appear in the ListImages API Results.

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_images({
  owner: "Self", # accepts Self, Shared, Amazon, ThirdParty, AWSMarketplace
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  by_name: false,
  max_results: 1,
  next_token: "PaginationToken",
  include_deprecated: false,
})

Response structure


resp.request_id #=> String
resp.image_version_list #=> Array
resp.image_version_list[0].arn #=> String
resp.image_version_list[0].name #=> String
resp.image_version_list[0].type #=> String, one of "AMI", "DOCKER"
resp.image_version_list[0].version #=> String
resp.image_version_list[0].platform #=> String, one of "Windows", "Linux", "macOS"
resp.image_version_list[0].os_version #=> String
resp.image_version_list[0].owner #=> String
resp.image_version_list[0].date_created #=> String
resp.image_version_list[0].build_type #=> String, one of "USER_INITIATED", "SCHEDULED", "IMPORT", "IMPORT_ISO"
resp.image_version_list[0].image_source #=> String, one of "AMAZON_MANAGED", "AWS_MARKETPLACE", "IMPORTED", "CUSTOM"
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :owner (String) —

    The owner defines which images you want to list. By default, this request will only show images owned by your account. You can use this field to specify if you want to view images owned by yourself, by Amazon, or those images that have been shared with you by other customers.

  • :filters (Array<Types::Filter>) —

    Use the following filters to streamline results:

    • name

    • osVersion

    • platform

    • type

    • version

  • :by_name (Boolean) —

    Requests a list of images with a specific recipe name.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

  • :include_deprecated (Boolean) —

    Includes deprecated images in the response list.

Returns:

See Also:



4522
4523
4524
4525
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4522

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

#list_infrastructure_configurations(params = {}) ⇒ Types::ListInfrastructureConfigurationsResponse

Returns a list of infrastructure configurations.

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_infrastructure_configurations({
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.request_id #=> String
resp.infrastructure_configuration_summary_list #=> Array
resp.infrastructure_configuration_summary_list[0].arn #=> String
resp.infrastructure_configuration_summary_list[0].name #=> String
resp.infrastructure_configuration_summary_list[0].description #=> String
resp.infrastructure_configuration_summary_list[0].date_created #=> String
resp.infrastructure_configuration_summary_list[0].date_updated #=> String
resp.infrastructure_configuration_summary_list[0].resource_tags #=> Hash
resp.infrastructure_configuration_summary_list[0].resource_tags["TagKey"] #=> String
resp.infrastructure_configuration_summary_list[0].tags #=> Hash
resp.infrastructure_configuration_summary_list[0].tags["TagKey"] #=> String
resp.infrastructure_configuration_summary_list[0].instance_types #=> Array
resp.infrastructure_configuration_summary_list[0].instance_types[0] #=> String
resp.infrastructure_configuration_summary_list[0].instance_profile_name #=> String
resp.infrastructure_configuration_summary_list[0].placement.availability_zone #=> String
resp.infrastructure_configuration_summary_list[0].placement.tenancy #=> String, one of "default", "dedicated", "host"
resp.infrastructure_configuration_summary_list[0].placement.host_id #=> String
resp.infrastructure_configuration_summary_list[0].placement.host_resource_group_arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :filters (Array<Types::Filter>) —

    You can filter on name to streamline results.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4586
4587
4588
4589
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4586

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

#list_lifecycle_execution_resources(params = {}) ⇒ Types::ListLifecycleExecutionResourcesResponse

List resources that the runtime instance of the image lifecycle identified for lifecycle actions.

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_lifecycle_execution_resources({
  lifecycle_execution_id: "LifecycleExecutionId", # required
  parent_resource_id: "NonEmptyString",
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.lifecycle_execution_id #=> String
resp.lifecycle_execution_state.status #=> String, one of "IN_PROGRESS", "CANCELLED", "CANCELLING", "FAILED", "SUCCESS", "PENDING"
resp.lifecycle_execution_state.reason #=> String
resp.resources #=> Array
resp.resources[0]. #=> String
resp.resources[0].resource_id #=> String
resp.resources[0].state.status #=> String, one of "FAILED", "IN_PROGRESS", "SKIPPED", "SUCCESS"
resp.resources[0].state.reason #=> String
resp.resources[0].action.name #=> String, one of "AVAILABLE", "DELETE", "DEPRECATE", "DISABLE"
resp.resources[0].action.reason #=> String
resp.resources[0].region #=> String
resp.resources[0].snapshots #=> Array
resp.resources[0].snapshots[0].snapshot_id #=> String
resp.resources[0].snapshots[0].state.status #=> String, one of "FAILED", "IN_PROGRESS", "SKIPPED", "SUCCESS"
resp.resources[0].snapshots[0].state.reason #=> String
resp.resources[0].image_uris #=> Array
resp.resources[0].image_uris[0] #=> String
resp.resources[0].start_time #=> Time
resp.resources[0].end_time #=> Time
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :lifecycle_execution_id (required, String) —

    Use the unique identifier for a runtime instance of the lifecycle policy to get runtime details.

  • :parent_resource_id (String) —

    You can leave this empty to get a list of Image Builder resources that were identified for lifecycle actions.

    To get a list of associated resources that are impacted for an individual resource (the parent), specify its Amazon Resource Name (ARN). Associated resources are produced from your image and distributed when you run a build, such as AMIs or container images stored in ECR repositories.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4660
4661
4662
4663
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4660

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

#list_lifecycle_executions(params = {}) ⇒ Types::ListLifecycleExecutionsResponse

Get the lifecycle runtime history for the specified resource.

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_lifecycle_executions({
  max_results: 1,
  next_token: "PaginationToken",
  resource_arn: "ImageBuilderArn", # required
})

Response structure


resp.lifecycle_executions #=> Array
resp.lifecycle_executions[0].lifecycle_execution_id #=> String
resp.lifecycle_executions[0].lifecycle_policy_arn #=> String
resp.lifecycle_executions[0].resources_impacted_summary.has_impacted_resources #=> Boolean
resp.lifecycle_executions[0].state.status #=> String, one of "IN_PROGRESS", "CANCELLED", "CANCELLING", "FAILED", "SUCCESS", "PENDING"
resp.lifecycle_executions[0].state.reason #=> String
resp.lifecycle_executions[0].start_time #=> Time
resp.lifecycle_executions[0].end_time #=> Time
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the resource for which to get a list of lifecycle runtime instances.

Returns:

See Also:



4709
4710
4711
4712
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4709

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

#list_lifecycle_policies(params = {}) ⇒ Types::ListLifecyclePoliciesResponse

Get a list of lifecycle policies in your Amazon Web Services 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_lifecycle_policies({
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.lifecycle_policy_summary_list #=> Array
resp.lifecycle_policy_summary_list[0].arn #=> String
resp.lifecycle_policy_summary_list[0].name #=> String
resp.lifecycle_policy_summary_list[0].description #=> String
resp.lifecycle_policy_summary_list[0].status #=> String, one of "DISABLED", "ENABLED"
resp.lifecycle_policy_summary_list[0].execution_role #=> String
resp.lifecycle_policy_summary_list[0].resource_type #=> String, one of "AMI_IMAGE", "CONTAINER_IMAGE"
resp.lifecycle_policy_summary_list[0].date_created #=> Time
resp.lifecycle_policy_summary_list[0].date_updated #=> Time
resp.lifecycle_policy_summary_list[0].date_last_run #=> Time
resp.lifecycle_policy_summary_list[0].tags #=> Hash
resp.lifecycle_policy_summary_list[0].tags["TagKey"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :filters (Array<Types::Filter>) —

    Streamline results based on one of the following values: Name, Status.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4767
4768
4769
4770
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4767

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

#list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceResponse

Returns the list of tags for the specified resource.

Examples:

Request syntax with placeholder values


resp = client.list_tags_for_resource({
  resource_arn: "ImageBuilderArn", # required
})

Response structure


resp.tags #=> Hash
resp.tags["TagKey"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the resource whose tags you want to retrieve.

Returns:

See Also:



4797
4798
4799
4800
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4797

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

#list_waiting_workflow_steps(params = {}) ⇒ Types::ListWaitingWorkflowStepsResponse

Get a list of workflow steps that are waiting for action for workflows in your Amazon Web Services 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_waiting_workflow_steps({
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.steps #=> Array
resp.steps[0].step_execution_id #=> String
resp.steps[0].image_build_version_arn #=> String
resp.steps[0].workflow_execution_id #=> String
resp.steps[0].workflow_build_version_arn #=> String
resp.steps[0].name #=> String
resp.steps[0].action #=> String
resp.steps[0].start_time #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4842
4843
4844
4845
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4842

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

#list_workflow_build_versions(params = {}) ⇒ Types::ListWorkflowBuildVersionsResponse

Returns a list of build versions for a specific workflow resource.

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_workflow_build_versions({
  workflow_version_arn: "WorkflowWildcardVersionArn",
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.workflow_summary_list #=> Array
resp.workflow_summary_list[0].arn #=> String
resp.workflow_summary_list[0].name #=> String
resp.workflow_summary_list[0].version #=> String
resp.workflow_summary_list[0].description #=> String
resp.workflow_summary_list[0].change_description #=> String
resp.workflow_summary_list[0].type #=> String, one of "BUILD", "TEST", "DISTRIBUTION"
resp.workflow_summary_list[0].owner #=> String
resp.workflow_summary_list[0].state.status #=> String, one of "DEPRECATED"
resp.workflow_summary_list[0].state.reason #=> String
resp.workflow_summary_list[0].date_created #=> String
resp.workflow_summary_list[0].tags #=> Hash
resp.workflow_summary_list[0].tags["TagKey"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :workflow_version_arn (String) —

    The Amazon Resource Name (ARN) of the workflow resource for which to get a list of build versions.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



4896
4897
4898
4899
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4896

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

#list_workflow_executions(params = {}) ⇒ Types::ListWorkflowExecutionsResponse

Returns a list of workflow runtime instance metadata objects for a specific image build version.

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_workflow_executions({
  max_results: 1,
  next_token: "PaginationToken",
  image_build_version_arn: "ImageBuildVersionArn", # required
})

Response structure


resp.request_id #=> String
resp.workflow_executions #=> Array
resp.workflow_executions[0].workflow_build_version_arn #=> String
resp.workflow_executions[0].workflow_execution_id #=> String
resp.workflow_executions[0].type #=> String, one of "BUILD", "TEST", "DISTRIBUTION"
resp.workflow_executions[0].status #=> String, one of "PENDING", "SKIPPED", "RUNNING", "COMPLETED", "FAILED", "ROLLBACK_IN_PROGRESS", "ROLLBACK_COMPLETED", "CANCELLED"
resp.workflow_executions[0].message #=> String
resp.workflow_executions[0].total_step_count #=> Integer
resp.workflow_executions[0].total_steps_succeeded #=> Integer
resp.workflow_executions[0].total_steps_failed #=> Integer
resp.workflow_executions[0].total_steps_skipped #=> Integer
resp.workflow_executions[0].start_time #=> String
resp.workflow_executions[0].end_time #=> String
resp.workflow_executions[0].parallel_group #=> String
resp.workflow_executions[0].retried #=> Boolean
resp.image_build_version_arn #=> String
resp.message #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

  • :image_build_version_arn (required, String) —

    List all workflow runtime instances for the specified image build version resource ARN.

Returns:

See Also:



4958
4959
4960
4961
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 4958

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

#list_workflow_step_executions(params = {}) ⇒ Types::ListWorkflowStepExecutionsResponse

Returns runtime data for each step in a runtime instance of the workflow that you specify in the request.

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_workflow_step_executions({
  max_results: 1,
  next_token: "PaginationToken",
  workflow_execution_id: "WorkflowExecutionId", # required
})

Response structure


resp.request_id #=> String
resp.steps #=> Array
resp.steps[0].step_execution_id #=> String
resp.steps[0].name #=> String
resp.steps[0].description #=> String
resp.steps[0].action #=> String
resp.steps[0].status #=> String, one of "PENDING", "SKIPPED", "RUNNING", "COMPLETED", "FAILED", "CANCELLED"
resp.steps[0].rollback_status #=> String, one of "RUNNING", "COMPLETED", "SKIPPED", "FAILED"
resp.steps[0].message #=> String
resp.steps[0].inputs #=> String
resp.steps[0].outputs #=> String
resp.steps[0].start_time #=> String
resp.steps[0].end_time #=> String
resp.workflow_build_version_arn #=> String
resp.workflow_execution_id #=> String
resp.image_build_version_arn #=> String
resp.message #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

  • :workflow_execution_id (required, String) —

    The unique identifier that Image Builder assigned to keep track of runtime details when it ran the workflow.

Returns:

See Also:



5022
5023
5024
5025
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5022

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

#list_workflows(params = {}) ⇒ Types::ListWorkflowsResponse

Lists workflow build versions based on filtering parameters.

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_workflows({
  owner: "Self", # accepts Self, Shared, Amazon, ThirdParty, AWSMarketplace
  filters: [
    {
      name: "FilterName",
      values: ["FilterValue"],
    },
  ],
  by_name: false,
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.workflow_version_list #=> Array
resp.workflow_version_list[0].arn #=> String
resp.workflow_version_list[0].name #=> String
resp.workflow_version_list[0].version #=> String
resp.workflow_version_list[0].description #=> String
resp.workflow_version_list[0].type #=> String, one of "BUILD", "TEST", "DISTRIBUTION"
resp.workflow_version_list[0].owner #=> String
resp.workflow_version_list[0].date_created #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :owner (String) —

    Used to get a list of workflow build version filtered by the identity of the creator.

  • :filters (Array<Types::Filter>) —

    Used to streamline search results.

  • :by_name (Boolean) —

    Specify all or part of the workflow name to streamline results.

  • :max_results (Integer) —

    Specify the maximum number of items to return in a request.

  • :next_token (String) —

    A token to specify where to start paginating. This is the nextToken from a previously truncated response.

Returns:

See Also:



5084
5085
5086
5087
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5084

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

#put_component_policy(params = {}) ⇒ Types::PutComponentPolicyResponse

Applies a policy to a component. We recommend that you call the RAM API CreateResourceShare to share resources. If you call the Image Builder API PutComponentPolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy in order for the resource to be visible to all principals with whom the resource is shared.

Examples:

Request syntax with placeholder values


resp = client.put_component_policy({
  component_arn: "ComponentBuildVersionArn", # required
  policy: "ResourcePolicyDocument", # required
})

Response structure


resp.request_id #=> String
resp.component_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :component_arn (required, String) —

    The Amazon Resource Name (ARN) of the component that this policy should be applied to.

  • :policy (required, String) —

    The policy to apply.

Returns:

See Also:



5128
5129
5130
5131
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5128

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

#put_container_recipe_policy(params = {}) ⇒ Types::PutContainerRecipePolicyResponse

Applies a policy to a container image. We recommend that you call the RAM API CreateResourceShare (https://docs.aws.amazon.com//ram/latest/APIReference/API_CreateResourceShare.html) to share resources. If you call the Image Builder API PutContainerImagePolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy (https://docs.aws.amazon.com//ram/latest/APIReference/API_PromoteResourceShareCreatedFromPolicy.html) in order for the resource to be visible to all principals with whom the resource is shared.

Examples:

Request syntax with placeholder values


resp = client.put_container_recipe_policy({
  container_recipe_arn: "ContainerRecipeArn", # required
  policy: "ResourcePolicyDocument", # required
})

Response structure


resp.request_id #=> String
resp.container_recipe_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :container_recipe_arn (required, String) —

    The Amazon Resource Name (ARN) of the container recipe that this policy should be applied to.

  • :policy (required, String) —

    The policy to apply to the container recipe.

Returns:

See Also:



5171
5172
5173
5174
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5171

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

#put_image_policy(params = {}) ⇒ Types::PutImagePolicyResponse

Applies a policy to an image. We recommend that you call the RAM API CreateResourceShare to share resources. If you call the Image Builder API PutImagePolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy in order for the resource to be visible to all principals with whom the resource is shared.

Examples:

Request syntax with placeholder values


resp = client.put_image_policy({
  image_arn: "ImageBuildVersionArn", # required
  policy: "ResourcePolicyDocument", # required
})

Response structure


resp.request_id #=> String
resp.image_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_arn (required, String) —

    The Amazon Resource Name (ARN) of the image that this policy should be applied to.

  • :policy (required, String) —

    The policy to apply.

Returns:

See Also:



5215
5216
5217
5218
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5215

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

#put_image_recipe_policy(params = {}) ⇒ Types::PutImageRecipePolicyResponse

Applies a policy to an image recipe. We recommend that you call the RAM API CreateResourceShare to share resources. If you call the Image Builder API PutImageRecipePolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy in order for the resource to be visible to all principals with whom the resource is shared.

Examples:

Request syntax with placeholder values


resp = client.put_image_recipe_policy({
  image_recipe_arn: "ImageRecipeArn", # required
  policy: "ResourcePolicyDocument", # required
})

Response structure


resp.request_id #=> String
resp.image_recipe_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_recipe_arn (required, String) —

    The Amazon Resource Name (ARN) of the image recipe that this policy should be applied to.

  • :policy (required, String) —

    The policy to apply.

Returns:

See Also:



5260
5261
5262
5263
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5260

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

#retry_image(params = {}) ⇒ Types::RetryImageResponse

RetryImage retries an image distribution without rebuilding the image.

Examples:

Request syntax with placeholder values


resp = client.retry_image({
  image_build_version_arn: "ImageBuildVersionArn", # required
  client_token: "ClientToken", # required
})

Response structure


resp.client_token #=> String
resp.image_build_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_build_version_arn (required, String) —

    The source image Amazon Resource Name (ARN) to retry.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



5303
5304
5305
5306
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5303

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

#send_workflow_step_action(params = {}) ⇒ Types::SendWorkflowStepActionResponse

Pauses or resumes image creation when the associated workflow runs a WaitForAction step.

Examples:

Request syntax with placeholder values


resp = client.send_workflow_step_action({
  step_execution_id: "WorkflowStepExecutionId", # required
  image_build_version_arn: "ImageBuildVersionArn", # required
  action: "RESUME", # required, accepts RESUME, STOP
  reason: "NonEmptyString",
  client_token: "ClientToken", # required
})

Response structure


resp.step_execution_id #=> String
resp.image_build_version_arn #=> String
resp.client_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :step_execution_id (required, String) —

    Uniquely identifies the workflow step that sent the step action.

  • :image_build_version_arn (required, String) —

    The Amazon Resource Name (ARN) of the image build version to send action for.

  • :action (required, String) —

    The action for the image creation process to take while a workflow WaitForAction step waits for an asynchronous action to complete.

  • :reason (String) —

    The reason why this action is sent.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



5363
5364
5365
5366
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5363

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

#start_image_pipeline_execution(params = {}) ⇒ Types::StartImagePipelineExecutionResponse

Manually triggers a pipeline to create an image.

Examples:

Request syntax with placeholder values


resp = client.start_image_pipeline_execution({
  image_pipeline_arn: "ImagePipelineArn", # required
  client_token: "ClientToken", # required
  tags: {
    "TagKey" => "TagValue",
  },
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.image_build_version_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_pipeline_arn (required, String) —

    The Amazon Resource Name (ARN) of the image pipeline that you want to manually invoke.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

  • :tags (Hash<String,String>) —

    Specify tags for Image Builder to apply to the image resource that's created When it starts pipeline execution.

Returns:

See Also:



5416
5417
5418
5419
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5416

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

#start_resource_state_update(params = {}) ⇒ Types::StartResourceStateUpdateResponse

Begin asynchronous resource state update for lifecycle changes to the specified image resources.

Examples:

Request syntax with placeholder values


resp = client.start_resource_state_update({
  resource_arn: "ImageBuildVersionArn", # required
  state: { # required
    status: "AVAILABLE", # accepts AVAILABLE, DELETED, DEPRECATED, DISABLED
  },
  execution_role: "RoleNameOrArn",
  include_resources: {
    amis: false,
    snapshots: false,
    containers: false,
  },
  exclusion_rules: {
    amis: {
      is_public: false,
      regions: ["NonEmptyString"],
      shared_accounts: ["AccountId"],
      last_launched: {
        value: 1, # required
        unit: "DAYS", # required, accepts DAYS, WEEKS, MONTHS, YEARS
      },
      tag_map: {
        "TagKey" => "TagValue",
      },
    },
  },
  update_at: Time.now,
  client_token: "ClientToken", # required
})

Response structure


resp.lifecycle_execution_id #=> String
resp.resource_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the Image Builder resource that is updated. The state update might also impact associated resources.

  • :state (required, Types::ResourceState) —

    Indicates the lifecycle action to take for this request.

  • :execution_role (String) —

    The name or Amazon Resource Name (ARN) of the IAM role that’s used to update image state.

  • :include_resources (Types::ResourceStateUpdateIncludeResources) —

    A list of image resources to update state for.

  • :exclusion_rules (Types::ResourceStateUpdateExclusionRules) —

    Skip action on the image resource and associated resources if specified exclusion rules are met.

  • :update_at (Time, DateTime, Date, Integer, String) —

    The timestamp that indicates when resources are updated by a lifecycle action.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



5503
5504
5505
5506
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5503

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

#tag_resource(params = {}) ⇒ Struct

Adds a tag to a resource.

Examples:

Request syntax with placeholder values


resp = client.tag_resource({
  resource_arn: "ImageBuilderArn", # required
  tags: { # required
    "TagKey" => "TagValue",
  },
})

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the resource that you want to tag.

  • :tags (required, Hash<String,String>) —

    The tags to apply to the resource.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



5531
5532
5533
5534
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5531

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

#untag_resource(params = {}) ⇒ Struct

Removes a tag from a resource.

Examples:

Request syntax with placeholder values


resp = client.untag_resource({
  resource_arn: "ImageBuilderArn", # required
  tag_keys: ["TagKey"], # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the resource that you want to untag.

  • :tag_keys (required, Array<String>) —

    The tag keys to remove from the resource.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



5557
5558
5559
5560
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5557

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

#update_distribution_configuration(params = {}) ⇒ Types::UpdateDistributionConfigurationResponse

Updates a new distribution configuration. Distribution configurations define and configure the outputs of your pipeline.

Examples:

Request syntax with placeholder values


resp = client.update_distribution_configuration({
  distribution_configuration_arn: "DistributionConfigurationArn", # required
  description: "NonEmptyString",
  distributions: [ # required
    {
      region: "NonEmptyString", # required
      ami_distribution_configuration: {
        name: "AmiNameString",
        description: "NonEmptyString",
        target_account_ids: ["AccountId"],
        ami_tags: {
          "TagKey" => "TagValue",
        },
        kms_key_id: "NonEmptyString",
        launch_permission: {
          user_ids: ["AccountId"],
          user_groups: ["NonEmptyString"],
          organization_arns: ["OrganizationArn"],
          organizational_unit_arns: ["OrganizationalUnitArn"],
        },
      },
      container_distribution_configuration: {
        description: "NonEmptyString",
        container_tags: ["NonEmptyString"],
        target_repository: { # required
          service: "ECR", # required, accepts ECR
          repository_name: "NonEmptyString", # required
        },
      },
      license_configuration_arns: ["LicenseConfigurationArn"],
      launch_template_configurations: [
        {
          launch_template_id: "LaunchTemplateId", # required
          account_id: "AccountId",
          set_default_version: false,
        },
      ],
      s3_export_configuration: {
        role_name: "NonEmptyString", # required
        disk_image_format: "VMDK", # required, accepts VMDK, RAW, VHD
        s3_bucket: "NonEmptyString", # required
        s3_prefix: "NonEmptyString",
      },
      fast_launch_configurations: [
        {
          enabled: false, # required
          snapshot_configuration: {
            target_resource_count: 1,
          },
          max_parallel_launches: 1,
          launch_template: {
            launch_template_id: "LaunchTemplateId",
            launch_template_name: "NonEmptyString",
            launch_template_version: "NonEmptyString",
          },
          account_id: "AccountId",
        },
      ],
      ssm_parameter_configurations: [
        {
          ami_account_id: "AccountId",
          parameter_name: "SsmParameterName", # required
          data_type: "text", # accepts text, aws:ec2:image
        },
      ],
    },
  ],
  client_token: "ClientToken", # required
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.distribution_configuration_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :distribution_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the distribution configuration that you want to update.

  • :description (String) —

    The description of the distribution configuration.

  • :distributions (required, Array<Types::Distribution>) —

    The distributions of the distribution configuration.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



5675
5676
5677
5678
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5675

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

#update_image_pipeline(params = {}) ⇒ Types::UpdateImagePipelineResponse

Updates an image pipeline. Image pipelines enable you to automate the creation and distribution of images. You must specify exactly one recipe for your image, using either a containerRecipeArn or an imageRecipeArn.

UpdateImagePipeline does not support selective updates for the pipeline. You must specify all of the required properties in the update request, not just the properties that have changed.

Examples:

Request syntax with placeholder values


resp = client.update_image_pipeline({
  image_pipeline_arn: "ImagePipelineArn", # required
  description: "NonEmptyString",
  image_recipe_arn: "ImageRecipeArn",
  container_recipe_arn: "ContainerRecipeArn",
  infrastructure_configuration_arn: "InfrastructureConfigurationArn", # required
  distribution_configuration_arn: "DistributionConfigurationArn",
  image_tests_configuration: {
    image_tests_enabled: false,
    timeout_minutes: 1,
  },
  enhanced_image_metadata_enabled: false,
  schedule: {
    schedule_expression: "NonEmptyString",
    timezone: "Timezone",
    pipeline_execution_start_condition: "EXPRESSION_MATCH_ONLY", # accepts EXPRESSION_MATCH_ONLY, EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE
    auto_disable_policy: {
      failure_count: 1, # required
    },
  },
  status: "DISABLED", # accepts DISABLED, ENABLED
  client_token: "ClientToken", # required
  image_scanning_configuration: {
    image_scanning_enabled: false,
    ecr_configuration: {
      repository_name: "NonEmptyString",
      container_tags: ["NonEmptyString"],
    },
  },
  workflows: [
    {
      workflow_arn: "WorkflowVersionArnOrBuildVersionArn", # required
      parameters: [
        {
          name: "WorkflowParameterName", # required
          value: ["WorkflowParameterValue"], # required
        },
      ],
      parallel_group: "ParallelGroup",
      on_failure: "CONTINUE", # accepts CONTINUE, ABORT
    },
  ],
  logging_configuration: {
    image_log_group_name: "LogGroupName",
    pipeline_log_group_name: "LogGroupName",
  },
  execution_role: "RoleNameOrArn",
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.image_pipeline_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :image_pipeline_arn (required, String) —

    The Amazon Resource Name (ARN) of the image pipeline that you want to update.

  • :description (String) —

    The description of the image pipeline.

  • :image_recipe_arn (String) —

    The Amazon Resource Name (ARN) of the image recipe that will be used to configure images updated by this image pipeline.

  • :container_recipe_arn (String) —

    The Amazon Resource Name (ARN) of the container pipeline to update.

  • :infrastructure_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the infrastructure configuration that Image Builder uses to build images that this image pipeline has updated.

  • :distribution_configuration_arn (String) —

    The Amazon Resource Name (ARN) of the distribution configuration that Image Builder uses to configure and distribute images that this image pipeline has updated.

  • :image_tests_configuration (Types::ImageTestsConfiguration) —

    The image test configuration of the image pipeline.

  • :enhanced_image_metadata_enabled (Boolean) —

    Collects additional information about the image being created, including the operating system (OS) version and package list. This information is used to enhance the overall experience of using EC2 Image Builder. Enabled by default.

  • :schedule (Types::Schedule) —

    The schedule of the image pipeline.

  • :status (String) —

    The status of the image pipeline.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

  • :image_scanning_configuration (Types::ImageScanningConfiguration) —

    Contains settings for vulnerability scans.

  • :workflows (Array<Types::WorkflowConfiguration>) —

    Contains the workflows to run for the pipeline.

  • :logging_configuration (Types::PipelineLoggingConfiguration) —

    Update logging configuration for the output image that's created when the pipeline runs.

  • :execution_role (String) —

    The name or Amazon Resource Name (ARN) for the IAM role you create that grants Image Builder access to perform workflow actions.

Returns:

See Also:



5823
5824
5825
5826
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5823

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

#update_infrastructure_configuration(params = {}) ⇒ Types::UpdateInfrastructureConfigurationResponse

Updates a new infrastructure configuration. An infrastructure configuration defines the environment in which your image will be built and tested.

Examples:

Request syntax with placeholder values


resp = client.update_infrastructure_configuration({
  infrastructure_configuration_arn: "InfrastructureConfigurationArn", # required
  description: "NonEmptyString",
  instance_types: ["InstanceType"],
  instance_profile_name: "InstanceProfileNameType", # required
  security_group_ids: ["NonEmptyString"],
  subnet_id: "NonEmptyString",
  logging: {
    s3_logs: {
      s3_bucket_name: "NonEmptyString",
      s3_key_prefix: "NonEmptyString",
    },
  },
  key_pair: "NonEmptyString",
  terminate_instance_on_failure: false,
  sns_topic_arn: "SnsTopicArn",
  resource_tags: {
    "TagKey" => "TagValue",
  },
  instance_metadata_options: {
    http_tokens: "HttpTokens",
    http_put_response_hop_limit: 1,
  },
  placement: {
    availability_zone: "NonEmptyString",
    tenancy: "default", # accepts default, dedicated, host
    host_id: "NonEmptyString",
    host_resource_group_arn: "NonEmptyString",
  },
  client_token: "ClientToken", # required
})

Response structure


resp.request_id #=> String
resp.client_token #=> String
resp.infrastructure_configuration_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :infrastructure_configuration_arn (required, String) —

    The Amazon Resource Name (ARN) of the infrastructure configuration that you want to update.

  • :description (String) —

    The description of the infrastructure configuration.

  • :instance_types (Array<String>) —

    The instance types of the infrastructure configuration. You can specify one or more instance types to use for this build. The service will pick one of these instance types based on availability.

  • :instance_profile_name (required, String) —

    The instance profile to associate with the instance used to customize your Amazon EC2 AMI.

  • :security_group_ids (Array<String>) —

    The security group IDs to associate with the instance used to customize your Amazon EC2 AMI.

  • :subnet_id (String) —

    The subnet ID to place the instance used to customize your Amazon EC2 AMI in.

  • :logging (Types::Logging) —

    The logging configuration of the infrastructure configuration.

  • :key_pair (String) —

    The key pair of the infrastructure configuration. You can use this to log on to and debug the instance used to create your image.

  • :terminate_instance_on_failure (Boolean) —

    The terminate instance on failure setting of the infrastructure configuration. Set to false if you want Image Builder to retain the instance used to configure your AMI if the build or test phase of your workflow fails.

  • :sns_topic_arn (String) —

    The Amazon Resource Name (ARN) for the SNS topic to which we send image build event notifications.

    EC2 Image Builder is unable to send notifications to SNS topics that are encrypted using keys from other accounts. The key that is used to encrypt the SNS topic must reside in the account that the Image Builder service runs under.

  • :resource_tags (Hash<String,String>) —

    The tags attached to the resource created by Image Builder.

  • :instance_metadata_options (Types::InstanceMetadataOptions) —

    The instance metadata options that you can set for the HTTP requests that pipeline builds use to launch EC2 build and test instances. For more information about instance metadata options, see one of the following links:

  • :placement (Types::Placement) —

    The instance placement settings that define where the instances that are launched from your image will run.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



5966
5967
5968
5969
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 5966

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

#update_lifecycle_policy(params = {}) ⇒ Types::UpdateLifecyclePolicyResponse

Update the specified lifecycle policy.

Examples:

Request syntax with placeholder values


resp = client.update_lifecycle_policy({
  lifecycle_policy_arn: "LifecyclePolicyArn", # required
  description: "NonEmptyString",
  status: "DISABLED", # accepts DISABLED, ENABLED
  execution_role: "RoleNameOrArn", # required
  resource_type: "AMI_IMAGE", # required, accepts AMI_IMAGE, CONTAINER_IMAGE
  policy_details: [ # required
    {
      action: { # required
        type: "DELETE", # required, accepts DELETE, DEPRECATE, DISABLE
        include_resources: {
          amis: false,
          snapshots: false,
          containers: false,
        },
      },
      filter: { # required
        type: "AGE", # required, accepts AGE, COUNT
        value: 1, # required
        unit: "DAYS", # accepts DAYS, WEEKS, MONTHS, YEARS
        retain_at_least: 1,
      },
      exclusion_rules: {
        tag_map: {
          "TagKey" => "TagValue",
        },
        amis: {
          is_public: false,
          regions: ["NonEmptyString"],
          shared_accounts: ["AccountId"],
          last_launched: {
            value: 1, # required
            unit: "DAYS", # required, accepts DAYS, WEEKS, MONTHS, YEARS
          },
          tag_map: {
            "TagKey" => "TagValue",
          },
        },
      },
    },
  ],
  resource_selection: { # required
    recipes: [
      {
        name: "ResourceName", # required
        semantic_version: "VersionNumber", # required
      },
    ],
    tag_map: {
      "TagKey" => "TagValue",
    },
  },
  client_token: "ClientToken", # required
})

Response structure


resp.lifecycle_policy_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :lifecycle_policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the lifecycle policy resource.

  • :description (String) —

    Optional description for the lifecycle policy.

  • :status (String) —

    Indicates whether the lifecycle policy resource is enabled.

  • :execution_role (required, String) —

    The name or Amazon Resource Name (ARN) of the IAM role that Image Builder uses to update the lifecycle policy.

  • :resource_type (required, String) —

    The type of image resource that the lifecycle policy applies to.

  • :policy_details (required, Array<Types::LifecyclePolicyDetail>) —

    The configuration details for a lifecycle policy resource.

  • :resource_selection (required, Types::LifecyclePolicyResourceSelection) —

    Selection criteria for resources that the lifecycle policy applies to.

  • :client_token (required, String) —

    Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency in the Amazon EC2 API Reference.

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

Returns:

See Also:



6076
6077
6078
6079
 
# File 'gems/aws-sdk-imagebuilder/lib/aws-sdk-imagebuilder/client.rb', line 6076

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