Container Registry in your stack
Manage images and Helm charts across your organization with the Loopback Container Registry. Learn how repositories, robot accounts, and RBAC work together.
Manage images and Helm charts across your organization with the Loopback Container Registry. Learn how repositories, robot accounts, and RBAC work together.
A Container Registry stores the artifacts your applications need for deployment. Your CI pipeline publishes built images, Kubernetes pulls them for production, and development teams access the same artifacts for testing.
With the Loopback Registry, you manage container images and Helm charts across your organization. The Registry supports OCI and Docker workflows, public and private repositories, and robot accounts for automated access. You manage permissions through central Loopback RBAC.
During development, source code becomes runnable container images. Once a build finishes, its output needs a location from which it remains available for subsequent steps.
The Registry provides that location. Your pipeline pushes the image. For a deployment, the Kubernetes cluster pulls the image it needs.
The Registry connects two workflows: building an application and running it on the cluster. Both work with a published artifact.
Clear responsibilities help you organize this process:
| Component | Purpose |
|---|---|
| Source code repository | Contains application code and build configuration |
| CI pipeline | Builds the container image and pushes it to the Registry |
| Container Registry | Stores and distributes images |
| Kubernetes cluster | Pulls the required images and runs the containers |
The Registry becomes a shared reference point for everyone involved. Your pipeline knows where to send its output. The deployment specifies which image to use from which repository.
Alongside the application image, a Kubernetes deployment needs a description of the resources used to run the application. Helm charts can package these resources and adapt them to an environment through configurable values.
OCI registries can store and distribute these chart packages. Helm supports publishing with helm push and retrieving with helm pull, among other operations. Charts can also be installed directly from an OCI registry.
The Loopback Registry supports both container images and Helm charts. You can organize your runnable application and its deployment packages within the same Registry.
For a project, you might divide repositories as follows:
| Repository | Content |
|---|---|
apps/checkout-api | Container images for the application |
charts/checkout-api | Helm charts for deployment |
apps/document-worker | Images for a related background process |
Clear naming helps your team find artifacts and understand how they are used. Your structure should reflect the applications and responsibilities within your organization.
In Loopback, the Registry belongs to your organization. You can use it across individual projects. Different clusters and teams can access the images and charts published there.
This is useful, for example, for an application with development, staging, and production environments. Your pipeline can publish an image that is then used across these environments.
A release workflow could look like this:
You can establish this approach as a team convention. It creates a traceable connection between the tested build and the later deployment.
The shared Registry makes these artifacts available across your organization. Each deployment workflow determines which version runs in which environment.
People and automated processes both use a Registry. A CI pipeline needs access to push artifacts. A cluster needs access to pull private images.
The Loopback Registry provides robot accounts and credentials with different permissions. Supported permissions cover pull, push, push and pull together, and a combination that also includes deletion.
When planning access, separate it by task:
| Process | Required task |
|---|---|
| Build pipeline | Publish built artifacts |
| Cluster | Retrieve published images |
| Management process | Delete artifacts according to defined rules |
This distinction makes credential requirements concrete. A process that only retrieves images receives the permissions intended for that task. A process that publishes artifacts needs different permissions.
Robot accounts represent these automated access paths. Management remains within your organization and follows the platform's central permissions model.
You set visibility per repository. This applies to images and Helm charts.
Private repositories suit internal applications and deployment packages that only authorized users and processes should retrieve. Public repositories suit artifacts you want to make publicly available.
For your team, this decision forms part of organizing the Registry. When creating a repository, you should already know who will use its content and which processes may publish there.
A shared Registry can accommodate different requirements within the same organization. Repository visibility and management permissions remain concrete decisions for each type of content.
The Loopback Registry is OCI and Docker compatible. You push and pull with familiar clients, allowing you to integrate the Registry into existing build and deployment workflows.
Technically, this integration consists of several related settings: the Registry destination, repository path, and appropriate credentials. Your pipeline uses these details to publish artifacts. For private images, your cluster also needs the corresponding access.
When introducing the Registry, run through the complete process: build an image, push it to the intended repository, and use it in the target cluster. This checks the entire path from build to running container.
The Registry adds a central location for images and Helm charts to your Kubernetes operations. Pipelines publish their output there. Clusters retrieve artifacts for deployment. Teams organize repositories and access within their organization.
The Loopback Registry is operated in Germany and uses the same central RBAC as the rest of the platform. Artifacts, clusters, and permissions remain within a shared management context.
Start with managed Kubernetes, object storage, registry, or Bundles. One account, one permission model.