Documentation

Overview

    Package servicediscovery provides the API client, operations, and parameter types for AWS Cloud Map.

    AWS Cloud Map lets you configure public DNS, private DNS, or HTTP namespaces that your microservice applications run in. When an instance of the service becomes available, you can call the AWS Cloud Map API to register the instance with AWS Cloud Map. For public or private DNS namespaces, AWS Cloud Map automatically creates DNS records and an optional health check. Clients that submit public or private DNS queries, or HTTP requests, for the service receive an answer that contains up to eight healthy records.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2017-03-14"
    View Source
    const ServiceID = "ServiceDiscovery"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for AWS Cloud Map.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) CreateHttpNamespace

                func (c *Client) CreateHttpNamespace(ctx context.Context, params *CreateHttpNamespaceInput, optFns ...func(*Options)) (*CreateHttpNamespaceOutput, error)

                  Creates an HTTP namespace. Service instances that you register using an HTTP namespace can be discovered using a DiscoverInstances request but can't be discovered using DNS. For the current quota on the number of namespaces that you can create using the same AWS account, see AWS Cloud Map quotas (https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-limits.html) in the AWS Cloud Map Developer Guide.

                  func (*Client) CreatePrivateDnsNamespace

                  func (c *Client) CreatePrivateDnsNamespace(ctx context.Context, params *CreatePrivateDnsNamespaceInput, optFns ...func(*Options)) (*CreatePrivateDnsNamespaceOutput, error)

                    Creates a private namespace based on DNS, which will be visible only inside a specified Amazon VPC. The namespace defines your service naming scheme. For example, if you name your namespace example.com and name your service backend, the resulting DNS name for the service will be backend.example.com. For the current quota on the number of namespaces that you can create using the same AWS account, see AWS Cloud Map Limits (https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-limits.html) in the AWS Cloud Map Developer Guide.

                    func (*Client) CreatePublicDnsNamespace

                    func (c *Client) CreatePublicDnsNamespace(ctx context.Context, params *CreatePublicDnsNamespaceInput, optFns ...func(*Options)) (*CreatePublicDnsNamespaceOutput, error)

                      Creates a public namespace based on DNS, which will be visible on the internet. The namespace defines your service naming scheme. For example, if you name your namespace example.com and name your service backend, the resulting DNS name for the service will be backend.example.com. For the current quota on the number of namespaces that you can create using the same AWS account, see AWS Cloud Map Limits (https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-limits.html) in the AWS Cloud Map Developer Guide.

                      func (*Client) CreateService

                      func (c *Client) CreateService(ctx context.Context, params *CreateServiceInput, optFns ...func(*Options)) (*CreateServiceOutput, error)

                        Creates a service, which defines the configuration for the following entities:

                        * For public and private DNS namespaces, one of the following combinations of DNS records in Amazon Route 53:

                        * A

                        * AAAA

                        * A and AAAA

                        * SRV

                        * CNAME

                        * Optionally, a health check

                        After you create the service, you can submit a RegisterInstance (https://docs.aws.amazon.com/cloud-map/latest/api/API_RegisterInstance.html) request, and AWS Cloud Map uses the values in the configuration to create the specified entities. For the current quota on the number of instances that you can register using the same namespace and using the same service, see AWS Cloud Map Limits (https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-limits.html) in the AWS Cloud Map Developer Guide.

                        func (*Client) DeleteNamespace

                        func (c *Client) DeleteNamespace(ctx context.Context, params *DeleteNamespaceInput, optFns ...func(*Options)) (*DeleteNamespaceOutput, error)

                          Deletes a namespace from the current account. If the namespace still contains one or more services, the request fails.

                          func (*Client) DeleteService

                          func (c *Client) DeleteService(ctx context.Context, params *DeleteServiceInput, optFns ...func(*Options)) (*DeleteServiceOutput, error)

                            Deletes a specified service. If the service still contains one or more registered instances, the request fails.

                            func (*Client) DeregisterInstance

                            func (c *Client) DeregisterInstance(ctx context.Context, params *DeregisterInstanceInput, optFns ...func(*Options)) (*DeregisterInstanceOutput, error)

                              Deletes the Amazon Route 53 DNS records and health check, if any, that AWS Cloud Map created for the specified instance.

                              func (*Client) DiscoverInstances

                              func (c *Client) DiscoverInstances(ctx context.Context, params *DiscoverInstancesInput, optFns ...func(*Options)) (*DiscoverInstancesOutput, error)

                                Discovers registered instances for a specified namespace and service. You can use DiscoverInstances to discover instances for any type of namespace. For public and private DNS namespaces, you can also use DNS queries to discover instances.

                                func (*Client) GetInstance

                                func (c *Client) GetInstance(ctx context.Context, params *GetInstanceInput, optFns ...func(*Options)) (*GetInstanceOutput, error)

                                  Gets information about a specified instance.

                                  func (*Client) GetInstancesHealthStatus

                                  func (c *Client) GetInstancesHealthStatus(ctx context.Context, params *GetInstancesHealthStatusInput, optFns ...func(*Options)) (*GetInstancesHealthStatusOutput, error)

                                    Gets the current health status (Healthy, Unhealthy, or Unknown) of one or more instances that are associated with a specified service. There is a brief delay between when you register an instance and when the health status for the instance is available.

                                    func (*Client) GetNamespace

                                    func (c *Client) GetNamespace(ctx context.Context, params *GetNamespaceInput, optFns ...func(*Options)) (*GetNamespaceOutput, error)

                                      Gets information about a namespace.

                                      func (*Client) GetOperation

                                      func (c *Client) GetOperation(ctx context.Context, params *GetOperationInput, optFns ...func(*Options)) (*GetOperationOutput, error)

                                        Gets information about any operation that returns an operation ID in the response, such as a CreateService request. To get a list of operations that match specified criteria, see ListOperations (https://docs.aws.amazon.com/cloud-map/latest/api/API_ListOperations.html).

                                        func (*Client) GetService

                                        func (c *Client) GetService(ctx context.Context, params *GetServiceInput, optFns ...func(*Options)) (*GetServiceOutput, error)

                                          Gets the settings for a specified service.

                                          func (*Client) ListInstances

                                          func (c *Client) ListInstances(ctx context.Context, params *ListInstancesInput, optFns ...func(*Options)) (*ListInstancesOutput, error)

                                            Lists summary information about the instances that you registered by using a specified service.

                                            func (*Client) ListNamespaces

                                            func (c *Client) ListNamespaces(ctx context.Context, params *ListNamespacesInput, optFns ...func(*Options)) (*ListNamespacesOutput, error)

                                              Lists summary information about the namespaces that were created by the current AWS account.

                                              func (*Client) ListOperations

                                              func (c *Client) ListOperations(ctx context.Context, params *ListOperationsInput, optFns ...func(*Options)) (*ListOperationsOutput, error)

                                                Lists operations that match the criteria that you specify.

                                                func (*Client) ListServices

                                                func (c *Client) ListServices(ctx context.Context, params *ListServicesInput, optFns ...func(*Options)) (*ListServicesOutput, error)

                                                  Lists summary information for all the services that are associated with one or more specified namespaces.

                                                  func (*Client) ListTagsForResource

                                                  func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                    Lists tags for the specified resource.

                                                    func (*Client) RegisterInstance

                                                    func (c *Client) RegisterInstance(ctx context.Context, params *RegisterInstanceInput, optFns ...func(*Options)) (*RegisterInstanceOutput, error)

                                                      Creates or updates one or more records and, optionally, creates a health check based on the settings in a specified service. When you submit a RegisterInstance request, the following occurs:

                                                      * For each DNS record that you define in the service that is specified by ServiceId, a record is created or updated in the hosted zone that is associated with the corresponding namespace.

                                                      * If the service includes HealthCheckConfig, a health check is created based on the settings in the health check configuration.

                                                      * The health check, if any, is associated with each of the new or updated records.

                                                      One RegisterInstance request must complete before you can submit another request and specify the same service ID and instance ID. For more information, see CreateService (https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html). When AWS Cloud Map receives a DNS query for the specified DNS name, it returns the applicable value:

                                                      * If the health check is healthy: returns all the records

                                                      * If the health check is unhealthy: returns the applicable value for the last healthy instance

                                                      * If you didn't specify a health check configuration: returns all the records

                                                      For the current quota on the number of instances that you can register using the same namespace and using the same service, see AWS Cloud Map Limits (https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-limits.html) in the AWS Cloud Map Developer Guide.

                                                      func (*Client) TagResource

                                                      func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                        Adds one or more tags to the specified resource.

                                                        func (*Client) UntagResource

                                                        func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                          Removes one or more tags from the specified resource.

                                                          func (*Client) UpdateInstanceCustomHealthStatus

                                                          func (c *Client) UpdateInstanceCustomHealthStatus(ctx context.Context, params *UpdateInstanceCustomHealthStatusInput, optFns ...func(*Options)) (*UpdateInstanceCustomHealthStatusOutput, error)

                                                            Submits a request to change the health status of a custom health check to healthy or unhealthy. You can use UpdateInstanceCustomHealthStatus to change the status only for custom health checks, which you define using HealthCheckCustomConfig when you create a service. You can't use it to change the status for Route 53 health checks, which you define using HealthCheckConfig. For more information, see HealthCheckCustomConfig (https://docs.aws.amazon.com/cloud-map/latest/api/API_HealthCheckCustomConfig.html).

                                                            func (*Client) UpdateService

                                                            func (c *Client) UpdateService(ctx context.Context, params *UpdateServiceInput, optFns ...func(*Options)) (*UpdateServiceOutput, error)

                                                              Submits a request to perform the following operations:

                                                              * Update the TTL setting for existing DnsRecords configurations

                                                              * Add, update, or delete HealthCheckConfig for a specified service You can't add, update, or delete a HealthCheckCustomConfig configuration.

                                                              For public and private DNS namespaces, note the following:

                                                              * If you omit any existing DnsRecords or HealthCheckConfig configurations from an UpdateService request, the configurations are deleted from the service.

                                                              * If you omit an existing HealthCheckCustomConfig configuration from an UpdateService request, the configuration is not deleted from the service.

                                                              When you update settings for a service, AWS Cloud Map also updates the corresponding settings in all the records and health checks that were created by using the specified service.

                                                              type CreateHttpNamespaceInput

                                                              type CreateHttpNamespaceInput struct {
                                                              
                                                              	// The name that you want to assign to this namespace.
                                                              	//
                                                              	// This member is required.
                                                              	Name *string
                                                              
                                                              	// A unique string that identifies the request and that allows failed
                                                              	// CreateHttpNamespace requests to be retried without the risk of executing the
                                                              	// operation twice. CreatorRequestId can be any unique string, for example, a
                                                              	// date/time stamp.
                                                              	CreatorRequestId *string
                                                              
                                                              	// A description for the namespace.
                                                              	Description *string
                                                              
                                                              	// The tags to add to the namespace. Each tag consists of a key and an optional
                                                              	// value, both of which you define. Tag keys can have a maximum character length of
                                                              	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                              	Tags []types.Tag
                                                              }

                                                              type CreateHttpNamespaceOutput

                                                              type CreateHttpNamespaceOutput struct {
                                                              
                                                              	// A value that you can use to determine whether the request completed
                                                              	// successfully. To get the status of the operation, see GetOperation
                                                              	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html).
                                                              	OperationId *string
                                                              
                                                              	// Metadata pertaining to the operation's result.
                                                              	ResultMetadata middleware.Metadata
                                                              }

                                                              type CreatePrivateDnsNamespaceInput

                                                              type CreatePrivateDnsNamespaceInput struct {
                                                              
                                                              	// The name that you want to assign to this namespace. When you create a private
                                                              	// DNS namespace, AWS Cloud Map automatically creates an Amazon Route 53 private
                                                              	// hosted zone that has the same name as the namespace.
                                                              	//
                                                              	// This member is required.
                                                              	Name *string
                                                              
                                                              	// The ID of the Amazon VPC that you want to associate the namespace with.
                                                              	//
                                                              	// This member is required.
                                                              	Vpc *string
                                                              
                                                              	// A unique string that identifies the request and that allows failed
                                                              	// CreatePrivateDnsNamespace requests to be retried without the risk of executing
                                                              	// the operation twice. CreatorRequestId can be any unique string, for example, a
                                                              	// date/time stamp.
                                                              	CreatorRequestId *string
                                                              
                                                              	// A description for the namespace.
                                                              	Description *string
                                                              
                                                              	// The tags to add to the namespace. Each tag consists of a key and an optional
                                                              	// value, both of which you define. Tag keys can have a maximum character length of
                                                              	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                              	Tags []types.Tag
                                                              }

                                                              type CreatePrivateDnsNamespaceOutput

                                                              type CreatePrivateDnsNamespaceOutput struct {
                                                              
                                                              	// A value that you can use to determine whether the request completed
                                                              	// successfully. To get the status of the operation, see GetOperation
                                                              	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html).
                                                              	OperationId *string
                                                              
                                                              	// Metadata pertaining to the operation's result.
                                                              	ResultMetadata middleware.Metadata
                                                              }

                                                              type CreatePublicDnsNamespaceInput

                                                              type CreatePublicDnsNamespaceInput struct {
                                                              
                                                              	// The name that you want to assign to this namespace.
                                                              	//
                                                              	// This member is required.
                                                              	Name *string
                                                              
                                                              	// A unique string that identifies the request and that allows failed
                                                              	// CreatePublicDnsNamespace requests to be retried without the risk of executing
                                                              	// the operation twice. CreatorRequestId can be any unique string, for example, a
                                                              	// date/time stamp.
                                                              	CreatorRequestId *string
                                                              
                                                              	// A description for the namespace.
                                                              	Description *string
                                                              
                                                              	// The tags to add to the namespace. Each tag consists of a key and an optional
                                                              	// value, both of which you define. Tag keys can have a maximum character length of
                                                              	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                              	Tags []types.Tag
                                                              }

                                                              type CreatePublicDnsNamespaceOutput

                                                              type CreatePublicDnsNamespaceOutput struct {
                                                              
                                                              	// A value that you can use to determine whether the request completed
                                                              	// successfully. To get the status of the operation, see GetOperation
                                                              	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html).
                                                              	OperationId *string
                                                              
                                                              	// Metadata pertaining to the operation's result.
                                                              	ResultMetadata middleware.Metadata
                                                              }

                                                              type CreateServiceInput

                                                              type CreateServiceInput struct {
                                                              
                                                              	// The name that you want to assign to the service. If you want AWS Cloud Map to
                                                              	// create an SRV record when you register an instance, and if you're using a system
                                                              	// that requires a specific SRV format, such as HAProxy (http://www.haproxy.org/),
                                                              	// specify the following for Name:
                                                              	//
                                                              	// * Start the name with an underscore (_), such
                                                              	// as _exampleservice
                                                              	//
                                                              	// * End the name with ._protocol, such as ._tcp
                                                              	//
                                                              	// When you
                                                              	// register an instance, AWS Cloud Map creates an SRV record and assigns a name to
                                                              	// the record by concatenating the service name and the namespace name, for
                                                              	// example: _exampleservice._tcp.example.com
                                                              	//
                                                              	// This member is required.
                                                              	Name *string
                                                              
                                                              	// A unique string that identifies the request and that allows failed CreateService
                                                              	// requests to be retried without the risk of executing the operation twice.
                                                              	// CreatorRequestId can be any unique string, for example, a date/time stamp.
                                                              	CreatorRequestId *string
                                                              
                                                              	// A description for the service.
                                                              	Description *string
                                                              
                                                              	// A complex type that contains information about the Amazon Route 53 records that
                                                              	// you want AWS Cloud Map to create when you register an instance.
                                                              	DnsConfig *types.DnsConfig
                                                              
                                                              	// Public DNS and HTTP namespaces only. A complex type that contains settings for
                                                              	// an optional Route 53 health check. If you specify settings for a health check,
                                                              	// AWS Cloud Map associates the health check with all the Route 53 DNS records that
                                                              	// you specify in DnsConfig. If you specify a health check configuration, you can
                                                              	// specify either HealthCheckCustomConfig or HealthCheckConfig but not both. For
                                                              	// information about the charges for health checks, see AWS Cloud Map Pricing
                                                              	// (http://aws.amazon.com/cloud-map/pricing/).
                                                              	HealthCheckConfig *types.HealthCheckConfig
                                                              
                                                              	// A complex type that contains information about an optional custom health check.
                                                              	// If you specify a health check configuration, you can specify either
                                                              	// HealthCheckCustomConfig or HealthCheckConfig but not both. You can't add,
                                                              	// update, or delete a HealthCheckCustomConfig configuration from an existing
                                                              	// service.
                                                              	HealthCheckCustomConfig *types.HealthCheckCustomConfig
                                                              
                                                              	// The ID of the namespace that you want to use to create the service.
                                                              	NamespaceId *string
                                                              
                                                              	// The tags to add to the service. Each tag consists of a key and an optional
                                                              	// value, both of which you define. Tag keys can have a maximum character length of
                                                              	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                              	Tags []types.Tag
                                                              }

                                                              type CreateServiceOutput

                                                              type CreateServiceOutput struct {
                                                              
                                                              	// A complex type that contains information about the new service.
                                                              	Service *types.Service
                                                              
                                                              	// Metadata pertaining to the operation's result.
                                                              	ResultMetadata middleware.Metadata
                                                              }

                                                              type DeleteNamespaceInput

                                                              type DeleteNamespaceInput struct {
                                                              
                                                              	// The ID of the namespace that you want to delete.
                                                              	//
                                                              	// This member is required.
                                                              	Id *string
                                                              }

                                                              type DeleteNamespaceOutput

                                                              type DeleteNamespaceOutput struct {
                                                              
                                                              	// A value that you can use to determine whether the request completed
                                                              	// successfully. To get the status of the operation, see GetOperation
                                                              	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html).
                                                              	OperationId *string
                                                              
                                                              	// Metadata pertaining to the operation's result.
                                                              	ResultMetadata middleware.Metadata
                                                              }

                                                              type DeleteServiceInput

                                                              type DeleteServiceInput struct {
                                                              
                                                              	// The ID of the service that you want to delete.
                                                              	//
                                                              	// This member is required.
                                                              	Id *string
                                                              }

                                                              type DeleteServiceOutput

                                                              type DeleteServiceOutput struct {
                                                              	// Metadata pertaining to the operation's result.
                                                              	ResultMetadata middleware.Metadata
                                                              }

                                                              type DeregisterInstanceInput

                                                              type DeregisterInstanceInput struct {
                                                              
                                                              	// The value that you specified for Id in the RegisterInstance
                                                              	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_RegisterInstance.html)
                                                              	// request.
                                                              	//
                                                              	// This member is required.
                                                              	InstanceId *string
                                                              
                                                              	// The ID of the service that the instance is associated with.
                                                              	//
                                                              	// This member is required.
                                                              	ServiceId *string
                                                              }

                                                              type DeregisterInstanceOutput

                                                              type DeregisterInstanceOutput struct {
                                                              
                                                              	// A value that you can use to determine whether the request completed
                                                              	// successfully. For more information, see GetOperation
                                                              	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html).
                                                              	OperationId *string
                                                              
                                                              	// Metadata pertaining to the operation's result.
                                                              	ResultMetadata middleware.Metadata
                                                              }

                                                              type DiscoverInstancesInput

                                                              type DiscoverInstancesInput struct {
                                                              
                                                              	// The name of the namespace that you specified when you registered the instance.
                                                              	//
                                                              	// This member is required.
                                                              	NamespaceName *string
                                                              
                                                              	// The name of the service that you specified when you registered the instance.
                                                              	//
                                                              	// This member is required.
                                                              	ServiceName *string
                                                              
                                                              	// The health status of the instances that you want to discover.
                                                              	HealthStatus types.HealthStatusFilter
                                                              
                                                              	// The maximum number of instances that you want AWS Cloud Map to return in the
                                                              	// response to a DiscoverInstances request. If you don't specify a value for
                                                              	// MaxResults, AWS Cloud Map returns up to 100 instances.
                                                              	MaxResults *int32
                                                              
                                                              	// Opportunistic filters to scope the results based on custom attributes. If there
                                                              	// are instances that match both the filters specified in both the QueryParameters
                                                              	// parameter and this parameter, they are returned. Otherwise, these filters are
                                                              	// ignored and only instances that match the filters specified in the
                                                              	// QueryParameters parameter are returned.
                                                              	OptionalParameters map[string]string
                                                              
                                                              	// Filters to scope the results based on custom attributes for the instance. For
                                                              	// example, {version=v1, az=1a}. Only instances that match all the specified
                                                              	// key-value pairs will be returned.
                                                              	QueryParameters map[string]string
                                                              }

                                                              type DiscoverInstancesOutput

                                                              type DiscoverInstancesOutput struct {
                                                              
                                                              	// A complex type that contains one HttpInstanceSummary for each registered
                                                              	// instance.
                                                              	Instances []types.HttpInstanceSummary
                                                              
                                                              	// Metadata pertaining to the operation's result.
                                                              	ResultMetadata middleware.Metadata
                                                              }

                                                              type EndpointResolver

                                                              type EndpointResolver interface {
                                                              	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                              }

                                                                EndpointResolver interface for resolving service endpoints.

                                                                func EndpointResolverFromURL

                                                                func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                  EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                  type EndpointResolverFunc

                                                                  type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                    EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                    func (EndpointResolverFunc) ResolveEndpoint

                                                                    func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                    type EndpointResolverOptions

                                                                    type EndpointResolverOptions = internalendpoints.Options

                                                                      EndpointResolverOptions is the service endpoint resolver options

                                                                      type GetInstanceInput

                                                                      type GetInstanceInput struct {
                                                                      
                                                                      	// The ID of the instance that you want to get information about.
                                                                      	//
                                                                      	// This member is required.
                                                                      	InstanceId *string
                                                                      
                                                                      	// The ID of the service that the instance is associated with.
                                                                      	//
                                                                      	// This member is required.
                                                                      	ServiceId *string
                                                                      }

                                                                      type GetInstanceOutput

                                                                      type GetInstanceOutput struct {
                                                                      
                                                                      	// A complex type that contains information about a specified instance.
                                                                      	Instance *types.Instance
                                                                      
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type GetInstancesHealthStatusAPIClient

                                                                      type GetInstancesHealthStatusAPIClient interface {
                                                                      	GetInstancesHealthStatus(context.Context, *GetInstancesHealthStatusInput, ...func(*Options)) (*GetInstancesHealthStatusOutput, error)
                                                                      }

                                                                        GetInstancesHealthStatusAPIClient is a client that implements the GetInstancesHealthStatus operation.

                                                                        type GetInstancesHealthStatusInput

                                                                        type GetInstancesHealthStatusInput struct {
                                                                        
                                                                        	// The ID of the service that the instance is associated with.
                                                                        	//
                                                                        	// This member is required.
                                                                        	ServiceId *string
                                                                        
                                                                        	// An array that contains the IDs of all the instances that you want to get the
                                                                        	// health status for. If you omit Instances, AWS Cloud Map returns the health
                                                                        	// status for all the instances that are associated with the specified service. To
                                                                        	// get the IDs for the instances that you've registered by using a specified
                                                                        	// service, submit a ListInstances
                                                                        	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_ListInstances.html)
                                                                        	// request.
                                                                        	Instances []string
                                                                        
                                                                        	// The maximum number of instances that you want AWS Cloud Map to return in the
                                                                        	// response to a GetInstancesHealthStatus request. If you don't specify a value for
                                                                        	// MaxResults, AWS Cloud Map returns up to 100 instances.
                                                                        	MaxResults *int32
                                                                        
                                                                        	// For the first GetInstancesHealthStatus request, omit this value. If more than
                                                                        	// MaxResults instances match the specified criteria, you can submit another
                                                                        	// GetInstancesHealthStatus request to get the next group of results. Specify the
                                                                        	// value of NextToken from the previous response in the next request.
                                                                        	NextToken *string
                                                                        }

                                                                        type GetInstancesHealthStatusOutput

                                                                        type GetInstancesHealthStatusOutput struct {
                                                                        
                                                                        	// If more than MaxResults instances match the specified criteria, you can submit
                                                                        	// another GetInstancesHealthStatus request to get the next group of results.
                                                                        	// Specify the value of NextToken from the previous response in the next request.
                                                                        	NextToken *string
                                                                        
                                                                        	// A complex type that contains the IDs and the health status of the instances that
                                                                        	// you specified in the GetInstancesHealthStatus request.
                                                                        	Status map[string]types.HealthStatus
                                                                        
                                                                        	// Metadata pertaining to the operation's result.
                                                                        	ResultMetadata middleware.Metadata
                                                                        }

                                                                        type GetInstancesHealthStatusPaginator

                                                                        type GetInstancesHealthStatusPaginator struct {
                                                                        	// contains filtered or unexported fields
                                                                        }

                                                                          GetInstancesHealthStatusPaginator is a paginator for GetInstancesHealthStatus

                                                                          func NewGetInstancesHealthStatusPaginator

                                                                            NewGetInstancesHealthStatusPaginator returns a new GetInstancesHealthStatusPaginator

                                                                            func (*GetInstancesHealthStatusPaginator) HasMorePages

                                                                            func (p *GetInstancesHealthStatusPaginator) HasMorePages() bool

                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                              func (*GetInstancesHealthStatusPaginator) NextPage

                                                                                NextPage retrieves the next GetInstancesHealthStatus page.

                                                                                type GetInstancesHealthStatusPaginatorOptions

                                                                                type GetInstancesHealthStatusPaginatorOptions struct {
                                                                                	// The maximum number of instances that you want AWS Cloud Map to return in the
                                                                                	// response to a GetInstancesHealthStatus request. If you don't specify a value for
                                                                                	// MaxResults, AWS Cloud Map returns up to 100 instances.
                                                                                	Limit int32
                                                                                
                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                	// that matches the most recent token provided to the service.
                                                                                	StopOnDuplicateToken bool
                                                                                }

                                                                                  GetInstancesHealthStatusPaginatorOptions is the paginator options for GetInstancesHealthStatus

                                                                                  type GetNamespaceInput

                                                                                  type GetNamespaceInput struct {
                                                                                  
                                                                                  	// The ID of the namespace that you want to get information about.
                                                                                  	//
                                                                                  	// This member is required.
                                                                                  	Id *string
                                                                                  }

                                                                                  type GetNamespaceOutput

                                                                                  type GetNamespaceOutput struct {
                                                                                  
                                                                                  	// A complex type that contains information about the specified namespace.
                                                                                  	Namespace *types.Namespace
                                                                                  
                                                                                  	// Metadata pertaining to the operation's result.
                                                                                  	ResultMetadata middleware.Metadata
                                                                                  }

                                                                                  type GetOperationInput

                                                                                  type GetOperationInput struct {
                                                                                  
                                                                                  	// The ID of the operation that you want to get more information about.
                                                                                  	//
                                                                                  	// This member is required.
                                                                                  	OperationId *string
                                                                                  }

                                                                                  type GetOperationOutput

                                                                                  type GetOperationOutput struct {
                                                                                  
                                                                                  	// A complex type that contains information about the operation.
                                                                                  	Operation *types.Operation
                                                                                  
                                                                                  	// Metadata pertaining to the operation's result.
                                                                                  	ResultMetadata middleware.Metadata
                                                                                  }

                                                                                  type GetServiceInput

                                                                                  type GetServiceInput struct {
                                                                                  
                                                                                  	// The ID of the service that you want to get settings for.
                                                                                  	//
                                                                                  	// This member is required.
                                                                                  	Id *string
                                                                                  }

                                                                                  type GetServiceOutput

                                                                                  type GetServiceOutput struct {
                                                                                  
                                                                                  	// A complex type that contains information about the service.
                                                                                  	Service *types.Service
                                                                                  
                                                                                  	// Metadata pertaining to the operation's result.
                                                                                  	ResultMetadata middleware.Metadata
                                                                                  }

                                                                                  type HTTPClient

                                                                                  type HTTPClient interface {
                                                                                  	Do(*http.Request) (*http.Response, error)
                                                                                  }

                                                                                  type HTTPSignerV4

                                                                                  type HTTPSignerV4 interface {
                                                                                  	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                  }

                                                                                  type IdempotencyTokenProvider

                                                                                  type IdempotencyTokenProvider interface {
                                                                                  	GetIdempotencyToken() (string, error)
                                                                                  }

                                                                                    IdempotencyTokenProvider interface for providing idempotency token

                                                                                    type ListInstancesAPIClient

                                                                                    type ListInstancesAPIClient interface {
                                                                                    	ListInstances(context.Context, *ListInstancesInput, ...func(*Options)) (*ListInstancesOutput, error)
                                                                                    }

                                                                                      ListInstancesAPIClient is a client that implements the ListInstances operation.

                                                                                      type ListInstancesInput

                                                                                      type ListInstancesInput struct {
                                                                                      
                                                                                      	// The ID of the service that you want to list instances for.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	ServiceId *string
                                                                                      
                                                                                      	// The maximum number of instances that you want AWS Cloud Map to return in the
                                                                                      	// response to a ListInstances request. If you don't specify a value for
                                                                                      	// MaxResults, AWS Cloud Map returns up to 100 instances.
                                                                                      	MaxResults *int32
                                                                                      
                                                                                      	// For the first ListInstances request, omit this value. If more than MaxResults
                                                                                      	// instances match the specified criteria, you can submit another ListInstances
                                                                                      	// request to get the next group of results. Specify the value of NextToken from
                                                                                      	// the previous response in the next request.
                                                                                      	NextToken *string
                                                                                      }

                                                                                      type ListInstancesOutput

                                                                                      type ListInstancesOutput struct {
                                                                                      
                                                                                      	// Summary information about the instances that are associated with the specified
                                                                                      	// service.
                                                                                      	Instances []types.InstanceSummary
                                                                                      
                                                                                      	// If more than MaxResults instances match the specified criteria, you can submit
                                                                                      	// another ListInstances request to get the next group of results. Specify the
                                                                                      	// value of NextToken from the previous response in the next request.
                                                                                      	NextToken *string
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type ListInstancesPaginator

                                                                                      type ListInstancesPaginator struct {
                                                                                      	// contains filtered or unexported fields
                                                                                      }

                                                                                        ListInstancesPaginator is a paginator for ListInstances

                                                                                        func NewListInstancesPaginator

                                                                                        func NewListInstancesPaginator(client ListInstancesAPIClient, params *ListInstancesInput, optFns ...func(*ListInstancesPaginatorOptions)) *ListInstancesPaginator

                                                                                          NewListInstancesPaginator returns a new ListInstancesPaginator

                                                                                          func (*ListInstancesPaginator) HasMorePages

                                                                                          func (p *ListInstancesPaginator) HasMorePages() bool

                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                            func (*ListInstancesPaginator) NextPage

                                                                                            func (p *ListInstancesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListInstancesOutput, error)

                                                                                              NextPage retrieves the next ListInstances page.

                                                                                              type ListInstancesPaginatorOptions

                                                                                              type ListInstancesPaginatorOptions struct {
                                                                                              	// The maximum number of instances that you want AWS Cloud Map to return in the
                                                                                              	// response to a ListInstances request. If you don't specify a value for
                                                                                              	// MaxResults, AWS Cloud Map returns up to 100 instances.
                                                                                              	Limit int32
                                                                                              
                                                                                              	// Set to true if pagination should stop if the service returns a pagination token
                                                                                              	// that matches the most recent token provided to the service.
                                                                                              	StopOnDuplicateToken bool
                                                                                              }

                                                                                                ListInstancesPaginatorOptions is the paginator options for ListInstances

                                                                                                type ListNamespacesAPIClient

                                                                                                type ListNamespacesAPIClient interface {
                                                                                                	ListNamespaces(context.Context, *ListNamespacesInput, ...func(*Options)) (*ListNamespacesOutput, error)
                                                                                                }

                                                                                                  ListNamespacesAPIClient is a client that implements the ListNamespaces operation.

                                                                                                  type ListNamespacesInput

                                                                                                  type ListNamespacesInput struct {
                                                                                                  
                                                                                                  	// A complex type that contains specifications for the namespaces that you want to
                                                                                                  	// list. If you specify more than one filter, a namespace must match all filters to
                                                                                                  	// be returned by ListNamespaces.
                                                                                                  	Filters []types.NamespaceFilter
                                                                                                  
                                                                                                  	// The maximum number of namespaces that you want AWS Cloud Map to return in the
                                                                                                  	// response to a ListNamespaces request. If you don't specify a value for
                                                                                                  	// MaxResults, AWS Cloud Map returns up to 100 namespaces.
                                                                                                  	MaxResults *int32
                                                                                                  
                                                                                                  	// For the first ListNamespaces request, omit this value. If the response contains
                                                                                                  	// NextToken, submit another ListNamespaces request to get the next group of
                                                                                                  	// results. Specify the value of NextToken from the previous response in the next
                                                                                                  	// request. AWS Cloud Map gets MaxResults namespaces and then filters them based on
                                                                                                  	// the specified criteria. It's possible that no namespaces in the first MaxResults
                                                                                                  	// namespaces matched the specified criteria but that subsequent groups of
                                                                                                  	// MaxResults namespaces do contain namespaces that match the criteria.
                                                                                                  	NextToken *string
                                                                                                  }

                                                                                                  type ListNamespacesOutput

                                                                                                  type ListNamespacesOutput struct {
                                                                                                  
                                                                                                  	// An array that contains one NamespaceSummary object for each namespace that
                                                                                                  	// matches the specified filter criteria.
                                                                                                  	Namespaces []types.NamespaceSummary
                                                                                                  
                                                                                                  	// If the response contains NextToken, submit another ListNamespaces request to get
                                                                                                  	// the next group of results. Specify the value of NextToken from the previous
                                                                                                  	// response in the next request. AWS Cloud Map gets MaxResults namespaces and then
                                                                                                  	// filters them based on the specified criteria. It's possible that no namespaces
                                                                                                  	// in the first MaxResults namespaces matched the specified criteria but that
                                                                                                  	// subsequent groups of MaxResults namespaces do contain namespaces that match the
                                                                                                  	// criteria.
                                                                                                  	NextToken *string
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  type ListNamespacesPaginator

                                                                                                  type ListNamespacesPaginator struct {
                                                                                                  	// contains filtered or unexported fields
                                                                                                  }

                                                                                                    ListNamespacesPaginator is a paginator for ListNamespaces

                                                                                                    func NewListNamespacesPaginator

                                                                                                    func NewListNamespacesPaginator(client ListNamespacesAPIClient, params *ListNamespacesInput, optFns ...func(*ListNamespacesPaginatorOptions)) *ListNamespacesPaginator

                                                                                                      NewListNamespacesPaginator returns a new ListNamespacesPaginator

                                                                                                      func (*ListNamespacesPaginator) HasMorePages

                                                                                                      func (p *ListNamespacesPaginator) HasMorePages() bool

                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                        func (*ListNamespacesPaginator) NextPage

                                                                                                        func (p *ListNamespacesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListNamespacesOutput, error)

                                                                                                          NextPage retrieves the next ListNamespaces page.

                                                                                                          type ListNamespacesPaginatorOptions

                                                                                                          type ListNamespacesPaginatorOptions struct {
                                                                                                          	// The maximum number of namespaces that you want AWS Cloud Map to return in the
                                                                                                          	// response to a ListNamespaces request. If you don't specify a value for
                                                                                                          	// MaxResults, AWS Cloud Map returns up to 100 namespaces.
                                                                                                          	Limit int32
                                                                                                          
                                                                                                          	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                          	// that matches the most recent token provided to the service.
                                                                                                          	StopOnDuplicateToken bool
                                                                                                          }

                                                                                                            ListNamespacesPaginatorOptions is the paginator options for ListNamespaces

                                                                                                            type ListOperationsAPIClient

                                                                                                            type ListOperationsAPIClient interface {
                                                                                                            	ListOperations(context.Context, *ListOperationsInput, ...func(*Options)) (*ListOperationsOutput, error)
                                                                                                            }

                                                                                                              ListOperationsAPIClient is a client that implements the ListOperations operation.

                                                                                                              type ListOperationsInput

                                                                                                              type ListOperationsInput struct {
                                                                                                              
                                                                                                              	// A complex type that contains specifications for the operations that you want to
                                                                                                              	// list, for example, operations that you started between a specified start date
                                                                                                              	// and end date. If you specify more than one filter, an operation must match all
                                                                                                              	// filters to be returned by ListOperations.
                                                                                                              	Filters []types.OperationFilter
                                                                                                              
                                                                                                              	// The maximum number of items that you want AWS Cloud Map to return in the
                                                                                                              	// response to a ListOperations request. If you don't specify a value for
                                                                                                              	// MaxResults, AWS Cloud Map returns up to 100 operations.
                                                                                                              	MaxResults *int32
                                                                                                              
                                                                                                              	// For the first ListOperations request, omit this value. If the response contains
                                                                                                              	// NextToken, submit another ListOperations request to get the next group of
                                                                                                              	// results. Specify the value of NextToken from the previous response in the next
                                                                                                              	// request. AWS Cloud Map gets MaxResults operations and then filters them based on
                                                                                                              	// the specified criteria. It's possible that no operations in the first MaxResults
                                                                                                              	// operations matched the specified criteria but that subsequent groups of
                                                                                                              	// MaxResults operations do contain operations that match the criteria.
                                                                                                              	NextToken *string
                                                                                                              }

                                                                                                              type ListOperationsOutput

                                                                                                              type ListOperationsOutput struct {
                                                                                                              
                                                                                                              	// If the response contains NextToken, submit another ListOperations request to get
                                                                                                              	// the next group of results. Specify the value of NextToken from the previous
                                                                                                              	// response in the next request. AWS Cloud Map gets MaxResults operations and then
                                                                                                              	// filters them based on the specified criteria. It's possible that no operations
                                                                                                              	// in the first MaxResults operations matched the specified criteria but that
                                                                                                              	// subsequent groups of MaxResults operations do contain operations that match the
                                                                                                              	// criteria.
                                                                                                              	NextToken *string
                                                                                                              
                                                                                                              	// Summary information about the operations that match the specified criteria.
                                                                                                              	Operations []types.OperationSummary
                                                                                                              
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              type ListOperationsPaginator

                                                                                                              type ListOperationsPaginator struct {
                                                                                                              	// contains filtered or unexported fields
                                                                                                              }

                                                                                                                ListOperationsPaginator is a paginator for ListOperations

                                                                                                                func NewListOperationsPaginator

                                                                                                                func NewListOperationsPaginator(client ListOperationsAPIClient, params *ListOperationsInput, optFns ...func(*ListOperationsPaginatorOptions)) *ListOperationsPaginator

                                                                                                                  NewListOperationsPaginator returns a new ListOperationsPaginator

                                                                                                                  func (*ListOperationsPaginator) HasMorePages

                                                                                                                  func (p *ListOperationsPaginator) HasMorePages() bool

                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                    func (*ListOperationsPaginator) NextPage

                                                                                                                    func (p *ListOperationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListOperationsOutput, error)

                                                                                                                      NextPage retrieves the next ListOperations page.

                                                                                                                      type ListOperationsPaginatorOptions

                                                                                                                      type ListOperationsPaginatorOptions struct {
                                                                                                                      	// The maximum number of items that you want AWS Cloud Map to return in the
                                                                                                                      	// response to a ListOperations request. If you don't specify a value for
                                                                                                                      	// MaxResults, AWS Cloud Map returns up to 100 operations.
                                                                                                                      	Limit int32
                                                                                                                      
                                                                                                                      	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                      	// that matches the most recent token provided to the service.
                                                                                                                      	StopOnDuplicateToken bool
                                                                                                                      }

                                                                                                                        ListOperationsPaginatorOptions is the paginator options for ListOperations

                                                                                                                        type ListServicesAPIClient

                                                                                                                        type ListServicesAPIClient interface {
                                                                                                                        	ListServices(context.Context, *ListServicesInput, ...func(*Options)) (*ListServicesOutput, error)
                                                                                                                        }

                                                                                                                          ListServicesAPIClient is a client that implements the ListServices operation.

                                                                                                                          type ListServicesInput

                                                                                                                          type ListServicesInput struct {
                                                                                                                          
                                                                                                                          	// A complex type that contains specifications for the namespaces that you want to
                                                                                                                          	// list services for. If you specify more than one filter, an operation must match
                                                                                                                          	// all filters to be returned by ListServices.
                                                                                                                          	Filters []types.ServiceFilter
                                                                                                                          
                                                                                                                          	// The maximum number of services that you want AWS Cloud Map to return in the
                                                                                                                          	// response to a ListServices request. If you don't specify a value for MaxResults,
                                                                                                                          	// AWS Cloud Map returns up to 100 services.
                                                                                                                          	MaxResults *int32
                                                                                                                          
                                                                                                                          	// For the first ListServices request, omit this value. If the response contains
                                                                                                                          	// NextToken, submit another ListServices request to get the next group of results.
                                                                                                                          	// Specify the value of NextToken from the previous response in the next request.
                                                                                                                          	// AWS Cloud Map gets MaxResults services and then filters them based on the
                                                                                                                          	// specified criteria. It's possible that no services in the first MaxResults
                                                                                                                          	// services matched the specified criteria but that subsequent groups of MaxResults
                                                                                                                          	// services do contain services that match the criteria.
                                                                                                                          	NextToken *string
                                                                                                                          }

                                                                                                                          type ListServicesOutput

                                                                                                                          type ListServicesOutput struct {
                                                                                                                          
                                                                                                                          	// If the response contains NextToken, submit another ListServices request to get
                                                                                                                          	// the next group of results. Specify the value of NextToken from the previous
                                                                                                                          	// response in the next request. AWS Cloud Map gets MaxResults services and then
                                                                                                                          	// filters them based on the specified criteria. It's possible that no services in
                                                                                                                          	// the first MaxResults services matched the specified criteria but that subsequent
                                                                                                                          	// groups of MaxResults services do contain services that match the criteria.
                                                                                                                          	NextToken *string
                                                                                                                          
                                                                                                                          	// An array that contains one ServiceSummary object for each service that matches
                                                                                                                          	// the specified filter criteria.
                                                                                                                          	Services []types.ServiceSummary
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ListServicesPaginator

                                                                                                                          type ListServicesPaginator struct {
                                                                                                                          	// contains filtered or unexported fields
                                                                                                                          }

                                                                                                                            ListServicesPaginator is a paginator for ListServices

                                                                                                                            func NewListServicesPaginator

                                                                                                                            func NewListServicesPaginator(client ListServicesAPIClient, params *ListServicesInput, optFns ...func(*ListServicesPaginatorOptions)) *ListServicesPaginator

                                                                                                                              NewListServicesPaginator returns a new ListServicesPaginator

                                                                                                                              func (*ListServicesPaginator) HasMorePages

                                                                                                                              func (p *ListServicesPaginator) HasMorePages() bool

                                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                func (*ListServicesPaginator) NextPage

                                                                                                                                func (p *ListServicesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListServicesOutput, error)

                                                                                                                                  NextPage retrieves the next ListServices page.

                                                                                                                                  type ListServicesPaginatorOptions

                                                                                                                                  type ListServicesPaginatorOptions struct {
                                                                                                                                  	// The maximum number of services that you want AWS Cloud Map to return in the
                                                                                                                                  	// response to a ListServices request. If you don't specify a value for MaxResults,
                                                                                                                                  	// AWS Cloud Map returns up to 100 services.
                                                                                                                                  	Limit int32
                                                                                                                                  
                                                                                                                                  	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                  	// that matches the most recent token provided to the service.
                                                                                                                                  	StopOnDuplicateToken bool
                                                                                                                                  }

                                                                                                                                    ListServicesPaginatorOptions is the paginator options for ListServices

                                                                                                                                    type ListTagsForResourceInput

                                                                                                                                    type ListTagsForResourceInput struct {
                                                                                                                                    
                                                                                                                                    	// The Amazon Resource Name (ARN) of the resource that you want to retrieve tags
                                                                                                                                    	// for.
                                                                                                                                    	//
                                                                                                                                    	// This member is required.
                                                                                                                                    	ResourceARN *string
                                                                                                                                    }

                                                                                                                                    type ListTagsForResourceOutput

                                                                                                                                    type ListTagsForResourceOutput struct {
                                                                                                                                    
                                                                                                                                    	// The tags that are assigned to the resource.
                                                                                                                                    	Tags []types.Tag
                                                                                                                                    
                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                    }

                                                                                                                                    type Options

                                                                                                                                    type Options struct {
                                                                                                                                    	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                    	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                    	// modify this list for per operation behavior.
                                                                                                                                    	APIOptions []func(*middleware.Stack) error
                                                                                                                                    
                                                                                                                                    	// Configures the events that will be sent to the configured logger.
                                                                                                                                    	ClientLogMode aws.ClientLogMode
                                                                                                                                    
                                                                                                                                    	// The credentials object to use when signing requests.
                                                                                                                                    	Credentials aws.CredentialsProvider
                                                                                                                                    
                                                                                                                                    	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                    	EndpointOptions EndpointResolverOptions
                                                                                                                                    
                                                                                                                                    	// The service endpoint resolver.
                                                                                                                                    	EndpointResolver EndpointResolver
                                                                                                                                    
                                                                                                                                    	// Signature Version 4 (SigV4) Signer
                                                                                                                                    	HTTPSignerV4 HTTPSignerV4
                                                                                                                                    
                                                                                                                                    	// Provides idempotency tokens values that will be automatically populated into
                                                                                                                                    	// idempotent API operations.
                                                                                                                                    	IdempotencyTokenProvider IdempotencyTokenProvider
                                                                                                                                    
                                                                                                                                    	// The logger writer interface to write logging messages to.
                                                                                                                                    	Logger logging.Logger
                                                                                                                                    
                                                                                                                                    	// The region to send requests to. (Required)
                                                                                                                                    	Region string
                                                                                                                                    
                                                                                                                                    	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                    	// failures. When nil the API client will use a default retryer.
                                                                                                                                    	Retryer aws.Retryer
                                                                                                                                    
                                                                                                                                    	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                    	// implementation if nil.
                                                                                                                                    	HTTPClient HTTPClient
                                                                                                                                    }

                                                                                                                                    func (Options) Copy

                                                                                                                                    func (o Options) Copy() Options

                                                                                                                                      Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                      type RegisterInstanceInput

                                                                                                                                      type RegisterInstanceInput struct {
                                                                                                                                      
                                                                                                                                      	// A string map that contains the following information for the service that you
                                                                                                                                      	// specify in ServiceId:
                                                                                                                                      	//
                                                                                                                                      	// * The attributes that apply to the records that are
                                                                                                                                      	// defined in the service.
                                                                                                                                      	//
                                                                                                                                      	// * For each attribute, the applicable value.
                                                                                                                                      	//
                                                                                                                                      	// Supported
                                                                                                                                      	// attribute keys include the following: AWS_ALIAS_DNS_NAME If you want AWS Cloud
                                                                                                                                      	// Map to create an Amazon Route 53 alias record that routes traffic to an Elastic
                                                                                                                                      	// Load Balancing load balancer, specify the DNS name that is associated with the
                                                                                                                                      	// load balancer. For information about how to get the DNS name, see "DNSName" in
                                                                                                                                      	// the topic AliasTarget
                                                                                                                                      	// (https://docs.aws.amazon.com/Route53/latest/APIReference/API_AliasTarget.html)
                                                                                                                                      	// in the Route 53 API Reference. Note the following:
                                                                                                                                      	//
                                                                                                                                      	// * The configuration for the
                                                                                                                                      	// service that is specified by ServiceId must include settings for an A record, an
                                                                                                                                      	// AAAA record, or both.
                                                                                                                                      	//
                                                                                                                                      	// * In the service that is specified by ServiceId, the
                                                                                                                                      	// value of RoutingPolicy must be WEIGHTED.
                                                                                                                                      	//
                                                                                                                                      	// * If the service that is specified by
                                                                                                                                      	// ServiceId includes HealthCheckConfig settings, AWS Cloud Map will create the
                                                                                                                                      	// Route 53 health check, but it won't associate the health check with the alias
                                                                                                                                      	// record.
                                                                                                                                      	//
                                                                                                                                      	// * Auto naming currently doesn't support creating alias records that
                                                                                                                                      	// route traffic to AWS resources other than Elastic Load Balancing load
                                                                                                                                      	// balancers.
                                                                                                                                      	//
                                                                                                                                      	// * If you specify a value for AWS_ALIAS_DNS_NAME, don't specify
                                                                                                                                      	// values for any of the AWS_INSTANCE attributes.
                                                                                                                                      	//
                                                                                                                                      	// AWS_EC2_INSTANCE_ID HTTP
                                                                                                                                      	// namespaces only. The Amazon EC2 instance ID for the instance. If the
                                                                                                                                      	// AWS_EC2_INSTANCE_ID attribute is specified, then the only other attribute that
                                                                                                                                      	// can be specified is AWS_INIT_HEALTH_STATUS. When the AWS_EC2_INSTANCE_ID
                                                                                                                                      	// attribute is specified, then the AWS_INSTANCE_IPV4 attribute will be filled out
                                                                                                                                      	// with the primary private IPv4 address. AWS_INIT_HEALTH_STATUS If the service
                                                                                                                                      	// configuration includes HealthCheckCustomConfig, you can optionally use
                                                                                                                                      	// AWS_INIT_HEALTH_STATUS to specify the initial status of the custom health check,
                                                                                                                                      	// HEALTHY or UNHEALTHY. If you don't specify a value for AWS_INIT_HEALTH_STATUS,
                                                                                                                                      	// the initial status is HEALTHY. AWS_INSTANCE_CNAME If the service configuration
                                                                                                                                      	// includes a CNAME record, the domain name that you want Route 53 to return in
                                                                                                                                      	// response to DNS queries, for example, example.com. This value is required if the
                                                                                                                                      	// service specified by ServiceId includes settings for an CNAME record.
                                                                                                                                      	// AWS_INSTANCE_IPV4 If the service configuration includes an A record, the IPv4
                                                                                                                                      	// address that you want Route 53 to return in response to DNS queries, for
                                                                                                                                      	// example, 192.0.2.44. This value is required if the service specified by
                                                                                                                                      	// ServiceId includes settings for an A record. If the service includes settings
                                                                                                                                      	// for an SRV record, you must specify a value for AWS_INSTANCE_IPV4,
                                                                                                                                      	// AWS_INSTANCE_IPV6, or both. AWS_INSTANCE_IPV6 If the service configuration
                                                                                                                                      	// includes an AAAA record, the IPv6 address that you want Route 53 to return in
                                                                                                                                      	// response to DNS queries, for example, 2001:0db8:85a3:0000:0000:abcd:0001:2345.
                                                                                                                                      	// This value is required if the service specified by ServiceId includes settings
                                                                                                                                      	// for an AAAA record. If the service includes settings for an SRV record, you must
                                                                                                                                      	// specify a value for AWS_INSTANCE_IPV4, AWS_INSTANCE_IPV6, or both.
                                                                                                                                      	// AWS_INSTANCE_PORT If the service includes an SRV record, the value that you want
                                                                                                                                      	// Route 53 to return for the port. If the service includes HealthCheckConfig, the
                                                                                                                                      	// port on the endpoint that you want Route 53 to send requests to. This value is
                                                                                                                                      	// required if you specified settings for an SRV record or a Route 53 health check
                                                                                                                                      	// when you created the service. Custom attributes You can add up to 30 custom
                                                                                                                                      	// attributes. For each key-value pair, the maximum length of the attribute name is
                                                                                                                                      	// 255 characters, and the maximum length of the attribute value is 1,024
                                                                                                                                      	// characters. The total size of all provided attributes (sum of all keys and
                                                                                                                                      	// values) must not exceed 5,000 characters.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Attributes map[string]string
                                                                                                                                      
                                                                                                                                      	// An identifier that you want to associate with the instance. Note the
                                                                                                                                      	// following:
                                                                                                                                      	//
                                                                                                                                      	// * If the service that is specified by ServiceId includes settings
                                                                                                                                      	// for an SRV record, the value of InstanceId is automatically included as part of
                                                                                                                                      	// the value for the SRV record. For more information, see DnsRecord > Type
                                                                                                                                      	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_DnsRecord.html#cloudmap-Type-DnsRecord-Type).
                                                                                                                                      	//
                                                                                                                                      	// *
                                                                                                                                      	// You can use this value to update an existing instance.
                                                                                                                                      	//
                                                                                                                                      	// * To register a new
                                                                                                                                      	// instance, you must specify a value that is unique among instances that you
                                                                                                                                      	// register by using the same service.
                                                                                                                                      	//
                                                                                                                                      	// * If you specify an existing InstanceId and
                                                                                                                                      	// ServiceId, AWS Cloud Map updates the existing DNS records, if any. If there's
                                                                                                                                      	// also an existing health check, AWS Cloud Map deletes the old health check and
                                                                                                                                      	// creates a new one. The health check isn't deleted immediately, so it will still
                                                                                                                                      	// appear for a while if you submit a ListHealthChecks request, for example.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	InstanceId *string
                                                                                                                                      
                                                                                                                                      	// The ID of the service that you want to use for settings for the instance.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	ServiceId *string
                                                                                                                                      
                                                                                                                                      	// A unique string that identifies the request and that allows failed
                                                                                                                                      	// RegisterInstance requests to be retried without the risk of executing the
                                                                                                                                      	// operation twice. You must use a unique CreatorRequestId string every time you
                                                                                                                                      	// submit a RegisterInstance request if you're registering additional instances for
                                                                                                                                      	// the same namespace and service. CreatorRequestId can be any unique string, for
                                                                                                                                      	// example, a date/time stamp.
                                                                                                                                      	CreatorRequestId *string
                                                                                                                                      }

                                                                                                                                      type RegisterInstanceOutput

                                                                                                                                      type RegisterInstanceOutput struct {
                                                                                                                                      
                                                                                                                                      	// A value that you can use to determine whether the request completed
                                                                                                                                      	// successfully. To get the status of the operation, see GetOperation
                                                                                                                                      	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html).
                                                                                                                                      	OperationId *string
                                                                                                                                      
                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                      }

                                                                                                                                      type ResolveEndpoint

                                                                                                                                      type ResolveEndpoint struct {
                                                                                                                                      	Resolver EndpointResolver
                                                                                                                                      	Options  EndpointResolverOptions
                                                                                                                                      }

                                                                                                                                      func (*ResolveEndpoint) HandleSerialize

                                                                                                                                      func (*ResolveEndpoint) ID

                                                                                                                                      func (*ResolveEndpoint) ID() string

                                                                                                                                      type TagResourceInput

                                                                                                                                      type TagResourceInput struct {
                                                                                                                                      
                                                                                                                                      	// The Amazon Resource Name (ARN) of the resource that you want to retrieve tags
                                                                                                                                      	// for.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	ResourceARN *string
                                                                                                                                      
                                                                                                                                      	// The tags to add to the specified resource. Specifying the tag key is required.
                                                                                                                                      	// You can set the value of a tag to an empty string, but you can't set the value
                                                                                                                                      	// of a tag to null.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Tags []types.Tag
                                                                                                                                      }

                                                                                                                                      type TagResourceOutput

                                                                                                                                      type TagResourceOutput struct {
                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                      }

                                                                                                                                      type UntagResourceInput

                                                                                                                                      type UntagResourceInput struct {
                                                                                                                                      
                                                                                                                                      	// The Amazon Resource Name (ARN) of the resource that you want to retrieve tags
                                                                                                                                      	// for.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	ResourceARN *string
                                                                                                                                      
                                                                                                                                      	// The tag keys to remove from the specified resource.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	TagKeys []string
                                                                                                                                      }

                                                                                                                                      type UntagResourceOutput

                                                                                                                                      type UntagResourceOutput struct {
                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                      }

                                                                                                                                      type UpdateInstanceCustomHealthStatusInput

                                                                                                                                      type UpdateInstanceCustomHealthStatusInput struct {
                                                                                                                                      
                                                                                                                                      	// The ID of the instance that you want to change the health status for.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	InstanceId *string
                                                                                                                                      
                                                                                                                                      	// The ID of the service that includes the configuration for the custom health
                                                                                                                                      	// check that you want to change the status for.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	ServiceId *string
                                                                                                                                      
                                                                                                                                      	// The new status of the instance, HEALTHY or UNHEALTHY.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Status types.CustomHealthStatus
                                                                                                                                      }

                                                                                                                                      type UpdateInstanceCustomHealthStatusOutput

                                                                                                                                      type UpdateInstanceCustomHealthStatusOutput struct {
                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                      }

                                                                                                                                      type UpdateServiceInput

                                                                                                                                      type UpdateServiceInput struct {
                                                                                                                                      
                                                                                                                                      	// The ID of the service that you want to update.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Id *string
                                                                                                                                      
                                                                                                                                      	// A complex type that contains the new settings for the service.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Service *types.ServiceChange
                                                                                                                                      }

                                                                                                                                      type UpdateServiceOutput

                                                                                                                                      type UpdateServiceOutput struct {
                                                                                                                                      
                                                                                                                                      	// A value that you can use to determine whether the request completed
                                                                                                                                      	// successfully. To get the status of the operation, see GetOperation
                                                                                                                                      	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_GetOperation.html).
                                                                                                                                      	OperationId *string
                                                                                                                                      
                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                      }

                                                                                                                                      Directories

                                                                                                                                      Path Synopsis
                                                                                                                                      internal