יישום של GitOps בעזרת Argo CD

מדריכים
Git Kubernetes

הקדמה

Argo CD הוא מימוש פתוח פופולרי עבור ביצוע של משלוח רציף באמצעות GitOps על בסיס Kubernetes. יישומים, הגדרות, תצורות וסביבות שלך צריכים להיות מצהירים ובאחסון גרסאות. גם פרסום יישום וניהול מחזור החיים של היישום צריכים להיות ממומנים, ברורים לסקירה וקלים להבנה. כל זה ניתן לעשות באמצעות Argo.

Argo CD נאמן לתבניות ולעקרונות ה-GitOps הכל זה תוך שמירה על מצב האשכול שלך באמצעות גישה מצהירה. סנכרון מתרחש דרך תיק גיט, בו מאוחסן מנפצי ה-Kubernetes שלך. ניתן לציין מנפצי Kubernetes בכמה דרכים:

כמו כל אפליקציה שרצה באשכול Kubernetes, Argo CD מוגדרת דרך הגדרות משאבים מותאמות אישית (CRDs) המאוחסנות בתוך רפרסנטציות YAML. הכי חשובה מביניהן היא ה-CRD Application. באפליקציה של Argo CD, אתה מגדיר איזה גיט ריפוזיטורי יש להשתמש לסנכרון עם איזה אשכול Kubernetes. זה יכול להיות אותו אשכול Kubernetes בו הותקן Argo CD, או אחד חיצוני.

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

Argo CD מציעה מספר יכולות, המשמעותיות ביותר מהן הן:

  • תמיכה בכלים לניהול הגדרות/ערכים מרובים, כגון: Kustomize, Helm, Ksonnet, Jsonnet, plain-YAML.
  • יכולת לנהל ולפרסם לאשכולים מרובים.
  • אינטגרציית SSO (OIDC, OAuth2, LDAP, SAML 2.0, GitHub, GitLab, Microsoft, LinkedIn).
  • רב-שכבתיות ומדיניות RBAC לאוטוריזציה.
  • ניתוח סטטוס בריאות של משאבי האפליקציה.
  • עתור/עתירו אל כל הגדרת אפליקציה שנרשמה במאגר Git.
  • איתור תגובת הגדרה אוטומטית ותצוגה גרפית.
  • ממשק משתמש באינטרנט שמספק תצוגה בזמן אמת של פעילות האפליקציה.
  • סי.אל.איי עבור אוטומציה ואינטגרציה של סי.איי.
  • אינטגרציה של וובהוק (גיטהאב, ביטבאקט, גיטלאב).
  • תגיות פריסה מראש, פריסה, פוסט-פריסה לתמוך בפרסומיות מורכבות של הפרקות האפליקציה (לדוגמה, שדרוגי כחול/ירוק וקנרי).
  • מדדי Prometheus.

במדריך הזה, תלמד/י:

  • להשתמש ב־Helm לספק את Argo CD לערכת ה-DOKS שלך.
  • לשמור על סנכרון מצב אפליקציות ערכת Kubernetes שלך עם מאגר Git (להשתמש בעקרונות GitOps).
  • להפעיל ולנהל אפליקציות באמצעות Argo CD.

לאחר שתסיים/י את כל השלבים במדריך הזה, תהיה/י עם ערכת DOKS שלך, עם Argo CD מפורסם, שיעשה/תפעיל:

  • טיפול בסינכרון עם ערכות CRD של האפליקציה. טיפול בשחרורי Helm, באמצעות מקורות Helm שמוגדרים בתוך CRD של האפליקציה.

סקירה של DOKS ו-Argo CD עבור שחרורי Helm

התרשים למטה מציג איך Argo CD ניהלת אפליקציות Helm שמתחסנות באמצעות מאגר Git:

תוכן עניינים

דרישות מוקדמות

כדי להשלים את המדריך הזה, תצטרך:

  1. A working DOKS cluster that you have access to. Please follow the Starter Kit DOKS Setup Guide to find out more.to find out more.
  2. A GitHub repository and branch, to store Argo CD and your applications manifests. Must be created beforehand.
  3. A Git client, for cloning the Starter Kit repository.
  4. Kubectl CLI, לאינטראקציה עם Kubernetes. עקוב אחרי ההוראות האלה כדי להתחבר לאשכול שלך עם kubectl ו- doctl.
  5. Argo CLI, לאינטראקציה עם Argo CD באמצעות ממשק שורת פקודה.
  6. Kubeseal, להצפנת סודות ולאינטראקציה עם Sealed Secrets Controller.
  7. Helm, לניהול שחרורים ושדרוגים של Argo CD (אופציונלי, אך מומלץ בדרך כלל למערכות הפקודה).

הבנת עקרונות Argo CD עבור התקנת אפליקציות

Argo CD משתמש בעקרון היסוד של יישום כדי לנהל את הפיתוח ומחזור החיים של יישומים. בתוך רישום יישום של Argo CD, אתה מגדיר את מאגר ה-Git שבו מאוחסנות הגדרות היישום שלך, כמו גם את האשכול התואם של Kubernetes לפרסום היישומים. במילים אחרות, יישום של Argo CD מגדיר את הקשר בין מאגר מקור (Git) לבין אשכול Kubernetes. זו תכנות מאוד קצרה ונפתחת, שבה תוכל לקשור מקורות מרובים (מאגרי Git) ואשכולות Kubernetes תואמים.

A major benefit of using applications is that you don’t need to deploy Argo to each cluster individually. You can use a dedicated cluster for Argo, and deploy applications to all clusters at once from a single place. This way, you avoid Argo CD downtime or loss, in case other environments have issues or get decommissioned.

מעבר לכך, ניתן לקבץ יישומים דומים לתוך פרויקט. פרויקטים מאפשרים קיבוץ לוגי של יישומים ותפקידים/הרשאות משויכים כאשר עובדים עם מספר קבוצות. כאשר לא מצויין, כל יישום חדש משוייך לפרויקט default. פרויקט ה-default נוצר באופן אוטומטי ואין לו מגבלות. ניתן לשנות את פרויקט הברירת מחדל, אך לא למחוקו.

ערכת ההתחלה משתמשת בפרויקט default לקפיצת התחלה מהירה באמצעות Argo CD. לאחר מכן, תלמד כיצד ליצור יישום עבור כל רכיב של ערכת ההתחלה, ולהשתמש ב־גרפים Helm כמקור היישום. Argo CD אינו מוגבל למקורות Helm בלבד, ותוכל גם לנצל את הכוח של Kustomize, Ksonnet, Jsonnet, וכו'. אנא ראה את דף מקורות היישום לפרטים נוספים.

אף על פי שתוכל להשתמש בממשק משתמש גרפי (ממשק אינטרנטי) של Argo CD כדי ליצור יישומים, ערכת ההתחלה מתבססת על דרך ההגדרה הדקלרטיבית של GitOps, באמצעות קבצי YAML. כל הגדרת YAML פועלת כמתכון לכל יישום, ולכן ניתן לאחסן אותו במאגר Git. זה אומר שתוכל ליצור מחדש תמיד את ההגדרה שלך ב־Argo CD אם תיצור מחדש את הסביבה שלך, או תעבור לקבוצה אחרת. יותר חשוב, תוכל לבצע בדיקות ולעקוב אחר כל שינוי דרך היסטוריית ה־Git. זו הפרקטיקה הטובה ביותר גם להפעיל את קבצי ההגדרה של Argo CD במאגר Git נפרד, מאשר באחד המשמש לפיתוח היישום שלך. תוכל לקרוא את דף הפרקטיקות הטובות מאתר תיעוד הרשמי של Argo CD למידע נוסף על הנושא.

הערה חשובה:
נקודה חשובה לשים לב אליה היא שברירת מחדל Argo CD לא מסנכרנת אוטומטית את היישומים החדשים שלך. כאשר יישום של ArgoCD נוצר לראשונה, המצב שלו הוא OutOfSync. זה אומר שהמצב של מאגר ה-Git שמצביע עליו היישום של ArgoCD אינו תואם למצב האשכול של Kubernetes. יצירת יישום חדש של ArgoCD לא מפעילה הרצה אוטומטית על האשכול היעד.

כדי לאפשר סנכרון אוטומטי ומחיקת משאבים נטושים (צמיחה), עליך ליצור syncPolicy. ניתן גם להגדיר את Argo CD כך שיבטל אוטומטית שינויים ידניים שנעשו באמצעות kubectl. ניתן לקרוא עוד על מדיניות הסנכרון האוטומטית באתר התיעוד הרשמי.

תצורת Application CRD רגילה באמצעות מקור מאגר Git נראית כמו בהמשך:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-apps
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/myrepo/my-apps.git
    targetRevision: HEAD
    path: apps
  destination:
    server: https://kubernetes.default.svc
    namespace: my-apps
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

הסברים להגדרה לעיל:

  • spec.project: מספר ל- Argo CD איזה פרויקט להשתמש בו עבור היישום (default בדוגמה זו).
  • spec.source.repoURL: כתובת URL של מאגר ה-Git המשמש לסנכרון מצב האשכול.
  • spec.source.targetRevision: גרסת מאגר ה-Git שמשמשת לסנכרון (יכולה להיות שם של ענף או תג כמו כן).
  • spec.source.path: נתיב במאגר ה-Git בו מאוחסנים קבצי המקור (מניפסטים YAML).
  • spec.destination.server: כתובת אשכול Kubernetes יעד. כמעט תמיד מצביעה על https://kubernetes.default.svc, אם Argo CD משתמשת באותו אשכול שבו הוא מותקן.
  • spec.destination.namespace: רווח שמות של Kubernetes לשימוש ביישום שלך.
  • spec.syncPolicy.automated: מאפשר סנכרון אוטומטי של יישומים באשכול שלך עם מאגר Git.
  • spec.syncPolicy.automated.prune: פורום מציין האם למחוק משאבים מהאשכול שאינם נמצאים עוד במקורות כחלק מהסנכרון האוטומטי.
  • spec.syncPolicy.automated.selfHeal: מציין האם להחזיר משאבים למצבם הרצוי לאחר שינוי ידני באשכול (לדוגמה באמצעות kubectl).

ניתן גם להשתמש במאגרי Helm כמקור להתקנת יישומים באשכול שלך. דוגמת Application CRD סטנדרטית המשתמשת במאגר מרכזי של Helm נראית כמו מטה (דומה לדוגמה של מאגר Git, רק שמשתמשים במאגר מסוג Helm):

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: sealed-secrets
  namespace: argocd
spec:
  project: default
  source:
    chart: sealed-secrets
    repoURL: https://bitnami-labs.github.io/sealed-secrets
    targetRevision: 2.4.0
    helm:
      releaseName: sealed-secrets
      values: |
        replicaCount: 2
  destination:
    server: "https://kubernetes.default.svc"
    namespace: kubeseal

הסברים להגדרות מעלה:

  • spec.source.chart: תרשים של Helm לשימוש כמקור ליישום.
  • spec.source.repoURL: כתובת URL של מאגר תרשים של Helm.
  • spec.source.targetRevision: גרסת תרשים של Helm לשימוש ביישום.
  • spec.source.helm.releaseName: שם של השחרור של Helm ליצירה באשכול Kubernetes שלך.
  • spec.source.helm.values: מציין ערכי Helm להעברה לתבנית של helm, מוגדרת כלפי רוב כבלוק.
  • spec.destination.server: כתובת של שרת האשכול היעד. נקודת יעד נמצאת בדרך כלל ב- https://kubernetes.default.svc, אם Argo CD משתמשת באשכול זהה שבו הוא מותקן.
  • spec.destination.namespace: מרחב השמות Kubernetes שיש להשתמש בו עבור היישום שלך.

נא להמשיך ולקרוא עוד על מושגים המרכזיים של Argo CD באתר התיעוד הרשמי. לאחר מכן, תגלה את האפשרויות להתקנה הזמינות כדי להעלות את Argo CD בקשר Kubernetes שלך.

התקנת Argo CD

ניתן להתקין את Argo CD באמצעות kubectl, או באמצעות Helm:

  1. שימוש ב־kubectl וקובץ תצורה להתקנה. שיטה זו אינה מציעה שליטה ישירה על פרמטרי ההתקנה השונים. אם אינך מכיר יישום ההתקנה של Helm, זו האפשרות הכי ישירה להתחיל איתה.
  2. התקנה באמצעות Helm. מציע יותר שליטה נגד התקנת היישום Argo CD ובמחזור חיי הקיום שלו. מומלץ עבור הגדרות HA (גישה גבוהה) ואם נעשה שימוש ב־Argo CD בסביבה production.

לאחר מכן, תלוי בתכונות שברצונך שיהיו זמינות, יש לך שני אפשרויות:

  • מצב Multi-Tenant. סוג התקנה זה נהוג לשירות צוותי מפתחי יישומים מרובים בארגון ונחזק על ידי צוות פלטפורמה. המשתמשים הסופיים יכולים לגשת אל Argo CD דרך שרת ה־API באמצעות ממשק ה־Web UI או את הפקודה argocd.
  • ציד הליבה בלבד. זהו מותקן מצומצם, ללא ממשק משתמש גרפי, שרת API, SSO וכו', ומתקין את גרסת המשקול הקלה (לא-HA) של כל רכיב.

מערכת ההתחלה משתמשת במצבי רבי דיירים ו־גבוה זמינות להתקנת Argo CD בקשת DOKS שלך. בכך, תהיה לך הגדרה אמינה ותוכל לחקור את כל התכונות הזמינות, כולל הממשק המשתמש. אנא בקר בדף התיעוד על שיטות ההתקנה לקבלת מידע נוסף על הנושא.

התקנת על ידי Kubectl

שיטה זו דורשת את kubectl, והיא תהליך משני שלבים:

  1. צור מרחב שמות, כדי להתקין את Argo CD עצמו.
  2. הפעל את קובץ ההתקנה של HA, דרך kubectl.

אנא הריץ את הפקודות הבאות בסדר:

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

כעת, אנא המשך ובדוק אם ההתקנה הצליחה. תחילה, בדוק אם כל ההתקנות של Argo CD הן בריאותיות:

kubectl get deployments -n argocd

הפלט דומה למסך הבא (בדוק את העמודה READY – כל Pods חייבים להיות רצים):

Output
NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
argocd-applicationset-controller   1/1     1            1           51s
argocd-dex-server                  1/1     1            1           50s
argocd-notifications-controller    1/1     1            1           50s
argocd-redis-ha-haproxy            3/3     3            3           50s
argocd-repo-server                 2/2     2            2           49s
argocd-server                      2/2     2            2           49s

השרת של Argo CD חייב לקבל את הערך המינימלי של replicaset בגודל של 2 עבור מצב HA. אם מסיבה כלשהי ישנן התקנות שאינן בריאותיות, אנא בדוק אירועי Kubernetes ויומני רישום עבור פודים המושפעים.

התקנת Helm-Based

שיטה זו מחייבת את התקנת Helm על המחשב המקומי שלך. הערכת ההתחלה מספקת קובץ ערכות של Helm מוכן לשימוש כדי להתחיל, ומתקין את Argo CD במצב HA (ללא התנגדות אוטומטית).

אנא עקוב אחר השלבים הבאים כדי להשלים את ההתקנה המבוססת על Helm:

  1. ראשית, שכפול את ספריית ערכת ההתחלה (אם עדיין לא), ושנה את התיקייה להעתקתך המקומית:
git clone https://github.com/digitalocean/Kubernetes-Starter-Kit-Developers.git
cd Kubernetes-Starter-Kit-Developers
  1. לאחר מכן, הוסף את ספריית Helm של Argo CD:
helm repo add argo https://argoproj.github.io/argo-helm
helm repo update argo
  1. עכשיו, חפש במאגר ה-Helm של argo תרשים זמין להתקנה:
helm search repo argo

הפלט דומה לכך:

Output
NAME                            CHART VERSION   APP VERSION     DESCRIPTION 
argo/argo                       1.0.0           v2.12.5         A Helm chart for Argo Workflows  
argo/argo-cd                    4.9.4           v2.4.0          A Helm chart for Argo CD, a declarative, GitOps...
...
  1. אז, פתח ובדוק את קובץ ערכות ה-Helm של Argo CD המסופק במאגר ערכת ההתחלה בעזרת עורך לבחירתך (מומלץ תומך ב־YAML lint). לדוגמה, תוכל להשתמש ב־VS Code:
code 14-continuous-delivery-using-gitops/assets/manifests/argocd/argocd-values-v4.9.4.yaml
  1. לבסוף, הפעל את Argo CD בקבוצת ה-DOKS שלך:
HELM_CHART_VERSION="4.9.4"
helm install argocd argo/argo-cd --version "${HELM_CHART_VERSION}" \
  --namespace argocd \
  --create-namespace \
  -f "14-continuous-delivery-using-gitops/assets/manifests/argocd/argocd-values-v${HELM_CHART_VERSION}.yaml"

–create-namespace \

הערה:השתמשנו ב-גרסה ספציפית של תרשים ה-Helm. במקרה זה, בחרנו ב-4.9.4, המתאימה לגרסת היישום 2.4.0. זהו נוהג נכון בכלל, לנעול על גרסה ספציפית. זה מסייע לקבל תוצאות צפויות, ומאפשר בקרה על גרסאות דרך Git.

helm ls -n argocd

כעת, בדוק האם השחרור של Helm הצליח:

NAME    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART           APP VERSION
argocd  argocd          1               2022-03-23 11:22:48.486199 +0200 EET    deployed        argo-cd-4.9.4   v2.4.0

הפלט דומה ל-(ערך העמודה STATUS צריך להיות מוגדר ל-deployed):

kubectl get deployments -n argocd

לבסוף, ודא סטטוס פרישת האפליקציה של Argo CD:

Output
NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
argocd-applicationset-controller   1/1     1            1           2m9s
argocd-dex-server                  1/1     1            1           2m9s
argocd-notifications-controller    1/1     1            1           2m9s
argocd-redis-ha-haproxy            3/3     3            3           2m9s
argocd-repo-server                 2/2     2            2           2m9s
argocd-server                      2/2     2            2           2m9s

הפלט דומה ל-(בדוק את העמודה READY – כל Pods חייבים להיות פועלים):

השרת של Argo CD חייב להיות עם ערך מינימלי של replicaset של 2 עבור מצב HA. אם, מסיבה מסוימת, יישומים כלשהם אינם בריאים, יש לבדוק את אירועי Kubernetes ולוגים עבור קופוננטות ה- Pods המושפעות.

ניתן גם למצוא מידע נוסף על תרשים ה- Helm של Argo CD על ידי גישה ל-מאגר התומך בקהילה.

הבא, תלמד כיצד לגשת ולחקור את התכונות העיקריות של ממשק המשתמש הגרפי שסופק על ידי Argo CD.

גישה וחקירה של ממשק האינטרנט של Argo CD

אחת התכונות המעניינות שיש ל- Argo CD להציע היא הממשק האינטרנטי, המשמש לביצוע מגוון משימות מנהליות שונות ולצפייה במצב ההתקנה של האפליקציה. ניתן ליצור אפליקציות באמצעות ממשק המשתמש הגרפי ולפעול עם Argo CD בדרכים שונות. תכונה חשובה נוספת היא היכולת לבדוק את מצב היישום כל אחד ולגשת לאירועי Kubernetes, כמו גם ליישומים שלך. מעל כך, Argo CD מספק מיוצג ויזואלי של כל אובייקטי Kubernetes (replicasets, pods, וכו ') שיש בכל התקנה של אפליקציה.

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

ניתן לגשת לממשק האינטרנטי על ידי פתיחת צינור התקשורת לשירות Kubernetes של argocd-server. יש להריץ את הפקודה הבאה בטרמינל:

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo

עכשיו, פתחו דפדפן אינטרנט ונווטו אל localhost:8080 (אנא התעלמו מתעודות TLS לא חוקיות לעכשיו). תתקבלו בדף התחברות של Argo CD. שם משתמש ברירת המחדל למנהל הוא admin, והסיסמה נוצרת אקראית בזמן ההתקנה. ניתן לקבל אותה על ידי הרצת הפקודה הבאה:

לאחר מכן, תועברו לדף לוח המחוונים של האפליקציות. מכאן, ניתן להציג, ליצור או לנהל אפליקציות דרך ה-UI (עורך YAML זמין גם), כמו גם לבצע פעולות סנכרון או רענון:

אם תלחצו על כל אריח אפליקציה, תוצג גם מיוצג ויזואלי של כל האובייקטים המעורבים:

בסעיף הבא, ניתן לנהל את פרויקטי האפליקציות שלך, מאגרי הקוד והאשכולות:

לבסוף, סעיף מידע המשתמש מציג את המשתמשים הזמינים ומאפשר עדכון של סיסמת המנהל:

ניתן לשחק סביב ולחקור כל קטע ותת-קטע בפרט כדי לראות את כל התכונות הזמינות. למעבר לשימוש ב-CLI המתאים, הנקרא argocd.

מכירת ה-CLI של Argo CD

argocd
Usage:
  argocd [flags]
  argocd [command]

Available Commands:
  account     Manage account settings
  admin       Contains a set of commands useful for Argo CD administrators and requires direct Kubernetes access
  app         Manage applications
  cert        Manage repository certificates and SSH known hosts entries
  cluster     Manage cluster credentials
  completion  output shell completion code for the specified shell (bash or zsh)
  context     Switch between contexts
  gpg         Manage GPG keys used for signature verification
  help        Help about any command
...

Argo CD מאפשר את אותם סט תכונות להשתמש בהם באמצעות ממשק האינטרנט או דרך CLI. כדי להשתמש ב-CLI של argocd, עליך לפתוח חלון של סל שונה ופשוט להקליד argocd בלי שום ארגומנטים. באופן ברירת מחדל, הוא יציג את הפקודות והאפשרויות הזמינות:

argocd app --help

לכל פקודה או תת-פקודה, ניתן לקרוא את דף העזרה המתאים באמצעות התבנית הבאה: argocd <פקודה/תת-פקודה> --help. לדוגמה, אם ברצונך לבדוק אילו אפשרויות זמינות עבור הפקודה app:

Manage Applications
Usage:
  argocd app [flags]
  argocd app [command]

Examples:
  הפלט דומה למטה:
  argocd app list
  
  # רשימת כל היישומים.
  argocd app get my-app
...

# לקבל את הפרטים של אפליקציה

אנא המשך ובחן פקודות/תת-פקודות אחרות כדי לראות את כל האפשרויות הזמינות. למעבר לכך, תלמד כיצד לספק יישום ראשון של Argo CD, אשר יפעיל באופן אוטומטי את כל רכיבי ערכת ההתחלה.

הפעלת יישומים של Argo CD באמצעות Bootstrapping

בהתקנה חדשה, Argo CD לא מכיר את מקום הסנכרון של היישומים שלך או אילו מאגרי Git זמינים למקור המניינים של היישומים. לכן, השלב הראשון הוא לבצע פעולה חד פעמית הנקראת Bootstrapping. באפשרותך לבצע את כל הפעולות שמוצגות בסעיף זה באמצעות כלי ה-CLI של argocd או ממשק המשתמש הגרפי.

ישנם מספר דרכים שונות לבצע את Bootstrapping של האשכול שלך (לדוגמה, באמצעות סקריפטים), אך בדרך כלל, משתמשי Argo CD משתמשים בתבנית יישום של יישומים. זו אומרת שתתחיל ביצירת יישום הורה באמצעות CLI של argocd (או ממשק האינטרנט), שיפנה ויפעיל את שאר היישומים באשכול הקוברנטיס שלך.

הכנת מבנה תיקיית מאגר Git

clusters
└── dev
    └── helm
        ├── cert-manager-v1.8.0.yaml
        ├── nginx-v4.1.3.yaml
        ├── prometheus-stack-v35.5.1.yaml
        ├── sealed-secrets-v2.4.0.yaml
        └── velero-v2.29.7.yaml

יש תחילה להכין את מבנה התיקייה שלך במאגר Git כך שיהיה בו מבנה עקבי. בדוגמה הבאה, תיצור מבנה של מאגר Git הדומה למטה:

  1. אנא פתח טרמינל ועקוב אחר השלבים הבאים כדי ליצור את המבנה של מאגר Git שלך:
git clone <YOUR_ARGOCD_GIT_REPOSITORY_ADDRESS>
  1. ראשית, שכפל את מאגר ה-Git שלך שמשמש לבדיקת Argo CD (ודא כי תחליף את המציינים <> בהתאם):
cd <YOUR_GIT_REPO_LOCAL_COPY_DIRECTORY>
mkdir -p clusters/dev/helm
  1. לאחר מכן, שנה את התיקייה לעותק המקומי שלך וצור את מבנה התיקיות (ודא כי תחליף את המציינים <> בהתאם):
CERT_MANAGER_CHART_VERSION="1.8.0"
NGINX_CHART_VERSION="4.1.3"
PROMETHEUS_CHART_VERSION="35.5.1"
SEALED_SECRETS_CHART_VERSION="2.4.0"
VELERO_CHART_VERSION="2.29.7"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/cert-manager-v${CERT_MANAGER_CHART_VERSION}.yaml" > "clusters/dev/helm/cert-manager-v${CERT_MANAGER_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/nginx-v${NGINX_CHART_VERSION}.yaml" > "clusters/dev/helm/nginx-v${NGINX_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/prometheus-stack-v${PROMETHEUS_CHART_VERSION}.yaml" > "clusters/dev/helm/prometheus-stack-v${PROMETHEUS_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/sealed-secrets-v${SEALED_SECRETS_CHART_VERSION}.yaml" > "clusters/dev/helm/sealed-secrets-v${SEALED_SECRETS_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/velero-v${VELERO_CHART_VERSION}.yaml" > "clusters/dev/helm/velero-v${VELERO_CHART_VERSION}.yaml"
  1. העתק את מנגנוני היישום המסופקים לכל רכיב במאגר ה-Starter Kit (תוכל גם להסתכל ולראות איך כל מנגנון מאוגד):

לבסוף, הגש את השינויים ודחוף אל המקור.

לאחר מכן, תיצור את התפריט העליון של היישום ההורה ותאפשר ל- Argo CD לסנכרן את כל יישומי ה-Starter Kit באופן אוטומטי לאשכול DOKS שלך.

שימוש בתבנית היישום של היישום דרך ה-CLI של Argo CD

בסעיף זה, תלמד כיצד להשתמש ב-CLI של argocd כדי ליצור ולהשתמש בתבנית app of apps כדי להפעיל את כל רכיבי ה-Starter Kit באשכול DOKS שלך. התמונה למטה ממחישה את המושג העיקרי:

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

ראשית, עליך להעביר פנים את שרת הראשי של Argo CD על מחשב המקומי שלך בחלון טרמינל נפרד:

ADMIN_USER="admin"
ADMIN_PASSWD="$(kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d)"
argocd login localhost:8080 --username $ADMIN_USER --password $ADMIN_PASSWD --insecure

השלב הבא הוא לגשת לשרת API של Argo CD כדי לאפשר ל-CLI של argocd לעבוד. באמצעות חלון טרמינל נוסף, עליך לאמת את הלקוח של argocd עם מופע השרת שלך של Argo CD: 

Output
'admin:login' logged in successfully
Context 'localhost:8080' updated

הפלט נראה דומה ל: 

argocd app create starter-kit-apps \
    --dest-namespace argocd \
    --dest-server https://kubernetes.default.svc \
    --repo https://github.com/<YOUR_GITHUB_USERNAME>/<YOUR_ARGOCD_GITHUB_REPO_NAME>.git \
    --path clusters/dev/helm

לאחר מכן, אנא הריץ את הפקודה הבאה כדי ליצור את אפליקציית ההורה starter-kit-apps (ודא שאתה מחליף את המילים המצוינות בתפקידן):

  • –dest-namespace argocd \
  • –dest-server https://kubernetes.default.svc \
  • הפקודה לעיל תיצור אפליקציה חדשה של Argo CD בשם starter-kit-apps בשטח השמור argocd, מוגדרת ל:

לגעת באותו אשכול Kubernetes שבו נתקבל Argo CD, מכיוון שה---dest-server מוגדר כ-https://kubernetes.default.svc. 

argocd app sync starter-kit-apps

להשתמש במאגר GitHub שמוגדר על ידי הארגומנט --repo כדי לסנכרן את האשכול שלך. 

Output
TIMESTAMP                  GROUP        KIND             NAMESPACE   NAME                       STATUS     HEALTH  ...
2022-03-23T17:39:38+02:00  argoproj.io  Application      argocd      sealed-secrets-controller  OutOfSync  Missing ...            
2022-03-23T17:39:38+02:00  argoproj.io  Application      argocd      velero                     OutOfSync  Missing ...             
2022-03-23T17:39:38+02:00  argoproj.io  Application      argocd      ingress-nginx              OutOfSync  Missing ...
...
GROUP        KIND         NAMESPACE  NAME                       STATUS  HEALTH  HOOK  MESSAGE
argoproj.io  Application  argocd     sealed-secrets-controller  Synced                application.argoproj.io/sealed-secrets-controller created
argoproj.io  Application  argocd     ingress-nginx              Synced                application.argoproj.io/ingress-nginx created
argoproj.io  Application  argocd     kube-prometheus-stack      Synced                application.argoproj.io/kube-prometheus-stack created
argoproj.io  Application  argocd     velero                     Synced                application.argoproj.io/velero created
argoproj.io  Application  argocd     cert-manager               Synced                application.argoproj.io/cert-manager created

לסרוק ולהחיל את כל מאפייני האפליקציה שנמצאים בתיקיית clusters/dev/helm (--path ארגומנט).

לאחר מכן, עליך לסנכרן את האפליקציה starter-kit-apps (שים לב ש-Argo CD לא מסנכרן דברים באופן ברירת מחדל אלא אם כן נצוין): 

argocd app list

הפלט נראה דומה ל:

Output
NAME                       CLUSTER                         NAMESPACE       PROJECT  STATUS     HEALTH   SYNCPOLICY  ...
ingress-nginx              https://kubernetes.default.svc  ingress-nginx   default  OutOfSync  Missing  Auto-Prune  ...
cert-manager               https://kubernetes.default.svc  cert-manager    default  OutOfSync  Missing  Auto-Prune  ...
kube-prometheus-stack      https://kubernetes.default.svc  monitoring      default  OutOfSync  Missing  Auto-Prune  ...
sealed-secrets-controller  https://kubernetes.default.svc  sealed-secrets  default  OutOfSync  Missing  Auto-Prune  ...
starter-kit-apps           https://kubernetes.default.svc  argocd          default  Synced     Healthy  <none>      ...  
velero                     https://kubernetes.default.svc  velero          default  OutOfSync  Missing  Auto-Prune  ...

לאחר שהפקודה הנ"ל מסתיימת, תראו אפליקציה חדשה בלוח המחוונים הראשי של שרת ה-Argo CD שלכם. אנא פתחו דפדפן אינטרנט ונווטו אל http://localhost:8080. לאחר מכן בחרו בלשונית Applications, ולחצו על פסיפס ה-starter-kit-apps (שימו לב לתבנית ה-app of apps על ידי הצגת גרף ההרכב):

argocd app sync -l argocd.argoproj.io/instance=starter-kit-apps

תוכלו גם לבדוק את האפליקציות החדשות דרך CLI:

הפלט דומה למה שבתמונה:

argocd app list

האפליקציה האב starter-kit-apps תופיע כתואמת אך האפליקציות הבנות יהיו לא תואמות. לאחר מכן, תוכלו לסנכרן הכל באמצעות ממשק האינטרנט או דרך CLI:

Output
NAME                       CLUSTER                         NAMESPACE       PROJECT  STATUS    HEALTH   SYNCPOLICY  CONDITIONS ...
ingress-nginx              https://kubernetes.default.svc  ingress-nginx   default  Synced    Healthy  Auto-Prune  <none>     ...
cert-manager               https://kubernetes.default.svc  cert-manager    default  Synced    Healthy  Auto-Prune  <none>     ...
kube-prometheus-stack      https://kubernetes.default.svc  monitoring      default  Synced    Healthy  Auto-Prune  <none>     ...
sealed-secrets-controller  https://kubernetes.default.svc  sealed-secrets  default  Synced    Healthy  Auto-Prune  <none>     ...
starter-kit-apps           https://kubernetes.default.svc  argocd          default  Synced    Healthy  <none>      <none>     ...
velero                     https://kubernetes.default.svc  velero          default  OutOfSync Missing  Auto-Prune  SyncError  ...

פעולת הסנכרון עשויה לקחת זמן להשלמה (אפילו עד 5-10 דקות), תלוי במורכבות ובמספר העצמים של כל האפליקציות המוצגות.

לאחר זמן מה, אנא רשמו שוב את כל האפליקציות:

argocd app create starter-kit-apps \
  --dest-namespace argocd \
  --dest-server https://kubernetes.default.svc \
  -repo https://github.com/<YOUR_GITHUB_USERNAME>/<YOUR_ARGOCD_GITHUB_REPO_NAME>.git \
  --path clusters/dev/helm \
   --sync-policy automated \
  --auto-prune \
  --self-heal
  • הפלט דומה למה שנמצא בתמונה (שימו לב שכל האפליקציות תואמות כעת):
argocd app get velero

התקנת אפליקציית Velero תיכשל ותישאר במצב SyncError מכוון שכישלון זה מתוכנן כחלק מתרגול של הקורא להכיר וללמוד כיצד לאבחן בעיות באפליקציות ב-Argo CD. אנא עיין בחלק הנקודות מידה (Hints) למטה כדי לראות כיצד לאבחן בעיות של אפליקציות ב-Argo CD.
הקמת האפליקציה האב נעשית פעם אחת בלבד. בשינויים ב-Git לאחר מכן עבור כל אפליקציה, Argo CD יזהה את השינויים ויחיל את השינויים הנדרשים. Argo CD משתמש במנגנון polling mechanism כברירת מחדל כדי לזהות שינויים במאגר Git שלך. המרווח הרענון המוגדר כברירת מחדל הוא 3 דקות. במקום לסמוך על מנגנון זימון, תוכל גם להשתמש ביתרונותו של פקודות האפשרויות של Git. אנא בקר באתר התיעוד הרשמי כדי ללמוד כיצד ליצור ולהגדיר את Argo CD לשימוש ב-webhooks.

Output
 Name:               velero
Project:            default
Server:             https://kubernetes.default.svc
Namespace:          velero
URL:                https://argocd.example.com/applications/velero
Repo:               https://vmware-tanzu.github.io/helm-charts
Target:             2.27.3
 Path:               
SyncWindow:         Sync Allowed
Sync Policy:        Automated (Prune)
Sync Status:        OutOfSync from 2.27.3
Health Status:      Missing
CONDITION  MESSAGE                                                                                          LAST TRANSITION
SyncError  Failed sync attempt to 2.27.3: one or more objects failed to apply (dry run) (retried 5 times).  2022-03-24 12:14:21 +0200 EET
 GROUP                      KIND                      NAMESPACE  NAME                               STATUS     HEALTH      HOOK      MESSAGE
velero.io                  VolumeSnapshotLocation    velero     default                            Failed     SyncFailed  PostSync  error validating data: ValidationError(VolumeSnapshotLocation.spec): missing required field "provider" in io.velero.v1.VolumeSnapshotLocation.spec
velero.io                  BackupStorageLocation     velero     default                            Failed     SyncFailed  PostSync  error validating data: [ValidationError(BackupStorageLocation.spec.objectStorage): missing required field "bucket" in io.velero.v1.BackupStorageLocation.spec.objectStorage, ValidationError(BackupStorageLocation.spec): missing required field "provider" in io.velero.v1.BackupStorageLocation.spec]
...

Hints: אם מתכוונים, ניתן להגדיר את האפליקציה האב לסנכרן באופן אוטומטי (וגם לאפשר ריפוי עצמי והסרה אוטומטית), אפשר להשתמש בפקודה הבאה (אל תשכח להחליף את המילות מפתח <> לפי הצורך):

–dest-namespace argocd \

–dest-server https://kubernetes.default.svc \

–sync-policy automated \

–auto-prune \

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo

במקרה של כישלון בסנכרון כלשהו, תוכל תמיד לבדוק את אירועי ה-Kubernetes עבור היישום הרלוונטי (באמצעות argocd app get <application_name>):

הפלט דומה למשל:

  • בשלב הבא, תלמד כיצד להשתמש בתבנית ה-app of apps ולבצע את אותם צעדים דרך ממשק משתמש גרפי של Argo CD.
  • שימוש בתבנית ה-App of Apps דרך ממשק האינטרנט של Argo CD
  • במקטע זה, תלמד כיצד להשתמש בממשק האינטרנט של Argo CD כדי ליצור ולהשתמש בתבנית ה-app of apps כדי להפעיל את כל רכיבי קיט ההתחלה בקלאסטר DOKS שלך. התמונה למטה ממחישה את הרעיון העיקרי:
  • כפי שמראה התרשים לעיל, הקמת יישום חדש דרך ממשק האינטרנט דומה מאוד לגרסת ה-CLI. ההבדל היחיד הוא שתעבור בין חלונות/לוחות שונים ותשתמש בפעולות נקודה-לחיצה. מאחורי הקלעים, Argo CD ייצור את ה-CRDs שנדרשים ליישום ויחיל את השינויים לקלאסטר Kubernetes שלך.
  • תחילה, אנא פתח דפדפן אינטרנט והתחבר לממשק האינטרנט של קונסולת Argo CD. שם המשתמש המוגדר כברירת מחדל הוא admin, והסיסמה המוגדרת כברירת מחדל ניתנת דרך:
  • ברגע שתתחבר, תופנה לעמוד הלוח של היישומים (בהתקנה חדשה, הלוח ריק). לאחר מכן, לחץ על לחצן צור יישום. חלון חדש יופיע שבו יידרשו פרטי היישום:
  • אנא מלא את כל השדות באופן הולם:

שם היישום: שם היישום החדש (לדוגמה, starter-kit-apps).

פרוייקט: שם הפרויקט שבו היישום משתייך (כאשר משתמשים ב-Argo CD לראשונה, ניתן להשתמש ב-default).

מדיניות סנכרון ו־אפשרויות סנכרון: מגדיר את מדיניות ואפשרויות הסנכרון (לדוגמה, ידני, אוטומטי, מספר ניסיונות חוזרים, מרווח בין ניסיונות חוזרים, וכו').

כתובת ה־מאגר מקור: כתובת URL של מאגר ה-GitHub שלך – לדוגמה, https://github.com/<YOUR_GITHUB_USERNAME>/<YOUR_ARGOCD_GITHUB_REPO_NAME>.git.

נתיב המקור Path: נתיב התיקייה במאגר ה-GitHub שבו מאוחסנים רפרזנטציות היישום (לדוגמה, clusters/dev/helm).

כתובת URL של ה־קלסטר היעד: קלסטר Kubernetes יעד לסנכרון עם מאגר ה-GitHub שלך (לדוגמה, https://kubernetes.default.svc עבור הקלסטר המקומי שבו הותקן Argo CD).

ה־מרחב השמות היעד: מרחב השמות בקלסטר Kubernetes המטרה לשימוש ביישומי Argo CD (argocd, בדרך כלל).

לאחר מילוי כל פרטי היישום, לחץ על הלחצן צור בחלק העליון. פריט יישום חדש מופיע על עמוד הלוח:

אם תלחץ על כפתור היישום, תוכל לראות את התבנית השל יישומים, על ידי הסתכלות על גרף ההרכבה:

אם תסתכל על התמונה למעלה, תבחין כי כל היישומים מסומנים כ החוץ_מסנכרן. השלב הבא הוא להפעיל פעולת סנכרון על היישום האב. לאחר מכן, כל היישומים המשניים ייסנכרנו גם הם. נא ללחוץ על כפתור ה-סנכרן באריח היישום האב. חלון חדש יופיע בצד הימני (שימו לב שכל היישומים המשניים נבחרים למטה):

השאירו את הערכים ברירת המחדל, ולאחר מכן לחצו על הכפתור לסנכרן בחלק העליון וצפו כיצד Argo CD משדרג את פעולת הסנכרון לכל היישומים:

אירוע הפירוק של היישום Velero יכשל וישות כתקלה מכוונת במצב שגיאת_סנכרון כתרגול לקורא להתנסות וללמוד איך לאבחן בעיות ביישומים ב-Argo CD. נא לעיין במקטע רמזים למטה כדי לראות איך לאבחן בעיות ביישומים של Argo CD.

אם הכל מתנהל כראוי, כל היישומים צריכים להציג מסגרת ירוקה והסטטוס צריך להיות בריא ו- מסונכרן. תהליך ההפעלה הראשוני הוא פעולה חד פעמית. בשינויים ב-Git לאחר מכן עבור כל יישום, Argo CD יזהה את השינויים ויחדש את השינויים הנדרשים. Argo CD משתמש במנגנון איתור ידני כברירת מחדל כדי לזהות שינויים במאגר ה-Git שלך. מרווח הרענון ברירת המחדל מוגדר ל־3 דקות. במקום לסמוך על מנגנון איתור ידני, תוכל גם להשתמש ביכולת של וובהוקים של Git. אנא בקר באתר התיעוד הרשמי כדי ללמוד כיצד ליצור ולהגדיר את Argo CD כך שישתמש ב־וובהוקים.

רמזים:
אם מתכוונים, ניתן להגדיר את היישום האב להיות מסונכרן אוטומטית על ידי הגדרת ערך של שדה מדיניות סנכרון ל־אוטומטי. כדי להפעיל תיקון עצמי וניתור אוטומטי, סמנו את תיבת הסימון משאבי ניתור ואת תיבת הסימון תיקון עצמי:

במקרה של כישלון בסנכרון, תמיד ניתן לבדוק את אירועי Kubernetes עבור היישום הרלוונטי. באמצעות ממשק האינטרנט, ניתן לנווט לאריח היישום המושפע:

אז, לחץ על הקישור של ההודעה Sync failed שסומן בצבע אדום, מתוך המקטע LAST SYNC RESULT בכותרת עמוד האפליקציה. לחיצה זו תפתח חלון חדש שיציג מידע שימושי אודות למה נכשלה פעולת הסנכרון:

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

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: my-app
spec:
  generators:
    - list:
        elements:
          - cluster: dev
            url: https://kubernetes.dev.svc
          - cluster: qa
            url: https://kubernetes.qa.svc
          - cluster: prod
            url: https://kubernetes.prod.svc
  template:
    metadata:
      name: '{{cluster}}-app'
    spec:
      project: default
      source:
        repoURL: https://github.com/myrepo/my-applicationset.git
        targetRevision: HEAD
        path: clusters/{{cluster}}/my-apps
      destination:
        server: '{{url}}'
        namespace: argocd

ה-ApplicationSet Controller מותקן יחד עם ארקו-סי-די (באותה מרחב שמורות), והוא מייצר באופן אוטומטי אפליקציות ארקו-סי-די בהתבסס על תוכן של משאב מותאם אישית (CR) חדש של ApplicationSet.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: dev-app
spec:
  project: default
  source:
    repoURL: https://github.com/myrepo/my-applicationset.git
    targetRevision: HEAD
    path: clusters/dev/my-apps
  destination:
    server: https://kubernetes.dev.svc
    namespace: argocd

הערה:החל מגרסה 2.3.x של ארקו-סי-די, אין צורך להתקין בנפרד את הApplicationSet Controller משום שהוא חלק מההתקנה הראשית של ארקו-סי-די. Starter Kit משתמש ב-גרסה >= 2.3.1, לכן אין צורך לשנות כלום.

הרעיון העיקרי של ApplicationSet מבוסס על רשימת ערכים הפועלת כמחולל (generator), ועל תבנית (template) שמתמלאת על ידי ערכי רשימת הקלט. עבור כל פריט מהרשימה, תבנית אפליקציה חדשה נוצרת בסדר. בגדול, אתה מגדיר CRD של ApplicationSet ואז מאפשר לו לייצר עבורך כמה CRDs של אפליקציות ArgoCD שתרצה, בהתבסס על ערכי הקלט. כך, במקום ליצור ולהתמודד עם מספר רב של מנפקי אפליקציה, אתה ניהל את הכל דרך מנפק יחיד – הApplicationSet.

הרעיון הזה גם מפשט את ניהול ההגדרות של רב-קלאסטרים ורב-סביבות על ידי שימוש בתבניות אפליקציה פרמטריזציה. סטים של אפליקציות כוללים גם מנפקים אחרים, מלבד מנפקי רשימה:

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

argocd app delete starter-kit-apps

מנפק Git: משתמש בקבצים/תיקיות של גיט ליצירת תבניות אפליקציות. 

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: cert-manager
  namespace: argocd
  finalizers:
    - resources-finalizer.argocd.argoproj.io
spec:
...

CRD טיפוסי של ApplicationSet בשימוש במנפק רשימה, נראה כמו בדוגמה הבאה:

החלקה של הApplicationSet לקלאסטר שלך ב־Kubernetes תחשוף שלוש אפליקציות של Argo CD. לדוגמה, אפליקציית הסביבה dev מוצגת באופן הבא:

המנועים של תבניות הוא כח עוצמתי מאוד בטבעם ומציעים המון אפשרויות. אנא בקר באתר התיעוד הראשי של ApplicationSet כדי ללמוד עוד על התכונה הזו.

הסרת התקנים של Argo CD

הסרת (או מחיקת) התקנים שניהלו על ידי Argo CD מתבצעת על ידי מחיקת המנף התואם ממקור המאגר Git. במקרה של יישום שנוצר באמצעות התבנית של יישום של יישומים, עליך למחוק את היישום האב רק (באמצעות CLI או ממשק האינטרנט). אז, כל היישומים הילד יימחקו גם כן כחלק מהתהליך.

  • כיצד למחוק את היישום האב starter-kit-apps (כולל יישומים ילד) באמצעות CLI של argocd:
  • אם ברצונך לוודא שיישומים הילד וכל המשאבים שלהם יימחקו כאשר היישום האב יימחק, אנא וודא שתוסיף את ה-finalizer המתאים להגדרת היישום שלך:

Source:
https://www.digitalocean.com/community/developer-center/implementing-gitops-using-argo-cd