Containerized Application Lifecycle Management¶
Deploying containerized applications to many edge devices, keeping them up to date and monitoring their health is a lot of work. Each device needs the right version of the application, with the right configuration, and you need to know where a deployment succeeded and where it failed.
Containerized Application Lifecycle Management (CALM) takes care of this in Orchestra Manager. You describe an application once with a Docker Compose file, group the devices that should run it into a fleet, and release a chosen version of the application to the whole fleet at once. Orchestra deploys it to every device and shows the status of the deployment for the fleet and for each device.
CALM concepts¶
CALM is built around a few concepts:
Fleet: a group of devices that run the same applications.
Composition: a containerized application, described by a Docker Compose file. A composition keeps all versions of the application in one place.
Release: a deployment of one version of a composition to all devices in a fleet.
Variable: a value that customizes a composition for all devices, a fleet or a single device, without changing the Docker Compose file.
Registry: a place devices pull container images from, such as Docker Hub or a private company registry.
A typical lifecycle of an application starts with a composition and its first version. You add the composition to a fleet, set the variables it needs and create a release. When a new version of the application is ready, you add it to the composition and release it to the fleet again.
Fleets¶
A fleet is a way to group your edge devices for streamlined management. It works best for similar devices that run the same applications: one release deploys an application to all of them at once.
The Fleets page lists all fleets of the tenant. For each fleet you can see its name, ID, the number of devices broken down by their status, and the overall status of the fleet. A fleet needs a name and at least one device; a description is optional.
The details of a fleet are split into four tabs:
Overview: the fleet’s information and status, a table of its compositions with their current released version and status, and a table of its devices with their connection and status. The connection status can be delayed by up to 4 minutes.
Compositions: the compositions added to the fleet, their releases and the status of each deployment.
Variables: the variables of the fleet, see Variables.
Releases: the history of releases to the fleet.
Important
Fleet membership controls what runs on a device. A device added to a fleet immediately gets all compositions of the fleet, and a device removed from a fleet immediately loses them.
Compositions¶
A composition is a containerized application that runs on edge devices. It is
described by a Docker Compose file (docker-compose.yml), which defines the
application’s containers and the images they use.
A composition is an object that keeps all versions of your application in one place. The Compositions page lists all compositions of the tenant, with their name, ID and latest version.
Composition versioning¶
Each version of a composition has its own Docker Compose file and an optional description of what changed. You start with the first version of the composition and add new versions as the application changes. The details of a composition show its information and the Docker Compose file of the selected version.
Orchestra requires semantic versioning for your compositions, and each version number can be used only once in a composition.
Note
Semantic versioning means versions are numbered like this: Major.Minor.Patch (e.g., 1.2.3)
Major: Increment for significant changes that might not be backward-compatible with previous versions.
Minor: Increment for new features or improvements that are backward-compatible.
Patch: Increment for bug fixes or small updates that don’t change functionality.
Releases¶
To deploy your application to a fleet of devices, you create a release. A release is tied to a specific version of a composition that was added to the fleet. Orchestra deploys that version to all devices in the fleet.
The deployment of a composition in a fleet has one of these statuses: Planned, In progress, Ok, Degraded, Failed or Unknown. The fleet’s Compositions tab shows the status for the whole fleet and for each device. While a release is in progress, no other release can start for that composition.
The Releases tab of a fleet keeps the history of releases: the released version, its status, who released it and when. This gives you a record of what was deployed to the fleet, for reference and auditing.
Managing compositions in a fleet¶
Besides releasing new versions, you can manage a composition that runs in a fleet:
Restart: restarts all containers of the composition on all devices in the fleet. This can help when the application runs into problems.
Detach: removes the composition from the fleet, together with all its containers on the fleet’s devices. The composition itself is kept, and you can add it to the fleet again later.
Compositions on a device¶
The Compositions tab of a device shows the containers deployed to that device through its fleets, with access to their logs. A device that doesn’t belong to any fleet with a released composition has no compositions.
Variables¶
Variables let you customize your compositions, for example a server address or a port, without changing the Docker Compose file. Each variable has a key and a value. The value can be text or a file.
Variables exist on three levels, marked with a badge:
GLOBAL: applies to all fleets and devices. Global variables are listed on the Global variables page.
FLEET: applies to the devices of one fleet.
DEVICE: applies to a single device.
Variables follow an inheritance hierarchy: Global > Fleet > Device. A variable is inherited by the levels below it, and a variable with the same key on a more specific level overrides the inherited one. The variables table shows both the current value and the overridden value. An inherited variable can only be edited on the level it comes from.
Variables can be masked. A masked variable isn’t used on that level and isn’t inherited down, which gives you control over which variables apply to a fleet or a device. You can unmask it again at any time.
Important
Make sure you have set all the variables a composition needs before you create a release.
Registries¶
Compositions use container images, which devices pull from container registries. Images from public registries, such as Docker Hub, need no setup. To use images from a private registry, save its address and login details on the Registries page. Orchestra uses them to pull the images of your compositions.
Deleting a registry revokes Orchestra’s access to it. Compositions that use the registry and are already deployed keep working, but you can’t update them.