Enrico Biella

Back

Deploying OpenStack with Helm and FluxCD on KubernetesBlur image

Following up on our previous post where we automated a production-ready Kubernetes cluster, this guide walks through deploying a complete OpenStack cloud on top of it using OpenStack-Helm ↗ (2026.2) and a GitOps workflow managed by FluxCD ↗.


Why OpenStack?#

OpenStack is the world’s leading open-source cloud operating system, turning bare-metal servers into a full AWS-style private cloud with multi-tenant Virtual Machines (Nova), Software-Defined Networking (Neutron/OVN), Ceph block storage (Cinder/Glance), Load Balancers (Octavia), DNS (Designate), hardware accelerators (Cyborg), and managed Kubernetes (Magnum).

Running OpenStack gives organizations complete data sovereignty, zero vendor lock-in, and predictable infrastructure costs compared to hyperscalers or proprietary virtualization stacks—and deploying its control plane on Kubernetes via OpenStack-Helm + FluxCD brings self-healing pods, rolling upgrades, and declarative GitOps lifecycle management to the entire cloud.


Architecture & Network Topology#

FluxCD continuously reconciles the Kubernetes cluster with the declarative configuration stored in Git. Upstream OpenStack-Helm charts are pulled dynamically by tag (${OPENSTACK_RELEASE}.${OPENSTACK_CHART_PATCH}), while all customizations are applied through Helm value overrides.

OpenStack-Helm FluxCD Architecture

All public endpoints are exposed through the Envoy Gateway VIP (192.168.64.100) at https://<service>.192.168.64.100.nip.io.

Node Network Layout#

The underlying Kubernetes nodes use the 4-NIC topology provisioned in the Kubernetes cluster post:

Network Topology

InterfaceSubnetOpenStack & Cluster Role
ens160192.168.64.0/24Management, Kubernetes API, Calico VXLAN, and MetalLB VIP (192.168.64.100)
ens19210.0.0.0/24Internal node-to-node traffic and tenant overlay transport
ens224L2 only (no IP)Bridged into OVS/OVN br-ex for OpenStack external flat (provider) networks and FIPs
ens256L2 only (no IP)Worker nodes only — Octavia Load Balancer management network

Key Design Decisions#

  1. Helm Hooks & Job Protection: OpenStack-Helm drops helm3_hook, turning most bootstrap tasks into regular Kubernetes Jobs ordered by kubernetes-entrypoint init containers (dependencies.static.<component>.jobs). Because a few charts still use hard-coded post-install,post-upgrade hooks, a global Kustomize patch sets spec.install.disableWait: true and spec.upgrade.disableWait: true on all HelmReleases to avoid deadlocks, and applies helm.sh/resource-policy: keep so completed Jobs are never deleted during Flux reconciliation.
  2. Unified Gateway & openstack-ca PKI: The Gateway (gateway-default in envoy-gateway-system) and the initial openstack-ca hierarchy are bootstrapped by Ansible. FluxCD adopts the openstack-ca resources seamlessly, issues openstack-gateway-tls in the openstack namespace (so pods like Magnum and Heat trust the public HTTPS endpoints via one shared CA), and manages all OpenStack HTTPRoutes.
  3. Single-Source Cluster Variables & Multi-Release Overrides: clusters/prod/region1/flux-system/cluster-vars.yaml defines GATEWAY_IP (192.168.64.100), PUBLIC_DOMAIN (192.168.64.100.nip.io), OPENSTACK_RELEASE (2026.1), and OPENSTACK_CHART_PATCH (0) once, which Flux injects across all manifests via postBuild.substituteFrom. Release-specific chart schema differences between 2026.1 and 2026.2 live cleanly in values-release/<release>/.

Repository Structure#


Detailed Setup & Deployment Walkthrough#

Prerequisites#

1. Kubernetes Cluster Infrastructure#

Ensure your Kubernetes cluster (deployed via openstack-k8s-cluster ↗) has all add-ons running and 300 GiB of raw Ceph storage available across the 3 worker nodes:

ComponentPurpose
MetalLBAssigns VIP 192.168.64.100 to Envoy Gateway
Envoy GatewayTerminates HTTPS on :443 via gateway-default
cert-managerManages openstack-ca and per-service mTLS certificates
Rook-CephProvides RBD block storage (general StorageClass)
FluxCDReconciles GitRepositories, Kustomizations, and HelmReleases

Verify Rook-Ceph health before starting:

kubectl -n rook-ceph exec -it deploy/rook-ceph-tools -- ceph status
bash

2. Admin Workstation Tools#

Install helm, the flux CLI, age, and sops on the host where you manage the cluster:

# Install Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Install Flux CLI
curl -s https://fluxcd.io/install.sh | sudo bash

# Install age and SOPS (arm64 example; use linux.amd64 on x86_64)
sudo apt update && sudo apt install -y age
curl -LO https://github.com/getsops/sops/releases/download/v3.13.3/sops-v3.13.3.linux.arm64
sudo install sops-v3.13.3.linux.arm64 /usr/local/bin/sops
bash

Step 1: Node Preparation#

OpenStack services require higher inotify limits on worker nodes, role labels so OpenStack-Helm pods schedule onto the right nodes, the openstack namespace, and endpoint_pod_names enabled in CoreDNS (already configured if you used the openstack-k8s-cluster playbook):


Step 2: SOPS Credential Encryption#

All OpenStack service, database, messaging, and registry passwords are stored in clusters/prod/region1/openstack/values/credentials.yaml and encrypted with SOPS + age. Never commit this file unencrypted.

1. Generate an age Keypair and Create the Cluster Secret#

unset SOPS_AGE_KEY
age-keygen -o age.agekey
export SOPS_AGE_KEY_FILE=$(pwd)/age.agekey
# Copy the printed public key (age1...) into .sops.yaml

# Store the private key in the flux-system namespace so FluxCD can decrypt secrets
kubectl create namespace flux-system --dry-run=client -o yaml | kubectl apply -f -
kubectl create secret generic sops-age \
  --namespace=flux-system \
  --from-file=age.agekey=./age.agekey \
  --dry-run=client -o yaml | kubectl apply -f -
bash

2. Configure .sops.yaml#

Ensure .sops.yaml at the root of the repository references your age public key:

.sops.yaml
creation_rules:
  - path_regex: clusters/prod/region1/openstack/values/credentials\.yaml
    encrypted_regex: '^(data|stringData)$'
    age: >-
      age19u528x0n9cxvlrxs4rxu6ws0yhvev3ucgv5tcpnp4vr5nrqaq4uqxhmkul
yaml

3. Populate and Encrypt credentials.yaml#

Populate clusters/prod/region1/openstack/values/credentials.yaml using the structure below (replace Password1 with strong passwords):

Encrypt the file in place, verify decryption locally, and push to the fluxcd-arm branch:

sops --encrypt --in-place clusters/prod/region1/openstack/values/credentials.yaml
sops -d clusters/prod/region1/openstack/values/credentials.yaml > /dev/null

git add .sops.yaml clusters/prod/region1/openstack/values/credentials.yaml
git commit -m "chore: update sops key and encrypt credentials"
git push origin fluxcd-arm
bash

Step 3: Bootstrap FluxCD & Apply Region1 GitOps Manifests#

Bootstrap FluxCD against your GitLab repository, create the GitLab repository and container registry secrets, and apply the region1 Flux Kustomizations:


Step 4: Verify PKI & Monitor the Deployment#

Confirm that the openstack-ca issuer and certificate are Ready, then watch the HelmReleases reconcile:

# Verify PKI status
kubectl get clusterissuer openstack-ca
kubectl get certificate openstack-ca -n cert-manager

# Watch all OpenStack HelmReleases
flux get helmreleases -n openstack --watch

# Stream helm-controller logs if needed
kubectl logs -n flux-system deploy/helm-controller -f
bash

kubernetes-entrypoint init containers enforce the following rollout sequence automatically:

mariadb, rabbitmq, memcached
  → keystone (db-init → db-sync → credential-setup → fernet-setup → api)
    → glance, cinder, placement
      → openvswitch → ovn → libvirt
        → neutron → nova
          → barbican → heat → magnum
            → octavia, designate (+powerdns)
              → skyline
                → prometheus exporters
text

Step 5: Trust the openstack-ca Certificate & Verify via CLI#

Because both the Envoy Gateway (gateway-openstack-ca-tls) and internal OpenStack services use openstack-ca, exporting a single CA certificate is sufficient for your browser and the OpenStack CLI:


Service Catalog#

All public endpoints are served over HTTPS at https://<service>.192.168.64.100.nip.io (with automatic HTTP-to-HTTPS redirect on port 80):

ServicePublic URLNotes
Skylinehttps://skyline.192.168.64.100.nip.ioWeb Dashboard
Keystonehttps://keystone.192.168.64.100.nip.io/v3Identity & Authentication
Novahttps://nova.192.168.64.100.nip.io/v2.1Compute API
NoVNChttps://novnc.192.168.64.100.nip.ioVM Console Access
Cinderhttps://cinder.192.168.64.100.nip.io/v3Block Storage (Ceph RBD)
Glancehttps://glance.192.168.64.100.nip.ioImage Service (Ceph RBD)
Neutronhttps://neutron.192.168.64.100.nip.ioNetworking (OVN)
Placementhttps://placement.192.168.64.100.nip.ioResource Inventory
Heathttps://heat.192.168.64.100.nip.io/v1Orchestration
Heat CFNhttps://heat-cfn.192.168.64.100.nip.ioCloudFormation-Compatible API
Barbicanhttps://barbican.192.168.64.100.nip.ioKey & Secret Manager
Magnumhttps://magnum.192.168.64.100.nip.io/v1Kubernetes Cluster as a Service
Cyborghttps://cyborg.192.168.64.100.nip.io/v2Accelerator Management
Octaviahttps://octavia.192.168.64.100.nip.ioLoad Balancer as a Service (OVN provider)
Designatehttps://designate.192.168.64.100.nip.io/v2DNS as a Service (PowerDNS backend)

Deployment in Action#

Once logged into Skyline (https://skyline.192.168.64.100.nip.io), you can provision the external flat network (external-net on ens224), create tenant routers, and launch instances or Magnum Kubernetes clusters:

External Network

Router Configuration

OpenStack Server List

OpenStack Network Topology

Deploying OpenStack with Helm and FluxCD on Kubernetes
https://private-site-585329.gitlab.io/blog/openstack-helm-k8s
Author Enrico Biella
Published at November 2, 2026
Comment seems to stuck. Try to refresh?✨