Guide de Failover PostgreSQL sur OpenShift

AVANT FAILOVER :
┌──────────┐
│  Master  │ ← Écritures
└────┬─────┘
     │ Réplication
     ▼
┌──────────┐
│  Slave   │ ← Lectures
└──────────┘

APRÈS FAILOVER :
┌──────────┐
│ Ex-Master│ ← ARRÊTÉ
└──────────┘

┌──────────┐
│ Ex-Slave │ ← Écritures + Lectures
│ (promu)  │   NOUVEAU MASTER
└──────────┘

# Vérifier l'état des pods
oc get pods -l app=postgresql

# Vérifier l'état de la réplication (si le master répond)
MASTER_POD=$(oc get pods -l name=postgresql -o jsonpath='{.items[0].metadata.name}')
oc exec $MASTER_POD -- psql -U postgres -c "SELECT * FROM pg_stat_replication;" 2>/dev/null || echo "Master inaccessible"

# Vérifier le lag sur le slave
SLAVE_POD=$(oc get pods -l role=slave -o jsonpath='{.items[0].metadata.name}')
oc exec $SLAVE_POD -- psql -U postgres -c "SELECT pg_is_in_recovery();"

# Snapshot du PVC (si votre storage class le supporte)
oc get pvc postgresql-slave -o yaml > pvc-slave-before-promotion.yaml

# Ou backup SQL
oc exec $SLAVE_POD -- pg_dumpall -U postgres > backup-slave-before-promotion.sql

# Se connecter au pod slave
oc exec -it $SLAVE_POD -- bash

# À l'intérieur du conteneur
pg_ctl promote -D $PGDATA

# Vérifier la promotion
psql -U postgres -c "SELECT pg_is_in_recovery();"
# Devrait retourner "f" (false)

# Sortir du conteneur
exit

oc exec $SLAVE_POD -- psql -U postgres -c "SELECT pg_promote();"

# Supprimer le fichier standby.signal
oc exec $SLAVE_POD -- rm -f /var/lib/postgresql/data/standby.signal

# Redémarrer PostgreSQL
oc exec $SLAVE_POD -- pg_ctl restart -D /var/lib/postgresql/data

# Vérifier que le slave n'est plus en recovery
oc exec $SLAVE_POD -- psql -U postgres -c "SELECT pg_is_in_recovery();"
# Doit retourner "f"

# Tester une écriture
oc exec $SLAVE_POD -- psql -U postgres -c "CREATE TABLE test_failover (id INT);"
oc exec $SLAVE_POD -- psql -U postgres -c "INSERT INTO test_failover VALUES (1);"
oc exec $SLAVE_POD -- psql -U postgres -c "SELECT * FROM test_failover;"

apiVersion: v1
kind: Service
metadata:
  name: postgresql
  labels:
    app: postgresql
spec:
  ports:
    - name: postgresql
      port: 5432
      targetPort: 5432
  selector:
    app: postgresql
    role: slave # ← Pointer vers l'ex-slave
  type: ClusterIP

oc apply -f postgresql-service-updated.yaml

# Ou directement avec oc patch
oc patch service postgresql -p '{"spec":{"selector":{"role":"slave"}}}'

# Modifier le deployment slave
oc edit deployment postgresql-slave

# Changer les labels
# labels:
#   app: postgresql
#   role: master  # ← Changer de "slave" à "master"

# Créer un service pointant vers l'ex-slave
oc expose deployment postgresql-slave --name=postgresql-temp --port=5432

# Supprimer l'ancien service master
oc delete service postgresql

# Renommer le service temporaire
oc patch service postgresql-temp -p '{"metadata":{"name":"postgresql"}}'

# Créer l'utilisateur de réplication si nécessaire
oc exec $SLAVE_POD -- psql -U postgres <<EOF
DO \$\$
BEGIN
    IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname='replicator') THEN
        CREATE USER replicator WITH REPLICATION ENCRYPTED PASSWORD 'replicator_password';
    END IF;
END
\$\$;
EOF

# Créer un nouveau slot de réplication
oc exec $SLAVE_POD -- psql -U postgres -c "SELECT pg_create_physical_replication_slot('replication_slot_new_slave');"

# Le pod utilise déjà slave.conf, il faut le passer en master.conf
oc exec $SLAVE_POD -- bash -c "cp /etc/postgresql/slave.conf /var/lib/postgresql/data/postgresql.auto.conf"

# Ou recréer le pod avec la configuration master
oc set volumes deployment/postgresql-slave \
  --add --name=master-config \
  --type=configmap \
  --configmap-name=postgresql-master-config \
  --mount-path=/etc/postgresql/master.conf \
  --sub-path=master.conf \
  --overwrite

# Redémarrer le pod
oc rollout restart deployment/postgresql-slave

# Applications peuvent écrire
oc exec $SLAVE_POD -- psql -U postgres -c "INSERT INTO test_failover VALUES (2);"

# Vérifier les connexions
oc exec $SLAVE_POD -- psql -U postgres -c "SELECT count(*) FROM pg_stat_activity;"

# Tester depuis une application
oc run test-pg --image=postgres:15 --rm -it --restart=Never -- \
  psql -h postgresql -U postgres -d postgres -c "SELECT now();"

┌─────────────────────────────────────────────┐
│              etcd / Consul                  │
│         (Distributed Config Store)          │
└────────────────┬────────────────────────────┘
                 │
         ┌───────┴────────┐
         │                │
    ┌────▼────┐      ┌────▼────┐
    │ Patroni │      │ Patroni │
    │ Master  │─────▶│ Replica │
    │   Pod   │      │   Pod   │
    └─────────┘      └─────────┘
         │                │
    ┌────▼────┐      ┌────▼────┐
    │  PG     │      │  PG     │
    │ Master  │      │ Slave   │
    └─────────┘      └─────────┘

apiVersion: v1
kind: Service
metadata:
  name: etcd
  labels:
    app: etcd
spec:
  ports:
    - port: 2379
      name: client
      
       
   
  
     

 
 

   

   
   
  
    
       
  
    
      
         
    
      
          
           
          
              
               
              
               
          
              
              
                
                   
              
               
              
               
              
               
              
               
              
               
              
               
              
               
          
              
               
  
     
         
      
         []
        
          
             

oc apply -f etcd-statefulset.yaml

# Attendre que etcd soit prêt
oc wait --for=condition=ready pod -l app=etcd --timeout=300s

# Vérifier l'état du cluster
oc exec etcd-0 -- etcdctl member list

apiVersion: v1
kind: ConfigMap
metadata:
  name: patroni-config
data:
  patroni.yml: |
    scope: postgres-cluster
    namespace: /service/
    name: ${HOSTNAME}

    restapi:
      listen: 0.0.0.0
       

    
       

    
      
         
         
         
         
        
           
          
             
             
             
             
             
             
             
             

      
          
         

      
            
             
             

      
        
           
          
             
             
        
           
          
             

    
       
       
       
       
      
        
           
           
        
           
           

    
       

    
       
       
       

oc apply -f patroni-config.yaml

apiVersion: v1
kind: Secret
metadata:
  name: postgresql-patroni-secret
type: Opaque
stringData:
  superuser-password: <GÉNÉRER_MOT_DE_PASSE_FORT>
  replication-password: <GÉNÉRER_MOT_DE_PASSE_FORT>

apiVersion: v1
kind: ServiceAccount
metadata:
  name: postgresql-patroni
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: postgresql-patroni
rules:
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["create", "get", "list", "patch", "update", "watch"]
  - apiGroups: [""]
    resources: ["endpoints"]
     [, , , , , , ]
    []
     []
     [, , , , ]

 
 

   

   
   
   

    
     

# Appliquer les secrets
oc apply -f postgresql-patroni-secret.yaml

# Appliquer les RBAC
oc apply -f postgresql-patroni-rbac.yaml

# Déployer le StatefulSet
oc apply -f postgresql-patroni-statefulset.yaml

# Surveiller le déploiement
oc get pods -l app=postgresql-patroni -w

# Vérifier les logs
oc logs -f postgresql-patroni-0

# Voir l'état du cluster
oc exec postgresql-patroni-0 -- patronictl -c /etc/patroni/patroni.yml list

# Résultat attendu :
# + Cluster: postgres-cluster --+---------+---------+----+-----------+
# | Member              | Host  | Role    | State   | TL | Lag in MB |
# +---------------------+-------+---------+---------+----+-----------+
# | postgresql-patroni-0| 10... | Leader  | running |  1 |           |
# | postgresql-patroni-1| 10... | Replica | running |  1 |         0 |
# | postgresql-patroni-2| 10... | Replica | running |  1 |         0 |
# +---------------------+-------+---------+---------+----+-----------+

# Vérifier le master actuel
oc exec postgresql-patroni-0 -- patronictl -c /etc/patroni/patroni.yml show-config

# Identifier le pod master
MASTER_POD=$(oc get pods -l app=postgresql-patroni,role=master -o jsonpath='{.items[0].metadata.name}')

# Supprimer le pod master
oc delete pod $MASTER_POD

# Observer le failover automatique
watch -n 1 "oc exec postgresql-patroni-0 -- patronictl -c /etc/patroni/patroni.yml list"

postgresql-master:5432

postgresql-replicas:5432

postgresql-patroni:5432

# Effectuer un switchover planifié
oc exec postgresql-patroni-0 -- patronictl -c /etc/patroni/patroni.yml switchover --master postgresql-patroni-0 --candidate postgresql-patroni-1 --force

# Simuler un crash du pod master
MASTER_POD=$(oc get pods -l app=postgresql-patroni,role=master -o jsonpath='{.items[0].metadata.name}')
oc delete pod $MASTER_POD --grace-period=0 --force

# Surveiller
watch -n 1 "oc get pods -l app=postgresql-patroni"
watch -n 1 "oc exec postgresql-patroni-0 -- patronictl -c /etc/patroni/patroni.yml list"

# Isoler un pod du réseau (nécessite Network Policies)
# Créer une NetworkPolicy qui bloque le master actuel

# Patroni devrait :
# 1. Détecter la perte de quorum
# 2. Promouvoir un nouveau master parmi les nœuds connectés
# 3. Empêcher l'ancien master d'accepter des écritures

# Script de test de charge
cat > test-failover-performance.sh <<'EOF'
#!/bin/bash

# Connexion à la base
CONNECTION="postgresql://postgres:password@postgresql-master:5432/postgres"

# Boucle d'écriture
while true; do
    result=$(psql "$CONNECTION" -c "INSERT INTO test_failover VALUES (NOW()) RETURNING *;" 2>&1)
    if [[ $? -eq 0 ]]; then
        echo "[$(date)] SUCCESS: $result"
    else
        echo "[$(date)] FAILED: $result"
    fi
    sleep 1
done
EOF

# Lancer le test en arrière-plan
oc run test-failover --image=postgres:15 --rm -it --restart=Never -- bash -c 


oc delete pod 

# Si l'ancien master est récupérable
OLD_MASTER_POD=$(oc get pods -l name=postgresql -o jsonpath='{.items[0].metadata.name}')

# Supprimer le pod et le PVC
oc delete pod $OLD_MASTER_POD
oc delete pvc postgresql  # PVC de l'ancien master

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgresql-new-slave
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi
  storageClassName: standard

ERROR: cannot promote server because it is still in recovery mode

oc exec $SLAVE_POD -- psql -U postgres -c "
SELECT pg_is_in_recovery(), pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn();
"

# Le slave doit terminer d'appliquer tous les WAL
# Attendre quelques minutes puis réessayer

oc exec $SLAVE_POD -- pg_ctl promote -D /var/lib/postgresql/data

oc exec <pod1> -- psql -U postgres -c "SELECT pg_is_in_recovery();"
oc exec <pod2> -- psql -U postgres -c "SELECT pg_is_in_recovery();"

# Vérifier les LSN
oc exec <pod1> -- psql -U postgres -c "SELECT pg_current_wal_lsn();"
oc exec <pod2> -- psql -U postgres -c "SELECT pg_current_wal_lsn();"

oc scale deployment/<old-master> --replicas=0

patronictl list
# Tous les membres en état "no master"

oc exec etcd-0 -- etcdctl endpoint health --cluster

# Patroni nécessite la majorité (2/3, 3/5, etc.)
# Si trop de nœuds down, pas de quorum

oc exec postgresql-patroni-0 -- patronictl -c /etc/patroni/patroni.yml reinit postgres-cluster postgresql-patroni-0

oc get endpoints postgresql-master
# Doit pointer vers le nouveau master

# Redémarrer les applications
oc rollout restart deployment/<app-name>

# État du cluster Patroni
oc exec <patroni-pod> -- patronictl list

# Switchover planifié
oc exec <patroni-pod> -- patronictl switchover

# Failover manuel (sans master actuel)
oc exec <patroni-pod> -- patronictl failover

# Redémarrer un membre
oc exec <patroni-pod> -- patronictl restart <member-name>

# Réinitialiser un membre
oc exec <patroni-pod> -- patronictl reinit <cluster-name> <member-name>