/******************************************************************************* * Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * Licensed under the Apache License, Version 2.0 (the "License"). You may not use * this file except in compliance with the License. A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. * This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. * ***************************************************************************** * * AWS Tools for Windows (TM) PowerShell (TM) * */ using System; using System.Collections.Generic; using System.Linq; using System.Management.Automation; using System.Text; using Amazon.PowerShell.Common; using Amazon.Runtime; using Amazon.ECS; using Amazon.ECS.Model; namespace Amazon.PowerShell.Cmdlets.ECS { /// /// Modifies the parameters of a service. /// /// /// /// For services using the rolling update (ECS) you can update the desired /// count, deployment configuration, network configuration, load balancers, service registries, /// enable ECS managed tags option, propagate tags option, task placement constraints /// and strategies, and task definition. When you update any of these parameters, Amazon /// ECS starts new tasks with the new configuration. /// /// For services using the blue/green (CODE_DEPLOY) deployment controller, /// only the desired count, deployment configuration, health check grace period, task /// placement constraints and strategies, enable ECS managed tags option, and propagate /// tags can be updated using this API. If the network configuration, platform version, /// task definition, or load balancer need to be updated, create a new CodeDeploy deployment. /// For more information, see CreateDeployment /// in the CodeDeploy API Reference. /// /// For services using an external deployment controller, you can update only the desired /// count, task placement constraints and strategies, health check grace period, enable /// ECS managed tags option, and propagate tags option, using this API. If the launch /// type, load balancer, network configuration, platform version, or task definition need /// to be updated, create a new task set For more information, see CreateTaskSet. /// /// You can add to or subtract from the number of instantiations of a task definition /// in a service by specifying the cluster that the service is running in and a new desiredCount /// parameter. /// /// If you have updated the Docker image of your application, you can create a new task /// definition with that image and deploy it to your service. The service scheduler uses /// the minimum healthy percent and maximum percent parameters (in the service's deployment /// configuration) to determine the deployment strategy. /// /// If your updated Docker image uses the same tag as what is in the existing task definition /// for your service (for example, my_image:latest), you don't need to create /// a new revision of your task definition. You can update the service using the forceNewDeployment /// option. The new tasks launched by the deployment pull the current image/tag combination /// from your repository when they start. /// /// You can also update the deployment configuration of a service. When a deployment is /// triggered by updating the task definition of a service, the service scheduler uses /// the deployment configuration parameters, minimumHealthyPercent and maximumPercent, /// to determine the deployment strategy. /// /// When UpdateService stops a task during a deployment, the equivalent of docker /// stop is issued to the containers running in the task. This results in a SIGTERM /// and a 30-second timeout. After this, SIGKILL is sent and the containers /// are forcibly stopped. If the container handles the SIGTERM gracefully /// and exits within 30 seconds from receiving it, no SIGKILL is sent. /// /// When the service scheduler launches new tasks, it determines task placement in your /// cluster with the following logic. /// /// When the service scheduler stops running tasks, it attempts to maintain balance across /// the Availability Zones in your cluster using the following logic: /// /// You must have a service-linked role when you update any of the following service properties. /// If you specified a custom role when you created the service, Amazon ECS automatically /// replaces the roleARN /// associated with the service with the ARN of your service-linked role. For more information, /// see Service-linked /// roles in the Amazon Elastic Container Service Developer Guide. /// /// [Cmdlet("Update", "ECSService", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)] [OutputType("Amazon.ECS.Model.Service")] [AWSCmdlet("Calls the Amazon EC2 Container Service UpdateService API operation.", Operation = new[] {"UpdateService"}, SelectReturnType = typeof(Amazon.ECS.Model.UpdateServiceResponse))] [AWSCmdletOutput("Amazon.ECS.Model.Service or Amazon.ECS.Model.UpdateServiceResponse", "This cmdlet returns an Amazon.ECS.Model.Service object.", "The service call response (type Amazon.ECS.Model.UpdateServiceResponse) can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack." )] public partial class UpdateECSServiceCmdlet : AmazonECSClientCmdlet, IExecutor { #region Parameter Alarms_AlarmName /// /// /// One or more CloudWatch alarm names. Use a "," to separate the alarms. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DeploymentConfiguration_Alarms_AlarmNames")] public System.String[] Alarms_AlarmName { get; set; } #endregion #region Parameter AwsvpcConfiguration_AssignPublicIp /// /// /// Whether the task's elastic network interface receives a public IP address. The default /// value is DISABLED. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("NetworkConfiguration_AwsvpcConfiguration_AssignPublicIp")] [AWSConstantClassSource("Amazon.ECS.AssignPublicIp")] public Amazon.ECS.AssignPublicIp AwsvpcConfiguration_AssignPublicIp { get; set; } #endregion #region Parameter CapacityProviderStrategy /// /// /// The capacity provider strategy to update the service to use.if the service uses the default capacity provider strategy for the cluster, the service /// can be updated to use one or more capacity providers as opposed to the default capacity /// provider strategy. However, when a service is using a capacity provider strategy that's /// not the default capacity provider strategy, the service can't be updated to use the /// cluster's default capacity provider strategy.A capacity provider strategy consists of one or more capacity providers along with /// the base and weight to assign to them. A capacity provider /// must be associated with the cluster to be used in a capacity provider strategy. The /// PutClusterCapacityProviders API is used to associate a capacity provider with /// a cluster. Only capacity providers with an ACTIVE or UPDATING /// status can be used.If specifying a capacity provider that uses an Auto Scaling group, the capacity provider /// must already be created. New capacity providers can be created with the CreateCapacityProvider /// API operation.To use a Fargate capacity provider, specify either the FARGATE or FARGATE_SPOT /// capacity providers. The Fargate capacity providers are available to all accounts and /// only need to be associated with a cluster to be used.The PutClusterCapacityProviders API operation is used to update the list of /// available capacity providers for a cluster after the cluster is created. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public Amazon.ECS.Model.CapacityProviderStrategyItem[] CapacityProviderStrategy { get; set; } #endregion #region Parameter Cluster /// /// /// The short name or full Amazon Resource Name (ARN) of the cluster that your service /// runs on. If you do not specify a cluster, the default cluster is assumed. /// /// [System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true)] public System.String Cluster { get; set; } #endregion #region Parameter DesiredCount /// /// /// The number of instantiations of the task to place and keep running in your service. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? DesiredCount { get; set; } #endregion #region Parameter Alarms_Enable /// /// /// Determines whether to use the CloudWatch alarm option in the service deployment process. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DeploymentConfiguration_Alarms_Enable")] public System.Boolean? Alarms_Enable { get; set; } #endregion #region Parameter DeploymentCircuitBreaker_Enable /// /// /// Determines whether to use the deployment circuit breaker logic for the service. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DeploymentConfiguration_DeploymentCircuitBreaker_Enable")] public System.Boolean? DeploymentCircuitBreaker_Enable { get; set; } #endregion #region Parameter ServiceConnectConfiguration_Enabled /// /// /// Specifies whether to use Service Connect with this service. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? ServiceConnectConfiguration_Enabled { get; set; } #endregion #region Parameter EnableECSManagedTag /// /// /// Determines whether to turn on Amazon ECS managed tags for the tasks in the service. /// For more information, see Tagging /// Your Amazon ECS Resources in the Amazon Elastic Container Service Developer /// Guide.Only tasks launched after the update will reflect the update. To update the tags on /// all tasks, set forceNewDeployment to true, so that Amazon /// ECS starts new tasks with the updated tags. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("EnableECSManagedTags")] public System.Boolean? EnableECSManagedTag { get; set; } #endregion #region Parameter EnableExecuteCommand /// /// /// If true, this enables execute command functionality on all task containers.If you do not want to override the value that was set when the service was created, /// you can set this to null when performing this action. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? EnableExecuteCommand { get; set; } #endregion #region Parameter ForceNewDeployment /// /// /// Determines whether to force a new deployment of the service. By default, deployments /// aren't forced. You can use this option to start a new deployment with no service definition /// changes. For example, you can update a service's tasks to use a newer Docker image /// with the same image/tag combination (my_image:latest) or to roll Fargate /// tasks onto a newer platform version. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? ForceNewDeployment { get; set; } #endregion #region Parameter HealthCheckGracePeriodSecond /// /// /// The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy /// Elastic Load Balancing target health checks after a task has first started. This is /// only valid if your service is configured to use a load balancer. If your service's /// tasks take a while to start and respond to Elastic Load Balancing health checks, you /// can specify a health check grace period of up to 2,147,483,647 seconds. During that /// time, the Amazon ECS service scheduler ignores the Elastic Load Balancing health check /// status. This grace period can prevent the ECS service scheduler from marking tasks /// as unhealthy and stopping them before they have time to come up. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("HealthCheckGracePeriodSeconds")] public System.Int32? HealthCheckGracePeriodSecond { get; set; } #endregion #region Parameter LoadBalancer /// /// /// A list of Elastic Load Balancing load balancer objects. It contains the load balancer /// name, the container name, and the container port to access from the load balancer. /// The container name is as it appears in a container definition.When you add, update, or remove a load balancer configuration, Amazon ECS starts new /// tasks with the updated Elastic Load Balancing configuration, and then stops the old /// tasks when the new tasks are running.For services that use rolling updates, you can add, update, or remove Elastic Load /// Balancing target groups. You can update from a single target group to multiple target /// groups and from multiple target groups to a single target group.For services that use blue/green deployments, you can update Elastic Load Balancing /// target groups by using CreateDeployment through CodeDeploy. Note that multiple target groups are not supported for /// blue/green deployments. For more information see Register /// multiple target groups with a service in the Amazon Elastic Container Service /// Developer Guide. For services that use the external deployment controller, you can add, update, or /// remove load balancers by using CreateTaskSet. /// Note that multiple target groups are not supported for external deployments. For more /// information see Register /// multiple target groups with a service in the Amazon Elastic Container Service /// Developer Guide. You can remove existing loadBalancers by passing an empty list. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("LoadBalancers")] public Amazon.ECS.Model.LoadBalancer[] LoadBalancer { get; set; } #endregion #region Parameter LogConfiguration_LogDriver /// /// /// The log driver to use for the container.For tasks on Fargate, the supported log drivers are awslogs, splunk, /// and awsfirelens.For tasks hosted on Amazon EC2 instances, the supported log drivers are awslogs, /// fluentd, gelf, json-file, journald, /// logentries,syslog, splunk, and awsfirelens.For more information about using the awslogs log driver, see Using /// the awslogs log driver in the Amazon Elastic Container Service Developer Guide.For more information about using the awsfirelens log driver, see Custom /// log routing in the Amazon Elastic Container Service Developer Guide.If you have a custom driver that isn't listed, you can fork the Amazon ECS container /// agent project that's available on /// GitHub and customize it to work with that driver. We encourage you to submit pull /// requests for changes that you would like to have included. However, we don't currently /// provide support for running modified copies of this software. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("ServiceConnectConfiguration_LogConfiguration_LogDriver")] [AWSConstantClassSource("Amazon.ECS.LogDriver")] public Amazon.ECS.LogDriver LogConfiguration_LogDriver { get; set; } #endregion #region Parameter DeploymentConfiguration_MaximumPercent /// /// /// If a service is using the rolling update (ECS) deployment type, the maximumPercent /// parameter represents an upper limit on the number of your service's tasks that are /// allowed in the RUNNING or PENDING state during a deployment, /// as a percentage of the desiredCount (rounded down to the nearest integer). /// This parameter enables you to define the deployment batch size. For example, if your /// service is using the REPLICA service scheduler and has a desiredCount /// of four tasks and a maximumPercent value of 200%, the scheduler may start /// four new tasks before stopping the four older tasks (provided that the cluster resources /// required to do this are available). The default maximumPercent value /// for a service using the REPLICA service scheduler is 200%.If a service is using either the blue/green (CODE_DEPLOY) or EXTERNAL /// deployment types and tasks that use the EC2 launch type, the maximum percent /// value is set to the default value and is used to define the upper limit on the number /// of the tasks in the service that remain in the RUNNING state while the /// container instances are in the DRAINING state. If the tasks in the service /// use the Fargate launch type, the maximum percent value is not used, although it is /// returned when describing your service. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? DeploymentConfiguration_MaximumPercent { get; set; } #endregion #region Parameter DeploymentConfiguration_MinimumHealthyPercent /// /// /// If a service is using the rolling update (ECS) deployment type, the minimumHealthyPercent /// represents a lower limit on the number of your service's tasks that must remain in /// the RUNNING state during a deployment, as a percentage of the desiredCount /// (rounded up to the nearest integer). This parameter enables you to deploy without /// using additional cluster capacity. For example, if your service has a desiredCount /// of four tasks and a minimumHealthyPercent of 50%, the service scheduler /// may stop two existing tasks to free up cluster capacity before starting two new tasks. /// For services that do not use a load balancer, the following should be noted:For services are that do use a load balancer, the following should be noted:If a service is using either the blue/green (CODE_DEPLOY) or EXTERNAL /// deployment types and is running tasks that use the EC2 launch type, the minimum /// healthy percent value is set to the default value and is used to define the lower /// limit on the number of the tasks in the service that remain in the RUNNING /// state while the container instances are in the DRAINING state. If a service /// is using either the blue/green (CODE_DEPLOY) or EXTERNAL /// deployment types and is running tasks that use the Fargate launch type, the minimum /// healthy percent value is not used, although it is returned when describing your service. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? DeploymentConfiguration_MinimumHealthyPercent { get; set; } #endregion #region Parameter ServiceConnectConfiguration_Namespace /// /// /// The namespace name or full Amazon Resource Name (ARN) of the Cloud Map namespace for /// use with Service Connect. The namespace must be in the same Amazon Web Services Region /// as the Amazon ECS service and cluster. The type of namespace doesn't affect Service /// Connect. For more information about Cloud Map, see Working /// with Services in the Cloud Map Developer Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String ServiceConnectConfiguration_Namespace { get; set; } #endregion #region Parameter LogConfiguration_Option /// /// /// The configuration options to send to the log driver. This parameter requires version /// 1.19 of the Docker Remote API or greater on your container instance. To check the /// Docker Remote API version on your container instance, log in to your container instance /// and run the following command: sudo docker version --format '{{.Server.APIVersion}}' /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("ServiceConnectConfiguration_LogConfiguration_Options")] public System.Collections.Hashtable LogConfiguration_Option { get; set; } #endregion #region Parameter PlacementConstraint /// /// /// An array of task placement constraint objects to update the service to use. If no /// value is specified, the existing placement constraints for the service will remain /// unchanged. If this value is specified, it will override any existing placement constraints /// defined for the service. To remove all existing placement constraints, specify an /// empty array.You can specify a maximum of 10 constraints for each task. This limit includes constraints /// in the task definition and those specified at runtime. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("PlacementConstraints")] public Amazon.ECS.Model.PlacementConstraint[] PlacementConstraint { get; set; } #endregion #region Parameter PlacementStrategy /// /// /// The task placement strategy objects to update the service to use. If no value is specified, /// the existing placement strategy for the service will remain unchanged. If this value /// is specified, it will override the existing placement strategy defined for the service. /// To remove an existing placement strategy, specify an empty object.You can specify a maximum of five strategy rules for each service. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public Amazon.ECS.Model.PlacementStrategy[] PlacementStrategy { get; set; } #endregion #region Parameter PlatformVersion /// /// /// The platform version that your tasks in the service run on. A platform version is /// only specified for tasks using the Fargate launch type. If a platform version is not /// specified, the LATEST platform version is used. For more information, /// see Fargate /// Platform Versions in the Amazon Elastic Container Service Developer Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String PlatformVersion { get; set; } #endregion #region Parameter PropagateTag /// /// /// Determines whether to propagate the tags from the task definition or the service to /// the task. If no value is specified, the tags aren't propagated.Only tasks launched after the update will reflect the update. To update the tags on /// all tasks, set forceNewDeployment to true, so that Amazon /// ECS starts new tasks with the updated tags. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("PropagateTags")] [AWSConstantClassSource("Amazon.ECS.PropagateTags")] public Amazon.ECS.PropagateTags PropagateTag { get; set; } #endregion #region Parameter Alarms_Rollback /// /// /// Determines whether to configure Amazon ECS to roll back the service if a service deployment /// fails. If rollback is used, when a service deployment fails, the service is rolled /// back to the last deployment that completed successfully. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DeploymentConfiguration_Alarms_Rollback")] public System.Boolean? Alarms_Rollback { get; set; } #endregion #region Parameter DeploymentCircuitBreaker_Rollback /// /// /// Determines whether to configure Amazon ECS to roll back the service if a service deployment /// fails. If rollback is on, when a service deployment fails, the service is rolled back /// to the last deployment that completed successfully. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DeploymentConfiguration_DeploymentCircuitBreaker_Rollback")] public System.Boolean? DeploymentCircuitBreaker_Rollback { get; set; } #endregion #region Parameter LogConfiguration_SecretOption /// /// /// The secrets to pass to the log configuration. For more information, see Specifying /// sensitive data in the Amazon Elastic Container Service Developer Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("ServiceConnectConfiguration_LogConfiguration_SecretOptions")] public Amazon.ECS.Model.Secret[] LogConfiguration_SecretOption { get; set; } #endregion #region Parameter AwsvpcConfiguration_SecurityGroup /// /// /// The IDs of the security groups associated with the task or service. If you don't specify /// a security group, the default security group for the VPC is used. There's a limit /// of 5 security groups that can be specified per AwsVpcConfiguration.All specified security groups must be from the same VPC. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("NetworkConfiguration_AwsvpcConfiguration_SecurityGroups")] public System.String[] AwsvpcConfiguration_SecurityGroup { get; set; } #endregion #region Parameter Service /// /// /// The name of the service to update. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.String Service { get; set; } #endregion #region Parameter ServiceRegistry /// /// /// The details for the service discovery registries to assign to this service. For more /// information, see Service /// Discovery.When you add, update, or remove the service registries configuration, Amazon ECS starts /// new tasks with the updated service registries configuration, and then stops the old /// tasks when the new tasks are running.You can remove existing serviceRegistries by passing an empty list. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("ServiceRegistries")] public Amazon.ECS.Model.ServiceRegistry[] ServiceRegistry { get; set; } #endregion #region Parameter ServiceConnectConfiguration_Service /// /// /// The list of Service Connect service objects. These are names and aliases (also known /// as endpoints) that are used by other Amazon ECS services to connect to this service. /// This field is not required for a "client" Amazon ECS service that's a member of a /// namespace only to connect to other services within the namespace. An example of this /// would be a frontend application that accepts incoming requests from either a load /// balancer that's attached to the service or by other means.An object selects a port from the task definition, assigns a name for the Cloud Map /// service, and a list of aliases (endpoints) and ports for client applications to refer /// to this service. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("ServiceConnectConfiguration_Services")] public Amazon.ECS.Model.ServiceConnectService[] ServiceConnectConfiguration_Service { get; set; } #endregion #region Parameter AwsvpcConfiguration_Subnet /// /// /// The IDs of the subnets associated with the task or service. There's a limit of 16 /// subnets that can be specified per AwsVpcConfiguration.All specified subnets must be from the same VPC. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("NetworkConfiguration_AwsvpcConfiguration_Subnets")] public System.String[] AwsvpcConfiguration_Subnet { get; set; } #endregion #region Parameter TaskDefinition /// /// /// The family and revision (family:revision) or /// full ARN of the task definition to run in your service. If a revision /// is not specified, the latest ACTIVE revision is used. If you modify the /// task definition with UpdateService, Amazon ECS spawns a task with the /// new version of the task definition and then stops an old task after the new version /// is running. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String TaskDefinition { get; set; } #endregion #region Parameter Select /// /// Use the -Select parameter to control the cmdlet output. The default value is 'Service'. /// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.ECS.Model.UpdateServiceResponse). /// Specifying the name of a property of type Amazon.ECS.Model.UpdateServiceResponse will result in that property being returned. /// Specifying -Select '^ParameterName' will result in the cmdlet returning the selected cmdlet parameter value. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public string Select { get; set; } = "Service"; #endregion #region Parameter PassThru /// /// Changes the cmdlet behavior to return the value passed to the Cluster parameter. /// The -PassThru parameter is deprecated, use -Select '^Cluster' instead. This parameter will be removed in a future version. /// [System.Obsolete("The -PassThru parameter is deprecated, use -Select '^Cluster' instead. This parameter will be removed in a future version.")] [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter PassThru { get; set; } #endregion #region Parameter Force /// /// This parameter overrides confirmation prompts to force /// the cmdlet to continue its operation. This parameter should always /// be used with caution. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter Force { get; set; } #endregion protected override void ProcessRecord() { this._AWSSignerType = "v4"; base.ProcessRecord(); var resourceIdentifiersText = FormatParameterValuesForConfirmationMsg(nameof(this.Service), MyInvocation.BoundParameters); if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "Update-ECSService (UpdateService)")) { return; } var context = new CmdletContext(); // allow for manipulation of parameters prior to loading into context PreExecutionContextLoad(context); #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute if (ParameterWasBound(nameof(this.Select))) { context.Select = CreateSelectDelegate(Select) ?? throw new System.ArgumentException("Invalid value for -Select parameter.", nameof(this.Select)); if (this.PassThru.IsPresent) { throw new System.ArgumentException("-PassThru cannot be used when -Select is specified.", nameof(this.Select)); } } else if (this.PassThru.IsPresent) { context.Select = (response, cmdlet) => this.Cluster; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute if (this.CapacityProviderStrategy != null) { context.CapacityProviderStrategy = new List(this.CapacityProviderStrategy); } context.Cluster = this.Cluster; if (this.Alarms_AlarmName != null) { context.Alarms_AlarmName = new List(this.Alarms_AlarmName); } context.Alarms_Enable = this.Alarms_Enable; context.Alarms_Rollback = this.Alarms_Rollback; context.DeploymentCircuitBreaker_Enable = this.DeploymentCircuitBreaker_Enable; context.DeploymentCircuitBreaker_Rollback = this.DeploymentCircuitBreaker_Rollback; context.DeploymentConfiguration_MaximumPercent = this.DeploymentConfiguration_MaximumPercent; context.DeploymentConfiguration_MinimumHealthyPercent = this.DeploymentConfiguration_MinimumHealthyPercent; context.DesiredCount = this.DesiredCount; context.EnableECSManagedTag = this.EnableECSManagedTag; context.EnableExecuteCommand = this.EnableExecuteCommand; context.ForceNewDeployment = this.ForceNewDeployment; context.HealthCheckGracePeriodSecond = this.HealthCheckGracePeriodSecond; if (this.LoadBalancer != null) { context.LoadBalancer = new List(this.LoadBalancer); } context.AwsvpcConfiguration_AssignPublicIp = this.AwsvpcConfiguration_AssignPublicIp; if (this.AwsvpcConfiguration_SecurityGroup != null) { context.AwsvpcConfiguration_SecurityGroup = new List(this.AwsvpcConfiguration_SecurityGroup); } if (this.AwsvpcConfiguration_Subnet != null) { context.AwsvpcConfiguration_Subnet = new List(this.AwsvpcConfiguration_Subnet); } if (this.PlacementConstraint != null) { context.PlacementConstraint = new List(this.PlacementConstraint); } if (this.PlacementStrategy != null) { context.PlacementStrategy = new List(this.PlacementStrategy); } context.PlatformVersion = this.PlatformVersion; context.PropagateTag = this.PropagateTag; context.Service = this.Service; #if MODULAR if (this.Service == null && ParameterWasBound(nameof(this.Service))) { WriteWarning("You are passing $null as a value for parameter Service which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.ServiceConnectConfiguration_Enabled = this.ServiceConnectConfiguration_Enabled; context.LogConfiguration_LogDriver = this.LogConfiguration_LogDriver; if (this.LogConfiguration_Option != null) { context.LogConfiguration_Option = new Dictionary(StringComparer.Ordinal); foreach (var hashKey in this.LogConfiguration_Option.Keys) { context.LogConfiguration_Option.Add((String)hashKey, (String)(this.LogConfiguration_Option[hashKey])); } } if (this.LogConfiguration_SecretOption != null) { context.LogConfiguration_SecretOption = new List(this.LogConfiguration_SecretOption); } context.ServiceConnectConfiguration_Namespace = this.ServiceConnectConfiguration_Namespace; if (this.ServiceConnectConfiguration_Service != null) { context.ServiceConnectConfiguration_Service = new List(this.ServiceConnectConfiguration_Service); } if (this.ServiceRegistry != null) { context.ServiceRegistry = new List(this.ServiceRegistry); } context.TaskDefinition = this.TaskDefinition; // allow further manipulation of loaded context prior to processing PostExecutionContextLoad(context); var output = Execute(context) as CmdletOutput; ProcessOutput(output); } #region IExecutor Members public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.ECS.Model.UpdateServiceRequest(); if (cmdletContext.CapacityProviderStrategy != null) { request.CapacityProviderStrategy = cmdletContext.CapacityProviderStrategy; } if (cmdletContext.Cluster != null) { request.Cluster = cmdletContext.Cluster; } // populate DeploymentConfiguration var requestDeploymentConfigurationIsNull = true; request.DeploymentConfiguration = new Amazon.ECS.Model.DeploymentConfiguration(); System.Int32? requestDeploymentConfiguration_deploymentConfiguration_MaximumPercent = null; if (cmdletContext.DeploymentConfiguration_MaximumPercent != null) { requestDeploymentConfiguration_deploymentConfiguration_MaximumPercent = cmdletContext.DeploymentConfiguration_MaximumPercent.Value; } if (requestDeploymentConfiguration_deploymentConfiguration_MaximumPercent != null) { request.DeploymentConfiguration.MaximumPercent = requestDeploymentConfiguration_deploymentConfiguration_MaximumPercent.Value; requestDeploymentConfigurationIsNull = false; } System.Int32? requestDeploymentConfiguration_deploymentConfiguration_MinimumHealthyPercent = null; if (cmdletContext.DeploymentConfiguration_MinimumHealthyPercent != null) { requestDeploymentConfiguration_deploymentConfiguration_MinimumHealthyPercent = cmdletContext.DeploymentConfiguration_MinimumHealthyPercent.Value; } if (requestDeploymentConfiguration_deploymentConfiguration_MinimumHealthyPercent != null) { request.DeploymentConfiguration.MinimumHealthyPercent = requestDeploymentConfiguration_deploymentConfiguration_MinimumHealthyPercent.Value; requestDeploymentConfigurationIsNull = false; } Amazon.ECS.Model.DeploymentCircuitBreaker requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker = null; // populate DeploymentCircuitBreaker var requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreakerIsNull = true; requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker = new Amazon.ECS.Model.DeploymentCircuitBreaker(); System.Boolean? requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker_deploymentCircuitBreaker_Enable = null; if (cmdletContext.DeploymentCircuitBreaker_Enable != null) { requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker_deploymentCircuitBreaker_Enable = cmdletContext.DeploymentCircuitBreaker_Enable.Value; } if (requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker_deploymentCircuitBreaker_Enable != null) { requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker.Enable = requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker_deploymentCircuitBreaker_Enable.Value; requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreakerIsNull = false; } System.Boolean? requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker_deploymentCircuitBreaker_Rollback = null; if (cmdletContext.DeploymentCircuitBreaker_Rollback != null) { requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker_deploymentCircuitBreaker_Rollback = cmdletContext.DeploymentCircuitBreaker_Rollback.Value; } if (requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker_deploymentCircuitBreaker_Rollback != null) { requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker.Rollback = requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker_deploymentCircuitBreaker_Rollback.Value; requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreakerIsNull = false; } // determine if requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker should be set to null if (requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreakerIsNull) { requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker = null; } if (requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker != null) { request.DeploymentConfiguration.DeploymentCircuitBreaker = requestDeploymentConfiguration_deploymentConfiguration_DeploymentCircuitBreaker; requestDeploymentConfigurationIsNull = false; } Amazon.ECS.Model.DeploymentAlarms requestDeploymentConfiguration_deploymentConfiguration_Alarms = null; // populate Alarms var requestDeploymentConfiguration_deploymentConfiguration_AlarmsIsNull = true; requestDeploymentConfiguration_deploymentConfiguration_Alarms = new Amazon.ECS.Model.DeploymentAlarms(); List requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_AlarmName = null; if (cmdletContext.Alarms_AlarmName != null) { requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_AlarmName = cmdletContext.Alarms_AlarmName; } if (requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_AlarmName != null) { requestDeploymentConfiguration_deploymentConfiguration_Alarms.AlarmNames = requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_AlarmName; requestDeploymentConfiguration_deploymentConfiguration_AlarmsIsNull = false; } System.Boolean? requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_Enable = null; if (cmdletContext.Alarms_Enable != null) { requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_Enable = cmdletContext.Alarms_Enable.Value; } if (requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_Enable != null) { requestDeploymentConfiguration_deploymentConfiguration_Alarms.Enable = requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_Enable.Value; requestDeploymentConfiguration_deploymentConfiguration_AlarmsIsNull = false; } System.Boolean? requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_Rollback = null; if (cmdletContext.Alarms_Rollback != null) { requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_Rollback = cmdletContext.Alarms_Rollback.Value; } if (requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_Rollback != null) { requestDeploymentConfiguration_deploymentConfiguration_Alarms.Rollback = requestDeploymentConfiguration_deploymentConfiguration_Alarms_alarms_Rollback.Value; requestDeploymentConfiguration_deploymentConfiguration_AlarmsIsNull = false; } // determine if requestDeploymentConfiguration_deploymentConfiguration_Alarms should be set to null if (requestDeploymentConfiguration_deploymentConfiguration_AlarmsIsNull) { requestDeploymentConfiguration_deploymentConfiguration_Alarms = null; } if (requestDeploymentConfiguration_deploymentConfiguration_Alarms != null) { request.DeploymentConfiguration.Alarms = requestDeploymentConfiguration_deploymentConfiguration_Alarms; requestDeploymentConfigurationIsNull = false; } // determine if request.DeploymentConfiguration should be set to null if (requestDeploymentConfigurationIsNull) { request.DeploymentConfiguration = null; } if (cmdletContext.DesiredCount != null) { request.DesiredCount = cmdletContext.DesiredCount.Value; } if (cmdletContext.EnableECSManagedTag != null) { request.EnableECSManagedTags = cmdletContext.EnableECSManagedTag.Value; } if (cmdletContext.EnableExecuteCommand != null) { request.EnableExecuteCommand = cmdletContext.EnableExecuteCommand.Value; } if (cmdletContext.ForceNewDeployment != null) { request.ForceNewDeployment = cmdletContext.ForceNewDeployment.Value; } if (cmdletContext.HealthCheckGracePeriodSecond != null) { request.HealthCheckGracePeriodSeconds = cmdletContext.HealthCheckGracePeriodSecond.Value; } if (cmdletContext.LoadBalancer != null) { request.LoadBalancers = cmdletContext.LoadBalancer; } // populate NetworkConfiguration var requestNetworkConfigurationIsNull = true; request.NetworkConfiguration = new Amazon.ECS.Model.NetworkConfiguration(); Amazon.ECS.Model.AwsVpcConfiguration requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration = null; // populate AwsvpcConfiguration var requestNetworkConfiguration_networkConfiguration_AwsvpcConfigurationIsNull = true; requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration = new Amazon.ECS.Model.AwsVpcConfiguration(); Amazon.ECS.AssignPublicIp requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_AssignPublicIp = null; if (cmdletContext.AwsvpcConfiguration_AssignPublicIp != null) { requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_AssignPublicIp = cmdletContext.AwsvpcConfiguration_AssignPublicIp; } if (requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_AssignPublicIp != null) { requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration.AssignPublicIp = requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_AssignPublicIp; requestNetworkConfiguration_networkConfiguration_AwsvpcConfigurationIsNull = false; } List requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_SecurityGroup = null; if (cmdletContext.AwsvpcConfiguration_SecurityGroup != null) { requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_SecurityGroup = cmdletContext.AwsvpcConfiguration_SecurityGroup; } if (requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_SecurityGroup != null) { requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration.SecurityGroups = requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_SecurityGroup; requestNetworkConfiguration_networkConfiguration_AwsvpcConfigurationIsNull = false; } List requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_Subnet = null; if (cmdletContext.AwsvpcConfiguration_Subnet != null) { requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_Subnet = cmdletContext.AwsvpcConfiguration_Subnet; } if (requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_Subnet != null) { requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration.Subnets = requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration_awsvpcConfiguration_Subnet; requestNetworkConfiguration_networkConfiguration_AwsvpcConfigurationIsNull = false; } // determine if requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration should be set to null if (requestNetworkConfiguration_networkConfiguration_AwsvpcConfigurationIsNull) { requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration = null; } if (requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration != null) { request.NetworkConfiguration.AwsvpcConfiguration = requestNetworkConfiguration_networkConfiguration_AwsvpcConfiguration; requestNetworkConfigurationIsNull = false; } // determine if request.NetworkConfiguration should be set to null if (requestNetworkConfigurationIsNull) { request.NetworkConfiguration = null; } if (cmdletContext.PlacementConstraint != null) { request.PlacementConstraints = cmdletContext.PlacementConstraint; } if (cmdletContext.PlacementStrategy != null) { request.PlacementStrategy = cmdletContext.PlacementStrategy; } if (cmdletContext.PlatformVersion != null) { request.PlatformVersion = cmdletContext.PlatformVersion; } if (cmdletContext.PropagateTag != null) { request.PropagateTags = cmdletContext.PropagateTag; } if (cmdletContext.Service != null) { request.Service = cmdletContext.Service; } // populate ServiceConnectConfiguration var requestServiceConnectConfigurationIsNull = true; request.ServiceConnectConfiguration = new Amazon.ECS.Model.ServiceConnectConfiguration(); System.Boolean? requestServiceConnectConfiguration_serviceConnectConfiguration_Enabled = null; if (cmdletContext.ServiceConnectConfiguration_Enabled != null) { requestServiceConnectConfiguration_serviceConnectConfiguration_Enabled = cmdletContext.ServiceConnectConfiguration_Enabled.Value; } if (requestServiceConnectConfiguration_serviceConnectConfiguration_Enabled != null) { request.ServiceConnectConfiguration.Enabled = requestServiceConnectConfiguration_serviceConnectConfiguration_Enabled.Value; requestServiceConnectConfigurationIsNull = false; } System.String requestServiceConnectConfiguration_serviceConnectConfiguration_Namespace = null; if (cmdletContext.ServiceConnectConfiguration_Namespace != null) { requestServiceConnectConfiguration_serviceConnectConfiguration_Namespace = cmdletContext.ServiceConnectConfiguration_Namespace; } if (requestServiceConnectConfiguration_serviceConnectConfiguration_Namespace != null) { request.ServiceConnectConfiguration.Namespace = requestServiceConnectConfiguration_serviceConnectConfiguration_Namespace; requestServiceConnectConfigurationIsNull = false; } List requestServiceConnectConfiguration_serviceConnectConfiguration_Service = null; if (cmdletContext.ServiceConnectConfiguration_Service != null) { requestServiceConnectConfiguration_serviceConnectConfiguration_Service = cmdletContext.ServiceConnectConfiguration_Service; } if (requestServiceConnectConfiguration_serviceConnectConfiguration_Service != null) { request.ServiceConnectConfiguration.Services = requestServiceConnectConfiguration_serviceConnectConfiguration_Service; requestServiceConnectConfigurationIsNull = false; } Amazon.ECS.Model.LogConfiguration requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration = null; // populate LogConfiguration var requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfigurationIsNull = true; requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration = new Amazon.ECS.Model.LogConfiguration(); Amazon.ECS.LogDriver requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_LogDriver = null; if (cmdletContext.LogConfiguration_LogDriver != null) { requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_LogDriver = cmdletContext.LogConfiguration_LogDriver; } if (requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_LogDriver != null) { requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration.LogDriver = requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_LogDriver; requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfigurationIsNull = false; } Dictionary requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_Option = null; if (cmdletContext.LogConfiguration_Option != null) { requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_Option = cmdletContext.LogConfiguration_Option; } if (requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_Option != null) { requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration.Options = requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_Option; requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfigurationIsNull = false; } List requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_SecretOption = null; if (cmdletContext.LogConfiguration_SecretOption != null) { requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_SecretOption = cmdletContext.LogConfiguration_SecretOption; } if (requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_SecretOption != null) { requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration.SecretOptions = requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration_logConfiguration_SecretOption; requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfigurationIsNull = false; } // determine if requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration should be set to null if (requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfigurationIsNull) { requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration = null; } if (requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration != null) { request.ServiceConnectConfiguration.LogConfiguration = requestServiceConnectConfiguration_serviceConnectConfiguration_LogConfiguration; requestServiceConnectConfigurationIsNull = false; } // determine if request.ServiceConnectConfiguration should be set to null if (requestServiceConnectConfigurationIsNull) { request.ServiceConnectConfiguration = null; } if (cmdletContext.ServiceRegistry != null) { request.ServiceRegistries = cmdletContext.ServiceRegistry; } if (cmdletContext.TaskDefinition != null) { request.TaskDefinition = cmdletContext.TaskDefinition; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return output; } public ExecutorContext CreateContext() { return new CmdletContext(); } #endregion #region AWS Service Operation Call private Amazon.ECS.Model.UpdateServiceResponse CallAWSServiceOperation(IAmazonECS client, Amazon.ECS.Model.UpdateServiceRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon EC2 Container Service", "UpdateService"); try { #if DESKTOP return client.UpdateService(request); #elif CORECLR return client.UpdateServiceAsync(request).GetAwaiter().GetResult(); #else #error "Unknown build edition" #endif } catch (AmazonServiceException exc) { var webException = exc.InnerException as System.Net.WebException; if (webException != null) { throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException); } throw; } } #endregion internal partial class CmdletContext : ExecutorContext { public List CapacityProviderStrategy { get; set; } public System.String Cluster { get; set; } public List Alarms_AlarmName { get; set; } public System.Boolean? Alarms_Enable { get; set; } public System.Boolean? Alarms_Rollback { get; set; } public System.Boolean? DeploymentCircuitBreaker_Enable { get; set; } public System.Boolean? DeploymentCircuitBreaker_Rollback { get; set; } public System.Int32? DeploymentConfiguration_MaximumPercent { get; set; } public System.Int32? DeploymentConfiguration_MinimumHealthyPercent { get; set; } public System.Int32? DesiredCount { get; set; } public System.Boolean? EnableECSManagedTag { get; set; } public System.Boolean? EnableExecuteCommand { get; set; } public System.Boolean? ForceNewDeployment { get; set; } public System.Int32? HealthCheckGracePeriodSecond { get; set; } public List LoadBalancer { get; set; } public Amazon.ECS.AssignPublicIp AwsvpcConfiguration_AssignPublicIp { get; set; } public List AwsvpcConfiguration_SecurityGroup { get; set; } public List AwsvpcConfiguration_Subnet { get; set; } public List PlacementConstraint { get; set; } public List PlacementStrategy { get; set; } public System.String PlatformVersion { get; set; } public Amazon.ECS.PropagateTags PropagateTag { get; set; } public System.String Service { get; set; } public System.Boolean? ServiceConnectConfiguration_Enabled { get; set; } public Amazon.ECS.LogDriver LogConfiguration_LogDriver { get; set; } public Dictionary LogConfiguration_Option { get; set; } public List LogConfiguration_SecretOption { get; set; } public System.String ServiceConnectConfiguration_Namespace { get; set; } public List ServiceConnectConfiguration_Service { get; set; } public List ServiceRegistry { get; set; } public System.String TaskDefinition { get; set; } public System.Func Select { get; set; } = (response, cmdlet) => response.Service; } } }