AWS SDK for C++

AWS SDK for C++ Version 1.11.935

Loading...
Searching...
No Matches
CreateServiceRequest.h
1
6#pragma once
7#include <aws/core/utils/memory/stl/AWSString.h>
8#include <aws/core/utils/memory/stl/AWSVector.h>
9#include <aws/ecs/ECSRequest.h>
10#include <aws/ecs/ECS_EXPORTS.h>
11#include <aws/ecs/model/AvailabilityZoneRebalancing.h>
12#include <aws/ecs/model/CapacityProviderStrategyItem.h>
13#include <aws/ecs/model/DeploymentConfiguration.h>
14#include <aws/ecs/model/DeploymentController.h>
15#include <aws/ecs/model/GatewayConnector.h>
16#include <aws/ecs/model/LaunchType.h>
17#include <aws/ecs/model/LoadBalancer.h>
18#include <aws/ecs/model/MonitoringConfiguration.h>
19#include <aws/ecs/model/NetworkConfiguration.h>
20#include <aws/ecs/model/PlacementConstraint.h>
21#include <aws/ecs/model/PlacementStrategy.h>
22#include <aws/ecs/model/PropagateTags.h>
23#include <aws/ecs/model/SchedulingStrategy.h>
24#include <aws/ecs/model/ServiceConnectConfiguration.h>
25#include <aws/ecs/model/ServiceRegistry.h>
26#include <aws/ecs/model/ServiceVolumeConfiguration.h>
27#include <aws/ecs/model/Tag.h>
28#include <aws/ecs/model/VpcLatticeConfiguration.h>
29
30#include <utility>
31
32namespace Aws {
33namespace ECS {
34namespace Model {
35
42 public:
43 AWS_ECS_API CreateServiceRequest() = default;
44
45 // Service request name is the Operation name which will send this request out,
46 // each operation should has unique request name, so that we can get operation's name from this request.
47 // Note: this is not true for response, multiple operations may have the same response name,
48 // so we can not get operation's name from response.
49 inline virtual const char* GetServiceRequestName() const override { return "CreateService"; }
50
51 AWS_ECS_API Aws::String SerializePayload() const override;
52
54
56
61 inline const Aws::String& GetCluster() const { return m_cluster; }
62 inline bool ClusterHasBeenSet() const { return m_clusterHasBeenSet; }
63 template <typename ClusterT = Aws::String>
64 void SetCluster(ClusterT&& value) {
65 m_clusterHasBeenSet = true;
66 m_cluster = std::forward<ClusterT>(value);
67 }
68 template <typename ClusterT = Aws::String>
69 CreateServiceRequest& WithCluster(ClusterT&& value) {
70 SetCluster(std::forward<ClusterT>(value));
71 return *this;
72 }
74
76
82 inline const Aws::String& GetServiceName() const { return m_serviceName; }
83 inline bool ServiceNameHasBeenSet() const { return m_serviceNameHasBeenSet; }
84 template <typename ServiceNameT = Aws::String>
85 void SetServiceName(ServiceNameT&& value) {
86 m_serviceNameHasBeenSet = true;
87 m_serviceName = std::forward<ServiceNameT>(value);
88 }
89 template <typename ServiceNameT = Aws::String>
90 CreateServiceRequest& WithServiceName(ServiceNameT&& value) {
91 SetServiceName(std::forward<ServiceNameT>(value));
92 return *this;
93 }
95
97
108 inline const Aws::String& GetTaskDefinition() const { return m_taskDefinition; }
109 inline bool TaskDefinitionHasBeenSet() const { return m_taskDefinitionHasBeenSet; }
110 template <typename TaskDefinitionT = Aws::String>
111 void SetTaskDefinition(TaskDefinitionT&& value) {
112 m_taskDefinitionHasBeenSet = true;
113 m_taskDefinition = std::forward<TaskDefinitionT>(value);
114 }
115 template <typename TaskDefinitionT = Aws::String>
116 CreateServiceRequest& WithTaskDefinition(TaskDefinitionT&& value) {
117 SetTaskDefinition(std::forward<TaskDefinitionT>(value));
118 return *this;
119 }
121
123
138 inline AvailabilityZoneRebalancing GetAvailabilityZoneRebalancing() const { return m_availabilityZoneRebalancing; }
139 inline bool AvailabilityZoneRebalancingHasBeenSet() const { return m_availabilityZoneRebalancingHasBeenSet; }
141 m_availabilityZoneRebalancingHasBeenSet = true;
142 m_availabilityZoneRebalancing = value;
143 }
149
151
195 inline const Aws::Vector<LoadBalancer>& GetLoadBalancers() const { return m_loadBalancers; }
196 inline bool LoadBalancersHasBeenSet() const { return m_loadBalancersHasBeenSet; }
197 template <typename LoadBalancersT = Aws::Vector<LoadBalancer>>
198 void SetLoadBalancers(LoadBalancersT&& value) {
199 m_loadBalancersHasBeenSet = true;
200 m_loadBalancers = std::forward<LoadBalancersT>(value);
201 }
202 template <typename LoadBalancersT = Aws::Vector<LoadBalancer>>
203 CreateServiceRequest& WithLoadBalancers(LoadBalancersT&& value) {
204 SetLoadBalancers(std::forward<LoadBalancersT>(value));
205 return *this;
206 }
207 template <typename LoadBalancersT = LoadBalancer>
208 CreateServiceRequest& AddLoadBalancers(LoadBalancersT&& value) {
209 m_loadBalancersHasBeenSet = true;
210 m_loadBalancers.emplace_back(std::forward<LoadBalancersT>(value));
211 return *this;
212 }
214
216
224 inline const Aws::Vector<ServiceRegistry>& GetServiceRegistries() const { return m_serviceRegistries; }
225 inline bool ServiceRegistriesHasBeenSet() const { return m_serviceRegistriesHasBeenSet; }
226 template <typename ServiceRegistriesT = Aws::Vector<ServiceRegistry>>
227 void SetServiceRegistries(ServiceRegistriesT&& value) {
228 m_serviceRegistriesHasBeenSet = true;
229 m_serviceRegistries = std::forward<ServiceRegistriesT>(value);
230 }
231 template <typename ServiceRegistriesT = Aws::Vector<ServiceRegistry>>
232 CreateServiceRequest& WithServiceRegistries(ServiceRegistriesT&& value) {
233 SetServiceRegistries(std::forward<ServiceRegistriesT>(value));
234 return *this;
235 }
236 template <typename ServiceRegistriesT = ServiceRegistry>
237 CreateServiceRequest& AddServiceRegistries(ServiceRegistriesT&& value) {
238 m_serviceRegistriesHasBeenSet = true;
239 m_serviceRegistries.emplace_back(std::forward<ServiceRegistriesT>(value));
240 return *this;
241 }
243
245
252 inline int GetDesiredCount() const { return m_desiredCount; }
253 inline bool DesiredCountHasBeenSet() const { return m_desiredCountHasBeenSet; }
254 inline void SetDesiredCount(int value) {
255 m_desiredCountHasBeenSet = true;
256 m_desiredCount = value;
257 }
259 SetDesiredCount(value);
260 return *this;
261 }
263
265
270 inline const Aws::String& GetClientToken() const { return m_clientToken; }
271 inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
272 template <typename ClientTokenT = Aws::String>
273 void SetClientToken(ClientTokenT&& value) {
274 m_clientTokenHasBeenSet = true;
275 m_clientToken = std::forward<ClientTokenT>(value);
276 }
277 template <typename ClientTokenT = Aws::String>
278 CreateServiceRequest& WithClientToken(ClientTokenT&& value) {
279 SetClientToken(std::forward<ClientTokenT>(value));
280 return *this;
281 }
283
285
304 inline LaunchType GetLaunchType() const { return m_launchType; }
305 inline bool LaunchTypeHasBeenSet() const { return m_launchTypeHasBeenSet; }
306 inline void SetLaunchType(LaunchType value) {
307 m_launchTypeHasBeenSet = true;
308 m_launchType = value;
309 }
311 SetLaunchType(value);
312 return *this;
313 }
315
317
328 inline const Aws::Vector<CapacityProviderStrategyItem>& GetCapacityProviderStrategy() const { return m_capacityProviderStrategy; }
329 inline bool CapacityProviderStrategyHasBeenSet() const { return m_capacityProviderStrategyHasBeenSet; }
330 template <typename CapacityProviderStrategyT = Aws::Vector<CapacityProviderStrategyItem>>
331 void SetCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
332 m_capacityProviderStrategyHasBeenSet = true;
333 m_capacityProviderStrategy = std::forward<CapacityProviderStrategyT>(value);
334 }
335 template <typename CapacityProviderStrategyT = Aws::Vector<CapacityProviderStrategyItem>>
336 CreateServiceRequest& WithCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
337 SetCapacityProviderStrategy(std::forward<CapacityProviderStrategyT>(value));
338 return *this;
339 }
340 template <typename CapacityProviderStrategyT = CapacityProviderStrategyItem>
341 CreateServiceRequest& AddCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
342 m_capacityProviderStrategyHasBeenSet = true;
343 m_capacityProviderStrategy.emplace_back(std::forward<CapacityProviderStrategyT>(value));
344 return *this;
345 }
347
349
358 inline const Aws::String& GetPlatformVersion() const { return m_platformVersion; }
359 inline bool PlatformVersionHasBeenSet() const { return m_platformVersionHasBeenSet; }
360 template <typename PlatformVersionT = Aws::String>
361 void SetPlatformVersion(PlatformVersionT&& value) {
362 m_platformVersionHasBeenSet = true;
363 m_platformVersion = std::forward<PlatformVersionT>(value);
364 }
365 template <typename PlatformVersionT = Aws::String>
366 CreateServiceRequest& WithPlatformVersion(PlatformVersionT&& value) {
367 SetPlatformVersion(std::forward<PlatformVersionT>(value));
368 return *this;
369 }
371
373
397 inline const Aws::String& GetRole() const { return m_role; }
398 inline bool RoleHasBeenSet() const { return m_roleHasBeenSet; }
399 template <typename RoleT = Aws::String>
400 void SetRole(RoleT&& value) {
401 m_roleHasBeenSet = true;
402 m_role = std::forward<RoleT>(value);
403 }
404 template <typename RoleT = Aws::String>
406 SetRole(std::forward<RoleT>(value));
407 return *this;
408 }
410
412
416 inline const DeploymentConfiguration& GetDeploymentConfiguration() const { return m_deploymentConfiguration; }
417 inline bool DeploymentConfigurationHasBeenSet() const { return m_deploymentConfigurationHasBeenSet; }
418 template <typename DeploymentConfigurationT = DeploymentConfiguration>
419 void SetDeploymentConfiguration(DeploymentConfigurationT&& value) {
420 m_deploymentConfigurationHasBeenSet = true;
421 m_deploymentConfiguration = std::forward<DeploymentConfigurationT>(value);
422 }
423 template <typename DeploymentConfigurationT = DeploymentConfiguration>
424 CreateServiceRequest& WithDeploymentConfiguration(DeploymentConfigurationT&& value) {
425 SetDeploymentConfiguration(std::forward<DeploymentConfigurationT>(value));
426 return *this;
427 }
429
431
436 inline const Aws::Vector<PlacementConstraint>& GetPlacementConstraints() const { return m_placementConstraints; }
437 inline bool PlacementConstraintsHasBeenSet() const { return m_placementConstraintsHasBeenSet; }
438 template <typename PlacementConstraintsT = Aws::Vector<PlacementConstraint>>
439 void SetPlacementConstraints(PlacementConstraintsT&& value) {
440 m_placementConstraintsHasBeenSet = true;
441 m_placementConstraints = std::forward<PlacementConstraintsT>(value);
442 }
443 template <typename PlacementConstraintsT = Aws::Vector<PlacementConstraint>>
444 CreateServiceRequest& WithPlacementConstraints(PlacementConstraintsT&& value) {
445 SetPlacementConstraints(std::forward<PlacementConstraintsT>(value));
446 return *this;
447 }
448 template <typename PlacementConstraintsT = PlacementConstraint>
449 CreateServiceRequest& AddPlacementConstraints(PlacementConstraintsT&& value) {
450 m_placementConstraintsHasBeenSet = true;
451 m_placementConstraints.emplace_back(std::forward<PlacementConstraintsT>(value));
452 return *this;
453 }
455
457
461 inline const Aws::Vector<PlacementStrategy>& GetPlacementStrategy() const { return m_placementStrategy; }
462 inline bool PlacementStrategyHasBeenSet() const { return m_placementStrategyHasBeenSet; }
463 template <typename PlacementStrategyT = Aws::Vector<PlacementStrategy>>
464 void SetPlacementStrategy(PlacementStrategyT&& value) {
465 m_placementStrategyHasBeenSet = true;
466 m_placementStrategy = std::forward<PlacementStrategyT>(value);
467 }
468 template <typename PlacementStrategyT = Aws::Vector<PlacementStrategy>>
469 CreateServiceRequest& WithPlacementStrategy(PlacementStrategyT&& value) {
470 SetPlacementStrategy(std::forward<PlacementStrategyT>(value));
471 return *this;
472 }
473 template <typename PlacementStrategyT = PlacementStrategy>
474 CreateServiceRequest& AddPlacementStrategy(PlacementStrategyT&& value) {
475 m_placementStrategyHasBeenSet = true;
476 m_placementStrategy.emplace_back(std::forward<PlacementStrategyT>(value));
477 return *this;
478 }
480
482
491 inline const NetworkConfiguration& GetNetworkConfiguration() const { return m_networkConfiguration; }
492 inline bool NetworkConfigurationHasBeenSet() const { return m_networkConfigurationHasBeenSet; }
493 template <typename NetworkConfigurationT = NetworkConfiguration>
494 void SetNetworkConfiguration(NetworkConfigurationT&& value) {
495 m_networkConfigurationHasBeenSet = true;
496 m_networkConfiguration = std::forward<NetworkConfigurationT>(value);
497 }
498 template <typename NetworkConfigurationT = NetworkConfiguration>
499 CreateServiceRequest& WithNetworkConfiguration(NetworkConfigurationT&& value) {
500 SetNetworkConfiguration(std::forward<NetworkConfigurationT>(value));
501 return *this;
502 }
504
506
515 inline int GetHealthCheckGracePeriodSeconds() const { return m_healthCheckGracePeriodSeconds; }
516 inline bool HealthCheckGracePeriodSecondsHasBeenSet() const { return m_healthCheckGracePeriodSecondsHasBeenSet; }
517 inline void SetHealthCheckGracePeriodSeconds(int value) {
518 m_healthCheckGracePeriodSecondsHasBeenSet = true;
519 m_healthCheckGracePeriodSeconds = value;
520 }
523 return *this;
524 }
526
528
549 inline SchedulingStrategy GetSchedulingStrategy() const { return m_schedulingStrategy; }
550 inline bool SchedulingStrategyHasBeenSet() const { return m_schedulingStrategyHasBeenSet; }
552 m_schedulingStrategyHasBeenSet = true;
553 m_schedulingStrategy = value;
554 }
557 return *this;
558 }
560
562
566 inline const DeploymentController& GetDeploymentController() const { return m_deploymentController; }
567 inline bool DeploymentControllerHasBeenSet() const { return m_deploymentControllerHasBeenSet; }
568 template <typename DeploymentControllerT = DeploymentController>
569 void SetDeploymentController(DeploymentControllerT&& value) {
570 m_deploymentControllerHasBeenSet = true;
571 m_deploymentController = std::forward<DeploymentControllerT>(value);
572 }
573 template <typename DeploymentControllerT = DeploymentController>
574 CreateServiceRequest& WithDeploymentController(DeploymentControllerT&& value) {
575 SetDeploymentController(std::forward<DeploymentControllerT>(value));
576 return *this;
577 }
579
581
600 inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
601 inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
602 template <typename TagsT = Aws::Vector<Tag>>
603 void SetTags(TagsT&& value) {
604 m_tagsHasBeenSet = true;
605 m_tags = std::forward<TagsT>(value);
606 }
607 template <typename TagsT = Aws::Vector<Tag>>
609 SetTags(std::forward<TagsT>(value));
610 return *this;
611 }
612 template <typename TagsT = Tag>
614 m_tagsHasBeenSet = true;
615 m_tags.emplace_back(std::forward<TagsT>(value));
616 return *this;
617 }
619
621
629 inline bool GetEnableECSManagedTags() const { return m_enableECSManagedTags; }
630 inline bool EnableECSManagedTagsHasBeenSet() const { return m_enableECSManagedTagsHasBeenSet; }
631 inline void SetEnableECSManagedTags(bool value) {
632 m_enableECSManagedTagsHasBeenSet = true;
633 m_enableECSManagedTags = value;
634 }
637 return *this;
638 }
640
642
654 inline PropagateTags GetPropagateTags() const { return m_propagateTags; }
655 inline bool PropagateTagsHasBeenSet() const { return m_propagateTagsHasBeenSet; }
656 inline void SetPropagateTags(PropagateTags value) {
657 m_propagateTagsHasBeenSet = true;
658 m_propagateTags = value;
659 }
661 SetPropagateTags(value);
662 return *this;
663 }
665
667
672 inline bool GetEnableExecuteCommand() const { return m_enableExecuteCommand; }
673 inline bool EnableExecuteCommandHasBeenSet() const { return m_enableExecuteCommandHasBeenSet; }
674 inline void SetEnableExecuteCommand(bool value) {
675 m_enableExecuteCommandHasBeenSet = true;
676 m_enableExecuteCommand = value;
677 }
680 return *this;
681 }
683
685
696 inline const ServiceConnectConfiguration& GetServiceConnectConfiguration() const { return m_serviceConnectConfiguration; }
697 inline bool ServiceConnectConfigurationHasBeenSet() const { return m_serviceConnectConfigurationHasBeenSet; }
698 template <typename ServiceConnectConfigurationT = ServiceConnectConfiguration>
699 void SetServiceConnectConfiguration(ServiceConnectConfigurationT&& value) {
700 m_serviceConnectConfigurationHasBeenSet = true;
701 m_serviceConnectConfiguration = std::forward<ServiceConnectConfigurationT>(value);
702 }
703 template <typename ServiceConnectConfigurationT = ServiceConnectConfiguration>
704 CreateServiceRequest& WithServiceConnectConfiguration(ServiceConnectConfigurationT&& value) {
705 SetServiceConnectConfiguration(std::forward<ServiceConnectConfigurationT>(value));
706 return *this;
707 }
709
711
716 inline const Aws::Vector<ServiceVolumeConfiguration>& GetVolumeConfigurations() const { return m_volumeConfigurations; }
717 inline bool VolumeConfigurationsHasBeenSet() const { return m_volumeConfigurationsHasBeenSet; }
718 template <typename VolumeConfigurationsT = Aws::Vector<ServiceVolumeConfiguration>>
719 void SetVolumeConfigurations(VolumeConfigurationsT&& value) {
720 m_volumeConfigurationsHasBeenSet = true;
721 m_volumeConfigurations = std::forward<VolumeConfigurationsT>(value);
722 }
723 template <typename VolumeConfigurationsT = Aws::Vector<ServiceVolumeConfiguration>>
724 CreateServiceRequest& WithVolumeConfigurations(VolumeConfigurationsT&& value) {
725 SetVolumeConfigurations(std::forward<VolumeConfigurationsT>(value));
726 return *this;
727 }
728 template <typename VolumeConfigurationsT = ServiceVolumeConfiguration>
729 CreateServiceRequest& AddVolumeConfigurations(VolumeConfigurationsT&& value) {
730 m_volumeConfigurationsHasBeenSet = true;
731 m_volumeConfigurations.emplace_back(std::forward<VolumeConfigurationsT>(value));
732 return *this;
733 }
735
737
740 inline const Aws::Vector<VpcLatticeConfiguration>& GetVpcLatticeConfigurations() const { return m_vpcLatticeConfigurations; }
741 inline bool VpcLatticeConfigurationsHasBeenSet() const { return m_vpcLatticeConfigurationsHasBeenSet; }
742 template <typename VpcLatticeConfigurationsT = Aws::Vector<VpcLatticeConfiguration>>
743 void SetVpcLatticeConfigurations(VpcLatticeConfigurationsT&& value) {
744 m_vpcLatticeConfigurationsHasBeenSet = true;
745 m_vpcLatticeConfigurations = std::forward<VpcLatticeConfigurationsT>(value);
746 }
747 template <typename VpcLatticeConfigurationsT = Aws::Vector<VpcLatticeConfiguration>>
748 CreateServiceRequest& WithVpcLatticeConfigurations(VpcLatticeConfigurationsT&& value) {
749 SetVpcLatticeConfigurations(std::forward<VpcLatticeConfigurationsT>(value));
750 return *this;
751 }
752 template <typename VpcLatticeConfigurationsT = VpcLatticeConfiguration>
753 CreateServiceRequest& AddVpcLatticeConfigurations(VpcLatticeConfigurationsT&& value) {
754 m_vpcLatticeConfigurationsHasBeenSet = true;
755 m_vpcLatticeConfigurations.emplace_back(std::forward<VpcLatticeConfigurationsT>(value));
756 return *this;
757 }
759
761
765 inline const Aws::Vector<GatewayConnector>& GetGatewayConnectors() const { return m_gatewayConnectors; }
766 inline bool GatewayConnectorsHasBeenSet() const { return m_gatewayConnectorsHasBeenSet; }
767 template <typename GatewayConnectorsT = Aws::Vector<GatewayConnector>>
768 void SetGatewayConnectors(GatewayConnectorsT&& value) {
769 m_gatewayConnectorsHasBeenSet = true;
770 m_gatewayConnectors = std::forward<GatewayConnectorsT>(value);
771 }
772 template <typename GatewayConnectorsT = Aws::Vector<GatewayConnector>>
773 CreateServiceRequest& WithGatewayConnectors(GatewayConnectorsT&& value) {
774 SetGatewayConnectors(std::forward<GatewayConnectorsT>(value));
775 return *this;
776 }
777 template <typename GatewayConnectorsT = GatewayConnector>
778 CreateServiceRequest& AddGatewayConnectors(GatewayConnectorsT&& value) {
779 m_gatewayConnectorsHasBeenSet = true;
780 m_gatewayConnectors.emplace_back(std::forward<GatewayConnectorsT>(value));
781 return *this;
782 }
784
786
792 inline const MonitoringConfiguration& GetMonitoring() const { return m_monitoring; }
793 inline bool MonitoringHasBeenSet() const { return m_monitoringHasBeenSet; }
794 template <typename MonitoringT = MonitoringConfiguration>
795 void SetMonitoring(MonitoringT&& value) {
796 m_monitoringHasBeenSet = true;
797 m_monitoring = std::forward<MonitoringT>(value);
798 }
799 template <typename MonitoringT = MonitoringConfiguration>
800 CreateServiceRequest& WithMonitoring(MonitoringT&& value) {
801 SetMonitoring(std::forward<MonitoringT>(value));
802 return *this;
803 }
805 private:
806 Aws::String m_cluster;
807
808 Aws::String m_serviceName;
809
810 Aws::String m_taskDefinition;
811
813
814 Aws::Vector<LoadBalancer> m_loadBalancers;
815
816 Aws::Vector<ServiceRegistry> m_serviceRegistries;
817
818 int m_desiredCount{0};
819
820 Aws::String m_clientToken;
821
822 LaunchType m_launchType{LaunchType::NOT_SET};
823
824 Aws::Vector<CapacityProviderStrategyItem> m_capacityProviderStrategy;
825
826 Aws::String m_platformVersion;
827
828 Aws::String m_role;
829
830 DeploymentConfiguration m_deploymentConfiguration;
831
832 Aws::Vector<PlacementConstraint> m_placementConstraints;
833
834 Aws::Vector<PlacementStrategy> m_placementStrategy;
835
836 NetworkConfiguration m_networkConfiguration;
837
838 int m_healthCheckGracePeriodSeconds{0};
839
841
842 DeploymentController m_deploymentController;
843
844 Aws::Vector<Tag> m_tags;
845
846 bool m_enableECSManagedTags{false};
847
848 PropagateTags m_propagateTags{PropagateTags::NOT_SET};
849
850 bool m_enableExecuteCommand{false};
851
852 ServiceConnectConfiguration m_serviceConnectConfiguration;
853
854 Aws::Vector<ServiceVolumeConfiguration> m_volumeConfigurations;
855
856 Aws::Vector<VpcLatticeConfiguration> m_vpcLatticeConfigurations;
857
858 Aws::Vector<GatewayConnector> m_gatewayConnectors;
859
860 MonitoringConfiguration m_monitoring;
861 bool m_clusterHasBeenSet = false;
862 bool m_serviceNameHasBeenSet = false;
863 bool m_taskDefinitionHasBeenSet = false;
864 bool m_availabilityZoneRebalancingHasBeenSet = false;
865 bool m_loadBalancersHasBeenSet = false;
866 bool m_serviceRegistriesHasBeenSet = false;
867 bool m_desiredCountHasBeenSet = false;
868 bool m_clientTokenHasBeenSet = false;
869 bool m_launchTypeHasBeenSet = false;
870 bool m_capacityProviderStrategyHasBeenSet = false;
871 bool m_platformVersionHasBeenSet = false;
872 bool m_roleHasBeenSet = false;
873 bool m_deploymentConfigurationHasBeenSet = false;
874 bool m_placementConstraintsHasBeenSet = false;
875 bool m_placementStrategyHasBeenSet = false;
876 bool m_networkConfigurationHasBeenSet = false;
877 bool m_healthCheckGracePeriodSecondsHasBeenSet = false;
878 bool m_schedulingStrategyHasBeenSet = false;
879 bool m_deploymentControllerHasBeenSet = false;
880 bool m_tagsHasBeenSet = false;
881 bool m_enableECSManagedTagsHasBeenSet = false;
882 bool m_propagateTagsHasBeenSet = false;
883 bool m_enableExecuteCommandHasBeenSet = false;
884 bool m_serviceConnectConfigurationHasBeenSet = false;
885 bool m_volumeConfigurationsHasBeenSet = false;
886 bool m_vpcLatticeConfigurationsHasBeenSet = false;
887 bool m_gatewayConnectorsHasBeenSet = false;
888 bool m_monitoringHasBeenSet = false;
889};
890
891} // namespace Model
892} // namespace ECS
893} // namespace Aws
void SetTaskDefinition(TaskDefinitionT &&value)
AWS_ECS_API CreateServiceRequest()=default
void SetDeploymentController(DeploymentControllerT &&value)
CreateServiceRequest & AddPlacementStrategy(PlacementStrategyT &&value)
void SetCapacityProviderStrategy(CapacityProviderStrategyT &&value)
CreateServiceRequest & WithLoadBalancers(LoadBalancersT &&value)
void SetPlacementConstraints(PlacementConstraintsT &&value)
void SetVpcLatticeConfigurations(VpcLatticeConfigurationsT &&value)
const Aws::Vector< LoadBalancer > & GetLoadBalancers() const
void SetNetworkConfiguration(NetworkConfigurationT &&value)
CreateServiceRequest & WithPropagateTags(PropagateTags value)
CreateServiceRequest & WithMonitoring(MonitoringT &&value)
const Aws::Vector< GatewayConnector > & GetGatewayConnectors() const
const MonitoringConfiguration & GetMonitoring() const
CreateServiceRequest & AddVpcLatticeConfigurations(VpcLatticeConfigurationsT &&value)
void SetServiceConnectConfiguration(ServiceConnectConfigurationT &&value)
CreateServiceRequest & WithVolumeConfigurations(VolumeConfigurationsT &&value)
CreateServiceRequest & AddCapacityProviderStrategy(CapacityProviderStrategyT &&value)
CreateServiceRequest & WithRole(RoleT &&value)
CreateServiceRequest & AddServiceRegistries(ServiceRegistriesT &&value)
const DeploymentConfiguration & GetDeploymentConfiguration() const
CreateServiceRequest & WithDeploymentController(DeploymentControllerT &&value)
CreateServiceRequest & WithPlacementConstraints(PlacementConstraintsT &&value)
CreateServiceRequest & AddVolumeConfigurations(VolumeConfigurationsT &&value)
const NetworkConfiguration & GetNetworkConfiguration() const
CreateServiceRequest & AddLoadBalancers(LoadBalancersT &&value)
CreateServiceRequest & WithEnableExecuteCommand(bool value)
AWS_ECS_API Aws::String SerializePayload() const override
CreateServiceRequest & WithDeploymentConfiguration(DeploymentConfigurationT &&value)
CreateServiceRequest & WithClientToken(ClientTokenT &&value)
CreateServiceRequest & WithSchedulingStrategy(SchedulingStrategy value)
void SetDeploymentConfiguration(DeploymentConfigurationT &&value)
CreateServiceRequest & WithLaunchType(LaunchType value)
CreateServiceRequest & WithServiceConnectConfiguration(ServiceConnectConfigurationT &&value)
CreateServiceRequest & WithEnableECSManagedTags(bool value)
const Aws::String & GetTaskDefinition() const
CreateServiceRequest & AddPlacementConstraints(PlacementConstraintsT &&value)
CreateServiceRequest & WithCapacityProviderStrategy(CapacityProviderStrategyT &&value)
void SetServiceRegistries(ServiceRegistriesT &&value)
CreateServiceRequest & WithHealthCheckGracePeriodSeconds(int value)
virtual const char * GetServiceRequestName() const override
const Aws::Vector< PlacementConstraint > & GetPlacementConstraints() const
SchedulingStrategy GetSchedulingStrategy() const
CreateServiceRequest & WithDesiredCount(int value)
CreateServiceRequest & AddGatewayConnectors(GatewayConnectorsT &&value)
const Aws::Vector< VpcLatticeConfiguration > & GetVpcLatticeConfigurations() const
AWS_ECS_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override
void SetGatewayConnectors(GatewayConnectorsT &&value)
const Aws::Vector< ServiceRegistry > & GetServiceRegistries() const
const DeploymentController & GetDeploymentController() const
const Aws::Vector< Tag > & GetTags() const
const Aws::Vector< PlacementStrategy > & GetPlacementStrategy() const
void SetLoadBalancers(LoadBalancersT &&value)
const Aws::String & GetServiceName() const
CreateServiceRequest & WithServiceName(ServiceNameT &&value)
void SetAvailabilityZoneRebalancing(AvailabilityZoneRebalancing value)
CreateServiceRequest & AddTags(TagsT &&value)
CreateServiceRequest & WithCluster(ClusterT &&value)
void SetVolumeConfigurations(VolumeConfigurationsT &&value)
CreateServiceRequest & WithVpcLatticeConfigurations(VpcLatticeConfigurationsT &&value)
CreateServiceRequest & WithTaskDefinition(TaskDefinitionT &&value)
const Aws::String & GetPlatformVersion() const
CreateServiceRequest & WithPlatformVersion(PlatformVersionT &&value)
CreateServiceRequest & WithTags(TagsT &&value)
void SetPlacementStrategy(PlacementStrategyT &&value)
const Aws::Vector< CapacityProviderStrategyItem > & GetCapacityProviderStrategy() const
CreateServiceRequest & WithPlacementStrategy(PlacementStrategyT &&value)
AvailabilityZoneRebalancing GetAvailabilityZoneRebalancing() const
void SetServiceName(ServiceNameT &&value)
void SetPlatformVersion(PlatformVersionT &&value)
const Aws::String & GetClientToken() const
const ServiceConnectConfiguration & GetServiceConnectConfiguration() const
const Aws::Vector< ServiceVolumeConfiguration > & GetVolumeConfigurations() const
CreateServiceRequest & WithServiceRegistries(ServiceRegistriesT &&value)
void SetSchedulingStrategy(SchedulingStrategy value)
CreateServiceRequest & WithAvailabilityZoneRebalancing(AvailabilityZoneRebalancing value)
CreateServiceRequest & WithGatewayConnectors(GatewayConnectorsT &&value)
CreateServiceRequest & WithNetworkConfiguration(NetworkConfigurationT &&value)
Aws::Map< Aws::String, Aws::String > HeaderValueCollection
std::basic_string< char, std::char_traits< char >, Aws::Allocator< char > > String
std::vector< T, Aws::Allocator< T > > Vector