שימוש בערכי גיבוב (digest) של קובץ אימג' של קונטיינר במניפסטים של Kubernetes

Last reviewed 2023-07-21 UTC

טייס אוטומטי רגילה

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

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

הארגומנט image לקונטיינרים במפרט של Pod ב-Kubernetes מקבל תמונות עם ערכי גיבוב. הארגומנט הזה חל בכל מקום שבו משתמשים במפרט Pod, כמו בקטע template של המשאבים Deployment,‏ StatefulSet,‏ DaemonSet,‏ ReplicaSet,‏ CronJob ו-Job.

כדי לפרוס תמונה באמצעות ה-digest, משתמשים בשם התמונה, ואחריו @sha256: וערך ה-digest. הדוגמה הבאה היא של משאב פריסה שמשתמש בתמונה עם סיכום. פריסה היא אובייקט של Kubernetes API שמאפשר להריץ כמה רפליקות של Pods שמופצים בין הצמתים באשכול.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-deployment
spec:
  selector:
    matchLabels:
      app: echo
  template:
    metadata:
      labels:
        app: echo
    spec:
      containers:
      - name: echoserver
        image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
        ports:
        - containerPort: 8080

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

במדריך הזה מוסבר איך להשתמש בכלים כמו Skaffold,‏ kpt,‏ digester,‏ kustomize,‏ gke-deploy ו-ko כדי להשתמש בערכי גיבוב של תמונות במניפסטים.

המלצות

במסמך הזה מוצגות כמה דרכים להשתמש בסיכומי תמונות בפריסות של Kubernetes. הכלים שמתוארים במסמך הזה משלימים זה את זה. לדוגמה, אפשר להשתמש בפלט של פונקציית kpt עם kustomize כדי ליצור וריאנטים לסביבות שונות. ‫Skaffold יכולה ליצור תמונות באמצעות ko ולפרוס את התמונות באשכולות Kubernetes באמצעות kubectl או kpt.

הסיבה לכך שהכלים משלימים זה את זה היא שהם מבצעים עריכות מובנות שמבוססות על Kubernetes Resource Model ‏ (KRM). המודל הזה מאפשר להוסיף כלים, ואתם יכולים לשנות את אופן השימוש בכלים כדי ליצור תהליכים וצינורות עיבוד נתונים שיעזרו לכם לפרוס את האפליקציות והשירותים שלכם.

כדי להתחיל, מומלץ לבחור בגישה שהכי מתאימה לכלים ולתהליכים הקיימים שלכם:

• ‫Skaffold יכול להוסיף תקצירים להפניות לתמונות. כדי להפעיל את הפונקציה הזו, צריך לבצע שינוי קטן בהגדרות. שימוש ב-Skaffold מספק יתרונות נוספים, כמו הפשטה של האופן שבו כלים שונים יוצרים ומפריסים תמונות של קונטיינרים.

• אם משתמשים בכלי digester כ-webhook לשינוי הרשאות כניסה באשכולות Kubernetes, אפשר להוסיף digests לכל הפריסות עם השפעה מינימלית על התהליכים הנוכחיים של יצירת ופריסת תמונות קונטיינר. בנוסף, ה-webhook של ה-digester מפשט את ההטמעה של Binary Authorization, כי הוא דורש רק הוספה של תווית למרחב שמות.

• ‫kpt הוא אפשרות מצוינת אם אתם צריכים כלי גמיש לטיפול במניפסטים של Kubernetes. אפשר להשתמש בכלי digester כפונקציית KRM בצד הלקוח בצינור kpt.

• אם אתם כבר משתמשים ב-kustomize כדי לנהל מניפסטים של Kubernetes בסביבות שונות, מומלץ להשתמש בטרנספורמציות של תמונות כדי לפרוס תמונות לפי תקציר.

• ‫ko הוא כלי מצוין ליצירה ולפרסום של קובצי אימג' לאפליקציות Go, והוא משמש בפרויקטים של קוד פתוח כמו Knative,‏ Tekton ו-sigstore.

אם אתם לא משתמשים באף אחד מהכלים שמתוארים במסמך הזה, מומלץ להתחיל עם Skaffold ו-webhook של digester. ‫Skaffold הוא כלי נפוץ שמשמש גם מפתחים וגם צוותי הפצה, והוא משתלב עם הכלים האחרים שמתוארים במדריך הזה. כשהדרישות שלכם ישתנו, תוכלו להשתמש באפשרויות השילוב האלה. ה-webhook של digester Kubernetes משלים את Skaffold בכך שהוא מאפשר פריסות מבוססות-תקציר לכל האשכול.

מטרות

• משתמשים ב-Skaffold כדי ליצור קובץ אימג' ולהעביר אותו בדחיפה, וכדי להוסיף את שם קובץ האימג' ואת ה-digest למניפסט של Kubernetes.
• משתמשים בפונקציה בצד הלקוח של digester וב-mutating admission webhook כדי להוסיף תקצירים לתמונות בתבניות של Pods ו-Pod ב-Kubernetes.
• אפשר להשתמש ב-kpt setters כדי להחליף תג תמונה במניפסט של Kubernetes ב-image digest.
• אפשר להשתמש ב-kustomize כדי ליצור מניפסט של Kubernetes עם תקציר של תמונה.
• משתמשים ב-gke-deploy כדי לפתור תג תמונה לסיכום במניפסט של Kubernetes.
• משתמשים בפקודה ko כדי ליצור קובץ אימג' ולהעביר אותו בדחיפה, וכדי להוסיף את שם קובץ האימג' ואת הגיבוב (digest) למניפסט של Kubernetes.

עלויות

במסמך הזה משתמשים ברכיבים הבאים של Google Cloud, והשימוש בהם כרוך בתשלום:

• Artifact Registry

בעזרת מחשבון העלויות אתם יכולים להעריך את העלויות בהתאם לשימוש הצפוי.

משתמשים חדשים של Google Cloud ? יכול להיות שאתם זכאים לתקופת ניסיון בחינם.

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

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

1. בדף לבחירת הפרויקט במסוף Google Cloud , בוחרים פרויקט ב- Google Cloud או יוצרים אותו.

   התפקידים שנדרשים כדי לבחור או ליצור פרויקט

   • בחירת פרויקט: כדי לבחור פרויקט לא נדרש תפקיד IAM ספציפי – אתם יכולים לבחור כל פרויקט שקיבלתם בו תפקיד.
   • יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד Project Creator (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים
   הערה: אם אתם לא מתכננים לשמור את המשאבים שתיצרו בתהליך הזה, תוכלו ליצור פרויקט חדש במקום לבחור באחד מהפרויקטים הקיימים. בסיום התהליך תוכלו למחוק את הפרויקט ולהסיר את כל המשאבים שמשויכים אליו.

   כניסה לדף לבחירת הפרויקט

2. מוודאים שהחיוב מופעל בפרויקט Google Cloud .

3. מפעילים את Artifact Registry API, אם הוא עדיין לא מופעל.

   תפקידים שנדרשים להפעלת ממשקי API

   כדי להפעיל ממשקי API, צריך את ההרשאה serviceusage.services.enable. אם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד 'בעלים' (roles/owner). אחרת, תוכלו לקבל את ההרשאה הזו דרך התפקיד 'אדמין בממשק 'שימוש בשירות'' (roles/serviceusage.serviceUsageAdmin). איך מקצים תפקידים

   להפעלת ה-API

4. במסוף Google Cloud , מפעילים את Cloud Shell.

   הפעלת Cloud Shell

5. ב-Cloud Shell, מגדירים את פרויקט ברירת המחדל ל-Google Cloud CLI:

   gcloud config set project PROJECT_ID
   

   מחליפים את PROJECT_ID ב[מזהה הפרויקט].

6. יוצרים מאגר קובצי אימג' של קונטיינרים ב-Artifact Registry:

   gcloud artifacts repositories create REPOSITORY \
       --location=LOCATION \
       --repository-format=docker
   

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

   • ‫REPOSITORY: השם שרוצים לתת למאגר, למשל digest-tutorial.
   • ‫LOCATION: מיקום ב-Artifact Registry, לדוגמה us-central1.

7. מגדירים אימות למיקום של Artifact Registry לכלי ה-CLI שבהם משתמשים במדריך הזה:

   gcloud auth configure-docker LOCATION-docker.pkg.dev
   

שימוש ב-Skaffold

‫Skaffold הוא כלי שורת פקודה לפיתוח ולפריסה רציפים של אפליקציות באשכולות Kubernetes.

משתמשים ב-Skaffold כדי ליצור אימג', להעביר אותו בדחיפה ל-Artifact Registry ולהחליף את ערך הפלייס הולדר image בתבנית של מניפסט Kubernetes בשם, בתג ובערך הגיבוב של האימג' שהועבר בדחיפה:

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

   mkdir -p ~/container-image-digests-tutorial/skaffold
   cd ~/container-image-digests-tutorial/skaffold
   

2. משכפלים את מאגר ה-Git של Skaffold:

   git clone https://github.com/GoogleContainerTools/skaffold.git
   

3. עוברים לספרייה של הדוגמה getting-started:

   cd skaffold/examples/getting-started
   

4. בודקים את תג ה-Git שתואם לגרסה של Skaffold:

   git checkout $(skaffold version)
   

5. צפייה בקובץ ההגדרות skaffold.yaml:

   cat skaffold.yaml
   

   הקובץ ייראה כך:

   apiVersion: skaffold/v4beta6
   kind: Config
   build:
     artifacts:
     - image: skaffold-example
   manifests:
     rawYaml:
     - k8s-pod.yaml

   בקטע build.artifacts מופיע שם של פלייסהולדר של תמונה. ‫Skaffold מחפש את ה-placeholder הזה בקובצי המניפסט של הקלט.

   הקטע manifests אומר ל-Skaffold לקרוא מניפסט קלט מהספרייה הנוכחית עם השם k8s-pod.yaml.

   סקירה כללית של כל האפשרויות הזמינות מופיעה במאמרי העזרה בנושא skaffold.yaml.

6. צפייה בתבנית המניפסט של Kubernetes:

   cat k8s-pod.yaml
   

   הקובץ הוא:

   apiVersion: v1
   kind: Pod
   metadata:
     name: getting-started
   spec:
     containers:
     - name: getting-started
       image: skaffold-example

   ערך ה-placeholder‏ skaffold-example בשדה image תואם לערך בשדה image בקובץ skaffold.yaml. ‫Skaffold מחליף את ערך זמני לשמירת מקום (פלייסהולדר) הזה בשם המלא של קובץ האימג' וב-digest בפלט שעבר רינדור.

7. יוצרים את האימג' ומעבירים אותו בדחיפה ל-Artifact Registry:

   skaffold build \
       --default-repo=LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY \
       --file-output=artifacts.json \
       --interactive=false \
       --push=true \
       --update-check=false
   

   בפקודה הזו נעשה שימוש בדגלים הבאים:

   • הדגל --file-output מציין את הקובץ שבו Skaffold שומר מידע על קובץ האימג' שנוצר, כולל ערך התקציר.
   • הדגל --push מורה ל-Skaffold להעביר בדחיפה את קובץ אימג' של קונטיינר שנוצר למאגר קובצי אימג' של קונטיינר שצוין בדגל --default-repo.
   • הדגלים --interactive ו---update-check מוגדרים שניהם לערך false. בסביבות לא אינטראקטיביות, כמו צינורות build, צריך להגדיר את הדגלים האלה לערך false, אבל בפיתוח מקומי צריך להשאיר אותם כערכי ברירת המחדל שלהם (true לשני הדגלים).

   אם אתם משתמשים ב-Cloud Deploy כדי לפרוס ל-GKE, אתם צריכים להשתמש בקובץ מהדגל --file-output כערך של הדגל --build-artifacts כשאתם יוצרים גרסת הפצה.

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

   skaffold render \
       --build-artifacts=artifacts.json \
       --digest-source=none \
       --interactive=false \
       --offline=true \
       --output=rendered.yaml \
       --update-check=false
   

   בפקודה הזו נעשה שימוש בדגלים הבאים:

   • הדגל --build-artifacts מפנה לקובץ הפלט מהפקודה skaffold build בשלב הקודם.
   • הדגל --digest-source=none מציין ש-Skaffold משתמש בערך ה-digest מהקובץ שצוין בדגל --build-artifacts, במקום לפתור את ה-digest ממאגר קובצי האימג' של הקונטיינרים.
   • הדגל --offline=true מציין שאפשר להריץ את הפקודה בלי גישה לאשכול Kubernetes.
   • הדגל --output מציין את קובץ הפלט של המניפסט שעבר עיבוד.

9. הצגת קובץ המניפסט שעבר רינדור:

   cat rendered.yaml
   

   הפלט אמור להיראות כך:

   apiVersion: v1
   kind: Pod
   metadata:
     name: getting-started
   spec:
     containers:
     - image: LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/skaffold-example:TAG@sha256:DIGEST
       name: getting-started

   בפלט הזה מופיעים הערכים הבאים:

   • ‫TAG: התג ש-Skaffold הקצה לתמונה.
   • ‫DIGEST: ערך ה-digest של התמונה

שימוש ב-digester

‫Digester מוסיף תקצירים לתמונות של קונטיינרים וקונטיינרים של init במפרטים של Kubernetes Pod ו-Pod template. ‫Digester מחליף את ההפניות לקובצי אימג' של קונטיינרים שמשתמשים בתגים:

spec:
  containers:
  - image: gcr.io/google-containers/echoserver:1.10

עם הפניות שמשתמשות בסיכום התמונה:

spec:
  containers:
  - image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

אפשר להריץ את Digester כתגובה לפעולה מאתר אחר (webhook) לשינוי הרשאות גישה באשכול Kubernetes, או כפונקציית KRM בצד הלקוח באמצעות כלי שורת הפקודה kpt או kustomize.

שימוש בפונקציית KRM של מעכל

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

   mkdir -p ~/container-image-digests-tutorial/digester-fn
   cd ~/container-image-digests-tutorial/digester-fn
   

2. מורידים את הקובץ הבינארי של הכלי לסיכום:

   mkdir -p ${HOME}/bin
   export PATH=${HOME}/bin:${PATH}
   DIGESTER_VERSION=$(curl -sL https://api.github.com/repos/google/k8s-digester/releases/latest | jq -r .tag_name)
   curl -L "https://github.com/google/k8s-digester/releases/download/${DIGESTER_VERSION}/digester_$(uname -s)_$(uname -m)" --output ${HOME}/bin/digester
   chmod +x ${HOME}/bin/digester
   

3. יוצרים מניפסט של Kubernetes Pod שמפנה לתמונה gcr.io/google-containers/echoserver באמצעות התג 1.10:

   cat << EOF > pod.yaml
   apiVersion: v1
   kind: Pod
   metadata:
     name: echo
   spec:
     containers:
     - name: echoserver
       image: gcr.io/google-containers/echoserver:1.10
       ports:
       - containerPort: 8080
   EOF
   

4. מריצים את הפונקציה digester KRM באמצעות kpt עם המניפסטים בספרייה הנוכחית (.):

   kpt fn eval . --exec digester
   

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

5. צפייה במניפסט המעודכן:

   cat pod.yaml
   

   הקובץ הוא:

   apiVersion: v1
   kind: Pod
   metadata:
     name: echo
   spec:
     containers:
       - name: echoserver
         image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
         ports:
           - containerPort: 8080

שימוש ב-webhook של בקרת כניסה של digester

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

   mkdir -p ~/container-image-digests-tutorial/digester-webhook
   cd ~/container-image-digests-tutorial/digester-webhook
   

2. יצירת אשכול Kubernetes מקומי באמצעות kind:

   kind create cluster
   

   ‫kind הוא כלי שורת פקודה להרצת אשכולות Kubernetes מקומיים באמצעות Docker.

3. פורסים את ה-webhook של ה-digester:

   DIGESTER_VERSION=$(curl -sL https://api.github.com/repos/google/k8s-digester/releases/latest | jq -r .tag_name)
   kustomize build "https://github.com/google/k8s-digester.git/manifests?ref=${DIGESTER_VERSION}" | kubectl apply -f -
   

4. יוצרים מרחב שמות של Kubernetes בשם digester-demo באשכול kind:

   kubectl create namespace digester-demo
   

5. מוסיפים את התווית digest-resolution: enabled למרחב השמות digester-demo:

   kubectl label namespace digester-demo digest-resolution=enabled
   

   ה-webhook של ה-digester מוסיף תקצירים ל-Pods במרחבי שמות עם התווית הזו.

6. יוצרים מניפסט של פריסת Kubernetes שמפנה לתמונה gcr.io/google-containers/echoserver באמצעות התג 1.10:

   cat << EOF > deployment.yaml
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: echo-deployment
   spec:
     selector:
       matchLabels:
         app: echo
     template:
       metadata:
         labels:
           app: echo
       spec:
         containers:
         - name: echoserver
           image: gcr.io/google-containers/echoserver:1.10
           ports:
           - containerPort: 8080
   EOF
   

7. מחילים את המניפסט במרחב השמות digester-demo:

   kubectl apply --filename deployment.yaml --namespace digester-demo \
       --output jsonpath='{.spec.template.spec.containers[].image}{"\n"}'
   

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

   gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

   הפלט הזה מראה ש-webhook של digester הוסיף את תקציר התמונה למפרט של תבנית ה-Pod במשאב Deployment.

8. מוחקים את אשכול kind כדי לפנות משאבים בסשן של Cloud Shell:

   kind delete cluster
   

שימוש ב-kpt setters

‫kpt הוא כלי לשורת הפקודה שמאפשר לנהל, לתפעל, להתאים אישית וליישם מניפסטים של משאבי Kubernetes.

אפשר להשתמש בפונקציות create-setters ו-apply-setters KRM מתוך קטלוג הפונקציות של kpt כדי לעדכן את תמציות הגיבוב של התמונות במניפסטים של Kubernetes כשיוצרים תמונות חדשות.

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

   mkdir -p ~/container-image-digests-tutorial/kpt
   cd ~/container-image-digests-tutorial/kpt
   

2. יוצרים חבילת kpt בספרייה הנוכחית:

   kpt pkg init --description "Container image digest tutorial"
   

3. יוצרים מניפסט של Kubernetes Pod שמפנה לתמונה gcr.io/google-containers/echoserver באמצעות התג 1.10:

   cat << EOF > pod.yaml
   apiVersion: v1
   kind: Pod
   metadata:
     name: echo
   spec:
     containers:
     - name: echoserver
       image: gcr.io/google-containers/echoserver:1.10
       ports:
       - containerPort: 8080
   EOF
   

4. משתמשים ב-kpt כדי ליצור setter בשם echoimage לשדה המניפסט, כאשר הערך הקיים הוא gcr.io/google-containers/echoserver:1.10:

   kpt fn eval . \
       --image gcr.io/kpt-fn/create-setters@sha256:0220cc87f29ff9abfa3a3b5643aa50f18d355d5e9dc9e1f518119633ddc4895c \
       -- "echoimage=gcr.io/google-containers/echoserver:1.10"
   

5. איך רואים את המניפסט:

   cat pod.yaml
   

   הקובץ הוא:

   apiVersion: v1
   kind: Pod
   metadata:
     name: echo
   spec:
     containers:
     - name: echoserver
       image: gcr.io/google-containers/echoserver:1.10 # kpt-set: ${echoimage}
       ports:
       - containerPort: 8080

6. מקבלים את ערך ה-digest של קובץ האימג' של הקונטיינר:

   DIGEST=$(gcloud container images describe \
       gcr.io/google-containers/echoserver:1.10 \
       --format='value(image_summary.digest)')
   

7. מגדירים את הערך החדש של השדה:

   kpt fn eval . \
       --image gcr.io/kpt-fn/apply-setters@sha256:4d4295727183396f0c3c6a75d2560254c2f9041a39e95dc1e5beffeb49cc1a12 \
       -- "echoimage=gcr.io/google-containers/echoserver:1.10@$DIGEST"
   

   כשמריצים את הפקודה הזו, kpt מבצע החלפה במקום של ערך השדה image במניפסט.

8. צפייה במניפסט המעודכן:

   cat pod.yaml
   

   הקובץ הוא:

   apiVersion: v1
   kind: Pod
   metadata:
     name: echo
   spec:
     containers:
     - name: echoserver
       image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229 # kpt-set: ${echoimage}
       ports:
       - containerPort: 8080

שימוש בטרנספורמציות של תמונות ב-kustomize

‫kustomize הוא כלי לשורת פקודה שמאפשר להתאים אישית מניפסטים של Kubernetes באמצעות שכבות-על, תיקונים וטרנספורמציות.

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

קטע הקוד הבא ב-kustomization.yaml מראה איך להגדיר את ממיר התמונות כך שישתמש בערך digest של הממיר לתמונות שבהן הערך image של מפרט ה-Pod תואם לערך name של הממיר:

images:
- name: gcr.io/google-containers/echoserver
  digest: sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

כדי להשתמש בטרנספורמציית תמונה של kustomize עם תקציר תמונה:

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

   mkdir -p ~/container-image-digests-tutorial/kustomize
   cd ~/container-image-digests-tutorial/kustomize
   

2. יוצרים קובץ kustomization.yaml:

   kustomize init
   

3. יוצרים מניפסט של Kubernetes עם מפרט של Pod שמפנה לתמונה gcr.io/google-containers/echoserver באמצעות התג 1.10:

   cat << EOF > pod.yaml
   apiVersion: v1
   kind: Pod
   metadata:
     name: echo
   spec:
     containers:
     - name: echoserver
       image: gcr.io/google-containers/echoserver:1.10
       ports:
       - containerPort: 8080
   EOF
   

4. מוסיפים את המניפסט כמשאב בקובץ kustomization.yaml:

   kustomize edit add resource pod.yaml
   

5. משתמשים בכלי לשינוי תמונות כדי לעדכן את תקציר התמונה:

   kustomize edit set image \
       gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
   

6. מציגים את הכלי לטרנספורמציה של תמונות בקובץ kustomization.yaml:

   cat kustomization.yaml
   

   הקובץ הוא:

   apiVersion: kustomize.config.k8s.io/v1beta1
   kind: Kustomization
   resources:
   - pod.yaml
   images:
   - digest: sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
     name: gcr.io/google-containers/echoserver

7. צפייה במניפסט שנוצר:

   kustomize build .
   

   הפלט שיתקבל:

   apiVersion: v1
   kind: Pod
   metadata:
     name: echo
   spec:
     containers:
     - image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
       name: echoserver
       ports:
       - containerPort: 8080

8. כדי להריץ את הטרנספורמציה של kustomize ולהחיל את המניפסט שמתקבל על אשכול Kubernetes בשלב אחד, אפשר להשתמש בפקודה kubectl apply עם הדגל --kustomize:

   kubectl apply --kustomize .
   

   אם רוצים להחיל את הפלט מאוחר יותר, אפשר להפנות את הפלט של הפקודה kustomize build לקובץ.

שימוש ב-gke-deploy

‫gke-deploy הוא כלי לשורת הפקודה שמשמש עם Google Kubernetes Engine‏ (GKE). ‫gke-deploy כולל את כלי שורת הפקודה kubectl ויכול לשנות את המשאבים שאתם יוצרים בהתאם לשיטות המומלצות של Google.

אם משתמשים בפקודות המשנה gke-deploy prepare או run, gke-deploy הפקודה פותרת את תגי התמונה לערכי גיבוב ושומרת את המניפסטים המורחבים עם ערכי הגיבוב של התמונות בקובץ output/expanded/aggregated-resources.yaml כברירת מחדל.

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

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

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

   mkdir -p ~/container-image-digests-tutorial/gke-deploy
   cd ~/container-image-digests-tutorial/gke-deploy
   

2. התקנת gke-deploy:

   go install github.com/GoogleCloudPlatform/cloud-builders/gke-deploy@latest
   

3. יוצרים מניפסט של פריסת Kubernetes שמפנה לתמונה gcr.io/google-containers/echoserver באמצעות התג 1.10:

   cat << EOF > deployment.yaml
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: echo-deployment
   spec:
     selector:
       matchLabels:
         app: echo
     template:
       metadata:
         labels:
           app: echo
       spec:
         containers:
         - name: echoserver
           image: gcr.io/google-containers/echoserver:1.10
           ports:
           - containerPort: 8080
   EOF
   

4. יוצרים מניפסט מורחב על סמך המניפסט של deployment.yaml:

   gke-deploy prepare \
       --filename deployment.yaml \
       --image gcr.io/google-containers/echoserver:1.10 \
       --version 1.10
   

5. צפייה במניפסט המורחב:

   cat output/expanded/aggregated-resources.yaml
   

   הפלט שיתקבל:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       app.kubernetes.io/managed-by: gcp-cloud-build-deploy
       app.kubernetes.io/version: "1.10"
     name: echo-deployment
     namespace: default
   spec:
     selector:
       matchLabels:
         app: echo
     template:
       metadata:
         labels:
           app: echo
           app.kubernetes.io/managed-by: gcp-cloud-build-deploy
           app.kubernetes.io/version: "1.10"
       spec:
         containers:
         - image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
           name: echoserver
           ports:
           - containerPort: 8080

   במניפסט המורחב, תג התמונה מוחלף בערך ה-digest.

   הארגומנט --version שבו השתמשתם עם הפקודה gke-deploy מגדיר את הערך של התווית app.kubernetes.io/version בפריסה ובמטא-נתונים של תבנית ה-Pod במניפסט המורחב.

   במסמכי התיעוד של Cloud Build בנושא gke-deploy מוסבר איך משתמשים ב-gke-deploy עם Cloud Build.

שימוש ב-ko

‫ko הוא כלי שורת פקודה וספרייה ליצירת Go קובצי אימג' של קונטיינרים ולפריסתם באשכולות Kubernetes. ‫ko יוצר קובצי אימג' בלי להשתמש בשד של Docker, כך שאפשר להשתמש בו בסביבות שבהן אי אפשר להתקין את Docker.

פקודת המשנה kobuild יוצרת קובצי אימג' של קונטיינר ומפרסמת אותם במאגר של קובצי אימג' של קונטיינר, או טוענת אותם ל-Docker daemon המקומי.

פקודת המשנה koresolve מבצעת את הפעולות הבאות:

• מזהה את התמונות שצריך ליצור על ידי איתור של placeholders בשדות image של מניפסטים של Kubernetes שסיפקתם באמצעות הארגומנט --filename.
• יוצר ומפרסם את התמונות.
• הפונקציה מחליפה את ערכי ה-placeholder‏ image בשמות ובערכי ה-digest של התמונות שהיא יצרה.
• מדפיס את המניפסטים המורחבים.

פקודות המשנה ko apply, create, ו-run מבצעות את אותם השלבים כמו resolve, ואז מריצות את kubectl apply, את create או את run עם המניפסטים המורחבים.

כדי ליצור תמונה מקוד מקור של Go ולהוסיף את ה-digest של התמונה למניפסט של פריסת Kubernetes, מבצעים את הפעולות הבאות

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

   mkdir -p ~/container-image-digests-tutorial/ko
   cd ~/container-image-digests-tutorial/ko
   

2. מורידים את ko ומוסיפים אותו ל-PATH:

   mkdir -p ${HOME}/bin
   export PATH=${HOME}/bin:${PATH}
   KO_VERSION=$(curl -sL https://api.github.com/repos/ko-build/ko/releases/latest | jq -r .tag_name | cut -c2-)
   curl -L "https://github.com/ko-build/ko/releases/download/v${KO_VERSION}/ko_${KO_VERSION}_$(uname -s)_$(uname -m).tar.gz" | tar -zxC ${HOME}/bin ko
   

3. יוצרים אפליקציית Go עם שם המודול example.com/hello-world בספרייה חדשה בשם app:

   mkdir -p app/cmd/ko-example
   
   cd app
   
   go mod init example.com/hello-world
   
   cat << EOF > cmd/ko-example/main.go
   package main
   
   import "fmt"
   
   func main() {
       fmt.Println("hello world")
   }
   EOF
   

4. מגדירים את מאגר התמונות ש-ko משתמש בו כדי לפרסם תמונות:

   export KO_DOCKER_REPO=LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY
   

   בדוגמה הזו נעשה שימוש ב-Artifact Registry, אבל אפשר להשתמש ב-ko עם מרשם אחר של קובצי אימג' של קונטיינר.

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

   • כדי ליצור ולפרסם קובץ אימג' לאפליקציה, מציינים את הנתיב אל חבילת ה-main של Go:

     ko build --base-import-paths ./cmd/ko-example
     

     הארגומנט האופציונלי --base-import-paths מציין שהפקודה ko משתמשת בשם המקוצר של ספריית החבילה הראשית כשם קובץ האימג'.

     ‫ko מדפיס את שם התמונה ואת ה-digest שלה ב-stdout בפורמט הבא:

     LOCATION-docker.pkg.dev/PROJECT_ID/ko-example@sha256:DIGEST

     בפלט הזה, DIGEST הוא ערך ה-digest של התמונה.

     הערה: כל הפלט האחר של ko מועבר אל stderr. אם רוצים לתעד את השם והתקציר של קובץ האימג', אפשר לתעד את stdout במשתנה סביבה:

     IMAGE_AND_DIGEST=$(ko build --base-import-paths ./cmd/ko-example)
     

   • משתמשים ב-ko כדי להחליף פלייסולדר במניפסט בשם וב-digest של האימג' שהוא יוצר ומפרסם:

     1. יוצרים מניפסט של Pod ב-Kubernetes. במניפסט נעשה שימוש בפלייסהולדר ko://IMPORT_PATH_OF_YOUR_MAIN_PACKAGE כערך של השדה image:

        cat << EOF > ko-pod.yaml
        apiVersion: v1
        kind: Pod
        metadata:
          name: ko-example
        spec:
          containers:
          - name: hello-world
            image: ko://example.com/hello-world/cmd/ko-example
        EOF
        

     2. יוצרים ומפרסמים אימג' לאפליקציה, ומחליפים את הפלייסהולדר של המניפסט בשם האימג' ובערך ה-digest:

        ko resolve --base-import-paths --filename ko-pod.yaml
        

        ‫ko מדפיס את המניפסט עם שם קובץ האימג' והתקציר ל-stdout:

        apiVersion: v1
        kind: Pod
        metadata:
          name: ko-example
        spec:
          containers:
          - name: hello-world
            image: LOCATION-docker.pkg.dev/PROJECT_ID/ko-example@sha256:DIGEST

        בפלט הזה, DIGEST הוא ערך ה-digest של התמונה.

הסרת המשאבים

הדרך הקלה ביותר לבטל את החיוב היא למחוק את הפרויקט Google Cloud שיצרתם בשביל המדריך. אפשר גם למחוק את המשאבים בנפרד.

מחיקת הפרויקט

זהירות: כשמוחקים פרויקט:
• התוכן של הפרויקט נמחק כולו. אם השתמשתם בפרויקט קיים כדי לתרגל את המשימות במדריך הזה, כשתמחקו אותו תימחק גם כל העבודה שביצעתם באותו פרויקט.
• מאבדים את מזהה הפרויקט בהתאמה אישית. כשיצרתם את הפרויקט, יכולתם לבחור לו מזהה פרויקט בהתאמה אישית כדי להשתמש בו בעתיד. כדי לשמור על כתובות ה-URL שמשתמשות במזהה הפרויקט, כמו appspot.com, צריך למחוק את המשאבים שנבחרו בפרויקט אבל לא את הפרויקט כולו.
1. במסוף Google Cloud , נכנסים לדף Manage resources.

   כניסה לדף Manage resources

2. ברשימת הפרויקטים, בוחרים את הפרויקט שרוצים למחוק ולוחצים על Delete.
3. כדי למחוק את הפרויקט, כותבים את מזהה הפרויקט בתיבת הדו-שיח ולוחצים על Shut down.

מחיקת המשאבים

אם אתם רוצים לשמור את Google Cloud הפרויקט שבו השתמשתם במדריך הזה, אתם צריכים למחוק את המשאבים הבודדים:

1. ב-Cloud Shell, מוחקים את הקבצים שיצרתם במדריך הזה:

   cd
   rm -rf ~/container-image-digests-tutorial
   

2. מחיקת מאגר קובצי אימג' של קונטיינר ב-Artifact Registry:

   gcloud artifacts repositories delete REPOSITORY \
       --location=LOCATION --async --quiet
   

המאמרים הבאים

• מידע נוסף על תקצירי קובצי אימג' של קונטיינרים
• מידע נוסף על הפונקציה digester client-side KRM ועל Kubernetes mutating webhook
• מומלץ לקרוא את המדריך בנושא פיתוח רציף (continuous delivery) בסגנון GitOps באמצעות Cloud Build.