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

Last reviewed 2023-07-21 UTC

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

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

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

כדי לפרוס תמונה באמצעות ה-digest, משתמשים בשם התמונה, ואחריו @sha256: וערך ה-digest. הדוגמה הבאה היא של משאב Deployment שמשתמש בתמונה עם תקציר. פריסה היא אובייקט 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 מספק יתרונות נוספים, כמו הפשטה של האופן שבו כלים שונים יוצרים ומפריסים תמונות של קונטיינרים.

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

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

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

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

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

מטרות

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

עלויות

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

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

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

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

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

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

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

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

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

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

  3. מפעילים את Artifact Registry API.

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

    כדי להפעיל ממשקי API, צריך את תפקיד ה-IAM 'אדמין של Service Usage' (roles/serviceusage.serviceUsageAdmin), שכולל את ההרשאה serviceusage.services.enable. איך מקצים תפקידים

    להפעלת ה-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 מחליף את ערך ה-placeholder הזה בשם המלא של התמונה וב-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 שומר מידע על התמונה שנבנתה, כולל ערך ה-digest.
    • הדגל --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 מוסיף תקצירים לתמונות של קונטיינרים וקונטיינרים של 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. מורידים את הקובץ הבינארי של ה-digester:

    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_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 הוסיף את ה-digest של התמונה למפרט של תבנית ה-Pod במשאב Deployment.

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

    kind delete cluster

שימוש ב-setters של kpt

‫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 באמצעות שכבות-על, תיקונים וטרנספורמציות.

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

קטע הקוד 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 יוצרת קובצי אימג' של קונטיינר ומפרסמת אותם במאגר של קובצי אימג' של קונטיינר, או טוענת אותם ל-daemon המקומי של Docker.

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

  • מזהה את התמונות שצריך ליצור על ידי איתור של placeholders בשדות image של מניפסטים של Kubernetes שסיפקתם באמצעות הארגומנט --filename.
  • מבצע build ופרסום של התמונות.
  • הפונקציה מחליפה את ערכי ה-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 מדפיס את שם התמונה ואת הגיבוב שלה ב-stdout בפורמט הבא:

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

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

    • משתמשים ב-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 prints the manifest with the image name and digest to 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 הפרויקט שיצרתם בשביל המדריך. אפשר גם למחוק את המשאבים בנפרד.

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

  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

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