This repo contains the code for a lambda function and terraform code to deploy it.
I've used this code to simplify the use of ASG's and the instances they manage in a bunch of different ways:
- Resource pools
- Autoscaling group of worker servers that have a deterministic set of IP's from a pool of Elastic IPs. As you scale up, the instances will grab an IP from the pool.
- Guarantee a particular server is up as much as possible and has a static IP.
- Stateful services
- Graphite servers that store their data on secondary EBS volumes and when they fall over are automatically recreated and have the volume reattached.
- Kafka servers that do the same, and when they rejoin the cluster only have to worry about what they missed while they were down (minutes)
- DNS (not yet supported)
- Guarantee that all hosts have a name associated to them based on Tag conventions (Name, Environment, etc), including reverse records.
- Support Round Robin records that automatically update when a server is replaced.
- Associate a CNAME record to the host's default record, for easier to remember - and shorter - names.
The basic design is simple. Add tags to an autoscaling group and propagate them to the instances that it creates. Add matching tags to other resources and the lambda function will attach them when the instance is running.
This works around the problem that from terraform you cannot attach an elastic IP to an instance that is built by an autoscaling group.
In its simplest form, you can ensure that an instance comes up with an address and/or volume reattached after replacement. You can take it further and have the instances grab resources from pools, to guarantee as you scale up and down that the new instances use addresses from the pool.
The code is written in Go and was originally designed and built by me while working at a previous job. It had become best practice at multiple companies where I worked to always build instances as part of an autoscaling group (even if you want just a single instance). This ensured that you were always building things as cattle not pets, by distancing you from the direct manipulation of instances. However, it does introduce a problem where you need to ensure that the host has an Elastic IP or EBS volume attached.
Automagical was born from that need.
Previously, it also managed DNS records (forward, reverse, CNAME's, and round robin), but this will require a bit more design, to make it configurable enough to be useful to a larger audience that may not architect their DNS infrastructure in the same way.
To make it as easy as possible to use, I've included Terraform modules that you can include into your existing Terraform configurations to manage all the related resources needed for the Automagical lambda function to run.
I'm not sure how long people will keep using instances in AWS, as many companies are moving to container-based architecture, but I have a feeling that instances won't go away entirely.
Please feel free to ping me or open PR's to expand the functionality.