Gérer les certificats

Sélectionnez une version de la documentation :

Les émetteurs de certificats personnalisés vous permettent de gérer les certificats TLS (Transport Layer Security) sur votre cluster de bases de données AlloyDB Omni basé sur Kubernetes.

Par défaut, l'opérateur Kubernetes AlloyDB Omni utilise cert-manager pour provisionner un ensemble de certificats TLS pour chaque cluster de bases de données. Outre le certificat du serveur de base de données, l'opérateur crée également des certificats pour les composants du plan de contrôle afin de s'assurer que les connexions internes sont également sécurisées. Par défaut, chaque certificat est signé par un émetteur géré par l'opérateur.

Si vous préférez que tous les certificats, y compris ceux des composants du plan de contrôle, soient associés à votre propre autorité de certification racine de confiance, vous pouvez configurer l'opérateur pour qu'il utilise l'émetteur de votre choix. Cela vous permet de lier tous les certificats à votre propre infrastructure à clé publique (PKI), y compris les certificats utilisés pour les fonctionnalités du plan de contrôle, sans exposer les détails de mise en œuvre de chaque entité interne.

Durées de vie des certificats par défaut

Par défaut, l'opérateur AlloyDB Omni utilise cert-manager pour émettre et renouveler automatiquement les certificats TLS pour l'opérateur, le plan de contrôle et les instances de base de données.

Le tableau suivant liste les durées de validité par défaut des certificats gérés par l'opérateur AlloyDB Omni :

Type de certificat Description du certificat Nom du secret Espace de noms Durée par défaut
Certificat client mTLS de l'opérateur Utilisé par le déploiement local-controller-manager pour les vérifications d'état à haute disponibilité et les connexions entre l'opérateur et les agents du plan de contrôle. dbs-al-cert-l2-operator Espace de noms de l'opérateur 1440h0m0s (60 jours)
Certificats du serveur de webhook de l'opérateur Utilisé par les serveurs de webhook d'admission de l'opérateur pour valider et modifier les ressources personnalisées. fleet-webhook-server-cert

local-webhook-server-cert
Espace de noms de l'opérateur 1440h0m0s (60 jours)
Certificats d'agent du plan de contrôle par instance Utilisé par l'agent de base de données par instance, le gestionnaire de nœuds et le daemon de sauvegarde pour les connexions au plan de contrôle. dbs-al-cert-dbd-INSTANCE_ID-DB_CLUSTER_NAME

dbs-al-cert-al-INSTANCE_ID-DB_CLUSTER_NAME-nm

dbs-al-cert-backup-daemon-BACKUP_REPO_NAME
Espace de noms du cluster de bases de données 1440h0m0s (60 jours)
Certificats de sauvegarde Utilisé par les services de sauvegarde pour les connexions de sauvegarde et de restauration. dbs-al-cert-backup-client

dbs-al-cert-backup-client-DATA_PLANE_ISSUER_NAME

dbs-al-cert-backup-server-INSTANCE_ID-DB_CLUSTER_NAME

dbs-al-cert-standby-backup-server-INSTANCE_ID-DB_CLUSTER_NAME
Espace de noms du cluster de bases de données 1440h0m0s (60 jours)
Certificat de serveur de base de données Sécurise les connexions client du plan de données à l'instance de base de données. dbs-al-cert-DB_CLUSTER_NAME Espace de noms du cluster de bases de données 87600h0m0s (10 ans)
Certificat de requête d'authentification PgBouncer Certificat client de base de données utilisé par le déploiement PgBouncer pour se connecter à la base de données et effectuer la mise en pool des connexions. Créé uniquement lorsque vous créez une ressource PgBouncer. dbs-al-pgb-cert-PGBOUNCER_NAME Espace de noms du cluster de bases de données 87600h0m0s (10 ans)
Certificats CA autosignés gérés par l'opérateur Certificats d'autorité de certification racine utilisés par les émetteurs autosignés par défaut de l'opérateur pour signer les certificats de l'opérateur, de l'agent du plan de contrôle, de la sauvegarde et du serveur de base de données. dbs-al-ca-l2-operator

dbs-al-ca-DB_CLUSTER_NAME

dbs-al-ca-dbd-INSTANCE_ID-DB_CLUSTER_NAME

dbs-al-ca-backup-server

dbs-al-ca-backup-daemon-BACKUP_REPO_NAME
Espace de noms de l'opérateur et espace de noms du cluster de bases de données 87600h0m0s (10 ans)

Dans ce tableau, les noms des secrets utilisent les espaces réservés suivants :

  • INSTANCE_ID : identifiant à quatre caractères généré pour l'instance de base de données.
  • DB_CLUSTER_NAME : nom de votre ressource DBCluster.
  • DATA_PLANE_ISSUER_NAME : nom de l'émetteur cert-manager personnalisé configuré dans spec.primarySpec.tls.dataPlaneCertIssuer.name, s'il est spécifié.
  • BACKUP_REPO_NAME : nom de votre ressource BackupRepository, si elle est configurée.
  • PGBOUNCER_NAME : nom de votre ressource PgBouncer.

Configurer des émetteurs personnalisés

Vous pouvez configurer des émetteurs de certificats personnalisés pour le cluster de bases de données, l'opérateur AlloyDB Omni et PgBouncer.

Pour configurer un émetteur de certificats, vous devez d'abord créer un émetteur cert-manager associé à l'autorité de certification que vous souhaitez utiliser pour signer vos certificats. Vous pouvez utiliser l'un des types d'émetteurs cert-manager ou un émetteur externe compatible. L'opérateur AlloyDB Omni fait référence à cet émetteur lors de la création de certificats.

Les émetteurs de certificats cert-manager personnalisés doivent renseigner le champ ca.crt dans le secret de certificat généré avec le certificat de l'autorité de certification racine.

Certificats de cluster de bases de données

Il existe deux champs de spécification de cluster de bases de données pour configurer les émetteurs de certificats :

  • spec.primarySpec.tls.dataPlaneCertIssuer : référence à l'émetteur cert-manager qui provisionne les certificats du plan de données. L'autorité de certification émettrice est celle à laquelle le client de base de données peut faire confiance pour valider la base de données lors d'une connexion TLS.

  • spec.primarySpec.tls.controlPlaneAgentsCertIssuer : référence à l'émetteur cert-manager qui provisionne les certificats du plan de contrôle. Ces certificats sont utilisés pour les connexions internes.

spec:
  primarySpec:
    tls:
      dataPlaneCertIssuer:
        name: DATA_PLANE_ISSUER_NAME
        kind: DATA_PLANE_ISSUER_KIND
        group: DATA_PLANE_ISSUER_GROUP
      controlPlaneAgentsCertIssuer:
        name: CONTROL_PLANE_ISSUER_NAME
        kind: CONTROL_PLANE_ISSUER_KIND
        group: CONTROL_PLANE_ISSUER_GROUP

Remplacez les éléments suivants :

  • DATA_PLANE_ISSUER_NAME : nom de l'émetteur cert-manager qui provisionne les certificats du plan de données, par exemple pour le serveur de base de données.

  • DATA_PLANE_ISSUER_KIND : type d'API de l'émetteur cert-manager. La valeur par défaut est Issuer.

  • DATA_PLANE_ISSUER_GROUP : groupe d'API de l'émetteur. La valeur par défaut est cert-manager.io.

  • CONTROL_PLANE_ISSUER_NAME : nom de l'émetteur cert-manager qui provisionne les certificats du plan de contrôle pour les composants internes.

  • CONTROL_PLANE_ISSUER_KIND : type d'API de l'émetteur cert-manager. La valeur par défaut est Issuer.

  • CONTROL_PLANE_ISSUER_GROUP : groupe d'API de l'émetteur. La valeur par défaut est cert-manager.io.

Certificats d'opérateur

La procédure de configuration d'un émetteur cert-manager pour les certificats d'opérateur dépend de la méthode utilisée pour installer l'opérateur AlloyDB Omni.

Configurer à l'aide de Helm

Si vous installez l'opérateur AlloyDB Omni pour la première fois, utilisez helm install et définissez les valeurs appropriées. Cela suppose que vous suivez les instructions pour déployer l'opérateur à l'aide de Helm.

helm install alloydbomni-operator alloydbomni-operator-OPERATOR_VERSION.tgz \
--create-namespace \
--namespace alloydb-omni-system \
--set operatorCertIssuer.certManagerIssuerName="OPERATOR_CERT_ISSUER_NAME" \
--set operatorCertIssuer.certManagerIssuerKind="OPERATOR_CERT_ISSUER_KIND" \
--set operatorCertIssuer.certManagerIssuerGroup="OPERATOR_CERT_ISSUER_GROUP" \
--atomic \
--timeout 5m

Si l'opérateur est déjà installé et que vous devez définir l'émetteur du certificat, utilisez helm upgrade pour définir les valeurs appropriées :

helm upgrade alloydbomni-operator alloydbomni-operator-OPERATOR_VERSION.tgz \
--create-namespace \
--namespace alloydb-omni-system \
--set operatorCertIssuer.certManagerIssuerName="OPERATOR_CERT_ISSUER_NAME" \
--set operatorCertIssuer.certManagerIssuerKind="OPERATOR_CERT_ISSUER_KIND" \
--set operatorCertIssuer.certManagerIssuerGroup="OPERATOR_CERT_ISSUER_GROUP" \
--atomic \
--timeout 5m

Remplacez les éléments suivants :

  • OPERATOR_VERSION : version de l'opérateur AlloyDB Omni à installer.

  • OPERATOR_CERT_ISSUER_NAME : nom de l'émetteur cert-manager qui provisionne le certificat de l'opérateur, utilisé pour les connexions internes.

  • OPERATOR_CERT_ISSUER_KIND : type d'API de l'émetteur cert-manager. La valeur par défaut est Issuer.

  • OPERATOR_CERT_ISSUER_GROUP : groupe d'API de l'émetteur. La valeur par défaut est cert-manager.io.

Configurer à l'aide d'Operator Lifecycle Manager

Si vous avez utilisé Operator Lifecycle Manager (OLM) pour installer l'opérateur AlloyDB Omni, vous pouvez modifier le champ spec.config.env de la ressource Subscription pour définir les variables d'environnement CERT_MANAGER_ISSUER_NAME, CERT_MANAGER_ISSUER_KIND et CERT_MANAGER_ISSUER_GROUP de l'opérateur Deployment.

spec:
  config:
    env:
    - name: CERT_MANAGER_ISSUER_NAME
      value: OPERATOR_CERT_ISSUER_NAME
    - name: CERT_MANAGER_ISSUER_KIND
      value: OPERATOR_CERT_ISSUER_KIND
    - name: CERT_MANAGER_ISSUER_GROUP
      value: OPERATOR_CERT_ISSUER_GROUP

Remplacez les éléments suivants :

  • OPERATOR_CERT_ISSUER_NAME : nom de l'émetteur cert-manager qui provisionne le certificat de l'opérateur, utilisé pour les connexions internes.

  • OPERATOR_CERT_ISSUER_KIND : type d'API de l'émetteur cert-manager. La valeur par défaut est Issuer.

  • OPERATOR_CERT_ISSUER_GROUP : groupe d'API de l'émetteur. La valeur par défaut est cert-manager.io.

Certificats PgBouncer

Pour accepter les émetteurs personnalisés, le contrôleur PgBouncer vérifie le champ DBCluster spec.primarySpec.tls.dataPlaneCertIssuer et l'utilise pour provisionner le certificat PgBouncer. Le contrôleur PgBouncer utilise également les attributs configurés dans spec.primarySpec.tls.dataPlaneCertRequest pour provisionner le certificat PgBouncer. Cela permet de s'assurer que PgBouncer utilise un certificat de la même autorité de certification qui possède les mêmes attributs que la base de données.

Configurer des attributs de certificat personnalisés

Vous pouvez personnaliser les attributs des certificats TLS générés par l'opérateur, tels que la durée du certificat, la période de renouvellement, les autres noms de l'objet (SAN), le nom commun et la configuration de la clé privée.

Vous configurez les attributs de certificat personnalisés dans votre fichier manifeste DBCluster :

  • spec.primarySpec.tls.dataPlaneCertRequest : spécifie les attributs des certificats du plan de données, y compris le serveur pgBackRest, la requête d'authentification PgBouncer et les certificats du serveur de base de données.
  • spec.primarySpec.tls.controlPlaneAgentsCertRequest : spécifie les attributs pour le provisionnement des certificats du plan de contrôle. Ces certificats sont utilisés pour les connexions internes.

Configurer les demandes de certificat

Spécifiez les propriétés de la requête au format suivant :

spec:
  primarySpec:
    tls:
      dataPlaneCertRequest:
        commonName: DATABASE_COMMON_NAME
        dnsNames:
        - DATABASE_DNS_NAME_1
        - DATABASE_DNS_NAME_2
        duration: DATA_PLANE_DURATION
        renewBefore: DATA_PLANE_RENEW_BEFORE
        privateKey:
          algorithm: DATA_PLANE_ALGORITHM
          size: DATA_PLANE_KEY_SIZE
          rotationPolicy: DATA_PLANE_ROTATION_POLICY
      controlPlaneAgentsCertRequest:
        duration: CONTROL_PLANE_DURATION
        renewBefore: CONTROL_PLANE_RENEW_BEFORE
        privateKey:
          algorithm: CONTROL_PLANE_ALGORITHM
          size: CONTROL_PLANE_KEY_SIZE
          rotationPolicy: CONTROL_PLANE_ROTATION_POLICY

Remplacez les éléments suivants :

  • DATABASE_COMMON_NAME : (facultatif, plan de données uniquement) nom commun du certificat de base de données.
  • DATABASE_DNS_NAME_1, DATABASE_DNS_NAME_2 : (facultatif, plan de données uniquement) liste des autres noms de l'objet (SAN) pour le certificat de base de données.
  • DATA_PLANE_DURATION et CONTROL_PLANE_DURATION : durée de validité demandée du certificat sous forme de chaîne de durée (par exemple, 720h0m0s pour une durée personnalisée de 30 jours). Dans chaque bloc de demande de certificat, vous devez spécifier à la fois duration et renewBefore (avec renewBefore inférieur à duration) ou omettre les deux champs. Lorsque les deux champs sont omis, la durée par défaut est de 1440h0m0s, soit 60 jours, pour les certificats de plan de contrôle et de sauvegarde, et de 87600h0m0s, soit 10 ans, pour les certificats de serveur de base de données et de requête d'authentification PgBouncer.
  • DATA_PLANE_RENEW_BEFORE et CONTROL_PLANE_RENEW_BEFORE : durée avant l'expiration pendant laquelle cert-manager doit lancer une tentative de renouvellement (par exemple, 120h0m0s pour cinq jours avant l'expiration). Dans chaque bloc de demande de certificat, vous devez spécifier à la fois duration et renewBefore (avec renewBefore inférieur à duration) ou omettre les deux champs. Lorsque les deux champs sont omis, la période de renouvellement par défaut est de 120h0m0s (cinq jours) pour les certificats du plan de contrôle et de sauvegarde, et de 1440h0m0s (60 jours) pour les certificats du serveur de base de données et de requête d'authentification PgBouncer.
  • DATA_PLANE_ALGORITHM et CONTROL_PLANE_ALGORITHM : algorithme de clé privée. Les valeurs valides sont RSA, ECDSA ou Ed25519.
  • DATA_PLANE_KEY_SIZE et CONTROL_PLANE_KEY_SIZE : taille de la clé privée en bits. Si l'algorithme est RSA, les valeurs valides sont 4096 ou 8192 (la valeur par défaut est 4096). Si l'algorithme est ECDSA, les valeurs valides sont 384 ou 521 (la valeur par défaut est 384). Si l'algorithme est Ed25519, la taille est ignorée.
  • DATA_PLANE_ROTATION_POLICY et CONTROL_PLANE_ROTATION_POLICY : règle qui contrôle la régénération de la clé privée. Les valeurs valides sont Always ou Never.

Certificats client d'opérateur et de sauvegarde

Pour personnaliser les attributs de certificat de l'opérateur et du client de sauvegarde (qui sont partagés entre toutes les instances d'un espace de noms et ne sont pas gérés par une spécification de cluster de bases de données), modifiez les ressources personnalisées Certificate. L'opérateur conserve ces modifications manuelles.

Nettoyer les secrets de certificat

Lorsque vous supprimez une ressource DBCluster, l'opérateur AlloyDB Omni supprime les ressources Certificate associées, mais cert-manager ne nettoie pas les ressources de certificat Secret par défaut. Pour configurer le contrôleur cert-manager afin de nettoyer les secrets lorsque les certificats sont supprimés, consultez Nettoyer les secrets lorsque les certificats sont supprimés dans la documentation de cert-manager.

Si vous avez déjà supprimé une ressource DBCluster sans configurer le nettoyage automatique, supprimez manuellement les secrets de certificat restants :

kubectl delete secret CERTIFICATE_SECRET_NAME -n NAMESPACE

Remplacez les éléments suivants :

  • CERTIFICATE_SECRET_NAME : nom du secret de certificat à supprimer.
  • NAMESPACE : espace de noms du cluster de bases de données.

Valider

Pour vérifier que l'opérateur Deployment est opérationnel et que les variables d'environnement CERT_MANAGER_ISSUER_NAME, CERT_MANAGER_ISSUER_KIND et CERT_MANAGER_ISSUER_GROUP sont définies, exécutez la commande suivante :

kubectl get deployments local-controller-manager -n alloydb-omni-system -o yaml

Pour vérifier que l'émetteur approprié est utilisé, inspectez les objets Certificate comme suit :

kubectl get certificate -n NAMESPACE

Remplacez NAMESPACE par l'espace de noms de votre cluster de base de données ou alloydb-omni-system par le certificat de l'opérateur.

Vérifiez le champ issuerRef dans le résultat de chaque certificat pour confirmer qu'il correspond à votre émetteur personnalisé.

Atténuer l'expiration du certificat client de l'opérateur dans les versions de l'opérateur antérieures à la version 1.8.2

Dans les versions de l'opérateur AlloyDB Omni antérieures à la version 1.8.2, le déploiement local-controller-manager met en cache le certificat client mTLS dbs-al-cert-l2-operator de 60 jours en mémoire pour les connexions de vérification de l'état de haute disponibilité aux agents du plan de contrôle. Bien que cert-manager renouvelle automatiquement le secret dbs-al-cert-l2-operator cinq jours avant l'expiration, le déploiement local-controller-manager ne recharge pas le certificat renouvelé tant que le pod de l'opérateur n'a pas redémarré. Lorsque le certificat mis en cache expire le 60e jour, les reconnexions de vérification d'état suivantes échouent avec une erreur tls: expired certificate et peuvent déclencher des basculements de haute disponibilité non planifiés.

Pour résoudre définitivement ce problème, mettez à niveau l'opérateur AlloyDB Omni vers la version 1.8.2 ou ultérieure.

Si vous ne pouvez pas passer immédiatement à la version 1.8.2 ou ultérieure de l'opérateur, effectuez une rotation du secret dbs-al-cert-l2-operator et redémarrez le déploiement local-controller-manager au moins 10 jours avant l'expiration du certificat. Cette procédure ne redémarre pas les pods de base de données et n'interrompt pas le trafic de la base de données.

Avant de commencer

Avant d'exécuter le script rotate_cert.sh, vérifiez que votre environnement répond aux exigences suivantes :

  • Installez bash, kubectl, openssl et base64 dans votre PATH.
  • Configurez l'accès à votre cluster Kubernetes et définissez votre contexte kubectl actif sur le cluster cible. Pour confirmer le contexte actif, exécutez kubectl config current-context. Répétez cette procédure pour chaque cluster qui exécute une version d'opérateur antérieure à la version 1.8.2.
  • Vérifiez que votre compte dispose des autorisations de contrôle des accès basé sur les rôles (RBAC) Kubernetes dans l'espace de noms de l'opérateur, qui est défini par défaut sur alloydb-omni-system :
    • get sur les ressources Certificate et les journaux Pod
    • get et list sur les ressources Pod
    • get et delete sur le secret dbs-al-cert-l2-operator (ainsi que create et patch pour restaurer un secret sauvegardé)
    • get et patch sur le déploiement local-controller-manager
    • delete sur les ressources CertificateRequest (pour restaurer un secret sauvegardé)

Effectuer la rotation du certificat client de l'opérateur

Le script rotate_cert.sh accepte deux modes et un argument d'espace de noms facultatif, qui est défini par défaut sur alloydb-omni-system :

  • ./rotate_cert.sh check : effectue une vérification en lecture seule et affiche les informations suivantes :
    • Numéro de série et dates de validité du certificat actuel
    • Délai de rotation recommandé, défini sur 10 jours avant l'expiration
    • Heure de démarrage du conteneur local-controller-manager
    • État du certificat en mémoire : [OK] ou [WARNING]
    • Une commande de sauvegarde kubectl
  • ./rotate_cert.sh rotate : effectue les actions suivantes :
    • Supprime le secret dbs-al-cert-l2-operator
    • Attendre que cert-manager émette un nouveau numéro de série de certificat et mette à jour la ressource dbs-al-cert-request-l2-operator Certificate
    • Redémarre le déploiement local-controller-manager.
    • Vérifie les journaux du nouveau pod et affiche la nouvelle date d'expiration.

Pour vérifier et effectuer la rotation du certificat client de l'opérateur, procédez comme suit :

  1. Enregistrez le script suivant dans un fichier nommé rotate_cert.sh, puis rendez le fichier exécutable :

    cat << 'EOF' > rotate_cert.sh
    #!/usr/bin/env bash
    set -euo pipefail
    MODE="${1:-}"
    NS="${2:-alloydb-omni-system}"
    SECRET="dbs-al-cert-l2-operator"
    CERT="dbs-al-cert-request-l2-operator"
    DEPLOY="local-controller-manager"
    get_cert_info() {
      kubectl get secret "$SECRET" -n "$NS" -o jsonpath='{.data.tls\.crt}' 2>/dev/null \
        | base64 -d 2>/dev/null | openssl x509 -noout -serial -enddate 2>/dev/null || true
    }
    calc_rotate_by() {
      date -u -d "$1 - 10 days" +"%Y-%m-%d" 2>/dev/null \
        || date -u -j -v-10d -f "%Y-%m-%dT%H:%M:%SZ" "$1" +"%Y-%m-%d" 2>/dev/null || echo "unknown"
    }
    get_container_name() {
      local names
      names="$(kubectl get pods -n "$NS" -l local-control-plane=controller-manager \
        --field-selector=status.phase=Running --sort-by=.metadata.creationTimestamp \
        -o jsonpath='{.items[-1].spec.containers[*].name}' 2>/dev/null || true)"
      if [[ " $names " == *" local-manager "* ]]; then
        echo "local-manager"
      else
        echo "manager"
      fi
    }
    case "$MODE" in
      check)
        INFO="$(get_cert_info)"
        SERIAL="$(echo "$INFO" | sed -n 's/^serial=//p')"
        ENDDATE="$(echo "$INFO" | sed -n 's/^notAfter=//p')"
        NOT_BEFORE="$(kubectl get certificate "$CERT" -n "$NS" -o jsonpath='{.status.notBefore}')"
        NOT_AFTER="$(kubectl get certificate "$CERT" -n "$NS" -o jsonpath='{.status.notAfter}')"
        CONTAINER="$(get_container_name)"
        STARTED_AT="$(kubectl get pods -n "$NS" -l local-control-plane=controller-manager \
          --field-selector=status.phase=Running --sort-by=.metadata.creationTimestamp \
          -o jsonpath="{.items[-1].status.containerStatuses[?(@.name==\"$CONTAINER\")].state.running.startedAt}")"
        echo "Certificate Serial      : $SERIAL"
        echo "Certificate Start Date  : $NOT_BEFORE"
        echo "Certificate End Date    : $ENDDATE ($NOT_AFTER)"
        echo "Recommended Rotate By   : $(calc_rotate_by "$NOT_AFTER") (10 days before expiry)"
        echo "Operator Started At     : $STARTED_AT"
        if [[ "$STARTED_AT" < "$NOT_BEFORE" ]]; then
          echo "[WARNING] Operator started ($STARTED_AT) BEFORE current cert was issued ($NOT_BEFORE). It is still caching the old cert in memory! Run './rotate_cert.sh rotate $NS' now."
        else
          echo "[OK] Operator is running with the current certificate in memory."
        fi
        echo "Optional Backup Command : kubectl get secret $SECRET -n $NS -o yaml > $SECRET-backup.yaml"
        ;;
      rotate)
        OLD_SERIAL="$(get_cert_info | sed -n 's/^serial=//p')"
        OLD_REV="$(kubectl get certificate "$CERT" -n "$NS" -o jsonpath='{.status.revision}' 2>/dev/null || true)"
        echo "Current Certificate Serial: ${OLD_SERIAL:-none}"
        kubectl delete secret "$SECRET" -n "$NS" --ignore-not-found
        NEW_SERIAL=""
        NOT_AFTER=""
        for _ in {1..30}; do
          sleep 2
          NEW_SERIAL="$(get_cert_info | sed -n 's/^serial=//p')"
          NEW_REV="$(kubectl get certificate "$CERT" -n "$NS" -o jsonpath='{.status.revision}' 2>/dev/null || true)"
          READY_COND="$(kubectl get certificate "$CERT" -n "$NS" -o jsonpath='{.status.conditions[?(@.type=="Ready")].status}' 2>/dev/null || true)"
          NOT_AFTER="$(kubectl get certificate "$CERT" -n "$NS" -o jsonpath='{.status.notAfter}' 2>/dev/null || true)"
          [[ -n "$NEW_SERIAL" && "$NEW_SERIAL" != "$OLD_SERIAL" && "$NEW_REV" != "$OLD_REV" && "$READY_COND" == "True" && -n "$NOT_AFTER" ]] && break
        done
        [[ -n "$NEW_SERIAL" && "$NEW_SERIAL" != "$OLD_SERIAL" && "$READY_COND" == "True" ]] || { echo "[ERROR] Timed out waiting for new cert."; exit 1; }
        kubectl rollout restart "deployment/$DEPLOY" -n "$NS"
        kubectl rollout status "deployment/$DEPLOY" -n "$NS" --timeout=180s
        NEW_POD="$(kubectl get pods -n "$NS" -l local-control-plane=controller-manager \
          --field-selector=status.phase=Running --sort-by=.metadata.creationTimestamp -o jsonpath='{.items[-1].metadata.name}')"
        CONTAINER="$(get_container_name)"
        READY=false
        for _ in {1..40}; do
          LOGS="$(kubectl logs "pod/$NEW_POD" -n "$NS" -c "$CONTAINER" 2>/dev/null || true)"
          grep -q "tls: expired certificate" <<<"$LOGS" && { echo "[ERROR] Found 'tls: expired certificate' in operator logs!"; exit 1; }
          grep -q "L2 controller cert generation completed successfully" <<<"$LOGS" && { READY=true; break; }
          sleep 3
        done
        [[ "$READY" == "true" ]] || { echo "[ERROR] Timed out waiting for L2 controller cert generation log."; exit 1; }
        echo "[SUCCESS] New Serial: $NEW_SERIAL | End Date: $NOT_AFTER | Next Rotate By: $(calc_rotate_by "$NOT_AFTER") (10 days before expiry)"
        ;;
      *)
        echo "Usage: $0 <check|rotate> [namespace]"
        echo "  check       : Validate current certificate status and operator start time."
        echo "  rotate      : Trigger immediate certificate rotation and restart the operator."
        echo "  [namespace] : Namespace of the operator (defaults to 'alloydb-omni-system')."
        exit 1 ;;
    esac
    EOF
    chmod +x rotate_cert.sh
    
  2. Exécutez le script rotate_cert.sh en mode check pour inspecter la date d'expiration actuelle du certificat, la date de rotation recommandée et l'état de l'opérateur en mémoire :

    ./rotate_cert.sh check
    
  3. Facultatif : Sauvegardez le secret dbs-al-cert-l2-operator avant d'effectuer la rotation du certificat :

    kubectl get secret dbs-al-cert-l2-operator -n alloydb-omni-system \
      -o yaml > dbs-al-cert-l2-operator-backup.yaml
    
  4. Si la sortie check affiche [WARNING], ou si la date actuelle est antérieure ou égale à la date Recommended Rotate By, exécutez le script rotate_cert.sh en mode rotate :

    ./rotate_cert.sh rotate
    

    Vérifiez que le résultat se termine par [SUCCESS] et affiche le nouveau numéro de série du certificat, la date d'expiration et la prochaine date de rotation recommandée. Si la sortie affiche [ERROR] ou si le script se termine avec un état différent de zéro, réexécutez ./rotate_cert.sh check et inspectez les journaux de l'opérateur en exécutant kubectl logs deployment/local-controller-manager -n alloydb-omni-system -c local-manager (ou -c manager dans les versions de l'opérateur antérieures à la version 1.6.0).

  5. Facultatif : Si vous avez créé un fichier de sauvegarde à l'étape 3, supprimez le fichier de sauvegarde local après avoir vérifié que la rotation a réussi, car le fichier contient l'ancienne clé privée :

    rm -f dbs-al-cert-l2-operator-backup.yaml
    

Restaurer un certificat sauvegardé

Si cert-manager ne parvient pas à émettre un nouveau certificat lors de la rotation et que vous devez revenir à un fichier dbs-al-cert-l2-operator-backup.yaml non expiré, procédez comme suit :

  1. Supprimez la ressource CertificateRequest en attente ou ayant échoué pour le certificat dbs-al-cert-request-l2-operator afin que cert-manager ne rejette pas la clé privée restaurée avec un motif SecretMismatch et n'écrase pas le secret restauré :

    REV="$(kubectl get certificate dbs-al-cert-request-l2-operator -n alloydb-omni-system -o jsonpath='{.status.revision}')"
    kubectl delete certificaterequest \
      "dbs-al-cert-request-l2-operator-$((REV + 1))" \
      -n alloydb-omni-system --ignore-not-found
    
  2. Supprimez les champs metadata.resourceVersion et metadata.uid de premier niveau du fichier dbs-al-cert-l2-operator-backup.yaml, puis appliquez le secret à l'aide de l'application côté serveur :

    grep -vE '^  (resourceVersion|uid):' dbs-al-cert-l2-operator-backup.yaml \
      | kubectl apply --server-side --force-conflicts -f -
    
  3. Redémarrez le déploiement local-controller-manager pour charger le certificat restauré en mémoire :

    kubectl rollout restart deployment/local-controller-manager -n alloydb-omni-system
    kubectl rollout status deployment/local-controller-manager -n alloydb-omni-system --timeout=180s
    
  4. Exécutez le script rotate_cert.sh en mode check pour confirmer que la valeur Certificate Serial correspond au numéro de série du certificat sauvegardé et que le script renvoie [OK] :

    ./rotate_cert.sh check
    

    Le certificat restauré conserve sa date d'expiration d'origine. Vous devez donc toujours effectuer une rotation du certificat au plus tard à la date Recommended Rotate By.

  5. Supprimez le fichier de sauvegarde local après avoir confirmé la restauration :

    rm -f dbs-al-cert-l2-operator-backup.yaml