feat(ecs): allow selection of container and port for SRV service discovery records

packages/@aws-cdk/aws-ecs/README.md

@@ -683,6 +683,49 @@ taskDefinition.addContainer('TheContainer', {
 });
 ```
 
+## CloudMap Service Discovery
+
+To register your ECS service with a CloudMap Service Registry, you may add the
+`cloudMapOptions` property to your service:
+
+```ts
+const service = new ecs.Ec2Service(stack, 'Service', {
+ cluster,
+ taskDefinition,
+ cloudMapOptions: {
+ // Create A records - useful for AWSVPC network mode.
+ dnsRecordType: cloudmap.DnsRecordType.A,
+ },
+});
+```
+
+With `bridge` or `host` network modes, only `SRV` DNS record types are supported. 
+By default, `SRV` DNS record types will target the default container and default
+port. However, you may target a different container and port on the same ECS task:
+
+```ts
+// Add a container to the task definition
+const specificContainer = taskDefinition.addContainer(...);
+
+// Add a port mapping
+specificContainer.addPortMappings({
+ containerPort: 7600,
+ protocol: ecs.Protocol.TCP,
+});
+
+new ecs.Ec2Service(stack, 'Service', {
+ cluster,
+ taskDefinition,
+ cloudMapOptions: {
+ // Create SRV records - useful for bridge networking
+ dnsRecordType: cloudmap.DnsRecordType.SRV,
+ // Targets port TCP port 7600 `specificContainer`
+ container: specificContainer,
+ containerPort: 7600,
+ },
+});
+```
+
 ## Capacity Providers
 
 Currently, only `FARGATE` and `FARGATE_SPOT` capacity providers are supported.

packages/@aws-cdk/aws-ecs/lib/base/base-service.ts

@@ -8,8 +8,8 @@ import * as cloudmap from '@aws-cdk/aws-servicediscovery';
 import { Annotations, Duration, IResolvable, IResource, Lazy, Resource, Stack } from '@aws-cdk/core';
 import { Construct } from 'constructs';
 import { LoadBalancerTargetOptions, NetworkMode, TaskDefinition } from '../base/task-definition';
+import { ContainerDefinition, Protocol } from '../container-definition';
 import { ICluster, CapacityProviderStrategy } from '../cluster';
-import { Protocol } from '../container-definition';
 import { CfnService } from '../ecs.generated';
 import { ScalableTaskCount } from './scalable-task-count';
 
@@ -572,10 +572,12 @@ export abstract class BaseService extends Resource
  }
  }
 
- // If the task definition that your service task specifies uses the AWSVPC network mode and a type SRV DNS record is
- // used, you must specify a containerName and containerPort combination
- const containerName = dnsRecordType === cloudmap.DnsRecordType.SRV ? this.taskDefinition.defaultContainer!.containerName : undefined;
- const containerPort = dnsRecordType === cloudmap.DnsRecordType.SRV ? this.taskDefinition.defaultContainer!.containerPort : undefined;
+ const { containerName, containerPort } = determineContainerNameAndPort({
+ taskDefinition: this.taskDefinition,
+ dnsRecordType: dnsRecordType!,
+ container: options.container,
+ containerPort: options.containerPort,
+ });
 
  const cloudmapService = new cloudmap.Service(this, 'CloudmapService', {
  namespace: sdNamespace,
@@ -799,7 +801,19 @@ export interface CloudMapOptions {
  *
  * NOTE: This is used for HealthCheckCustomConfig
  */
- readonly failureThreshold?: number,
+ readonly failureThreshold?: number;
+
+ /**
+ * The container to point to for a SRV record.
+ * @default - the task definition's default container
+ */
+ readonly container?: ContainerDefinition;
+
+ /**
+ * The port to point to for a SRV record.
+ * @default - the default port of the task definition's default container
+ */
+ readonly containerPort?: number;
 }
 
 /**
@@ -885,3 +899,42 @@ export enum PropagatedTagSource {
  */
  NONE = 'NONE'
 }
+
+/**
+ * Options for `determineContainerNameAndPort`
+ */
+interface DetermineContainerNameAndPortOptions {
+ dnsRecordType: cloudmap.DnsRecordType;
+ taskDefinition: TaskDefinition;
+ container?: ContainerDefinition;
+ containerPort?: number;
+}
+
+/**
+ * Determine the name of the container and port to target for the service registry.
+ */
+function determineContainerNameAndPort(options: DetermineContainerNameAndPortOptions) {
+ // If the record type is SRV, then provide the containerName and containerPort to target.
+ // We use the name of the default container and the default port of the default container
+ // unless the user specifies otherwise.
+ if (options.dnsRecordType === cloudmap.DnsRecordType.SRV) {
+ // Ensure the user-provided container is from the right task definition.
+ if (options.container && options.container.taskDefinition != options.taskDefinition) {
+ throw new Error('Cannot add discovery for a container from another task definition');
+ }
+
+ const container = options.container ?? options.taskDefinition.defaultContainer!;
+
+ // Ensure that any port given by the user is mapped.
+ if (options.containerPort && !container.portMappings.some(mapping => mapping.containerPort === options.containerPort)) {
+ throw new Error('Cannot add discovery for a container port that has not been mapped');
+ }
+
+ return {
+ containerName: container.containerName,
+ containerPort: options.containerPort ?? options.taskDefinition.defaultContainer!.containerPort,
+ };
+ }
+
+ return {};
+}