Get started

What Is Kuberik

Kuberik deploys the versions your CI publishes to Kubernetes: it picks up each new release, holds it until its gates allow it, deploys it through Flux and verifies it during bake time.

On this page
  1. What Kuberik does with a release
  2. Works with
  3. What stays with you
  4. FAQ
    1. What Kuberik needs from GitHub, and what happens when GitHub is down
  5. Related
One release from tag to record: detect, gate, deploy, verify, recordYour CI pushes a tag to a registry. Kuberik detects it with a ReleaseSource, checks it against the RolloutGates (the Rollout reports GatesPassing), and the Rollout hands it to Flux by setting a Kustomization substitute or an OCIRepository tag. HealthChecks report health while the Rollout bakes the deploy, Deploying then InProgress, and the Rollout records the result in its history as Succeeded or Failed. After a Failed bake automatic deploys stop until someone acts.Your CIDetectGateDeployRegistrya new tagReleaseSourcelists the tagRolloutGateallows versionsKustomizationor OCIRepositoryVerifyRecordHealthCheckreports healthRolloutstatus.historyFAILEDorSUCCEEDEDFailed: automatic deploys stopuntil someone acts. One release from tag to record: detect, gate, deploy, verify, recordYour CI pushes a tag to a registry. Kuberik detects it with a ReleaseSource, checks it against the RolloutGates (the Rollout reports GatesPassing), and the Rollout hands it to Flux by setting a Kustomization substitute or an OCIRepository tag. HealthChecks report health while the Rollout bakes the deploy, Deploying then InProgress, and the Rollout records the result in its history as Succeeded or Failed. After a Failed bake automatic deploys stop until someone acts.Your CIDetectGateDeployVerifyRecordRegistrya new tagReleaseSourcelists the tagRolloutGateallows versionsKustomizationor OCIRepositoryHealthCheckreports healthRolloutstatus.historySUCCEEDEDorFAILEDFailed: automatic deploys stopuntil someone acts.
One release, from a new tag in your registry to a record in the Rollout history.

What Kuberik does with a release

A release is a tagged artifact in a registry: the application image, or the rendered manifests for one environment pushed as an OCI artifact. From the moment the tag exists, Kuberik takes it through five stages; a person acts only where a gate asks for an approval. See Propagation Modes for how the two kinds of artifact compare.

Home in the dashboard: Attention, with a billing-edge change waiting for your approval in production and its Approve button, above Your changes, where the pull requests of checkout-api, platform-telemetry and recommender-svc each show the environment they have reachedHome in the dashboard: Attention, with a billing-edge change waiting for your approval in production and its Approve button, above Your changes, where the pull requests of checkout-api, platform-telemetry and recommender-svc each show the environment they have reached
StageWhat happensResources
DetectA ReleaseSource lists the new tag and adds it to its catalogue of releases.ReleaseSource
GateThe Rollout makes the release a candidate and checks it against every gate: deployment windows, approvals, service dependencies. Gates never hold a Rollout’s first deploy or a deploy you start by hand.Rollout, RolloutGate
DeployKuberik writes the tag into a Kustomization substitution, or moves the tag on an OCIRepository, and Flux applies it.Kustomization, OCIRepository
VerifyHealth checks must report healthy, then stay healthy for the bake time.HealthCheck
RecordThe deploy is recorded in the Rollout’s history as Succeeded or Failed, or Cancelled when a deploy you start by hand replaced it before it finished.Rollout

A failed bake stops automatic deploys of that Rollout. They resume when someone deploys a version by hand, pins one, unblocks the Rollout, or retries the bake and it succeeds.

Works with

Kuberik runs on Kubernetes 1.30 or later and deploys through Flux. Promotion between environments goes through GitHub, even on one cluster; the other systems are optional and each adds one thing.

SystemStatusWhat Kuberik does with it
Flux 2.6 or laterRequiredApplies each version through a Kustomization or an OCIRepository
Argo CDNot supportedKuberik reads and writes Flux objects only
GitHubRequired to promoteCarries each bake result from one environment to the next; the dashboard reads commits and pull requests through each person’s GitHub connection
GitLabNot supportedEnvironments record and read deploys through GitHub only (FAQ)
Datadog, PrometheusOptionalMonitors and alerts become HealthChecks
OpenKruiseOptionalCanary steps inside one deploy (Roll Out with a Canary)

Install Kuberik in every cluster that runs your apps: each cluster’s controllers deploy its own Rollouts and reach other clusters only through GitHub deployments (Sites and waves). One cluster’s dashboard is the hub for all of them, and deploys do not depend on it (Connect several clusters).

What stays with you

Your CI builds the artifact and decides when a release exists by pushing its tag. Flux stays your GitOps tool: it fetches sources and applies manifests, and Kuberik only changes which version Flux applies. Kuberik does not build images, run CI, or replace Flux.

FAQ

What Kuberik needs from GitHub, and what happens when GitHub is down

To promote across environments, Kuberik needs a GitHub token in each app namespace that can read and write deployments on the app’s repository. The environment-controller uses it only for the deployments API: it records each deploy as a GitHub deployment and reads the other tiers’ deployments to decide what each tier may deploy. GitHub is the only backend an Environment supports; GitLab is not one of them. The dashboard’s commit and pull request views use a separate, optional GitHub App, and the GitHub integration page sets up both.

When GitHub is unreachable, running workloads are unaffected: Flux and Kubernetes keep running what is deployed, and Rollouts, health checks and bake times never call GitHub. Each environment keeps deploying the releases its gates already allow, and the Environment gate of the first tier’s wave-1 leader allows every release unless lockstep holds it, so new builds still reach that leader. Promotion pauses: the controller can neither record new bakes nor read upstream ones, so the gates of later tiers and waves keep their last allowed versions. When GitHub is back, the controller records the deploys still in each Rollout’s history, and promotion resumes.

A ReleaseSource reads tags from your registry, not from GitHub. If that registry is ghcr.io and it is down as well, new releases arrive once it is back; a deploy whose artifact Flux cannot pull meanwhile waits in Deploying and fails when its deployTimeout runs out, if it has one.

Related