Versioning container content: The ‘single source of truth’

Have you thought about what your future looks like when you’re managing hundreds of containers and microservices that make up a single version of your software solution?  Let’s just say, you’re going to need more than an Excel spreadsheet.

Containers and microservices are game-changers in terms of how we develop and deliver software.  In the past, we have relied on a monolithic approach, with everything moving at the same time in an orchestrated dance that was never guaranteed to work just right.  With microservices, we are deconstructing that dance into individual steps, allowing for its unique parts to be independently deployed.

While solving many problems, this approach also creates its own set of issues.  The primary problem is how to visualize what those individual services create over time in terms of the whole base application and subsequent application versions.

What is a microservice?
Let’s start from the top.  What is a microservice and how do we decompose a monolithic application into Services?  I like how Chris Richardson of CloudFoundry fame defines a Service:

  • A service should implement a small set of strongly related functions;
  • Services that change together should be packaged together;
  • The Service can be changed without affecting clients;
  • And, each team that owns one or more services must be autonomous. A team must be able to develop and deploy their services with minimal collaboration with other teams.

With microservices, we let go of the concept of a monolithic software application or linear pipeline.  We instead have a non-linear configuration of different points of Services that represents the application. It’s still there, but just represented by many parts.

For managing deployment configurations, we need to understand what is in the ‘Microservice Soup’ in terms of usage and configurations in order to see the whole picture, or what we can call the ‘monolithic equivalent.’

Versioning your container content
For these and other reasons, there’s a conversation happening about tracking and versioning your ‘configuration as code.’  Most of the focus is on using version control to manage the scripts defining a Kubernetes Pod or Cluster.

Another discussion is needed about how to version the content of the containers, tracking history, and updates over time.  Knowing where a service is, who is calling it, as well as the version and relationships is critical. In other words, we need a ‘single source of truth.’

DeployHub: A single source of truth
DeployHub is a hosted Continuous Deployment solution that evolves deployments from an ‘endpoint release’ practice to an intelligent repository of deployment data. DeployHub was designed to be the ‘single source of truth’ for deployment configurations, particularly around the Kubernetes architecture.

DeployHub performs version control of the microservices running in your containers and continuously deploys updates.  DeployHub’s versioning reports on what microservice is in a container, who is using it, and the microservice’s relationship to the larger applications.

DeployHub versions and deploys database updates, environment variables, Kubernetes configurations, infrastructure components, application artifacts, and other critical parts of your software release.  By versioning these individual parts, DeployHub can iteratively update, roll back, roll forward or jump versions to any state. It was designed with microservices in mind but can also support agile teams working in legacy architectures with safe, iterative releases.

When we created DeployHub, we knew we needed to address the new microservices architecture.  What we saw as critical for Kubernetes deployments was the ability to:

  • group ‘like’ Services together as a package.
  • support Domain Driven Design (DDD) with sub-domains allowing Services to be organized based on a ‘business’ or ‘problem’ space.
  • encourage re-use and collaboration of Services.
  • perform continuous deployments without agents for frictionless implementation.
  • track a Service version to an application version, providing a single source of truth.

Collaborating for success
As developers, we know from our experience around object-oriented programming that sharing and collaborating around the use of services will become critical for their success.  We know we’re failing when each team begins to ‘copy’ and ‘rename’ their own versions of services. This would be bad.

DeployHub provides a collaboration framework so that your service can be published and shared across teams. This allows them to choose a service from a component list.  Providing a central repository of the available components also reduces the temptation of taking an older version of a service and making it ‘our own.’

Content provided by SD Times and DeployHub.

The post Versioning container content: The ‘single source of truth’ appeared first on SD Times.

from SD Times http://bit.ly/2TkMNSy

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Create your website at WordPress.com
Get started
%d bloggers like this:
search previous next tag category expand menu location phone mail time cart zoom edit close