Go CI/CD and Immutable Infrastructure for Edge Computing Management
In our last post, we pretty much tore apart the idea of running mini-clouds on the edge because they are not designed to be managed at scale in resource constrained environments without deep hardware automation. While I’m a huge advocate of API-driven infrastructure, I don’t believe in a one-size-fits-all API because a good API provides purpose-driven abstractions.
The logical extension is that having deep hardware automation means there’s no need for cloud (aka virtual infrastructure) APIs. This is exactly what container-focused customers have been telling us at RackN in regular data centers so we’d expect the same to apply for edge infrastructure.
If “cloudification” is not the solution then where should we look for management patterns?
We believe that software development CI/CD and immutable infrastructure patterns are well suited to edge infrastructure use cases. We discussed this at a session at the OpenStack OpenDev Edge summit.
Continuous Integration / Continuous Delivery (CI/CD) software pipelines help to manage environments where the risk of making changes is significant by breaking the changes into small, verifiable units. This is essential for edge because lack of physical access makes it very hard to mitigate problems. Using CI/CD, especially with A/B testing, allows for controlled rolling distribution of new software.
For example, in a 10,000 site deployment, the CI/CD infrastructure would continuously roll out updates and patches over the entire system. Small incremental changes reduce the risk of a major flaw being introduced. The effect is enhanced when changes are rolled slowly over the entire fleet instead of simultaneously rolled out to all sites (known as A/B or blue/green testing). In the rolling deployment scenario, breaking changes can be detected and stopped before they have significant impacts.
These processes and the support software systems are already in place for large scale cloud software deployments. There are likely gaps around physical proximity and heterogeneity; however, the process is there and initial use-case fit seems to be very good.
Immutable Infrastructure is a catch-all term for deployments based on images instead of configuration. This concept is popular in cloud deployments were teams produce “golden” VM or container images that contain the exact version of software needed and then are provisioned with minimal secondary configuration. In most cases, the images only need a small file injected (known as a cloud init) to complete the process.
In this immutable pattern, images are never updated post deployment; instead, instances are destroyed and recreated. It’s a deploy, destroy, repeat process. At RackN, we’ve been able to adapt Digital Rebar Provisioning to support this even at the hardware layer where images are delivered directly to disk and re-provisioning happens on a constant basis just like a cloud managing VMs.
The advantage of the immutable pattern is that we create a very repeatable and controlled environment. Instead of trying to maintain elaborate configurations and bi-directional systems of record, we can simply reset whole environments. In a CI/CD system, we constantly generate fresh images that are incrementally distributed through the environment.
Immutable Edge Infrastructure would mean building and deploying complete system images for our distributed environment. Clearly, this requires moving around larger images than just pushing patches; however, these uploads can easily be staged and they provide critical repeatability in management. The alternative is trying to keep track of which patches have been applied successfully to distributed systems. Based on personal experience, having an atomic deliverable sounds very attractive.
CI/CD and Immutable patterns are deep and complex subjects that go beyond the scope of a single post; however, they also offer a concrete basis for building manageable data centers.
The takeaway is that we need to be looking first to scale distributed software management patterns to help build robust edge infrastructure platforms. Picking a cloud platform before we’ve figured out these concerns is a waste of time.
Previous 2 Posts on OpenStack Conference: