# BaseServiceOptions

The properties for the base Ec2Service or FargateService service.

- Source: [`aws-ecs/lib/base/base-service.ts`](https://github.com/aws/aws-cdk/blob/v2.274.0/packages/aws-cdk-lib/aws-ecs/lib/base/base-service.ts#L426)
- Type last changed: v2.259.0 · 12 Jun 2026

## Example

```ts
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import * as cdk from 'aws-cdk-lib';
import { aws_ecs as ecs } from 'aws-cdk-lib';
import { aws_iam as iam } from 'aws-cdk-lib';
import { aws_servicediscovery as servicediscovery } from 'aws-cdk-lib';
import { aws_kms as interfaces_kms } from 'aws-cdk-lib/interfaces';

declare const cluster: ecs.Cluster;
declare const containerDefinition: ecs.ContainerDefinition;
declare const deploymentLifecycleHookTarget: ecs.IDeploymentLifecycleHookTarget;
declare const keyRef: interfaces_kms.IKeyRef;
declare const logDriver: ecs.LogDriver;
declare const namespace: servicediscovery.INamespace;
declare const role: iam.Role;
declare const serviceManagedVolume: ecs.ServiceManagedVolume;
declare const taskDefinitionRevision: ecs.TaskDefinitionRevision;
const baseServiceOptions: ecs.BaseServiceOptions = {
  cluster: cluster,

  // the properties below are optional
  bakeTime: cdk.Duration.minutes(30),
  canaryConfiguration: {
    stepBakeTime: cdk.Duration.minutes(30),
    stepPercent: 123,
  },
  capacityProviderStrategies: [{
    capacityProvider: 'capacityProvider',

    // the properties below are optional
    base: 123,
    weight: 123,
  }],
  circuitBreaker: {
    enable: false,
    rollback: false,
  },
  cloudMapOptions: {
    cloudMapNamespace: namespace,
    container: containerDefinition,
    containerPort: 123,
    dnsRecordType: servicediscovery.DnsRecordType.A,
    dnsTtl: cdk.Duration.minutes(30),
    failureThreshold: 123,
    name: 'name',
  },
  deploymentAlarms: {
    alarmNames: ['alarmNames'],

    // the properties below are optional
    behavior: ecs.AlarmBehavior.ROLLBACK_ON_ALARM,
  },
  deploymentController: {
    type: ecs.DeploymentControllerType.ECS,
  },
  deploymentStrategy: ecs.DeploymentStrategy.ROLLING,
  desiredCount: 123,
  enableECSManagedTags: false,
  enableExecuteCommand: false,
  forceNewDeployment: {
    enabled: false,

    // the properties below are optional
    nonce: 'nonce',
  },
  healthCheckGracePeriod: cdk.Duration.minutes(30),
  lifecycleHooks: [deploymentLifecycleHookTarget],
  linearConfiguration: {
    stepBakeTime: cdk.Duration.minutes(30),
    stepPercent: 123,
  },
  maxHealthyPercent: 123,
  minHealthyPercent: 123,
  propagateTags: ecs.PropagatedTagSource.SERVICE,
  serviceConnectConfiguration: {
    accessLogConfiguration: {
      format: ecs.ServiceConnectAccessLogFormat.TEXT,

      // the properties below are optional
      includeQueryParameters: false,
    },
    logDriver: logDriver,
    namespace: 'namespace',
    services: [{
      portMappingName: 'portMappingName',

      // the properties below are optional
      discoveryName: 'discoveryName',
      dnsName: 'dnsName',
      idleTimeout: cdk.Duration.minutes(30),
      ingressPortOverride: 123,
      perRequestTimeout: cdk.Duration.minutes(30),
      port: 123,
      tls: {
        awsPcaAuthorityArn: 'awsPcaAuthorityArn',
        kmsKey: keyRef,
        role: role,
      },
    }],
  },
  serviceName: 'serviceName',
  taskDefinitionRevision: taskDefinitionRevision,
  volumeConfigurations: [serviceManagedVolume],
};
```

## Properties

- `bakeTime`: [Duration](/cdk/api/v2/docs/aws-cdk-lib.Duration.html) = none — bake time minutes for service.

- `canaryConfiguration`: [TrafficShiftConfig](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.TrafficShiftConfig.html) — Configuration for canary deployment strategy.

  **Default:** no canary configuration

  Only valid when deploymentStrategy is set to CANARY.

- `capacityProviderStrategies`: [CapacityProviderStrategy](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.CapacityProviderStrategy.html)[] = undefined — A list of Capacity Provider strategies used to place a service.

- `circuitBreaker`: [DeploymentCircuitBreaker](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.DeploymentCircuitBreaker.html) = disabled — Whether to enable the deployment circuit breaker.

  If this property is defined, circuit breaker will be implicitly
  enabled.

- `cloudMapOptions`: [CloudMapOptions](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.CloudMapOptions.html) — The options for configuring an Amazon ECS service to use service discovery.

  **Default:** AWS Cloud Map service discovery is not enabled.

- `cluster`: [ICluster](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ICluster.html) (required) — The name of the cluster that hosts the service.

- `deploymentAlarms`: [DeploymentAlarmConfig](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.DeploymentAlarmConfig.html) — The alarm(s) to monitor during deployment, and behavior to apply if at least one enters a state of alarm during the deployment or bake time.

  **Default:** No alarms will be monitored during deployment.

- `deploymentController`: [DeploymentController](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.DeploymentController.html) — Specifies which deployment controller to use for the service.

  **Default:** Rolling update (ECS)

  For more information, see
  [Amazon ECS Deployment Types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)

- `deploymentStrategy`: [DeploymentStrategy](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.DeploymentStrategy.html) = ROLLING — The deployment strategy to use for the service.

- `desiredCount`: number — The desired number of instantiations of the task definition to keep running on the service.

  **Default:** When creating the service, default is 1; when updating the service, default uses the current task number.

- `enableECSManagedTags`: boolean = false — Specifies whether to enable Amazon ECS managed tags for the tasks within the service.

  For more information, see
  [Tagging Your Amazon ECS Resources](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html)

- `enableExecuteCommand`: boolean = undefined — Whether to enable the ability to execute into a container.

- `forceNewDeployment`: [ForceNewDeployment](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ForceNewDeployment.html) — Configuration for forcing a new deployment of the service.

  **Default:** no forced deployment

  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.

  This is equivalent to calling the `forceNewDeployment()` method, but allows
  you to configure it declaratively at construction time, including the ability
  to explicitly disable it with `enabled: false`.

- `healthCheckGracePeriod`: [Duration](/cdk/api/v2/docs/aws-cdk-lib.Duration.html) — 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.

  **Default:** defaults to 60 seconds if at least one load balancer is in-use and it is not already set

- `lifecycleHooks`: [IDeploymentLifecycleHookTarget](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.IDeploymentLifecycleHookTarget.html)[] = none; — The lifecycle hooks to execute during deployment stages.

- `linearConfiguration`: [TrafficShiftConfig](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.TrafficShiftConfig.html) — Configuration for linear deployment strategy.

  **Default:** no linear configuration

  Only valid when deploymentStrategy is set to LINEAR.

- `maxHealthyPercent`: number — The maximum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that can run in a service during a deployment.

  **Default:** 100 if daemon, otherwise 200

- `minHealthyPercent`: number — The minimum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that must continue to run and remain healthy during a deployment.

  **Default:** 0 if daemon, otherwise 50

- `propagateTags`: [PropagatedTagSource](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.PropagatedTagSource.html) = PropagatedTagSource.NONE — Specifies whether to propagate the tags from the task definition or the service to the tasks in the service.

  Valid values are: PropagatedTagSource.SERVICE, PropagatedTagSource.TASK_DEFINITION or PropagatedTagSource.NONE

- `serviceConnectConfiguration`: [ServiceConnectProps](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ServiceConnectProps.html) — Configuration for Service Connect.

  **Default:** No ports are advertised via Service Connect on this service, and the service cannot make requests to other services via Service Connect.

- `serviceName`: string — The name of the service.

  **Default:** CloudFormation-generated name.

- `taskDefinitionRevision`: [TaskDefinitionRevision](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.TaskDefinitionRevision.html) — Revision number for the task definition or `latest` to use the latest active task revision.

  **Default:** Uses the revision of the passed task definition deployed by CloudFormation

- `volumeConfigurations`: [ServiceManagedVolume](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ServiceManagedVolume.html)[] = undefined — Configuration details for a volume used by the service.

  This allows you to specify
  details about the EBS volume that can be attached to ECS tasks.