AWS SDK for C++

AWS SDK for C++ Version 1.11.933

Loading...
Searching...
No Matches
TaskDefinition.h
1
6#pragma once
7#include <aws/core/utils/DateTime.h>
8#include <aws/core/utils/memory/stl/AWSString.h>
9#include <aws/core/utils/memory/stl/AWSVector.h>
10#include <aws/ecs/ECS_EXPORTS.h>
11#include <aws/ecs/model/Attribute.h>
12#include <aws/ecs/model/Compatibility.h>
13#include <aws/ecs/model/ContainerDefinition.h>
14#include <aws/ecs/model/EphemeralStorage.h>
15#include <aws/ecs/model/InferenceAccelerator.h>
16#include <aws/ecs/model/IpcMode.h>
17#include <aws/ecs/model/NetworkMode.h>
18#include <aws/ecs/model/PidMode.h>
19#include <aws/ecs/model/ProxyConfiguration.h>
20#include <aws/ecs/model/RuntimePlatform.h>
21#include <aws/ecs/model/TaskDefinitionPlacementConstraint.h>
22#include <aws/ecs/model/TaskDefinitionStatus.h>
23#include <aws/ecs/model/TrustedExecutionConfiguration.h>
24#include <aws/ecs/model/Volume.h>
25
26#include <utility>
27
28namespace Aws {
29namespace Utils {
30namespace Json {
31class JsonValue;
32class JsonView;
33} // namespace Json
34} // namespace Utils
35namespace ECS {
36namespace Model {
37
48 public:
49 AWS_ECS_API TaskDefinition() = default;
53
55
58 inline const Aws::String& GetTaskDefinitionArn() const { return m_taskDefinitionArn; }
59 inline bool TaskDefinitionArnHasBeenSet() const { return m_taskDefinitionArnHasBeenSet; }
60 template <typename TaskDefinitionArnT = Aws::String>
61 void SetTaskDefinitionArn(TaskDefinitionArnT&& value) {
62 m_taskDefinitionArnHasBeenSet = true;
63 m_taskDefinitionArn = std::forward<TaskDefinitionArnT>(value);
64 }
65 template <typename TaskDefinitionArnT = Aws::String>
66 TaskDefinition& WithTaskDefinitionArn(TaskDefinitionArnT&& value) {
67 SetTaskDefinitionArn(std::forward<TaskDefinitionArnT>(value));
68 return *this;
69 }
71
73
81 inline const Aws::Vector<ContainerDefinition>& GetContainerDefinitions() const { return m_containerDefinitions; }
82 inline bool ContainerDefinitionsHasBeenSet() const { return m_containerDefinitionsHasBeenSet; }
83 template <typename ContainerDefinitionsT = Aws::Vector<ContainerDefinition>>
84 void SetContainerDefinitions(ContainerDefinitionsT&& value) {
85 m_containerDefinitionsHasBeenSet = true;
86 m_containerDefinitions = std::forward<ContainerDefinitionsT>(value);
87 }
88 template <typename ContainerDefinitionsT = Aws::Vector<ContainerDefinition>>
89 TaskDefinition& WithContainerDefinitions(ContainerDefinitionsT&& value) {
90 SetContainerDefinitions(std::forward<ContainerDefinitionsT>(value));
91 return *this;
92 }
93 template <typename ContainerDefinitionsT = ContainerDefinition>
94 TaskDefinition& AddContainerDefinitions(ContainerDefinitionsT&& value) {
95 m_containerDefinitionsHasBeenSet = true;
96 m_containerDefinitions.emplace_back(std::forward<ContainerDefinitionsT>(value));
97 return *this;
98 }
100
102
110 inline const Aws::String& GetFamily() const { return m_family; }
111 inline bool FamilyHasBeenSet() const { return m_familyHasBeenSet; }
112 template <typename FamilyT = Aws::String>
113 void SetFamily(FamilyT&& value) {
114 m_familyHasBeenSet = true;
115 m_family = std::forward<FamilyT>(value);
116 }
117 template <typename FamilyT = Aws::String>
118 TaskDefinition& WithFamily(FamilyT&& value) {
119 SetFamily(std::forward<FamilyT>(value));
120 return *this;
121 }
123
125
134 inline const Aws::String& GetTaskRoleArn() const { return m_taskRoleArn; }
135 inline bool TaskRoleArnHasBeenSet() const { return m_taskRoleArnHasBeenSet; }
136 template <typename TaskRoleArnT = Aws::String>
137 void SetTaskRoleArn(TaskRoleArnT&& value) {
138 m_taskRoleArnHasBeenSet = true;
139 m_taskRoleArn = std::forward<TaskRoleArnT>(value);
140 }
141 template <typename TaskRoleArnT = Aws::String>
142 TaskDefinition& WithTaskRoleArn(TaskRoleArnT&& value) {
143 SetTaskRoleArn(std::forward<TaskRoleArnT>(value));
144 return *this;
145 }
147
149
157 inline const Aws::String& GetExecutionRoleArn() const { return m_executionRoleArn; }
158 inline bool ExecutionRoleArnHasBeenSet() const { return m_executionRoleArnHasBeenSet; }
159 template <typename ExecutionRoleArnT = Aws::String>
160 void SetExecutionRoleArn(ExecutionRoleArnT&& value) {
161 m_executionRoleArnHasBeenSet = true;
162 m_executionRoleArn = std::forward<ExecutionRoleArnT>(value);
163 }
164 template <typename ExecutionRoleArnT = Aws::String>
165 TaskDefinition& WithExecutionRoleArn(ExecutionRoleArnT&& value) {
166 SetExecutionRoleArn(std::forward<ExecutionRoleArnT>(value));
167 return *this;
168 }
170
172
203 inline NetworkMode GetNetworkMode() const { return m_networkMode; }
204 inline bool NetworkModeHasBeenSet() const { return m_networkModeHasBeenSet; }
205 inline void SetNetworkMode(NetworkMode value) {
206 m_networkModeHasBeenSet = true;
207 m_networkMode = value;
208 }
210 SetNetworkMode(value);
211 return *this;
212 }
214
216
224 inline int GetRevision() const { return m_revision; }
225 inline bool RevisionHasBeenSet() const { return m_revisionHasBeenSet; }
226 inline void SetRevision(int value) {
227 m_revisionHasBeenSet = true;
228 m_revision = value;
229 }
230 inline TaskDefinition& WithRevision(int value) {
231 SetRevision(value);
232 return *this;
233 }
235
237
245 inline const Aws::Vector<Volume>& GetVolumes() const { return m_volumes; }
246 inline bool VolumesHasBeenSet() const { return m_volumesHasBeenSet; }
247 template <typename VolumesT = Aws::Vector<Volume>>
248 void SetVolumes(VolumesT&& value) {
249 m_volumesHasBeenSet = true;
250 m_volumes = std::forward<VolumesT>(value);
251 }
252 template <typename VolumesT = Aws::Vector<Volume>>
253 TaskDefinition& WithVolumes(VolumesT&& value) {
254 SetVolumes(std::forward<VolumesT>(value));
255 return *this;
256 }
257 template <typename VolumesT = Volume>
258 TaskDefinition& AddVolumes(VolumesT&& value) {
259 m_volumesHasBeenSet = true;
260 m_volumes.emplace_back(std::forward<VolumesT>(value));
261 return *this;
262 }
264
266
269 inline TaskDefinitionStatus GetStatus() const { return m_status; }
270 inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
271 inline void SetStatus(TaskDefinitionStatus value) {
272 m_statusHasBeenSet = true;
273 m_status = value;
274 }
276 SetStatus(value);
277 return *this;
278 }
280
282
294 inline const Aws::Vector<Attribute>& GetRequiresAttributes() const { return m_requiresAttributes; }
295 inline bool RequiresAttributesHasBeenSet() const { return m_requiresAttributesHasBeenSet; }
296 template <typename RequiresAttributesT = Aws::Vector<Attribute>>
297 void SetRequiresAttributes(RequiresAttributesT&& value) {
298 m_requiresAttributesHasBeenSet = true;
299 m_requiresAttributes = std::forward<RequiresAttributesT>(value);
300 }
301 template <typename RequiresAttributesT = Aws::Vector<Attribute>>
302 TaskDefinition& WithRequiresAttributes(RequiresAttributesT&& value) {
303 SetRequiresAttributes(std::forward<RequiresAttributesT>(value));
304 return *this;
305 }
306 template <typename RequiresAttributesT = Attribute>
307 TaskDefinition& AddRequiresAttributes(RequiresAttributesT&& value) {
308 m_requiresAttributesHasBeenSet = true;
309 m_requiresAttributes.emplace_back(std::forward<RequiresAttributesT>(value));
310 return *this;
311 }
313
315
319 inline const Aws::Vector<TaskDefinitionPlacementConstraint>& GetPlacementConstraints() const { return m_placementConstraints; }
320 inline bool PlacementConstraintsHasBeenSet() const { return m_placementConstraintsHasBeenSet; }
321 template <typename PlacementConstraintsT = Aws::Vector<TaskDefinitionPlacementConstraint>>
322 void SetPlacementConstraints(PlacementConstraintsT&& value) {
323 m_placementConstraintsHasBeenSet = true;
324 m_placementConstraints = std::forward<PlacementConstraintsT>(value);
325 }
326 template <typename PlacementConstraintsT = Aws::Vector<TaskDefinitionPlacementConstraint>>
327 TaskDefinition& WithPlacementConstraints(PlacementConstraintsT&& value) {
328 SetPlacementConstraints(std::forward<PlacementConstraintsT>(value));
329 return *this;
330 }
331 template <typename PlacementConstraintsT = TaskDefinitionPlacementConstraint>
332 TaskDefinition& AddPlacementConstraints(PlacementConstraintsT&& value) {
333 m_placementConstraintsHasBeenSet = true;
334 m_placementConstraints.emplace_back(std::forward<PlacementConstraintsT>(value));
335 return *this;
336 }
338
340
347 inline const Aws::Vector<Compatibility>& GetCompatibilities() const { return m_compatibilities; }
348 inline bool CompatibilitiesHasBeenSet() const { return m_compatibilitiesHasBeenSet; }
349 template <typename CompatibilitiesT = Aws::Vector<Compatibility>>
350 void SetCompatibilities(CompatibilitiesT&& value) {
351 m_compatibilitiesHasBeenSet = true;
352 m_compatibilities = std::forward<CompatibilitiesT>(value);
353 }
354 template <typename CompatibilitiesT = Aws::Vector<Compatibility>>
355 TaskDefinition& WithCompatibilities(CompatibilitiesT&& value) {
356 SetCompatibilities(std::forward<CompatibilitiesT>(value));
357 return *this;
358 }
360 m_compatibilitiesHasBeenSet = true;
361 m_compatibilities.push_back(value);
362 return *this;
363 }
365
367
373 inline const RuntimePlatform& GetRuntimePlatform() const { return m_runtimePlatform; }
374 inline bool RuntimePlatformHasBeenSet() const { return m_runtimePlatformHasBeenSet; }
375 template <typename RuntimePlatformT = RuntimePlatform>
376 void SetRuntimePlatform(RuntimePlatformT&& value) {
377 m_runtimePlatformHasBeenSet = true;
378 m_runtimePlatform = std::forward<RuntimePlatformT>(value);
379 }
380 template <typename RuntimePlatformT = RuntimePlatform>
381 TaskDefinition& WithRuntimePlatform(RuntimePlatformT&& value) {
382 SetRuntimePlatform(std::forward<RuntimePlatformT>(value));
383 return *this;
384 }
386
388
396 inline const Aws::Vector<Compatibility>& GetRequiresCompatibilities() const { return m_requiresCompatibilities; }
397 inline bool RequiresCompatibilitiesHasBeenSet() const { return m_requiresCompatibilitiesHasBeenSet; }
398 template <typename RequiresCompatibilitiesT = Aws::Vector<Compatibility>>
399 void SetRequiresCompatibilities(RequiresCompatibilitiesT&& value) {
400 m_requiresCompatibilitiesHasBeenSet = true;
401 m_requiresCompatibilities = std::forward<RequiresCompatibilitiesT>(value);
402 }
403 template <typename RequiresCompatibilitiesT = Aws::Vector<Compatibility>>
404 TaskDefinition& WithRequiresCompatibilities(RequiresCompatibilitiesT&& value) {
405 SetRequiresCompatibilities(std::forward<RequiresCompatibilitiesT>(value));
406 return *this;
407 }
409 m_requiresCompatibilitiesHasBeenSet = true;
410 m_requiresCompatibilities.push_back(value);
411 return *this;
412 }
414
416
429 inline const Aws::String& GetCpu() const { return m_cpu; }
430 inline bool CpuHasBeenSet() const { return m_cpuHasBeenSet; }
431 template <typename CpuT = Aws::String>
432 void SetCpu(CpuT&& value) {
433 m_cpuHasBeenSet = true;
434 m_cpu = std::forward<CpuT>(value);
435 }
436 template <typename CpuT = Aws::String>
437 TaskDefinition& WithCpu(CpuT&& value) {
438 SetCpu(std::forward<CpuT>(value));
439 return *this;
440 }
442
444
470 inline const Aws::String& GetMemory() const { return m_memory; }
471 inline bool MemoryHasBeenSet() const { return m_memoryHasBeenSet; }
472 template <typename MemoryT = Aws::String>
473 void SetMemory(MemoryT&& value) {
474 m_memoryHasBeenSet = true;
475 m_memory = std::forward<MemoryT>(value);
476 }
477 template <typename MemoryT = Aws::String>
478 TaskDefinition& WithMemory(MemoryT&& value) {
479 SetMemory(std::forward<MemoryT>(value));
480 return *this;
481 }
483
485
488 inline const Aws::Vector<InferenceAccelerator>& GetInferenceAccelerators() const { return m_inferenceAccelerators; }
489 inline bool InferenceAcceleratorsHasBeenSet() const { return m_inferenceAcceleratorsHasBeenSet; }
490 template <typename InferenceAcceleratorsT = Aws::Vector<InferenceAccelerator>>
491 void SetInferenceAccelerators(InferenceAcceleratorsT&& value) {
492 m_inferenceAcceleratorsHasBeenSet = true;
493 m_inferenceAccelerators = std::forward<InferenceAcceleratorsT>(value);
494 }
495 template <typename InferenceAcceleratorsT = Aws::Vector<InferenceAccelerator>>
496 TaskDefinition& WithInferenceAccelerators(InferenceAcceleratorsT&& value) {
497 SetInferenceAccelerators(std::forward<InferenceAcceleratorsT>(value));
498 return *this;
499 }
500 template <typename InferenceAcceleratorsT = InferenceAccelerator>
501 TaskDefinition& AddInferenceAccelerators(InferenceAcceleratorsT&& value) {
502 m_inferenceAcceleratorsHasBeenSet = true;
503 m_inferenceAccelerators.emplace_back(std::forward<InferenceAcceleratorsT>(value));
504 return *this;
505 }
507
509
527 inline PidMode GetPidMode() const { return m_pidMode; }
528 inline bool PidModeHasBeenSet() const { return m_pidModeHasBeenSet; }
529 inline void SetPidMode(PidMode value) {
530 m_pidModeHasBeenSet = true;
531 m_pidMode = value;
532 }
534 SetPidMode(value);
535 return *this;
536 }
538
540
565 inline IpcMode GetIpcMode() const { return m_ipcMode; }
566 inline bool IpcModeHasBeenSet() const { return m_ipcModeHasBeenSet; }
567 inline void SetIpcMode(IpcMode value) {
568 m_ipcModeHasBeenSet = true;
569 m_ipcMode = value;
570 }
572 SetIpcMode(value);
573 return *this;
574 }
576
578
590 inline const ProxyConfiguration& GetProxyConfiguration() const { return m_proxyConfiguration; }
591 inline bool ProxyConfigurationHasBeenSet() const { return m_proxyConfigurationHasBeenSet; }
592 template <typename ProxyConfigurationT = ProxyConfiguration>
593 void SetProxyConfiguration(ProxyConfigurationT&& value) {
594 m_proxyConfigurationHasBeenSet = true;
595 m_proxyConfiguration = std::forward<ProxyConfigurationT>(value);
596 }
597 template <typename ProxyConfigurationT = ProxyConfiguration>
598 TaskDefinition& WithProxyConfiguration(ProxyConfigurationT&& value) {
599 SetProxyConfiguration(std::forward<ProxyConfigurationT>(value));
600 return *this;
601 }
603
605
608 inline const Aws::Utils::DateTime& GetRegisteredAt() const { return m_registeredAt; }
609 inline bool RegisteredAtHasBeenSet() const { return m_registeredAtHasBeenSet; }
610 template <typename RegisteredAtT = Aws::Utils::DateTime>
611 void SetRegisteredAt(RegisteredAtT&& value) {
612 m_registeredAtHasBeenSet = true;
613 m_registeredAt = std::forward<RegisteredAtT>(value);
614 }
615 template <typename RegisteredAtT = Aws::Utils::DateTime>
616 TaskDefinition& WithRegisteredAt(RegisteredAtT&& value) {
617 SetRegisteredAt(std::forward<RegisteredAtT>(value));
618 return *this;
619 }
621
623
627 inline const Aws::Utils::DateTime& GetDeregisteredAt() const { return m_deregisteredAt; }
628 inline bool DeregisteredAtHasBeenSet() const { return m_deregisteredAtHasBeenSet; }
629 template <typename DeregisteredAtT = Aws::Utils::DateTime>
630 void SetDeregisteredAt(DeregisteredAtT&& value) {
631 m_deregisteredAtHasBeenSet = true;
632 m_deregisteredAt = std::forward<DeregisteredAtT>(value);
633 }
634 template <typename DeregisteredAtT = Aws::Utils::DateTime>
635 TaskDefinition& WithDeregisteredAt(DeregisteredAtT&& value) {
636 SetDeregisteredAt(std::forward<DeregisteredAtT>(value));
637 return *this;
638 }
640
642
646 inline const Aws::Utils::DateTime& GetDeleteRequestedAt() const { return m_deleteRequestedAt; }
647 inline bool DeleteRequestedAtHasBeenSet() const { return m_deleteRequestedAtHasBeenSet; }
648 template <typename DeleteRequestedAtT = Aws::Utils::DateTime>
649 void SetDeleteRequestedAt(DeleteRequestedAtT&& value) {
650 m_deleteRequestedAtHasBeenSet = true;
651 m_deleteRequestedAt = std::forward<DeleteRequestedAtT>(value);
652 }
653 template <typename DeleteRequestedAtT = Aws::Utils::DateTime>
654 TaskDefinition& WithDeleteRequestedAt(DeleteRequestedAtT&& value) {
655 SetDeleteRequestedAt(std::forward<DeleteRequestedAtT>(value));
656 return *this;
657 }
659
661
664 inline const Aws::String& GetRegisteredBy() const { return m_registeredBy; }
665 inline bool RegisteredByHasBeenSet() const { return m_registeredByHasBeenSet; }
666 template <typename RegisteredByT = Aws::String>
667 void SetRegisteredBy(RegisteredByT&& value) {
668 m_registeredByHasBeenSet = true;
669 m_registeredBy = std::forward<RegisteredByT>(value);
670 }
671 template <typename RegisteredByT = Aws::String>
672 TaskDefinition& WithRegisteredBy(RegisteredByT&& value) {
673 SetRegisteredBy(std::forward<RegisteredByT>(value));
674 return *this;
675 }
677
679
683 inline const EphemeralStorage& GetEphemeralStorage() const { return m_ephemeralStorage; }
684 inline bool EphemeralStorageHasBeenSet() const { return m_ephemeralStorageHasBeenSet; }
685 template <typename EphemeralStorageT = EphemeralStorage>
686 void SetEphemeralStorage(EphemeralStorageT&& value) {
687 m_ephemeralStorageHasBeenSet = true;
688 m_ephemeralStorage = std::forward<EphemeralStorageT>(value);
689 }
690 template <typename EphemeralStorageT = EphemeralStorage>
691 TaskDefinition& WithEphemeralStorage(EphemeralStorageT&& value) {
692 SetEphemeralStorage(std::forward<EphemeralStorageT>(value));
693 return *this;
694 }
696
698
703 inline bool GetEnableFaultInjection() const { return m_enableFaultInjection; }
704 inline bool EnableFaultInjectionHasBeenSet() const { return m_enableFaultInjectionHasBeenSet; }
705 inline void SetEnableFaultInjection(bool value) {
706 m_enableFaultInjectionHasBeenSet = true;
707 m_enableFaultInjection = value;
708 }
711 return *this;
712 }
714
716
722 inline const TrustedExecutionConfiguration& GetTrustedExecutionConfiguration() const { return m_trustedExecutionConfiguration; }
723 inline bool TrustedExecutionConfigurationHasBeenSet() const { return m_trustedExecutionConfigurationHasBeenSet; }
724 template <typename TrustedExecutionConfigurationT = TrustedExecutionConfiguration>
725 void SetTrustedExecutionConfiguration(TrustedExecutionConfigurationT&& value) {
726 m_trustedExecutionConfigurationHasBeenSet = true;
727 m_trustedExecutionConfiguration = std::forward<TrustedExecutionConfigurationT>(value);
728 }
729 template <typename TrustedExecutionConfigurationT = TrustedExecutionConfiguration>
730 TaskDefinition& WithTrustedExecutionConfiguration(TrustedExecutionConfigurationT&& value) {
731 SetTrustedExecutionConfiguration(std::forward<TrustedExecutionConfigurationT>(value));
732 return *this;
733 }
735 private:
736 Aws::String m_taskDefinitionArn;
737
738 Aws::Vector<ContainerDefinition> m_containerDefinitions;
739
740 Aws::String m_family;
741
742 Aws::String m_taskRoleArn;
743
744 Aws::String m_executionRoleArn;
745
746 NetworkMode m_networkMode{NetworkMode::NOT_SET};
747
748 int m_revision{0};
749
750 Aws::Vector<Volume> m_volumes;
751
753
754 Aws::Vector<Attribute> m_requiresAttributes;
755
757
758 Aws::Vector<Compatibility> m_compatibilities;
759
760 RuntimePlatform m_runtimePlatform;
761
762 Aws::Vector<Compatibility> m_requiresCompatibilities;
763
764 Aws::String m_cpu;
765
766 Aws::String m_memory;
767
768 Aws::Vector<InferenceAccelerator> m_inferenceAccelerators;
769
770 PidMode m_pidMode{PidMode::NOT_SET};
771
772 IpcMode m_ipcMode{IpcMode::NOT_SET};
773
774 ProxyConfiguration m_proxyConfiguration;
775
776 Aws::Utils::DateTime m_registeredAt{};
777
778 Aws::Utils::DateTime m_deregisteredAt{};
779
780 Aws::Utils::DateTime m_deleteRequestedAt{};
781
782 Aws::String m_registeredBy;
783
784 EphemeralStorage m_ephemeralStorage;
785
786 bool m_enableFaultInjection{false};
787
788 TrustedExecutionConfiguration m_trustedExecutionConfiguration;
789 bool m_taskDefinitionArnHasBeenSet = false;
790 bool m_containerDefinitionsHasBeenSet = false;
791 bool m_familyHasBeenSet = false;
792 bool m_taskRoleArnHasBeenSet = false;
793 bool m_executionRoleArnHasBeenSet = false;
794 bool m_networkModeHasBeenSet = false;
795 bool m_revisionHasBeenSet = false;
796 bool m_volumesHasBeenSet = false;
797 bool m_statusHasBeenSet = false;
798 bool m_requiresAttributesHasBeenSet = false;
799 bool m_placementConstraintsHasBeenSet = false;
800 bool m_compatibilitiesHasBeenSet = false;
801 bool m_runtimePlatformHasBeenSet = false;
802 bool m_requiresCompatibilitiesHasBeenSet = false;
803 bool m_cpuHasBeenSet = false;
804 bool m_memoryHasBeenSet = false;
805 bool m_inferenceAcceleratorsHasBeenSet = false;
806 bool m_pidModeHasBeenSet = false;
807 bool m_ipcModeHasBeenSet = false;
808 bool m_proxyConfigurationHasBeenSet = false;
809 bool m_registeredAtHasBeenSet = false;
810 bool m_deregisteredAtHasBeenSet = false;
811 bool m_deleteRequestedAtHasBeenSet = false;
812 bool m_registeredByHasBeenSet = false;
813 bool m_ephemeralStorageHasBeenSet = false;
814 bool m_enableFaultInjectionHasBeenSet = false;
815 bool m_trustedExecutionConfigurationHasBeenSet = false;
816};
817
818} // namespace Model
819} // namespace ECS
820} // namespace Aws
const Aws::String & GetRegisteredBy() const
TaskDefinition & WithCpu(CpuT &&value)
const Aws::String & GetMemory() const
TaskDefinition & WithVolumes(VolumesT &&value)
TaskDefinition & WithStatus(TaskDefinitionStatus value)
TaskDefinition & AddVolumes(VolumesT &&value)
const Aws::String & GetCpu() const
const Aws::Vector< Volume > & GetVolumes() const
TaskDefinition & WithDeregisteredAt(DeregisteredAtT &&value)
void SetTrustedExecutionConfiguration(TrustedExecutionConfigurationT &&value)
TaskDefinition & WithCompatibilities(CompatibilitiesT &&value)
const ProxyConfiguration & GetProxyConfiguration() const
void SetEnableFaultInjection(bool value)
TaskDefinition & WithTrustedExecutionConfiguration(TrustedExecutionConfigurationT &&value)
const Aws::Vector< Compatibility > & GetCompatibilities() const
void SetCompatibilities(CompatibilitiesT &&value)
void SetInferenceAccelerators(InferenceAcceleratorsT &&value)
const Aws::String & GetTaskDefinitionArn() const
void SetTaskDefinitionArn(TaskDefinitionArnT &&value)
void SetStatus(TaskDefinitionStatus value)
TaskDefinition & WithNetworkMode(NetworkMode value)
void SetRegisteredAt(RegisteredAtT &&value)
const Aws::String & GetTaskRoleArn() const
AWS_ECS_API TaskDefinition & operator=(Aws::Utils::Json::JsonView jsonValue)
void SetDeregisteredAt(DeregisteredAtT &&value)
TaskDefinition & WithRequiresAttributes(RequiresAttributesT &&value)
TaskDefinition & AddPlacementConstraints(PlacementConstraintsT &&value)
TaskDefinition & WithMemory(MemoryT &&value)
void SetContainerDefinitions(ContainerDefinitionsT &&value)
void SetExecutionRoleArn(ExecutionRoleArnT &&value)
TaskDefinition & WithExecutionRoleArn(ExecutionRoleArnT &&value)
void SetPlacementConstraints(PlacementConstraintsT &&value)
void SetRequiresCompatibilities(RequiresCompatibilitiesT &&value)
TaskDefinition & AddInferenceAccelerators(InferenceAcceleratorsT &&value)
AWS_ECS_API TaskDefinition(Aws::Utils::Json::JsonView jsonValue)
TaskDefinition & WithFamily(FamilyT &&value)
TaskDefinition & WithRegisteredBy(RegisteredByT &&value)
AWS_ECS_API TaskDefinition()=default
const RuntimePlatform & GetRuntimePlatform() const
void SetRuntimePlatform(RuntimePlatformT &&value)
TaskDefinition & WithRegisteredAt(RegisteredAtT &&value)
TaskDefinition & WithProxyConfiguration(ProxyConfigurationT &&value)
void SetDeleteRequestedAt(DeleteRequestedAtT &&value)
TaskDefinition & WithDeleteRequestedAt(DeleteRequestedAtT &&value)
TaskDefinition & WithTaskDefinitionArn(TaskDefinitionArnT &&value)
TaskDefinition & WithIpcMode(IpcMode value)
const Aws::Vector< InferenceAccelerator > & GetInferenceAccelerators() const
void SetVolumes(VolumesT &&value)
void SetFamily(FamilyT &&value)
void SetRegisteredBy(RegisteredByT &&value)
const Aws::Vector< Compatibility > & GetRequiresCompatibilities() const
TaskDefinition & WithEnableFaultInjection(bool value)
const Aws::Vector< Attribute > & GetRequiresAttributes() const
TaskDefinitionStatus GetStatus() const
const Aws::String & GetExecutionRoleArn() const
const Aws::Utils::DateTime & GetDeleteRequestedAt() const
const EphemeralStorage & GetEphemeralStorage() const
TaskDefinition & AddRequiresCompatibilities(Compatibility value)
NetworkMode GetNetworkMode() const
void SetTaskRoleArn(TaskRoleArnT &&value)
TaskDefinition & WithRuntimePlatform(RuntimePlatformT &&value)
const Aws::Vector< TaskDefinitionPlacementConstraint > & GetPlacementConstraints() const
const Aws::Utils::DateTime & GetDeregisteredAt() const
TaskDefinition & WithRevision(int value)
void SetProxyConfiguration(ProxyConfigurationT &&value)
TaskDefinition & AddCompatibilities(Compatibility value)
TaskDefinition & WithEphemeralStorage(EphemeralStorageT &&value)
const Aws::String & GetFamily() const
void SetEphemeralStorage(EphemeralStorageT &&value)
TaskDefinition & WithTaskRoleArn(TaskRoleArnT &&value)
const TrustedExecutionConfiguration & GetTrustedExecutionConfiguration() const
TaskDefinition & AddContainerDefinitions(ContainerDefinitionsT &&value)
void SetMemory(MemoryT &&value)
void SetRequiresAttributes(RequiresAttributesT &&value)
TaskDefinition & WithPidMode(PidMode value)
const Aws::Utils::DateTime & GetRegisteredAt() const
TaskDefinition & WithInferenceAccelerators(InferenceAcceleratorsT &&value)
TaskDefinition & WithRequiresCompatibilities(RequiresCompatibilitiesT &&value)
const Aws::Vector< ContainerDefinition > & GetContainerDefinitions() const
AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const
TaskDefinition & WithPlacementConstraints(PlacementConstraintsT &&value)
TaskDefinition & AddRequiresAttributes(RequiresAttributesT &&value)
TaskDefinition & WithContainerDefinitions(ContainerDefinitionsT &&value)
void SetNetworkMode(NetworkMode value)
bool TrustedExecutionConfigurationHasBeenSet() const
std::basic_string< char, std::char_traits< char >, Aws::Allocator< char > > String
std::vector< T, Aws::Allocator< T > > Vector
Aws::Utils::Json::JsonValue JsonValue