8.2.4 AWS Route 53 Support

To use Route 53 Service Discovery, you must meet the following criteria:

• Run EC2 instances of some type

• Have a domain name hosted in Route 53

• Have a newer version of AWS-CLI (such as 14+)

Assuming you have those things, you are ready. It is not as fancy as Consul or Eureka, but other than some initial setup with the AWS-CLI, there is no other software running to go wrong. You can even support health checks if you add a custom health check to your service. To test if your account can create and use Service Discovery, see the Integration Test section. More information is available at https://docs.aws.amazon.com/Route53/latest/APIReference/overview-service-discovery.html.

Here are the steps:

1. Use AWS-CLI to create a namespace. You can make either a public or private one depending on the IPs or subnets you use

2. Create a service with DNS Records with AWS-CLI command

3. Add health checks or custom health checks (optional)

4. Add Service ID to your application configuration file like so:

Sample application.yml

aws:
  route53:
    registration
    enabled: true
    aws-service-id: srv-978fs98fsdf
    namespace: micronaut.io
micronaut:
  application:
    name: something

1. Make sure you have the following dependencies in your build file:

implementation("io.micronaut.aws:micronaut-aws-route53")

<dependency>
    <groupId>io.micronaut.aws</groupId>
    <artifactId>micronaut-aws-route53</artifactId>
</dependency>

1. On the client side, you need the same dependencies and fewer configuration options:

Sample application.yml

aws:
  route53:
    discovery:
      client:
        enabled: true
        aws-service-id: srv-978fs98fsdf
        namespace-id: micronaut.io

You can then use the DiscoveryClient API to find other services registered via Route 53. For example:

Sample code for client

DiscoveryClient discoveryClient = embeddedServer.getApplicationContext().getBean(DiscoveryClient.class);
List<String> serviceIds = Flux.from(discoveryClient.getServiceIds()).blockFirst();
List<ServiceInstance> instances = Flux.from(discoveryClient.getInstances(serviceIds.get(0))).blockFirst();

Creating the Namespace

Namespaces are similar to a regular Route53 hosted zone, and they appear in the Route53 console, but the console doesn’t support modifying them. You must use the AWS-CLI at this time for any Service Discovery functionality.

First decide if you are creating a public-facing namespace or a private one, as the commands are different:

Creating Namespace

$ aws servicediscovery create-public-dns-namespace --name micronaut.io --create-request-id create-1522767790 --description adescriptionhere
or
$ aws servicediscovery create-private-dns-namespace --name micronaut.internal.io --create-request-id create-1522767790 --description adescriptionhere --vpc yourvpcID

When you run this you will get an operation ID. You can check the status with the get-operation CLI command:

Get Operation Results

$ aws servicediscovery get-operation --operation-id asdffasdfsda

You can use this command to get the status of any call you make that returns an operation ID.

The result of the command will tell you the ID of the namespace. Write that down, you’ll need it for the next steps. If you get an error it will say what the error was.

Creating the Service and DNS Records

The next step is creating the Service and DNS records.

Create Service

$ aws create-service --name yourservicename --create-request-id somenumber --description someservicedescription --dns-config NamespaceId=yournamespaceid,RoutingPolicy=WEIGHTED,DnsRecords=[{Type=A,TTL=1000},{Type=A,TTL=1000}]

The DnsRecord type can be A(ipv4),AAAA(ipv6),SRV, or CNAME. RoutingPolicy can be WEIGHTED or MULTIVALUE. Keep in mind CNAME must use weighted routing type, SRV must have a valid port configured.

To add a health check, use the following syntax on the CLI:

Specifying a Health Check

Type=string,ResourcePath=string,FailureThreshold=integer

Type can be ‘HTTP’,’HTTPS’, or ‘TCP’. You can only use a standard health check on a public namespace. See Custom Health Checks for private namespaces. Resource path should be a URL that returns 200 OK if it is healthy.

For a custom health check, you only need to specify --health-check-custom-config FailureThreshold=integer which works on private namespaces as well.

This is also good because Micronaut sends out pulsation commands to let AWS know the instance is still healthy.

For more help run ‘aws discoveryservice create-service help’.

You will get a service ID and an ARN back from this command if successful. Write that down, it is going to go into the Micronaut configuration.

Setting up the configuration in Micronaut

Auto Naming Registration

Add the configuration to make your applications register with Route 53 Auto-discovery:

Registration Properties

aws:
  route53:
    registration:
      enabled: true
      aws-service-id=<enter the service id you got after creation on aws cli>
    discovery:
      namespace-id=<enter the namespace id you got after creating the namespace>

Discovery Client Configuration

Discovery Properties

aws:
  route53:
    discovery:
      client
      enabled: true
      aws-service-id: <enter the service id you got after creation on aws cli>

You can also call the following methods by getting the bean “Route53AutoNamingClient”:

Discovery Methods

// if serviceId is null it will use property "aws.route53.discovery.client.awsServiceId"
Publisher<List<ServiceInstance>> getInstances(String serviceId)
// reads property "aws.route53.discovery.namespaceId"
Publisher<List<String>> getServiceIds()

Integration Tests

If you set the environment variable AWS_SUBNET_ID and have credentials configured in your home directory that are valid (in ~/.aws/credentials) you can run the integration tests. You need a domain hosted on Route53 as well. This test will create a t2.nano instance, a namespace, service, and register that instance to service discovery. When the test completes it will remove/terminate all resources it spun up.