pulumi-aws-native 1.38.0a1761026291__py3-none-any.whl → 1.39.0a1762409198__py3-none-any.whl

pulumi_aws_native/ecs/_enums.py

@@ -25,6 +25,8 @@ __all__ = [
     'ClusterCapacityProviderAssociationsCapacityProvider0',
     'ServiceAvailabilityZoneRebalancing',
     'ServiceAwsVpcConfigurationAssignPublicIp',
+    'ServiceConnectAccessLogConfigurationFormat',
+    'ServiceConnectAccessLogConfigurationIncludeQueryParameters',
     'ServiceDeploymentConfigurationStrategy',
     'ServiceDeploymentControllerType',
     'ServiceDeploymentLifecycleHookLifecycleStagesItem',
@@ -91,6 +93,7 @@ class CapacityProviderInstanceRequirementsRequestAcceleratorNamesItem(_builtins.
     T4G = "t4g"
     VU9P = "vu9p"
     V100 = "v100"
+    L40S = "l40s"
 
 
 @pulumi.type_token("aws-native:ecs:CapacityProviderInstanceRequirementsRequestAcceleratorTypesItem")
@@ -216,6 +219,26 @@ class ServiceAwsVpcConfigurationAssignPublicIp(_builtins.str, Enum):
     ENABLED = "ENABLED"
 
 
+@pulumi.type_token("aws-native:ecs:ServiceConnectAccessLogConfigurationFormat")
+class ServiceConnectAccessLogConfigurationFormat(_builtins.str, Enum):
+    """
+    The format for Service Connect access log output. Choose TEXT for human-readable logs or JSON for structured data that integrates well with log analysis tools.
+    """
+    TEXT = "TEXT"
+    JSON = "JSON"
+
+
+@pulumi.type_token("aws-native:ecs:ServiceConnectAccessLogConfigurationIncludeQueryParameters")
+class ServiceConnectAccessLogConfigurationIncludeQueryParameters(_builtins.str, Enum):
+    """
+    Specifies whether to include query parameters in Service Connect access logs.
+
+    When enabled, query parameters from HTTP requests are included in the access logs. Consider security and privacy implications when enabling this feature, as query parameters may contain sensitive information such as request IDs and tokens. By default, this parameter is `DISABLED` .
+    """
+    DISABLED = "DISABLED"
+    ENABLED = "ENABLED"
+
+
 @pulumi.type_token("aws-native:ecs:ServiceDeploymentConfigurationStrategy")
 class ServiceDeploymentConfigurationStrategy(_builtins.str, Enum):
     """
@@ -299,6 +322,7 @@ class ServiceEbsTagSpecificationPropagateTags(_builtins.str, Enum):
 class ServiceLaunchType(_builtins.str, Enum):
     """
     The launch type on which to run your service. For more information, see [Amazon ECS Launch Types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) in the *Amazon Elastic Container Service Developer Guide*.
+      If you want to use Managed Instances, you must use the ``capacityProviderStrategy`` request parameter
     """
     EC2 = "EC2"
     FARGATE = "FARGATE"

pulumi_aws_native/ecs/_inputs.py

@@ -68,8 +68,12 @@ __all__ = [
     'ServiceAdvancedConfigurationArgsDict',
     'ServiceAwsVpcConfigurationArgs',
     'ServiceAwsVpcConfigurationArgsDict',
+    'ServiceCanaryConfigurationArgs',
+    'ServiceCanaryConfigurationArgsDict',
     'ServiceCapacityProviderStrategyItemArgs',
     'ServiceCapacityProviderStrategyItemArgsDict',
+    'ServiceConnectAccessLogConfigurationArgs',
+    'ServiceConnectAccessLogConfigurationArgsDict',
     'ServiceConnectClientAliasArgs',
     'ServiceConnectClientAliasArgsDict',
     'ServiceConnectConfigurationArgs',
@@ -100,6 +104,8 @@ __all__ = [
     'ServiceEbsTagSpecificationArgsDict',
     'ServiceForceNewDeploymentArgs',
     'ServiceForceNewDeploymentArgsDict',
+    'ServiceLinearConfigurationArgs',
+    'ServiceLinearConfigurationArgsDict',
     'ServiceLoadBalancerArgs',
     'ServiceLoadBalancerArgsDict',
     'ServiceLogConfigurationArgs',
@@ -2508,6 +2514,58 @@ class ServiceAwsVpcConfigurationArgs:
         pulumi.set(self, "subnets", value)
 
 
+if not MYPY:
+    class ServiceCanaryConfigurationArgsDict(TypedDict):
+        canary_bake_time_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The amount of time in minutes to wait during the canary phase before shifting the remaining production traffic to the new service revision. Valid values are 0 to 1440 minutes (24 hours). The default value is 10.
+        """
+        canary_percent: NotRequired[pulumi.Input[_builtins.float]]
+        """
+        The percentage of production traffic to shift to the new service revision during the canary phase. Valid values are multiples of 0.1 from 0.1 to 100.0. The default value is 5.0.
+        """
+elif False:
+    ServiceCanaryConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServiceCanaryConfigurationArgs:
+    def __init__(__self__, *,
+                 canary_bake_time_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
+                 canary_percent: Optional[pulumi.Input[_builtins.float]] = None):
+        """
+        :param pulumi.Input[_builtins.int] canary_bake_time_in_minutes: The amount of time in minutes to wait during the canary phase before shifting the remaining production traffic to the new service revision. Valid values are 0 to 1440 minutes (24 hours). The default value is 10.
+        :param pulumi.Input[_builtins.float] canary_percent: The percentage of production traffic to shift to the new service revision during the canary phase. Valid values are multiples of 0.1 from 0.1 to 100.0. The default value is 5.0.
+        """
+        if canary_bake_time_in_minutes is not None:
+            pulumi.set(__self__, "canary_bake_time_in_minutes", canary_bake_time_in_minutes)
+        if canary_percent is not None:
+            pulumi.set(__self__, "canary_percent", canary_percent)
+
+    @_builtins.property
+    @pulumi.getter(name="canaryBakeTimeInMinutes")
+    def canary_bake_time_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The amount of time in minutes to wait during the canary phase before shifting the remaining production traffic to the new service revision. Valid values are 0 to 1440 minutes (24 hours). The default value is 10.
+        """
+        return pulumi.get(self, "canary_bake_time_in_minutes")
+
+    @canary_bake_time_in_minutes.setter
+    def canary_bake_time_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "canary_bake_time_in_minutes", value)
+
+    @_builtins.property
+    @pulumi.getter(name="canaryPercent")
+    def canary_percent(self) -> Optional[pulumi.Input[_builtins.float]]:
+        """
+        The percentage of production traffic to shift to the new service revision during the canary phase. Valid values are multiples of 0.1 from 0.1 to 100.0. The default value is 5.0.
+        """
+        return pulumi.get(self, "canary_percent")
+
+    @canary_percent.setter
+    def canary_percent(self, value: Optional[pulumi.Input[_builtins.float]]):
+        pulumi.set(self, "canary_percent", value)
+
+
 if not MYPY:
     class ServiceCapacityProviderStrategyItemArgsDict(TypedDict):
         """
@@ -2650,6 +2708,63 @@ class ServiceCapacityProviderStrategyItemArgs:
         pulumi.set(self, "weight", value)
 
 
+if not MYPY:
+    class ServiceConnectAccessLogConfigurationArgsDict(TypedDict):
+        format: pulumi.Input['ServiceConnectAccessLogConfigurationFormat']
+        """
+        The format for Service Connect access log output. Choose TEXT for human-readable logs or JSON for structured data that integrates well with log analysis tools.
+        """
+        include_query_parameters: NotRequired[pulumi.Input['ServiceConnectAccessLogConfigurationIncludeQueryParameters']]
+        """
+        Specifies whether to include query parameters in Service Connect access logs.
+
+        When enabled, query parameters from HTTP requests are included in the access logs. Consider security and privacy implications when enabling this feature, as query parameters may contain sensitive information such as request IDs and tokens. By default, this parameter is `DISABLED` .
+        """
+elif False:
+    ServiceConnectAccessLogConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServiceConnectAccessLogConfigurationArgs:
+    def __init__(__self__, *,
+                 format: pulumi.Input['ServiceConnectAccessLogConfigurationFormat'],
+                 include_query_parameters: Optional[pulumi.Input['ServiceConnectAccessLogConfigurationIncludeQueryParameters']] = None):
+        """
+        :param pulumi.Input['ServiceConnectAccessLogConfigurationFormat'] format: The format for Service Connect access log output. Choose TEXT for human-readable logs or JSON for structured data that integrates well with log analysis tools.
+        :param pulumi.Input['ServiceConnectAccessLogConfigurationIncludeQueryParameters'] include_query_parameters: Specifies whether to include query parameters in Service Connect access logs.
+               
+               When enabled, query parameters from HTTP requests are included in the access logs. Consider security and privacy implications when enabling this feature, as query parameters may contain sensitive information such as request IDs and tokens. By default, this parameter is `DISABLED` .
+        """
+        pulumi.set(__self__, "format", format)
+        if include_query_parameters is not None:
+            pulumi.set(__self__, "include_query_parameters", include_query_parameters)
+
+    @_builtins.property
+    @pulumi.getter
+    def format(self) -> pulumi.Input['ServiceConnectAccessLogConfigurationFormat']:
+        """
+        The format for Service Connect access log output. Choose TEXT for human-readable logs or JSON for structured data that integrates well with log analysis tools.
+        """
+        return pulumi.get(self, "format")
+
+    @format.setter
+    def format(self, value: pulumi.Input['ServiceConnectAccessLogConfigurationFormat']):
+        pulumi.set(self, "format", value)
+
+    @_builtins.property
+    @pulumi.getter(name="includeQueryParameters")
+    def include_query_parameters(self) -> Optional[pulumi.Input['ServiceConnectAccessLogConfigurationIncludeQueryParameters']]:
+        """
+        Specifies whether to include query parameters in Service Connect access logs.
+
+        When enabled, query parameters from HTTP requests are included in the access logs. Consider security and privacy implications when enabling this feature, as query parameters may contain sensitive information such as request IDs and tokens. By default, this parameter is `DISABLED` .
+        """
+        return pulumi.get(self, "include_query_parameters")
+
+    @include_query_parameters.setter
+    def include_query_parameters(self, value: Optional[pulumi.Input['ServiceConnectAccessLogConfigurationIncludeQueryParameters']]):
+        pulumi.set(self, "include_query_parameters", value)
+
+
 if not MYPY:
     class ServiceConnectClientAliasArgsDict(TypedDict):
         """
@@ -2748,6 +2863,12 @@ if not MYPY:
         """
         Specifies whether to use Service Connect with this service.
         """
+        access_log_configuration: NotRequired[pulumi.Input['ServiceConnectAccessLogConfigurationArgsDict']]
+        """
+        The configuration for Service Connect access logging. Access logs capture detailed information about requests made to your service, including request patterns, response codes, and timing data. They can be useful for debugging connectivity issues, monitoring service performance, and auditing service-to-service communication for security and compliance purposes.
+
+        > To enable access logs, you must also specify a `logConfiguration` in the `serviceConnectConfiguration` .
+        """
         log_configuration: NotRequired[pulumi.Input['ServiceLogConfigurationArgsDict']]
         """
         The log configuration for the container. This parameter maps to ``LogConfig`` in the docker container create command and the ``--log-driver`` option to docker run.
@@ -2777,6 +2898,7 @@ elif False:
 class ServiceConnectConfigurationArgs:
     def __init__(__self__, *,
                  enabled: pulumi.Input[_builtins.bool],
+                 access_log_configuration: Optional[pulumi.Input['ServiceConnectAccessLogConfigurationArgs']] = None,
                  log_configuration: Optional[pulumi.Input['ServiceLogConfigurationArgs']] = None,
                  namespace: Optional[pulumi.Input[_builtins.str]] = None,
                  services: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceConnectServiceArgs']]]] = None):
@@ -2784,6 +2906,9 @@ class ServiceConnectConfigurationArgs:
         The Service Connect configuration of your Amazon ECS service. The configuration for this service to discover and connect to services, and be discovered by, and connected from, other services within a namespace.
          Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
         :param pulumi.Input[_builtins.bool] enabled: Specifies whether to use Service Connect with this service.
+        :param pulumi.Input['ServiceConnectAccessLogConfigurationArgs'] access_log_configuration: The configuration for Service Connect access logging. Access logs capture detailed information about requests made to your service, including request patterns, response codes, and timing data. They can be useful for debugging connectivity issues, monitoring service performance, and auditing service-to-service communication for security and compliance purposes.
+               
+               > To enable access logs, you must also specify a `logConfiguration` in the `serviceConnectConfiguration` .
         :param pulumi.Input['ServiceLogConfigurationArgs'] log_configuration: The log configuration for the container. This parameter maps to ``LogConfig`` in the docker container create command and the ``--log-driver`` option to docker run.
                 By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition.
                 Understand the following when specifying a log configuration for your containers.
@@ -2799,6 +2924,8 @@ class ServiceConnectConfigurationArgs:
                 An object selects a port from the task definition, assigns a name for the CMAPlong service, and a list of aliases (endpoints) and ports for client applications to refer to this service.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if access_log_configuration is not None:
+            pulumi.set(__self__, "access_log_configuration", access_log_configuration)
         if log_configuration is not None:
             pulumi.set(__self__, "log_configuration", log_configuration)
         if namespace is not None:
@@ -2818,6 +2945,20 @@ class ServiceConnectConfigurationArgs:
     def enabled(self, value: pulumi.Input[_builtins.bool]):
         pulumi.set(self, "enabled", value)
 
+    @_builtins.property
+    @pulumi.getter(name="accessLogConfiguration")
+    def access_log_configuration(self) -> Optional[pulumi.Input['ServiceConnectAccessLogConfigurationArgs']]:
+        """
+        The configuration for Service Connect access logging. Access logs capture detailed information about requests made to your service, including request patterns, response codes, and timing data. They can be useful for debugging connectivity issues, monitoring service performance, and auditing service-to-service communication for security and compliance purposes.
+
+        > To enable access logs, you must also specify a `logConfiguration` in the `serviceConnectConfiguration` .
+        """
+        return pulumi.get(self, "access_log_configuration")
+
+    @access_log_configuration.setter
+    def access_log_configuration(self, value: Optional[pulumi.Input['ServiceConnectAccessLogConfigurationArgs']]):
+        pulumi.set(self, "access_log_configuration", value)
+
     @_builtins.property
     @pulumi.getter(name="logConfiguration")
     def log_configuration(self) -> Optional[pulumi.Input['ServiceLogConfigurationArgs']]:
@@ -3377,7 +3518,10 @@ if not MYPY:
           +  When you use an external deployment controller (``EXTERNAL``), or the ACD blue/green deployment controller (``CODE_DEPLOY``), the value is set to 3 hours (180 minutes).
           +  For all other cases, the value is set to 36 hours (2160 minutes).
         """
-        canary_configuration: NotRequired[Any]
+        canary_configuration: NotRequired[pulumi.Input['ServiceCanaryConfigurationArgsDict']]
+        """
+        Configuration for canary deployment strategy. Only valid when the deployment strategy is `CANARY` . This configuration enables shifting a fixed percentage of traffic for testing, followed by shifting the remaining traffic after a bake period.
+        """
         deployment_circuit_breaker: NotRequired[pulumi.Input['ServiceDeploymentCircuitBreakerArgsDict']]
         """
         The deployment circuit breaker can only be used for services using the rolling update (``ECS``) deployment type.
@@ -3387,7 +3531,10 @@ if not MYPY:
         """
         An array of deployment lifecycle hook objects to run custom logic at specific stages of the deployment lifecycle.
         """
-        linear_configuration: NotRequired[Any]
+        linear_configuration: NotRequired[pulumi.Input['ServiceLinearConfigurationArgsDict']]
+        """
+        Configuration for linear deployment strategy. Only valid when the deployment strategy is `LINEAR` . This configuration enables progressive traffic shifting in equal percentage increments with configurable bake times between each step.
+        """
         maximum_percent: NotRequired[pulumi.Input[_builtins.int]]
         """
         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%.
@@ -3429,10 +3576,10 @@ class ServiceDeploymentConfigurationArgs:
     def __init__(__self__, *,
                  alarms: Optional[pulumi.Input['ServiceDeploymentAlarmsArgs']] = None,
                  bake_time_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
-                 canary_configuration: Optional[Any] = None,
+                 canary_configuration: Optional[pulumi.Input['ServiceCanaryConfigurationArgs']] = None,
                  deployment_circuit_breaker: Optional[pulumi.Input['ServiceDeploymentCircuitBreakerArgs']] = None,
                  lifecycle_hooks: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceDeploymentLifecycleHookArgs']]]] = None,
-                 linear_configuration: Optional[Any] = None,
+                 linear_configuration: Optional[pulumi.Input['ServiceLinearConfigurationArgs']] = None,
                  maximum_percent: Optional[pulumi.Input[_builtins.int]] = None,
                  minimum_healthy_percent: Optional[pulumi.Input[_builtins.int]] = None,
                  strategy: Optional[pulumi.Input['ServiceDeploymentConfigurationStrategy']] = None):
@@ -3444,9 +3591,11 @@ class ServiceDeploymentConfigurationArgs:
                  +  For rolling deployments, the value is set to 3 hours (180 minutes).
                  +  When you use an external deployment controller (``EXTERNAL``), or the ACD blue/green deployment controller (``CODE_DEPLOY``), the value is set to 3 hours (180 minutes).
                  +  For all other cases, the value is set to 36 hours (2160 minutes).
+        :param pulumi.Input['ServiceCanaryConfigurationArgs'] canary_configuration: Configuration for canary deployment strategy. Only valid when the deployment strategy is `CANARY` . This configuration enables shifting a fixed percentage of traffic for testing, followed by shifting the remaining traffic after a bake period.
         :param pulumi.Input['ServiceDeploymentCircuitBreakerArgs'] deployment_circuit_breaker: The deployment circuit breaker can only be used for services using the rolling update (``ECS``) deployment type.
                  The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If you use the deployment circuit breaker, a service deployment will transition to a failed state and stop launching new tasks. If you use the rollback option, when a service deployment fails, the service is rolled back to the last deployment that completed successfully. For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*
         :param pulumi.Input[Sequence[pulumi.Input['ServiceDeploymentLifecycleHookArgs']]] lifecycle_hooks: An array of deployment lifecycle hook objects to run custom logic at specific stages of the deployment lifecycle.
+        :param pulumi.Input['ServiceLinearConfigurationArgs'] linear_configuration: Configuration for linear deployment strategy. Only valid when the deployment strategy is `LINEAR` . This configuration enables progressive traffic shifting in equal percentage increments with configurable bake times between each step.
         :param pulumi.Input[_builtins.int] maximum_percent: 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%.
                 The Amazon ECS scheduler uses this parameter to replace unhealthy tasks by starting replacement tasks first and then stopping the unhealthy tasks, as long as cluster resources for starting replacement tasks are available. For more information about how the scheduler replaces unhealthy tasks, see [Amazon ECS services](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html).
                 If a service is using either the blue/green (``CODE_DEPLOY``) or ``EXTERNAL`` deployment types, and tasks in the service use the EC2 launch type, the *maximum percent* value is set to the default value. The *maximum percent* value 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.
@@ -3521,11 +3670,14 @@ class ServiceDeploymentConfigurationArgs:
 
     @_builtins.property
     @pulumi.getter(name="canaryConfiguration")
-    def canary_configuration(self) -> Optional[Any]:
+    def canary_configuration(self) -> Optional[pulumi.Input['ServiceCanaryConfigurationArgs']]:
+        """
+        Configuration for canary deployment strategy. Only valid when the deployment strategy is `CANARY` . This configuration enables shifting a fixed percentage of traffic for testing, followed by shifting the remaining traffic after a bake period.
+        """
         return pulumi.get(self, "canary_configuration")
 
     @canary_configuration.setter
-    def canary_configuration(self, value: Optional[Any]):
+    def canary_configuration(self, value: Optional[pulumi.Input['ServiceCanaryConfigurationArgs']]):
         pulumi.set(self, "canary_configuration", value)
 
     @_builtins.property
@@ -3555,11 +3707,14 @@ class ServiceDeploymentConfigurationArgs:
 
     @_builtins.property
     @pulumi.getter(name="linearConfiguration")
-    def linear_configuration(self) -> Optional[Any]:
+    def linear_configuration(self) -> Optional[pulumi.Input['ServiceLinearConfigurationArgs']]:
+        """
+        Configuration for linear deployment strategy. Only valid when the deployment strategy is `LINEAR` . This configuration enables progressive traffic shifting in equal percentage increments with configurable bake times between each step.
+        """
         return pulumi.get(self, "linear_configuration")
 
     @linear_configuration.setter
-    def linear_configuration(self, value: Optional[Any]):
+    def linear_configuration(self, value: Optional[pulumi.Input['ServiceLinearConfigurationArgs']]):
         pulumi.set(self, "linear_configuration", value)
 
     @_builtins.property
@@ -4067,6 +4222,58 @@ class ServiceForceNewDeploymentArgs:
         pulumi.set(self, "force_new_deployment_nonce", value)
 
 
+if not MYPY:
+    class ServiceLinearConfigurationArgsDict(TypedDict):
+        step_bake_time_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The amount of time in minutes to wait between each traffic shifting step during a linear deployment. Valid values are 0 to 1440 minutes (24 hours). The default value is 6. This bake time is not applied after reaching 100 percent traffic.
+        """
+        step_percent: NotRequired[pulumi.Input[_builtins.float]]
+        """
+        The percentage of production traffic to shift in each step during a linear deployment. Valid values are multiples of 0.1 from 3.0 to 100.0. The default value is 10.0.
+        """
+elif False:
+    ServiceLinearConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServiceLinearConfigurationArgs:
+    def __init__(__self__, *,
+                 step_bake_time_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
+                 step_percent: Optional[pulumi.Input[_builtins.float]] = None):
+        """
+        :param pulumi.Input[_builtins.int] step_bake_time_in_minutes: The amount of time in minutes to wait between each traffic shifting step during a linear deployment. Valid values are 0 to 1440 minutes (24 hours). The default value is 6. This bake time is not applied after reaching 100 percent traffic.
+        :param pulumi.Input[_builtins.float] step_percent: The percentage of production traffic to shift in each step during a linear deployment. Valid values are multiples of 0.1 from 3.0 to 100.0. The default value is 10.0.
+        """
+        if step_bake_time_in_minutes is not None:
+            pulumi.set(__self__, "step_bake_time_in_minutes", step_bake_time_in_minutes)
+        if step_percent is not None:
+            pulumi.set(__self__, "step_percent", step_percent)
+
+    @_builtins.property
+    @pulumi.getter(name="stepBakeTimeInMinutes")
+    def step_bake_time_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The amount of time in minutes to wait between each traffic shifting step during a linear deployment. Valid values are 0 to 1440 minutes (24 hours). The default value is 6. This bake time is not applied after reaching 100 percent traffic.
+        """
+        return pulumi.get(self, "step_bake_time_in_minutes")
+
+    @step_bake_time_in_minutes.setter
+    def step_bake_time_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "step_bake_time_in_minutes", value)
+
+    @_builtins.property
+    @pulumi.getter(name="stepPercent")
+    def step_percent(self) -> Optional[pulumi.Input[_builtins.float]]:
+        """
+        The percentage of production traffic to shift in each step during a linear deployment. Valid values are multiples of 0.1 from 3.0 to 100.0. The default value is 10.0.
+        """
+        return pulumi.get(self, "step_percent")
+
+    @step_percent.setter
+    def step_percent(self, value: Optional[pulumi.Input[_builtins.float]]):
+        pulumi.set(self, "step_percent", value)
+
+
 if not MYPY:
     class ServiceLoadBalancerArgsDict(TypedDict):
         """
@@ -9152,13 +9359,13 @@ if not MYPY:
         Base value characteristics:
 
         - Only one capacity provider in a strategy can have a base defined
-        - Default value is `0` if not specified
-        - Valid range: 0 to 100,000
+        - The default value is `0` if not specified
+        - The valid range is 0 to 100,000
         - Base requirements are satisfied first before weight distribution
         """
         capacity_provider: NotRequired[pulumi.Input[_builtins.str]]
         """
-        The short name of the capacity provider.
+        The short name of the capacity provider. This can be either an AWS managed capacity provider ( `FARGATE` or `FARGATE_SPOT` ) or the name of a custom capacity provider that you created.
         """
         weight: NotRequired[pulumi.Input[_builtins.int]]
         """
@@ -9169,8 +9376,8 @@ if not MYPY:
         Weight value characteristics:
 
         - Weight is considered after the base value is satisfied
-        - Default value is `0` if not specified
-        - Valid range: 0 to 1,000
+        - The default value is `0` if not specified
+        - The valid range is 0 to 1,000
         - At least one capacity provider must have a weight greater than zero
         - Capacity providers with weight of `0` cannot place tasks
 
@@ -9200,10 +9407,10 @@ class TaskSetCapacityProviderStrategyItemArgs:
                Base value characteristics:
                
                - Only one capacity provider in a strategy can have a base defined
-               - Default value is `0` if not specified
-               - Valid range: 0 to 100,000
+               - The default value is `0` if not specified
+               - The valid range is 0 to 100,000
                - Base requirements are satisfied first before weight distribution
-        :param pulumi.Input[_builtins.str] capacity_provider: The short name of the capacity provider.
+        :param pulumi.Input[_builtins.str] capacity_provider: The short name of the capacity provider. This can be either an AWS managed capacity provider ( `FARGATE` or `FARGATE_SPOT` ) or the name of a custom capacity provider that you created.
         :param pulumi.Input[_builtins.int] weight: The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider. The `weight` value is taken into consideration after the `base` value, if defined, is satisfied.
                
                If no `weight` value is specified, the default value of `0` is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of `0` can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of `0` , any `RunTask` or `CreateService` actions using the capacity provider strategy will fail.
@@ -9211,8 +9418,8 @@ class TaskSetCapacityProviderStrategyItemArgs:
                Weight value characteristics:
                
                - Weight is considered after the base value is satisfied
-               - Default value is `0` if not specified
-               - Valid range: 0 to 1,000
+               - The default value is `0` if not specified
+               - The valid range is 0 to 1,000
                - At least one capacity provider must have a weight greater than zero
                - Capacity providers with weight of `0` cannot place tasks
                
@@ -9243,8 +9450,8 @@ class TaskSetCapacityProviderStrategyItemArgs:
         Base value characteristics:
 
         - Only one capacity provider in a strategy can have a base defined
-        - Default value is `0` if not specified
-        - Valid range: 0 to 100,000
+        - The default value is `0` if not specified
+        - The valid range is 0 to 100,000
         - Base requirements are satisfied first before weight distribution
         """
         return pulumi.get(self, "base")
@@ -9257,7 +9464,7 @@ class TaskSetCapacityProviderStrategyItemArgs:
     @pulumi.getter(name="capacityProvider")
     def capacity_provider(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        The short name of the capacity provider.
+        The short name of the capacity provider. This can be either an AWS managed capacity provider ( `FARGATE` or `FARGATE_SPOT` ) or the name of a custom capacity provider that you created.
         """
         return pulumi.get(self, "capacity_provider")
 
@@ -9276,8 +9483,8 @@ class TaskSetCapacityProviderStrategyItemArgs:
         Weight value characteristics:
 
         - Weight is considered after the base value is satisfied
-        - Default value is `0` if not specified
-        - Valid range: 0 to 1,000
+        - The default value is `0` if not specified
+        - The valid range is 0 to 1,000
         - At least one capacity provider must have a weight greater than zero
         - Capacity providers with weight of `0` cannot place tasks