/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace Aws { namespace ECS { namespace Model { /** */ class RegisterTaskDefinitionRequest : public ECSRequest { public: AWS_ECS_API RegisterTaskDefinitionRequest(); // Service request name is the Operation name which will send this request out, // each operation should has unique request name, so that we can get operation's name from this request. // Note: this is not true for response, multiple operations may have the same response name, // so we can not get operation's name from response. inline virtual const char* GetServiceRequestName() const override { return "RegisterTaskDefinition"; } AWS_ECS_API Aws::String SerializePayload() const override; AWS_ECS_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override; /** *

You must specify a family for a task definition. You can use it * 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, underscores, and hyphens are allowed.

*/ inline const Aws::String& GetFamily() const{ return m_family; } /** *

*/ inline bool FamilyHasBeenSet() const { return m_familyHasBeenSet; } /** *

*/ inline void SetFamily(const Aws::String& value) { m_familyHasBeenSet = true; m_family = value; } /** *

*/ inline void SetFamily(Aws::String&& value) { m_familyHasBeenSet = true; m_family = std::move(value); } /** *

*/ inline void SetFamily(const char* value) { m_familyHasBeenSet = true; m_family.assign(value); } /** *

*/ inline RegisterTaskDefinitionRequest& WithFamily(const Aws::String& value) { SetFamily(value); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& WithFamily(Aws::String&& value) { SetFamily(std::move(value)); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& WithFamily(const char* value) { SetFamily(value); return *this;} /** *

The short name or full 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. For more information, see IAM * Roles for Tasks in the Amazon Elastic Container Service Developer * Guide.

*/ inline const Aws::String& GetTaskRoleArn() const{ return m_taskRoleArn; } /** *

*/ inline bool TaskRoleArnHasBeenSet() const { return m_taskRoleArnHasBeenSet; } /** *

*/ inline void SetTaskRoleArn(const Aws::String& value) { m_taskRoleArnHasBeenSet = true; m_taskRoleArn = value; } /** *

*/ inline void SetTaskRoleArn(Aws::String&& value) { m_taskRoleArnHasBeenSet = true; m_taskRoleArn = std::move(value); } /** *

*/ inline void SetTaskRoleArn(const char* value) { m_taskRoleArnHasBeenSet = true; m_taskRoleArn.assign(value); } /** *

*/ inline RegisterTaskDefinitionRequest& WithTaskRoleArn(const Aws::String& value) { SetTaskRoleArn(value); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& WithTaskRoleArn(Aws::String&& value) { SetTaskRoleArn(std::move(value)); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& WithTaskRoleArn(const char* value) { SetTaskRoleArn(value); return *this;} /** *

The Amazon Resource Name (ARN) of the task execution role that grants the * Amazon ECS container agent permission to make Amazon Web Services API calls on * your behalf. The task execution IAM role is required depending on the * requirements of your task. For more information, see Amazon * ECS task execution IAM role in the Amazon Elastic Container Service * Developer Guide.

*/ inline const Aws::String& GetExecutionRoleArn() const{ return m_executionRoleArn; } /** *

*/ inline bool ExecutionRoleArnHasBeenSet() const { return m_executionRoleArnHasBeenSet; } /** *

*/ inline void SetExecutionRoleArn(const Aws::String& value) { m_executionRoleArnHasBeenSet = true; m_executionRoleArn = value; } /** *

*/ inline void SetExecutionRoleArn(Aws::String&& value) { m_executionRoleArnHasBeenSet = true; m_executionRoleArn = std::move(value); } /** *

*/ inline void SetExecutionRoleArn(const char* value) { m_executionRoleArnHasBeenSet = true; m_executionRoleArn.assign(value); } /** *

*/ inline RegisterTaskDefinitionRequest& WithExecutionRoleArn(const Aws::String& value) { SetExecutionRoleArn(value); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& WithExecutionRoleArn(Aws::String&& value) { SetExecutionRoleArn(std::move(value)); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& WithExecutionRoleArn(const char* value) { SetExecutionRoleArn(value); return *this;} /** *

The Docker networking mode to use for the containers in the task. The valid * values are none, bridge, awsvpc, and * host. If no network mode is specified, the default is * bridge.

For Amazon ECS tasks on Fargate, the * awsvpc network mode is required. For Amazon ECS tasks on Amazon EC2 * Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon * EC2 Windows instances, <default> or awsvpc can * be used. If the network mode is set to none, you cannot specify * port mappings in your container definitions, and the tasks containers do not * have external connectivity. The host and awsvpc * network modes offer the highest networking performance for containers because * they use the EC2 network stack instead of the virtualized network stack provided * by the bridge mode.

With the host and * awsvpc network modes, exposed container ports are mapped directly * to the corresponding host port (for the host network mode) or the * attached elastic network interface port (for the awsvpc network * mode), so you cannot take advantage of dynamic host port mappings.

When using the host network mode, you should not run * containers using the root user (UID 0). It is considered best practice to use a * non-root user.

If the network mode is awsvpc, * the task is allocated an elastic network interface, and you must specify a * NetworkConfiguration value when you create a service or run a task with * the task definition. For more information, see Task * Networking in the Amazon Elastic Container Service Developer * Guide.

If the network mode is host, you cannot run * multiple instantiations of the same task on a single container instance when * port mappings are used.

For more information, see Network * settings in the Docker run reference.

*/ inline const NetworkMode& GetNetworkMode() const{ return m_networkMode; } /** *

The Docker networking mode to use for the containers in the task. The valid * values are none, bridge, awsvpc, and * host. If no network mode is specified, the default is * bridge.

When using the host network mode, you should not run * containers using the root user (UID 0). It is considered best practice to use a * non-root user.

If the network mode is host, you cannot run * multiple instantiations of the same task on a single container instance when * port mappings are used.

For more information, see Network * settings in the Docker run reference.

*/ inline bool NetworkModeHasBeenSet() const { return m_networkModeHasBeenSet; } /** *

The Docker networking mode to use for the containers in the task. The valid * values are none, bridge, awsvpc, and * host. If no network mode is specified, the default is * bridge.

When using the host network mode, you should not run * containers using the root user (UID 0). It is considered best practice to use a * non-root user.

If the network mode is host, you cannot run * multiple instantiations of the same task on a single container instance when * port mappings are used.

For more information, see Network * settings in the Docker run reference.

*/ inline void SetNetworkMode(const NetworkMode& value) { m_networkModeHasBeenSet = true; m_networkMode = value; } /** *

The Docker networking mode to use for the containers in the task. The valid * values are none, bridge, awsvpc, and * host. If no network mode is specified, the default is * bridge.

When using the host network mode, you should not run * containers using the root user (UID 0). It is considered best practice to use a * non-root user.

If the network mode is host, you cannot run * multiple instantiations of the same task on a single container instance when * port mappings are used.

For more information, see Network * settings in the Docker run reference.

*/ inline void SetNetworkMode(NetworkMode&& value) { m_networkModeHasBeenSet = true; m_networkMode = std::move(value); } /** *

The Docker networking mode to use for the containers in the task. The valid * values are none, bridge, awsvpc, and * host. If no network mode is specified, the default is * bridge.

When using the host network mode, you should not run * containers using the root user (UID 0). It is considered best practice to use a * non-root user.

If the network mode is host, you cannot run * multiple instantiations of the same task on a single container instance when * port mappings are used.

For more information, see Network * settings in the Docker run reference.

*/ inline RegisterTaskDefinitionRequest& WithNetworkMode(const NetworkMode& value) { SetNetworkMode(value); return *this;} /** *

The Docker networking mode to use for the containers in the task. The valid * values are none, bridge, awsvpc, and * host. If no network mode is specified, the default is * bridge.

When using the host network mode, you should not run * containers using the root user (UID 0). It is considered best practice to use a * non-root user.

If the network mode is host, you cannot run * multiple instantiations of the same task on a single container instance when * port mappings are used.

For more information, see Network * settings in the Docker run reference.

*/ inline RegisterTaskDefinitionRequest& WithNetworkMode(NetworkMode&& value) { SetNetworkMode(std::move(value)); return *this;} /** *

A list of container definitions in JSON format that describe the different * containers that make up your task.

*/ inline const Aws::Vector& GetContainerDefinitions() const{ return m_containerDefinitions; } /** *

A list of container definitions in JSON format that describe the different * containers that make up your task.

*/ inline bool ContainerDefinitionsHasBeenSet() const { return m_containerDefinitionsHasBeenSet; } /** *

A list of container definitions in JSON format that describe the different * containers that make up your task.

*/ inline void SetContainerDefinitions(const Aws::Vector& value) { m_containerDefinitionsHasBeenSet = true; m_containerDefinitions = value; } /** *

A list of container definitions in JSON format that describe the different * containers that make up your task.

*/ inline void SetContainerDefinitions(Aws::Vector&& value) { m_containerDefinitionsHasBeenSet = true; m_containerDefinitions = std::move(value); } /** *

A list of container definitions in JSON format that describe the different * containers that make up your task.

*/ inline RegisterTaskDefinitionRequest& WithContainerDefinitions(const Aws::Vector& value) { SetContainerDefinitions(value); return *this;} /** *

A list of container definitions in JSON format that describe the different * containers that make up your task.

*/ inline RegisterTaskDefinitionRequest& WithContainerDefinitions(Aws::Vector&& value) { SetContainerDefinitions(std::move(value)); return *this;} /** *

A list of container definitions in JSON format that describe the different * containers that make up your task.

*/ inline RegisterTaskDefinitionRequest& AddContainerDefinitions(const ContainerDefinition& value) { m_containerDefinitionsHasBeenSet = true; m_containerDefinitions.push_back(value); return *this; } /** *

A list of container definitions in JSON format that describe the different * containers that make up your task.

*/ inline RegisterTaskDefinitionRequest& AddContainerDefinitions(ContainerDefinition&& value) { m_containerDefinitionsHasBeenSet = true; m_containerDefinitions.push_back(std::move(value)); return *this; } /** *

A list of volume definitions in JSON format that containers in your task * might use.

*/ inline const Aws::Vector& GetVolumes() const{ return m_volumes; } /** *

A list of volume definitions in JSON format that containers in your task * might use.

*/ inline bool VolumesHasBeenSet() const { return m_volumesHasBeenSet; } /** *

A list of volume definitions in JSON format that containers in your task * might use.

*/ inline void SetVolumes(const Aws::Vector& value) { m_volumesHasBeenSet = true; m_volumes = value; } /** *

A list of volume definitions in JSON format that containers in your task * might use.

*/ inline void SetVolumes(Aws::Vector&& value) { m_volumesHasBeenSet = true; m_volumes = std::move(value); } /** *

A list of volume definitions in JSON format that containers in your task * might use.

*/ inline RegisterTaskDefinitionRequest& WithVolumes(const Aws::Vector& value) { SetVolumes(value); return *this;} /** *

A list of volume definitions in JSON format that containers in your task * might use.

*/ inline RegisterTaskDefinitionRequest& WithVolumes(Aws::Vector&& value) { SetVolumes(std::move(value)); return *this;} /** *

A list of volume definitions in JSON format that containers in your task * might use.

*/ inline RegisterTaskDefinitionRequest& AddVolumes(const Volume& value) { m_volumesHasBeenSet = true; m_volumes.push_back(value); return *this; } /** *

A list of volume definitions in JSON format that containers in your task * might use.

*/ inline RegisterTaskDefinitionRequest& AddVolumes(Volume&& value) { m_volumesHasBeenSet = true; m_volumes.push_back(std::move(value)); return *this; } /** *

An array of placement constraint objects to use for the task. You can specify * a maximum of 10 constraints for each task. This limit includes constraints in * the task definition and those specified at runtime.

*/ inline const Aws::Vector& GetPlacementConstraints() const{ return m_placementConstraints; } /** *

*/ inline bool PlacementConstraintsHasBeenSet() const { return m_placementConstraintsHasBeenSet; } /** *

*/ inline void SetPlacementConstraints(const Aws::Vector& value) { m_placementConstraintsHasBeenSet = true; m_placementConstraints = value; } /** *

*/ inline void SetPlacementConstraints(Aws::Vector&& value) { m_placementConstraintsHasBeenSet = true; m_placementConstraints = std::move(value); } /** *

*/ inline RegisterTaskDefinitionRequest& WithPlacementConstraints(const Aws::Vector& value) { SetPlacementConstraints(value); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& WithPlacementConstraints(Aws::Vector&& value) { SetPlacementConstraints(std::move(value)); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& AddPlacementConstraints(const TaskDefinitionPlacementConstraint& value) { m_placementConstraintsHasBeenSet = true; m_placementConstraints.push_back(value); return *this; } /** *

*/ inline RegisterTaskDefinitionRequest& AddPlacementConstraints(TaskDefinitionPlacementConstraint&& value) { m_placementConstraintsHasBeenSet = true; m_placementConstraints.push_back(std::move(value)); return *this; } /** *

The task launch type that Amazon ECS validates the task definition against. A * client exception is returned if the task definition doesn't validate against the * compatibilities specified. If no value is specified, the parameter is omitted * from the response.

*/ inline const Aws::Vector& GetRequiresCompatibilities() const{ return m_requiresCompatibilities; } /** *

*/ inline bool RequiresCompatibilitiesHasBeenSet() const { return m_requiresCompatibilitiesHasBeenSet; } /** *

*/ inline void SetRequiresCompatibilities(const Aws::Vector& value) { m_requiresCompatibilitiesHasBeenSet = true; m_requiresCompatibilities = value; } /** *

*/ inline void SetRequiresCompatibilities(Aws::Vector&& value) { m_requiresCompatibilitiesHasBeenSet = true; m_requiresCompatibilities = std::move(value); } /** *

*/ inline RegisterTaskDefinitionRequest& WithRequiresCompatibilities(const Aws::Vector& value) { SetRequiresCompatibilities(value); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& WithRequiresCompatibilities(Aws::Vector&& value) { SetRequiresCompatibilities(std::move(value)); return *this;} /** *

*/ inline RegisterTaskDefinitionRequest& AddRequiresCompatibilities(const Compatibility& value) { m_requiresCompatibilitiesHasBeenSet = true; m_requiresCompatibilities.push_back(value); return *this; } /** *

*/ inline RegisterTaskDefinitionRequest& AddRequiresCompatibilities(Compatibility&& value) { m_requiresCompatibilitiesHasBeenSet = true; m_requiresCompatibilities.push_back(std::move(value)); return *this; } /** *

The number of CPU units used by the task. It can be expressed as an integer * using CPU units (for example, 1024) or as a string using vCPUs (for * example, 1 vCPU or 1 vcpu) in a task definition. * String values are converted to an integer indicating the CPU units when the task * definition is registered.

Task-level CPU and memory parameters are * ignored for Windows containers. We recommend specifying container-level * resources for Windows containers.

If you're using the EC2 launch * type, this field is optional. Supported values are between 128 CPU * units (0.125 vCPUs) and 10240 CPU units * (10 vCPUs). If you do not specify a value, the parameter is * ignored.

If you're using the Fargate launch type, this field is required * and you must use one of the following values, which determines your range of * supported values for the memory parameter: