Déploiement d’OpenStack en production

OpenStack est bien plus qu’une alternative aux hyperscalers : c’est une plateforme complète d’orchestration d’infrastructure. Ce guide ultra-avancé, pensé pour les ingénieurs cloud, architectes DevOps et intégrateurs systèmes, couvre chaque étape du déploiement, avec toutes les commandes et considérations stratégiques.

1. Objectif

Créer une plateforme cloud privée conforme aux exigences suivantes :

• Haute disponibilité (HA) complète
• Isolation réseau multi-tenant (VXLAN/OVN)
• Stockage unifié (bloc, objet, fichier)
• Monitoring avancé et logging distribué
• Intégration CI/CD avec Terraform, GitLab, ArgoCD
• Authentification unifiée (LDAP/OIDC)
• Chiffrement TLS interne + external endpoints

2. Architecture recommandée (production réelle)

Schéma physique :

• 3 nœuds contrôle : Galera, Keystone, RabbitMQ, Horizon, HAProxy, Keepalived
• 2 nœuds réseau : Neutron agents + OVN + L3 routing + DHCP + Metadata
• 3+ nœuds compute : KVM + QEMU + libvirt
• 3+ nœuds Ceph : MON, OSD, RGW, MDS (RBD, CephFS)
• 1 nœud monitoring : Prometheus, Grafana, Alertmanager, Fluent Bit

Réseaux physiques :

• bond0 : VLAN MGMT + API + Internal
• eth1 : External provider network
• bond1 : Ceph (public / cluster)
• VLAN tagging via 802.1Q + LACP active/active

3. Préparation des hôtes

# Configuration système de base
apt update && apt upgrade -y
swapoff -a && sed -i '/swap/ s/^/#/' /etc/fstab
modprobe br_netfilter
sysctl -w net.ipv4.ip_forward=1
cat <<EOF >> /etc/sysctl.conf
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl -p

# Installation NTP (requis pour Galera)
apt install chrony -y
systemctl enable chronyd --now

# Installation Docker + pip + kolla
apt install docker.io python3-pip git -y
pip install -U pip
pip install 'ansible>=8.0.0' kolla-ansible

# SSH key entre nœuds
ssh-keygen -t rsa
for i in ctl01 ctl02 ctl03 net01 cmp01; do ssh-copy-id $i; done

4. Configuration multinode Kolla-Ansible

mkdir -p /etc/kolla
cp -r /usr/local/share/kolla-ansible/etc_examples/kolla/* /etc/kolla/
cp /usr/local/share/kolla-ansible/ansible/inventory/multinode ~/inventory.ini

[control]
ctl01 ansible_host=10.10.10.11
ctl02 ansible_host=10.10.10.12
ctl03 ansible_host=10.10.10.13

[network]
net01 ansible_host=10.10.10.21
net02 ansible_host=10.10.10.22

[compute]
cmp01 ansible_host=10.10.10.31
cmp02 ansible_host=10.10.10.32

[storage]
ceph01 ansible_host=10.10.10.41
ceph02 ansible_host=10.10.10.42
ceph03 ansible_host=10.10.10.43

Génération des mots de passe :

kolla-genpwd

globals.yml :

kolla_base_distro: "ubuntu"
kolla_install_type: "source"
openstack_release: "caracal"
network_interface: "bond0"
neutron_external_interface: "eth1"
docker_restart_policy: "unless-stopped"
keepalived_virtual_router_id: "51"
enable_ceph: yes
enable_cinder: yes
enable_gnocchi: yes
enable_prometheus: yes
enable_grafana: yes
enable_barbican: yes
enable_octavia: yes
enable_magnum: yes

5. Déploiement complet

kolla-ansible bootstrap-servers -i inventory.ini
kolla-ansible prechecks -i inventory.ini
kolla-ansible deploy -i inventory.ini
kolla-ansible post-deploy -i inventory.ini
source /etc/kolla/admin-openrc.sh

Test d’intégrité :

openstack service list
openstack network agent list
openstack compute service list

6. Sécurisation et durcissement

1. Activation TLS avec Certbot (Let’s Encrypt) et HAProxy

Générer les certificats TLS :

apt install certbot -y
certbot certonly --standalone -d api.openstack.local --agree-tos --register-unsafely-without-email

Configurer HAProxy pour SSL termination :

frontend keystone_ssl
  bind *:443 ssl crt /etc/letsencrypt/live/api.openstack.local/fullchain.pem crt /etc/letsencrypt/live/api.openstack.local/privkey.pem
  default_backend keystone

Redémarrer HAProxy :

systemctl restart haproxy

(Option) Intégration TLS via Vault

Génération dynamique des certificats :

vault secrets enable pki
vault write pki/root/generate/internal common_name="openstack.internal" ttl=8760h
vault write pki/roles/openstack allow_any_name=true ttl=72h

Requêtes TLS automatisées via Ansible :

- name: Générer un certificat
  uri:
    url: https://vault:8200/v1/pki/issue/openstack
    method: POST
    body: '{"common_name": "api.openstack.local"}'
    headers:
      X-Vault-Token: "{{ vault_token }}"

2. Rotation automatique des credentials via Barbican

Stockage de secrets :

openstack secret store --name db-root-password --payload 'mysecret' --payload-content-type text/plain

Lecture à l’exécution :

openstack secret get db-root-password

Automatisation via ansible :

- name: Récupérer mot de passe
  shell: openstack secret get db-root-password -f value -c payload
  register: db_password

3. Firewall host-based avec UFW / iptables / nftables

UFW :

ufw allow OpenSSH
ufw allow 443/tcp
ufw allow 3306/tcp
ufw enable

Iptables :

iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -P INPUT DROP

Nftables :

nft add table inet filter
nft add chain inet filter input { type filter hook input priority 0; }
nft add rule inet filter input tcp dport { 22, 443 } accept
nft add rule inet filter input ct state established,related accept
nft add rule inet filter input drop

4. Sécurisation des APIs avec Keystone OIDC + mTLS

Activer l’OIDC :

openstack identity provider create keycloak --remote-id https://auth.example.com
openstack mapping create oidc-map --rules file://rules.json
openstack federation protocol create oidc --identity-provider keycloak --mapping oidc-map

Configurer Keystone pour mTLS (dans HAProxy) :

frontend keystone_ssl
  bind *:443 ssl crt /etc/ssl/private/openstack.pem ca-file /etc/ssl/certs/ca.crt verify required

Configurer les certificats clients dans Keystone :

mkdir -p /etc/keystone/ssl
cp client.crt /etc/keystone/ssl/
cp client.key /etc/keystone/ssl/

Redémarrage Keystone + HAProxy :

kolla-ansible restart -i inventory.ini
systemctl restart haproxy

7. CI/CD & automatisation

GitLab + Terraform + OpenStack

git clone git@repo:infra/terraform-openstack
cd terraform-openstack
terraform init && terraform apply

ArgoCD pour workloads K8s dans Magnum

1. Créer un cluster Kubernetes avec Magnum :

openstack coe cluster template create k8s-template \
  --image-id fedora-coreos-latest \
  --external-network public \
  --dns-nameserver 1.1.1.1 \
  --flavor m1.medium \
  --docker-storage-driver overlay2 \
  --coe kubernetes

openstack coe cluster create dev-cluster \
  --cluster-template k8s-template \
  --keypair mykey \
  --node-count 3

2. Récupérer le kubeconfig :

openstack coe cluster config dev-cluster --dir ~/.kube --force
export KUBECONFIG=~/.kube/config

3. Déployer ArgoCD sur le cluster Magnum :

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

4. Exposer l’interface Web d’ArgoCD :

kubectl port-forward svc/argocd-server -n argocd 8080:443

Accès via https://localhost:8080 (admin / mot de passe via kubectl get secret)

5. Ajouter un dépôt Git et déployer une app Helm :

argocd repo add https://github.com/monorg/monrepo --username gituser --password pass
argocd app create nginx-app \
  --repo https://github.com/monorg/monrepo \
  --path charts/nginx \
  --dest-server https://kubernetes.default.svc \
  --dest-namespace default \
  --helm-set replicaCount=2
argocd app sync nginx-app

Vault integration pour secrets (ex. DB, tokens Keystone)

1. Déployer HashiCorp Vault (mode HA recommandé) :

helm repo add hashicorp https://helm.releases.hashicorp.com
helm install vault hashicorp/vault --namespace vault --create-namespace

2. Initialiser et débloquer Vault :

kubectl exec -n vault vault-0 -- vault operator init
kubectl exec -n vault vault-0 -- vault operator unseal

3. Activer le moteur de secrets KV :

vault secrets enable -version=2 kv
vault kv put kv/database db_user=admin db_pass=securepass123

4. Créer des policies Vault :

vault policy write openstack - <<EOF
path "kv/database" {
  capabilities = ["read"]
}
EOF

5. Gérer la rotation automatique des tokens avec TTL :

vault auth enable approle
vault write auth/approle/role/openstack-role \
  token_policies="openstack" \
  token_ttl="1h" \
  token_max_ttl="4h"

Utilisation dans vos applications via :

vault write auth/approle/login role_id=<role_id> secret_id=<secret_id>

Cela permet un accès dynamique, sécurisé et limité dans le temps aux secrets pour vos services déployés sur OpenStack ou Kubernetes.

8. Monitoring et observabilité

Installation de Prometheus Node Exporter sur tous les nœuds

useradd --no-create-home --shell /bin/false node_exporter
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvf node_exporter-1.7.0.linux-amd64.tar.gz
cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
chown node_exporter:node_exporter /usr/local/bin/node_exporter

Création du service systemd :

cat <<EOF > /etc/systemd/system/node_exporter.service
[Unit]
Description=Node Exporter
After=network.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target
EOF

Activation :

systemctl daemon-reexec
systemctl enable --now node_exporter

Configuration de Prometheus pour scrapper les cibles OpenStack

Dans le fichier prometheus.yml sur le nœud monitoring :

  - job_name: 'openstack-nodes'
    static_configs:
      - targets: ['10.10.10.11:9100', '10.10.10.12:9100', '10.10.10.13:9100']

Redémarrage Prometheus :

docker restart prometheus

Intégration Grafana

# Lancement via container (si non géré par Kolla)
docker run -d --name=grafana -p 3000:3000 grafana/grafana

Accès : http://<IP>:3000 (admin/admin), ajouter Prometheus comme source de données.

Importer des dashboards :

curl -s https://grafana.com/api/dashboards/11074/revisions/5/download -o openstack-dashboard.json

Via interface Grafana : Configuration > Dashboards > Import.

Fluent Bit vers Loki

Installation :

apt install fluent-bit -y

Configuration Fluent Bit : /etc/fluent-bit/fluent-bit.conf

[OUTPUT]
    Name loki
    Match *
    Host loki.internal
    Port 3100
    Labels job=fluentbit,host=${HOSTNAME}

Redémarrer Fluent Bit :

systemctl restart fluent-bit

Alertes critiques avec Alertmanager

Dans alertmanager.yml :

receivers:
  - name: 'email-alerts'
    email_configs:
    - to: '[email protected]'
      from: '[email protected]'
      smarthost: 'smtp.exemple.com:587'
      auth_username: 'alertmanager'
      auth_password: 'password'

Déclencheur d’alerte Prometheus :

- alert: InstanceDown
  expr: up == 0
  for: 1m
  labels:
    severity: critical
  annotations:
    summary: "Instance {{ $labels.instance }} down"
    description: "Service {{ $labels.job }} ne répond plus."

Redémarrage stack Prometheus + Alertmanager :

docker restart prometheus alertmanager

Supervision Ceph (via Ceph Exporter)

Installation sur un nœud MON :

wget https://github.com/digitalocean/ceph_exporter/releases/download/v3.0.0/ceph_exporter-3.0.0.linux-amd64.tar.gz
tar xvf ceph_exporter-3.0.0.linux-amd64.tar.gz
cp ceph_exporter /usr/local/bin/
useradd -r -s /sbin/nologin ceph_exporter

Service systemd :

cat <<EOF > /etc/systemd/system/ceph_exporter.service
[Unit]
Description=Ceph Prometheus Exporter
After=network.target

[Service]
User=ceph_exporter
ExecStart=/usr/local/bin/ceph_exporter --cluster=ceph

[Install]
WantedBy=multi-user.target
EOF

Activation :

systemctl daemon-reexec
systemctl enable --now ceph_exporter

Prometheus config :

- job_name: 'ceph'
  static_configs:
    - targets: ['10.10.10.41:9128']

Supervision RabbitMQ

Activer le plugin Prometheus sur le conteneur Kolla :

docker exec -it rabbitmq bash
rabbitmq-plugins enable rabbitmq_prometheus
exit

Prometheus scrape :

- job_name: 'rabbitmq'
  static_configs:
    - targets: ['10.10.10.11:15692']

Supervision Neutron OVN

Exporter OVN NB/SB metrics avec OVN-exporter :

git clone https://github.com/greenpau/ovn-exporter.git
cd ovn-exporter
./ovn-exporter --listen-on=:9476 --nb-address=tcp:127.0.0.1:6641 --sb-address=tcp:127.0.0.1:6642

Prometheus job :

- job_name: 'neutron-ovn'
  static_configs:
    - targets: ['localhost:9476']

Redémarrage Prometheus après modifications :

docker restart prometheus

9. Tests de charge et résilience

• Rally :

rally deployment create --fromenv --name openstack
rally task start --task tasks/create-and-delete.json

• Tempest :

cd /opt/tempest
source ~/admin-openrc.sh
pytest -v tempest/api/compute/servers/test_servers.py

• Shaker (réseau) :

shaker --scenario scenarios/full_mesh --server-endpoint 0.0.0.0:5000

10. Scalabilité horizontale

Ajout d’un nouveau compute live :

ansible-playbook -i inventory.ini -l cmp03 bootstrap-servers.yml
kolla-ansible deploy -i inventory.ini

Ajout d’un second cloud :

Federation Keystone + Fernet

1. Créer un Identity Provider sur le cloud principal :

openstack identity provider create regionTwo \
  --remote-id https://regionTwo.example.com \
  --description "Federated region two"

2. Créer un mapping pour les utilisateurs fédérés :

openstack mapping create regionTwo-mapping \
  --rules '[{"local": [{"user": {"name": "federated_user"}, "group": {"name": "admin", "domain": {"name": "Default"}}], "remote": [{"type": "openstack_user"}]}]'

3. Définir un protocole d’authentification :

openstack federation protocol create saml2 \
  --identity-provider regionTwo \
  --mapping regionTwo-mapping

4. Synchronisation des Fernet keys entre clouds :

Sur cloud A :

scp /etc/keystone/fernet-keys/* user@regionTwo:/etc/keystone/fernet-keys/

Sur cloud B :

chown keystone:keystone /etc/keystone/fernet-keys/*

5. Relancer Keystone :

docker restart keystone

Zones multi-régions : region_name

1. Créer une région dans Keystone (cloud secondaire) :

openstack region create regionTwo

2. Déployer les services avec la variable :

region_name: regionTwo

3. Vérifier :

openstack catalog list --os-region-name regionTwo

Vous pouvez interconnecter les clouds via Federation + Fernet pour gérer l’authentification unique, tout en segmentant les ressources par région.

Conclusion

Ce guide s’adresse aux architectes et ingénieurs en quête de maîtrise avancée d’OpenStack dans un contexte de production critique. En 2025, OpenStack reste incontournable pour bâtir une infrastructure cloud souveraine, réplicable, modulaire et alignée DevSecOps.