Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

Last reviewed 2023-07-21 UTC

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

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

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

הארגומנט 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 ‏ (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.
משתמשים בפונקציה בצד הלקוח לסיכום וב-webhook לשינוי הרשאות הכניסה כדי להוסיף סיכומים לתמונות ב-Pods של Kubernetes ולתבניות של Pods.
אפשר להשתמש ב-kpt setters כדי להחליף תג תמונה במניפסט של Kubernetes ב-image digest.
אפשר להשתמש ב-kustomize כדי ליצור מניפסט של Kubernetes עם תקציר של תמונה.
משתמשים ב-gke-deploy כדי לפתור תג תמונה לסיכום ב-Kubernetes manifest.
משתמשים בפקודה ko כדי ליצור קובץ אימג' ולהעביר אותו בדחיפה, וכדי להוסיף את שם קובץ האימג' ואת הגיבוב שלו למניפסט של Kubernetes.

עלויות

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

Artifact Registry

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

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

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

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

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the Artifact Registry API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API
In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell
ב-Cloud Shell, מגדירים את פרויקט ברירת המחדל ל-Google Cloud CLI:
```
gcloud config set project PROJECT_ID
```
מחליפים את PROJECT_ID ב[מזהה הפרויקט].
יוצרים מאגר של קובצי אימג' של קונטיינרים ב-Artifact Registry:
```
gcloud artifacts repositories create REPOSITORY \
    --location=LOCATION \
    --repository-format=docker
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫REPOSITORY: השם שבו רוצים להשתמש למאגר, למשל digest-tutorial.
- ‫LOCATION: מיקום ב-Artifact Registry, לדוגמה us-central1.
מגדירים אימות למיקום ב-Artifact Registry עבור כלי ה-CLI שבהם נעשה שימוש במדריך הזה:
```
gcloud auth configure-docker LOCATION-docker.pkg.dev
```
שימוש ב-Skaffold

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

משתמשים ב-Skaffold כדי ליצור אימג', להעביר אותו בדחיפה ל-Artifact Registry ולהחליף את ערך ה-placeholder ‏image בתבנית של מניפסט Kubernetes בשם, בתג וב-digest של האימג' שהועבר בדחיפה:
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
```
עם הפניות שמשתמשות ב-digest של התמונה:
```
spec:
  containers:
  - image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
```
אפשר להריץ את Digester כווּבּוּק קבלה משנה באשכול 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 הוסיף את תקציר התמונה למפרט של תבנית ה-Pod במשאב Deployment.
8. כדי לפנות משאבים בסשן של Cloud Shell, מוחקים את אשכול ה-Kind:
```
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 באמצעות שכבות-על, תיקונים וטרנספורמציות.

אתם יכולים להשתמש ב-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 תגי התמונה נפתרים ל-digests והמניפסטים המורחבים נשמרים עם ה-digests של התמונה בקובץ 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. יוצרים מניפסט של Kubernetes Pod. במניפסט נעשה שימוש בפלייסהולדר 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. In the Google Cloud console, go to the Manage resources page.
  Go to Manage resources
2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.
מחיקת המשאבים

אם רוצים לשמור את 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.

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

המלצות

מטרות

עלויות

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

שימוש ב-Skaffold

שימוש במעכל

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

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

שימוש ב-kpt setters

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

שימוש ב-`gke-deploy`

שימוש ב-`ko`

הסרת המשאבים

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

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

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

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

המלצות

מטרות

עלויות

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

שימוש ב-Skaffold

שימוש במעכל

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

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

שימוש ב-kpt setters

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

שימוש ב-gke-deploy

שימוש ב-ko

הסרת המשאבים

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

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

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

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

שימוש ב-`gke-deploy`

שימוש ב-`ko`