Class: Aws::ECRPublic::Client

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

Overview

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

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

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

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

Class Attribute Summary collapse

API Operations collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

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

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

    • ‘ENV`, `ENV`, `ENV`, and `ENV`.

    • ‘~/.aws/credentials`

    • ‘~/.aws/config`

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

  • :region (required, String) —

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

  • :access_key_id (String)
  • :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` 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 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 the 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` - A retry mode that includes all the functionality of `standard` mode along with automatic client side throttling.

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

  • :simple_json (Boolean) — default: false —

    Disables request parameter conversion, validation, and formatting. Also disables response data type conversions. The request parameters hash must be formatted exactly as the API expects.This option is useful when you want to ensure the highest level of performance by avoiding overhead of walking request parameters and response data structures.

  • :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::ECRPublic::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to ‘#resolve_endpoint(parameters)` where `parameters` is a Struct similar to `Aws::ECRPublic::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 ‘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.



478
479
480
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 478

def initialize(*args)
  super
end

Class Attribute Details

.identifier ⇒ Object (readonly)

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



1710
1711
1712
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1710

def identifier
  @identifier
end

Class Method Details

.errors_module ⇒ Object

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



1713
1714
1715
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1713

def errors_module
  Errors
end

Instance Method Details

#batch_check_layer_availability(params = {}) ⇒ Types::BatchCheckLayerAvailabilityResponse

Checks the availability of one or more image layers that are within a repository in a public registry. When an image is pushed to a repository, each image layer is checked to verify if it has been uploaded before. If it has been uploaded, then the image layer is skipped.

<note markdown=“1”> This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the ‘docker` CLI to pull, tag, and push images.

</note>

Examples:

Request syntax with placeholder values


resp = client.batch_check_layer_availability({
  registry_id: "RegistryIdOrAlias",
  repository_name: "RepositoryName", # required
  layer_digests: ["BatchedOperationLayerDigest"], # required
})

Response structure


resp.layers #=> Array
resp.layers[0].layer_digest #=> String
resp.layers[0].layer_availability #=> String, one of "AVAILABLE", "UNAVAILABLE"
resp.layers[0].layer_size #=> Integer
resp.layers[0].media_type #=> String
resp.failures #=> Array
resp.failures[0].layer_digest #=> String
resp.failures[0].failure_code #=> String, one of "InvalidLayerDigest", "MissingLayerDigest"
resp.failures[0].failure_reason #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID, or registry alias, associated with the public registry that contains the image layers to check. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository that’s associated with the image layers to check.

  • :layer_digests (required, Array<String>) —

    The digests of the image layers to check.

Returns:

See Also:



537
538
539
540
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 537

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

#batch_delete_image(params = {}) ⇒ Types::BatchDeleteImageResponse

Deletes a list of specified images that are within a repository in a public registry. Images are specified with either an ‘imageTag` or `imageDigest`.

You can remove a tag from an image by specifying the image’s tag in your request. When you remove the last tag from an image, the image is deleted from your repository.

You can completely delete an image (and all of its tags) by specifying the digest of the image in your request.

Examples:

Request syntax with placeholder values


resp = client.batch_delete_image({
  registry_id: "RegistryIdOrAlias",
  repository_name: "RepositoryName", # required
  image_ids: [ # required
    {
      image_digest: "ImageDigest",
      image_tag: "ImageTag",
    },
  ],
})

Response structure


resp.image_ids #=> Array
resp.image_ids[0].image_digest #=> String
resp.image_ids[0].image_tag #=> String
resp.failures #=> Array
resp.failures[0].image_id.image_digest #=> String
resp.failures[0].image_id.image_tag #=> String
resp.failures[0].failure_code #=> String, one of "InvalidImageDigest", "InvalidImageTag", "ImageTagDoesNotMatchDigest", "ImageNotFound", "MissingDigestAndTag", "ImageReferencedByManifestList", "KmsError"
resp.failures[0].failure_reason #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID, or registry alias, that’s associated with the registry that contains the image to delete. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The repository in a public registry that contains the image to delete.

  • :image_ids (required, Array<Types::ImageIdentifier>) —

    A list of image ID references that correspond to images to delete. The format of the ‘imageIds` reference is `imageTag=tag` or `imageDigest=digest`.

Returns:

See Also:



599
600
601
602
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 599

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

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

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

Parameters:

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


1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1683

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  tracer = config.telemetry_provider.tracer_provider.tracer(
    Aws::Telemetry.module_to_tracer_name('Aws::ECRPublic')
  )
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config,
    tracer: tracer
  )
  context[:gem_name] = 'aws-sdk-ecrpublic'
  context[:gem_version] = '1.66.0'
  Seahorse::Client::Request.new(handlers, context)
end

#complete_layer_upload(params = {}) ⇒ Types::CompleteLayerUploadResponse

Informs Amazon ECR that the image layer upload is complete for a specified public registry, repository name, and upload ID. You can optionally provide a ‘sha256` digest of the image layer for data validation purposes.

When an image is pushed, the CompleteLayerUpload API is called once for each new image layer to verify that the upload is complete.

<note markdown=“1”> This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the ‘docker` CLI to pull, tag, and push images.

</note>

Examples:

Request syntax with placeholder values


resp = client.complete_layer_upload({
  registry_id: "RegistryIdOrAlias",
  repository_name: "RepositoryName", # required
  upload_id: "UploadId", # required
  layer_digests: ["LayerDigest"], # required
})

Response structure


resp.registry_id #=> String
resp.repository_name #=> String
resp.upload_id #=> String
resp.layer_digest #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID, or registry alias, associated with the registry where layers are uploaded. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository in a public registry to associate with the image layer.

  • :upload_id (required, String) —

    The upload ID from a previous InitiateLayerUpload operation to associate with the image layer.

  • :layer_digests (required, Array<String>) —

    The ‘sha256` digest of the image layer.

Returns:

See Also:



661
662
663
664
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 661

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

#create_repository(params = {}) ⇒ Types::CreateRepositoryResponse

Creates a repository in a public registry. For more information, see

Amazon ECR repositories][1

in the *Amazon Elastic Container Registry

User Guide*.

[1]: docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html

Examples:

Request syntax with placeholder values


resp = client.create_repository({
  repository_name: "RepositoryName", # required
  catalog_data: {
    description: "RepositoryDescription",
    architectures: ["Architecture"],
    operating_systems: ["OperatingSystem"],
    logo_image_blob: "data",
    about_text: "AboutText",
    usage_text: "UsageText",
  },
  tags: [
    {
      key: "TagKey",
      value: "TagValue",
    },
  ],
})

Response structure


resp.repository.repository_arn #=> String
resp.repository.registry_id #=> String
resp.repository.repository_name #=> String
resp.repository.repository_uri #=> String
resp.repository.created_at #=> Time
resp.catalog_data.description #=> String
resp.catalog_data.architectures #=> Array
resp.catalog_data.architectures[0] #=> String
resp.catalog_data.operating_systems #=> Array
resp.catalog_data.operating_systems[0] #=> String
resp.catalog_data.logo_url #=> String
resp.catalog_data.about_text #=> String
resp.catalog_data.usage_text #=> String
resp.catalog_data.marketplace_certified #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :repository_name (required, String) —

    The name to use for the repository. This appears publicly in the Amazon ECR Public Gallery. The repository name can be specified on its own (for example ‘nginx-web-app`) or prepended with a namespace to group the repository into a category (for example `project-a/nginx-web-app`).

  • :catalog_data (Types::RepositoryCatalogDataInput) —

    The details about the repository that are publicly visible in the Amazon ECR Public Gallery.

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

    The metadata that you apply to each repository to help categorize and organize your repositories. Each tag consists of a key and an optional value. You define both of them. Tag keys can have a maximum character length of 128 characters, and tag values can have a maximum length of 256 characters.

Returns:

See Also:



738
739
740
741
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 738

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

#delete_repository(params = {}) ⇒ Types::DeleteRepositoryResponse

Deletes a repository in a public registry. If the repository contains images, you must either manually delete all images in the repository or use the ‘force` option. This option deletes all images on your behalf before deleting the repository.

Examples:

Request syntax with placeholder values


resp = client.delete_repository({
  registry_id: "RegistryId",
  repository_name: "RepositoryName", # required
  force: false,
})

Response structure


resp.repository.repository_arn #=> String
resp.repository.registry_id #=> String
resp.repository.repository_name #=> String
resp.repository.repository_uri #=> String
resp.repository.created_at #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID that’s associated with the public registry that contains the repository to delete. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository to delete.

  • :force (Boolean) —

    The force option can be used to delete a repository that contains images. If the force option is not used, the repository must be empty prior to deletion.

Returns:

See Also:



785
786
787
788
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 785

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

#delete_repository_policy(params = {}) ⇒ Types::DeleteRepositoryPolicyResponse

Deletes the repository policy that’s associated with the specified repository.

Examples:

Request syntax with placeholder values


resp = client.delete_repository_policy({
  registry_id: "RegistryId",
  repository_name: "RepositoryName", # required
})

Response structure


resp.registry_id #=> String
resp.repository_name #=> String
resp.policy_text #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID that’s associated with the public registry that contains the repository policy to delete. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository that’s associated with the repository policy to delete.

Returns:

See Also:



825
826
827
828
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 825

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

#describe_image_tags(params = {}) ⇒ Types::DescribeImageTagsResponse

Returns the image tag details for a repository in a public registry.

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

Examples:

Request syntax with placeholder values


resp = client.describe_image_tags({
  registry_id: "RegistryId",
  repository_name: "RepositoryName", # required
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.image_tag_details #=> Array
resp.image_tag_details[0].image_tag #=> String
resp.image_tag_details[0].created_at #=> Time
resp.image_tag_details[0].image_detail.image_digest #=> String
resp.image_tag_details[0].image_detail.image_size_in_bytes #=> Integer
resp.image_tag_details[0].image_detail.image_pushed_at #=> Time
resp.image_tag_details[0].image_detail.image_manifest_media_type #=> String
resp.image_tag_details[0].image_detail.artifact_media_type #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID that’s associated with the public registry that contains the repository where images are described. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository that contains the image tag details to describe.

  • :next_token (String) —

    The ‘nextToken` value that’s returned from a previous paginated ‘DescribeImageTags` request where `maxResults` was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the `nextToken` value. If there are no more results to return, this value is `null`. If you specify images with `imageIds`, you can’t use this option.

  • :max_results (Integer) —

    The maximum number of repository results that’s returned by ‘DescribeImageTags` in paginated output. When this parameter is used, `DescribeImageTags` only returns `maxResults` results in a single page along with a `nextToken` response element. You can see the remaining results of the initial request by sending another `DescribeImageTags` request with the returned `nextToken` value. This value can be between 1 and 1000. If this parameter isn’t used, then ‘DescribeImageTags` returns up to 100 results and a `nextToken` value, if applicable. If you specify images with `imageIds`, you can’t use this option.

Returns:

See Also:



892
893
894
895
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 892

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

#describe_images(params = {}) ⇒ Types::DescribeImagesResponse

Returns metadata that’s related to the images in a repository in a public registry.

<note markdown=“1”> Beginning with Docker version 1.9, the Docker client compresses image layers before pushing them to a V2 Docker registry. The output of the ‘docker images` command shows the uncompressed image size. Therefore, it might return a larger image size than the image sizes that are returned by DescribeImages.

</note>

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

Examples:

Request syntax with placeholder values


resp = client.describe_images({
  registry_id: "RegistryId",
  repository_name: "RepositoryName", # required
  image_ids: [
    {
      image_digest: "ImageDigest",
      image_tag: "ImageTag",
    },
  ],
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.image_details #=> Array
resp.image_details[0].registry_id #=> String
resp.image_details[0].repository_name #=> String
resp.image_details[0].image_digest #=> String
resp.image_details[0].image_tags #=> Array
resp.image_details[0].image_tags[0] #=> String
resp.image_details[0].image_size_in_bytes #=> Integer
resp.image_details[0].image_pushed_at #=> Time
resp.image_details[0].image_manifest_media_type #=> String
resp.image_details[0].artifact_media_type #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID that’s associated with the public registry that contains the repository where images are described. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The repository that contains the images to describe.

  • :image_ids (Array<Types::ImageIdentifier>) —

    The list of image IDs for the requested repository.

  • :next_token (String) —

    The ‘nextToken` value that’s returned from a previous paginated ‘DescribeImages` request where `maxResults` was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the `nextToken` value. If there are no more results to return, this value is `null`. If you specify images with `imageIds`, you can’t use this option.

  • :max_results (Integer) —

    The maximum number of repository results that’s returned by ‘DescribeImages` in paginated output. When this parameter is used, `DescribeImages` only returns `maxResults` results in a single page along with a `nextToken` response element. You can see the remaining results of the initial request by sending another `DescribeImages` request with the returned `nextToken` value. This value can be between 1 and 1000. If this parameter isn’t used, then ‘DescribeImages` returns up to 100 results and a `nextToken` value, if applicable. If you specify images with `imageIds`, you can’t use this option.

Returns:

See Also:



978
979
980
981
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 978

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

#describe_registries(params = {}) ⇒ Types::DescribeRegistriesResponse

Returns details for a public registry.

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

Examples:

Request syntax with placeholder values


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

Response structure


resp.registries #=> Array
resp.registries[0].registry_id #=> String
resp.registries[0].registry_arn #=> String
resp.registries[0].registry_uri #=> String
resp.registries[0].verified #=> Boolean
resp.registries[0].aliases #=> Array
resp.registries[0].aliases[0].name #=> String
resp.registries[0].aliases[0].status #=> String, one of "ACTIVE", "PENDING", "REJECTED"
resp.registries[0].aliases[0].primary_registry_alias #=> Boolean
resp.registries[0].aliases[0].default_registry_alias #=> Boolean
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The ‘nextToken` value that’s returned from a previous paginated ‘DescribeRegistries` request where `maxResults` was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the `nextToken` value. If there are no more results to return, this value is `null`.

    <note markdown=“1”> This token should be treated as an opaque identifier that is only used to retrieve the next items in a list and not for other programmatic purposes.

    </note>
  • :max_results (Integer) —

    The maximum number of repository results that’s returned by ‘DescribeRegistries` in paginated output. When this parameter is used, `DescribeRegistries` only returns `maxResults` results in a single page along with a `nextToken` response element. The remaining results of the initial request can be seen by sending another `DescribeRegistries` request with the returned `nextToken` value. This value can be between 1 and 1000. If this parameter isn’t used, then ‘DescribeRegistries` returns up to 100 results and a `nextToken` value, if applicable.

Returns:

See Also:



1041
1042
1043
1044
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1041

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

#describe_repositories(params = {}) ⇒ Types::DescribeRepositoriesResponse

Describes repositories that are in a public registry.

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

Examples:

Request syntax with placeholder values


resp = client.describe_repositories({
  registry_id: "RegistryId",
  repository_names: ["RepositoryName"],
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.repositories #=> Array
resp.repositories[0].repository_arn #=> String
resp.repositories[0].registry_id #=> String
resp.repositories[0].repository_name #=> String
resp.repositories[0].repository_uri #=> String
resp.repositories[0].created_at #=> Time
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID that’s associated with the registry that contains the repositories to be described. If you do not specify a registry, the default public registry is assumed.

  • :repository_names (Array<String>) —

    A list of repositories to describe. If this parameter is omitted, then all repositories in a registry are described.

  • :next_token (String) —

    The ‘nextToken` value that’s returned from a previous paginated ‘DescribeRepositories` request where `maxResults` was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the `nextToken` value. If there are no more results to return, this value is `null`. If you specify repositories with `repositoryNames`, you can’t use this option.

    <note markdown=“1”> This token should be treated as an opaque identifier that is only used to retrieve the next items in a list and not for other programmatic purposes.

    </note>
  • :max_results (Integer) —

    The maximum number of repository results that’s returned by ‘DescribeRepositories` in paginated output. When this parameter is used, `DescribeRepositories` only returns `maxResults` results in a single page along with a `nextToken` response element. You can see the remaining results of the initial request by sending another `DescribeRepositories` request with the returned `nextToken` value. This value can be between 1 and 1000. If this parameter isn’t used, then ‘DescribeRepositories` returns up to 100 results and a `nextToken` value, if applicable. If you specify repositories with `repositoryNames`, you can’t use this option.

Returns:

See Also:



1114
1115
1116
1117
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1114

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

#get_authorization_token(params = {}) ⇒ Types::GetAuthorizationTokenResponse

Retrieves an authorization token. An authorization token represents your IAM authentication credentials. You can use it to access any Amazon ECR registry that your IAM principal has access to. The authorization token is valid for 12 hours. This API requires the ‘ecr-public:GetAuthorizationToken` and `sts:GetServiceBearerToken` permissions.

Examples:

Response structure


resp.authorization_data.authorization_token #=> String
resp.authorization_data.expires_at #=> Time

Parameters:

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

    ({})

Returns:

See Also:



1139
1140
1141
1142
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1139

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

#get_registry_catalog_data(params = {}) ⇒ Types::GetRegistryCatalogDataResponse

Retrieves catalog metadata for a public registry.

Examples:

Response structure


resp.registry_catalog_data.display_name #=> String

Parameters:

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

    ({})

Returns:

See Also:



1158
1159
1160
1161
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1158

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

#get_repository_catalog_data(params = {}) ⇒ Types::GetRepositoryCatalogDataResponse

Retrieve catalog metadata for a repository in a public registry. This metadata is displayed publicly in the Amazon ECR Public Gallery.

Examples:

Request syntax with placeholder values


resp = client.get_repository_catalog_data({
  registry_id: "RegistryId",
  repository_name: "RepositoryName", # required
})

Response structure


resp.catalog_data.description #=> String
resp.catalog_data.architectures #=> Array
resp.catalog_data.architectures[0] #=> String
resp.catalog_data.operating_systems #=> Array
resp.catalog_data.operating_systems[0] #=> String
resp.catalog_data.logo_url #=> String
resp.catalog_data.about_text #=> String
resp.catalog_data.usage_text #=> String
resp.catalog_data.marketplace_certified #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID that’s associated with the registry that contains the repositories to be described. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository to retrieve the catalog metadata for.

Returns:

See Also:



1201
1202
1203
1204
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1201

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

#get_repository_policy(params = {}) ⇒ Types::GetRepositoryPolicyResponse

Retrieves the repository policy for the specified repository.

Examples:

Request syntax with placeholder values


resp = client.get_repository_policy({
  registry_id: "RegistryId",
  repository_name: "RepositoryName", # required
})

Response structure


resp.registry_id #=> String
resp.repository_name #=> String
resp.policy_text #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID that’s associated with the public registry that contains the repository. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository with the policy to retrieve.

Returns:

See Also:



1239
1240
1241
1242
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1239

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

#initiate_layer_upload(params = {}) ⇒ Types::InitiateLayerUploadResponse

Notifies Amazon ECR that you intend to upload an image layer.

When an image is pushed, the InitiateLayerUpload API is called once for each image layer that hasn’t already been uploaded. Whether an image layer uploads is determined by the BatchCheckLayerAvailability API action.

<note markdown=“1”> This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the ‘docker` CLI to pull, tag, and push images.

</note>

Examples:

Request syntax with placeholder values


resp = client.initiate_layer_upload({
  registry_id: "RegistryIdOrAlias",
  repository_name: "RepositoryName", # required
})

Response structure


resp.upload_id #=> String
resp.part_size #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID, or registry alias, that’s associated with the registry to which you intend to upload layers. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository that you want to upload layers to.

Returns:

See Also:



1286
1287
1288
1289
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1286

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

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

List the tags for an Amazon ECR Public resource.

Examples:

Request syntax with placeholder values


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

Response structure


resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) that identifies the resource to list the tags for. Currently, the supported resource is an Amazon ECR Public repository.

Returns:

See Also:



1318
1319
1320
1321
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1318

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

#put_image(params = {}) ⇒ Types::PutImageResponse

Creates or updates the image manifest and tags that are associated with an image.

When an image is pushed and all new image layers have been uploaded, the PutImage API is called once to create or update the image manifest and the tags that are associated with the image.

<note markdown=“1”> This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the ‘docker` CLI to pull, tag, and push images.

</note>

Examples:

Request syntax with placeholder values


resp = client.put_image({
  registry_id: "RegistryIdOrAlias",
  repository_name: "RepositoryName", # required
  image_manifest: "ImageManifest", # required
  image_manifest_media_type: "MediaType",
  image_tag: "ImageTag",
  image_digest: "ImageDigest",
})

Response structure


resp.image.registry_id #=> String
resp.image.repository_name #=> String
resp.image.image_id.image_digest #=> String
resp.image.image_id.image_tag #=> String
resp.image.image_manifest #=> String
resp.image.image_manifest_media_type #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID, or registry alias, that’s associated with the public registry that contains the repository where the image is put. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository where the image is put.

  • :image_manifest (required, String) —

    The image manifest that corresponds to the image to be uploaded.

  • :image_manifest_media_type (String) —

    The media type of the image manifest. If you push an image manifest that doesn’t contain the ‘mediaType` field, you must specify the `imageManifestMediaType` in the request.

  • :image_tag (String) —

    The tag to associate with the image. This parameter is required for images that use the Docker Image Manifest V2 Schema 2 or Open Container Initiative (OCI) formats.

  • :image_digest (String) —

    The image digest of the image manifest that corresponds to the image.

Returns:

See Also:



1389
1390
1391
1392
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1389

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

#put_registry_catalog_data(params = {}) ⇒ Types::PutRegistryCatalogDataResponse

Create or update the catalog data for a public registry.

Examples:

Request syntax with placeholder values


resp = client.put_registry_catalog_data({
  display_name: "RegistryDisplayName",
})

Response structure


resp.registry_catalog_data.display_name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :display_name (String) —

    The display name for a public registry. The display name is shown as the repository author in the Amazon ECR Public Gallery.

    <note markdown=“1”> The registry display name is only publicly visible in the Amazon ECR Public Gallery for verified accounts.

    </note>

Returns:

See Also:



1423
1424
1425
1426
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1423

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

#put_repository_catalog_data(params = {}) ⇒ Types::PutRepositoryCatalogDataResponse

Creates or updates the catalog data for a repository in a public registry.

Examples:

Request syntax with placeholder values


resp = client.put_repository_catalog_data({
  registry_id: "RegistryId",
  repository_name: "RepositoryName", # required
  catalog_data: { # required
    description: "RepositoryDescription",
    architectures: ["Architecture"],
    operating_systems: ["OperatingSystem"],
    logo_image_blob: "data",
    about_text: "AboutText",
    usage_text: "UsageText",
  },
})

Response structure


resp.catalog_data.description #=> String
resp.catalog_data.architectures #=> Array
resp.catalog_data.architectures[0] #=> String
resp.catalog_data.operating_systems #=> Array
resp.catalog_data.operating_systems[0] #=> String
resp.catalog_data.logo_url #=> String
resp.catalog_data.about_text #=> String
resp.catalog_data.usage_text #=> String
resp.catalog_data.marketplace_certified #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID that’s associated with the public registry the repository is in. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository to create or update the catalog data for.

  • :catalog_data (required, Types::RepositoryCatalogDataInput) —

    An object containing the catalog data for a repository. This data is publicly visible in the Amazon ECR Public Gallery.

Returns:

See Also:



1478
1479
1480
1481
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1478

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

#set_repository_policy(params = {}) ⇒ Types::SetRepositoryPolicyResponse

Applies a repository policy to the specified public repository to control access permissions. For more information, see [Amazon ECR Repository Policies] in the *Amazon Elastic Container Registry User Guide*.

[1]: docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html

Examples:

Request syntax with placeholder values


resp = client.set_repository_policy({
  registry_id: "RegistryId",
  repository_name: "RepositoryName", # required
  policy_text: "RepositoryPolicyText", # required
  force: false,
})

Response structure


resp.registry_id #=> String
resp.repository_name #=> String
resp.policy_text #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID that’s associated with the registry that contains the repository. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository to receive the policy.

  • :policy_text (required, String) —

    The JSON repository policy text to apply to the repository. For more information, see [Amazon ECR Repository Policies] in the *Amazon Elastic Container Registry User Guide*.

    [1]: docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html

  • :force (Boolean) —

    If the policy that you want to set on a repository policy would prevent you from setting another policy in the future, you must force the SetRepositoryPolicy operation. This prevents accidental repository lockouts.

Returns:

See Also:



1540
1541
1542
1543
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1540

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

#tag_resource(params = {}) ⇒ Struct

Associates the specified tags to a resource with the specified ‘resourceArn`. If existing tags on a resource aren’t specified in the request parameters, they aren’t changed. When a resource is deleted, the tags associated with that resource are also deleted.

Examples:

Request syntax with placeholder values


resp = client.tag_resource({
  resource_arn: "Arn", # required
  tags: [ # required
    {
      key: "TagKey",
      value: "TagValue",
    },
  ],
})

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the resource to add tags to. Currently, the supported resource is an Amazon ECR Public repository.

  • :tags (required, Array<Types::Tag>) —

    The tags to add to the resource. A tag is an array of key-value pairs. Tag keys can have a maximum character length of 128 characters, and tag values can have a maximum length of 256 characters.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1577
1578
1579
1580
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1577

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

#untag_resource(params = {}) ⇒ Struct

Deletes specified tags from a resource.

Examples:

Request syntax with placeholder values


resp = client.untag_resource({
  resource_arn: "Arn", # 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 to delete tags from. Currently, the supported resource is an Amazon ECR Public repository.

  • :tag_keys (required, Array<String>) —

    The keys of the tags to be removed.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1604
1605
1606
1607
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1604

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

#upload_layer_part(params = {}) ⇒ Types::UploadLayerPartResponse

Uploads an image layer part to Amazon ECR.

When an image is pushed, each new image layer is uploaded in parts. The maximum size of each image layer part can be 20971520 bytes (about 20MB). The UploadLayerPart API is called once for each new image layer part.

<note markdown=“1”> This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the ‘docker` CLI to pull, tag, and push images.

</note>

Examples:

Request syntax with placeholder values


resp = client.upload_layer_part({
  registry_id: "RegistryIdOrAlias",
  repository_name: "RepositoryName", # required
  upload_id: "UploadId", # required
  part_first_byte: 1, # required
  part_last_byte: 1, # required
  layer_part_blob: "data", # required
})

Response structure


resp.registry_id #=> String
resp.repository_name #=> String
resp.upload_id #=> String
resp.last_byte_received #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :registry_id (String) —

    The Amazon Web Services account ID, or registry alias, that’s associated with the registry that you’re uploading layer parts to. If you do not specify a registry, the default public registry is assumed.

  • :repository_name (required, String) —

    The name of the repository that you’re uploading layer parts to.

  • :upload_id (required, String) —

    The upload ID from a previous InitiateLayerUpload operation to associate with the layer part upload.

  • :part_first_byte (required, Integer) —

    The position of the first byte of the layer part witin the overall image layer.

  • :part_last_byte (required, Integer) —

    The position of the last byte of the layer part within the overall image layer.

  • :layer_part_blob (required, String, StringIO, File) —

    The base64-encoded layer part payload.

Returns:

See Also:



1674
1675
1676
1677
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1674

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

#waiter_names ⇒ Object

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

Deprecated. 


1703
1704
1705
 
# File 'lib/aws-sdk-ecrpublic/client.rb', line 1703

def waiter_names
  []
end