1 /** 2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 * SPDX-License-Identifier: Apache-2.0. 4 */ 5 6 #pragma once 7 #include <aws/ecs/ECS_EXPORTS.h> 8 #include <aws/ecs/ECSRequest.h> 9 #include <aws/core/utils/memory/stl/AWSString.h> 10 #include <aws/ecs/model/NetworkMode.h> 11 #include <aws/core/utils/memory/stl/AWSVector.h> 12 #include <aws/ecs/model/PidMode.h> 13 #include <aws/ecs/model/IpcMode.h> 14 #include <aws/ecs/model/ProxyConfiguration.h> 15 #include <aws/ecs/model/EphemeralStorage.h> 16 #include <aws/ecs/model/ContainerDefinition.h> 17 #include <aws/ecs/model/Volume.h> 18 #include <aws/ecs/model/TaskDefinitionPlacementConstraint.h> 19 #include <aws/ecs/model/Compatibility.h> 20 #include <aws/ecs/model/Tag.h> 21 #include <aws/ecs/model/InferenceAccelerator.h> 22 #include <utility> 23 24 namespace Aws 25 { 26 namespace ECS 27 { 28 namespace Model 29 { 30 31 /** 32 */ 33 class AWS_ECS_API RegisterTaskDefinitionRequest : public ECSRequest 34 { 35 public: 36 RegisterTaskDefinitionRequest(); 37 38 // Service request name is the Operation name which will send this request out, 39 // each operation should has unique request name, so that we can get operation's name from this request. 40 // Note: this is not true for response, multiple operations may have the same response name, 41 // so we can not get operation's name from response. GetServiceRequestName()42 inline virtual const char* GetServiceRequestName() const override { return "RegisterTaskDefinition"; } 43 44 Aws::String SerializePayload() const override; 45 46 Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override; 47 48 49 /** 50 * <p>You must specify a <code>family</code> for a task definition, which allows 51 * you to track multiple versions of the same task definition. The 52 * <code>family</code> is used as a name for your task definition. Up to 255 53 * letters (uppercase and lowercase), numbers, underscores, and hyphens are 54 * allowed.</p> 55 */ GetFamily()56 inline const Aws::String& GetFamily() const{ return m_family; } 57 58 /** 59 * <p>You must specify a <code>family</code> for a task definition, which allows 60 * you to track multiple versions of the same task definition. The 61 * <code>family</code> is used as a name for your task definition. Up to 255 62 * letters (uppercase and lowercase), numbers, underscores, and hyphens are 63 * allowed.</p> 64 */ FamilyHasBeenSet()65 inline bool FamilyHasBeenSet() const { return m_familyHasBeenSet; } 66 67 /** 68 * <p>You must specify a <code>family</code> for a task definition, which allows 69 * you to track multiple versions of the same task definition. The 70 * <code>family</code> is used as a name for your task definition. Up to 255 71 * letters (uppercase and lowercase), numbers, underscores, and hyphens are 72 * allowed.</p> 73 */ SetFamily(const Aws::String & value)74 inline void SetFamily(const Aws::String& value) { m_familyHasBeenSet = true; m_family = value; } 75 76 /** 77 * <p>You must specify a <code>family</code> for a task definition, which allows 78 * you to track multiple versions of the same task definition. The 79 * <code>family</code> is used as a name for your task definition. Up to 255 80 * letters (uppercase and lowercase), numbers, underscores, and hyphens are 81 * allowed.</p> 82 */ SetFamily(Aws::String && value)83 inline void SetFamily(Aws::String&& value) { m_familyHasBeenSet = true; m_family = std::move(value); } 84 85 /** 86 * <p>You must specify a <code>family</code> for a task definition, which allows 87 * you to track multiple versions of the same task definition. The 88 * <code>family</code> is used as a name for your task definition. Up to 255 89 * letters (uppercase and lowercase), numbers, underscores, and hyphens are 90 * allowed.</p> 91 */ SetFamily(const char * value)92 inline void SetFamily(const char* value) { m_familyHasBeenSet = true; m_family.assign(value); } 93 94 /** 95 * <p>You must specify a <code>family</code> for a task definition, which allows 96 * you to track multiple versions of the same task definition. The 97 * <code>family</code> is used as a name for your task definition. Up to 255 98 * letters (uppercase and lowercase), numbers, underscores, and hyphens are 99 * allowed.</p> 100 */ WithFamily(const Aws::String & value)101 inline RegisterTaskDefinitionRequest& WithFamily(const Aws::String& value) { SetFamily(value); return *this;} 102 103 /** 104 * <p>You must specify a <code>family</code> for a task definition, which allows 105 * you to track multiple versions of the same task definition. The 106 * <code>family</code> is used as a name for your task definition. Up to 255 107 * letters (uppercase and lowercase), numbers, underscores, and hyphens are 108 * allowed.</p> 109 */ WithFamily(Aws::String && value)110 inline RegisterTaskDefinitionRequest& WithFamily(Aws::String&& value) { SetFamily(std::move(value)); return *this;} 111 112 /** 113 * <p>You must specify a <code>family</code> for a task definition, which allows 114 * you to track multiple versions of the same task definition. The 115 * <code>family</code> is used as a name for your task definition. Up to 255 116 * letters (uppercase and lowercase), numbers, underscores, and hyphens are 117 * allowed.</p> 118 */ WithFamily(const char * value)119 inline RegisterTaskDefinitionRequest& WithFamily(const char* value) { SetFamily(value); return *this;} 120 121 122 /** 123 * <p>The short name or full Amazon Resource Name (ARN) of the IAM role that 124 * containers in this task can assume. All containers in this task are granted the 125 * permissions that are specified in this role. For more information, see <a 126 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 127 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 128 * Guide</i>.</p> 129 */ GetTaskRoleArn()130 inline const Aws::String& GetTaskRoleArn() const{ return m_taskRoleArn; } 131 132 /** 133 * <p>The short name or full Amazon Resource Name (ARN) of the IAM role that 134 * containers in this task can assume. All containers in this task are granted the 135 * permissions that are specified in this role. For more information, see <a 136 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 137 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 138 * Guide</i>.</p> 139 */ TaskRoleArnHasBeenSet()140 inline bool TaskRoleArnHasBeenSet() const { return m_taskRoleArnHasBeenSet; } 141 142 /** 143 * <p>The short name or full Amazon Resource Name (ARN) of the IAM role that 144 * containers in this task can assume. All containers in this task are granted the 145 * permissions that are specified in this role. For more information, see <a 146 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 147 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 148 * Guide</i>.</p> 149 */ SetTaskRoleArn(const Aws::String & value)150 inline void SetTaskRoleArn(const Aws::String& value) { m_taskRoleArnHasBeenSet = true; m_taskRoleArn = value; } 151 152 /** 153 * <p>The short name or full Amazon Resource Name (ARN) of the IAM role that 154 * containers in this task can assume. All containers in this task are granted the 155 * permissions that are specified in this role. For more information, see <a 156 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 157 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 158 * Guide</i>.</p> 159 */ SetTaskRoleArn(Aws::String && value)160 inline void SetTaskRoleArn(Aws::String&& value) { m_taskRoleArnHasBeenSet = true; m_taskRoleArn = std::move(value); } 161 162 /** 163 * <p>The short name or full Amazon Resource Name (ARN) of the IAM role that 164 * containers in this task can assume. All containers in this task are granted the 165 * permissions that are specified in this role. For more information, see <a 166 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 167 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 168 * Guide</i>.</p> 169 */ SetTaskRoleArn(const char * value)170 inline void SetTaskRoleArn(const char* value) { m_taskRoleArnHasBeenSet = true; m_taskRoleArn.assign(value); } 171 172 /** 173 * <p>The short name or full Amazon Resource Name (ARN) of the IAM role that 174 * containers in this task can assume. All containers in this task are granted the 175 * permissions that are specified in this role. For more information, see <a 176 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 177 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 178 * Guide</i>.</p> 179 */ WithTaskRoleArn(const Aws::String & value)180 inline RegisterTaskDefinitionRequest& WithTaskRoleArn(const Aws::String& value) { SetTaskRoleArn(value); return *this;} 181 182 /** 183 * <p>The short name or full Amazon Resource Name (ARN) of the IAM role that 184 * containers in this task can assume. All containers in this task are granted the 185 * permissions that are specified in this role. For more information, see <a 186 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 187 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 188 * Guide</i>.</p> 189 */ WithTaskRoleArn(Aws::String && value)190 inline RegisterTaskDefinitionRequest& WithTaskRoleArn(Aws::String&& value) { SetTaskRoleArn(std::move(value)); return *this;} 191 192 /** 193 * <p>The short name or full Amazon Resource Name (ARN) of the IAM role that 194 * containers in this task can assume. All containers in this task are granted the 195 * permissions that are specified in this role. For more information, see <a 196 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 197 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 198 * Guide</i>.</p> 199 */ WithTaskRoleArn(const char * value)200 inline RegisterTaskDefinitionRequest& WithTaskRoleArn(const char* value) { SetTaskRoleArn(value); return *this;} 201 202 203 /** 204 * <p>The Amazon Resource Name (ARN) of the task execution role that grants the 205 * Amazon ECS container agent permission to make Amazon Web Services API calls on 206 * your behalf. The task execution IAM role is required depending on the 207 * requirements of your task. For more information, see <a 208 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon 209 * ECS task execution IAM role</a> in the <i>Amazon Elastic Container Service 210 * Developer Guide</i>.</p> 211 */ GetExecutionRoleArn()212 inline const Aws::String& GetExecutionRoleArn() const{ return m_executionRoleArn; } 213 214 /** 215 * <p>The Amazon Resource Name (ARN) of the task execution role that grants the 216 * Amazon ECS container agent permission to make Amazon Web Services API calls on 217 * your behalf. The task execution IAM role is required depending on the 218 * requirements of your task. For more information, see <a 219 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon 220 * ECS task execution IAM role</a> in the <i>Amazon Elastic Container Service 221 * Developer Guide</i>.</p> 222 */ ExecutionRoleArnHasBeenSet()223 inline bool ExecutionRoleArnHasBeenSet() const { return m_executionRoleArnHasBeenSet; } 224 225 /** 226 * <p>The Amazon Resource Name (ARN) of the task execution role that grants the 227 * Amazon ECS container agent permission to make Amazon Web Services API calls on 228 * your behalf. The task execution IAM role is required depending on the 229 * requirements of your task. For more information, see <a 230 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon 231 * ECS task execution IAM role</a> in the <i>Amazon Elastic Container Service 232 * Developer Guide</i>.</p> 233 */ SetExecutionRoleArn(const Aws::String & value)234 inline void SetExecutionRoleArn(const Aws::String& value) { m_executionRoleArnHasBeenSet = true; m_executionRoleArn = value; } 235 236 /** 237 * <p>The Amazon Resource Name (ARN) of the task execution role that grants the 238 * Amazon ECS container agent permission to make Amazon Web Services API calls on 239 * your behalf. The task execution IAM role is required depending on the 240 * requirements of your task. For more information, see <a 241 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon 242 * ECS task execution IAM role</a> in the <i>Amazon Elastic Container Service 243 * Developer Guide</i>.</p> 244 */ SetExecutionRoleArn(Aws::String && value)245 inline void SetExecutionRoleArn(Aws::String&& value) { m_executionRoleArnHasBeenSet = true; m_executionRoleArn = std::move(value); } 246 247 /** 248 * <p>The Amazon Resource Name (ARN) of the task execution role that grants the 249 * Amazon ECS container agent permission to make Amazon Web Services API calls on 250 * your behalf. The task execution IAM role is required depending on the 251 * requirements of your task. For more information, see <a 252 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon 253 * ECS task execution IAM role</a> in the <i>Amazon Elastic Container Service 254 * Developer Guide</i>.</p> 255 */ SetExecutionRoleArn(const char * value)256 inline void SetExecutionRoleArn(const char* value) { m_executionRoleArnHasBeenSet = true; m_executionRoleArn.assign(value); } 257 258 /** 259 * <p>The Amazon Resource Name (ARN) of the task execution role that grants the 260 * Amazon ECS container agent permission to make Amazon Web Services API calls on 261 * your behalf. The task execution IAM role is required depending on the 262 * requirements of your task. For more information, see <a 263 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon 264 * ECS task execution IAM role</a> in the <i>Amazon Elastic Container Service 265 * Developer Guide</i>.</p> 266 */ WithExecutionRoleArn(const Aws::String & value)267 inline RegisterTaskDefinitionRequest& WithExecutionRoleArn(const Aws::String& value) { SetExecutionRoleArn(value); return *this;} 268 269 /** 270 * <p>The Amazon Resource Name (ARN) of the task execution role that grants the 271 * Amazon ECS container agent permission to make Amazon Web Services API calls on 272 * your behalf. The task execution IAM role is required depending on the 273 * requirements of your task. For more information, see <a 274 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon 275 * ECS task execution IAM role</a> in the <i>Amazon Elastic Container Service 276 * Developer Guide</i>.</p> 277 */ WithExecutionRoleArn(Aws::String && value)278 inline RegisterTaskDefinitionRequest& WithExecutionRoleArn(Aws::String&& value) { SetExecutionRoleArn(std::move(value)); return *this;} 279 280 /** 281 * <p>The Amazon Resource Name (ARN) of the task execution role that grants the 282 * Amazon ECS container agent permission to make Amazon Web Services API calls on 283 * your behalf. The task execution IAM role is required depending on the 284 * requirements of your task. For more information, see <a 285 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon 286 * ECS task execution IAM role</a> in the <i>Amazon Elastic Container Service 287 * Developer Guide</i>.</p> 288 */ WithExecutionRoleArn(const char * value)289 inline RegisterTaskDefinitionRequest& WithExecutionRoleArn(const char* value) { SetExecutionRoleArn(value); return *this;} 290 291 292 /** 293 * <p>The Docker networking mode to use for the containers in the task. The valid 294 * values are <code>none</code>, <code>bridge</code>, <code>awsvpc</code>, and 295 * <code>host</code>. If no network mode is specified, the default is 296 * <code>bridge</code>.</p> <p>For Amazon ECS tasks on Fargate, the 297 * <code>awsvpc</code> network mode is required. For Amazon ECS tasks on Amazon EC2 298 * Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon 299 * EC2 Windows instances, <code><default></code> or <code>awsvpc</code> can 300 * be used. If the network mode is set to <code>none</code>, you cannot specify 301 * port mappings in your container definitions, and the tasks containers do not 302 * have external connectivity. The <code>host</code> and <code>awsvpc</code> 303 * network modes offer the highest networking performance for containers because 304 * they use the EC2 network stack instead of the virtualized network stack provided 305 * by the <code>bridge</code> mode.</p> <p>With the <code>host</code> and 306 * <code>awsvpc</code> network modes, exposed container ports are mapped directly 307 * to the corresponding host port (for the <code>host</code> network mode) or the 308 * attached elastic network interface port (for the <code>awsvpc</code> network 309 * mode), so you cannot take advantage of dynamic host port mappings. </p> 310 * <p>When using the <code>host</code> network mode, you should not run 311 * containers using the root user (UID 0). It is considered best practice to use a 312 * non-root user.</p> <p>If the network mode is <code>awsvpc</code>, 313 * the task is allocated an elastic network interface, and you must specify a 314 * <a>NetworkConfiguration</a> value when you create a service or run a task with 315 * the task definition. For more information, see <a 316 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task 317 * Networking</a> in the <i>Amazon Elastic Container Service Developer 318 * Guide</i>.</p> <p>If the network mode is <code>host</code>, you cannot run 319 * multiple instantiations of the same task on a single container instance when 320 * port mappings are used.</p> <p>For more information, see <a 321 * href="https://docs.docker.com/engine/reference/run/#network-settings">Network 322 * settings</a> in the <i>Docker run reference</i>.</p> 323 */ GetNetworkMode()324 inline const NetworkMode& GetNetworkMode() const{ return m_networkMode; } 325 326 /** 327 * <p>The Docker networking mode to use for the containers in the task. The valid 328 * values are <code>none</code>, <code>bridge</code>, <code>awsvpc</code>, and 329 * <code>host</code>. If no network mode is specified, the default is 330 * <code>bridge</code>.</p> <p>For Amazon ECS tasks on Fargate, the 331 * <code>awsvpc</code> network mode is required. For Amazon ECS tasks on Amazon EC2 332 * Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon 333 * EC2 Windows instances, <code><default></code> or <code>awsvpc</code> can 334 * be used. If the network mode is set to <code>none</code>, you cannot specify 335 * port mappings in your container definitions, and the tasks containers do not 336 * have external connectivity. The <code>host</code> and <code>awsvpc</code> 337 * network modes offer the highest networking performance for containers because 338 * they use the EC2 network stack instead of the virtualized network stack provided 339 * by the <code>bridge</code> mode.</p> <p>With the <code>host</code> and 340 * <code>awsvpc</code> network modes, exposed container ports are mapped directly 341 * to the corresponding host port (for the <code>host</code> network mode) or the 342 * attached elastic network interface port (for the <code>awsvpc</code> network 343 * mode), so you cannot take advantage of dynamic host port mappings. </p> 344 * <p>When using the <code>host</code> network mode, you should not run 345 * containers using the root user (UID 0). It is considered best practice to use a 346 * non-root user.</p> <p>If the network mode is <code>awsvpc</code>, 347 * the task is allocated an elastic network interface, and you must specify a 348 * <a>NetworkConfiguration</a> value when you create a service or run a task with 349 * the task definition. For more information, see <a 350 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task 351 * Networking</a> in the <i>Amazon Elastic Container Service Developer 352 * Guide</i>.</p> <p>If the network mode is <code>host</code>, you cannot run 353 * multiple instantiations of the same task on a single container instance when 354 * port mappings are used.</p> <p>For more information, see <a 355 * href="https://docs.docker.com/engine/reference/run/#network-settings">Network 356 * settings</a> in the <i>Docker run reference</i>.</p> 357 */ NetworkModeHasBeenSet()358 inline bool NetworkModeHasBeenSet() const { return m_networkModeHasBeenSet; } 359 360 /** 361 * <p>The Docker networking mode to use for the containers in the task. The valid 362 * values are <code>none</code>, <code>bridge</code>, <code>awsvpc</code>, and 363 * <code>host</code>. If no network mode is specified, the default is 364 * <code>bridge</code>.</p> <p>For Amazon ECS tasks on Fargate, the 365 * <code>awsvpc</code> network mode is required. For Amazon ECS tasks on Amazon EC2 366 * Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon 367 * EC2 Windows instances, <code><default></code> or <code>awsvpc</code> can 368 * be used. If the network mode is set to <code>none</code>, you cannot specify 369 * port mappings in your container definitions, and the tasks containers do not 370 * have external connectivity. The <code>host</code> and <code>awsvpc</code> 371 * network modes offer the highest networking performance for containers because 372 * they use the EC2 network stack instead of the virtualized network stack provided 373 * by the <code>bridge</code> mode.</p> <p>With the <code>host</code> and 374 * <code>awsvpc</code> network modes, exposed container ports are mapped directly 375 * to the corresponding host port (for the <code>host</code> network mode) or the 376 * attached elastic network interface port (for the <code>awsvpc</code> network 377 * mode), so you cannot take advantage of dynamic host port mappings. </p> 378 * <p>When using the <code>host</code> network mode, you should not run 379 * containers using the root user (UID 0). It is considered best practice to use a 380 * non-root user.</p> <p>If the network mode is <code>awsvpc</code>, 381 * the task is allocated an elastic network interface, and you must specify a 382 * <a>NetworkConfiguration</a> value when you create a service or run a task with 383 * the task definition. For more information, see <a 384 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task 385 * Networking</a> in the <i>Amazon Elastic Container Service Developer 386 * Guide</i>.</p> <p>If the network mode is <code>host</code>, you cannot run 387 * multiple instantiations of the same task on a single container instance when 388 * port mappings are used.</p> <p>For more information, see <a 389 * href="https://docs.docker.com/engine/reference/run/#network-settings">Network 390 * settings</a> in the <i>Docker run reference</i>.</p> 391 */ SetNetworkMode(const NetworkMode & value)392 inline void SetNetworkMode(const NetworkMode& value) { m_networkModeHasBeenSet = true; m_networkMode = value; } 393 394 /** 395 * <p>The Docker networking mode to use for the containers in the task. The valid 396 * values are <code>none</code>, <code>bridge</code>, <code>awsvpc</code>, and 397 * <code>host</code>. If no network mode is specified, the default is 398 * <code>bridge</code>.</p> <p>For Amazon ECS tasks on Fargate, the 399 * <code>awsvpc</code> network mode is required. For Amazon ECS tasks on Amazon EC2 400 * Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon 401 * EC2 Windows instances, <code><default></code> or <code>awsvpc</code> can 402 * be used. If the network mode is set to <code>none</code>, you cannot specify 403 * port mappings in your container definitions, and the tasks containers do not 404 * have external connectivity. The <code>host</code> and <code>awsvpc</code> 405 * network modes offer the highest networking performance for containers because 406 * they use the EC2 network stack instead of the virtualized network stack provided 407 * by the <code>bridge</code> mode.</p> <p>With the <code>host</code> and 408 * <code>awsvpc</code> network modes, exposed container ports are mapped directly 409 * to the corresponding host port (for the <code>host</code> network mode) or the 410 * attached elastic network interface port (for the <code>awsvpc</code> network 411 * mode), so you cannot take advantage of dynamic host port mappings. </p> 412 * <p>When using the <code>host</code> network mode, you should not run 413 * containers using the root user (UID 0). It is considered best practice to use a 414 * non-root user.</p> <p>If the network mode is <code>awsvpc</code>, 415 * the task is allocated an elastic network interface, and you must specify a 416 * <a>NetworkConfiguration</a> value when you create a service or run a task with 417 * the task definition. For more information, see <a 418 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task 419 * Networking</a> in the <i>Amazon Elastic Container Service Developer 420 * Guide</i>.</p> <p>If the network mode is <code>host</code>, you cannot run 421 * multiple instantiations of the same task on a single container instance when 422 * port mappings are used.</p> <p>For more information, see <a 423 * href="https://docs.docker.com/engine/reference/run/#network-settings">Network 424 * settings</a> in the <i>Docker run reference</i>.</p> 425 */ SetNetworkMode(NetworkMode && value)426 inline void SetNetworkMode(NetworkMode&& value) { m_networkModeHasBeenSet = true; m_networkMode = std::move(value); } 427 428 /** 429 * <p>The Docker networking mode to use for the containers in the task. The valid 430 * values are <code>none</code>, <code>bridge</code>, <code>awsvpc</code>, and 431 * <code>host</code>. If no network mode is specified, the default is 432 * <code>bridge</code>.</p> <p>For Amazon ECS tasks on Fargate, the 433 * <code>awsvpc</code> network mode is required. For Amazon ECS tasks on Amazon EC2 434 * Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon 435 * EC2 Windows instances, <code><default></code> or <code>awsvpc</code> can 436 * be used. If the network mode is set to <code>none</code>, you cannot specify 437 * port mappings in your container definitions, and the tasks containers do not 438 * have external connectivity. The <code>host</code> and <code>awsvpc</code> 439 * network modes offer the highest networking performance for containers because 440 * they use the EC2 network stack instead of the virtualized network stack provided 441 * by the <code>bridge</code> mode.</p> <p>With the <code>host</code> and 442 * <code>awsvpc</code> network modes, exposed container ports are mapped directly 443 * to the corresponding host port (for the <code>host</code> network mode) or the 444 * attached elastic network interface port (for the <code>awsvpc</code> network 445 * mode), so you cannot take advantage of dynamic host port mappings. </p> 446 * <p>When using the <code>host</code> network mode, you should not run 447 * containers using the root user (UID 0). It is considered best practice to use a 448 * non-root user.</p> <p>If the network mode is <code>awsvpc</code>, 449 * the task is allocated an elastic network interface, and you must specify a 450 * <a>NetworkConfiguration</a> value when you create a service or run a task with 451 * the task definition. For more information, see <a 452 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task 453 * Networking</a> in the <i>Amazon Elastic Container Service Developer 454 * Guide</i>.</p> <p>If the network mode is <code>host</code>, you cannot run 455 * multiple instantiations of the same task on a single container instance when 456 * port mappings are used.</p> <p>For more information, see <a 457 * href="https://docs.docker.com/engine/reference/run/#network-settings">Network 458 * settings</a> in the <i>Docker run reference</i>.</p> 459 */ WithNetworkMode(const NetworkMode & value)460 inline RegisterTaskDefinitionRequest& WithNetworkMode(const NetworkMode& value) { SetNetworkMode(value); return *this;} 461 462 /** 463 * <p>The Docker networking mode to use for the containers in the task. The valid 464 * values are <code>none</code>, <code>bridge</code>, <code>awsvpc</code>, and 465 * <code>host</code>. If no network mode is specified, the default is 466 * <code>bridge</code>.</p> <p>For Amazon ECS tasks on Fargate, the 467 * <code>awsvpc</code> network mode is required. For Amazon ECS tasks on Amazon EC2 468 * Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon 469 * EC2 Windows instances, <code><default></code> or <code>awsvpc</code> can 470 * be used. If the network mode is set to <code>none</code>, you cannot specify 471 * port mappings in your container definitions, and the tasks containers do not 472 * have external connectivity. The <code>host</code> and <code>awsvpc</code> 473 * network modes offer the highest networking performance for containers because 474 * they use the EC2 network stack instead of the virtualized network stack provided 475 * by the <code>bridge</code> mode.</p> <p>With the <code>host</code> and 476 * <code>awsvpc</code> network modes, exposed container ports are mapped directly 477 * to the corresponding host port (for the <code>host</code> network mode) or the 478 * attached elastic network interface port (for the <code>awsvpc</code> network 479 * mode), so you cannot take advantage of dynamic host port mappings. </p> 480 * <p>When using the <code>host</code> network mode, you should not run 481 * containers using the root user (UID 0). It is considered best practice to use a 482 * non-root user.</p> <p>If the network mode is <code>awsvpc</code>, 483 * the task is allocated an elastic network interface, and you must specify a 484 * <a>NetworkConfiguration</a> value when you create a service or run a task with 485 * the task definition. For more information, see <a 486 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task 487 * Networking</a> in the <i>Amazon Elastic Container Service Developer 488 * Guide</i>.</p> <p>If the network mode is <code>host</code>, you cannot run 489 * multiple instantiations of the same task on a single container instance when 490 * port mappings are used.</p> <p>For more information, see <a 491 * href="https://docs.docker.com/engine/reference/run/#network-settings">Network 492 * settings</a> in the <i>Docker run reference</i>.</p> 493 */ WithNetworkMode(NetworkMode && value)494 inline RegisterTaskDefinitionRequest& WithNetworkMode(NetworkMode&& value) { SetNetworkMode(std::move(value)); return *this;} 495 496 497 /** 498 * <p>A list of container definitions in JSON format that describe the different 499 * containers that make up your task.</p> 500 */ GetContainerDefinitions()501 inline const Aws::Vector<ContainerDefinition>& GetContainerDefinitions() const{ return m_containerDefinitions; } 502 503 /** 504 * <p>A list of container definitions in JSON format that describe the different 505 * containers that make up your task.</p> 506 */ ContainerDefinitionsHasBeenSet()507 inline bool ContainerDefinitionsHasBeenSet() const { return m_containerDefinitionsHasBeenSet; } 508 509 /** 510 * <p>A list of container definitions in JSON format that describe the different 511 * containers that make up your task.</p> 512 */ SetContainerDefinitions(const Aws::Vector<ContainerDefinition> & value)513 inline void SetContainerDefinitions(const Aws::Vector<ContainerDefinition>& value) { m_containerDefinitionsHasBeenSet = true; m_containerDefinitions = value; } 514 515 /** 516 * <p>A list of container definitions in JSON format that describe the different 517 * containers that make up your task.</p> 518 */ SetContainerDefinitions(Aws::Vector<ContainerDefinition> && value)519 inline void SetContainerDefinitions(Aws::Vector<ContainerDefinition>&& value) { m_containerDefinitionsHasBeenSet = true; m_containerDefinitions = std::move(value); } 520 521 /** 522 * <p>A list of container definitions in JSON format that describe the different 523 * containers that make up your task.</p> 524 */ WithContainerDefinitions(const Aws::Vector<ContainerDefinition> & value)525 inline RegisterTaskDefinitionRequest& WithContainerDefinitions(const Aws::Vector<ContainerDefinition>& value) { SetContainerDefinitions(value); return *this;} 526 527 /** 528 * <p>A list of container definitions in JSON format that describe the different 529 * containers that make up your task.</p> 530 */ WithContainerDefinitions(Aws::Vector<ContainerDefinition> && value)531 inline RegisterTaskDefinitionRequest& WithContainerDefinitions(Aws::Vector<ContainerDefinition>&& value) { SetContainerDefinitions(std::move(value)); return *this;} 532 533 /** 534 * <p>A list of container definitions in JSON format that describe the different 535 * containers that make up your task.</p> 536 */ AddContainerDefinitions(const ContainerDefinition & value)537 inline RegisterTaskDefinitionRequest& AddContainerDefinitions(const ContainerDefinition& value) { m_containerDefinitionsHasBeenSet = true; m_containerDefinitions.push_back(value); return *this; } 538 539 /** 540 * <p>A list of container definitions in JSON format that describe the different 541 * containers that make up your task.</p> 542 */ AddContainerDefinitions(ContainerDefinition && value)543 inline RegisterTaskDefinitionRequest& AddContainerDefinitions(ContainerDefinition&& value) { m_containerDefinitionsHasBeenSet = true; m_containerDefinitions.push_back(std::move(value)); return *this; } 544 545 546 /** 547 * <p>A list of volume definitions in JSON format that containers in your task may 548 * use.</p> 549 */ GetVolumes()550 inline const Aws::Vector<Volume>& GetVolumes() const{ return m_volumes; } 551 552 /** 553 * <p>A list of volume definitions in JSON format that containers in your task may 554 * use.</p> 555 */ VolumesHasBeenSet()556 inline bool VolumesHasBeenSet() const { return m_volumesHasBeenSet; } 557 558 /** 559 * <p>A list of volume definitions in JSON format that containers in your task may 560 * use.</p> 561 */ SetVolumes(const Aws::Vector<Volume> & value)562 inline void SetVolumes(const Aws::Vector<Volume>& value) { m_volumesHasBeenSet = true; m_volumes = value; } 563 564 /** 565 * <p>A list of volume definitions in JSON format that containers in your task may 566 * use.</p> 567 */ SetVolumes(Aws::Vector<Volume> && value)568 inline void SetVolumes(Aws::Vector<Volume>&& value) { m_volumesHasBeenSet = true; m_volumes = std::move(value); } 569 570 /** 571 * <p>A list of volume definitions in JSON format that containers in your task may 572 * use.</p> 573 */ WithVolumes(const Aws::Vector<Volume> & value)574 inline RegisterTaskDefinitionRequest& WithVolumes(const Aws::Vector<Volume>& value) { SetVolumes(value); return *this;} 575 576 /** 577 * <p>A list of volume definitions in JSON format that containers in your task may 578 * use.</p> 579 */ WithVolumes(Aws::Vector<Volume> && value)580 inline RegisterTaskDefinitionRequest& WithVolumes(Aws::Vector<Volume>&& value) { SetVolumes(std::move(value)); return *this;} 581 582 /** 583 * <p>A list of volume definitions in JSON format that containers in your task may 584 * use.</p> 585 */ AddVolumes(const Volume & value)586 inline RegisterTaskDefinitionRequest& AddVolumes(const Volume& value) { m_volumesHasBeenSet = true; m_volumes.push_back(value); return *this; } 587 588 /** 589 * <p>A list of volume definitions in JSON format that containers in your task may 590 * use.</p> 591 */ AddVolumes(Volume && value)592 inline RegisterTaskDefinitionRequest& AddVolumes(Volume&& value) { m_volumesHasBeenSet = true; m_volumes.push_back(std::move(value)); return *this; } 593 594 595 /** 596 * <p>An array of placement constraint objects to use for the task. You can specify 597 * a maximum of 10 constraints per task (this limit includes constraints in the 598 * task definition and those specified at runtime).</p> 599 */ GetPlacementConstraints()600 inline const Aws::Vector<TaskDefinitionPlacementConstraint>& GetPlacementConstraints() const{ return m_placementConstraints; } 601 602 /** 603 * <p>An array of placement constraint objects to use for the task. You can specify 604 * a maximum of 10 constraints per task (this limit includes constraints in the 605 * task definition and those specified at runtime).</p> 606 */ PlacementConstraintsHasBeenSet()607 inline bool PlacementConstraintsHasBeenSet() const { return m_placementConstraintsHasBeenSet; } 608 609 /** 610 * <p>An array of placement constraint objects to use for the task. You can specify 611 * a maximum of 10 constraints per task (this limit includes constraints in the 612 * task definition and those specified at runtime).</p> 613 */ SetPlacementConstraints(const Aws::Vector<TaskDefinitionPlacementConstraint> & value)614 inline void SetPlacementConstraints(const Aws::Vector<TaskDefinitionPlacementConstraint>& value) { m_placementConstraintsHasBeenSet = true; m_placementConstraints = value; } 615 616 /** 617 * <p>An array of placement constraint objects to use for the task. You can specify 618 * a maximum of 10 constraints per task (this limit includes constraints in the 619 * task definition and those specified at runtime).</p> 620 */ SetPlacementConstraints(Aws::Vector<TaskDefinitionPlacementConstraint> && value)621 inline void SetPlacementConstraints(Aws::Vector<TaskDefinitionPlacementConstraint>&& value) { m_placementConstraintsHasBeenSet = true; m_placementConstraints = std::move(value); } 622 623 /** 624 * <p>An array of placement constraint objects to use for the task. You can specify 625 * a maximum of 10 constraints per task (this limit includes constraints in the 626 * task definition and those specified at runtime).</p> 627 */ WithPlacementConstraints(const Aws::Vector<TaskDefinitionPlacementConstraint> & value)628 inline RegisterTaskDefinitionRequest& WithPlacementConstraints(const Aws::Vector<TaskDefinitionPlacementConstraint>& value) { SetPlacementConstraints(value); return *this;} 629 630 /** 631 * <p>An array of placement constraint objects to use for the task. You can specify 632 * a maximum of 10 constraints per task (this limit includes constraints in the 633 * task definition and those specified at runtime).</p> 634 */ WithPlacementConstraints(Aws::Vector<TaskDefinitionPlacementConstraint> && value)635 inline RegisterTaskDefinitionRequest& WithPlacementConstraints(Aws::Vector<TaskDefinitionPlacementConstraint>&& value) { SetPlacementConstraints(std::move(value)); return *this;} 636 637 /** 638 * <p>An array of placement constraint objects to use for the task. You can specify 639 * a maximum of 10 constraints per task (this limit includes constraints in the 640 * task definition and those specified at runtime).</p> 641 */ AddPlacementConstraints(const TaskDefinitionPlacementConstraint & value)642 inline RegisterTaskDefinitionRequest& AddPlacementConstraints(const TaskDefinitionPlacementConstraint& value) { m_placementConstraintsHasBeenSet = true; m_placementConstraints.push_back(value); return *this; } 643 644 /** 645 * <p>An array of placement constraint objects to use for the task. You can specify 646 * a maximum of 10 constraints per task (this limit includes constraints in the 647 * task definition and those specified at runtime).</p> 648 */ AddPlacementConstraints(TaskDefinitionPlacementConstraint && value)649 inline RegisterTaskDefinitionRequest& AddPlacementConstraints(TaskDefinitionPlacementConstraint&& value) { m_placementConstraintsHasBeenSet = true; m_placementConstraints.push_back(std::move(value)); return *this; } 650 651 652 /** 653 * <p>The task launch type that Amazon ECS should validate the task definition 654 * against. A client exception is returned if the task definition doesn't validate 655 * against the compatibilities specified. If no value is specified, the parameter 656 * is omitted from the response.</p> 657 */ GetRequiresCompatibilities()658 inline const Aws::Vector<Compatibility>& GetRequiresCompatibilities() const{ return m_requiresCompatibilities; } 659 660 /** 661 * <p>The task launch type that Amazon ECS should validate the task definition 662 * against. A client exception is returned if the task definition doesn't validate 663 * against the compatibilities specified. If no value is specified, the parameter 664 * is omitted from the response.</p> 665 */ RequiresCompatibilitiesHasBeenSet()666 inline bool RequiresCompatibilitiesHasBeenSet() const { return m_requiresCompatibilitiesHasBeenSet; } 667 668 /** 669 * <p>The task launch type that Amazon ECS should validate the task definition 670 * against. A client exception is returned if the task definition doesn't validate 671 * against the compatibilities specified. If no value is specified, the parameter 672 * is omitted from the response.</p> 673 */ SetRequiresCompatibilities(const Aws::Vector<Compatibility> & value)674 inline void SetRequiresCompatibilities(const Aws::Vector<Compatibility>& value) { m_requiresCompatibilitiesHasBeenSet = true; m_requiresCompatibilities = value; } 675 676 /** 677 * <p>The task launch type that Amazon ECS should validate the task definition 678 * against. A client exception is returned if the task definition doesn't validate 679 * against the compatibilities specified. If no value is specified, the parameter 680 * is omitted from the response.</p> 681 */ SetRequiresCompatibilities(Aws::Vector<Compatibility> && value)682 inline void SetRequiresCompatibilities(Aws::Vector<Compatibility>&& value) { m_requiresCompatibilitiesHasBeenSet = true; m_requiresCompatibilities = std::move(value); } 683 684 /** 685 * <p>The task launch type that Amazon ECS should validate the task definition 686 * against. A client exception is returned if the task definition doesn't validate 687 * against the compatibilities specified. If no value is specified, the parameter 688 * is omitted from the response.</p> 689 */ WithRequiresCompatibilities(const Aws::Vector<Compatibility> & value)690 inline RegisterTaskDefinitionRequest& WithRequiresCompatibilities(const Aws::Vector<Compatibility>& value) { SetRequiresCompatibilities(value); return *this;} 691 692 /** 693 * <p>The task launch type that Amazon ECS should validate the task definition 694 * against. A client exception is returned if the task definition doesn't validate 695 * against the compatibilities specified. If no value is specified, the parameter 696 * is omitted from the response.</p> 697 */ WithRequiresCompatibilities(Aws::Vector<Compatibility> && value)698 inline RegisterTaskDefinitionRequest& WithRequiresCompatibilities(Aws::Vector<Compatibility>&& value) { SetRequiresCompatibilities(std::move(value)); return *this;} 699 700 /** 701 * <p>The task launch type that Amazon ECS should validate the task definition 702 * against. A client exception is returned if the task definition doesn't validate 703 * against the compatibilities specified. If no value is specified, the parameter 704 * is omitted from the response.</p> 705 */ AddRequiresCompatibilities(const Compatibility & value)706 inline RegisterTaskDefinitionRequest& AddRequiresCompatibilities(const Compatibility& value) { m_requiresCompatibilitiesHasBeenSet = true; m_requiresCompatibilities.push_back(value); return *this; } 707 708 /** 709 * <p>The task launch type that Amazon ECS should validate the task definition 710 * against. A client exception is returned if the task definition doesn't validate 711 * against the compatibilities specified. If no value is specified, the parameter 712 * is omitted from the response.</p> 713 */ AddRequiresCompatibilities(Compatibility && value)714 inline RegisterTaskDefinitionRequest& AddRequiresCompatibilities(Compatibility&& value) { m_requiresCompatibilitiesHasBeenSet = true; m_requiresCompatibilities.push_back(std::move(value)); return *this; } 715 716 717 /** 718 * <p>The number of CPU units used by the task. It can be expressed as an integer 719 * using CPU units, for example <code>1024</code>, or as a string using vCPUs, for 720 * example <code>1 vCPU</code> or <code>1 vcpu</code>, in a task definition. String 721 * values are converted to an integer indicating the CPU units when the task 722 * definition is registered.</p> <p>Task-level CPU and memory parameters are 723 * ignored for Windows containers. We recommend specifying container-level 724 * resources for Windows containers.</p> <p>If you are using the EC2 launch 725 * type, this field is optional. Supported values are between <code>128</code> CPU 726 * units (<code>0.125</code> vCPUs) and <code>10240</code> CPU units 727 * (<code>10</code> vCPUs).</p> <p>If you are using the Fargate launch type, this 728 * field is required and you must use one of the following values, which determines 729 * your range of supported values for the <code>memory</code> parameter:</p> <ul> 730 * <li> <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 731 * 1024 (1 GB), 2048 (2 GB)</p> </li> <li> <p>512 (.5 vCPU) - Available 732 * <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 733 * GB)</p> </li> <li> <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 734 * (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 735 * GB)</p> </li> <li> <p>2048 (2 vCPU) - Available <code>memory</code> values: 736 * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p> </li> 737 * <li> <p>4096 (4 vCPU) - Available <code>memory</code> values: Between 8192 (8 738 * GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p> </li> </ul> 739 */ GetCpu()740 inline const Aws::String& GetCpu() const{ return m_cpu; } 741 742 /** 743 * <p>The number of CPU units used by the task. It can be expressed as an integer 744 * using CPU units, for example <code>1024</code>, or as a string using vCPUs, for 745 * example <code>1 vCPU</code> or <code>1 vcpu</code>, in a task definition. String 746 * values are converted to an integer indicating the CPU units when the task 747 * definition is registered.</p> <p>Task-level CPU and memory parameters are 748 * ignored for Windows containers. We recommend specifying container-level 749 * resources for Windows containers.</p> <p>If you are using the EC2 launch 750 * type, this field is optional. Supported values are between <code>128</code> CPU 751 * units (<code>0.125</code> vCPUs) and <code>10240</code> CPU units 752 * (<code>10</code> vCPUs).</p> <p>If you are using the Fargate launch type, this 753 * field is required and you must use one of the following values, which determines 754 * your range of supported values for the <code>memory</code> parameter:</p> <ul> 755 * <li> <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 756 * 1024 (1 GB), 2048 (2 GB)</p> </li> <li> <p>512 (.5 vCPU) - Available 757 * <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 758 * GB)</p> </li> <li> <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 759 * (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 760 * GB)</p> </li> <li> <p>2048 (2 vCPU) - Available <code>memory</code> values: 761 * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p> </li> 762 * <li> <p>4096 (4 vCPU) - Available <code>memory</code> values: Between 8192 (8 763 * GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p> </li> </ul> 764 */ CpuHasBeenSet()765 inline bool CpuHasBeenSet() const { return m_cpuHasBeenSet; } 766 767 /** 768 * <p>The number of CPU units used by the task. It can be expressed as an integer 769 * using CPU units, for example <code>1024</code>, or as a string using vCPUs, for 770 * example <code>1 vCPU</code> or <code>1 vcpu</code>, in a task definition. String 771 * values are converted to an integer indicating the CPU units when the task 772 * definition is registered.</p> <p>Task-level CPU and memory parameters are 773 * ignored for Windows containers. We recommend specifying container-level 774 * resources for Windows containers.</p> <p>If you are using the EC2 launch 775 * type, this field is optional. Supported values are between <code>128</code> CPU 776 * units (<code>0.125</code> vCPUs) and <code>10240</code> CPU units 777 * (<code>10</code> vCPUs).</p> <p>If you are using the Fargate launch type, this 778 * field is required and you must use one of the following values, which determines 779 * your range of supported values for the <code>memory</code> parameter:</p> <ul> 780 * <li> <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 781 * 1024 (1 GB), 2048 (2 GB)</p> </li> <li> <p>512 (.5 vCPU) - Available 782 * <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 783 * GB)</p> </li> <li> <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 784 * (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 785 * GB)</p> </li> <li> <p>2048 (2 vCPU) - Available <code>memory</code> values: 786 * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p> </li> 787 * <li> <p>4096 (4 vCPU) - Available <code>memory</code> values: Between 8192 (8 788 * GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p> </li> </ul> 789 */ SetCpu(const Aws::String & value)790 inline void SetCpu(const Aws::String& value) { m_cpuHasBeenSet = true; m_cpu = value; } 791 792 /** 793 * <p>The number of CPU units used by the task. It can be expressed as an integer 794 * using CPU units, for example <code>1024</code>, or as a string using vCPUs, for 795 * example <code>1 vCPU</code> or <code>1 vcpu</code>, in a task definition. String 796 * values are converted to an integer indicating the CPU units when the task 797 * definition is registered.</p> <p>Task-level CPU and memory parameters are 798 * ignored for Windows containers. We recommend specifying container-level 799 * resources for Windows containers.</p> <p>If you are using the EC2 launch 800 * type, this field is optional. Supported values are between <code>128</code> CPU 801 * units (<code>0.125</code> vCPUs) and <code>10240</code> CPU units 802 * (<code>10</code> vCPUs).</p> <p>If you are using the Fargate launch type, this 803 * field is required and you must use one of the following values, which determines 804 * your range of supported values for the <code>memory</code> parameter:</p> <ul> 805 * <li> <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 806 * 1024 (1 GB), 2048 (2 GB)</p> </li> <li> <p>512 (.5 vCPU) - Available 807 * <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 808 * GB)</p> </li> <li> <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 809 * (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 810 * GB)</p> </li> <li> <p>2048 (2 vCPU) - Available <code>memory</code> values: 811 * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p> </li> 812 * <li> <p>4096 (4 vCPU) - Available <code>memory</code> values: Between 8192 (8 813 * GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p> </li> </ul> 814 */ SetCpu(Aws::String && value)815 inline void SetCpu(Aws::String&& value) { m_cpuHasBeenSet = true; m_cpu = std::move(value); } 816 817 /** 818 * <p>The number of CPU units used by the task. It can be expressed as an integer 819 * using CPU units, for example <code>1024</code>, or as a string using vCPUs, for 820 * example <code>1 vCPU</code> or <code>1 vcpu</code>, in a task definition. String 821 * values are converted to an integer indicating the CPU units when the task 822 * definition is registered.</p> <p>Task-level CPU and memory parameters are 823 * ignored for Windows containers. We recommend specifying container-level 824 * resources for Windows containers.</p> <p>If you are using the EC2 launch 825 * type, this field is optional. Supported values are between <code>128</code> CPU 826 * units (<code>0.125</code> vCPUs) and <code>10240</code> CPU units 827 * (<code>10</code> vCPUs).</p> <p>If you are using the Fargate launch type, this 828 * field is required and you must use one of the following values, which determines 829 * your range of supported values for the <code>memory</code> parameter:</p> <ul> 830 * <li> <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 831 * 1024 (1 GB), 2048 (2 GB)</p> </li> <li> <p>512 (.5 vCPU) - Available 832 * <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 833 * GB)</p> </li> <li> <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 834 * (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 835 * GB)</p> </li> <li> <p>2048 (2 vCPU) - Available <code>memory</code> values: 836 * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p> </li> 837 * <li> <p>4096 (4 vCPU) - Available <code>memory</code> values: Between 8192 (8 838 * GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p> </li> </ul> 839 */ SetCpu(const char * value)840 inline void SetCpu(const char* value) { m_cpuHasBeenSet = true; m_cpu.assign(value); } 841 842 /** 843 * <p>The number of CPU units used by the task. It can be expressed as an integer 844 * using CPU units, for example <code>1024</code>, or as a string using vCPUs, for 845 * example <code>1 vCPU</code> or <code>1 vcpu</code>, in a task definition. String 846 * values are converted to an integer indicating the CPU units when the task 847 * definition is registered.</p> <p>Task-level CPU and memory parameters are 848 * ignored for Windows containers. We recommend specifying container-level 849 * resources for Windows containers.</p> <p>If you are using the EC2 launch 850 * type, this field is optional. Supported values are between <code>128</code> CPU 851 * units (<code>0.125</code> vCPUs) and <code>10240</code> CPU units 852 * (<code>10</code> vCPUs).</p> <p>If you are using the Fargate launch type, this 853 * field is required and you must use one of the following values, which determines 854 * your range of supported values for the <code>memory</code> parameter:</p> <ul> 855 * <li> <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 856 * 1024 (1 GB), 2048 (2 GB)</p> </li> <li> <p>512 (.5 vCPU) - Available 857 * <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 858 * GB)</p> </li> <li> <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 859 * (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 860 * GB)</p> </li> <li> <p>2048 (2 vCPU) - Available <code>memory</code> values: 861 * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p> </li> 862 * <li> <p>4096 (4 vCPU) - Available <code>memory</code> values: Between 8192 (8 863 * GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p> </li> </ul> 864 */ WithCpu(const Aws::String & value)865 inline RegisterTaskDefinitionRequest& WithCpu(const Aws::String& value) { SetCpu(value); return *this;} 866 867 /** 868 * <p>The number of CPU units used by the task. It can be expressed as an integer 869 * using CPU units, for example <code>1024</code>, or as a string using vCPUs, for 870 * example <code>1 vCPU</code> or <code>1 vcpu</code>, in a task definition. String 871 * values are converted to an integer indicating the CPU units when the task 872 * definition is registered.</p> <p>Task-level CPU and memory parameters are 873 * ignored for Windows containers. We recommend specifying container-level 874 * resources for Windows containers.</p> <p>If you are using the EC2 launch 875 * type, this field is optional. Supported values are between <code>128</code> CPU 876 * units (<code>0.125</code> vCPUs) and <code>10240</code> CPU units 877 * (<code>10</code> vCPUs).</p> <p>If you are using the Fargate launch type, this 878 * field is required and you must use one of the following values, which determines 879 * your range of supported values for the <code>memory</code> parameter:</p> <ul> 880 * <li> <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 881 * 1024 (1 GB), 2048 (2 GB)</p> </li> <li> <p>512 (.5 vCPU) - Available 882 * <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 883 * GB)</p> </li> <li> <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 884 * (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 885 * GB)</p> </li> <li> <p>2048 (2 vCPU) - Available <code>memory</code> values: 886 * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p> </li> 887 * <li> <p>4096 (4 vCPU) - Available <code>memory</code> values: Between 8192 (8 888 * GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p> </li> </ul> 889 */ WithCpu(Aws::String && value)890 inline RegisterTaskDefinitionRequest& WithCpu(Aws::String&& value) { SetCpu(std::move(value)); return *this;} 891 892 /** 893 * <p>The number of CPU units used by the task. It can be expressed as an integer 894 * using CPU units, for example <code>1024</code>, or as a string using vCPUs, for 895 * example <code>1 vCPU</code> or <code>1 vcpu</code>, in a task definition. String 896 * values are converted to an integer indicating the CPU units when the task 897 * definition is registered.</p> <p>Task-level CPU and memory parameters are 898 * ignored for Windows containers. We recommend specifying container-level 899 * resources for Windows containers.</p> <p>If you are using the EC2 launch 900 * type, this field is optional. Supported values are between <code>128</code> CPU 901 * units (<code>0.125</code> vCPUs) and <code>10240</code> CPU units 902 * (<code>10</code> vCPUs).</p> <p>If you are using the Fargate launch type, this 903 * field is required and you must use one of the following values, which determines 904 * your range of supported values for the <code>memory</code> parameter:</p> <ul> 905 * <li> <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 906 * 1024 (1 GB), 2048 (2 GB)</p> </li> <li> <p>512 (.5 vCPU) - Available 907 * <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 908 * GB)</p> </li> <li> <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 909 * (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 910 * GB)</p> </li> <li> <p>2048 (2 vCPU) - Available <code>memory</code> values: 911 * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p> </li> 912 * <li> <p>4096 (4 vCPU) - Available <code>memory</code> values: Between 8192 (8 913 * GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p> </li> </ul> 914 */ WithCpu(const char * value)915 inline RegisterTaskDefinitionRequest& WithCpu(const char* value) { SetCpu(value); return *this;} 916 917 918 /** 919 * <p>The amount of memory (in MiB) used by the task. It can be expressed as an 920 * integer using MiB, for example <code>1024</code>, or as a string using GB, for 921 * example <code>1GB</code> or <code>1 GB</code>, in a task definition. String 922 * values are converted to an integer indicating the MiB when the task definition 923 * is registered.</p> <p>Task-level CPU and memory parameters are ignored 924 * for Windows containers. We recommend specifying container-level resources for 925 * Windows containers.</p> <p>If using the EC2 launch type, this field is 926 * optional.</p> <p>If using the Fargate launch type, this field is required and 927 * you must use one of the following values, which determines your range of 928 * supported values for the <code>cpu</code> parameter:</p> <ul> <li> <p>512 (0.5 929 * GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 930 * vCPU)</p> </li> <li> <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - 931 * Available <code>cpu</code> values: 512 (.5 vCPU)</p> </li> <li> <p>2048 (2 GB), 932 * 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - 933 * Available <code>cpu</code> values: 1024 (1 vCPU)</p> </li> <li> <p>Between 4096 934 * (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available 935 * <code>cpu</code> values: 2048 (2 vCPU)</p> </li> <li> <p>Between 8192 (8 GB) and 936 * 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 937 * 4096 (4 vCPU)</p> </li> </ul> 938 */ GetMemory()939 inline const Aws::String& GetMemory() const{ return m_memory; } 940 941 /** 942 * <p>The amount of memory (in MiB) used by the task. It can be expressed as an 943 * integer using MiB, for example <code>1024</code>, or as a string using GB, for 944 * example <code>1GB</code> or <code>1 GB</code>, in a task definition. String 945 * values are converted to an integer indicating the MiB when the task definition 946 * is registered.</p> <p>Task-level CPU and memory parameters are ignored 947 * for Windows containers. We recommend specifying container-level resources for 948 * Windows containers.</p> <p>If using the EC2 launch type, this field is 949 * optional.</p> <p>If using the Fargate launch type, this field is required and 950 * you must use one of the following values, which determines your range of 951 * supported values for the <code>cpu</code> parameter:</p> <ul> <li> <p>512 (0.5 952 * GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 953 * vCPU)</p> </li> <li> <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - 954 * Available <code>cpu</code> values: 512 (.5 vCPU)</p> </li> <li> <p>2048 (2 GB), 955 * 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - 956 * Available <code>cpu</code> values: 1024 (1 vCPU)</p> </li> <li> <p>Between 4096 957 * (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available 958 * <code>cpu</code> values: 2048 (2 vCPU)</p> </li> <li> <p>Between 8192 (8 GB) and 959 * 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 960 * 4096 (4 vCPU)</p> </li> </ul> 961 */ MemoryHasBeenSet()962 inline bool MemoryHasBeenSet() const { return m_memoryHasBeenSet; } 963 964 /** 965 * <p>The amount of memory (in MiB) used by the task. It can be expressed as an 966 * integer using MiB, for example <code>1024</code>, or as a string using GB, for 967 * example <code>1GB</code> or <code>1 GB</code>, in a task definition. String 968 * values are converted to an integer indicating the MiB when the task definition 969 * is registered.</p> <p>Task-level CPU and memory parameters are ignored 970 * for Windows containers. We recommend specifying container-level resources for 971 * Windows containers.</p> <p>If using the EC2 launch type, this field is 972 * optional.</p> <p>If using the Fargate launch type, this field is required and 973 * you must use one of the following values, which determines your range of 974 * supported values for the <code>cpu</code> parameter:</p> <ul> <li> <p>512 (0.5 975 * GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 976 * vCPU)</p> </li> <li> <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - 977 * Available <code>cpu</code> values: 512 (.5 vCPU)</p> </li> <li> <p>2048 (2 GB), 978 * 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - 979 * Available <code>cpu</code> values: 1024 (1 vCPU)</p> </li> <li> <p>Between 4096 980 * (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available 981 * <code>cpu</code> values: 2048 (2 vCPU)</p> </li> <li> <p>Between 8192 (8 GB) and 982 * 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 983 * 4096 (4 vCPU)</p> </li> </ul> 984 */ SetMemory(const Aws::String & value)985 inline void SetMemory(const Aws::String& value) { m_memoryHasBeenSet = true; m_memory = value; } 986 987 /** 988 * <p>The amount of memory (in MiB) used by the task. It can be expressed as an 989 * integer using MiB, for example <code>1024</code>, or as a string using GB, for 990 * example <code>1GB</code> or <code>1 GB</code>, in a task definition. String 991 * values are converted to an integer indicating the MiB when the task definition 992 * is registered.</p> <p>Task-level CPU and memory parameters are ignored 993 * for Windows containers. We recommend specifying container-level resources for 994 * Windows containers.</p> <p>If using the EC2 launch type, this field is 995 * optional.</p> <p>If using the Fargate launch type, this field is required and 996 * you must use one of the following values, which determines your range of 997 * supported values for the <code>cpu</code> parameter:</p> <ul> <li> <p>512 (0.5 998 * GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 999 * vCPU)</p> </li> <li> <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - 1000 * Available <code>cpu</code> values: 512 (.5 vCPU)</p> </li> <li> <p>2048 (2 GB), 1001 * 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - 1002 * Available <code>cpu</code> values: 1024 (1 vCPU)</p> </li> <li> <p>Between 4096 1003 * (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available 1004 * <code>cpu</code> values: 2048 (2 vCPU)</p> </li> <li> <p>Between 8192 (8 GB) and 1005 * 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 1006 * 4096 (4 vCPU)</p> </li> </ul> 1007 */ SetMemory(Aws::String && value)1008 inline void SetMemory(Aws::String&& value) { m_memoryHasBeenSet = true; m_memory = std::move(value); } 1009 1010 /** 1011 * <p>The amount of memory (in MiB) used by the task. It can be expressed as an 1012 * integer using MiB, for example <code>1024</code>, or as a string using GB, for 1013 * example <code>1GB</code> or <code>1 GB</code>, in a task definition. String 1014 * values are converted to an integer indicating the MiB when the task definition 1015 * is registered.</p> <p>Task-level CPU and memory parameters are ignored 1016 * for Windows containers. We recommend specifying container-level resources for 1017 * Windows containers.</p> <p>If using the EC2 launch type, this field is 1018 * optional.</p> <p>If using the Fargate launch type, this field is required and 1019 * you must use one of the following values, which determines your range of 1020 * supported values for the <code>cpu</code> parameter:</p> <ul> <li> <p>512 (0.5 1021 * GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 1022 * vCPU)</p> </li> <li> <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - 1023 * Available <code>cpu</code> values: 512 (.5 vCPU)</p> </li> <li> <p>2048 (2 GB), 1024 * 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - 1025 * Available <code>cpu</code> values: 1024 (1 vCPU)</p> </li> <li> <p>Between 4096 1026 * (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available 1027 * <code>cpu</code> values: 2048 (2 vCPU)</p> </li> <li> <p>Between 8192 (8 GB) and 1028 * 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 1029 * 4096 (4 vCPU)</p> </li> </ul> 1030 */ SetMemory(const char * value)1031 inline void SetMemory(const char* value) { m_memoryHasBeenSet = true; m_memory.assign(value); } 1032 1033 /** 1034 * <p>The amount of memory (in MiB) used by the task. It can be expressed as an 1035 * integer using MiB, for example <code>1024</code>, or as a string using GB, for 1036 * example <code>1GB</code> or <code>1 GB</code>, in a task definition. String 1037 * values are converted to an integer indicating the MiB when the task definition 1038 * is registered.</p> <p>Task-level CPU and memory parameters are ignored 1039 * for Windows containers. We recommend specifying container-level resources for 1040 * Windows containers.</p> <p>If using the EC2 launch type, this field is 1041 * optional.</p> <p>If using the Fargate launch type, this field is required and 1042 * you must use one of the following values, which determines your range of 1043 * supported values for the <code>cpu</code> parameter:</p> <ul> <li> <p>512 (0.5 1044 * GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 1045 * vCPU)</p> </li> <li> <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - 1046 * Available <code>cpu</code> values: 512 (.5 vCPU)</p> </li> <li> <p>2048 (2 GB), 1047 * 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - 1048 * Available <code>cpu</code> values: 1024 (1 vCPU)</p> </li> <li> <p>Between 4096 1049 * (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available 1050 * <code>cpu</code> values: 2048 (2 vCPU)</p> </li> <li> <p>Between 8192 (8 GB) and 1051 * 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 1052 * 4096 (4 vCPU)</p> </li> </ul> 1053 */ WithMemory(const Aws::String & value)1054 inline RegisterTaskDefinitionRequest& WithMemory(const Aws::String& value) { SetMemory(value); return *this;} 1055 1056 /** 1057 * <p>The amount of memory (in MiB) used by the task. It can be expressed as an 1058 * integer using MiB, for example <code>1024</code>, or as a string using GB, for 1059 * example <code>1GB</code> or <code>1 GB</code>, in a task definition. String 1060 * values are converted to an integer indicating the MiB when the task definition 1061 * is registered.</p> <p>Task-level CPU and memory parameters are ignored 1062 * for Windows containers. We recommend specifying container-level resources for 1063 * Windows containers.</p> <p>If using the EC2 launch type, this field is 1064 * optional.</p> <p>If using the Fargate launch type, this field is required and 1065 * you must use one of the following values, which determines your range of 1066 * supported values for the <code>cpu</code> parameter:</p> <ul> <li> <p>512 (0.5 1067 * GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 1068 * vCPU)</p> </li> <li> <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - 1069 * Available <code>cpu</code> values: 512 (.5 vCPU)</p> </li> <li> <p>2048 (2 GB), 1070 * 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - 1071 * Available <code>cpu</code> values: 1024 (1 vCPU)</p> </li> <li> <p>Between 4096 1072 * (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available 1073 * <code>cpu</code> values: 2048 (2 vCPU)</p> </li> <li> <p>Between 8192 (8 GB) and 1074 * 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 1075 * 4096 (4 vCPU)</p> </li> </ul> 1076 */ WithMemory(Aws::String && value)1077 inline RegisterTaskDefinitionRequest& WithMemory(Aws::String&& value) { SetMemory(std::move(value)); return *this;} 1078 1079 /** 1080 * <p>The amount of memory (in MiB) used by the task. It can be expressed as an 1081 * integer using MiB, for example <code>1024</code>, or as a string using GB, for 1082 * example <code>1GB</code> or <code>1 GB</code>, in a task definition. String 1083 * values are converted to an integer indicating the MiB when the task definition 1084 * is registered.</p> <p>Task-level CPU and memory parameters are ignored 1085 * for Windows containers. We recommend specifying container-level resources for 1086 * Windows containers.</p> <p>If using the EC2 launch type, this field is 1087 * optional.</p> <p>If using the Fargate launch type, this field is required and 1088 * you must use one of the following values, which determines your range of 1089 * supported values for the <code>cpu</code> parameter:</p> <ul> <li> <p>512 (0.5 1090 * GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 1091 * vCPU)</p> </li> <li> <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - 1092 * Available <code>cpu</code> values: 512 (.5 vCPU)</p> </li> <li> <p>2048 (2 GB), 1093 * 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - 1094 * Available <code>cpu</code> values: 1024 (1 vCPU)</p> </li> <li> <p>Between 4096 1095 * (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available 1096 * <code>cpu</code> values: 2048 (2 vCPU)</p> </li> <li> <p>Between 8192 (8 GB) and 1097 * 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 1098 * 4096 (4 vCPU)</p> </li> </ul> 1099 */ WithMemory(const char * value)1100 inline RegisterTaskDefinitionRequest& WithMemory(const char* value) { SetMemory(value); return *this;} 1101 1102 1103 /** 1104 * <p>The metadata that you apply to the task definition to help you categorize and 1105 * organize them. Each tag consists of a key and an optional value, both of which 1106 * you define.</p> <p>The following basic restrictions apply to tags:</p> <ul> <li> 1107 * <p>Maximum number of tags per resource - 50</p> </li> <li> <p>For each resource, 1108 * each tag key must be unique, and each tag key can have only one value.</p> </li> 1109 * <li> <p>Maximum key length - 128 Unicode characters in UTF-8</p> </li> <li> 1110 * <p>Maximum value length - 256 Unicode characters in UTF-8</p> </li> <li> <p>If 1111 * your tagging schema is used across multiple services and resources, remember 1112 * that other services may have restrictions on allowed characters. Generally 1113 * allowed characters are: letters, numbers, and spaces representable in UTF-8, and 1114 * the following characters: + - = . _ : / @.</p> </li> <li> <p>Tag keys and values 1115 * are case-sensitive.</p> </li> <li> <p>Do not use <code>aws:</code>, 1116 * <code>AWS:</code>, or any upper or lowercase combination of such as a prefix for 1117 * either keys or values as it is reserved for Amazon Web Services use. You cannot 1118 * edit or delete tag keys or values with this prefix. Tags with this prefix do not 1119 * count against your tags per resource limit.</p> </li> </ul> 1120 */ GetTags()1121 inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; } 1122 1123 /** 1124 * <p>The metadata that you apply to the task definition to help you categorize and 1125 * organize them. Each tag consists of a key and an optional value, both of which 1126 * you define.</p> <p>The following basic restrictions apply to tags:</p> <ul> <li> 1127 * <p>Maximum number of tags per resource - 50</p> </li> <li> <p>For each resource, 1128 * each tag key must be unique, and each tag key can have only one value.</p> </li> 1129 * <li> <p>Maximum key length - 128 Unicode characters in UTF-8</p> </li> <li> 1130 * <p>Maximum value length - 256 Unicode characters in UTF-8</p> </li> <li> <p>If 1131 * your tagging schema is used across multiple services and resources, remember 1132 * that other services may have restrictions on allowed characters. Generally 1133 * allowed characters are: letters, numbers, and spaces representable in UTF-8, and 1134 * the following characters: + - = . _ : / @.</p> </li> <li> <p>Tag keys and values 1135 * are case-sensitive.</p> </li> <li> <p>Do not use <code>aws:</code>, 1136 * <code>AWS:</code>, or any upper or lowercase combination of such as a prefix for 1137 * either keys or values as it is reserved for Amazon Web Services use. You cannot 1138 * edit or delete tag keys or values with this prefix. Tags with this prefix do not 1139 * count against your tags per resource limit.</p> </li> </ul> 1140 */ TagsHasBeenSet()1141 inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; } 1142 1143 /** 1144 * <p>The metadata that you apply to the task definition to help you categorize and 1145 * organize them. Each tag consists of a key and an optional value, both of which 1146 * you define.</p> <p>The following basic restrictions apply to tags:</p> <ul> <li> 1147 * <p>Maximum number of tags per resource - 50</p> </li> <li> <p>For each resource, 1148 * each tag key must be unique, and each tag key can have only one value.</p> </li> 1149 * <li> <p>Maximum key length - 128 Unicode characters in UTF-8</p> </li> <li> 1150 * <p>Maximum value length - 256 Unicode characters in UTF-8</p> </li> <li> <p>If 1151 * your tagging schema is used across multiple services and resources, remember 1152 * that other services may have restrictions on allowed characters. Generally 1153 * allowed characters are: letters, numbers, and spaces representable in UTF-8, and 1154 * the following characters: + - = . _ : / @.</p> </li> <li> <p>Tag keys and values 1155 * are case-sensitive.</p> </li> <li> <p>Do not use <code>aws:</code>, 1156 * <code>AWS:</code>, or any upper or lowercase combination of such as a prefix for 1157 * either keys or values as it is reserved for Amazon Web Services use. You cannot 1158 * edit or delete tag keys or values with this prefix. Tags with this prefix do not 1159 * count against your tags per resource limit.</p> </li> </ul> 1160 */ SetTags(const Aws::Vector<Tag> & value)1161 inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; } 1162 1163 /** 1164 * <p>The metadata that you apply to the task definition to help you categorize and 1165 * organize them. Each tag consists of a key and an optional value, both of which 1166 * you define.</p> <p>The following basic restrictions apply to tags:</p> <ul> <li> 1167 * <p>Maximum number of tags per resource - 50</p> </li> <li> <p>For each resource, 1168 * each tag key must be unique, and each tag key can have only one value.</p> </li> 1169 * <li> <p>Maximum key length - 128 Unicode characters in UTF-8</p> </li> <li> 1170 * <p>Maximum value length - 256 Unicode characters in UTF-8</p> </li> <li> <p>If 1171 * your tagging schema is used across multiple services and resources, remember 1172 * that other services may have restrictions on allowed characters. Generally 1173 * allowed characters are: letters, numbers, and spaces representable in UTF-8, and 1174 * the following characters: + - = . _ : / @.</p> </li> <li> <p>Tag keys and values 1175 * are case-sensitive.</p> </li> <li> <p>Do not use <code>aws:</code>, 1176 * <code>AWS:</code>, or any upper or lowercase combination of such as a prefix for 1177 * either keys or values as it is reserved for Amazon Web Services use. You cannot 1178 * edit or delete tag keys or values with this prefix. Tags with this prefix do not 1179 * count against your tags per resource limit.</p> </li> </ul> 1180 */ SetTags(Aws::Vector<Tag> && value)1181 inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); } 1182 1183 /** 1184 * <p>The metadata that you apply to the task definition to help you categorize and 1185 * organize them. Each tag consists of a key and an optional value, both of which 1186 * you define.</p> <p>The following basic restrictions apply to tags:</p> <ul> <li> 1187 * <p>Maximum number of tags per resource - 50</p> </li> <li> <p>For each resource, 1188 * each tag key must be unique, and each tag key can have only one value.</p> </li> 1189 * <li> <p>Maximum key length - 128 Unicode characters in UTF-8</p> </li> <li> 1190 * <p>Maximum value length - 256 Unicode characters in UTF-8</p> </li> <li> <p>If 1191 * your tagging schema is used across multiple services and resources, remember 1192 * that other services may have restrictions on allowed characters. Generally 1193 * allowed characters are: letters, numbers, and spaces representable in UTF-8, and 1194 * the following characters: + - = . _ : / @.</p> </li> <li> <p>Tag keys and values 1195 * are case-sensitive.</p> </li> <li> <p>Do not use <code>aws:</code>, 1196 * <code>AWS:</code>, or any upper or lowercase combination of such as a prefix for 1197 * either keys or values as it is reserved for Amazon Web Services use. You cannot 1198 * edit or delete tag keys or values with this prefix. Tags with this prefix do not 1199 * count against your tags per resource limit.</p> </li> </ul> 1200 */ WithTags(const Aws::Vector<Tag> & value)1201 inline RegisterTaskDefinitionRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;} 1202 1203 /** 1204 * <p>The metadata that you apply to the task definition to help you categorize and 1205 * organize them. Each tag consists of a key and an optional value, both of which 1206 * you define.</p> <p>The following basic restrictions apply to tags:</p> <ul> <li> 1207 * <p>Maximum number of tags per resource - 50</p> </li> <li> <p>For each resource, 1208 * each tag key must be unique, and each tag key can have only one value.</p> </li> 1209 * <li> <p>Maximum key length - 128 Unicode characters in UTF-8</p> </li> <li> 1210 * <p>Maximum value length - 256 Unicode characters in UTF-8</p> </li> <li> <p>If 1211 * your tagging schema is used across multiple services and resources, remember 1212 * that other services may have restrictions on allowed characters. Generally 1213 * allowed characters are: letters, numbers, and spaces representable in UTF-8, and 1214 * the following characters: + - = . _ : / @.</p> </li> <li> <p>Tag keys and values 1215 * are case-sensitive.</p> </li> <li> <p>Do not use <code>aws:</code>, 1216 * <code>AWS:</code>, or any upper or lowercase combination of such as a prefix for 1217 * either keys or values as it is reserved for Amazon Web Services use. You cannot 1218 * edit or delete tag keys or values with this prefix. Tags with this prefix do not 1219 * count against your tags per resource limit.</p> </li> </ul> 1220 */ WithTags(Aws::Vector<Tag> && value)1221 inline RegisterTaskDefinitionRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;} 1222 1223 /** 1224 * <p>The metadata that you apply to the task definition to help you categorize and 1225 * organize them. Each tag consists of a key and an optional value, both of which 1226 * you define.</p> <p>The following basic restrictions apply to tags:</p> <ul> <li> 1227 * <p>Maximum number of tags per resource - 50</p> </li> <li> <p>For each resource, 1228 * each tag key must be unique, and each tag key can have only one value.</p> </li> 1229 * <li> <p>Maximum key length - 128 Unicode characters in UTF-8</p> </li> <li> 1230 * <p>Maximum value length - 256 Unicode characters in UTF-8</p> </li> <li> <p>If 1231 * your tagging schema is used across multiple services and resources, remember 1232 * that other services may have restrictions on allowed characters. Generally 1233 * allowed characters are: letters, numbers, and spaces representable in UTF-8, and 1234 * the following characters: + - = . _ : / @.</p> </li> <li> <p>Tag keys and values 1235 * are case-sensitive.</p> </li> <li> <p>Do not use <code>aws:</code>, 1236 * <code>AWS:</code>, or any upper or lowercase combination of such as a prefix for 1237 * either keys or values as it is reserved for Amazon Web Services use. You cannot 1238 * edit or delete tag keys or values with this prefix. Tags with this prefix do not 1239 * count against your tags per resource limit.</p> </li> </ul> 1240 */ AddTags(const Tag & value)1241 inline RegisterTaskDefinitionRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; } 1242 1243 /** 1244 * <p>The metadata that you apply to the task definition to help you categorize and 1245 * organize them. Each tag consists of a key and an optional value, both of which 1246 * you define.</p> <p>The following basic restrictions apply to tags:</p> <ul> <li> 1247 * <p>Maximum number of tags per resource - 50</p> </li> <li> <p>For each resource, 1248 * each tag key must be unique, and each tag key can have only one value.</p> </li> 1249 * <li> <p>Maximum key length - 128 Unicode characters in UTF-8</p> </li> <li> 1250 * <p>Maximum value length - 256 Unicode characters in UTF-8</p> </li> <li> <p>If 1251 * your tagging schema is used across multiple services and resources, remember 1252 * that other services may have restrictions on allowed characters. Generally 1253 * allowed characters are: letters, numbers, and spaces representable in UTF-8, and 1254 * the following characters: + - = . _ : / @.</p> </li> <li> <p>Tag keys and values 1255 * are case-sensitive.</p> </li> <li> <p>Do not use <code>aws:</code>, 1256 * <code>AWS:</code>, or any upper or lowercase combination of such as a prefix for 1257 * either keys or values as it is reserved for Amazon Web Services use. You cannot 1258 * edit or delete tag keys or values with this prefix. Tags with this prefix do not 1259 * count against your tags per resource limit.</p> </li> </ul> 1260 */ AddTags(Tag && value)1261 inline RegisterTaskDefinitionRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; } 1262 1263 1264 /** 1265 * <p>The process namespace to use for the containers in the task. The valid values 1266 * are <code>host</code> or <code>task</code>. If <code>host</code> is specified, 1267 * then all containers within the tasks that specified the <code>host</code> PID 1268 * mode on the same container instance share the same process namespace with the 1269 * host Amazon EC2 instance. If <code>task</code> is specified, all containers 1270 * within the specified task share the same process namespace. If no value is 1271 * specified, the default is a private namespace. For more information, see <a 1272 * href="https://docs.docker.com/engine/reference/run/#pid-settings---pid">PID 1273 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1274 * PID mode is used, be aware that there is a heightened risk of undesired process 1275 * namespace expose. For more information, see <a 1276 * href="https://docs.docker.com/engine/security/security/">Docker 1277 * security</a>.</p> <p>This parameter is not supported for Windows 1278 * containers or tasks run on Fargate.</p> 1279 */ GetPidMode()1280 inline const PidMode& GetPidMode() const{ return m_pidMode; } 1281 1282 /** 1283 * <p>The process namespace to use for the containers in the task. The valid values 1284 * are <code>host</code> or <code>task</code>. If <code>host</code> is specified, 1285 * then all containers within the tasks that specified the <code>host</code> PID 1286 * mode on the same container instance share the same process namespace with the 1287 * host Amazon EC2 instance. If <code>task</code> is specified, all containers 1288 * within the specified task share the same process namespace. If no value is 1289 * specified, the default is a private namespace. For more information, see <a 1290 * href="https://docs.docker.com/engine/reference/run/#pid-settings---pid">PID 1291 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1292 * PID mode is used, be aware that there is a heightened risk of undesired process 1293 * namespace expose. For more information, see <a 1294 * href="https://docs.docker.com/engine/security/security/">Docker 1295 * security</a>.</p> <p>This parameter is not supported for Windows 1296 * containers or tasks run on Fargate.</p> 1297 */ PidModeHasBeenSet()1298 inline bool PidModeHasBeenSet() const { return m_pidModeHasBeenSet; } 1299 1300 /** 1301 * <p>The process namespace to use for the containers in the task. The valid values 1302 * are <code>host</code> or <code>task</code>. If <code>host</code> is specified, 1303 * then all containers within the tasks that specified the <code>host</code> PID 1304 * mode on the same container instance share the same process namespace with the 1305 * host Amazon EC2 instance. If <code>task</code> is specified, all containers 1306 * within the specified task share the same process namespace. If no value is 1307 * specified, the default is a private namespace. For more information, see <a 1308 * href="https://docs.docker.com/engine/reference/run/#pid-settings---pid">PID 1309 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1310 * PID mode is used, be aware that there is a heightened risk of undesired process 1311 * namespace expose. For more information, see <a 1312 * href="https://docs.docker.com/engine/security/security/">Docker 1313 * security</a>.</p> <p>This parameter is not supported for Windows 1314 * containers or tasks run on Fargate.</p> 1315 */ SetPidMode(const PidMode & value)1316 inline void SetPidMode(const PidMode& value) { m_pidModeHasBeenSet = true; m_pidMode = value; } 1317 1318 /** 1319 * <p>The process namespace to use for the containers in the task. The valid values 1320 * are <code>host</code> or <code>task</code>. If <code>host</code> is specified, 1321 * then all containers within the tasks that specified the <code>host</code> PID 1322 * mode on the same container instance share the same process namespace with the 1323 * host Amazon EC2 instance. If <code>task</code> is specified, all containers 1324 * within the specified task share the same process namespace. If no value is 1325 * specified, the default is a private namespace. For more information, see <a 1326 * href="https://docs.docker.com/engine/reference/run/#pid-settings---pid">PID 1327 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1328 * PID mode is used, be aware that there is a heightened risk of undesired process 1329 * namespace expose. For more information, see <a 1330 * href="https://docs.docker.com/engine/security/security/">Docker 1331 * security</a>.</p> <p>This parameter is not supported for Windows 1332 * containers or tasks run on Fargate.</p> 1333 */ SetPidMode(PidMode && value)1334 inline void SetPidMode(PidMode&& value) { m_pidModeHasBeenSet = true; m_pidMode = std::move(value); } 1335 1336 /** 1337 * <p>The process namespace to use for the containers in the task. The valid values 1338 * are <code>host</code> or <code>task</code>. If <code>host</code> is specified, 1339 * then all containers within the tasks that specified the <code>host</code> PID 1340 * mode on the same container instance share the same process namespace with the 1341 * host Amazon EC2 instance. If <code>task</code> is specified, all containers 1342 * within the specified task share the same process namespace. If no value is 1343 * specified, the default is a private namespace. For more information, see <a 1344 * href="https://docs.docker.com/engine/reference/run/#pid-settings---pid">PID 1345 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1346 * PID mode is used, be aware that there is a heightened risk of undesired process 1347 * namespace expose. For more information, see <a 1348 * href="https://docs.docker.com/engine/security/security/">Docker 1349 * security</a>.</p> <p>This parameter is not supported for Windows 1350 * containers or tasks run on Fargate.</p> 1351 */ WithPidMode(const PidMode & value)1352 inline RegisterTaskDefinitionRequest& WithPidMode(const PidMode& value) { SetPidMode(value); return *this;} 1353 1354 /** 1355 * <p>The process namespace to use for the containers in the task. The valid values 1356 * are <code>host</code> or <code>task</code>. If <code>host</code> is specified, 1357 * then all containers within the tasks that specified the <code>host</code> PID 1358 * mode on the same container instance share the same process namespace with the 1359 * host Amazon EC2 instance. If <code>task</code> is specified, all containers 1360 * within the specified task share the same process namespace. If no value is 1361 * specified, the default is a private namespace. For more information, see <a 1362 * href="https://docs.docker.com/engine/reference/run/#pid-settings---pid">PID 1363 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1364 * PID mode is used, be aware that there is a heightened risk of undesired process 1365 * namespace expose. For more information, see <a 1366 * href="https://docs.docker.com/engine/security/security/">Docker 1367 * security</a>.</p> <p>This parameter is not supported for Windows 1368 * containers or tasks run on Fargate.</p> 1369 */ WithPidMode(PidMode && value)1370 inline RegisterTaskDefinitionRequest& WithPidMode(PidMode&& value) { SetPidMode(std::move(value)); return *this;} 1371 1372 1373 /** 1374 * <p>The IPC resource namespace to use for the containers in the task. The valid 1375 * values are <code>host</code>, <code>task</code>, or <code>none</code>. If 1376 * <code>host</code> is specified, then all containers within the tasks that 1377 * specified the <code>host</code> IPC mode on the same container instance share 1378 * the same IPC resources with the host Amazon EC2 instance. If <code>task</code> 1379 * is specified, all containers within the specified task share the same IPC 1380 * resources. If <code>none</code> is specified, then IPC resources within the 1381 * containers of a task are private and not shared with other containers in a task 1382 * or on the container instance. If no value is specified, then the IPC resource 1383 * namespace sharing depends on the Docker daemon setting on the container 1384 * instance. For more information, see <a 1385 * href="https://docs.docker.com/engine/reference/run/#ipc-settings---ipc">IPC 1386 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1387 * IPC mode is used, be aware that there is a heightened risk of undesired IPC 1388 * namespace expose. For more information, see <a 1389 * href="https://docs.docker.com/engine/security/security/">Docker 1390 * security</a>.</p> <p>If you are setting namespaced kernel parameters using 1391 * <code>systemControls</code> for the containers in the task, the following will 1392 * apply to your IPC resource namespace. For more information, see <a 1393 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html">System 1394 * Controls</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 1395 * <ul> <li> <p>For tasks that use the <code>host</code> IPC mode, IPC namespace 1396 * related <code>systemControls</code> are not supported.</p> </li> <li> <p>For 1397 * tasks that use the <code>task</code> IPC mode, IPC namespace related 1398 * <code>systemControls</code> will apply to all containers within a task.</p> 1399 * </li> </ul> <p>This parameter is not supported for Windows containers or 1400 * tasks run on Fargate.</p> 1401 */ GetIpcMode()1402 inline const IpcMode& GetIpcMode() const{ return m_ipcMode; } 1403 1404 /** 1405 * <p>The IPC resource namespace to use for the containers in the task. The valid 1406 * values are <code>host</code>, <code>task</code>, or <code>none</code>. If 1407 * <code>host</code> is specified, then all containers within the tasks that 1408 * specified the <code>host</code> IPC mode on the same container instance share 1409 * the same IPC resources with the host Amazon EC2 instance. If <code>task</code> 1410 * is specified, all containers within the specified task share the same IPC 1411 * resources. If <code>none</code> is specified, then IPC resources within the 1412 * containers of a task are private and not shared with other containers in a task 1413 * or on the container instance. If no value is specified, then the IPC resource 1414 * namespace sharing depends on the Docker daemon setting on the container 1415 * instance. For more information, see <a 1416 * href="https://docs.docker.com/engine/reference/run/#ipc-settings---ipc">IPC 1417 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1418 * IPC mode is used, be aware that there is a heightened risk of undesired IPC 1419 * namespace expose. For more information, see <a 1420 * href="https://docs.docker.com/engine/security/security/">Docker 1421 * security</a>.</p> <p>If you are setting namespaced kernel parameters using 1422 * <code>systemControls</code> for the containers in the task, the following will 1423 * apply to your IPC resource namespace. For more information, see <a 1424 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html">System 1425 * Controls</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 1426 * <ul> <li> <p>For tasks that use the <code>host</code> IPC mode, IPC namespace 1427 * related <code>systemControls</code> are not supported.</p> </li> <li> <p>For 1428 * tasks that use the <code>task</code> IPC mode, IPC namespace related 1429 * <code>systemControls</code> will apply to all containers within a task.</p> 1430 * </li> </ul> <p>This parameter is not supported for Windows containers or 1431 * tasks run on Fargate.</p> 1432 */ IpcModeHasBeenSet()1433 inline bool IpcModeHasBeenSet() const { return m_ipcModeHasBeenSet; } 1434 1435 /** 1436 * <p>The IPC resource namespace to use for the containers in the task. The valid 1437 * values are <code>host</code>, <code>task</code>, or <code>none</code>. If 1438 * <code>host</code> is specified, then all containers within the tasks that 1439 * specified the <code>host</code> IPC mode on the same container instance share 1440 * the same IPC resources with the host Amazon EC2 instance. If <code>task</code> 1441 * is specified, all containers within the specified task share the same IPC 1442 * resources. If <code>none</code> is specified, then IPC resources within the 1443 * containers of a task are private and not shared with other containers in a task 1444 * or on the container instance. If no value is specified, then the IPC resource 1445 * namespace sharing depends on the Docker daemon setting on the container 1446 * instance. For more information, see <a 1447 * href="https://docs.docker.com/engine/reference/run/#ipc-settings---ipc">IPC 1448 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1449 * IPC mode is used, be aware that there is a heightened risk of undesired IPC 1450 * namespace expose. For more information, see <a 1451 * href="https://docs.docker.com/engine/security/security/">Docker 1452 * security</a>.</p> <p>If you are setting namespaced kernel parameters using 1453 * <code>systemControls</code> for the containers in the task, the following will 1454 * apply to your IPC resource namespace. For more information, see <a 1455 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html">System 1456 * Controls</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 1457 * <ul> <li> <p>For tasks that use the <code>host</code> IPC mode, IPC namespace 1458 * related <code>systemControls</code> are not supported.</p> </li> <li> <p>For 1459 * tasks that use the <code>task</code> IPC mode, IPC namespace related 1460 * <code>systemControls</code> will apply to all containers within a task.</p> 1461 * </li> </ul> <p>This parameter is not supported for Windows containers or 1462 * tasks run on Fargate.</p> 1463 */ SetIpcMode(const IpcMode & value)1464 inline void SetIpcMode(const IpcMode& value) { m_ipcModeHasBeenSet = true; m_ipcMode = value; } 1465 1466 /** 1467 * <p>The IPC resource namespace to use for the containers in the task. The valid 1468 * values are <code>host</code>, <code>task</code>, or <code>none</code>. If 1469 * <code>host</code> is specified, then all containers within the tasks that 1470 * specified the <code>host</code> IPC mode on the same container instance share 1471 * the same IPC resources with the host Amazon EC2 instance. If <code>task</code> 1472 * is specified, all containers within the specified task share the same IPC 1473 * resources. If <code>none</code> is specified, then IPC resources within the 1474 * containers of a task are private and not shared with other containers in a task 1475 * or on the container instance. If no value is specified, then the IPC resource 1476 * namespace sharing depends on the Docker daemon setting on the container 1477 * instance. For more information, see <a 1478 * href="https://docs.docker.com/engine/reference/run/#ipc-settings---ipc">IPC 1479 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1480 * IPC mode is used, be aware that there is a heightened risk of undesired IPC 1481 * namespace expose. For more information, see <a 1482 * href="https://docs.docker.com/engine/security/security/">Docker 1483 * security</a>.</p> <p>If you are setting namespaced kernel parameters using 1484 * <code>systemControls</code> for the containers in the task, the following will 1485 * apply to your IPC resource namespace. For more information, see <a 1486 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html">System 1487 * Controls</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 1488 * <ul> <li> <p>For tasks that use the <code>host</code> IPC mode, IPC namespace 1489 * related <code>systemControls</code> are not supported.</p> </li> <li> <p>For 1490 * tasks that use the <code>task</code> IPC mode, IPC namespace related 1491 * <code>systemControls</code> will apply to all containers within a task.</p> 1492 * </li> </ul> <p>This parameter is not supported for Windows containers or 1493 * tasks run on Fargate.</p> 1494 */ SetIpcMode(IpcMode && value)1495 inline void SetIpcMode(IpcMode&& value) { m_ipcModeHasBeenSet = true; m_ipcMode = std::move(value); } 1496 1497 /** 1498 * <p>The IPC resource namespace to use for the containers in the task. The valid 1499 * values are <code>host</code>, <code>task</code>, or <code>none</code>. If 1500 * <code>host</code> is specified, then all containers within the tasks that 1501 * specified the <code>host</code> IPC mode on the same container instance share 1502 * the same IPC resources with the host Amazon EC2 instance. If <code>task</code> 1503 * is specified, all containers within the specified task share the same IPC 1504 * resources. If <code>none</code> is specified, then IPC resources within the 1505 * containers of a task are private and not shared with other containers in a task 1506 * or on the container instance. If no value is specified, then the IPC resource 1507 * namespace sharing depends on the Docker daemon setting on the container 1508 * instance. For more information, see <a 1509 * href="https://docs.docker.com/engine/reference/run/#ipc-settings---ipc">IPC 1510 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1511 * IPC mode is used, be aware that there is a heightened risk of undesired IPC 1512 * namespace expose. For more information, see <a 1513 * href="https://docs.docker.com/engine/security/security/">Docker 1514 * security</a>.</p> <p>If you are setting namespaced kernel parameters using 1515 * <code>systemControls</code> for the containers in the task, the following will 1516 * apply to your IPC resource namespace. For more information, see <a 1517 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html">System 1518 * Controls</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 1519 * <ul> <li> <p>For tasks that use the <code>host</code> IPC mode, IPC namespace 1520 * related <code>systemControls</code> are not supported.</p> </li> <li> <p>For 1521 * tasks that use the <code>task</code> IPC mode, IPC namespace related 1522 * <code>systemControls</code> will apply to all containers within a task.</p> 1523 * </li> </ul> <p>This parameter is not supported for Windows containers or 1524 * tasks run on Fargate.</p> 1525 */ WithIpcMode(const IpcMode & value)1526 inline RegisterTaskDefinitionRequest& WithIpcMode(const IpcMode& value) { SetIpcMode(value); return *this;} 1527 1528 /** 1529 * <p>The IPC resource namespace to use for the containers in the task. The valid 1530 * values are <code>host</code>, <code>task</code>, or <code>none</code>. If 1531 * <code>host</code> is specified, then all containers within the tasks that 1532 * specified the <code>host</code> IPC mode on the same container instance share 1533 * the same IPC resources with the host Amazon EC2 instance. If <code>task</code> 1534 * is specified, all containers within the specified task share the same IPC 1535 * resources. If <code>none</code> is specified, then IPC resources within the 1536 * containers of a task are private and not shared with other containers in a task 1537 * or on the container instance. If no value is specified, then the IPC resource 1538 * namespace sharing depends on the Docker daemon setting on the container 1539 * instance. For more information, see <a 1540 * href="https://docs.docker.com/engine/reference/run/#ipc-settings---ipc">IPC 1541 * settings</a> in the <i>Docker run reference</i>.</p> <p>If the <code>host</code> 1542 * IPC mode is used, be aware that there is a heightened risk of undesired IPC 1543 * namespace expose. For more information, see <a 1544 * href="https://docs.docker.com/engine/security/security/">Docker 1545 * security</a>.</p> <p>If you are setting namespaced kernel parameters using 1546 * <code>systemControls</code> for the containers in the task, the following will 1547 * apply to your IPC resource namespace. For more information, see <a 1548 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html">System 1549 * Controls</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 1550 * <ul> <li> <p>For tasks that use the <code>host</code> IPC mode, IPC namespace 1551 * related <code>systemControls</code> are not supported.</p> </li> <li> <p>For 1552 * tasks that use the <code>task</code> IPC mode, IPC namespace related 1553 * <code>systemControls</code> will apply to all containers within a task.</p> 1554 * </li> </ul> <p>This parameter is not supported for Windows containers or 1555 * tasks run on Fargate.</p> 1556 */ WithIpcMode(IpcMode && value)1557 inline RegisterTaskDefinitionRequest& WithIpcMode(IpcMode&& value) { SetIpcMode(std::move(value)); return *this;} 1558 1559 1560 /** 1561 * <p>The configuration details for the App Mesh proxy.</p> <p>For tasks hosted on 1562 * Amazon EC2 instances, the container instances require at least version 1563 * <code>1.26.0</code> of the container agent and at least version 1564 * <code>1.26.0-1</code> of the <code>ecs-init</code> package to enable a proxy 1565 * configuration. If your container instances are launched from the Amazon 1566 * ECS-optimized AMI version <code>20190301</code> or later, then they contain the 1567 * required versions of the container agent and <code>ecs-init</code>. For more 1568 * information, see <a 1569 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-ami-versions.html">Amazon 1570 * ECS-optimized AMI versions</a> in the <i>Amazon Elastic Container Service 1571 * Developer Guide</i>.</p> 1572 */ GetProxyConfiguration()1573 inline const ProxyConfiguration& GetProxyConfiguration() const{ return m_proxyConfiguration; } 1574 1575 /** 1576 * <p>The configuration details for the App Mesh proxy.</p> <p>For tasks hosted on 1577 * Amazon EC2 instances, the container instances require at least version 1578 * <code>1.26.0</code> of the container agent and at least version 1579 * <code>1.26.0-1</code> of the <code>ecs-init</code> package to enable a proxy 1580 * configuration. If your container instances are launched from the Amazon 1581 * ECS-optimized AMI version <code>20190301</code> or later, then they contain the 1582 * required versions of the container agent and <code>ecs-init</code>. For more 1583 * information, see <a 1584 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-ami-versions.html">Amazon 1585 * ECS-optimized AMI versions</a> in the <i>Amazon Elastic Container Service 1586 * Developer Guide</i>.</p> 1587 */ ProxyConfigurationHasBeenSet()1588 inline bool ProxyConfigurationHasBeenSet() const { return m_proxyConfigurationHasBeenSet; } 1589 1590 /** 1591 * <p>The configuration details for the App Mesh proxy.</p> <p>For tasks hosted on 1592 * Amazon EC2 instances, the container instances require at least version 1593 * <code>1.26.0</code> of the container agent and at least version 1594 * <code>1.26.0-1</code> of the <code>ecs-init</code> package to enable a proxy 1595 * configuration. If your container instances are launched from the Amazon 1596 * ECS-optimized AMI version <code>20190301</code> or later, then they contain the 1597 * required versions of the container agent and <code>ecs-init</code>. For more 1598 * information, see <a 1599 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-ami-versions.html">Amazon 1600 * ECS-optimized AMI versions</a> in the <i>Amazon Elastic Container Service 1601 * Developer Guide</i>.</p> 1602 */ SetProxyConfiguration(const ProxyConfiguration & value)1603 inline void SetProxyConfiguration(const ProxyConfiguration& value) { m_proxyConfigurationHasBeenSet = true; m_proxyConfiguration = value; } 1604 1605 /** 1606 * <p>The configuration details for the App Mesh proxy.</p> <p>For tasks hosted on 1607 * Amazon EC2 instances, the container instances require at least version 1608 * <code>1.26.0</code> of the container agent and at least version 1609 * <code>1.26.0-1</code> of the <code>ecs-init</code> package to enable a proxy 1610 * configuration. If your container instances are launched from the Amazon 1611 * ECS-optimized AMI version <code>20190301</code> or later, then they contain the 1612 * required versions of the container agent and <code>ecs-init</code>. For more 1613 * information, see <a 1614 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-ami-versions.html">Amazon 1615 * ECS-optimized AMI versions</a> in the <i>Amazon Elastic Container Service 1616 * Developer Guide</i>.</p> 1617 */ SetProxyConfiguration(ProxyConfiguration && value)1618 inline void SetProxyConfiguration(ProxyConfiguration&& value) { m_proxyConfigurationHasBeenSet = true; m_proxyConfiguration = std::move(value); } 1619 1620 /** 1621 * <p>The configuration details for the App Mesh proxy.</p> <p>For tasks hosted on 1622 * Amazon EC2 instances, the container instances require at least version 1623 * <code>1.26.0</code> of the container agent and at least version 1624 * <code>1.26.0-1</code> of the <code>ecs-init</code> package to enable a proxy 1625 * configuration. If your container instances are launched from the Amazon 1626 * ECS-optimized AMI version <code>20190301</code> or later, then they contain the 1627 * required versions of the container agent and <code>ecs-init</code>. For more 1628 * information, see <a 1629 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-ami-versions.html">Amazon 1630 * ECS-optimized AMI versions</a> in the <i>Amazon Elastic Container Service 1631 * Developer Guide</i>.</p> 1632 */ WithProxyConfiguration(const ProxyConfiguration & value)1633 inline RegisterTaskDefinitionRequest& WithProxyConfiguration(const ProxyConfiguration& value) { SetProxyConfiguration(value); return *this;} 1634 1635 /** 1636 * <p>The configuration details for the App Mesh proxy.</p> <p>For tasks hosted on 1637 * Amazon EC2 instances, the container instances require at least version 1638 * <code>1.26.0</code> of the container agent and at least version 1639 * <code>1.26.0-1</code> of the <code>ecs-init</code> package to enable a proxy 1640 * configuration. If your container instances are launched from the Amazon 1641 * ECS-optimized AMI version <code>20190301</code> or later, then they contain the 1642 * required versions of the container agent and <code>ecs-init</code>. For more 1643 * information, see <a 1644 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-ami-versions.html">Amazon 1645 * ECS-optimized AMI versions</a> in the <i>Amazon Elastic Container Service 1646 * Developer Guide</i>.</p> 1647 */ WithProxyConfiguration(ProxyConfiguration && value)1648 inline RegisterTaskDefinitionRequest& WithProxyConfiguration(ProxyConfiguration&& value) { SetProxyConfiguration(std::move(value)); return *this;} 1649 1650 1651 /** 1652 * <p>The Elastic Inference accelerators to use for the containers in the task.</p> 1653 */ GetInferenceAccelerators()1654 inline const Aws::Vector<InferenceAccelerator>& GetInferenceAccelerators() const{ return m_inferenceAccelerators; } 1655 1656 /** 1657 * <p>The Elastic Inference accelerators to use for the containers in the task.</p> 1658 */ InferenceAcceleratorsHasBeenSet()1659 inline bool InferenceAcceleratorsHasBeenSet() const { return m_inferenceAcceleratorsHasBeenSet; } 1660 1661 /** 1662 * <p>The Elastic Inference accelerators to use for the containers in the task.</p> 1663 */ SetInferenceAccelerators(const Aws::Vector<InferenceAccelerator> & value)1664 inline void SetInferenceAccelerators(const Aws::Vector<InferenceAccelerator>& value) { m_inferenceAcceleratorsHasBeenSet = true; m_inferenceAccelerators = value; } 1665 1666 /** 1667 * <p>The Elastic Inference accelerators to use for the containers in the task.</p> 1668 */ SetInferenceAccelerators(Aws::Vector<InferenceAccelerator> && value)1669 inline void SetInferenceAccelerators(Aws::Vector<InferenceAccelerator>&& value) { m_inferenceAcceleratorsHasBeenSet = true; m_inferenceAccelerators = std::move(value); } 1670 1671 /** 1672 * <p>The Elastic Inference accelerators to use for the containers in the task.</p> 1673 */ WithInferenceAccelerators(const Aws::Vector<InferenceAccelerator> & value)1674 inline RegisterTaskDefinitionRequest& WithInferenceAccelerators(const Aws::Vector<InferenceAccelerator>& value) { SetInferenceAccelerators(value); return *this;} 1675 1676 /** 1677 * <p>The Elastic Inference accelerators to use for the containers in the task.</p> 1678 */ WithInferenceAccelerators(Aws::Vector<InferenceAccelerator> && value)1679 inline RegisterTaskDefinitionRequest& WithInferenceAccelerators(Aws::Vector<InferenceAccelerator>&& value) { SetInferenceAccelerators(std::move(value)); return *this;} 1680 1681 /** 1682 * <p>The Elastic Inference accelerators to use for the containers in the task.</p> 1683 */ AddInferenceAccelerators(const InferenceAccelerator & value)1684 inline RegisterTaskDefinitionRequest& AddInferenceAccelerators(const InferenceAccelerator& value) { m_inferenceAcceleratorsHasBeenSet = true; m_inferenceAccelerators.push_back(value); return *this; } 1685 1686 /** 1687 * <p>The Elastic Inference accelerators to use for the containers in the task.</p> 1688 */ AddInferenceAccelerators(InferenceAccelerator && value)1689 inline RegisterTaskDefinitionRequest& AddInferenceAccelerators(InferenceAccelerator&& value) { m_inferenceAcceleratorsHasBeenSet = true; m_inferenceAccelerators.push_back(std::move(value)); return *this; } 1690 1691 1692 /** 1693 * <p>The amount of ephemeral storage to allocate for the task. This parameter is 1694 * used to expand the total amount of ephemeral storage available, beyond the 1695 * default amount, for tasks hosted on Fargate. For more information, see <a 1696 * href="https://docs.aws.amazon.com/AmazonECS/latest/userguide/using_data_volumes.html">Fargate 1697 * task storage</a> in the <i>Amazon ECS User Guide for Fargate</i>.</p> 1698 * <p>This parameter is only supported for tasks hosted on Fargate using platform 1699 * version <code>1.4.0</code> or later.</p> 1700 */ GetEphemeralStorage()1701 inline const EphemeralStorage& GetEphemeralStorage() const{ return m_ephemeralStorage; } 1702 1703 /** 1704 * <p>The amount of ephemeral storage to allocate for the task. This parameter is 1705 * used to expand the total amount of ephemeral storage available, beyond the 1706 * default amount, for tasks hosted on Fargate. For more information, see <a 1707 * href="https://docs.aws.amazon.com/AmazonECS/latest/userguide/using_data_volumes.html">Fargate 1708 * task storage</a> in the <i>Amazon ECS User Guide for Fargate</i>.</p> 1709 * <p>This parameter is only supported for tasks hosted on Fargate using platform 1710 * version <code>1.4.0</code> or later.</p> 1711 */ EphemeralStorageHasBeenSet()1712 inline bool EphemeralStorageHasBeenSet() const { return m_ephemeralStorageHasBeenSet; } 1713 1714 /** 1715 * <p>The amount of ephemeral storage to allocate for the task. This parameter is 1716 * used to expand the total amount of ephemeral storage available, beyond the 1717 * default amount, for tasks hosted on Fargate. For more information, see <a 1718 * href="https://docs.aws.amazon.com/AmazonECS/latest/userguide/using_data_volumes.html">Fargate 1719 * task storage</a> in the <i>Amazon ECS User Guide for Fargate</i>.</p> 1720 * <p>This parameter is only supported for tasks hosted on Fargate using platform 1721 * version <code>1.4.0</code> or later.</p> 1722 */ SetEphemeralStorage(const EphemeralStorage & value)1723 inline void SetEphemeralStorage(const EphemeralStorage& value) { m_ephemeralStorageHasBeenSet = true; m_ephemeralStorage = value; } 1724 1725 /** 1726 * <p>The amount of ephemeral storage to allocate for the task. This parameter is 1727 * used to expand the total amount of ephemeral storage available, beyond the 1728 * default amount, for tasks hosted on Fargate. For more information, see <a 1729 * href="https://docs.aws.amazon.com/AmazonECS/latest/userguide/using_data_volumes.html">Fargate 1730 * task storage</a> in the <i>Amazon ECS User Guide for Fargate</i>.</p> 1731 * <p>This parameter is only supported for tasks hosted on Fargate using platform 1732 * version <code>1.4.0</code> or later.</p> 1733 */ SetEphemeralStorage(EphemeralStorage && value)1734 inline void SetEphemeralStorage(EphemeralStorage&& value) { m_ephemeralStorageHasBeenSet = true; m_ephemeralStorage = std::move(value); } 1735 1736 /** 1737 * <p>The amount of ephemeral storage to allocate for the task. This parameter is 1738 * used to expand the total amount of ephemeral storage available, beyond the 1739 * default amount, for tasks hosted on Fargate. For more information, see <a 1740 * href="https://docs.aws.amazon.com/AmazonECS/latest/userguide/using_data_volumes.html">Fargate 1741 * task storage</a> in the <i>Amazon ECS User Guide for Fargate</i>.</p> 1742 * <p>This parameter is only supported for tasks hosted on Fargate using platform 1743 * version <code>1.4.0</code> or later.</p> 1744 */ WithEphemeralStorage(const EphemeralStorage & value)1745 inline RegisterTaskDefinitionRequest& WithEphemeralStorage(const EphemeralStorage& value) { SetEphemeralStorage(value); return *this;} 1746 1747 /** 1748 * <p>The amount of ephemeral storage to allocate for the task. This parameter is 1749 * used to expand the total amount of ephemeral storage available, beyond the 1750 * default amount, for tasks hosted on Fargate. For more information, see <a 1751 * href="https://docs.aws.amazon.com/AmazonECS/latest/userguide/using_data_volumes.html">Fargate 1752 * task storage</a> in the <i>Amazon ECS User Guide for Fargate</i>.</p> 1753 * <p>This parameter is only supported for tasks hosted on Fargate using platform 1754 * version <code>1.4.0</code> or later.</p> 1755 */ WithEphemeralStorage(EphemeralStorage && value)1756 inline RegisterTaskDefinitionRequest& WithEphemeralStorage(EphemeralStorage&& value) { SetEphemeralStorage(std::move(value)); return *this;} 1757 1758 private: 1759 1760 Aws::String m_family; 1761 bool m_familyHasBeenSet; 1762 1763 Aws::String m_taskRoleArn; 1764 bool m_taskRoleArnHasBeenSet; 1765 1766 Aws::String m_executionRoleArn; 1767 bool m_executionRoleArnHasBeenSet; 1768 1769 NetworkMode m_networkMode; 1770 bool m_networkModeHasBeenSet; 1771 1772 Aws::Vector<ContainerDefinition> m_containerDefinitions; 1773 bool m_containerDefinitionsHasBeenSet; 1774 1775 Aws::Vector<Volume> m_volumes; 1776 bool m_volumesHasBeenSet; 1777 1778 Aws::Vector<TaskDefinitionPlacementConstraint> m_placementConstraints; 1779 bool m_placementConstraintsHasBeenSet; 1780 1781 Aws::Vector<Compatibility> m_requiresCompatibilities; 1782 bool m_requiresCompatibilitiesHasBeenSet; 1783 1784 Aws::String m_cpu; 1785 bool m_cpuHasBeenSet; 1786 1787 Aws::String m_memory; 1788 bool m_memoryHasBeenSet; 1789 1790 Aws::Vector<Tag> m_tags; 1791 bool m_tagsHasBeenSet; 1792 1793 PidMode m_pidMode; 1794 bool m_pidModeHasBeenSet; 1795 1796 IpcMode m_ipcMode; 1797 bool m_ipcModeHasBeenSet; 1798 1799 ProxyConfiguration m_proxyConfiguration; 1800 bool m_proxyConfigurationHasBeenSet; 1801 1802 Aws::Vector<InferenceAccelerator> m_inferenceAccelerators; 1803 bool m_inferenceAcceleratorsHasBeenSet; 1804 1805 EphemeralStorage m_ephemeralStorage; 1806 bool m_ephemeralStorageHasBeenSet; 1807 }; 1808 1809 } // namespace Model 1810 } // namespace ECS 1811 } // namespace Aws 1812