Bundles connect your deployments
Loopback Bundles connect GitHub, image builds, the Registry, and Kubernetes deployments. Manage sources, environments, and deployment history in one workflow.
Loopback Bundles connect GitHub, image builds, the Registry, and Kubernetes deployments. Manage sources, environments, and deployment history in one workflow.
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.
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:
| Component | Purpose |
|---|---|
| Sources | Provide the sources for the application and charts |
| Environment | Defines the deployment context for an environment |
| Target Workspace | The Kubernetes cluster to which you deploy |
| Registry | Stores built images |
| Deployment History | Makes 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.
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.
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:
| Environment | Purpose | Example target |
|---|---|---|
| Development | Check changes during development | Development cluster |
| Staging | Test a planned release | Staging cluster |
| Production | Run the application in production | Production 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.
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:
The Bundle connects these steps to the application and its environment.
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.
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:
| Action | Purpose |
|---|---|
| Deploy | Roll out an intended revision |
| Rollback | Return to a previous deployment revision |
| Undeploy | Remove 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.
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.
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.
Start with managed Kubernetes, object storage, registry, or Bundles. One account, one permission model.