ניהול אישורים

בוחרים גרסת תיעוד:

מנפיקי אישורים בהתאמה אישית מאפשרים לכם לנהל אישורי Transport Layer Security (‏TLS) באשכול מסד הנתונים של AlloyDB Omni שמבוסס על Kubernetes.

כברירת מחדל, מפעיל AlloyDB Omni Kubernetes משתמש ב-cert-manager כדי להקצות קבוצה של אישורי TLS לכל אשכול של מסד נתונים. בנוסף לאישור של שרת מסד הנתונים, המפעיל יוצר גם אישורים לרכיבים של מישור הבקרה כדי לוודא שגם החיבורים הפנימיים מאובטחים. כברירת מחדל, כל אישור נחתם על ידי מנפיק שמנוהל על ידי המפעיל.

אם אתם מעדיפים שכל האישורים, כולל אלה של רכיבי מישור הבקרה, יהיו משורשרים בחזרה לרשות אישורי הבסיס (CA) המהימנה שלכם, אתם יכולים להגדיר את המפעיל כך שישתמש במנפיק לבחירתכם. כך אתם יכולים לקשר את כל האישורים לתשתית של מפתח ציבורי (PKI) משלכם, כולל אישורים שמשמשים לפונקציונליות של מישור הבקרה, בלי לחשוף את פרטי ההטמעה של כל ישות פנימית.

משך החיים של אישורי ברירת המחדל

כברירת מחדל, אופרטור AlloyDB Omni משתמש ב-cert-manager כדי להנפיק ולחדש באופן אוטומטי אישורי TLS לאופרטור, למישור הבקרה ולמכונות של מסד הנתונים.

בטבלה הבאה מפורטים משכי התוקף שמוגדרים כברירת מחדל לאישורים שמנוהלים על ידי אופרטור AlloyDB Omni:

סוג האישור תיאור האישור שם הסוד מרחב שמות ברירת המחדל למשך הזמן
אישור לקוח mTLS של המפעיל משמש את הפריסה של local-controller-manager לבדיקות תקינות של זמינות גבוהה (HA) ולחיבורים בין המפעיל לבין סוכני מישור הבקרה. dbs-al-cert-l2-operator מרחב השמות של אופרטורים ‫1440h0m0s (60 ימים)
אישורים של שרת ה-webhook של המפעיל משמש את שרתי ה-webhook של בקרת הגישה של המפעיל כדי לאמת ולשנות משאבים בהתאמה אישית. fleet-webhook-server-cert

local-webhook-server-cert
מרחב השמות של אופרטורים ‫1440h0m0s (60 ימים)
אישורים של סוכן מישור הבקרה לכל מכונה משמש את סוכן מסד הנתונים לכל מכונה, את Node Manager ואת הדימון (daemon) של הגיבוי לחיבורים של מישור הבקרה. 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
מרחב שמות של אשכול מסד נתונים ‫1440h0m0s (60 ימים)
אישורי גיבוי משמש את שירותי הגיבוי לחיבורי גיבוי ושחזור. 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
מרחב שמות של אשכול מסד נתונים ‫1440h0m0s (60 ימים)
אישור של שרת מסד הנתונים מאבטח את החיבורים של הלקוחות במישור הנתונים למכונה של מסד הנתונים. dbs-al-cert-DB_CLUSTER_NAME מרחב שמות של אשכול מסד נתונים 87600h0m0s (10 שנים)
אישור שאילתת אימות של PgBouncer אישור לקוח של מסד הנתונים שמשמש את פריסת PgBouncer כדי להתחבר למסד הנתונים ולבצע איגום חיבורים. נוצר רק כשיוצרים משאב PgBouncer. dbs-al-pgb-cert-PGBOUNCER_NAME מרחב שמות של אשכול מסד נתונים 87600h0m0s (10 שנים)
אישורי CA בחתימה עצמית שמנוהלים על ידי המפעיל אישורי CA בסיסיים שמשמשים את המנפיקים שמוגדרים כברירת מחדל בחתימה עצמית של המפעיל, כדי לחתום על אישורים של המפעיל, של סוכן מישור הבקרה, של הגיבוי ושל שרת מסד הנתונים. 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
מרחב השמות של המפעיל ומרחב השמות של אשכול מסד הנתונים 87600h0m0s (10 שנים)

בטבלה הזו, שמות הסודות משתמשים בתווי ה-placeholder הבאים:

  • ‫INSTANCE_ID: המזהה בן 4 התווים שנוצר למכונה של מסד הנתונים.
  • ‫DB_CLUSTER_NAME: השם של המשאב ב-DBCluster.
  • ‫DATA_PLANE_ISSUER_NAME: השם של מנפיק ה-cert-manager המותאם אישית שהוגדר ב-spec.primarySpec.tls.dataPlaneCertIssuer.name, אם צוין.
  • ‫BACKUP_REPO_NAME: השם של המשאב ב-BackupRepository, אם הוא מוגדר.
  • ‫PGBOUNCER_NAME: השם של המשאב ב-PgBouncer.

הגדרת מנפיקים בהתאמה אישית

אתם יכולים להגדיר מנפיקי אישורים בהתאמה אישית לאשכול מסד הנתונים, לאופרטור AlloyDB Omni ול-PgBouncer.

כדי להגדיר מנפיק אישורים, קודם צריך ליצור מנפיק cert-manager שמשויך ל-CA שאתם רוצים שיחתום על האישורים. אפשר להשתמש באחד מסוגי המנפיקים של cert-manager או במנפיק חיצוני תואם. אופרטור AlloyDB Omni מפנה למנפיק הזה כשהוא יוצר אישורים.

מנפיקי אישורים בהתאמה אישית של cert-manager צריכים לאכלס את השדה ca.crt בסוד האישור שנוצר באמצעות אישור ה-CA הבסיסי.

אישורים של אשכולות מסדי נתונים

יש שני שדות במפרט של אשכול מסד הנתונים שבהם מגדירים את מנפיקי האישורים:

  • spec.primarySpec.tls.dataPlaneCertIssuer: הפניה למנפיק של cert-manager שמקצה אישורים למישור הנתונים. רשות האישורים המנפיקה היא הרשות שבה לקוח מסד הנתונים יכול לבטוח כדי לאמת את מסד הנתונים במהלך חיבור TLS.

  • ‫spec.primarySpec.tls.controlPlaneAgentsCertIssuer: הפניה למנפיק של cert-manager שמקצה אישורים למישור הבקרה. האישורים האלה משמשים לחיבורים פנימיים.

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

מחליפים את מה שכתוב בשדות הבאים:

  • ‫DATA_PLANE_ISSUER_NAME: השם של מנפיק ה-cert-manager שמקצה אישורים למישור הנתונים, למשל לשרת מסד הנתונים.

  • ‫DATA_PLANE_ISSUER_KIND: סוג ה-API של מנפיק ה-cert-manager. ברירת המחדל היא Issuer.

  • ‫DATA_PLANE_ISSUER_GROUP: קבוצת ה-API של המנפיק. ברירת המחדל היא cert-manager.io.

  • ‫CONTROL_PLANE_ISSUER_NAME: השם של מנפיק ה-cert-manager שמקצה אישורים של מישור הבקרה לרכיבים פנימיים.

  • ‫CONTROL_PLANE_ISSUER_KIND: סוג ה-API של מנפיק ה-cert-manager. ברירת המחדל היא Issuer.

  • ‫CONTROL_PLANE_ISSUER_GROUP: קבוצת ה-API של המנפיק. ברירת המחדל היא cert-manager.io.

אישורי מפעיל

השלבים להגדרת מנפיק cert-manager לאישורי אופרטורים תלויים בשיטה שבה משתמשים כדי להתקין את אופרטור AlloyDB Omni.

הגדרה באמצעות Helm

אם אתם מתקינים את אופרטור AlloyDB Omni בפעם הראשונה, השתמשו ב-helm install והגדירו את הערכים המתאימים. בהנחה שפעלתם לפי ההוראות לפריסת האופרטור באמצעות 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

אם כבר התקנתם את האופרטור ואתם צריכים להגדיר את מנפיק האישור, השתמשו ב-helm upgrade כדי להגדיר את הערכים המתאימים:

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

מחליפים את מה שכתוב בשדות הבאים:

  • ‫OPERATOR_VERSION: הגרסה של אופרטור AlloyDB Omni שרוצים להתקין.

  • ‫OPERATOR_CERT_ISSUER_NAME: השם של מנפיק ה-cert-manager שמקצה את אישור המפעיל, שמשמש לחיבורים פנימיים.

  • ‫OPERATOR_CERT_ISSUER_KIND: סוג ה-API של מנפיק ה-cert-manager. ברירת המחדל היא Issuer.

  • ‫OPERATOR_CERT_ISSUER_GROUP: קבוצת ה-API של המנפיק. ברירת המחדל היא cert-manager.io.

הגדרה באמצעות Operator Lifecycle Manager

אם השתמשתם ב-Operator Lifecycle Manager ‏ (OLM) כדי להתקין את אופרטור AlloyDB Omni, אתם יכולים לשנות את השדה Subscription של המשאב spec.config.env כדי להגדיר את משתני הסביבה CERT_MANAGER_ISSUER_NAME,‏ CERT_MANAGER_ISSUER_KIND ו-CERT_MANAGER_ISSUER_GROUP של האופרטור 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

מחליפים את מה שכתוב בשדות הבאים:

  • ‫OPERATOR_CERT_ISSUER_NAME: השם של מנפיק ה-cert-manager שמקצה את אישור המפעיל, שמשמש לחיבורים פנימיים.

  • ‫OPERATOR_CERT_ISSUER_KIND: סוג ה-API של מנפיק ה-cert-manager. ברירת המחדל היא Issuer.

  • ‫OPERATOR_CERT_ISSUER_GROUP: קבוצת ה-API של המנפיק. ברירת המחדל היא cert-manager.io.

אישורי PgBouncer

כדי לתמוך במנפיקים בהתאמה אישית, הבקר של PgBouncer בודק את השדה DBCluster spec.primarySpec.tls.dataPlaneCertIssuer ומשתמש בו כדי להקצות את האישור של PgBouncer. בקר PgBouncer משתמש גם במאפיינים שהוגדרו ב-spec.primarySpec.tls.dataPlaneCertRequest כדי להקצות את האישור של PgBouncer. כך אפשר לוודא ש-PgBouncer משתמש באישור מאותה רשות אישורים (CA) עם אותם מאפיינים כמו של מסד הנתונים.

הגדרת מאפייני אישור בהתאמה אישית

אתם יכולים להתאים אישית את המאפיינים של אישורי ה-TLS שנוצרו על ידי המפעיל, כמו משך הזמן של האישור, חלון החידוש, השמות החלופיים של הבעלים (SAN), השם הנפוץ והגדרת המפתח הפרטי.

אתם מגדירים מאפייני אישורים בהתאמה אישית במניפסט של DBCluster:

  • ‫spec.primarySpec.tls.dataPlaneCertRequest: מציין מאפיינים של אישורים במישור הנתונים, כולל שרת pgBackRest, שאילתת אימות של PgBouncer ואישורים של שרת מסד הנתונים.
  • ‫spec.primarySpec.tls.controlPlaneAgentsCertRequest: מציין מאפיינים להקצאת אישורים למישור הבקרה. האישורים האלה משמשים לחיבורים פנימיים.

הגדרת בקשות לאישורים

מציינים את מאפייני הבקשה בפורמט הבא:

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

מחליפים את מה שכתוב בשדות הבאים:

  • ‫DATABASE_COMMON_NAME: (אופציונלי, מישור נתונים בלבד) השם הנפוץ של אישור מסד הנתונים.
  • ‫DATABASE_DNS_NAME_1, DATABASE_DNS_NAME_2: (אופציונלי, מישור נתונים בלבד) רשימה של שמות חלופיים של בעלים (SAN) לאישור של מסד הנתונים.
  • ‫DATA_PLANE_DURATION ו-CONTROL_PLANE_DURATION: משך התוקף המבוקש של האישור כמחרוזת משך זמן – לדוגמה, 720h0m0s למשך זמן מותאם אישית של 30 יום. בכל בלוק של בקשת אישור, צריך לציין את שני השדות duration ו-renewBefore (כאשר renewBefore קטן מ-duration) או להשמיט את שניהם. אם משמיטים את שני השדות, משך הזמן שמוגדר כברירת מחדל הוא 1440h0m0s (60 ימים) לאישורים של מישור הבקרה ושל הגיבוי, ו-87600h0m0s (10 שנים) לאישורים של שרת מסד הנתונים ושל שאילתת האימות של PgBouncer.
  • ‫DATA_PLANE_RENEW_BEFORE ו-CONTROL_PLANE_RENEW_BEFORE: משך הזמן לפני התפוגה שבו cert-manager צריך להתחיל ניסיון חידוש – לדוגמה, 120h0m0s למשך חמישה ימים לפני התפוגה. בכל בלוק של בקשת אישור, צריך לציין גם את duration וגם את renewBefore (כאשר renewBefore קטן מ-duration) או להשמיט את שני השדות. אם משמיטים את שני השדות, חלון ברירת המחדל לחידוש הוא 120h0m0s (או חמישה ימים) לאישורים של מישור הבקרה ושל הגיבוי, ו-1440h0m0s (או 60 ימים) לאישורים של שרת מסד הנתונים ושל שאילתת האימות של PgBouncer.
  • ‫DATA_PLANE_ALGORITHM ו-CONTROL_PLANE_ALGORITHM: האלגוריתם של המפתח הפרטי. הערכים התקינים הם RSA,‏ ECDSA או Ed25519.
  • ‫DATA_PLANE_KEY_SIZE ו-CONTROL_PLANE_KEY_SIZE: גודל המפתח הפרטי בביטים. אם האלגוריתם הוא RSA, הערכים התקינים הם 4096 או 8192 (ברירת המחדל היא 4096). אם האלגוריתם הוא ECDSA, הערכים התקינים הם 384 או 521 (ברירת המחדל היא 384). אם האלגוריתם הוא Ed25519, המערכת מתעלמת מהגודל.
  • DATA_PLANE_ROTATION_POLICY ו-CONTROL_PLANE_ROTATION_POLICY: המדיניות שקובעת את יצירת המפתח הפרטי מחדש. הערכים התקינים הם Always או Never.

אישורי לקוח של מפעיל וגיבוי

כדי להתאים אישית את מאפייני האישור של המפעיל ושל לקוח הגיבוי (שמשותפים לכל המופעים במרחב השמות ולא מנוהלים על ידי מפרט אשכול מסד הנתונים), משנים את המשאבים המותאמים אישית של Certificate. השינויים הידניים האלה נשמרים על ידי המפעיל.

ניקוי סודות של אישורים

כשמוחקים משאב DBCluster, אופרטור AlloyDB Omni מוחק את משאבי ה-Certificate המשויכים, אבל cert-manager לא מנקה את משאבי האישורים Secret כברירת מחדל. כדי להגדיר את הבקר של cert-manager למחוק סודות כשמוחקים אישורים, קראו את המאמר Cleaning up secrets when certificates are deleted במסמכי התיעוד של cert-manager.

אם כבר מחקתם משאב של DBCluster בלי להגדיר את הניקוי האוטומטי, אתם צריכים למחוק ידנית את הסודות של האישורים שלא בשימוש:

kubectl delete secret CERTIFICATE_SECRET_NAME -n NAMESPACE

מחליפים את מה שכתוב בשדות הבאים:

  • ‫CERTIFICATE_SECRET_NAME: השם של סוד האישור שרוצים למחוק.
  • ‫NAMESPACE: מרחב השמות של אשכול מסד הנתונים.

אימות

כדי לוודא שהאופרטור Deployment תקין ושמשתני הסביבה CERT_MANAGER_ISSUER_NAME,‏ CERT_MANAGER_ISSUER_KIND ו-CERT_MANAGER_ISSUER_GROUP מוגדרים, מריצים את הפקודה הבאה:

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

כדי לוודא שמשתמשים במנפיק הנכון, בודקים את האובייקטים של Certificate באופן הבא:

kubectl get certificate -n NAMESPACE

מחליפים את NAMESPACE במרחב השמות של אשכול מסד הנתונים, או את alloydb-omni-system באישור של המפעיל.

בודקים את השדה issuerRef בפלט של כל אישור כדי לוודא שהוא תואם למנפיק המותאם אישית.

איך לטפל בתפוגה של אישור לקוח של Operator בגרסאות Operator שקודמות ל-1.8.2

בגרסאות של אופרטור AlloyDB Omni שקודמות ל-1.8.2, הפריסה של local-controller-manager שומרת במטמון בזיכרון את אישור הלקוח של dbs-al-cert-l2-operator mTLS ל-60 יום, לצורך חיבורים של בדיקת תקינות של זמינות גבוהה לסוכנים של מישור הבקרה. למרות ש-cert-manager מחדש באופן אוטומטי את הסוד של dbs-al-cert-l2-operator חמישה ימים לפני שהוא פג, הפריסה של local-controller-manager לא טוענת מחדש את האישור המחודש עד שה-Pod של המפעיל מופעל מחדש. כשתוקף האישור במטמון פג ביום ה-60, החיבורים מחדש של בדיקת התקינות נכשלים עם שגיאת tls: expired certificate, ועלולים להפעיל יתירות כשל לא מתוכננת של זמינות גבוהה.

כדי לפתור את הבעיה באופן סופי, צריך לשדרג את אופרטור AlloyDB Omni לגרסה 1.8.2 ואילך.

אם אתם לא יכולים לשדרג מיד לגרסה 1.8.2 או לגרסה חדשה יותר של המפעיל, החליפו את הסוד dbs-al-cert-l2-operator והפעילו מחדש את הפריסה local-controller-manager לפחות 10 ימים לפני שתוקף האישור יפוג. התהליך הזה לא מפעיל מחדש את ה-Pods של מסד הנתונים ולא משבש את התנועה במסד הנתונים.

לפני שמתחילים

לפני שמריצים את הסקריפט rotate_cert.sh, צריך לוודא שהסביבה עומדת בדרישות הבאות:

  • מתקינים את bash,‏ kubectl,‏ openssl ו-base64 ב-PATH.
  • מגדירים גישה לאשכול Kubernetes ומגדירים את ההקשר הפעיל של kubectl לאשכול היעד. כדי לוודא מהו ההקשר הפעיל, מריצים את הפקודה kubectl config current-context. חוזרים על התהליך הזה בכל אשכול שפועלת בו גרסת אופרטור שקודמת ל-1.8.2.
  • מוודאים שלחשבון יש הרשאות בקרת גישה מבוססת-תפקידים (RBAC) ב-Kubernetes במרחב השמות של המפעיל, שמוגדר כברירת מחדל ל-alloydb-omni-system:
    • ‫get ב-Certificate משאבים ו-Pod יומנים
    • ‫get וגם list ב-Pod משאבים
    • ‫get ו-delete בסוד dbs-al-cert-l2-operator (וגם create ו-patch כדי לשחזר סוד שגובה)
    • ‫get ו-patch בפריסה של local-controller-manager
    • ‫delete במשאבים מסוג CertificateRequest (כדי לשחזר סוד שגובה)

החלפת אישור הלקוח של המפעיל

הסקריפט rotate_cert.sh תומך בשני מצבים ובארגומנט אופציונלי של מרחב שמות, שמוגדר כברירת מחדל ל-alloydb-omni-system:

  • ‫./rotate_cert.sh check: מבצעת בדיקה לקריאה בלבד ומדפיסה את המידע הבא:
    • המספר הסידורי של האישור הנוכחי ותאריכי התוקף שלו
    • המועד האחרון המומלץ לרוטציה, 10 ימים לפני תאריך התפוגה
    • שעת ההתחלה של מאגר התגים local-controller-manager
    • סטטוס האישור בזיכרון הוא [OK] או [WARNING]
    • פקודת גיבוי של kubectl
  • ‫./rotate_cert.sh rotate: מבצע את הפעולות הבאות:
    • מחיקת הסוד dbs-al-cert-l2-operator
    • ממתינים עד ש-cert-manager ינפיק מספר סידורי חדש לאישור ויעדכן את המשאב dbs-al-cert-request-l2-operator Certificate
    • הפעלה מחדש של הפריסה של local-controller-manager
    • בודקים את היומנים של ה-Pod החדש ומדפיסים את תאריך התפוגה החדש

כדי לבדוק ולהחליף את אישור הלקוח של המפעיל, פועלים לפי השלבים הבאים:

  1. שומרים את הסקריפט הבא בקובץ בשם rotate_cert.sh, ואז הופכים את הקובץ לניתן להפעלה:

    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. מריצים את הסקריפט rotate_cert.sh במצב check כדי לבדוק את תאריך התפוגה הנוכחי של האישור, את תאריך הרוטציה המומלץ ואת סטטוס ה-operator בזיכרון:

    ./rotate_cert.sh check
    
  3. אופציונלי: מגבים את הסוד של dbs-al-cert-l2-operator לפני שמחליפים את האישור:

    kubectl get secret dbs-al-cert-l2-operator -n alloydb-omni-system \
      -o yaml > dbs-al-cert-l2-operator-backup.yaml
    
  4. אם הפלט של check מציג את הערך [WARNING], או אם התאריך הנוכחי הוא בתאריך Recommended Rotate By או לפניו, מריצים את הסקריפט rotate_cert.sh במצב rotate:

    ./rotate_cert.sh rotate
    

    מוודאים שהפלט מסתיים ב-[SUCCESS] ומוצגים בו המספר הסידורי של האישור החדש, תאריך התפוגה ותאריך הרוטציה המומלץ הבא. אם הפלט מציג את הערך [ERROR] או שהסקריפט יוצא עם סטטוס שאינו אפס, מריצים מחדש את ./rotate_cert.sh check ובודקים את יומני המפעיל על ידי הרצת kubectl logs deployment/local-controller-manager -n alloydb-omni-system -c local-manager (או -c manager בגרסאות מפעיל שקודמות ל-1.6.0).

  5. אופציונלי: אם יצרתם קובץ גיבוי בשלב 3, מחקו את קובץ הגיבוי המקומי אחרי שווידאתם שהרוטציה הצליחה, כי הקובץ מכיל את המפתח הפרטי הישן:

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

שחזור אישור שגובה

אם cert-manager לא מצליח להנפיק אישור חדש במהלך הרוטציה, ואתם צריכים לחזור לקובץ dbs-al-cert-l2-operator-backup.yaml שלא פג תוקפו, בצעו את השלבים הבאים:

  1. מוחקים את המשאב CertificateRequest של האישור dbs-al-cert-request-l2-operator שנמצא בהמתנה או נכשל, כדי ש-cert-manager לא ידחה את המפתח הפרטי ששוחזר בגלל הסיבה SecretMismatch ויחליף את ה-Secret ששוחזר:

    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. מסירים את השדות metadata.resourceVersion ו-metadata.uid ברמה העליונה מהקובץ dbs-al-cert-l2-operator-backup.yaml ומחילים את הסוד באמצעות החלה בצד השרת:

    grep -vE '^  (resourceVersion|uid):' dbs-al-cert-l2-operator-backup.yaml \
      | kubectl apply --server-side --force-conflicts -f -
    
  3. מפעילים מחדש את הפריסה של local-controller-manager כדי לטעון את האישור ששוחזר לזיכרון:

    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. מריצים את הסקריפט rotate_cert.sh במצב check כדי לוודא שהערך של Certificate Serial תואם למספר הסידורי של האישור שגובה, ושהסקריפט מדווח על [OK]:

    ./rotate_cert.sh check
    

    האישור ששוחזר שומר על תאריך התפוגה המקורי שלו, כך שעדיין צריך להחליף את האישור בתאריך Recommended Rotate By או לפניו.

  5. אחרי שמוודאים שהשחזור בוצע, מוחקים את קובץ הגיבוי המקומי:

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