A release in Ctrlplane represents a specific version or iteration of your
software or infrastructure configuration that is ready to be deployed. It is a
crucial component of the deployment process, serving as a snapshot of your
application or system at a particular point in time.
Remember, the actual building and packaging of your software should be handled
by your existing CI pipelines or build systems. Ctrlplane takes over from the
point where your software is built and ready for distribution, solving the
complex problem of managing deployments across a large and potentially diverse
set of resources.
Version Representation: Each release typically corresponds to a specific
version of your codebase or infrastructure definition.
Deployment Association: Releases are created as part of a deployment in
Ctrlplane. They represent the content that will be deployed across various
environments and resources.
External Build Process: Ctrlplane does not manage the build process for
releases. The actual compilation, packaging, or preparation of your software
should be handled by your existing CI/CD pipelines or build systems.
Creation Methods: Releases can be created in two primary ways:
Through the Ctrlplane UI
Via the Ctrlplane API
Using a Ctrlplane integration
Metadata: A release often includes metadata such as version numbers,
commit hashes, build timestamps, or other relevant information to identify
and track the release.
Immutability: Once created, a release is typically considered immutable.
This ensures consistency across different environments and enables reliable
rollbacks if needed.
Since Ctrlplane is meant for solving the way releases are deployed across
resources, it’s very common to have version dependencies on other deployments.
In the world of software, this could mean a microservice depends on a specific
version of another microservice to ensure it has the required APIs.In the case of software and infrastructure interactions, this could require a
minimum version of a database that is necessary to deploy the software, or a set
list of Kubernetes versions that the software supports.To address these needs, Ctrlplane supports release dependencies. When defining a
release, you can also specify which versions it depends on from other
deployments. This feature allows you to:
Ensure Compatibility: Guarantee that your release is only deployed to
environments where its dependencies are met.
Manage Complex Systems: Easily handle intricate relationships between
different components of your system.
Prevent Deployment Issues: Avoid potential problems caused by
incompatible versions of interdependent services or infrastructure.
Facilitate Upgrades: Clearly define the upgrade path for your entire
system by specifying version requirements.
When creating a release, you can define expresions to determine what version of
other deployments is required.
Managing Dependencies with Resource Metadata Grouping
In most cases, a resource has multiple deployments associated with it, making it
easy to verify if a specific version is deployed on that resource as required by
another deployment. However, complexities arise when dependencies involve other
resources, where the deployment version might be present on any of these
dependent resources.To address this, Ctrlplane uses resource metadata grouping. This mechanism
allows you to logically group resources based on their metadata attributes. By
doing so, Ctrlplane can accurately determine which resources to inspect to
verify if the software has been deployed.The idea is to create logical associations between resources that share common
characteristics, such as being part of the same kubernetes cluster. This is
particularly useful in complex infrastructures or distributed systems where
deployments span multiple infrastructure components.For example:
Single Cluster Deployment: If you have a single Kubernetes namespace
represented by a resource, you can easily check if a version is deployed on
that cluster without additional grouping if that resource is used by all the
deployments.
Multiple Clusters Deployment: If you have multiple Kubernetes namespaces,
you might need to group resources by cluster name. This way, Ctrlplane can
check all namespaces within the specified cluster to determine if the
required version is deployed.
By defining metadata groups and associating deployments with these groups, you
ensure that version checks are performed within the relevant scope, maintaining
consistency and compatibility across your system.When defining release dependencies, carefully consider how your resources are
grouped and which metadata attributes are most relevant for determining version
compatibility across your system.