Technical Insight How-to Guide

Helm OCI Registries: You Moved Your Charts. Did You Secure Your Supply Chain?

OCI registries simplify Helm chart distribution, but not artifact trust. Explore digests, immutability, provenance, CI/CD security and GitOps verification.

Helm OCI Registries and Supply Chain Security
On this page

Your Helm charts are now stored in an OCI registry. No more index.yaml. No separate chart repository. Your CI pipeline packages the chart, pushes it to the registry, and your GitOps controller deploys it.

Cleaner architecture. Fewer moving parts. But who can overwrite the chart tag?

Can you prove that the artifact deployed to production is the one your pipeline tested? And if somebody compromises the credentials used to publish charts, what prevents them from replacing your next production deployment? Moving Helm charts into OCI registries solves distribution.

It doesn’t automatically solve software supply-chain security.

OCI changes distribution, not trust

Traditional Helm repositories distribute packaged charts through an HTTP server and an index.yaml file. OCI registries use the same artifact-distribution model already familiar from container images.

Since Helm 3.8, OCI support has been generally available. Charts can be stored in registries such as GHCR, Harbor, Amazon ECR, Azure Container Registry and Google Artifact Registry. The workflow becomes straightforward:

helm package ./charts/myapp
helm push myapp-1.0.0.tgz oci://ghcr.io/example-org/charts

Helm publishes the packaged chart as an OCI artifact. The chart name becomes the final repository path component, and the chart version becomes its tag:

ghcr.io/example-org/charts/myapp:1.0.0

OCI provides content-addressed storage. Each manifest has a digest derived from its content. That matters because a digest identifies a specific artifact, independently of the tag pointing to it.

But content addressing answers only one question: Are these the bytes identified by this digest?

It doesn’t answer who produced them, whether the publisher was authorized, or whether those bytes should be trusted. Integrity is not provenance. And provenance is not authorization.

Build once, publish once

Consider a small application chart:

charts/myapp/
├── Chart.yaml
├── values.yaml
└── templates/
    ├── deployment.yaml
    └── service.yaml

Its metadata defines the chart version:

apiVersion: v2
name: myapp
description: Example Kubernetes application
type: application
version: 1.0.0
appVersion: "2.4.1"

The distinction between version and appVersion matters. version identifies the Helm chart package. appVersion describes the application version and doesn’t automatically control the container image used by the Deployment.

Package and validate the chart:

helm lint ./charts/myapp --strict
helm template test-release ./charts/myapp > rendered.yaml
helm package ./charts/myapp

Then authenticate to GHCR:

printf '%s' "$GHCR_TOKEN" | \
  helm registry login ghcr.io \
    --username "$GHCR_USER" \
    --password-stdin

Publish:

helm push myapp-1.0.0.tgz oci://ghcr.io/example-org/charts

The publishing identity needs permission to write the target package. Repository and package permissions must be configured accordingly. The important architectural decision is not the helm push command. It is where packaging occurs.

If development, staging and production independently package the same source directory, you have three build operations. Even when the source revision is identical, you have introduced opportunities for differences in dependencies, tooling and packaged content.

Instead, package once in a controlled pipeline. Validate the artifact. Publish it. Promote that same artifact through environments.

Promotion should change deployment approval, not rebuild the thing being approved.

Tags are references, not guarantees

A chart version such as 1.0.0 looks immutable. It isn’t necessarily. OCI tags are registry-managed references. Whether a tag can be overwritten depends on registry configuration and authorization.

Imagine this sequence:

  1. CI publishes myapp:1.0.0, pointing to digest A.
  2. Staging tests the chart successfully.
  3. Another publisher overwrites the same tag with digest B.
  4. Production resolves myapp:1.0.0 and receives digest B.

The version string hasn’t changed. The artifact has.

Mutable chart tags versus content-addressed digests

For production, configure tag immutability where supported, restrict publishing permissions, and record the artifact digest produced by the pipeline.

There is another subtlety: a Helm chart digest and a container image digest identify different artifacts. A chart can be immutable while referencing a mutable container image tag. Protecting one does not protect the other. Also, not every Helm deployment interface supports OCI chart digests as direct references. Where the consumer requires chart versions, enforce registry-side immutability and verify the resolved artifact through a supported mechanism.

Don’t assume digest pinning works simply because OCI supports digests.

A digest doesn’t tell you who built the chart

Suppose an attacker obtains credentials with permission to publish to your registry. They upload a malicious chart and receive a perfectly valid SHA256 digest. The registry has done its job. The artifact is content-addressed. It is also malicious. This is where provenance becomes relevant.

Helm supports traditional chart provenance using GPG signatures and .prov files. OCI ecosystems also support artifact-signing mechanisms such as Sigstore Cosign. These are related but distinct workflows.

A Helm provenance file can associate a chart package with a signing key and verify package integrity. An OCI signature can associate an artifact digest with a signing identity or key, depending on the signing configuration. Neither automatically establishes that a publisher should be trusted. That decision requires a policy.

For example, a production policy might require that a chart:

  • Originates from an approved source repository.
  • Was published by an authorized CI identity.
  • Passed required validation.
  • Has an acceptable signature or attestation.
  • Matches an artifact approved for production.

The verification mechanism must also be integrated into the deployment workflow. Signing artifacts without verifying them before deployment is mostly ceremony.

CI is part of the trust boundary

Your CI pipeline is now responsible for producing deployable infrastructure artifacts. That makes its security model relevant to every Kubernetes cluster consuming those charts.

A minimal GitHub Actions publishing workflow might look like this:

name: Publish Helm Chart

on:
  push:
    tags:
      - "chart-v*"

permissions:
  contents: read
  packages: write

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@<pinned-commit-sha>
      - uses: azure/setup-helm@<pinned-commit-sha>
        with:
          version: v3.17.0
      - name: Validate
        run: |
          helm lint ./charts/myapp --strict
          helm template test ./charts/myapp > rendered.yaml
      - name: Package
        run: helm package ./charts/myapp
      - name: Authenticate
        env:
          GHCR_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          printf '%s' "$GHCR_TOKEN" | \
            helm registry login ghcr.io \
              --username "${{ github.actor }}" \
              --password-stdin
      - name: Publish
        run: |
          helm push myapp-1.0.0.tgz \
            oci://ghcr.io/example-org/charts

Replace the placeholder commit SHAs with verified full commit identifiers and configure the package destination and permissions for your organization. The chart version and release tag must also be checked for consistency. Otherwise, a tag-triggered workflow can publish an unintended chart version.

This is a simplified publishing example, not a complete supply-chain security pipeline. For production, add Kubernetes schema validation, artifact verification, controlled release authorization and an auditable record of the published digest.

And remember: pinning third-party GitHub Actions reduces exposure to unexpected upstream changes, but it doesn’t eliminate the need to assess the code and permissions of those actions. The pipeline itself is software. Treat it accordingly.

GitOps doesn’t automatically verify artifact trust

GitOps controllers are excellent at reconciling desired state. But reconciliation and artifact verification are different responsibilities. A controller can reliably deploy a chart from an OCI registry without proving that the artifact was built by an approved pipeline.

The architecture should make that distinction explicit.

Helm OCI artifact supply chain and verification boundaries

Flux supports OCI artifacts through its source-controller and OCIRepository resources. Argo CD also supports Helm charts stored in OCI registries. Their configuration and verification capabilities differ.

Do not assume that an artifact signature will automatically be checked because a controller can authenticate to the registry. Define how verification happens, which identities are trusted, and what should happen when verification fails.

For example, a failed verification should prevent promotion or deployment rather than merely generate a warning in an unrelated CI job. A secure publishing pipeline is useful. An enforced deployment trust policy is better.

Registry availability is now a deployment dependency

Centralizing charts in an OCI registry simplifies distribution. It also creates a dependency that needs operational attention.

What happens when the registry is unavailable during a deployment?

What happens when a GitOps controller loses access because credentials expire?

What happens when a retention policy deletes the chart version required for rollback?

These are not theoretical edge cases. They follow directly from making the registry part of your deployment path. A production design should address artifact retention, credential rotation, registry availability, recovery procedures and the relationship between deployed releases and stored chart versions.

Deleting old charts to save storage is particularly questionable if those artifacts are still required for recovery or reproducible deployment.

A rollback strategy that depends on artifacts you’ve already deleted isn’t much of a rollback strategy. For environments with strict isolation requirements, consider controlled replication into an internal registry. That can reduce external availability dependencies, provided replication also preserves the intended artifact identity and trust metadata.

Distribution is the easy part

OCI registries are a sensible way to distribute Helm charts. They consolidate artifact storage, reuse existing registry infrastructure and integrate naturally with modern CI/CD systems.

But the registry is only one component of the deployment supply chain. A trustworthy workflow needs controlled publishing, stable artifact identities, meaningful provenance, explicit verification and an operationally sound promotion process.

None of those properties appears automatically when you replace an HTTP chart repository with oci://.

You moved your charts into a container registry. Good.

Now make sure you can prove what you’re deploying, who produced it, and why your platform should trust it. That’s the difference between artifact distribution and software supply-chain engineering.

Related Articles

Stay ahead

Get the latest insights.

Insights on cloud, AI and open source — delivered to your inbox.

Email subscriptions are coming soon.