What “Everything as Code” is and why it matters

Simply put, “Everything as Code” (EaC) is a way to manage IT infrastructure and build systems and tools that support modern software applications. It converts the manual processes and activities humans do into software code so that machines can do those things. Everything teams need to figure out, agree on and check is documented and ‘codified’ as a configuration file that humans can read and then run by machines.

Imagine if your kitchen could somehow understand your favorite recipe and then automatically choose the right tools to prepare it, the right process to cook it, and even the right wine and dessert pairings, and than would serve that exact meal to you over and over, every time you asked for it. Sounds impossible? …It is. But if your kitchen were a public cloud provider and your meal was a software application, that’s pretty much exactly what we’re talking about here.

With Everything as Code, developers can tell their cloud providers (or their on-premises systems) exactly what they need to “serve” the perfect application, and then the systems, tools, and processes all execute that plan to make it a reality.

Use development best practices to accelerate time to market

EaC has been both a cultural and technological shift as it completely revolutionized the way developers think about building, deploying and updating software. For example, if a small business needs to run an application before “as code,” it has to go through a lot of steps. An IT administrator would order a physical server with the correct amount of physical disk, CPU, and memory built-in. It would arrive a few weeks later and the administrator would have to install the operating system, configure the kernel for maximum efficiency, and then connect the server to a physical network. All of these steps were time-consuming, prone to human error, and not easily scalable – and just a few of the things that had to be done before software developers could actually start using their apps.

With an “as code” approach, a developer can describe the same infrastructure in a policy configuration file, which tells their chosen cloud provider exactly what type of server environment to “step up.” The cloud provider has set it up within seconds and development can start immediately. If the developer later needs to make a change or move from a test environment to a production environment, all he has to do is modify the file in code, resubmit it, and the cloud provider will have it updated in seconds. This increases speed and scale exponentially, as machines can run code much faster than humans can perform tasks, and if done right, it can also eliminate human error and repetitive work.

Popular “as code” examples

Two of the most popular examples of “as code” that are part of the Everything as Code movement are infrastructure as code and policy as code:

Infrastructure as code

Modern software runs in a hyper-virtualized environment, which increases complexity but also allows for an unparalleled level of control. Application code runs in virtual containers, which themselves run on virtual machines, all connected to virtual networks – all of which can be controlled by software code. Today, instead of ordering a server, developers can simply define what their app needs and then submit that request as software code. The cloud platforms run that code and automatically build the requested environment. What’s really important about this is that it allows companies to scale “on demand” – they pay for the actual usage at a given point in time and they can scale up or down as needed.

Policy as code

This is when policies are a set of rules codified and enforced across systems. Think of “policy as code” as a series of guardrails that define what can happen and what can never happen. The policy is decoupled — or separate — from the app or infrastructure. That way, if a policy needs to be changed, a developer doesn’t have to update the rest of the app or infrastructure or worry about changing or breaking it. That means you can change the encoding for the policy without changing the encoding for the app. Open Policy agent (OPA) is a good example of policy as code — OPA is a general purpose policy engine that provides a single standard for policies that can be enforced anywhere.

Top three benefits of an everything-as-code approach

When you let people be creative and think through difficult problems, and you let them collaborate, share and imagine, we all know that magic can happen. Anything Like Code lets humans decide what’s right, then commands machines to make it so. That means you get the best out of everything, including:

• Repeatability: All processes, policies, and descriptions are coded for easy replication. Let’s say a developer working for an international bank wants to create a policy that says, “Only Central US users can access business accounts between 9am and 5pm CT.” If another developer in Europe wants to implement the same policy but with an updated time zone, they can easily replicate the policy to do so. This saves the second developer time, does not have to reinvent the wheel and also means less room for error.
• Scalability: Defining configuration as code means systems can scale up and down on demand with little chance of error. And since environments are literally defined in code and can be launched from anywhere, testing becomes easier too. Development, test, and production environments can be as close as possible, and lessons learned in one can be applied to the other just by making policy changes. An “as code” approach allows developers to test their changes before deploying them to production, reducing the risk of errors and security risks. Automation also frees up developers’ time and allows them to focus on more differentiated work.
• Security: When security policies and configuration are moved out of dedicated black boxes, PDFs, and team meetings and instead codified into policy files, teams can treat those policy files just like any other software file. That means they check in and peer review. They’re repeating it and implementing that security everywhere. It can be rolled forward or backward as needed. And when teams need to prove to auditors that their policies are compliant, they can simply refer to the code.

When done right, “everything as code” teams can determine what’s right and then the systems take over. It democratizes the ability to build applications and solve problems, meaning more people can contribute to a better end product.

And of course Everything as Code is not just about controlling systems. It also leverages the work culture that software developers have built to minimize errors and maximize satisfaction and productivity. By automating repetition and promoting collaboration, Everything as Code empowers people to focus on new challenges and meaningful work and let the machines do the rest.

Tim Hinrichs is CTO and co-founder of Styra.