// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. // Package ecs provides a client for Amazon EC2 Container Service. package ecs import ( "fmt" "time" "github.com/aws/aws-sdk-go/aws/awsutil" "github.com/aws/aws-sdk-go/aws/request" ) const opCreateCluster = "CreateCluster" // CreateClusterRequest generates a "aws/request.Request" representing the // client's request for the CreateCluster operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the CreateCluster method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the CreateClusterRequest method. // req, resp := client.CreateClusterRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) CreateClusterRequest(input *CreateClusterInput) (req *request.Request, output *CreateClusterOutput) { op := &request.Operation{ Name: opCreateCluster, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &CreateClusterInput{} } req = c.newRequest(op, input, output) output = &CreateClusterOutput{} req.Data = output return } // Creates a new Amazon ECS cluster. By default, your account receives a default // cluster when you launch your first container instance. However, you can create // your own cluster with a unique name with the CreateCluster action. func (c *ECS) CreateCluster(input *CreateClusterInput) (*CreateClusterOutput, error) { req, out := c.CreateClusterRequest(input) err := req.Send() return out, err } const opCreateService = "CreateService" // CreateServiceRequest generates a "aws/request.Request" representing the // client's request for the CreateService operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the CreateService method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the CreateServiceRequest method. // req, resp := client.CreateServiceRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) CreateServiceRequest(input *CreateServiceInput) (req *request.Request, output *CreateServiceOutput) { op := &request.Operation{ Name: opCreateService, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &CreateServiceInput{} } req = c.newRequest(op, input, output) output = &CreateServiceOutput{} req.Data = output return } // Runs and maintains a desired number of tasks from a specified task definition. // If the number of tasks running in a service drops below desiredCount, Amazon // ECS spawns another instantiation of the task in the specified cluster. To // update an existing service, see UpdateService. // // In addition to maintaining the desired count of tasks in your service, you // can optionally run your service behind a load balancer. The load balancer // distributes traffic across the tasks that are associated with the service. // // You can optionally specify a deployment configuration for your service. // During a deployment (which is triggered by changing the task definition of // a service with an UpdateService operation), the service scheduler uses the // minimumHealthyPercent and maximumPercent parameters to determine the deployment // strategy. // // If the minimumHealthyPercent is below 100%, the scheduler can ignore the // desiredCount temporarily during a deployment. For example, if your service // has a desiredCount of four tasks, a minimumHealthyPercent of 50% allows the // scheduler to stop two existing tasks before starting two new tasks. Tasks // for services that do not use a load balancer are considered healthy if they // are in the RUNNING state; tasks for services that do use a load balancer // are considered healthy if they are in the RUNNING state and the container // instance it is hosted on is reported as healthy by the load balancer. The // default value for minimumHealthyPercent is 50% in the console and 100% for // the AWS CLI, the AWS SDKs, and the APIs. // // The maximumPercent parameter represents an upper limit on the number of // running tasks during a deployment, which enables you to define the deployment // batch size. For example, if your service has a desiredCount of four tasks, // a maximumPercent value of 200% starts four new tasks before stopping the // four older tasks (provided that the cluster resources required to do this // are available). The default value for maximumPercent is 200%. // // When the service scheduler launches new tasks, it attempts to balance them // across the Availability Zones in your cluster with the following logic: // // Determine which of the container instances in your cluster can support // your service's task definition (for example, they have the required CPU, // memory, ports, and container instance attributes). // // Sort the valid container instances by the fewest number of running tasks // for this service in the same Availability Zone as the instance. For example, // if zone A has one running service task and zones B and C each have zero, // valid container instances in either zone B or C are considered optimal for // placement. // // Place the new service task on a valid container instance in an optimal // Availability Zone (based on the previous steps), favoring container instances // with the fewest number of running tasks for this service. func (c *ECS) CreateService(input *CreateServiceInput) (*CreateServiceOutput, error) { req, out := c.CreateServiceRequest(input) err := req.Send() return out, err } const opDeleteCluster = "DeleteCluster" // DeleteClusterRequest generates a "aws/request.Request" representing the // client's request for the DeleteCluster operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DeleteCluster method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DeleteClusterRequest method. // req, resp := client.DeleteClusterRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DeleteClusterRequest(input *DeleteClusterInput) (req *request.Request, output *DeleteClusterOutput) { op := &request.Operation{ Name: opDeleteCluster, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DeleteClusterInput{} } req = c.newRequest(op, input, output) output = &DeleteClusterOutput{} req.Data = output return } // Deletes the specified cluster. You must deregister all container instances // from this cluster before you may delete it. You can list the container instances // in a cluster with ListContainerInstances and deregister them with DeregisterContainerInstance. func (c *ECS) DeleteCluster(input *DeleteClusterInput) (*DeleteClusterOutput, error) { req, out := c.DeleteClusterRequest(input) err := req.Send() return out, err } const opDeleteService = "DeleteService" // DeleteServiceRequest generates a "aws/request.Request" representing the // client's request for the DeleteService operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DeleteService method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DeleteServiceRequest method. // req, resp := client.DeleteServiceRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DeleteServiceRequest(input *DeleteServiceInput) (req *request.Request, output *DeleteServiceOutput) { op := &request.Operation{ Name: opDeleteService, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DeleteServiceInput{} } req = c.newRequest(op, input, output) output = &DeleteServiceOutput{} req.Data = output return } // Deletes a specified service within a cluster. You can delete a service if // you have no running tasks in it and the desired task count is zero. If the // service is actively maintaining tasks, you cannot delete it, and you must // update the service to a desired task count of zero. For more information, // see UpdateService. // // When you delete a service, if there are still running tasks that require // cleanup, the service status moves from ACTIVE to DRAINING, and the service // is no longer visible in the console or in ListServices API operations. After // the tasks have stopped, then the service status moves from DRAINING to INACTIVE. // Services in the DRAINING or INACTIVE status can still be viewed with DescribeServices // API operations; however, in the future, INACTIVE services may be cleaned // up and purged from Amazon ECS record keeping, and DescribeServices API operations // on those services will return a ServiceNotFoundException error. func (c *ECS) DeleteService(input *DeleteServiceInput) (*DeleteServiceOutput, error) { req, out := c.DeleteServiceRequest(input) err := req.Send() return out, err } const opDeregisterContainerInstance = "DeregisterContainerInstance" // DeregisterContainerInstanceRequest generates a "aws/request.Request" representing the // client's request for the DeregisterContainerInstance operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DeregisterContainerInstance method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DeregisterContainerInstanceRequest method. // req, resp := client.DeregisterContainerInstanceRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DeregisterContainerInstanceRequest(input *DeregisterContainerInstanceInput) (req *request.Request, output *DeregisterContainerInstanceOutput) { op := &request.Operation{ Name: opDeregisterContainerInstance, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DeregisterContainerInstanceInput{} } req = c.newRequest(op, input, output) output = &DeregisterContainerInstanceOutput{} req.Data = output return } // Deregisters an Amazon ECS container instance from the specified cluster. // This instance is no longer available to run tasks. // // If you intend to use the container instance for some other purpose after // deregistration, you should stop all of the tasks running on the container // instance before deregistration to avoid any orphaned tasks from consuming // resources. // // Deregistering a container instance removes the instance from a cluster, // but it does not terminate the EC2 instance; if you are finished using the // instance, be sure to terminate it in the Amazon EC2 console to stop billing. // // If you terminate a running container instance with a connected Amazon ECS // container agent, the agent automatically deregisters the instance from your // cluster (stopped container instances or instances with disconnected agents // are not automatically deregistered when terminated). func (c *ECS) DeregisterContainerInstance(input *DeregisterContainerInstanceInput) (*DeregisterContainerInstanceOutput, error) { req, out := c.DeregisterContainerInstanceRequest(input) err := req.Send() return out, err } const opDeregisterTaskDefinition = "DeregisterTaskDefinition" // DeregisterTaskDefinitionRequest generates a "aws/request.Request" representing the // client's request for the DeregisterTaskDefinition operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DeregisterTaskDefinition method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DeregisterTaskDefinitionRequest method. // req, resp := client.DeregisterTaskDefinitionRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DeregisterTaskDefinitionRequest(input *DeregisterTaskDefinitionInput) (req *request.Request, output *DeregisterTaskDefinitionOutput) { op := &request.Operation{ Name: opDeregisterTaskDefinition, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DeregisterTaskDefinitionInput{} } req = c.newRequest(op, input, output) output = &DeregisterTaskDefinitionOutput{} req.Data = output return } // Deregisters the specified task definition by family and revision. Upon deregistration, // the task definition is marked as INACTIVE. Existing tasks and services that // reference an INACTIVE task definition continue to run without disruption. // Existing services that reference an INACTIVE task definition can still scale // up or down by modifying the service's desired count. // // You cannot use an INACTIVE task definition to run new tasks or create new // services, and you cannot update an existing service to reference an INACTIVE // task definition (although there may be up to a 10 minute window following // deregistration where these restrictions have not yet taken effect). func (c *ECS) DeregisterTaskDefinition(input *DeregisterTaskDefinitionInput) (*DeregisterTaskDefinitionOutput, error) { req, out := c.DeregisterTaskDefinitionRequest(input) err := req.Send() return out, err } const opDescribeClusters = "DescribeClusters" // DescribeClustersRequest generates a "aws/request.Request" representing the // client's request for the DescribeClusters operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DescribeClusters method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DescribeClustersRequest method. // req, resp := client.DescribeClustersRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DescribeClustersRequest(input *DescribeClustersInput) (req *request.Request, output *DescribeClustersOutput) { op := &request.Operation{ Name: opDescribeClusters, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DescribeClustersInput{} } req = c.newRequest(op, input, output) output = &DescribeClustersOutput{} req.Data = output return } // Describes one or more of your clusters. func (c *ECS) DescribeClusters(input *DescribeClustersInput) (*DescribeClustersOutput, error) { req, out := c.DescribeClustersRequest(input) err := req.Send() return out, err } const opDescribeContainerInstances = "DescribeContainerInstances" // DescribeContainerInstancesRequest generates a "aws/request.Request" representing the // client's request for the DescribeContainerInstances operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DescribeContainerInstances method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DescribeContainerInstancesRequest method. // req, resp := client.DescribeContainerInstancesRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DescribeContainerInstancesRequest(input *DescribeContainerInstancesInput) (req *request.Request, output *DescribeContainerInstancesOutput) { op := &request.Operation{ Name: opDescribeContainerInstances, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DescribeContainerInstancesInput{} } req = c.newRequest(op, input, output) output = &DescribeContainerInstancesOutput{} req.Data = output return } // Describes Amazon EC2 Container Service container instances. Returns metadata // about registered and remaining resources on each container instance requested. func (c *ECS) DescribeContainerInstances(input *DescribeContainerInstancesInput) (*DescribeContainerInstancesOutput, error) { req, out := c.DescribeContainerInstancesRequest(input) err := req.Send() return out, err } const opDescribeServices = "DescribeServices" // DescribeServicesRequest generates a "aws/request.Request" representing the // client's request for the DescribeServices operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DescribeServices method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DescribeServicesRequest method. // req, resp := client.DescribeServicesRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DescribeServicesRequest(input *DescribeServicesInput) (req *request.Request, output *DescribeServicesOutput) { op := &request.Operation{ Name: opDescribeServices, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DescribeServicesInput{} } req = c.newRequest(op, input, output) output = &DescribeServicesOutput{} req.Data = output return } // Describes the specified services running in your cluster. func (c *ECS) DescribeServices(input *DescribeServicesInput) (*DescribeServicesOutput, error) { req, out := c.DescribeServicesRequest(input) err := req.Send() return out, err } const opDescribeTaskDefinition = "DescribeTaskDefinition" // DescribeTaskDefinitionRequest generates a "aws/request.Request" representing the // client's request for the DescribeTaskDefinition operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DescribeTaskDefinition method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DescribeTaskDefinitionRequest method. // req, resp := client.DescribeTaskDefinitionRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DescribeTaskDefinitionRequest(input *DescribeTaskDefinitionInput) (req *request.Request, output *DescribeTaskDefinitionOutput) { op := &request.Operation{ Name: opDescribeTaskDefinition, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DescribeTaskDefinitionInput{} } req = c.newRequest(op, input, output) output = &DescribeTaskDefinitionOutput{} req.Data = output return } // Describes a task definition. You can specify a family and revision to find // information about a specific task definition, or you can simply specify the // family to find the latest ACTIVE revision in that family. // // You can only describe INACTIVE task definitions while an active task or // service references them. func (c *ECS) DescribeTaskDefinition(input *DescribeTaskDefinitionInput) (*DescribeTaskDefinitionOutput, error) { req, out := c.DescribeTaskDefinitionRequest(input) err := req.Send() return out, err } const opDescribeTasks = "DescribeTasks" // DescribeTasksRequest generates a "aws/request.Request" representing the // client's request for the DescribeTasks operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DescribeTasks method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DescribeTasksRequest method. // req, resp := client.DescribeTasksRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DescribeTasksRequest(input *DescribeTasksInput) (req *request.Request, output *DescribeTasksOutput) { op := &request.Operation{ Name: opDescribeTasks, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DescribeTasksInput{} } req = c.newRequest(op, input, output) output = &DescribeTasksOutput{} req.Data = output return } // Describes a specified task or tasks. func (c *ECS) DescribeTasks(input *DescribeTasksInput) (*DescribeTasksOutput, error) { req, out := c.DescribeTasksRequest(input) err := req.Send() return out, err } const opDiscoverPollEndpoint = "DiscoverPollEndpoint" // DiscoverPollEndpointRequest generates a "aws/request.Request" representing the // client's request for the DiscoverPollEndpoint operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the DiscoverPollEndpoint method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the DiscoverPollEndpointRequest method. // req, resp := client.DiscoverPollEndpointRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) DiscoverPollEndpointRequest(input *DiscoverPollEndpointInput) (req *request.Request, output *DiscoverPollEndpointOutput) { op := &request.Operation{ Name: opDiscoverPollEndpoint, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &DiscoverPollEndpointInput{} } req = c.newRequest(op, input, output) output = &DiscoverPollEndpointOutput{} req.Data = output return } // This action is only used by the Amazon EC2 Container Service agent, and it // is not intended for use outside of the agent. // // Returns an endpoint for the Amazon EC2 Container Service agent to poll // for updates. func (c *ECS) DiscoverPollEndpoint(input *DiscoverPollEndpointInput) (*DiscoverPollEndpointOutput, error) { req, out := c.DiscoverPollEndpointRequest(input) err := req.Send() return out, err } const opListClusters = "ListClusters" // ListClustersRequest generates a "aws/request.Request" representing the // client's request for the ListClusters operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the ListClusters method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the ListClustersRequest method. // req, resp := client.ListClustersRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) ListClustersRequest(input *ListClustersInput) (req *request.Request, output *ListClustersOutput) { op := &request.Operation{ Name: opListClusters, HTTPMethod: "POST", HTTPPath: "/", Paginator: &request.Paginator{ InputTokens: []string{"nextToken"}, OutputTokens: []string{"nextToken"}, LimitToken: "maxResults", TruncationToken: "", }, } if input == nil { input = &ListClustersInput{} } req = c.newRequest(op, input, output) output = &ListClustersOutput{} req.Data = output return } // Returns a list of existing clusters. func (c *ECS) ListClusters(input *ListClustersInput) (*ListClustersOutput, error) { req, out := c.ListClustersRequest(input) err := req.Send() return out, err } // ListClustersPages iterates over the pages of a ListClusters operation, // calling the "fn" function with the response data for each page. To stop // iterating, return false from the fn function. // // See ListClusters method for more information on how to use this operation. // // Note: This operation can generate multiple requests to a service. // // // Example iterating over at most 3 pages of a ListClusters operation. // pageNum := 0 // err := client.ListClustersPages(params, // func(page *ListClustersOutput, lastPage bool) bool { // pageNum++ // fmt.Println(page) // return pageNum <= 3 // }) // func (c *ECS) ListClustersPages(input *ListClustersInput, fn func(p *ListClustersOutput, lastPage bool) (shouldContinue bool)) error { page, _ := c.ListClustersRequest(input) page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator")) return page.EachPage(func(p interface{}, lastPage bool) bool { return fn(p.(*ListClustersOutput), lastPage) }) } const opListContainerInstances = "ListContainerInstances" // ListContainerInstancesRequest generates a "aws/request.Request" representing the // client's request for the ListContainerInstances operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the ListContainerInstances method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the ListContainerInstancesRequest method. // req, resp := client.ListContainerInstancesRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) ListContainerInstancesRequest(input *ListContainerInstancesInput) (req *request.Request, output *ListContainerInstancesOutput) { op := &request.Operation{ Name: opListContainerInstances, HTTPMethod: "POST", HTTPPath: "/", Paginator: &request.Paginator{ InputTokens: []string{"nextToken"}, OutputTokens: []string{"nextToken"}, LimitToken: "maxResults", TruncationToken: "", }, } if input == nil { input = &ListContainerInstancesInput{} } req = c.newRequest(op, input, output) output = &ListContainerInstancesOutput{} req.Data = output return } // Returns a list of container instances in a specified cluster. func (c *ECS) ListContainerInstances(input *ListContainerInstancesInput) (*ListContainerInstancesOutput, error) { req, out := c.ListContainerInstancesRequest(input) err := req.Send() return out, err } // ListContainerInstancesPages iterates over the pages of a ListContainerInstances operation, // calling the "fn" function with the response data for each page. To stop // iterating, return false from the fn function. // // See ListContainerInstances method for more information on how to use this operation. // // Note: This operation can generate multiple requests to a service. // // // Example iterating over at most 3 pages of a ListContainerInstances operation. // pageNum := 0 // err := client.ListContainerInstancesPages(params, // func(page *ListContainerInstancesOutput, lastPage bool) bool { // pageNum++ // fmt.Println(page) // return pageNum <= 3 // }) // func (c *ECS) ListContainerInstancesPages(input *ListContainerInstancesInput, fn func(p *ListContainerInstancesOutput, lastPage bool) (shouldContinue bool)) error { page, _ := c.ListContainerInstancesRequest(input) page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator")) return page.EachPage(func(p interface{}, lastPage bool) bool { return fn(p.(*ListContainerInstancesOutput), lastPage) }) } const opListServices = "ListServices" // ListServicesRequest generates a "aws/request.Request" representing the // client's request for the ListServices operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the ListServices method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the ListServicesRequest method. // req, resp := client.ListServicesRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) ListServicesRequest(input *ListServicesInput) (req *request.Request, output *ListServicesOutput) { op := &request.Operation{ Name: opListServices, HTTPMethod: "POST", HTTPPath: "/", Paginator: &request.Paginator{ InputTokens: []string{"nextToken"}, OutputTokens: []string{"nextToken"}, LimitToken: "maxResults", TruncationToken: "", }, } if input == nil { input = &ListServicesInput{} } req = c.newRequest(op, input, output) output = &ListServicesOutput{} req.Data = output return } // Lists the services that are running in a specified cluster. func (c *ECS) ListServices(input *ListServicesInput) (*ListServicesOutput, error) { req, out := c.ListServicesRequest(input) err := req.Send() return out, err } // ListServicesPages iterates over the pages of a ListServices operation, // calling the "fn" function with the response data for each page. To stop // iterating, return false from the fn function. // // See ListServices method for more information on how to use this operation. // // Note: This operation can generate multiple requests to a service. // // // Example iterating over at most 3 pages of a ListServices operation. // pageNum := 0 // err := client.ListServicesPages(params, // func(page *ListServicesOutput, lastPage bool) bool { // pageNum++ // fmt.Println(page) // return pageNum <= 3 // }) // func (c *ECS) ListServicesPages(input *ListServicesInput, fn func(p *ListServicesOutput, lastPage bool) (shouldContinue bool)) error { page, _ := c.ListServicesRequest(input) page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator")) return page.EachPage(func(p interface{}, lastPage bool) bool { return fn(p.(*ListServicesOutput), lastPage) }) } const opListTaskDefinitionFamilies = "ListTaskDefinitionFamilies" // ListTaskDefinitionFamiliesRequest generates a "aws/request.Request" representing the // client's request for the ListTaskDefinitionFamilies operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the ListTaskDefinitionFamilies method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the ListTaskDefinitionFamiliesRequest method. // req, resp := client.ListTaskDefinitionFamiliesRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) ListTaskDefinitionFamiliesRequest(input *ListTaskDefinitionFamiliesInput) (req *request.Request, output *ListTaskDefinitionFamiliesOutput) { op := &request.Operation{ Name: opListTaskDefinitionFamilies, HTTPMethod: "POST", HTTPPath: "/", Paginator: &request.Paginator{ InputTokens: []string{"nextToken"}, OutputTokens: []string{"nextToken"}, LimitToken: "maxResults", TruncationToken: "", }, } if input == nil { input = &ListTaskDefinitionFamiliesInput{} } req = c.newRequest(op, input, output) output = &ListTaskDefinitionFamiliesOutput{} req.Data = output return } // Returns a list of task definition families that are registered to your account // (which may include task definition families that no longer have any ACTIVE // task definition revisions). // // You can filter out task definition families that do not contain any ACTIVE // task definition revisions by setting the status parameter to ACTIVE. You // can also filter the results with the familyPrefix parameter. func (c *ECS) ListTaskDefinitionFamilies(input *ListTaskDefinitionFamiliesInput) (*ListTaskDefinitionFamiliesOutput, error) { req, out := c.ListTaskDefinitionFamiliesRequest(input) err := req.Send() return out, err } // ListTaskDefinitionFamiliesPages iterates over the pages of a ListTaskDefinitionFamilies operation, // calling the "fn" function with the response data for each page. To stop // iterating, return false from the fn function. // // See ListTaskDefinitionFamilies method for more information on how to use this operation. // // Note: This operation can generate multiple requests to a service. // // // Example iterating over at most 3 pages of a ListTaskDefinitionFamilies operation. // pageNum := 0 // err := client.ListTaskDefinitionFamiliesPages(params, // func(page *ListTaskDefinitionFamiliesOutput, lastPage bool) bool { // pageNum++ // fmt.Println(page) // return pageNum <= 3 // }) // func (c *ECS) ListTaskDefinitionFamiliesPages(input *ListTaskDefinitionFamiliesInput, fn func(p *ListTaskDefinitionFamiliesOutput, lastPage bool) (shouldContinue bool)) error { page, _ := c.ListTaskDefinitionFamiliesRequest(input) page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator")) return page.EachPage(func(p interface{}, lastPage bool) bool { return fn(p.(*ListTaskDefinitionFamiliesOutput), lastPage) }) } const opListTaskDefinitions = "ListTaskDefinitions" // ListTaskDefinitionsRequest generates a "aws/request.Request" representing the // client's request for the ListTaskDefinitions operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the ListTaskDefinitions method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the ListTaskDefinitionsRequest method. // req, resp := client.ListTaskDefinitionsRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) ListTaskDefinitionsRequest(input *ListTaskDefinitionsInput) (req *request.Request, output *ListTaskDefinitionsOutput) { op := &request.Operation{ Name: opListTaskDefinitions, HTTPMethod: "POST", HTTPPath: "/", Paginator: &request.Paginator{ InputTokens: []string{"nextToken"}, OutputTokens: []string{"nextToken"}, LimitToken: "maxResults", TruncationToken: "", }, } if input == nil { input = &ListTaskDefinitionsInput{} } req = c.newRequest(op, input, output) output = &ListTaskDefinitionsOutput{} req.Data = output return } // Returns a list of task definitions that are registered to your account. You // can filter the results by family name with the familyPrefix parameter or // by status with the status parameter. func (c *ECS) ListTaskDefinitions(input *ListTaskDefinitionsInput) (*ListTaskDefinitionsOutput, error) { req, out := c.ListTaskDefinitionsRequest(input) err := req.Send() return out, err } // ListTaskDefinitionsPages iterates over the pages of a ListTaskDefinitions operation, // calling the "fn" function with the response data for each page. To stop // iterating, return false from the fn function. // // See ListTaskDefinitions method for more information on how to use this operation. // // Note: This operation can generate multiple requests to a service. // // // Example iterating over at most 3 pages of a ListTaskDefinitions operation. // pageNum := 0 // err := client.ListTaskDefinitionsPages(params, // func(page *ListTaskDefinitionsOutput, lastPage bool) bool { // pageNum++ // fmt.Println(page) // return pageNum <= 3 // }) // func (c *ECS) ListTaskDefinitionsPages(input *ListTaskDefinitionsInput, fn func(p *ListTaskDefinitionsOutput, lastPage bool) (shouldContinue bool)) error { page, _ := c.ListTaskDefinitionsRequest(input) page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator")) return page.EachPage(func(p interface{}, lastPage bool) bool { return fn(p.(*ListTaskDefinitionsOutput), lastPage) }) } const opListTasks = "ListTasks" // ListTasksRequest generates a "aws/request.Request" representing the // client's request for the ListTasks operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the ListTasks method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the ListTasksRequest method. // req, resp := client.ListTasksRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) ListTasksRequest(input *ListTasksInput) (req *request.Request, output *ListTasksOutput) { op := &request.Operation{ Name: opListTasks, HTTPMethod: "POST", HTTPPath: "/", Paginator: &request.Paginator{ InputTokens: []string{"nextToken"}, OutputTokens: []string{"nextToken"}, LimitToken: "maxResults", TruncationToken: "", }, } if input == nil { input = &ListTasksInput{} } req = c.newRequest(op, input, output) output = &ListTasksOutput{} req.Data = output return } // Returns a list of tasks for a specified cluster. You can filter the results // by family name, by a particular container instance, or by the desired status // of the task with the family, containerInstance, and desiredStatus parameters. // // Recently-stopped tasks might appear in the returned results. Currently, // stopped tasks appear in the returned results for at least one hour. func (c *ECS) ListTasks(input *ListTasksInput) (*ListTasksOutput, error) { req, out := c.ListTasksRequest(input) err := req.Send() return out, err } // ListTasksPages iterates over the pages of a ListTasks operation, // calling the "fn" function with the response data for each page. To stop // iterating, return false from the fn function. // // See ListTasks method for more information on how to use this operation. // // Note: This operation can generate multiple requests to a service. // // // Example iterating over at most 3 pages of a ListTasks operation. // pageNum := 0 // err := client.ListTasksPages(params, // func(page *ListTasksOutput, lastPage bool) bool { // pageNum++ // fmt.Println(page) // return pageNum <= 3 // }) // func (c *ECS) ListTasksPages(input *ListTasksInput, fn func(p *ListTasksOutput, lastPage bool) (shouldContinue bool)) error { page, _ := c.ListTasksRequest(input) page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator")) return page.EachPage(func(p interface{}, lastPage bool) bool { return fn(p.(*ListTasksOutput), lastPage) }) } const opRegisterContainerInstance = "RegisterContainerInstance" // RegisterContainerInstanceRequest generates a "aws/request.Request" representing the // client's request for the RegisterContainerInstance operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the RegisterContainerInstance method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the RegisterContainerInstanceRequest method. // req, resp := client.RegisterContainerInstanceRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) RegisterContainerInstanceRequest(input *RegisterContainerInstanceInput) (req *request.Request, output *RegisterContainerInstanceOutput) { op := &request.Operation{ Name: opRegisterContainerInstance, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &RegisterContainerInstanceInput{} } req = c.newRequest(op, input, output) output = &RegisterContainerInstanceOutput{} req.Data = output return } // This action is only used by the Amazon EC2 Container Service agent, and it // is not intended for use outside of the agent. // // Registers an EC2 instance into the specified cluster. This instance becomes // available to place containers on. func (c *ECS) RegisterContainerInstance(input *RegisterContainerInstanceInput) (*RegisterContainerInstanceOutput, error) { req, out := c.RegisterContainerInstanceRequest(input) err := req.Send() return out, err } const opRegisterTaskDefinition = "RegisterTaskDefinition" // RegisterTaskDefinitionRequest generates a "aws/request.Request" representing the // client's request for the RegisterTaskDefinition operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the RegisterTaskDefinition method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the RegisterTaskDefinitionRequest method. // req, resp := client.RegisterTaskDefinitionRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) RegisterTaskDefinitionRequest(input *RegisterTaskDefinitionInput) (req *request.Request, output *RegisterTaskDefinitionOutput) { op := &request.Operation{ Name: opRegisterTaskDefinition, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &RegisterTaskDefinitionInput{} } req = c.newRequest(op, input, output) output = &RegisterTaskDefinitionOutput{} req.Data = output return } // Registers a new task definition from the supplied family and containerDefinitions. // Optionally, you can add data volumes to your containers with the volumes // parameter. For more information about task definition parameters and defaults, // see Amazon ECS Task Definitions (http://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html) // in the Amazon EC2 Container Service Developer Guide. // // You may also specify an IAM role for your task with the taskRoleArn parameter. // When you specify an IAM role for a task, its containers can then use the // latest versions of the AWS CLI or SDKs to make API requests to the AWS services // that are specified in the IAM policy associated with the role. For more information, // see IAM Roles for Tasks (http://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) // in the Amazon EC2 Container Service Developer Guide. func (c *ECS) RegisterTaskDefinition(input *RegisterTaskDefinitionInput) (*RegisterTaskDefinitionOutput, error) { req, out := c.RegisterTaskDefinitionRequest(input) err := req.Send() return out, err } const opRunTask = "RunTask" // RunTaskRequest generates a "aws/request.Request" representing the // client's request for the RunTask operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the RunTask method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the RunTaskRequest method. // req, resp := client.RunTaskRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) RunTaskRequest(input *RunTaskInput) (req *request.Request, output *RunTaskOutput) { op := &request.Operation{ Name: opRunTask, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &RunTaskInput{} } req = c.newRequest(op, input, output) output = &RunTaskOutput{} req.Data = output return } // Start a task using random placement and the default Amazon ECS scheduler. // To use your own scheduler or place a task on a specific container instance, // use StartTask instead. // // The count parameter is limited to 10 tasks per call. func (c *ECS) RunTask(input *RunTaskInput) (*RunTaskOutput, error) { req, out := c.RunTaskRequest(input) err := req.Send() return out, err } const opStartTask = "StartTask" // StartTaskRequest generates a "aws/request.Request" representing the // client's request for the StartTask operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the StartTask method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the StartTaskRequest method. // req, resp := client.StartTaskRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) StartTaskRequest(input *StartTaskInput) (req *request.Request, output *StartTaskOutput) { op := &request.Operation{ Name: opStartTask, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &StartTaskInput{} } req = c.newRequest(op, input, output) output = &StartTaskOutput{} req.Data = output return } // Starts a new task from the specified task definition on the specified container // instance or instances. To use the default Amazon ECS scheduler to place your // task, use RunTask instead. // // The list of container instances to start tasks on is limited to 10. func (c *ECS) StartTask(input *StartTaskInput) (*StartTaskOutput, error) { req, out := c.StartTaskRequest(input) err := req.Send() return out, err } const opStopTask = "StopTask" // StopTaskRequest generates a "aws/request.Request" representing the // client's request for the StopTask operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the StopTask method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the StopTaskRequest method. // req, resp := client.StopTaskRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) StopTaskRequest(input *StopTaskInput) (req *request.Request, output *StopTaskOutput) { op := &request.Operation{ Name: opStopTask, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &StopTaskInput{} } req = c.newRequest(op, input, output) output = &StopTaskOutput{} req.Data = output return } // Stops a running task. // // When StopTask is called on a task, the equivalent of docker stop is issued // to the containers running in the task. This results in a SIGTERM and a 30-second // timeout, after which SIGKILL is sent and the containers are forcibly stopped. // If the container handles the SIGTERM gracefully and exits within 30 seconds // from receiving it, no SIGKILL is sent. func (c *ECS) StopTask(input *StopTaskInput) (*StopTaskOutput, error) { req, out := c.StopTaskRequest(input) err := req.Send() return out, err } const opSubmitContainerStateChange = "SubmitContainerStateChange" // SubmitContainerStateChangeRequest generates a "aws/request.Request" representing the // client's request for the SubmitContainerStateChange operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the SubmitContainerStateChange method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the SubmitContainerStateChangeRequest method. // req, resp := client.SubmitContainerStateChangeRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) SubmitContainerStateChangeRequest(input *SubmitContainerStateChangeInput) (req *request.Request, output *SubmitContainerStateChangeOutput) { op := &request.Operation{ Name: opSubmitContainerStateChange, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &SubmitContainerStateChangeInput{} } req = c.newRequest(op, input, output) output = &SubmitContainerStateChangeOutput{} req.Data = output return } // This action is only used by the Amazon EC2 Container Service agent, and it // is not intended for use outside of the agent. // // Sent to acknowledge that a container changed states. func (c *ECS) SubmitContainerStateChange(input *SubmitContainerStateChangeInput) (*SubmitContainerStateChangeOutput, error) { req, out := c.SubmitContainerStateChangeRequest(input) err := req.Send() return out, err } const opSubmitTaskStateChange = "SubmitTaskStateChange" // SubmitTaskStateChangeRequest generates a "aws/request.Request" representing the // client's request for the SubmitTaskStateChange operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the SubmitTaskStateChange method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the SubmitTaskStateChangeRequest method. // req, resp := client.SubmitTaskStateChangeRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) SubmitTaskStateChangeRequest(input *SubmitTaskStateChangeInput) (req *request.Request, output *SubmitTaskStateChangeOutput) { op := &request.Operation{ Name: opSubmitTaskStateChange, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &SubmitTaskStateChangeInput{} } req = c.newRequest(op, input, output) output = &SubmitTaskStateChangeOutput{} req.Data = output return } // This action is only used by the Amazon EC2 Container Service agent, and it // is not intended for use outside of the agent. // // Sent to acknowledge that a task changed states. func (c *ECS) SubmitTaskStateChange(input *SubmitTaskStateChangeInput) (*SubmitTaskStateChangeOutput, error) { req, out := c.SubmitTaskStateChangeRequest(input) err := req.Send() return out, err } const opUpdateContainerAgent = "UpdateContainerAgent" // UpdateContainerAgentRequest generates a "aws/request.Request" representing the // client's request for the UpdateContainerAgent operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the UpdateContainerAgent method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the UpdateContainerAgentRequest method. // req, resp := client.UpdateContainerAgentRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) UpdateContainerAgentRequest(input *UpdateContainerAgentInput) (req *request.Request, output *UpdateContainerAgentOutput) { op := &request.Operation{ Name: opUpdateContainerAgent, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &UpdateContainerAgentInput{} } req = c.newRequest(op, input, output) output = &UpdateContainerAgentOutput{} req.Data = output return } // Updates the Amazon ECS container agent on a specified container instance. // Updating the Amazon ECS container agent does not interrupt running tasks // or services on the container instance. The process for updating the agent // differs depending on whether your container instance was launched with the // Amazon ECS-optimized AMI or another operating system. // // UpdateContainerAgent requires the Amazon ECS-optimized AMI or Amazon Linux // with the ecs-init service installed and running. For help updating the Amazon // ECS container agent on other operating systems, see Manually Updating the // Amazon ECS Container Agent (http://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html#manually_update_agent) // in the Amazon EC2 Container Service Developer Guide. func (c *ECS) UpdateContainerAgent(input *UpdateContainerAgentInput) (*UpdateContainerAgentOutput, error) { req, out := c.UpdateContainerAgentRequest(input) err := req.Send() return out, err } const opUpdateService = "UpdateService" // UpdateServiceRequest generates a "aws/request.Request" representing the // client's request for the UpdateService operation. The "output" return // value can be used to capture response data after the request's "Send" method // is called. // // Creating a request object using this method should be used when you want to inject // custom logic into the request's lifecycle using a custom handler, or if you want to // access properties on the request object before or after sending the request. If // you just want the service response, call the UpdateService method directly // instead. // // Note: You must call the "Send" method on the returned request object in order // to execute the request. // // // Example sending a request using the UpdateServiceRequest method. // req, resp := client.UpdateServiceRequest(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } // func (c *ECS) UpdateServiceRequest(input *UpdateServiceInput) (req *request.Request, output *UpdateServiceOutput) { op := &request.Operation{ Name: opUpdateService, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &UpdateServiceInput{} } req = c.newRequest(op, input, output) output = &UpdateServiceOutput{} req.Data = output return } // Modifies the desired count, deployment configuration, or task definition // used in a service. // // You can add to or subtract from the number of instantiations of a task definition // in a service by specifying the cluster that the service is running in and // a new desiredCount parameter. // // You can use UpdateService to modify your task definition and deploy a new // version of your service. // // You can also update the deployment configuration of a service. When a deployment // is triggered by updating the task definition of a service, the service scheduler // uses the deployment configuration parameters, minimumHealthyPercent and maximumPercent, // to determine the deployment strategy. // // If the minimumHealthyPercent is below 100%, the scheduler can ignore the // desiredCount temporarily during a deployment. For example, if your service // has a desiredCount of four tasks, a minimumHealthyPercent of 50% allows the // scheduler to stop two existing tasks before starting two new tasks. Tasks // for services that do not use a load balancer are considered healthy if they // are in the RUNNING state; tasks for services that do use a load balancer // are considered healthy if they are in the RUNNING state and the container // instance it is hosted on is reported as healthy by the load balancer. // // The maximumPercent parameter represents an upper limit on the number of // running tasks during a deployment, which enables you to define the deployment // batch size. For example, if your service has a desiredCount of four tasks, // a maximumPercent value of 200% starts four new tasks before stopping the // four older tasks (provided that the cluster resources required to do this // are available). // // When UpdateService stops a task during a deployment, the equivalent of docker // stop is issued to the containers running in the task. This results in a SIGTERM // and a 30-second timeout, after which SIGKILL is sent and the containers are // forcibly stopped. If the container handles the SIGTERM gracefully and exits // within 30 seconds from receiving it, no SIGKILL is sent. // // When the service scheduler launches new tasks, it attempts to balance them // across the Availability Zones in your cluster with the following logic: // // Determine which of the container instances in your cluster can support // your service's task definition (for example, they have the required CPU, // memory, ports, and container instance attributes). // // Sort the valid container instances by the fewest number of running tasks // for this service in the same Availability Zone as the instance. For example, // if zone A has one running service task and zones B and C each have zero, // valid container instances in either zone B or C are considered optimal for // placement. // // Place the new service task on a valid container instance in an optimal // Availability Zone (based on the previous steps), favoring container instances // with the fewest number of running tasks for this service. func (c *ECS) UpdateService(input *UpdateServiceInput) (*UpdateServiceOutput, error) { req, out := c.UpdateServiceRequest(input) err := req.Send() return out, err } // The attributes applicable to a container instance when it is registered. type Attribute struct { _ struct{} `type:"structure"` // The name of the container instance attribute. Name *string `locationName:"name" type:"string" required:"true"` // The value of the container instance attribute (at this time, the value here // is Null, but this could change in future revisions for expandability). Value *string `locationName:"value" type:"string"` } // String returns the string representation func (s Attribute) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Attribute) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *Attribute) Validate() error { invalidParams := request.ErrInvalidParams{Context: "Attribute"} if s.Name == nil { invalidParams.Add(request.NewErrParamRequired("Name")) } if invalidParams.Len() > 0 { return invalidParams } return nil } // A regional grouping of one or more container instances on which you can run // task requests. Each account receives a default cluster the first time you // use the Amazon ECS service, but you may also create other clusters. Clusters // may contain more than one instance type simultaneously. type Cluster struct { _ struct{} `type:"structure"` // The number of services that are running on the cluster in an ACTIVE state. // You can view these services with ListServices. ActiveServicesCount *int64 `locationName:"activeServicesCount" type:"integer"` // The Amazon Resource Name (ARN) that identifies the cluster. The ARN contains // the arn:aws:ecs namespace, followed by the region of the cluster, the AWS // account ID of the cluster owner, the cluster namespace, and then the cluster // name. For example, arn:aws:ecs:region:012345678910:cluster/test .. ClusterArn *string `locationName:"clusterArn" type:"string"` // A user-generated string that you use to identify your cluster. ClusterName *string `locationName:"clusterName" type:"string"` // The number of tasks in the cluster that are in the PENDING state. PendingTasksCount *int64 `locationName:"pendingTasksCount" type:"integer"` // The number of container instances registered into the cluster. RegisteredContainerInstancesCount *int64 `locationName:"registeredContainerInstancesCount" type:"integer"` // The number of tasks in the cluster that are in the RUNNING state. RunningTasksCount *int64 `locationName:"runningTasksCount" type:"integer"` // The status of the cluster. The valid values are ACTIVE or INACTIVE. ACTIVE // indicates that you can register container instances with the cluster and // the associated instances can accept tasks. Status *string `locationName:"status" type:"string"` } // String returns the string representation func (s Cluster) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Cluster) GoString() string { return s.String() } // A Docker container that is part of a task. type Container struct { _ struct{} `type:"structure"` // The Amazon Resource Name (ARN) of the container. ContainerArn *string `locationName:"containerArn" type:"string"` // The exit code returned from the container. ExitCode *int64 `locationName:"exitCode" type:"integer"` // The last known status of the container. LastStatus *string `locationName:"lastStatus" type:"string"` // The name of the container. Name *string `locationName:"name" type:"string"` // The network bindings associated with the container. NetworkBindings []*NetworkBinding `locationName:"networkBindings" type:"list"` // A short (255 max characters) human-readable string to provide additional // detail about a running or stopped container. Reason *string `locationName:"reason" type:"string"` // The Amazon Resource Name (ARN) of the task. TaskArn *string `locationName:"taskArn" type:"string"` } // String returns the string representation func (s Container) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Container) GoString() string { return s.String() } // Container definitions are used in task definitions to describe the different // containers that are launched as part of a task. type ContainerDefinition struct { _ struct{} `type:"structure"` // The command that is passed to the container. This parameter maps to Cmd in // the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the COMMAND parameter to docker run (https://docs.docker.com/reference/commandline/run/). // For more information, see https://docs.docker.com/reference/builder/#cmd // (https://docs.docker.com/reference/builder/#cmd). Command []*string `locationName:"command" type:"list"` // The number of cpu units reserved for the container. A container instance // has 1,024 cpu units for every CPU core. This parameter specifies the minimum // amount of CPU to reserve for a container, and containers share unallocated // CPU units with other containers on the instance with the same ratio as their // allocated amount. This parameter maps to CpuShares in the Create a container // (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --cpu-shares option to docker run (https://docs.docker.com/reference/commandline/run/). // // You can determine the number of CPU units that are available per EC2 instance // type by multiplying the vCPUs listed for that instance type on the Amazon // EC2 Instances (http://aws.amazon.com/ec2/instance-types/) detail page by // 1,024. // // For example, if you run a single-container task on a single-core instance // type with 512 CPU units specified for that container, and that is the only // task running on the container instance, that container could use the full // 1,024 CPU unit share at any given time. However, if you launched another // copy of the same task on that container instance, each task would be guaranteed // a minimum of 512 CPU units when needed, and each container could float to // higher CPU usage if the other container was not using it, but if both tasks // were 100% active all of the time, they would be limited to 512 CPU units. // // The Docker daemon on the container instance uses the CPU value to calculate // the relative CPU share ratios for running containers. For more information, // see CPU share constraint (https://docs.docker.com/reference/run/#cpu-share-constraint) // in the Docker documentation. The minimum valid CPU share value that the Linux // kernel allows is 2; however, the CPU parameter is not required, and you can // use CPU values below 2 in your container definitions. For CPU values below // 2 (including null), the behavior varies based on your Amazon ECS container // agent version: // // Agent versions less than or equal to 1.1.0: Null and zero CPU values // are passed to Docker as 0, which Docker then converts to 1,024 CPU shares. // CPU values of 1 are passed to Docker as 1, which the Linux kernel converts // to 2 CPU shares. // // Agent versions greater than or equal to 1.2.0: Null, zero, and CPU values // of 1 are passed to Docker as 2. Cpu *int64 `locationName:"cpu" type:"integer"` // When this parameter is true, networking is disabled within the container. // This parameter maps to NetworkDisabled in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/). DisableNetworking *bool `locationName:"disableNetworking" type:"boolean"` // A list of DNS search domains that are presented to the container. This parameter // maps to DnsSearch in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --dns-search option to docker run (https://docs.docker.com/reference/commandline/run/). DnsSearchDomains []*string `locationName:"dnsSearchDomains" type:"list"` // A list of DNS servers that are presented to the container. This parameter // maps to Dns in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --dns option to docker run (https://docs.docker.com/reference/commandline/run/). DnsServers []*string `locationName:"dnsServers" type:"list"` // A key/value map of labels to add to the container. This parameter maps to // Labels in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --label option to docker run (https://docs.docker.com/reference/commandline/run/). // This parameter requires version 1.18 of the Docker Remote API or greater // on your container instance. To check the Docker Remote API version on your // container instance, log into your container instance and run the following // command: sudo docker version | grep "Server API version" DockerLabels map[string]*string `locationName:"dockerLabels" type:"map"` // A list of strings to provide custom labels for SELinux and AppArmor multi-level // security systems. This parameter maps to SecurityOpt in the Create a container // (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --security-opt option to docker run (https://docs.docker.com/reference/commandline/run/). // // The Amazon ECS container agent running on a container instance must register // with the ECS_SELINUX_CAPABLE=true or ECS_APPARMOR_CAPABLE=true environment // variables before containers placed on that instance can use these security // options. For more information, see Amazon ECS Container Agent Configuration // (http://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) // in the Amazon EC2 Container Service Developer Guide. DockerSecurityOptions []*string `locationName:"dockerSecurityOptions" type:"list"` // Early versions of the Amazon ECS container agent do not properly handle entryPoint // parameters. If you have problems using entryPoint, update your container // agent or enter your commands and arguments as command array items instead. // // The entry point that is passed to the container. This parameter maps to // Entrypoint in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --entrypoint option to docker run (https://docs.docker.com/reference/commandline/run/). // For more information, see https://docs.docker.com/reference/builder/#entrypoint // (https://docs.docker.com/reference/builder/#entrypoint). EntryPoint []*string `locationName:"entryPoint" type:"list"` // The environment variables to pass to a container. This parameter maps to // Env in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --env option to docker run (https://docs.docker.com/reference/commandline/run/). // // We do not recommend using plain text environment variables for sensitive // information, such as credential data. Environment []*KeyValuePair `locationName:"environment" type:"list"` // If the essential parameter of a container is marked as true, and that container // fails or stops for any reason, all other containers that are part of the // task are stopped. If the essential parameter of a container is marked as // false, then its failure does not affect the rest of the containers in a task. // If this parameter is omitted, a container is assumed to be essential. // // All tasks must have at least one essential container. If you have an application // that is composed of multiple containers, you should group containers that // are used for a common purpose into components, and separate the different // components into multiple task definitions. For more information, see Application // Architecture (http://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html) // in the Amazon EC2 Container Service Developer Guide. Essential *bool `locationName:"essential" type:"boolean"` // A list of hostnames and IP address mappings to append to the /etc/hosts file // on the container. This parameter maps to ExtraHosts in the Create a container // (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --add-host option to docker run (https://docs.docker.com/reference/commandline/run/). ExtraHosts []*HostEntry `locationName:"extraHosts" type:"list"` // The hostname to use for your container. This parameter maps to Hostname in // the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --hostname option to docker run (https://docs.docker.com/reference/commandline/run/). Hostname *string `locationName:"hostname" type:"string"` // The image used to start a container. This string is passed directly to the // Docker daemon. Images in the Docker Hub registry are available by default. // Other repositories are specified with repository-url/image:tag . Up to 255 // letters (uppercase and lowercase), numbers, hyphens, underscores, colons, // periods, forward slashes, and number signs are allowed. This parameter maps // to Image in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the IMAGE parameter of docker run (https://docs.docker.com/reference/commandline/run/). // // Images in official repositories on Docker Hub use a single name (for example, // ubuntu or mongo). // // Images in other repositories on Docker Hub are qualified with an organization // name (for example, amazon/amazon-ecs-agent). // // Images in other online repositories are qualified further by a domain // name (for example, quay.io/assemblyline/ubuntu). Image *string `locationName:"image" type:"string"` // The link parameter allows containers to communicate with each other without // the need for port mappings, using the name parameter and optionally, an alias // for the link. This construct is analogous to name:alias in Docker links. // Up to 255 letters (uppercase and lowercase), numbers, hyphens, and underscores // are allowed for each name and alias. For more information on linking Docker // containers, see https://docs.docker.com/userguide/dockerlinks/ (https://docs.docker.com/userguide/dockerlinks/). // This parameter maps to Links in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --link option to docker run (https://docs.docker.com/reference/commandline/run/). // // Containers that are collocated on a single container instance may be able // to communicate with each other without requiring links or host port mappings. // Network isolation is achieved on the container instance using security groups // and VPC settings. Links []*string `locationName:"links" type:"list"` // The log configuration specification for the container. This parameter maps // to LogConfig in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --log-driver option to docker run (https://docs.docker.com/reference/commandline/run/). // By default, containers use the same logging driver that the Docker daemon // uses; however the container may use a different logging driver than the Docker // daemon by specifying a log driver with this parameter in the container definition. // To use a different logging driver for a container, the log system must be // configured properly on the container instance (or on a different log server // for remote logging options). For more information on the options for different // supported log drivers, see Configure logging drivers (https://docs.docker.com/engine/admin/logging/overview/) // in the Docker documentation. // // Amazon ECS currently supports a subset of the logging drivers available // to the Docker daemon (shown in the LogConfiguration data type). Currently // unsupported log drivers may be available in future releases of the Amazon // ECS container agent. // // This parameter requires version 1.18 of the Docker Remote API or greater // on your container instance. To check the Docker Remote API version on your // container instance, log into your container instance and run the following // command: sudo docker version | grep "Server API version" // // The Amazon ECS container agent running on a container instance must register // the logging drivers available on that instance with the ECS_AVAILABLE_LOGGING_DRIVERS // environment variable before containers placed on that instance can use these // log configuration options. For more information, see Amazon ECS Container // Agent Configuration (http://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) // in the Amazon EC2 Container Service Developer Guide. LogConfiguration *LogConfiguration `locationName:"logConfiguration" type:"structure"` // The number of MiB of memory to reserve for the container. You must specify // a non-zero integer for this parameter; the Docker daemon reserves a minimum // of 4 MiB of memory for a container, so you should not specify fewer than // 4 MiB of memory for your containers. If your container attempts to exceed // the memory allocated here, the container is killed. This parameter maps to // Memory in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --memory option to docker run (https://docs.docker.com/reference/commandline/run/). Memory *int64 `locationName:"memory" type:"integer"` // The mount points for data volumes in your container. This parameter maps // to Volumes in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --volume option to docker run (https://docs.docker.com/reference/commandline/run/). MountPoints []*MountPoint `locationName:"mountPoints" type:"list"` // The name of a container. If you are linking multiple containers together // in a task definition, the name of one container can be entered in the links // of another container to connect the containers. Up to 255 letters (uppercase // and lowercase), numbers, hyphens, and underscores are allowed. This parameter // maps to name in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --name option to docker run (https://docs.docker.com/reference/commandline/run/). Name *string `locationName:"name" type:"string"` // The list of port mappings for the container. Port mappings allow containers // to access ports on the host container instance to send or receive traffic. // This parameter maps to PortBindings in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --publish option to docker run (https://docs.docker.com/reference/commandline/run/). // // After a task reaches the RUNNING status, manual and automatic host and // container port assignments are visible in the Network Bindings section of // a container description of a selected task in the Amazon ECS console, or // the networkBindings section DescribeTasks responses. PortMappings []*PortMapping `locationName:"portMappings" type:"list"` // When this parameter is true, the container is given elevated privileges on // the host container instance (similar to the root user). This parameter maps // to Privileged in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --privileged option to docker run (https://docs.docker.com/reference/commandline/run/). Privileged *bool `locationName:"privileged" type:"boolean"` // When this parameter is true, the container is given read-only access to its // root file system. This parameter maps to ReadonlyRootfs in the Create a container // (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --read-only option to docker run. ReadonlyRootFilesystem *bool `locationName:"readonlyRootFilesystem" type:"boolean"` // A list of ulimits to set in the container. This parameter maps to Ulimits // in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --ulimit option to docker run (https://docs.docker.com/reference/commandline/run/). // Valid naming values are displayed in the Ulimit data type. This parameter // requires version 1.18 of the Docker Remote API or greater on your container // instance. To check the Docker Remote API version on your container instance, // log into your container instance and run the following command: sudo docker // version | grep "Server API version" Ulimits []*Ulimit `locationName:"ulimits" type:"list"` // The user name to use inside the container. This parameter maps to User in // the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --user option to docker run (https://docs.docker.com/reference/commandline/run/). User *string `locationName:"user" type:"string"` // Data volumes to mount from another container. This parameter maps to VolumesFrom // in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --volumes-from option to docker run (https://docs.docker.com/reference/commandline/run/). VolumesFrom []*VolumeFrom `locationName:"volumesFrom" type:"list"` // The working directory in which to run commands inside the container. This // parameter maps to WorkingDir in the Create a container (https://docs.docker.com/reference/api/docker_remote_api_v1.19/#create-a-container) // section of the Docker Remote API (https://docs.docker.com/reference/api/docker_remote_api_v1.19/) // and the --workdir option to docker run (https://docs.docker.com/reference/commandline/run/). WorkingDirectory *string `locationName:"workingDirectory" type:"string"` } // String returns the string representation func (s ContainerDefinition) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ContainerDefinition) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *ContainerDefinition) Validate() error { invalidParams := request.ErrInvalidParams{Context: "ContainerDefinition"} if s.ExtraHosts != nil { for i, v := range s.ExtraHosts { if v == nil { continue } if err := v.Validate(); err != nil { invalidParams.AddNested(fmt.Sprintf("%s[%v]", "ExtraHosts", i), err.(request.ErrInvalidParams)) } } } if s.LogConfiguration != nil { if err := s.LogConfiguration.Validate(); err != nil { invalidParams.AddNested("LogConfiguration", err.(request.ErrInvalidParams)) } } if s.Ulimits != nil { for i, v := range s.Ulimits { if v == nil { continue } if err := v.Validate(); err != nil { invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Ulimits", i), err.(request.ErrInvalidParams)) } } } if invalidParams.Len() > 0 { return invalidParams } return nil } // An EC2 instance that is running the Amazon ECS agent and has been registered // with a cluster. type ContainerInstance struct { _ struct{} `type:"structure"` // This parameter returns true if the agent is actually connected to Amazon // ECS. Registered instances with an agent that may be unhealthy or stopped // return false, and instances without a connected agent cannot accept placement // requests. AgentConnected *bool `locationName:"agentConnected" type:"boolean"` // The status of the most recent agent update. If an update has never been requested, // this value is NULL. AgentUpdateStatus *string `locationName:"agentUpdateStatus" type:"string" enum:"AgentUpdateStatus"` // The attributes set for the container instance by the Amazon ECS container // agent at instance registration. Attributes []*Attribute `locationName:"attributes" type:"list"` // The Amazon Resource Name (ARN) of the container instance. The ARN contains // the arn:aws:ecs namespace, followed by the region of the container instance, // the AWS account ID of the container instance owner, the container-instance // namespace, and then the container instance ID. For example, arn:aws:ecs:region:aws_account_id:container-instance/container_instance_ID // . ContainerInstanceArn *string `locationName:"containerInstanceArn" type:"string"` // The EC2 instance ID of the container instance. Ec2InstanceId *string `locationName:"ec2InstanceId" type:"string"` // The number of tasks on the container instance that are in the PENDING status. PendingTasksCount *int64 `locationName:"pendingTasksCount" type:"integer"` // The registered resources on the container instance that are in use by current // tasks. RegisteredResources []*Resource `locationName:"registeredResources" type:"list"` // The remaining resources of the container instance that are available for // new tasks. RemainingResources []*Resource `locationName:"remainingResources" type:"list"` // The number of tasks on the container instance that are in the RUNNING status. RunningTasksCount *int64 `locationName:"runningTasksCount" type:"integer"` // The status of the container instance. The valid values are ACTIVE or INACTIVE. // ACTIVE indicates that the container instance can accept tasks. Status *string `locationName:"status" type:"string"` // The version information for the Amazon ECS container agent and Docker daemon // running on the container instance. VersionInfo *VersionInfo `locationName:"versionInfo" type:"structure"` } // String returns the string representation func (s ContainerInstance) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ContainerInstance) GoString() string { return s.String() } // The overrides that should be sent to a container. type ContainerOverride struct { _ struct{} `type:"structure"` // The command to send to the container that overrides the default command from // the Docker image or the task definition. Command []*string `locationName:"command" type:"list"` // The environment variables to send to the container. You can add new environment // variables, which are added to the container at launch, or you can override // the existing environment variables from the Docker image or the task definition. Environment []*KeyValuePair `locationName:"environment" type:"list"` // The name of the container that receives the override. Name *string `locationName:"name" type:"string"` } // String returns the string representation func (s ContainerOverride) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ContainerOverride) GoString() string { return s.String() } type CreateClusterInput struct { _ struct{} `type:"structure"` // The name of your cluster. If you do not specify a name for your cluster, // you create a cluster named default. Up to 255 letters (uppercase and lowercase), // numbers, hyphens, and underscores are allowed. ClusterName *string `locationName:"clusterName" type:"string"` } // String returns the string representation func (s CreateClusterInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s CreateClusterInput) GoString() string { return s.String() } type CreateClusterOutput struct { _ struct{} `type:"structure"` // The full description of your new cluster. Cluster *Cluster `locationName:"cluster" type:"structure"` } // String returns the string representation func (s CreateClusterOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s CreateClusterOutput) GoString() string { return s.String() } type CreateServiceInput struct { _ struct{} `type:"structure"` // Unique, case-sensitive identifier you provide to ensure the idempotency of // the request. Up to 32 ASCII characters are allowed. ClientToken *string `locationName:"clientToken" type:"string"` // The short name or full Amazon Resource Name (ARN) of the cluster on which // to run your service. If you do not specify a cluster, the default cluster // is assumed. Cluster *string `locationName:"cluster" type:"string"` // Optional deployment parameters that control how many tasks run during the // deployment and the ordering of stopping and starting tasks. DeploymentConfiguration *DeploymentConfiguration `locationName:"deploymentConfiguration" type:"structure"` // The number of instantiations of the specified task definition to place and // keep running on your cluster. DesiredCount *int64 `locationName:"desiredCount" type:"integer" required:"true"` // A list of load balancer objects, containing the load balancer name, the container // name (as it appears in a container definition), and the container port to // access from the load balancer. LoadBalancers []*LoadBalancer `locationName:"loadBalancers" type:"list"` // The name or full Amazon Resource Name (ARN) of the IAM role that allows Amazon // ECS to make calls to your load balancer on your behalf. This parameter is // required if you are using a load balancer with your service. If you specify // the role parameter, you must also specify a load balancer object with the // loadBalancers parameter. // // If your specified role has a path other than /, then you must either specify // the full role ARN (this is recommended) or prefix the role name with the // path. For example, if a role with the name bar has a path of /foo/ then you // would specify /foo/bar as the role name. For more information, see Friendly // Names and Paths (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names) // in the IAM User Guide. Role *string `locationName:"role" type:"string"` // The name of your service. Up to 255 letters (uppercase and lowercase), numbers, // hyphens, and underscores are allowed. Service names must be unique within // a cluster, but you can have similarly named services in multiple clusters // within a region or across multiple regions. ServiceName *string `locationName:"serviceName" type:"string" required:"true"` // The family and revision (family:revision) or full Amazon Resource Name (ARN) // of the task definition to run in your service. If a revision is not specified, // the latest ACTIVE revision is used. TaskDefinition *string `locationName:"taskDefinition" type:"string" required:"true"` } // String returns the string representation func (s CreateServiceInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s CreateServiceInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *CreateServiceInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "CreateServiceInput"} if s.DesiredCount == nil { invalidParams.Add(request.NewErrParamRequired("DesiredCount")) } if s.ServiceName == nil { invalidParams.Add(request.NewErrParamRequired("ServiceName")) } if s.TaskDefinition == nil { invalidParams.Add(request.NewErrParamRequired("TaskDefinition")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type CreateServiceOutput struct { _ struct{} `type:"structure"` // The full description of your service following the create call. Service *Service `locationName:"service" type:"structure"` } // String returns the string representation func (s CreateServiceOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s CreateServiceOutput) GoString() string { return s.String() } type DeleteClusterInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster to delete. Cluster *string `locationName:"cluster" type:"string" required:"true"` } // String returns the string representation func (s DeleteClusterInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DeleteClusterInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *DeleteClusterInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "DeleteClusterInput"} if s.Cluster == nil { invalidParams.Add(request.NewErrParamRequired("Cluster")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type DeleteClusterOutput struct { _ struct{} `type:"structure"` // The full description of the deleted cluster. Cluster *Cluster `locationName:"cluster" type:"structure"` } // String returns the string representation func (s DeleteClusterOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DeleteClusterOutput) GoString() string { return s.String() } type DeleteServiceInput struct { _ struct{} `type:"structure"` // The name of the cluster that hosts the service to delete. If you do not specify // a cluster, the default cluster is assumed. Cluster *string `locationName:"cluster" type:"string"` // The name of the service to delete. Service *string `locationName:"service" type:"string" required:"true"` } // String returns the string representation func (s DeleteServiceInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DeleteServiceInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *DeleteServiceInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "DeleteServiceInput"} if s.Service == nil { invalidParams.Add(request.NewErrParamRequired("Service")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type DeleteServiceOutput struct { _ struct{} `type:"structure"` // The full description of the deleted service. Service *Service `locationName:"service" type:"structure"` } // String returns the string representation func (s DeleteServiceOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DeleteServiceOutput) GoString() string { return s.String() } // The details of an Amazon ECS service deployment. type Deployment struct { _ struct{} `type:"structure"` // The Unix time in seconds and milliseconds when the service was created. CreatedAt *time.Time `locationName:"createdAt" type:"timestamp" timestampFormat:"unix"` // The most recent desired count of tasks that was specified for the service // to deploy or maintain. DesiredCount *int64 `locationName:"desiredCount" type:"integer"` // The ID of the deployment. Id *string `locationName:"id" type:"string"` // The number of tasks in the deployment that are in the PENDING status. PendingCount *int64 `locationName:"pendingCount" type:"integer"` // The number of tasks in the deployment that are in the RUNNING status. RunningCount *int64 `locationName:"runningCount" type:"integer"` // The status of the deployment. Valid values are PRIMARY (for the most recent // deployment), ACTIVE (for previous deployments that still have tasks running, // but are being replaced with the PRIMARY deployment), and INACTIVE (for deployments // that have been completely replaced). Status *string `locationName:"status" type:"string"` // The most recent task definition that was specified for the service to use. TaskDefinition *string `locationName:"taskDefinition" type:"string"` // The Unix time in seconds and milliseconds when the service was last updated. UpdatedAt *time.Time `locationName:"updatedAt" type:"timestamp" timestampFormat:"unix"` } // String returns the string representation func (s Deployment) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Deployment) GoString() string { return s.String() } // Optional deployment parameters that control how many tasks run during the // deployment and the ordering of stopping and starting tasks. type DeploymentConfiguration struct { _ struct{} `type:"structure"` // The upper limit (as a percentage of the service's desiredCount) of the number // of running tasks that can be running in a service during a deployment. The // maximum number of tasks during a deployment is the desiredCount multiplied // by the maximumPercent/100, rounded down to the nearest integer value. MaximumPercent *int64 `locationName:"maximumPercent" type:"integer"` // The lower limit (as a percentage of the service's desiredCount) of the number // of running tasks that must remain running and healthy in a service during // a deployment. The minimum healthy tasks during a deployment is the desiredCount // multiplied by the minimumHealthyPercent/100, rounded up to the nearest integer // value. MinimumHealthyPercent *int64 `locationName:"minimumHealthyPercent" type:"integer"` } // String returns the string representation func (s DeploymentConfiguration) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DeploymentConfiguration) GoString() string { return s.String() } type DeregisterContainerInstanceInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that hosts // the container instance to deregister. If you do not specify a cluster, the // default cluster is assumed. Cluster *string `locationName:"cluster" type:"string"` // The container instance ID or full Amazon Resource Name (ARN) of the container // instance to deregister. The ARN contains the arn:aws:ecs namespace, followed // by the region of the container instance, the AWS account ID of the container // instance owner, the container-instance namespace, and then the container // instance ID. For example, arn:aws:ecs:region:aws_account_id:container-instance/container_instance_ID // . ContainerInstance *string `locationName:"containerInstance" type:"string" required:"true"` // Forces the deregistration of the container instance. If you have tasks running // on the container instance when you deregister it with the force option, these // tasks remain running and they continue to pass Elastic Load Balancing load // balancer health checks until you terminate the instance or the tasks stop // through some other means, but they are orphaned (no longer monitored or accounted // for by Amazon ECS). If an orphaned task on your container instance is part // of an Amazon ECS service, then the service scheduler starts another copy // of that task, on a different container instance if possible. Force *bool `locationName:"force" type:"boolean"` } // String returns the string representation func (s DeregisterContainerInstanceInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DeregisterContainerInstanceInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *DeregisterContainerInstanceInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "DeregisterContainerInstanceInput"} if s.ContainerInstance == nil { invalidParams.Add(request.NewErrParamRequired("ContainerInstance")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type DeregisterContainerInstanceOutput struct { _ struct{} `type:"structure"` // An EC2 instance that is running the Amazon ECS agent and has been registered // with a cluster. ContainerInstance *ContainerInstance `locationName:"containerInstance" type:"structure"` } // String returns the string representation func (s DeregisterContainerInstanceOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DeregisterContainerInstanceOutput) GoString() string { return s.String() } type DeregisterTaskDefinitionInput struct { _ struct{} `type:"structure"` // The family and revision (family:revision) or full Amazon Resource Name (ARN) // of the task definition to deregister. You must specify a revision. TaskDefinition *string `locationName:"taskDefinition" type:"string" required:"true"` } // String returns the string representation func (s DeregisterTaskDefinitionInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DeregisterTaskDefinitionInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *DeregisterTaskDefinitionInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "DeregisterTaskDefinitionInput"} if s.TaskDefinition == nil { invalidParams.Add(request.NewErrParamRequired("TaskDefinition")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type DeregisterTaskDefinitionOutput struct { _ struct{} `type:"structure"` // The full description of the deregistered task. TaskDefinition *TaskDefinition `locationName:"taskDefinition" type:"structure"` } // String returns the string representation func (s DeregisterTaskDefinitionOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DeregisterTaskDefinitionOutput) GoString() string { return s.String() } type DescribeClustersInput struct { _ struct{} `type:"structure"` // A space-separated list of up to 100 cluster names or full cluster Amazon // Resource Name (ARN) entries. If you do not specify a cluster, the default // cluster is assumed. Clusters []*string `locationName:"clusters" type:"list"` } // String returns the string representation func (s DescribeClustersInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeClustersInput) GoString() string { return s.String() } type DescribeClustersOutput struct { _ struct{} `type:"structure"` // The list of clusters. Clusters []*Cluster `locationName:"clusters" type:"list"` // Any failures associated with the call. Failures []*Failure `locationName:"failures" type:"list"` } // String returns the string representation func (s DescribeClustersOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeClustersOutput) GoString() string { return s.String() } type DescribeContainerInstancesInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that hosts // the container instances to describe. If you do not specify a cluster, the // default cluster is assumed. Cluster *string `locationName:"cluster" type:"string"` // A space-separated list of container instance IDs or full Amazon Resource // Name (ARN) entries. ContainerInstances []*string `locationName:"containerInstances" type:"list" required:"true"` } // String returns the string representation func (s DescribeContainerInstancesInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeContainerInstancesInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *DescribeContainerInstancesInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "DescribeContainerInstancesInput"} if s.ContainerInstances == nil { invalidParams.Add(request.NewErrParamRequired("ContainerInstances")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type DescribeContainerInstancesOutput struct { _ struct{} `type:"structure"` // The list of container instances. ContainerInstances []*ContainerInstance `locationName:"containerInstances" type:"list"` // Any failures associated with the call. Failures []*Failure `locationName:"failures" type:"list"` } // String returns the string representation func (s DescribeContainerInstancesOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeContainerInstancesOutput) GoString() string { return s.String() } type DescribeServicesInput struct { _ struct{} `type:"structure"` // The name of the cluster that hosts the service to describe. If you do not // specify a cluster, the default cluster is assumed. Cluster *string `locationName:"cluster" type:"string"` // A list of services to describe. Services []*string `locationName:"services" type:"list" required:"true"` } // String returns the string representation func (s DescribeServicesInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeServicesInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *DescribeServicesInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "DescribeServicesInput"} if s.Services == nil { invalidParams.Add(request.NewErrParamRequired("Services")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type DescribeServicesOutput struct { _ struct{} `type:"structure"` // Any failures associated with the call. Failures []*Failure `locationName:"failures" type:"list"` // The list of services described. Services []*Service `locationName:"services" type:"list"` } // String returns the string representation func (s DescribeServicesOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeServicesOutput) GoString() string { return s.String() } type DescribeTaskDefinitionInput struct { _ struct{} `type:"structure"` // The family for the latest ACTIVE revision, family and revision (family:revision) // for a specific revision in the family, or full Amazon Resource Name (ARN) // of the task definition to describe. TaskDefinition *string `locationName:"taskDefinition" type:"string" required:"true"` } // String returns the string representation func (s DescribeTaskDefinitionInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeTaskDefinitionInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *DescribeTaskDefinitionInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "DescribeTaskDefinitionInput"} if s.TaskDefinition == nil { invalidParams.Add(request.NewErrParamRequired("TaskDefinition")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type DescribeTaskDefinitionOutput struct { _ struct{} `type:"structure"` // The full task definition description. TaskDefinition *TaskDefinition `locationName:"taskDefinition" type:"structure"` } // String returns the string representation func (s DescribeTaskDefinitionOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeTaskDefinitionOutput) GoString() string { return s.String() } type DescribeTasksInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that hosts // the task to describe. If you do not specify a cluster, the default cluster // is assumed. Cluster *string `locationName:"cluster" type:"string"` // A space-separated list of task IDs or full Amazon Resource Name (ARN) entries. Tasks []*string `locationName:"tasks" type:"list" required:"true"` } // String returns the string representation func (s DescribeTasksInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeTasksInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *DescribeTasksInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "DescribeTasksInput"} if s.Tasks == nil { invalidParams.Add(request.NewErrParamRequired("Tasks")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type DescribeTasksOutput struct { _ struct{} `type:"structure"` // Any failures associated with the call. Failures []*Failure `locationName:"failures" type:"list"` // The list of tasks. Tasks []*Task `locationName:"tasks" type:"list"` } // String returns the string representation func (s DescribeTasksOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DescribeTasksOutput) GoString() string { return s.String() } type DiscoverPollEndpointInput struct { _ struct{} `type:"structure"` // The cluster that the container instance belongs to. Cluster *string `locationName:"cluster" type:"string"` // The container instance ID or full Amazon Resource Name (ARN) of the container // instance. The ARN contains the arn:aws:ecs namespace, followed by the region // of the container instance, the AWS account ID of the container instance owner, // the container-instance namespace, and then the container instance ID. For // example, arn:aws:ecs:region:aws_account_id:container-instance/container_instance_ID // . ContainerInstance *string `locationName:"containerInstance" type:"string"` } // String returns the string representation func (s DiscoverPollEndpointInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DiscoverPollEndpointInput) GoString() string { return s.String() } type DiscoverPollEndpointOutput struct { _ struct{} `type:"structure"` // The endpoint for the Amazon ECS agent to poll. Endpoint *string `locationName:"endpoint" type:"string"` // The telemetry endpoint for the Amazon ECS agent. TelemetryEndpoint *string `locationName:"telemetryEndpoint" type:"string"` } // String returns the string representation func (s DiscoverPollEndpointOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s DiscoverPollEndpointOutput) GoString() string { return s.String() } // A failed resource. type Failure struct { _ struct{} `type:"structure"` // The Amazon Resource Name (ARN) of the failed resource. Arn *string `locationName:"arn" type:"string"` // The reason for the failure. Reason *string `locationName:"reason" type:"string"` } // String returns the string representation func (s Failure) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Failure) GoString() string { return s.String() } // Hostnames and IP address entries that are added to the /etc/hosts file of // a container via the extraHosts parameter of its ContainerDefinition. type HostEntry struct { _ struct{} `type:"structure"` // The hostname to use in the /etc/hosts entry. Hostname *string `locationName:"hostname" type:"string" required:"true"` // The IP address to use in the /etc/hosts entry. IpAddress *string `locationName:"ipAddress" type:"string" required:"true"` } // String returns the string representation func (s HostEntry) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s HostEntry) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *HostEntry) Validate() error { invalidParams := request.ErrInvalidParams{Context: "HostEntry"} if s.Hostname == nil { invalidParams.Add(request.NewErrParamRequired("Hostname")) } if s.IpAddress == nil { invalidParams.Add(request.NewErrParamRequired("IpAddress")) } if invalidParams.Len() > 0 { return invalidParams } return nil } // Details on a container instance host volume. type HostVolumeProperties struct { _ struct{} `type:"structure"` // The path on the host container instance that is presented to the container. // If this parameter is empty, then the Docker daemon has assigned a host path // for you. If the host parameter contains a sourcePath file location, then // the data volume persists at the specified location on the host container // instance until you delete it manually. If the sourcePath value does not exist // on the host container instance, the Docker daemon creates it. If the location // does exist, the contents of the source path folder are exported. SourcePath *string `locationName:"sourcePath" type:"string"` } // String returns the string representation func (s HostVolumeProperties) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s HostVolumeProperties) GoString() string { return s.String() } // A key and value pair object. type KeyValuePair struct { _ struct{} `type:"structure"` // The name of the key value pair. For environment variables, this is the name // of the environment variable. Name *string `locationName:"name" type:"string"` // The value of the key value pair. For environment variables, this is the value // of the environment variable. Value *string `locationName:"value" type:"string"` } // String returns the string representation func (s KeyValuePair) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s KeyValuePair) GoString() string { return s.String() } type ListClustersInput struct { _ struct{} `type:"structure"` // The maximum number of cluster results returned by ListClusters in paginated // output. When this parameter is used, ListClusters only returns maxResults // results in a single page along with a nextToken response element. The remaining // results of the initial request can be seen by sending another ListClusters // request with the returned nextToken value. This value can be between 1 and // 100. If this parameter is not used, then ListClusters returns up to 100 results // and a nextToken value if applicable. MaxResults *int64 `locationName:"maxResults" type:"integer"` // The nextToken value returned from a previous paginated ListClusters request // where maxResults was used and the results exceeded the value of that parameter. // Pagination continues from the end of the previous results that returned the // nextToken value. This value is null when there are no more results to return. // // This token should be treated as an opaque identifier that is only used // to retrieve the next items in a list and not for other programmatic purposes. NextToken *string `locationName:"nextToken" type:"string"` } // String returns the string representation func (s ListClustersInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListClustersInput) GoString() string { return s.String() } type ListClustersOutput struct { _ struct{} `type:"structure"` // The list of full Amazon Resource Name (ARN) entries for each cluster associated // with your account. ClusterArns []*string `locationName:"clusterArns" type:"list"` // The nextToken value to include in a future ListClusters request. When the // results of a ListClusters request exceed maxResults, this value can be used // to retrieve the next page of results. This value is null when there are no // more results to return. NextToken *string `locationName:"nextToken" type:"string"` } // String returns the string representation func (s ListClustersOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListClustersOutput) GoString() string { return s.String() } type ListContainerInstancesInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that hosts // the container instances to list. If you do not specify a cluster, the default // cluster is assumed.. Cluster *string `locationName:"cluster" type:"string"` // The maximum number of container instance results returned by ListContainerInstances // in paginated output. When this parameter is used, ListContainerInstances // only returns maxResults results in a single page along with a nextToken response // element. The remaining results of the initial request can be seen by sending // another ListContainerInstances request with the returned nextToken value. // This value can be between 1 and 100. If this parameter is not used, then // ListContainerInstances returns up to 100 results and a nextToken value if // applicable. MaxResults *int64 `locationName:"maxResults" type:"integer"` // The nextToken value returned from a previous paginated ListContainerInstances // request where maxResults was used and the results exceeded the value of that // parameter. Pagination continues from the end of the previous results that // returned the nextToken value. This value is null when there are no more results // to return. // // This token should be treated as an opaque identifier that is only used // to retrieve the next items in a list and not for other programmatic purposes. NextToken *string `locationName:"nextToken" type:"string"` } // String returns the string representation func (s ListContainerInstancesInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListContainerInstancesInput) GoString() string { return s.String() } type ListContainerInstancesOutput struct { _ struct{} `type:"structure"` // The list of container instances with full Amazon Resource Name (ARN) entries // for each container instance associated with the specified cluster. ContainerInstanceArns []*string `locationName:"containerInstanceArns" type:"list"` // The nextToken value to include in a future ListContainerInstances request. // When the results of a ListContainerInstances request exceed maxResults, this // value can be used to retrieve the next page of results. This value is null // when there are no more results to return. NextToken *string `locationName:"nextToken" type:"string"` } // String returns the string representation func (s ListContainerInstancesOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListContainerInstancesOutput) GoString() string { return s.String() } type ListServicesInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that hosts // the services to list. If you do not specify a cluster, the default cluster // is assumed.. Cluster *string `locationName:"cluster" type:"string"` // The maximum number of container instance results returned by ListServices // in paginated output. When this parameter is used, ListServices only returns // maxResults results in a single page along with a nextToken response element. // The remaining results of the initial request can be seen by sending another // ListServices request with the returned nextToken value. This value can be // between 1 and 10. If this parameter is not used, then ListServices returns // up to 10 results and a nextToken value if applicable. MaxResults *int64 `locationName:"maxResults" type:"integer"` // The nextToken value returned from a previous paginated ListServices request // where maxResults was used and the results exceeded the value of that parameter. // Pagination continues from the end of the previous results that returned the // nextToken value. This value is null when there are no more results to return. // // This token should be treated as an opaque identifier that is only used // to retrieve the next items in a list and not for other programmatic purposes. NextToken *string `locationName:"nextToken" type:"string"` } // String returns the string representation func (s ListServicesInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListServicesInput) GoString() string { return s.String() } type ListServicesOutput struct { _ struct{} `type:"structure"` // The nextToken value to include in a future ListServices request. When the // results of a ListServices request exceed maxResults, this value can be used // to retrieve the next page of results. This value is null when there are no // more results to return. NextToken *string `locationName:"nextToken" type:"string"` // The list of full Amazon Resource Name (ARN) entries for each service associated // with the specified cluster. ServiceArns []*string `locationName:"serviceArns" type:"list"` } // String returns the string representation func (s ListServicesOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListServicesOutput) GoString() string { return s.String() } type ListTaskDefinitionFamiliesInput struct { _ struct{} `type:"structure"` // The familyPrefix is a string that is used to filter the results of ListTaskDefinitionFamilies. // If you specify a familyPrefix, only task definition family names that begin // with the familyPrefix string are returned. FamilyPrefix *string `locationName:"familyPrefix" type:"string"` // The maximum number of task definition family results returned by ListTaskDefinitionFamilies // in paginated output. When this parameter is used, ListTaskDefinitions only // returns maxResults results in a single page along with a nextToken response // element. The remaining results of the initial request can be seen by sending // another ListTaskDefinitionFamilies request with the returned nextToken value. // This value can be between 1 and 100. If this parameter is not used, then // ListTaskDefinitionFamilies returns up to 100 results and a nextToken value // if applicable. MaxResults *int64 `locationName:"maxResults" type:"integer"` // The nextToken value returned from a previous paginated ListTaskDefinitionFamilies // request where maxResults was used and the results exceeded the value of that // parameter. Pagination continues from the end of the previous results that // returned the nextToken value. This value is null when there are no more results // to return. // // This token should be treated as an opaque identifier that is only used // to retrieve the next items in a list and not for other programmatic purposes. NextToken *string `locationName:"nextToken" type:"string"` // The task definition family status with which to filter the ListTaskDefinitionFamilies // results. By default, both ACTIVE and INACTIVE task definition families are // listed. If this parameter is set to ACTIVE, only task definition families // that have an ACTIVE task definition revision are returned. If this parameter // is set to INACTIVE, only task definition families that do not have any ACTIVE // task definition revisions are returned. If you paginate the resulting output, // be sure to keep the status value constant in each subsequent request. Status *string `locationName:"status" type:"string" enum:"TaskDefinitionFamilyStatus"` } // String returns the string representation func (s ListTaskDefinitionFamiliesInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListTaskDefinitionFamiliesInput) GoString() string { return s.String() } type ListTaskDefinitionFamiliesOutput struct { _ struct{} `type:"structure"` // The list of task definition family names that match the ListTaskDefinitionFamilies // request. Families []*string `locationName:"families" type:"list"` // The nextToken value to include in a future ListTaskDefinitionFamilies request. // When the results of a ListTaskDefinitionFamilies request exceed maxResults, // this value can be used to retrieve the next page of results. This value is // null when there are no more results to return. NextToken *string `locationName:"nextToken" type:"string"` } // String returns the string representation func (s ListTaskDefinitionFamiliesOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListTaskDefinitionFamiliesOutput) GoString() string { return s.String() } type ListTaskDefinitionsInput struct { _ struct{} `type:"structure"` // The full family name with which to filter the ListTaskDefinitions results. // Specifying a familyPrefix limits the listed task definitions to task definition // revisions that belong to that family. FamilyPrefix *string `locationName:"familyPrefix" type:"string"` // The maximum number of task definition results returned by ListTaskDefinitions // in paginated output. When this parameter is used, ListTaskDefinitions only // returns maxResults results in a single page along with a nextToken response // element. The remaining results of the initial request can be seen by sending // another ListTaskDefinitions request with the returned nextToken value. This // value can be between 1 and 100. If this parameter is not used, then ListTaskDefinitions // returns up to 100 results and a nextToken value if applicable. MaxResults *int64 `locationName:"maxResults" type:"integer"` // The nextToken value returned from a previous paginated ListTaskDefinitions // request where maxResults was used and the results exceeded the value of that // parameter. Pagination continues from the end of the previous results that // returned the nextToken value. This value is null when there are no more results // to return. // // This token should be treated as an opaque identifier that is only used // to retrieve the next items in a list and not for other programmatic purposes. NextToken *string `locationName:"nextToken" type:"string"` // The order in which to sort the results. Valid values are ASC and DESC. By // default (ASC), task definitions are listed lexicographically by family name // and in ascending numerical order by revision so that the newest task definitions // in a family are listed last. Setting this parameter to DESC reverses the // sort order on family name and revision so that the newest task definitions // in a family are listed first. Sort *string `locationName:"sort" type:"string" enum:"SortOrder"` // The task definition status with which to filter the ListTaskDefinitions results. // By default, only ACTIVE task definitions are listed. By setting this parameter // to INACTIVE, you can view task definitions that are INACTIVE as long as an // active task or service still references them. If you paginate the resulting // output, be sure to keep the status value constant in each subsequent request. Status *string `locationName:"status" type:"string" enum:"TaskDefinitionStatus"` } // String returns the string representation func (s ListTaskDefinitionsInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListTaskDefinitionsInput) GoString() string { return s.String() } type ListTaskDefinitionsOutput struct { _ struct{} `type:"structure"` // The nextToken value to include in a future ListTaskDefinitions request. When // the results of a ListTaskDefinitions request exceed maxResults, this value // can be used to retrieve the next page of results. This value is null when // there are no more results to return. NextToken *string `locationName:"nextToken" type:"string"` // The list of task definition Amazon Resource Name (ARN) entries for the ListTaskDefinitions // request. TaskDefinitionArns []*string `locationName:"taskDefinitionArns" type:"list"` } // String returns the string representation func (s ListTaskDefinitionsOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListTaskDefinitionsOutput) GoString() string { return s.String() } type ListTasksInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that hosts // the tasks to list. If you do not specify a cluster, the default cluster is // assumed.. Cluster *string `locationName:"cluster" type:"string"` // The container instance ID or full Amazon Resource Name (ARN) of the container // instance with which to filter the ListTasks results. Specifying a containerInstance // limits the results to tasks that belong to that container instance. ContainerInstance *string `locationName:"containerInstance" type:"string"` // The task status with which to filter the ListTasks results. Specifying a // desiredStatus of STOPPED limits the results to tasks that are in the STOPPED // status, which can be useful for debugging tasks that are not starting properly // or have died or finished. The default status filter is status filter is RUNNING, // which shows tasks that ECS has set the desired status to RUNNING. // // Although you can filter results based on a desired status of PENDING, this // will not return any results because ECS never sets the desired status of // a task to that value (only a task's lastStatus may have a value of PENDING). DesiredStatus *string `locationName:"desiredStatus" type:"string" enum:"DesiredStatus"` // The name of the family with which to filter the ListTasks results. Specifying // a family limits the results to tasks that belong to that family. Family *string `locationName:"family" type:"string"` // The maximum number of task results returned by ListTasks in paginated output. // When this parameter is used, ListTasks only returns maxResults results in // a single page along with a nextToken response element. The remaining results // of the initial request can be seen by sending another ListTasks request with // the returned nextToken value. This value can be between 1 and 100. If this // parameter is not used, then ListTasks returns up to 100 results and a nextToken // value if applicable. MaxResults *int64 `locationName:"maxResults" type:"integer"` // The nextToken value returned from a previous paginated ListTasks request // where maxResults was used and the results exceeded the value of that parameter. // Pagination continues from the end of the previous results that returned the // nextToken value. This value is null when there are no more results to return. // // This token should be treated as an opaque identifier that is only used // to retrieve the next items in a list and not for other programmatic purposes. NextToken *string `locationName:"nextToken" type:"string"` // The name of the service with which to filter the ListTasks results. Specifying // a serviceName limits the results to tasks that belong to that service. ServiceName *string `locationName:"serviceName" type:"string"` // The startedBy value with which to filter the task results. Specifying a startedBy // value limits the results to tasks that were started with that value. StartedBy *string `locationName:"startedBy" type:"string"` } // String returns the string representation func (s ListTasksInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListTasksInput) GoString() string { return s.String() } type ListTasksOutput struct { _ struct{} `type:"structure"` // The nextToken value to include in a future ListTasks request. When the results // of a ListTasks request exceed maxResults, this value can be used to retrieve // the next page of results. This value is null when there are no more results // to return. NextToken *string `locationName:"nextToken" type:"string"` // The list of task Amazon Resource Name (ARN) entries for the ListTasks request. TaskArns []*string `locationName:"taskArns" type:"list"` } // String returns the string representation func (s ListTasksOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ListTasksOutput) GoString() string { return s.String() } // Details on a load balancer that is used with a service. type LoadBalancer struct { _ struct{} `type:"structure"` // The name of the container (as it appears in a container definition) to associate // with the load balancer. ContainerName *string `locationName:"containerName" type:"string"` // The port on the container to associate with the load balancer. This port // must correspond to a containerPort in the service's task definition. Your // container instances must allow ingress traffic on the hostPort of the port // mapping. ContainerPort *int64 `locationName:"containerPort" type:"integer"` // The name of the load balancer. LoadBalancerName *string `locationName:"loadBalancerName" type:"string"` } // String returns the string representation func (s LoadBalancer) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s LoadBalancer) GoString() string { return s.String() } // Log configuration options to send to a custom log driver for the container. type LogConfiguration struct { _ struct{} `type:"structure"` // The log driver to use for the container. The valid values listed for this // parameter are log drivers that the Amazon ECS container agent can communicate // with by default. // // If you have a custom driver that is not listed above that you would like // to work with the Amazon ECS container agent, you can fork the Amazon ECS // container agent project that is available on GitHub (https://github.com/aws/amazon-ecs-agent) // and customize it to work with that driver. We encourage you to submit pull // requests for changes that you would like to have included. However, Amazon // Web Services does not currently provide support for running modified copies // of this software. // // This parameter requires version 1.18 of the Docker Remote API or greater // on your container instance. To check the Docker Remote API version on your // container instance, log into your container instance and run the following // command: sudo docker version | grep "Server API version" LogDriver *string `locationName:"logDriver" type:"string" required:"true" enum:"LogDriver"` // The configuration options to send to the log driver. This parameter requires // version 1.19 of the Docker Remote API or greater on your container instance. // To check the Docker Remote API version on your container instance, log into // your container instance and run the following command: sudo docker version // | grep "Server API version" Options map[string]*string `locationName:"options" type:"map"` } // String returns the string representation func (s LogConfiguration) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s LogConfiguration) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *LogConfiguration) Validate() error { invalidParams := request.ErrInvalidParams{Context: "LogConfiguration"} if s.LogDriver == nil { invalidParams.Add(request.NewErrParamRequired("LogDriver")) } if invalidParams.Len() > 0 { return invalidParams } return nil } // Details on a volume mount point that is used in a container definition. type MountPoint struct { _ struct{} `type:"structure"` // The path on the container to mount the host volume at. ContainerPath *string `locationName:"containerPath" type:"string"` // If this value is true, the container has read-only access to the volume. // If this value is false, then the container can write to the volume. The default // value is false. ReadOnly *bool `locationName:"readOnly" type:"boolean"` // The name of the volume to mount. SourceVolume *string `locationName:"sourceVolume" type:"string"` } // String returns the string representation func (s MountPoint) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s MountPoint) GoString() string { return s.String() } // Details on the network bindings between a container and its host container // instance. After a task reaches the RUNNING status, manual and automatic host // and container port assignments are visible in the networkBindings section // of DescribeTasks API responses. type NetworkBinding struct { _ struct{} `type:"structure"` // The IP address that the container is bound to on the container instance. BindIP *string `locationName:"bindIP" type:"string"` // The port number on the container that is be used with the network binding. ContainerPort *int64 `locationName:"containerPort" type:"integer"` // The port number on the host that is used with the network binding. HostPort *int64 `locationName:"hostPort" type:"integer"` // The protocol used for the network binding. Protocol *string `locationName:"protocol" type:"string" enum:"TransportProtocol"` } // String returns the string representation func (s NetworkBinding) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s NetworkBinding) GoString() string { return s.String() } // Port mappings allow containers to access ports on the host container instance // to send or receive traffic. Port mappings are specified as part of the container // definition. After a task reaches the RUNNING status, manual and automatic // host and container port assignments are visible in the networkBindings section // of DescribeTasks API responses. type PortMapping struct { _ struct{} `type:"structure"` // The port number on the container that is bound to the user-specified or automatically // assigned host port. If you specify a container port and not a host port, // your container automatically receives a host port in the ephemeral port range // (for more information, see hostPort). Port mappings that are automatically // assigned in this way do not count toward the 100 reserved ports limit of // a container instance. ContainerPort *int64 `locationName:"containerPort" type:"integer"` // The port number on the container instance to reserve for your container. // You can specify a non-reserved host port for your container port mapping, // or you can omit the hostPort (or set it to 0) while specifying a containerPort // and your container automatically receives a port in the ephemeral port range // for your container instance operating system and Docker version. // // The default ephemeral port range is 49153 to 65535, and this range is used // for Docker versions prior to 1.6.0. For Docker version 1.6.0 and later, the // Docker daemon tries to read the ephemeral port range from /proc/sys/net/ipv4/ip_local_port_range; // if this kernel parameter is unavailable, the default ephemeral port range // is used. You should not attempt to specify a host port in the ephemeral port // range, because these are reserved for automatic assignment. In general, ports // below 32768 are outside of the ephemeral port range. // // The default reserved ports are 22 for SSH, the Docker ports 2375 and 2376, // and the Amazon ECS container agent port 51678. Any host port that was previously // specified in a running task is also reserved while the task is running (after // a task stops, the host port is released).The current reserved ports are displayed // in the remainingResources of DescribeContainerInstances output, and a container // instance may have up to 100 reserved ports at a time, including the default // reserved ports (automatically assigned ports do not count toward the 100 // reserved ports limit). HostPort *int64 `locationName:"hostPort" type:"integer"` // The protocol used for the port mapping. Valid values are tcp and udp. The // default is tcp. Protocol *string `locationName:"protocol" type:"string" enum:"TransportProtocol"` } // String returns the string representation func (s PortMapping) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s PortMapping) GoString() string { return s.String() } type RegisterContainerInstanceInput struct { _ struct{} `type:"structure"` // The container instance attributes that this container instance supports. Attributes []*Attribute `locationName:"attributes" type:"list"` // The short name or full Amazon Resource Name (ARN) of the cluster with which // to register your container instance. If you do not specify a cluster, the // default cluster is assumed.. Cluster *string `locationName:"cluster" type:"string"` // The Amazon Resource Name (ARN) of the container instance (if it was previously // registered). ContainerInstanceArn *string `locationName:"containerInstanceArn" type:"string"` // The instance identity document for the EC2 instance to register. This document // can be found by running the following command from the instance: curl http://169.254.169.254/latest/dynamic/instance-identity/document/ InstanceIdentityDocument *string `locationName:"instanceIdentityDocument" type:"string"` // The instance identity document signature for the EC2 instance to register. // This signature can be found by running the following command from the instance: // curl http://169.254.169.254/latest/dynamic/instance-identity/signature/ InstanceIdentityDocumentSignature *string `locationName:"instanceIdentityDocumentSignature" type:"string"` // The resources available on the instance. TotalResources []*Resource `locationName:"totalResources" type:"list"` // The version information for the Amazon ECS container agent and Docker daemon // running on the container instance. VersionInfo *VersionInfo `locationName:"versionInfo" type:"structure"` } // String returns the string representation func (s RegisterContainerInstanceInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s RegisterContainerInstanceInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *RegisterContainerInstanceInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "RegisterContainerInstanceInput"} if s.Attributes != nil { for i, v := range s.Attributes { if v == nil { continue } if err := v.Validate(); err != nil { invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Attributes", i), err.(request.ErrInvalidParams)) } } } if invalidParams.Len() > 0 { return invalidParams } return nil } type RegisterContainerInstanceOutput struct { _ struct{} `type:"structure"` // An EC2 instance that is running the Amazon ECS agent and has been registered // with a cluster. ContainerInstance *ContainerInstance `locationName:"containerInstance" type:"structure"` } // String returns the string representation func (s RegisterContainerInstanceOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s RegisterContainerInstanceOutput) GoString() string { return s.String() } type RegisterTaskDefinitionInput struct { _ struct{} `type:"structure"` // A list of container definitions in JSON format that describe the different // containers that make up your task. ContainerDefinitions []*ContainerDefinition `locationName:"containerDefinitions" type:"list" required:"true"` // You must specify a family for a task definition, which allows you to track // multiple versions of the same task definition. The family is used as a name // for your task definition. Up to 255 letters (uppercase and lowercase), numbers, // hyphens, and underscores are allowed. Family *string `locationName:"family" type:"string" required:"true"` // The Amazon Resource Name (ARN) of the IAM role that containers in this task // can assume. All containers in this task are granted the permissions that // are specified in this role. TaskRoleArn *string `locationName:"taskRoleArn" type:"string"` // A list of volume definitions in JSON format that containers in your task // may use. Volumes []*Volume `locationName:"volumes" type:"list"` } // String returns the string representation func (s RegisterTaskDefinitionInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s RegisterTaskDefinitionInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *RegisterTaskDefinitionInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "RegisterTaskDefinitionInput"} if s.ContainerDefinitions == nil { invalidParams.Add(request.NewErrParamRequired("ContainerDefinitions")) } if s.Family == nil { invalidParams.Add(request.NewErrParamRequired("Family")) } if s.ContainerDefinitions != nil { for i, v := range s.ContainerDefinitions { if v == nil { continue } if err := v.Validate(); err != nil { invalidParams.AddNested(fmt.Sprintf("%s[%v]", "ContainerDefinitions", i), err.(request.ErrInvalidParams)) } } } if invalidParams.Len() > 0 { return invalidParams } return nil } type RegisterTaskDefinitionOutput struct { _ struct{} `type:"structure"` // The full description of the registered task definition. TaskDefinition *TaskDefinition `locationName:"taskDefinition" type:"structure"` } // String returns the string representation func (s RegisterTaskDefinitionOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s RegisterTaskDefinitionOutput) GoString() string { return s.String() } // Describes the resources available for a container instance. type Resource struct { _ struct{} `type:"structure"` // When the doubleValue type is set, the value of the resource must be a double // precision floating-point type. DoubleValue *float64 `locationName:"doubleValue" type:"double"` // When the integerValue type is set, the value of the resource must be an integer. IntegerValue *int64 `locationName:"integerValue" type:"integer"` // When the longValue type is set, the value of the resource must be an extended // precision floating-point type. LongValue *int64 `locationName:"longValue" type:"long"` // The name of the resource, such as CPU, MEMORY, PORTS, or a user-defined resource. Name *string `locationName:"name" type:"string"` // When the stringSetValue type is set, the value of the resource must be a // string type. StringSetValue []*string `locationName:"stringSetValue" type:"list"` // The type of the resource, such as INTEGER, DOUBLE, LONG, or STRINGSET. Type *string `locationName:"type" type:"string"` } // String returns the string representation func (s Resource) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Resource) GoString() string { return s.String() } type RunTaskInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster on which // to run your task. If you do not specify a cluster, the default cluster is // assumed.. Cluster *string `locationName:"cluster" type:"string"` // The number of instantiations of the specified task to place on your cluster. // // The count parameter is limited to 10 tasks per call. Count *int64 `locationName:"count" type:"integer"` // A list of container overrides in JSON format that specify the name of a container // in the specified task definition and the overrides it should receive. You // can override the default command for a container (that is specified in the // task definition or Docker image) with a command override. You can also override // existing environment variables (that are specified in the task definition // or Docker image) on a container or add new environment variables to it with // an environment override. // // A total of 8192 characters are allowed for overrides. This limit includes // the JSON formatting characters of the override structure. Overrides *TaskOverride `locationName:"overrides" type:"structure"` // An optional tag specified when a task is started. For example if you automatically // trigger a task to run a batch process job, you could apply a unique identifier // for that job to your task with the startedBy parameter. You can then identify // which tasks belong to that job by filtering the results of a ListTasks call // with the startedBy value. Up to 36 letters (uppercase and lowercase), numbers, // hyphens, and underscores are allowed. // // If a task is started by an Amazon ECS service, then the startedBy parameter // contains the deployment ID of the service that starts it. StartedBy *string `locationName:"startedBy" type:"string"` // The family and revision (family:revision) or full Amazon Resource Name (ARN) // of the task definition to run. If a revision is not specified, the latest // ACTIVE revision is used. TaskDefinition *string `locationName:"taskDefinition" type:"string" required:"true"` } // String returns the string representation func (s RunTaskInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s RunTaskInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *RunTaskInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "RunTaskInput"} if s.TaskDefinition == nil { invalidParams.Add(request.NewErrParamRequired("TaskDefinition")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type RunTaskOutput struct { _ struct{} `type:"structure"` // Any failures associated with the call. Failures []*Failure `locationName:"failures" type:"list"` // A full description of the tasks that were run. Each task that was successfully // placed on your cluster are described here. Tasks []*Task `locationName:"tasks" type:"list"` } // String returns the string representation func (s RunTaskOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s RunTaskOutput) GoString() string { return s.String() } // Details on a service within a cluster type Service struct { _ struct{} `type:"structure"` // The Amazon Resource Name (ARN) of the cluster that hosts the service. ClusterArn *string `locationName:"clusterArn" type:"string"` // The Unix time in seconds and milliseconds when the service was created. CreatedAt *time.Time `locationName:"createdAt" type:"timestamp" timestampFormat:"unix"` // Optional deployment parameters that control how many tasks run during the // deployment and the ordering of stopping and starting tasks. DeploymentConfiguration *DeploymentConfiguration `locationName:"deploymentConfiguration" type:"structure"` // The current state of deployments for the service. Deployments []*Deployment `locationName:"deployments" type:"list"` // The desired number of instantiations of the task definition to keep running // on the service. This value is specified when the service is created with // CreateService, and it can be modified with UpdateService. DesiredCount *int64 `locationName:"desiredCount" type:"integer"` // The event stream for your service. A maximum of 100 of the latest events // are displayed. Events []*ServiceEvent `locationName:"events" type:"list"` // A list of load balancer objects, containing the load balancer name, the container // name (as it appears in a container definition), and the container port to // access from the load balancer. LoadBalancers []*LoadBalancer `locationName:"loadBalancers" type:"list"` // The number of tasks in the cluster that are in the PENDING state. PendingCount *int64 `locationName:"pendingCount" type:"integer"` // The Amazon Resource Name (ARN) of the IAM role associated with the service // that allows the Amazon ECS container agent to register container instances // with a load balancer. RoleArn *string `locationName:"roleArn" type:"string"` // The number of tasks in the cluster that are in the RUNNING state. RunningCount *int64 `locationName:"runningCount" type:"integer"` // The Amazon Resource Name (ARN) that identifies the service. The ARN contains // the arn:aws:ecs namespace, followed by the region of the service, the AWS // account ID of the service owner, the service namespace, and then the service // name. For example, arn:aws:ecs:region:012345678910:service/my-service . ServiceArn *string `locationName:"serviceArn" type:"string"` // The name of your service. Up to 255 letters (uppercase and lowercase), numbers, // hyphens, and underscores are allowed. Service names must be unique within // a cluster, but you can have similarly named services in multiple clusters // within a region or across multiple regions. ServiceName *string `locationName:"serviceName" type:"string"` // The status of the service. The valid values are ACTIVE, DRAINING, or INACTIVE. Status *string `locationName:"status" type:"string"` // The task definition to use for tasks in the service. This value is specified // when the service is created with CreateService, and it can be modified with // UpdateService. TaskDefinition *string `locationName:"taskDefinition" type:"string"` } // String returns the string representation func (s Service) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Service) GoString() string { return s.String() } // Details on an event associated with a service. type ServiceEvent struct { _ struct{} `type:"structure"` // The Unix time in seconds and milliseconds when the event was triggered. CreatedAt *time.Time `locationName:"createdAt" type:"timestamp" timestampFormat:"unix"` // The ID string of the event. Id *string `locationName:"id" type:"string"` // The event message. Message *string `locationName:"message" type:"string"` } // String returns the string representation func (s ServiceEvent) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s ServiceEvent) GoString() string { return s.String() } type StartTaskInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster on which // to start your task. If you do not specify a cluster, the default cluster // is assumed.. Cluster *string `locationName:"cluster" type:"string"` // The container instance IDs or full Amazon Resource Name (ARN) entries for // the container instances on which you would like to place your task. // // The list of container instances to start tasks on is limited to 10. ContainerInstances []*string `locationName:"containerInstances" type:"list" required:"true"` // A list of container overrides in JSON format that specify the name of a container // in the specified task definition and the overrides it should receive. You // can override the default command for a container (that is specified in the // task definition or Docker image) with a command override. You can also override // existing environment variables (that are specified in the task definition // or Docker image) on a container or add new environment variables to it with // an environment override. // // A total of 8192 characters are allowed for overrides. This limit includes // the JSON formatting characters of the override structure. Overrides *TaskOverride `locationName:"overrides" type:"structure"` // An optional tag specified when a task is started. For example if you automatically // trigger a task to run a batch process job, you could apply a unique identifier // for that job to your task with the startedBy parameter. You can then identify // which tasks belong to that job by filtering the results of a ListTasks call // with the startedBy value. Up to 36 letters (uppercase and lowercase), numbers, // hyphens, and underscores are allowed. // // If a task is started by an Amazon ECS service, then the startedBy parameter // contains the deployment ID of the service that starts it. StartedBy *string `locationName:"startedBy" type:"string"` // The family and revision (family:revision) or full Amazon Resource Name (ARN) // of the task definition to start. If a revision is not specified, the latest // ACTIVE revision is used. TaskDefinition *string `locationName:"taskDefinition" type:"string" required:"true"` } // String returns the string representation func (s StartTaskInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s StartTaskInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *StartTaskInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "StartTaskInput"} if s.ContainerInstances == nil { invalidParams.Add(request.NewErrParamRequired("ContainerInstances")) } if s.TaskDefinition == nil { invalidParams.Add(request.NewErrParamRequired("TaskDefinition")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type StartTaskOutput struct { _ struct{} `type:"structure"` // Any failures associated with the call. Failures []*Failure `locationName:"failures" type:"list"` // A full description of the tasks that were started. Each task that was successfully // placed on your container instances are described here. Tasks []*Task `locationName:"tasks" type:"list"` } // String returns the string representation func (s StartTaskOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s StartTaskOutput) GoString() string { return s.String() } type StopTaskInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that hosts // the task to stop. If you do not specify a cluster, the default cluster is // assumed.. Cluster *string `locationName:"cluster" type:"string"` // An optional message specified when a task is stopped. For example, if you // are using a custom scheduler, you can use this parameter to specify the reason // for stopping the task here, and the message will appear in subsequent DescribeTasks // API operations on this task. Up to 255 characters are allowed in this message. Reason *string `locationName:"reason" type:"string"` // The task ID or full Amazon Resource Name (ARN) entry of the task to stop. Task *string `locationName:"task" type:"string" required:"true"` } // String returns the string representation func (s StopTaskInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s StopTaskInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *StopTaskInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "StopTaskInput"} if s.Task == nil { invalidParams.Add(request.NewErrParamRequired("Task")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type StopTaskOutput struct { _ struct{} `type:"structure"` // Details on a task in a cluster. Task *Task `locationName:"task" type:"structure"` } // String returns the string representation func (s StopTaskOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s StopTaskOutput) GoString() string { return s.String() } type SubmitContainerStateChangeInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that hosts // the container. Cluster *string `locationName:"cluster" type:"string"` // The name of the container. ContainerName *string `locationName:"containerName" type:"string"` // The exit code returned for the state change request. ExitCode *int64 `locationName:"exitCode" type:"integer"` // The network bindings of the container. NetworkBindings []*NetworkBinding `locationName:"networkBindings" type:"list"` // The reason for the state change request. Reason *string `locationName:"reason" type:"string"` // The status of the state change request. Status *string `locationName:"status" type:"string"` // The task ID or full Amazon Resource Name (ARN) of the task that hosts the // container. Task *string `locationName:"task" type:"string"` } // String returns the string representation func (s SubmitContainerStateChangeInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s SubmitContainerStateChangeInput) GoString() string { return s.String() } type SubmitContainerStateChangeOutput struct { _ struct{} `type:"structure"` // Acknowledgement of the state change. Acknowledgment *string `locationName:"acknowledgment" type:"string"` } // String returns the string representation func (s SubmitContainerStateChangeOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s SubmitContainerStateChangeOutput) GoString() string { return s.String() } type SubmitTaskStateChangeInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that hosts // the task. Cluster *string `locationName:"cluster" type:"string"` // The reason for the state change request. Reason *string `locationName:"reason" type:"string"` // The status of the state change request. Status *string `locationName:"status" type:"string"` // The task ID or full Amazon Resource Name (ARN) of the task in the state change // request. Task *string `locationName:"task" type:"string"` } // String returns the string representation func (s SubmitTaskStateChangeInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s SubmitTaskStateChangeInput) GoString() string { return s.String() } type SubmitTaskStateChangeOutput struct { _ struct{} `type:"structure"` // Acknowledgement of the state change. Acknowledgment *string `locationName:"acknowledgment" type:"string"` } // String returns the string representation func (s SubmitTaskStateChangeOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s SubmitTaskStateChangeOutput) GoString() string { return s.String() } // Details on a task in a cluster. type Task struct { _ struct{} `type:"structure"` // The Amazon Resource Name (ARN) of the cluster that hosts the task. ClusterArn *string `locationName:"clusterArn" type:"string"` // The Amazon Resource Name (ARN) of the container instances that host the task. ContainerInstanceArn *string `locationName:"containerInstanceArn" type:"string"` // The containers associated with the task. Containers []*Container `locationName:"containers" type:"list"` // The Unix time in seconds and milliseconds when the task was created (the // task entered the PENDING state). CreatedAt *time.Time `locationName:"createdAt" type:"timestamp" timestampFormat:"unix"` // The desired status of the task. DesiredStatus *string `locationName:"desiredStatus" type:"string"` // The last known status of the task. LastStatus *string `locationName:"lastStatus" type:"string"` // One or more container overrides. Overrides *TaskOverride `locationName:"overrides" type:"structure"` // The Unix time in seconds and milliseconds when the task was started (the // task transitioned from the PENDING state to the RUNNING state). StartedAt *time.Time `locationName:"startedAt" type:"timestamp" timestampFormat:"unix"` // The tag specified when a task is started. If the task is started by an Amazon // ECS service, then the startedBy parameter contains the deployment ID of the // service that starts it. StartedBy *string `locationName:"startedBy" type:"string"` // The Unix time in seconds and milliseconds when the task was stopped (the // task transitioned from the RUNNING state to the STOPPED state). StoppedAt *time.Time `locationName:"stoppedAt" type:"timestamp" timestampFormat:"unix"` // The reason the task was stopped. StoppedReason *string `locationName:"stoppedReason" type:"string"` // The Amazon Resource Name (ARN) of the task. TaskArn *string `locationName:"taskArn" type:"string"` // The Amazon Resource Name (ARN) of the task definition that creates the task. TaskDefinitionArn *string `locationName:"taskDefinitionArn" type:"string"` } // String returns the string representation func (s Task) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Task) GoString() string { return s.String() } // Details of a task definition. type TaskDefinition struct { _ struct{} `type:"structure"` // A list of container definitions in JSON format that describe the different // containers that make up your task. For more information about container definition // parameters and defaults, see Amazon ECS Task Definitions (http://docs.aws.amazon.com/http:/docs.aws.amazon.com/AmazonECS/latest/developerguidetask_defintions.html) // in the Amazon EC2 Container Service Developer Guide. ContainerDefinitions []*ContainerDefinition `locationName:"containerDefinitions" type:"list"` // The family of your task definition, used as the definition name. Family *string `locationName:"family" type:"string"` // The container instance attributes required by your task. RequiresAttributes []*Attribute `locationName:"requiresAttributes" type:"list"` // The revision of the task in a particular family. The revision is a version // number of a task definition in a family. When you register a task definition // for the first time, the revision is 1; each time you register a new revision // of a task definition in the same family, the revision value always increases // by one (even if you have deregistered previous revisions in this family). Revision *int64 `locationName:"revision" type:"integer"` // The status of the task definition. Status *string `locationName:"status" type:"string" enum:"TaskDefinitionStatus"` // The full Amazon Resource Name (ARN) of the task definition. TaskDefinitionArn *string `locationName:"taskDefinitionArn" type:"string"` // The Amazon Resource Name (ARN) of the IAM role that containers in this task // can assume. All containers in this task are granted the permissions that // are specified in this role. TaskRoleArn *string `locationName:"taskRoleArn" type:"string"` // The list of volumes in a task. For more information about volume definition // parameters and defaults, see Amazon ECS Task Definitions (http://docs.aws.amazon.com/http:/docs.aws.amazon.com/AmazonECS/latest/developerguidetask_defintions.html) // in the Amazon EC2 Container Service Developer Guide. Volumes []*Volume `locationName:"volumes" type:"list"` } // String returns the string representation func (s TaskDefinition) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s TaskDefinition) GoString() string { return s.String() } // The overrides associated with a task. type TaskOverride struct { _ struct{} `type:"structure"` // One or more container overrides sent to a task. ContainerOverrides []*ContainerOverride `locationName:"containerOverrides" type:"list"` // The Amazon Resource Name (ARN) of the IAM role that containers in this task // can assume. All containers in this task are granted the permissions that // are specified in this role. TaskRoleArn *string `locationName:"taskRoleArn" type:"string"` } // String returns the string representation func (s TaskOverride) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s TaskOverride) GoString() string { return s.String() } // The ulimit settings to pass to the container. type Ulimit struct { _ struct{} `type:"structure"` // The hard limit for the ulimit type. HardLimit *int64 `locationName:"hardLimit" type:"integer" required:"true"` // The type of the ulimit. Name *string `locationName:"name" type:"string" required:"true" enum:"UlimitName"` // The soft limit for the ulimit type. SoftLimit *int64 `locationName:"softLimit" type:"integer" required:"true"` } // String returns the string representation func (s Ulimit) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Ulimit) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *Ulimit) Validate() error { invalidParams := request.ErrInvalidParams{Context: "Ulimit"} if s.HardLimit == nil { invalidParams.Add(request.NewErrParamRequired("HardLimit")) } if s.Name == nil { invalidParams.Add(request.NewErrParamRequired("Name")) } if s.SoftLimit == nil { invalidParams.Add(request.NewErrParamRequired("SoftLimit")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type UpdateContainerAgentInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that your // container instance is running on. If you do not specify a cluster, the default // cluster is assumed. Cluster *string `locationName:"cluster" type:"string"` // The container instance ID or full Amazon Resource Name (ARN) entries for // the container instance on which you would like to update the Amazon ECS container // agent. ContainerInstance *string `locationName:"containerInstance" type:"string" required:"true"` } // String returns the string representation func (s UpdateContainerAgentInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s UpdateContainerAgentInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *UpdateContainerAgentInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "UpdateContainerAgentInput"} if s.ContainerInstance == nil { invalidParams.Add(request.NewErrParamRequired("ContainerInstance")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type UpdateContainerAgentOutput struct { _ struct{} `type:"structure"` // An EC2 instance that is running the Amazon ECS agent and has been registered // with a cluster. ContainerInstance *ContainerInstance `locationName:"containerInstance" type:"structure"` } // String returns the string representation func (s UpdateContainerAgentOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s UpdateContainerAgentOutput) GoString() string { return s.String() } type UpdateServiceInput struct { _ struct{} `type:"structure"` // The short name or full Amazon Resource Name (ARN) of the cluster that your // service is running on. If you do not specify a cluster, the default cluster // is assumed. Cluster *string `locationName:"cluster" type:"string"` // Optional deployment parameters that control how many tasks run during the // deployment and the ordering of stopping and starting tasks. DeploymentConfiguration *DeploymentConfiguration `locationName:"deploymentConfiguration" type:"structure"` // The number of instantiations of the task to place and keep running in your // service. DesiredCount *int64 `locationName:"desiredCount" type:"integer"` // The name of the service to update. Service *string `locationName:"service" type:"string" required:"true"` // The family and revision (family:revision) or full Amazon Resource Name (ARN) // of the task definition to run in your service. If a revision is not specified, // the latest ACTIVE revision is used. If you modify the task definition with // UpdateService, Amazon ECS spawns a task with the new version of the task // definition and then stops an old task after the new version is running. TaskDefinition *string `locationName:"taskDefinition" type:"string"` } // String returns the string representation func (s UpdateServiceInput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s UpdateServiceInput) GoString() string { return s.String() } // Validate inspects the fields of the type to determine if they are valid. func (s *UpdateServiceInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "UpdateServiceInput"} if s.Service == nil { invalidParams.Add(request.NewErrParamRequired("Service")) } if invalidParams.Len() > 0 { return invalidParams } return nil } type UpdateServiceOutput struct { _ struct{} `type:"structure"` // The full description of your service following the update call. Service *Service `locationName:"service" type:"structure"` } // String returns the string representation func (s UpdateServiceOutput) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s UpdateServiceOutput) GoString() string { return s.String() } // The Docker and Amazon ECS container agent version information about a container // instance. type VersionInfo struct { _ struct{} `type:"structure"` // The Git commit hash for the Amazon ECS container agent build on the amazon-ecs-agent // (https://github.com/aws/amazon-ecs-agent/commits/master) GitHub repository. AgentHash *string `locationName:"agentHash" type:"string"` // The version number of the Amazon ECS container agent. AgentVersion *string `locationName:"agentVersion" type:"string"` // The Docker version running on the container instance. DockerVersion *string `locationName:"dockerVersion" type:"string"` } // String returns the string representation func (s VersionInfo) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s VersionInfo) GoString() string { return s.String() } // A data volume used in a task definition. type Volume struct { _ struct{} `type:"structure"` // The contents of the host parameter determine whether your data volume persists // on the host container instance and where it is stored. If the host parameter // is empty, then the Docker daemon assigns a host path for your data volume, // but the data is not guaranteed to persist after the containers associated // with it stop running. Host *HostVolumeProperties `locationName:"host" type:"structure"` // The name of the volume. Up to 255 letters (uppercase and lowercase), numbers, // hyphens, and underscores are allowed. This name is referenced in the sourceVolume // parameter of container definition mountPoints. Name *string `locationName:"name" type:"string"` } // String returns the string representation func (s Volume) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s Volume) GoString() string { return s.String() } // Details on a data volume from another container. type VolumeFrom struct { _ struct{} `type:"structure"` // If this value is true, the container has read-only access to the volume. // If this value is false, then the container can write to the volume. The default // value is false. ReadOnly *bool `locationName:"readOnly" type:"boolean"` // The name of the container to mount volumes from. SourceContainer *string `locationName:"sourceContainer" type:"string"` } // String returns the string representation func (s VolumeFrom) String() string { return awsutil.Prettify(s) } // GoString returns the string representation func (s VolumeFrom) GoString() string { return s.String() } const ( // @enum AgentUpdateStatus AgentUpdateStatusPending = "PENDING" // @enum AgentUpdateStatus AgentUpdateStatusStaging = "STAGING" // @enum AgentUpdateStatus AgentUpdateStatusStaged = "STAGED" // @enum AgentUpdateStatus AgentUpdateStatusUpdating = "UPDATING" // @enum AgentUpdateStatus AgentUpdateStatusUpdated = "UPDATED" // @enum AgentUpdateStatus AgentUpdateStatusFailed = "FAILED" ) const ( // @enum DesiredStatus DesiredStatusRunning = "RUNNING" // @enum DesiredStatus DesiredStatusPending = "PENDING" // @enum DesiredStatus DesiredStatusStopped = "STOPPED" ) const ( // @enum LogDriver LogDriverJsonFile = "json-file" // @enum LogDriver LogDriverSyslog = "syslog" // @enum LogDriver LogDriverJournald = "journald" // @enum LogDriver LogDriverGelf = "gelf" // @enum LogDriver LogDriverFluentd = "fluentd" // @enum LogDriver LogDriverAwslogs = "awslogs" ) const ( // @enum SortOrder SortOrderAsc = "ASC" // @enum SortOrder SortOrderDesc = "DESC" ) const ( // @enum TaskDefinitionFamilyStatus TaskDefinitionFamilyStatusActive = "ACTIVE" // @enum TaskDefinitionFamilyStatus TaskDefinitionFamilyStatusInactive = "INACTIVE" // @enum TaskDefinitionFamilyStatus TaskDefinitionFamilyStatusAll = "ALL" ) const ( // @enum TaskDefinitionStatus TaskDefinitionStatusActive = "ACTIVE" // @enum TaskDefinitionStatus TaskDefinitionStatusInactive = "INACTIVE" ) const ( // @enum TransportProtocol TransportProtocolTcp = "tcp" // @enum TransportProtocol TransportProtocolUdp = "udp" ) const ( // @enum UlimitName UlimitNameCore = "core" // @enum UlimitName UlimitNameCpu = "cpu" // @enum UlimitName UlimitNameData = "data" // @enum UlimitName UlimitNameFsize = "fsize" // @enum UlimitName UlimitNameLocks = "locks" // @enum UlimitName UlimitNameMemlock = "memlock" // @enum UlimitName UlimitNameMsgqueue = "msgqueue" // @enum UlimitName UlimitNameNice = "nice" // @enum UlimitName UlimitNameNofile = "nofile" // @enum UlimitName UlimitNameNproc = "nproc" // @enum UlimitName UlimitNameRss = "rss" // @enum UlimitName UlimitNameRtprio = "rtprio" // @enum UlimitName UlimitNameRttime = "rttime" // @enum UlimitName UlimitNameSigpending = "sigpending" // @enum UlimitName UlimitNameStack = "stack" )