CALM Concepts

In this guide we will explain the concepts used by Containerised Application Lifecycle Management feature.

Manage Your Devices with Fleets

A fleet is a powerful way to group your edge devices for streamlined management. It’s most effective when grouping similar devices that:

• Run the same applications: Deploy updates and manage applications efficiently across a group of devices.

• Share common functionalities: Target specific groups for actions and monitoring.

The Fleets page provides an overview of all your created fleets. You can see:

• Fleet List: All your defined fleets.

• Fleet Details: For each fleet, you’ll find the number of devices, individual device statuses, and the overall fleet status.

Compositions

Composition (from Docker Compose) or Containerized Application: This refers to an application that is packaged within a Docker container. It can be deployed using a Dockerfile, which includes instructions on connecting external components to the container’s hardware controls. In the context of CALM, this specifically refers to an application that operates on an edge device.

A composition is an object that contains information about your application and helps you keep all its versions in one place.

Compositions page lists all created compositions, its latest version and allows to see details of each composition by going to Details page.

Composition Versioning

Each composition has a version. You start by creating first version of your composition and continue updating it, as needed. Orchestra requires semantic versioning for your compositions.

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.

This systematic approach helps you track changes and ensure compatibility.

Connect to Your Private Registries

The Registries page allows you to grant Orchestra access to your private container registries.

Public vs. Private Registries:

• Public Registries: If your Docker Compose files reference public registries (like Docker Hub), no action is needed. Orchestra can access them automatically.

• Private Registries: To use images hosted in private registries, you need to provide Orchestra with the necessary credentials. This allows Orchestra to securely pull and deploy images from your private repositories.

Adding a Private Registry:

1. Click “Connect Registry”: Locate and click the “Connect Registry” button in the top right corner of the Registries page.

2. Provide Registry Details: A form will appear prompting you to enter the following information: * Registry Name: Choose a clear, descriptive name for this registry, making it easily identifiable within Orchestra. * Registry URL: Enter the full web address (URL) of your private registry. * Authentication Type: Select “Password-based” from the available options. * Login: Provide your username for authenticating with the registry. * Password: Enter your password for accessing the registry. * Description (optional): Add a brief description (this can be helpful for managing multiple registries).

3. Save: Review the provided information and click “Save” to store the registry connection details.

By configuring your private registries here, you ensure smooth and secure deployments of your applications from any source.

Variables

Variables allow you to customize Docker Compose environment variables based on your specific needs. They function by keys, meaning variables with the same key will override each other depending on their context.

Variables can exist in different contexts:

• Device: Specific to an individual device.

• Fleet: Applied to a group of devices.

• Composition: Related to a particular application composition.

• Global: Applies universally across all devices and compositions.

Variables follow an inheritance hierarchy. The order of inheritance is:

Global > Composition > Fleet > Device.

This means that more specific contexts (like a device) can override variables from broader contexts (like global), if the same key is used.

Variables can be masked to prevent them from being inherited. When a variable is masked, it blocks inheritance to lower-level contexts, allowing more control over which variables are applied.

Global Variables pages lists all variables on the highest inheritance level.

Variable Snapshotting

When you create a release, Orchestra takes a snapshot of all the variables assigned to devices in the target fleet.

Orchestra finds out all of the variables inherited for each device in the fleet and releases this composition with those variables.

What this means: Imagine customizing settings for individual devices in your fleet. When you release a composition, those unique device settings (variables) are captured and become part of the release deployed to those devices.

Warning

If you later change variables, those changes won’t automatically apply to devices already running the released composition. To update the variables that composition is using on devices its running on you need to restart a release.

Release

To deploy your application to a fleet of devices, you create a Release. A release is tied to a specific version of your composition. This lets you roll back to a previous version if needed.

Restarting a Release

To apply configuration updates or troubleshoot issues, you can restart a release. This will:

1. Refresh Variables: Fetch the latest variable values inherited by devices.

2. Redeploy the Release: Redeploy the composition version associated with the release, incorporating the updated variables.

Use Cases:

• Troubleshooting: If your application encounters problems, restarting it can often resolve the issue.

• Configuration Changes: After updating variables or making other configuration changes, restarting the application ensures that all devices receive the latest settings.