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.
Sign up for MIS Asia eNewsletters.