In our previous article from this series we introduced a use case for a cloud factory, deploying multiple private clouds based on one code base using the principles of Infrastructure as Code.
The process was laid out how we’ve approached the use case and how portfolio solutions are the base for researching a generic architecture.
The only thing left to cover was the order in which you’ll be led through the details.
This article starts the real journey at the very top, with a generic architecture from which we’ll discuss the common architectural elements one by one.
Architecture review
As mentioned before, the architectural details covered here are base on real solutions using open source technologies. The example scenario presented here is a generic common architecture that was uncovered while researching those solutions. It’s our intent to provide guidance and not deep technical details.
This section covers the visual representations as presented, but it’s expected that they’ll be evolving based on future research. There are many ways to represent each element in this architecture, but we’ve chosen a format that we hope makes it easy to absorb. Feel free to post comments at the bottom of this post, or contact us directly with your feedback.
From specific to generic
Before diving into the common elements, it might be nice to understand that this is not a catch-all for every possible solution. It’s a collection of identified elements that we’ve uncovered in multiple customer implementations. These elements presented here are then the generic common architectural elements that we’ve identified and collected into the generic architecture.
It’s our intent to provide an example for guidance and not deep technical details. You’re smart enough to figure out wiring integration points in your own architectures. You’re capable of slotting in the technologies and components you’ve committed to in the past where applicable. It’s our job here to describe the generic components and outline a few specific cases with visual diagrams so that you’re able to make the right decisions from the start of your own projects.
Another challenge has been how to visually represent the architecture. There are many ways to represent each element, but we’ve chosen some icons, text and colours that we hope are going to make it all easy to absorb.
Now let’s take a quick tour of the generic architecture and outline the common elements uncovered in my research.
Jump host
Starting on the left of the logical diagram you’ll notice two elements standing on their own, labeled as the
jump and bootstrap host together with the backup server.
Deployment head
This collection of elements is the initial deployment and is the base of your cloud factory. You find all the software you need setup in a definitive software library that pulls the latest versions from both internal and external sources.
A source code management element is for the infrastructure code. A CI / CD pipeline is part of the delivery elements ensuring code quality and automated delivery. A chat tool for communication, identity management for authentication and authorisation, and automation and orchestration to ensure repeatable processes when delivering infrastructure.
Finally, there’s imaging and helper VMs from the virtualisation layer that this entire deployment runs on to ensure everything is running smoothly.
Detached deployment head
Once your deployment head has been created, it’s then used to start generating your cloud factory products. These are the deployments you run in your private cloud like infrastructure and eventually your cloud environments.
The detached deployment head is created out of the initial deployment head. It contains elements needed to service this infrastructure, such as software proxy, compute deployment, and local monitoring to cover this specific deployment in your cloud factory.
Cloud environment
The first element are the storage nodes along with the storage controllers. These are used by the compute nodes and their compute controllers.
Finally there is some PaaS or platform as a service rolled out to ensure applications and services can be managed through the deployment mechanisms mentioned above.
What’s next
This was just a short overview of the common generic elements that make up our architecture for the cloud factory use case.
An overview of this series on cloud factory portfolio architecture:
- An architectural introduction
- Common architectural elements
- Example factory architecture
Catch up on any past articles you missed by following any published links above.
Next in this series, we’ll be taking a look at an example factory deployment architecture.
(Article co-authored by Eric Lavarde, Consulting Principal Architect, Red Hat)
Published on Java Code Geeks with permission by Eric Schabell, partner at our JCG program. See the original article here: Cloud factory – Common architectural elements Opinions expressed by Java Code Geeks contributors are their own. |
