Skip to main content
Cloud DevOps Solutions
Get a quote Talk to an engineer

CI/CD and GitOps

Flux Consulting: Lean, Composable GitOps for Kubernetes Platforms

Flux is a GitOps toolkit for Kubernetes made of small controllers that pull configuration from git, OCI or Helm repositories and reconcile it into clusters. We bootstrap and structure Flux, set up Kustomize and Helm releases, secrets, multi-tenancy and notifications, and run upgrades so clusters stay in line with git.

Key takeaways

  • Flux is built as a set of focused controllers using native Kubernetes custom resources, which suits platform teams who like composable, CLI and manifest-driven tooling.
  • Bootstrap makes Flux manage itself from git, so rebuilding a cluster returns it to the declared state.
  • Kustomization and HelmRelease resources are the core building blocks, with dependency ordering via dependsOn.
  • Multi-tenancy is achieved with service account impersonation and namespaced resources, not by trust.
  • Flux has no built-in dashboard in the way ArgoCD does, so visibility is delivered through notifications, metrics and optional UIs.

What teams use Flux for

Cluster bootstrap and fleet management

New clusters join a fleet by pointing Flux at a repository path, then pull their add-ons and applications themselves.

Helm release management through git

HelmRelease resources declare chart, version and values, with drift detection and automated remediation on failed upgrades.

Platform add-on lifecycle

Ingress, certificates, observability and policy engines are installed in dependency order and upgraded by pull request.

Multi-tenant platforms

Each team gets its own namespace, repository and restricted service account, and Flux reconciles with that identity.

Automated image updates

Image automation controllers scan registries and commit new tags back to git, closing the loop from build to deploy.

What Flux is and how it is built

Flux is a GitOps toolkit for Kubernetes. Rather than one large application, it is a group of single-purpose controllers. The source controller fetches artefacts from git, OCI registries or Helm repositories. The kustomize controller renders and applies Kustomize overlays. The helm controller manages Helm releases. The notification controller sends alerts and receives webhooks, and optional image controllers watch registries and update tags in git. Everything is expressed as Kubernetes custom resources, so a Flux setup reads like the rest of your cluster configuration.

Teams choose it when they want GitOps that feels like native Kubernetes, with small parts they can reason about and no extra control plane or UI to host. Our Flux GitOps consulting work is mostly platform engineering: structuring the fleet repository, ordering add-ons, bounding tenants and keeping upgrades uneventful. See the Flux glossary entry for a short definition.

How we run Flux in production

Bootstrap and self-management

Bootstrap installs the controllers and commits their manifests, plus a sync definition, into your repository. From then on Flux reconciles its own configuration. If a cluster is lost, you create a new one, run bootstrap against the same path, and it converges to the declared state. This is the foundation of everything else, and we cover installation trade-offs in ArgoCD and Flux installation.

A layered fleet repository

We usually split the repository into layers: cluster definitions, shared infrastructure and applications. Infrastructure is reconciled before applications through dependsOn, so a database operator or ingress controller exists before workloads that need it.

apiVersion: kustomize.toolkit.fluxcd.io/v1
kind: Kustomization
metadata:
  name: apps
  namespace: flux-system
spec:
  interval: 10m
  dependsOn:
    - name: infrastructure
  sourceRef:
    kind: GitRepository
    name: flux-system
  path: ./apps/production
  prune: true
  wait: true
  timeout: 5m

prune: true removes resources deleted from git, which is powerful and deserves care in production. wait: true makes Flux check the health of what it applied, so a failing rollout shows as a failed reconciliation. Layout guidance is in GitOps repository structure design and promotion with Kustomize.

Helm with HelmRelease

A HelmRelease declares chart, version and values, and the helm controller installs and upgrades it, with options for retries and remediation when an upgrade fails. Charts can come from Helm repositories or OCI registries. For building your own charts, see Helm chart development.

Sources beyond git

Flux can reconcile from OCI artefacts as well as git. Publishing configuration as a versioned artefact from CI means clusters pull an immutable, signed bundle instead of tracking a branch, which suits environments where promotion should be an explicit act. It also reduces load on git hosting when you run many clusters. We choose between a git branch, a tag or an OCI artefact per environment, usually tracking a branch in development and pinned versions in production.

Security and access

  • Impersonation for tenants. A Kustomization or HelmRelease can specify a service account to reconcile as. Combined with Kubernetes RBAC, a team can deploy only into its namespaces. Details in GitOps RBAC and access control.
  • Secrets. Encrypt with SOPS and let Flux decrypt using a key held in the cluster, or use the External Secrets Operator. Protect and back up the decryption key. See Sealed Secrets and External Secrets Operator.
  • Source verification. Flux can verify signed commits or signed OCI artefacts, which helps when git hosting is shared.
  • Least-privilege git access. Use deploy keys or app tokens that can read only the needed repositories.
  • Cross-namespace controls. Restrict which namespaces can reference sources and which can be targeted.

Cost and capacity

Flux controllers are lightweight, and the cost is largely the compute they use inside each cluster. Because each cluster runs its own Flux, there is no central instance to size, but you also have no single place to see everything. Reconciliation intervals are the main tuning knob: very short intervals on large repositories add load on git hosting and the source controller. We use webhooks to trigger reconciliation on push, and keep intervals modest as a safety net.

Day-2 operations

  • Upgrades: run the Flux upgrade by updating bootstrap manifests in git, test on a non-production cluster, and read the release notes first.
  • Visibility: export controller metrics to Prometheus, build Grafana dashboards for reconciliation status, and alert on stuck resources through monitoring with Grafana and Prometheus.
  • Notifications: send alerts to chat when reconciliation fails. See GitOps deployment notifications.
  • Image automation: use it where automatic tag bumps make sense, typically non-production, and keep production changes behind a pull request.
  • Progressive delivery: Flagger adds canary and blue-green releases, covered in progressive delivery.

Failure modes we avoid

SymptomCauseOur approach
Resources stuck not readyMissing dependency orderExplicit dependsOn and health checks
Accidental deletionprune with a mistaken commitReview gates, suspend capability, care in production
Lost secrets after rebuildDecryption key not backed upKey escrow and tested recovery
Tenant overreachReconciling as cluster-adminService account impersonation
Hidden failuresNo alertingNotifications and metrics

When to choose something else

If your developers expect a UI to browse application health, ArgoCD is often the more comfortable choice, and it offers ApplicationSets for large fleets. For one small cluster with simple needs, a pipeline running Helm may be enough for now. Flux and ArgoCD are both sound; running both on the same resources is a mistake, though a clear split of ownership can work. Pair either with a CI tool such as GitLab CI/CD or GitHub Actions to build and test, and with Helm for packaging.

To plan a Flux rollout, see our GitOps service or contact us.

Official documentation: fluxcd.io

How we work with Flux

  1. 01

    Assess clusters and ownership

    We map clusters, teams, existing deploy methods and compliance constraints, and decide where Flux fits.

  2. 02

    Design the repository layout

    We choose a fleet repository structure with clusters, infrastructure and apps layers, and a promotion approach between environments.

  3. 03

    Bootstrap and adopt

    Flux is bootstrapped so its manifests are committed to git and it reconciles itself, then existing workloads are adopted gradually.

  4. 04

    Define ordering and tenancy

    Dependencies between add-ons and apps are declared, and tenant permissions are bounded by service accounts and namespaces.

  5. 05

    Add secrets, notifications and policy

    Encrypted secrets or an external secrets operator are wired in, with alerts to chat and checks on failed reconciliations.

  6. 06

    Run and hand over

    Upgrade procedures, monitoring dashboards and recovery steps are documented and walked through with your team.

Flux compared with the alternatives

We recommend the tool that fits your team, not the one we know best. Here is when each option makes sense.

OptionChoose it when
FluxFlux is a GitOps toolkit for Kubernetes made of small controllers that pull configuration from git, OCI or Helm repositories and reconcile it into clusters.
ArgoCDChoose it if developers want a UI showing application health and diffs, or you want a central control plane with project-based access for many teams.
Pipeline-driven deploysChoose helm or kubectl from CI for a small, single cluster setup where GitOps overhead is not yet worth it.
Cloud-managed GitOps extensionsChoose a provider-managed Flux extension, such as on AKS, if you want less to operate and accept the provider's supported feature set.
Crossplane with a GitOps toolChoose it when you also want to provision cloud infrastructure from Kubernetes resources, alongside Flux or ArgoCD for sync.

Tools we use alongside Flux

KustomizeHelmSOPSageExternal Secrets OperatorFlaggerOCI registriesWeave GitOpsPrometheusGrafanaSlackGitHub

Frequently asked questions

What is Flux in Kubernetes?
Flux is a CNCF GitOps toolkit that keeps Kubernetes clusters in sync with sources such as git repositories, OCI artefacts and Helm repositories. A set of controllers fetches the sources, renders Kustomize and Helm, applies the result and corrects drift. Everything is configured with Kubernetes custom resources.
How do I bootstrap Flux?
Run the Flux bootstrap command against your git provider. It installs the controllers, commits their manifests and a sync configuration to your repository, and configures Flux to reconcile that path. From then on Flux manages itself from git, and upgrades are a commit.
Flux or ArgoCD: what is the real difference?
Flux is a set of small controllers driven by custom resources, with strong Helm, Kustomize and OCI support and a natural fit for platform teams. ArgoCD is more application-centric, with a built-in UI and project-based access. Both are mature, so we choose by team habits and visibility needs.
How does Flux handle secrets?
Flux supports decrypting secrets stored in git with SOPS using age or cloud key management keys, and it works with the External Secrets Operator. We choose based on your cloud and rotation needs, and ensure the decryption key is itself protected and recoverable.
Can Flux manage multiple teams safely?
Yes. Each tenant gets a namespace and a service account, and its Kustomization or HelmRelease resources are set to reconcile using that service account. Tenants then cannot create resources beyond what Kubernetes RBAC allows them, even though the same Flux controllers apply their changes.
Does Flux have a UI?
Flux itself is command line and resource driven, without a built-in dashboard. Teams get visibility through the flux CLI, notifications to chat, Prometheus metrics with Grafana dashboards, or optional third-party and community web interfaces. If a native UI is a priority for developers, ArgoCD may suit better.

Talk to an engineer about Flux

Book a free 30-minute call. We review your current setup and tell you honestly whether and how we can help.

Written by Saddique Khan, DevOps / SRE / Cloud Consultant Engineer. Last updated 2026-10-09.