Enterprises are plagued by fire drills. Experts in enterprise architecture, operations, and on application teams are dragged into unexpected issues, and spend precious hours, days, and even weeks debugging what are ultimately low-value problems. The most common of these issues is applications that work in test, but are mysteriously not working in production. The conversation usually goes something like this:
App Dev: Are you sure the environments are configured the same?
App Dev: Are you sure?
Ops: Shoot, I missed a checkbox while configuring the node, it works now!
Enterprises assert that they have “standardized” on a particular technology stack, but often times all that really means is that there is a document somewhere that has issued a decree to use product or framework X. The creation of systems are still manually done and, regardless of the “standard,” every virtual machine is still a snowflake. In addition to longer creation and debugging times, snowflakes also create unique attack vectors that, at scale, make securing an environment really difficult.
There is an assumption that there is some magic in the cloud that is the answer. At the most basic level, cloud is supposed to translate into standardizing, automating, and virtualizing systems. But that description is so 2008! Ultimately, for an enterprise the first step to cloud success is embracing “architecture as code,” enabling IT to operate with speed, consistency, and repeatability.
Architecture as code is about patterns. The patterns automate the creation and lifecycle management of 95 percent to 99 percent of an application’s topology. For example, a Highly Available Web Application would contain the automation scripts needed to create a clustered web tier, a clustered app server tier, a clustered database tier, and the network configurations necessary to connect those tiers together. Lifecycle management operations executed against the pattern drive operations against each of the tiers as needed. A centralized function, like enterprise architecture, can create a pattern library that contains authoritative, hardened, tuned application topologies that are secure by design. With that pattern library, operations no longer needs to manually create the dev, test, and production topologies for Web Apps, Mobile Apps, an Enterprise Service Bus, etc.
Application developers select the type of pattern needed, including the desired quality of service (QoS) eg. Single-instance dev or highly available, provide the final configuration elements needed (the .war file, database connection details, etc). Then the application developer watches the automation instatiate their environment. When done correctly, the only difference between test and production will be the user id’s, passwords, and IP addresses used to instantiate the highly-available web application pattern.
An important benefit that comes from creating a pattern library and embracing architecture as code is that application developers no longer need to care about the underlying plumbing. There is no need to worry about whether the application is running in a container or a VM or is it on-prem or off-prem. Instead, developers can focus on shipping code that drives business value and can trust that their apps are in fact providing the as advertised QoS.
There is a huge cost benefit as well. A large chunk of the IT costs for creating an enterprise application comes from building the underlying plumbing. With patterns, that cost is freed up and can be redirected to focus on higher-value work. By decoupling the application from the plumbing details, IT Operations has the flexibility to optimize workloads with little fear of breaking applications.
This is critical as enterprises migrate to the cloud, an enterprise-wide pattern library becomes an abstraction layer. As long as the pattern’s capabilities are consistent across off-prem and on-prem, applications can be seamlessly moved around, enabling a true hybrid cloud.
Architecture as code is an inherent capability of Platform as a Service (PaaS), cloud management services, and the emerging container ecosystem. Though some enterprises have deployed these technologies, only a fraction of the enterprise applications have been successfully migrated. Many enterprise applications are still in production running on manually created snowflakes that are still causing fire drills. Regardless of whether an enterprise leverages the capabilities of an out-of-the-box PaaS, or their own architecture-as-code solution, patterns enable enterprises to embrace three simple principles:
- Keep it simple: Patterns eliminate much of the manual work, and fewer moving parts will lead to a simpler, more stable environment.
- Get out of the IT integration business: Patterns enable app teams to focus on shipping code that drives revenue and higher-value business outcomes. Mastering the art of configuring an operating system or integrating an application server with an enterprise service bus, provides no sustainable differentiation for the business.
- Eliminate the fire drills: Patterns enable speed, consistency, and repeatability across dev, test, and production. Senior technologists spend less time being pulled off of their work to debug the differences between snowflakes, and can spend more time focused on delivering higher-value business outcomes.
This article is published as part of the IDG Contributor Network. Want to Join?