Amazon ECS Service Discovery Construct Library

This module is part of the AWS Cloud Development Kit project.

This package contains constructs for working with AWS Cloud Map

AWS Cloud Map is a fully managed service that you can use to create and maintain a map of the backend services and resources that your applications depend on.

For further information on AWS Cloud Map, see the AWS Cloud Map documentation

HTTP Namespace Example

The following example creates an AWS Cloud Map namespace that supports API calls, creates a service in that namespace, and registers an instance to it:

import * as cdk from '../../core';
import * as servicediscovery from '../lib';

const app = new cdk.App();
const stack = new cdk.Stack(app, 'aws-servicediscovery-integ');

const namespace = new servicediscovery.HttpNamespace(stack, 'MyNamespace', {
  name: 'MyHTTPNamespace',
});

const service1 = namespace.createService('NonIpService', {
  description: 'service registering non-ip instances',
});

service1.registerNonIpInstance('NonIpInstance', {
  customAttributes: { arn: 'arn:aws:s3:::amzn-s3-demo-bucket' },
});

const service2 = namespace.createService('IpService', {
  description: 'service registering ip instances',
  healthCheck: {
    type: servicediscovery.HealthCheckType.HTTP,
    resourcePath: '/check',
  },
});

service2.registerIpInstance('IpInstance', {
  ipv4: '54.239.25.192',
});

app.synth();

python

import aws_cdk as cdk
import aws_cdk as servicediscovery

app = cdk.App()
stack = cdk.Stack(app, "aws-servicediscovery-integ")

namespace = servicediscovery.HttpNamespace(stack, "MyNamespace",
    name="MyHTTPNamespace"
)

service1 = namespace.create_service("NonIpService",
    description="service registering non-ip instances"
)

service1.register_non_ip_instance("NonIpInstance",
    custom_attributes={"arn": "arn:aws:s3:::amzn-s3-demo-bucket"}
)

service2 = namespace.create_service("IpService",
    description="service registering ip instances",
    health_check=cdk.aws_servicediscovery.HealthCheckConfig(
        type=servicediscovery.HealthCheckType.HTTP,
        resource_path="/check"
    )
)

service2.register_ip_instance("IpInstance",
    ipv4="54.239.25.192"
)

app.synth()

java

import software.amazon.awscdk.*;
import software.amazon.awscdk.*;

App app = new App();
Stack stack = new Stack(app, "aws-servicediscovery-integ");

HttpNamespace namespace = HttpNamespace.Builder.create(stack, "MyNamespace")
        .name("MyHTTPNamespace")
        .build();

Service service1 = namespace.createService("NonIpService", BaseServiceProps.builder()
        .description("service registering non-ip instances")
        .build());

service1.registerNonIpInstance("NonIpInstance", NonIpInstanceBaseProps.builder()
        .customAttributes(Map.of("arn", "arn:aws:s3:::amzn-s3-demo-bucket"))
        .build());

Service service2 = namespace.createService("IpService", BaseServiceProps.builder()
        .description("service registering ip instances")
        .healthCheck(HealthCheckConfig.builder()
                .type(HealthCheckType.HTTP)
                .resourcePath("/check")
                .build())
        .build());

service2.registerIpInstance("IpInstance", IpInstanceBaseProps.builder()
        .ipv4("54.239.25.192")
        .build());

app.synth();

csharp

using Amazon.CDK;
using Amazon.CDK;

var app = new App();
var stack = new Stack(app, "aws-servicediscovery-integ");

var namespace = new HttpNamespace(stack, "MyNamespace", new HttpNamespaceProps {
    Name = "MyHTTPNamespace"
});

var service1 = namespace.CreateService("NonIpService", new BaseServiceProps {
    Description = "service registering non-ip instances"
});

service1.RegisterNonIpInstance("NonIpInstance", new NonIpInstanceBaseProps {
    CustomAttributes = new Dictionary<string, string> { { "arn", "arn:aws:s3:::amzn-s3-demo-bucket" } }
});

var service2 = namespace.CreateService("IpService", new BaseServiceProps {
    Description = "service registering ip instances",
    HealthCheck = new HealthCheckConfig {
        Type = HealthCheckType.HTTP,
        ResourcePath = "/check"
    }
});

service2.RegisterIpInstance("IpInstance", new IpInstanceBaseProps {
    Ipv4 = "54.239.25.192"
});

app.Synth();

import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

app := cdk.NewApp()
stack := cdk.NewStack(app, jsii.String("aws-servicediscovery-integ"))

namespace := servicediscovery.NewHttpNamespace(stack, jsii.String("MyNamespace"), &HttpNamespaceProps{
	Name: jsii.String("MyHTTPNamespace"),
})

service1 := namespace.CreateService(jsii.String("NonIpService"), &BaseServiceProps{
	Description: jsii.String("service registering non-ip instances"),
})

service1.RegisterNonIpInstance(jsii.String("NonIpInstance"), &NonIpInstanceBaseProps{
	CustomAttributes: map[string]*string{
		"arn": jsii.String("arn:aws:s3:::amzn-s3-demo-bucket"),
	},
})

service2 := namespace.CreateService(jsii.String("IpService"), &BaseServiceProps{
	Description: jsii.String("service registering ip instances"),
	HealthCheck: &HealthCheckConfig{
		Type: servicediscovery.HealthCheckType_HTTP,
		ResourcePath: jsii.String("/check"),
	},
})

service2.RegisterIpInstance(jsii.String("IpInstance"), &IpInstanceBaseProps{
	Ipv4: jsii.String("54.239.25.192"),
})

app.Synth()

Private DNS Namespace Example

The following example creates an AWS Cloud Map namespace that supports both API calls and DNS queries within a vpc, creates a service in that namespace, and registers a loadbalancer as an instance.

A secondary service is also configured which only supports API based discovery, a non ip based resource is registered to this service:

import * as ec2 from '../../aws-ec2';
import * as elbv2 from '../../aws-elasticloadbalancingv2';
import * as cdk from '../../core';
import * as servicediscovery from '../lib';

const app = new cdk.App();
const stack = new cdk.Stack(app, 'aws-servicediscovery-integ');

const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2 });

const namespace = new servicediscovery.PrivateDnsNamespace(stack, 'Namespace', {
  name: 'boobar.com',
  vpc,
});

const service = namespace.createService('Service', {
  dnsRecordType: servicediscovery.DnsRecordType.A_AAAA,
  dnsTtl: cdk.Duration.seconds(30),
  loadBalancer: true,
});

const loadbalancer = new elbv2.ApplicationLoadBalancer(stack, 'LB', { vpc, internetFacing: true });

service.registerLoadBalancer('Loadbalancer', loadbalancer);

const arnService = namespace.createService('ArnService', {
  discoveryType: servicediscovery.DiscoveryType.API,
});

arnService.registerNonIpInstance('NonIpInstance', {
  customAttributes: { arn: 'arn://' },
});

app.synth();

python

import aws_cdk.aws_ec2 as ec2
import aws_cdk.aws_elasticloadbalancingv2 as elbv2
import aws_cdk as cdk
import aws_cdk as servicediscovery

app = cdk.App()
stack = cdk.Stack(app, "aws-servicediscovery-integ")

vpc = ec2.Vpc(stack, "Vpc", max_azs=2)

namespace = servicediscovery.PrivateDnsNamespace(stack, "Namespace",
    name="boobar.com",
    vpc=vpc
)

service = namespace.create_service("Service",
    dns_record_type=servicediscovery.DnsRecordType.A_AAAA,
    dns_ttl=cdk.Duration.seconds(30),
    load_balancer=True
)

loadbalancer = elbv2.ApplicationLoadBalancer(stack, "LB", vpc=vpc, internet_facing=True)

service.register_load_balancer("Loadbalancer", loadbalancer)

arn_service = namespace.create_service("ArnService",
    discovery_type=servicediscovery.DiscoveryType.API
)

arn_service.register_non_ip_instance("NonIpInstance",
    custom_attributes={"arn": "arn://"}
)

app.synth()

java

import software.amazon.awscdk.services.ec2.*;
import software.amazon.awscdk.services.elasticloadbalancingv2.*;
import software.amazon.awscdk.*;
import software.amazon.awscdk.*;

App app = new App();
Stack stack = new Stack(app, "aws-servicediscovery-integ");

Vpc vpc = Vpc.Builder.create(stack, "Vpc").maxAzs(2).build();

PrivateDnsNamespace namespace = PrivateDnsNamespace.Builder.create(stack, "Namespace")
        .name("boobar.com")
        .vpc(vpc)
        .build();

Service service = namespace.createService("Service", DnsServiceProps.builder()
        .dnsRecordType(DnsRecordType.A_AAAA)
        .dnsTtl(Duration.seconds(30))
        .loadBalancer(true)
        .build());

ApplicationLoadBalancer loadbalancer = ApplicationLoadBalancer.Builder.create(stack, "LB").vpc(vpc).internetFacing(true).build();

service.registerLoadBalancer("Loadbalancer", loadbalancer);

Service arnService = namespace.createService("ArnService", DnsServiceProps.builder()
        .discoveryType(DiscoveryType.API)
        .build());

arnService.registerNonIpInstance("NonIpInstance", NonIpInstanceBaseProps.builder()
        .customAttributes(Map.of("arn", "arn://"))
        .build());

app.synth();

csharp

using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ElasticLoadBalancingV2;
using Amazon.CDK;
using Amazon.CDK;

var app = new App();
var stack = new Stack(app, "aws-servicediscovery-integ");

var vpc = new Vpc(stack, "Vpc", new VpcProps { MaxAzs = 2 });

var namespace = new PrivateDnsNamespace(stack, "Namespace", new PrivateDnsNamespaceProps {
    Name = "boobar.com",
    Vpc = vpc
});

var service = namespace.CreateService("Service", new DnsServiceProps {
    DnsRecordType = DnsRecordType.A_AAAA,
    DnsTtl = Duration.Seconds(30),
    LoadBalancer = true
});

var loadbalancer = new ApplicationLoadBalancer(stack, "LB", new ApplicationLoadBalancerProps { Vpc = vpc, InternetFacing = true });

service.RegisterLoadBalancer("Loadbalancer", loadbalancer);

var arnService = namespace.CreateService("ArnService", new DnsServiceProps {
    DiscoveryType = DiscoveryType.API
});

arnService.RegisterNonIpInstance("NonIpInstance", new NonIpInstanceBaseProps {
    CustomAttributes = new Dictionary<string, string> { { "arn", "arn://" } }
});

app.Synth();

import ec2 "github.com/aws/aws-cdk-go/awscdk"
import elbv2 "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

app := cdk.NewApp()
stack := cdk.NewStack(app, jsii.String("aws-servicediscovery-integ"))

vpc := ec2.NewVpc(stack, jsii.String("Vpc"), &VpcProps{
	MaxAzs: jsii.Number(2),
})

namespace := servicediscovery.NewPrivateDnsNamespace(stack, jsii.String("Namespace"), &PrivateDnsNamespaceProps{
	Name: jsii.String("boobar.com"),
	Vpc: Vpc,
})

service := namespace.CreateService(jsii.String("Service"), &DnsServiceProps{
	DnsRecordType: servicediscovery.DnsRecordType_A_AAAA,
	DnsTtl: cdk.Duration_Seconds(jsii.Number(30)),
	LoadBalancer: jsii.Boolean(true),
})

loadbalancer := elbv2.NewApplicationLoadBalancer(stack, jsii.String("LB"), &ApplicationLoadBalancerProps{
	Vpc: Vpc,
	InternetFacing: jsii.Boolean(true),
})

service.RegisterLoadBalancer(jsii.String("Loadbalancer"), loadbalancer)

arnService := namespace.CreateService(jsii.String("ArnService"), &DnsServiceProps{
	DiscoveryType: servicediscovery.DiscoveryType_API,
})

arnService.RegisterNonIpInstance(jsii.String("NonIpInstance"), &NonIpInstanceBaseProps{
	CustomAttributes: map[string]*string{
		"arn": jsii.String("arn://"),
	},
})

app.Synth()

Public DNS Namespace Example

The following example creates an AWS Cloud Map namespace that supports both API calls and public DNS queries, creates a service in that namespace, and registers an IP instance:

import * as cdk from '../../core';
import * as servicediscovery from '../lib';

const app = new cdk.App();
const stack = new cdk.Stack(app, 'aws-servicediscovery-integ');

const namespace = new servicediscovery.PublicDnsNamespace(stack, 'Namespace', {
  name: 'foobar.com',
});

const service = namespace.createService('Service', {
  name: 'foo',
  dnsRecordType: servicediscovery.DnsRecordType.A,
  dnsTtl: cdk.Duration.seconds(30),
  healthCheck: {
    type: servicediscovery.HealthCheckType.HTTPS,
    resourcePath: '/healthcheck',
    failureThreshold: 2,
  },
});

service.registerIpInstance('IpInstance', {
  ipv4: '54.239.25.192',
  port: 443,
});

app.synth();

python

import aws_cdk as cdk
import aws_cdk as servicediscovery

app = cdk.App()
stack = cdk.Stack(app, "aws-servicediscovery-integ")

namespace = servicediscovery.PublicDnsNamespace(stack, "Namespace",
    name="foobar.com"
)

service = namespace.create_service("Service",
    name="foo",
    dns_record_type=servicediscovery.DnsRecordType.A,
    dns_ttl=cdk.Duration.seconds(30),
    health_check=cdk.aws_servicediscovery.HealthCheckConfig(
        type=servicediscovery.HealthCheckType.HTTPS,
        resource_path="/healthcheck",
        failure_threshold=2
    )
)

service.register_ip_instance("IpInstance",
    ipv4="54.239.25.192",
    port=443
)

app.synth()

java

import software.amazon.awscdk.*;
import software.amazon.awscdk.*;

App app = new App();
Stack stack = new Stack(app, "aws-servicediscovery-integ");

PublicDnsNamespace namespace = PublicDnsNamespace.Builder.create(stack, "Namespace")
        .name("foobar.com")
        .build();

Service service = namespace.createService("Service", DnsServiceProps.builder()
        .name("foo")
        .dnsRecordType(DnsRecordType.A)
        .dnsTtl(Duration.seconds(30))
        .healthCheck(HealthCheckConfig.builder()
                .type(HealthCheckType.HTTPS)
                .resourcePath("/healthcheck")
                .failureThreshold(2)
                .build())
        .build());

service.registerIpInstance("IpInstance", IpInstanceBaseProps.builder()
        .ipv4("54.239.25.192")
        .port(443)
        .build());

app.synth();

csharp

using Amazon.CDK;
using Amazon.CDK;

var app = new App();
var stack = new Stack(app, "aws-servicediscovery-integ");

var namespace = new PublicDnsNamespace(stack, "Namespace", new PublicDnsNamespaceProps {
    Name = "foobar.com"
});

var service = namespace.CreateService("Service", new DnsServiceProps {
    Name = "foo",
    DnsRecordType = DnsRecordType.A,
    DnsTtl = Duration.Seconds(30),
    HealthCheck = new HealthCheckConfig {
        Type = HealthCheckType.HTTPS,
        ResourcePath = "/healthcheck",
        FailureThreshold = 2
    }
});

service.RegisterIpInstance("IpInstance", new IpInstanceBaseProps {
    Ipv4 = "54.239.25.192",
    Port = 443
});

app.Synth();

import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

app := cdk.NewApp()
stack := cdk.NewStack(app, jsii.String("aws-servicediscovery-integ"))

namespace := servicediscovery.NewPublicDnsNamespace(stack, jsii.String("Namespace"), &PublicDnsNamespaceProps{
	Name: jsii.String("foobar.com"),
})

service := namespace.CreateService(jsii.String("Service"), &DnsServiceProps{
	Name: jsii.String("foo"),
	DnsRecordType: servicediscovery.DnsRecordType_A,
	DnsTtl: cdk.Duration_Seconds(jsii.Number(30)),
	HealthCheck: &HealthCheckConfig{
		Type: servicediscovery.HealthCheckType_HTTPS,
		ResourcePath: jsii.String("/healthcheck"),
		FailureThreshold: jsii.Number(2),
	},
})

service.RegisterIpInstance(jsii.String("IpInstance"), &IpInstanceBaseProps{
	Ipv4: jsii.String("54.239.25.192"),
	Port: jsii.Number(443),
})

app.Synth()

For DNS namespaces, you can also register instances to services with CNAME records:

import * as cdk from '../../core';
import * as servicediscovery from '../lib';

const app = new cdk.App();
const stack = new cdk.Stack(app, 'aws-servicediscovery-integ');

const namespace = new servicediscovery.PublicDnsNamespace(stack, 'Namespace', {
  name: 'foobar.com',
});

const service = namespace.createService('Service', {
  name: 'foo',
  dnsRecordType: servicediscovery.DnsRecordType.CNAME,
  dnsTtl: cdk.Duration.seconds(30),
});

service.registerCnameInstance('CnameInstance', {
  instanceCname: 'service.pizza',
});

app.synth();

python

import aws_cdk as cdk
import aws_cdk as servicediscovery

app = cdk.App()
stack = cdk.Stack(app, "aws-servicediscovery-integ")

namespace = servicediscovery.PublicDnsNamespace(stack, "Namespace",
    name="foobar.com"
)

service = namespace.create_service("Service",
    name="foo",
    dns_record_type=servicediscovery.DnsRecordType.CNAME,
    dns_ttl=cdk.Duration.seconds(30)
)

service.register_cname_instance("CnameInstance",
    instance_cname="service.pizza"
)

app.synth()

java

import software.amazon.awscdk.*;
import software.amazon.awscdk.*;

App app = new App();
Stack stack = new Stack(app, "aws-servicediscovery-integ");

PublicDnsNamespace namespace = PublicDnsNamespace.Builder.create(stack, "Namespace")
        .name("foobar.com")
        .build();

Service service = namespace.createService("Service", DnsServiceProps.builder()
        .name("foo")
        .dnsRecordType(DnsRecordType.CNAME)
        .dnsTtl(Duration.seconds(30))
        .build());

service.registerCnameInstance("CnameInstance", CnameInstanceBaseProps.builder()
        .instanceCname("service.pizza")
        .build());

app.synth();

csharp

using Amazon.CDK;
using Amazon.CDK;

var app = new App();
var stack = new Stack(app, "aws-servicediscovery-integ");

var namespace = new PublicDnsNamespace(stack, "Namespace", new PublicDnsNamespaceProps {
    Name = "foobar.com"
});

var service = namespace.CreateService("Service", new DnsServiceProps {
    Name = "foo",
    DnsRecordType = DnsRecordType.CNAME,
    DnsTtl = Duration.Seconds(30)
});

service.RegisterCnameInstance("CnameInstance", new CnameInstanceBaseProps {
    InstanceCname = "service.pizza"
});

app.Synth();

import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

app := cdk.NewApp()
stack := cdk.NewStack(app, jsii.String("aws-servicediscovery-integ"))

namespace := servicediscovery.NewPublicDnsNamespace(stack, jsii.String("Namespace"), &PublicDnsNamespaceProps{
	Name: jsii.String("foobar.com"),
})

service := namespace.CreateService(jsii.String("Service"), &DnsServiceProps{
	Name: jsii.String("foo"),
	DnsRecordType: servicediscovery.DnsRecordType_CNAME,
	DnsTtl: cdk.Duration_Seconds(jsii.Number(30)),
})

service.RegisterCnameInstance(jsii.String("CnameInstance"), &CnameInstanceBaseProps{
	InstanceCname: jsii.String("service.pizza"),
})

app.Synth()

Types

Name	Kind	Summary
`AliasTargetInstance`	Construct (L2)	Instance that uses Route 53 Alias record type.
`CnameInstance`	Construct (L2)	Instance that is accessible using a domain name (CNAME).
`HttpNamespace`	Construct (L2)	Define an HTTP Namespace.
`InstanceBase`	Construct (L2)
`IpInstance`	Construct (L2)	Instance that is accessible using an IP address.
`NonIpInstance`	Construct (L2)	Instance accessible using values other than an IP address or a domain name (CNAME).
`PrivateDnsNamespace`	Construct (L2)	Define a Service Discovery HTTP Namespace.
`PublicDnsNamespace`	Construct (L2)	Define a Public DNS Namespace.
`Service`	Construct (L2)	Define a CloudMap Service.
`CfnHttpNamespace`	Construct (L1)	Creates an HTTP namespace.
`CfnInstance`	Construct (L1)	A complex type that contains information about an instance that AWS Cloud Map creates when you submit a `RegisterInstance` request.
`CfnPrivateDnsNamespace`	Construct (L1)	Creates a private namespace based on DNS, which is visible only inside a specified Amazon VPC.
`CfnPublicDnsNamespace`	Construct (L1)	Creates a public namespace based on DNS, which is visible on the internet.
`CfnService`	Construct (L1)	A complex type that contains information about the specified service.
`AliasTargetInstanceProps`	Struct
`BaseInstanceProps`	Struct	Used when the resource that's associated with the service instance is accessible using values other than an IP address or a domain name (CNAME), i.e. for non-ip-instances.
`BaseNamespaceProps`	Struct
`BaseServiceProps`	Struct	Basic props needed to create a service in a given namespace.
`CfnHttpNamespaceProps`	Struct	Properties for defining a `CfnHttpNamespace`.
`CfnInstanceProps`	Struct	Properties for defining a `CfnInstance`.
`CfnPrivateDnsNamespace.PrivateDnsPropertiesMutableProperty`	Struct	DNS properties for the private DNS namespace.
`CfnPrivateDnsNamespace.PropertiesProperty`	Struct	Properties for the private DNS namespace.
`CfnPrivateDnsNamespace.SOAProperty`	Struct	Start of Authority (SOA) properties for a public or private DNS namespace.
`CfnPrivateDnsNamespaceProps`	Struct	Properties for defining a `CfnPrivateDnsNamespace`.
`CfnPublicDnsNamespace.PropertiesProperty`	Struct	Properties for the public DNS namespace.
`CfnPublicDnsNamespace.PublicDnsPropertiesMutableProperty`	Struct	DNS properties for the public DNS namespace.
`CfnPublicDnsNamespace.SOAProperty`	Struct	Start of Authority (SOA) properties for a public or private DNS namespace.
`CfnPublicDnsNamespaceProps`	Struct	Properties for defining a `CfnPublicDnsNamespace`.
`CfnService.DnsConfigProperty`	Struct	A complex type that contains information about the Amazon Route 53 DNS records that you want AWS Cloud Map to create when you register an instance.
`CfnService.DnsRecordProperty`	Struct	A complex type that contains information about the Route 53 DNS records that you want AWS Cloud Map to create when you register an instance.
`CfnService.HealthCheckConfigProperty`	Struct	Public DNS and HTTP namespaces only. A complex type that contains settings for an optional health check. If you specify settings for a health check, AWS Cloud Map associates the health check with the records that you specify in `DnsConfig` .
`CfnService.HealthCheckCustomConfigProperty`	Struct	A complex type that contains information about an optional custom health check.
`CfnServiceProps`	Struct	Properties for defining a `CfnService`.
`CnameInstanceBaseProps`	Struct
`CnameInstanceProps`	Struct
`DiscoveryType`	Enum	Specifies information about the discovery type of a service.
`DnsRecordType`	Enum
`DnsServiceProps`	Struct	Service props needed to create a service in a given namespace.
`HealthCheckConfig`	Struct	Settings for an optional Amazon Route 53 health check.
`HealthCheckCustomConfig`	Struct	Specifies information about an optional custom health check.
`HealthCheckType`	Enum
`HttpNamespaceAttributes`	Struct
`HttpNamespaceProps`	Struct
`IHttpNamespace`	Interface
`IInstance`	Interface
`INamespace`	Interface	A type of namespace.
`IpInstanceBaseProps`	Struct
`IpInstanceProps`	Struct
`IPrivateDnsNamespace`	Interface
`IPublicDnsNamespace`	Interface
`IService`	Interface
`NamespaceType`	Enum
`NonIpInstanceBaseProps`	Struct
`NonIpInstanceProps`	Struct
`PrivateDnsNamespaceAttributes`	Struct
`PrivateDnsNamespaceProps`	Struct
`PublicDnsNamespaceAttributes`	Struct
`PublicDnsNamespaceProps`	Struct
`RoutingPolicy`	Enum
`ServiceAttributes`	Struct
`ServiceProps`	Struct

Amazon ECS Service Discovery Construct Library ​

HTTP Namespace Example ​

Private DNS Namespace Example ​

Public DNS Namespace Example ​

Types ​

Amazon ECS Service Discovery Construct Library

HTTP Namespace Example

Private DNS Namespace Example

Public DNS Namespace Example

Types