Bundles connect your deployments

Loopback Bundles connect GitHub, image builds, the Registry, and Kubernetes deployments. Manage sources, environments, and deployment history in one workflow.

6 min read
Bundles connect your deployments

A deployment starts in a repository and ends with an application running on a cluster. Between those points, source code, image builds, the Registry, deployment configuration, and the target environment need to work together.

Loopback Bundles connect these steps within the platform. A Bundle represents an application that you can deploy directly from GitHub to your Kubernetes cluster. Its sources, environments, and deployment history belong to the application. You control deploy, rollback, and undeploy within the same workflow.

An application as a Bundle

Running an application involves more than its source code. It needs an executable image, a description of its Kubernetes resources, and configuration for each environment.

Bundles bring these components together under one application. Your team creates a Bundle, connects the required sources, and sets up its environments.

Each component has a different role:

ComponentPurpose
SourcesProvide the sources for the application and charts
EnvironmentDefines the deployment context for an environment
Target WorkspaceThe Kubernetes cluster to which you deploy
RegistryStores built images
Deployment HistoryMakes previous deployments traceable

This structure creates a shared reference point. Anyone working on an application can find its sources, environments, and deployments in the associated Bundle.

Connect Bundles to GitHub

You start by connecting GitHub. You connect your GitHub account and make the required repositories available as sources for Bundles.

A Bundle supports multiple sources for applications and charts. This also accommodates a setup where application code and deployment packages are maintained separately.

For example, your team might manage its checkout-api code in one repository and the associated charts in another. Within the Bundle, both sources belong to the same application.

This is particularly useful when responsibilities differ: developers work on application code while a platform team maintains the deployment structure. The Bundle brings the sources together for a shared deployment process.

Environments for different stages

Applications often pass through several environments. Development is where you try changes, staging is where you test releases, and production is where the application serves its users.

In Loopback, you can create multiple environments per Bundle. For each environment, you define the target Workspace and associated settings. These include, for example, the branch, build triggers, and chart version selection.

One possible structure looks like this:

EnvironmentPurposeExample target
DevelopmentCheck changes during developmentDevelopment cluster
StagingTest a planned releaseStaging cluster
ProductionRun the application in productionProduction cluster

The environments belong to the same application but represent different deployment contexts.

It helps your team to define these contexts deliberately. Which changes should trigger a build? Which branch belongs to which environment? Which chart version should be used? The answers form the foundation of a traceable workflow.

From source code to image

Once sources and an environment are configured, the pipeline can process the application code and build the container image.

In Loopback, you can view pipeline runs and build logs. This lets you trace which source code was processed and how the build ran.

The built image is automatically stored in the organization-wide Loopback Registry. Your build output has a defined place within the stack and is available for the subsequent deployment.

Each step has a distinct purpose:

  1. Fetch source code: The pipeline works with the intended revision from the repository.
  2. Build the image: Application code becomes a container image.
  3. Store the image: The artifact is saved in the Loopback Registry.
  4. Run the deployment: The application is rolled out to the target cluster using its deployment configuration.

The Bundle connects these steps to the application and its environment.

Charts describe the deployment

The container image contains the executable application. Running it on Kubernetes also requires a description of its resources and their configuration.

Bundles integrate a Chart Builder and support sources for charts. Chart version selection is part of the environment settings.

This lets you consider the application and deployment configuration together. A new revision of application code can introduce different configuration requirements. Likewise, the deployment structure can evolve while the application code remains unchanged.

For release planning, the combination matters: which application revision will run with which chart version in which environment?

A clear mapping of these components helps your team review changes deliberately and trace deployments later.

Trace and control deployments

After the build comes deployment to the cluster. The Bundle remains the reference point for the application afterward.

Deployment History shows previous deployments. The associated controls let you deploy, roll back, and undeploy.

These actions serve different purposes:

ActionPurpose
DeployRoll out an intended revision
RollbackReturn to a previous deployment revision
UndeployRemove a deployment

For operations, the connection between history and action is particularly useful. Your team can review previous deployments and take the next step within the same application context.

A rollback should suit your application. If a release changes external data formats or interfaces, for example, those changes also belong in release planning. Deployment history provides the technical context for that decision.

A workflow for your team

Suppose your team develops an application with separate development and production environments.

First, you connect the GitHub sources for the application and charts. You then create a Bundle with the required environments and assign a target cluster to each.

For development, your team defines the intended branch and build triggers. Changes can be built and checked there. For production, you specify which application revision should be rolled out with which chart version.

The relationships remain visible throughout the process: sources provide code and charts, the pipeline produces the image, the Registry stores the artifact, and the environment defines the deployment context.

Deployment as part of your stack

With Bundles, the application becomes the shared reference point for sources, builds, and deployments.

GitHub provides the source code. Built images go into the Loopback Registry. Environments connect the application to its target clusters. Deployment History and controls support ongoing operations.

You can manage the path from repository to running application within the same platform.

Explore Bundles on Loopback

Your stack. One platform.

Start with managed Kubernetes, object storage, registry, or Bundles. One account, one permission model.