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

גישה לאובייקטים של Kubernetes API באמצעות מחבר

אשכול Google Kubernetes Engine‏ (GKE) מורכב ממישור בקרה וממכונות עובד שנקראות צמתים. אפשר להריץ את עומסי העבודה של Kubernetes בקונטיינרים באשכול GKE. צמתים הם מכונות העובד שמריצות את האפליקציות שמבוססות על קונטיינרים ועומסי עבודה אחרים, ומישור הבקרה הוא נקודת הקצה המאוחדת של האשכול. מידע נוסף זמין במאמר בנושא ארכיטקטורת אשכול GKE.

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

במאמר הזה נסביר איך להשתמש ב-Kubernetes API connector בתהליך עבודה כדי לשלוח בקשות לנקודת הקצה של שירות Kubernetes שמתארחת ברמת הבקרה של אשכול GKE. לדוגמה, אתם יכולים להשתמש במחבר כדי ליצור פריסות של Kubernetes, להריץ משימות, לנהל יחידות Pod או לגשת לאפליקציות שנפרסו דרך שרת proxy. מידע נוסף זמין במאמר סקירה כללית על Kubernetes API Connector.

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

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

הפעלת ממשקי ה-API

כדי לגשת לאובייקטים של Kubernetes API באמצעות מחבר Kubernetes API, צריך להפעיל את ממשקי ה-API הבאים:

‫Kubernetes Engine API: כדי ליצור ולנהל אפליקציות מבוססות-קונטיינרים באמצעות GKE
‫Workflows APIs: לניהול הגדרות וביצועים של תהליכי עבודה. הפעלת Workflows API מפעילה אוטומטית את Workflow Executions API.

המסוף

מפעילים את ממשקי ה-API:

הפעלת ממשקי ה-API

gcloud

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

הפעלת Cloud Shell

בחלק התחתון של Google Cloud המסוף יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

מפעילים את ממשקי ה-API:

gcloud services enable container.googleapis.com workflows.googleapis.com

יצירה של חשבון שירות

יוצרים חשבון שירות שהמשתמשים מנהלים, שמשמש כזהות של תהליך העבודה, ומקצים לו את התפקיד מפתח Kubernetes Engine (roles/container.developer) כדי שתהליך העבודה יוכל לגשת לאובייקטים של Kubernetes API בתוך אשכולות.

המסוף

נכנסים לדף Service accounts במסוף Google Cloud .

כניסה לדף Service accounts
בוחרים פרויקט ולוחצים על Create service account.
כותבים שם בשדה Service account name. המסוף Google Cloudממלא את השדה מזהה חשבון שירות בהתאם לשם הזה.

כותבים תיאור בשדה Service account description. לדוגמה, Service account for Kubernetes API.
לוחצים על Create and continue.
ברשימה Select a role, מסננים את התפקיד Kubernetes Engine Developer ובוחרים בו.
לוחצים על Continue.
כדי לסיים את יצירת החשבון, לוחצים על סיום.

gcloud

יוצרים את חשבון השירות:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
מחליפים את SERVICE_ACCOUNT_NAME בשם של חשבון השירות.

מקצים לחשבון השירות את התפקיד container.developer:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --role=roles/container.developer

מחליפים את PROJECT_ID במזהה הפרויקט ב- Google Cloud.

שימו לב שאפשר להשתמש גם ב-IAM וגם בבקרת גישה מבוססת-תפקידים (RBAC) של Kubernetes כדי לשלוט בגישה לאשכול GKE:

‫IAM לא ספציפי ל-Kubernetes, הוא מספק ניהול זהויות למספר מוצרים, והוא פועל בעיקר ברמת הפרויקט. Google Cloud Google Cloud
‫RBAC ב-Kubernetes הוא רכיב ליבה של Kubernetes שמאפשר ליצור תפקידים (קבוצות של הרשאות) ולהעניק אותם לכל אובייקט או סוג של אובייקט באשכול. אם אתם משתמשים בעיקר ב-GKE ואתם צריכים הרשאות מפורטות לכל אובייקט ולכל פעולה באשכול, כדאי להשתמש ב-Kubernetes RBAC.

למידע נוסף על בקרת גישה

יצירת אשכול GKE

כדי להשתמש בכלי Kubernetes API connector, צריך ליצור מראש אשכול GKE ציבורי או פרטי. באשכול פרטי, לצמתים יש רק כתובות IP פנימיות, מה שאומר שהצמתים וה-Pods מבודדים מהאינטרנט כברירת מחדל. מידע נוסף זמין במאמר בנושא אשכולות פרטיים.

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

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

המסוף

נכנסים לדף Kubernetes clusters במסוף Google Cloud .

מעבר אל Kubernetes clusters
לוחצים על יצירה.
אם מתבקשים לבחור מצב אשכול, בוחרים באפשרות Autopilot.
בקטע Cluster basics (יסודות האשכול), מבצעים את הפעולות הבאות:
1. מזינים את השם של האשכול, למשל hello-cluster.
2. בוחרים אזור לאשכול, כמו us-central1.
לוחצים על הבא: רשת.
בקטע IPv4 network access (גישה לרשת IPv4), כדי ליצור אשכול עם נקודת קצה שנגישה לכולם, בוחרים באפשרות Public cluster (אשכול ציבורי).
בשאר ההגדרות, מאשרים את ברירות המחדל.
לוחצים על יצירה.

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

gcloud

מריצים את הפקודה הבאה:

gcloud container clusters create-auto CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID

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

‫CLUSTER_NAME: השם של אשכול GKE, למשל hello-cluster
‫LOCATION: האזור של האשכול, למשל us-central1
‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud

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

Creating cluster hello-cluster...done.
Created [https://container.googleapis.com/v1/projects/MY_PROJECT/zones/us-central1/clusters/hello-cluster].
[...]
STATUS: RUNNING

שימוש במחבר לשליחת בקשת HTTP

אתם יכולים להשתמש במחבר Kubernetes API כדי לשלוח בקשת HTTP למישור הבקרה של אשכול GKE. לדוגמה, תהליך העבודה הבא יוצר פריסה בשם nginx-deployment באשכול Kubernetes שצוין. הפריסה מתארת מצב נדרש. במקרה הזה, הפעלת שלושה פודים עם תמונת nginx:1.14.2 וחשיפת השירות שלהם ביציאה 80. (אם לא מציינים ערך, ברירת המחדל של project ושל location היא הערך של תהליך העבודה).

מידע נוסף זמין בדף ההפניה לפונקציה של מחבר Kubernetes API‏, gke.request.

שימו לב לנקודות הבאות:

השדה path תואם לנתיב השיטה של Kubernetes API. מידע נוסף מופיע בסקירה הכללית על ה-API במסמכי העזרה של Kubernetes, שכוללת קישורים לדפים בנושא 'הפניית Kubernetes API'.
אפשר לזהות ולטפל בשגיאות בבקשות HTTP בתהליך העבודה. מידע נוסף זמין במאמר בנושא שגיאות בתהליך העבודה.

פריסת תהליך העבודה

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

המסוף

נכנסים לדף Workflows במסוף Google Cloud .

כניסה לדף Workflows
לוחצים על Create.
מזינים שם לתהליך העבודה החדש, למשל kubernetes-api-request.
ברשימה Region בוחרים באפשרות us-central1.
בוחרים את חשבון השירות שיצרתם קודם.
לוחצים על הבא.

בעורך תהליכי העבודה, מזינים את ההגדרה הבאה לתהליך העבודה:

YAML

main:
  steps:
    - create_deployment:
        call: gke.request
        args:
          cluster_id: "CLUSTER_NAME"
          project: "PROJECT_ID"
          location: "LOCATION"
          method: "POST"
          path: "/apis/apps/v1/namespaces/default/deployments"
          body:
            kind: Deployment
            metadata:
              name: nginx-deployment
              labels:
                app: nginx
            spec:
              replicas: 3
              selector:
                matchLabels:
                  app: nginx
              template:
                metadata:
                  labels:
                    app: nginx
                spec:
                  containers:
                    - name: nginx
                      image: nginx:1.14.2
                      ports:
                        - containerPort: 80
        result: result
    - returnResult:
        return: '${result}'

JSON

{
  "main": {
    "steps": [
      {
        "create_deployment": {
          "call": "gke.request",
          "args": {
            "cluster_id": "CLUSTER_NAME",
            "project": "PROJECT_ID",
            "location": "LOCATION",
            "method": "POST",
            "path": "/apis/apps/v1/namespaces/default/deployments",
            "body": {
              "kind": "Deployment",
              "metadata": {
                "name": "nginx-deployment",
                "labels": {
                  "app": "nginx"
                }
              },
              "spec": {
                "replicas": 3,
                "selector": {
                  "matchLabels": {
                    "app": "nginx"
                  }
                },
                "template": {
                  "metadata": {
                    "labels": {
                      "app": "nginx"
                    }
                  },
                  "spec": {
                    "containers": [
                      {
                        "name": "nginx",
                        "image": "nginx:1.14.2",
                        "ports": [
                          {
                            "containerPort": 80
                          }
                        ]
                      }
                    ]
                  }
                }
              }
            }
          },
          "result": "result"
        }
      },
      {
        "returnResult": {
          "return": "${result}"
        }
      }
    ]
  }
}

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

‫CLUSTER_NAME: השם של אשכול GKE, למשל hello-cluster
‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud
‫LOCATION: האזור של האשכול, למשל us-central1

לוחצים על פריסה.

gcloud

יוצרים קובץ קוד מקור לתהליך העבודה:
```
touch kubernetes-api-request.JSON_OR_YAML
```
מחליפים את JSON_OR_YAML ב-yaml או ב-json, בהתאם לפורמט של תהליך העבודה.

בכלי לעריכת טקסט, מעתיקים את זרימת העבודה הבאה לקובץ קוד המקור:

YAML

main:
  steps:
    - create_deployment:
        call: gke.request
        args:
          cluster_id: "CLUSTER_NAME"
          project: "PROJECT_ID"
          location: "LOCATION"
          method: "POST"
          path: "/apis/apps/v1/namespaces/default/deployments"
          body:
            kind: Deployment
            metadata:
              name: nginx-deployment
              labels:
                app: nginx
            spec:
              replicas: 3
              selector:
                matchLabels:
                  app: nginx
              template:
                metadata:
                  labels:
                    app: nginx
                spec:
                  containers:
                    - name: nginx
                      image: nginx:1.14.2
                      ports:
                        - containerPort: 80
        result: result
    - returnResult:
        return: '${result}'

JSON

{
  "main": {
    "steps": [
      {
        "create_deployment": {
          "call": "gke.request",
          "args": {
            "cluster_id": "CLUSTER_NAME",
            "project": "PROJECT_ID",
            "location": "LOCATION",
            "method": "POST",
            "path": "/apis/apps/v1/namespaces/default/deployments",
            "body": {
              "kind": "Deployment",
              "metadata": {
                "name": "nginx-deployment",
                "labels": {
                  "app": "nginx"
                }
              },
              "spec": {
                "replicas": 3,
                "selector": {
                  "matchLabels": {
                    "app": "nginx"
                  }
                },
                "template": {
                  "metadata": {
                    "labels": {
                      "app": "nginx"
                    }
                  },
                  "spec": {
                    "containers": [
                      {
                        "name": "nginx",
                        "image": "nginx:1.14.2",
                        "ports": [
                          {
                            "containerPort": 80
                          }
                        ]
                      }
                    ]
                  }
                }
              }
            }
          },
          "result": "result"
        }
      },
      {
        "returnResult": {
          "return": "${result}"
        }
      }
    ]
  }
}

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

‫CLUSTER_NAME: השם של אשכול GKE, למשל hello-cluster
‫LOCATION: האזור של האשכול, למשל us-central1

פריסת תהליך העבודה:

gcloud workflows deploy kubernetes-api-request \
    --source=kubernetes-api-request.JSON_OR_YAML \
    --location=LOCATION \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

ביצוע תהליך העבודה

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

המסוף

נכנסים לדף Workflows במסוף Google Cloud .

כניסה לדף Workflows
בדף Workflows (תהליכי עבודה), בוחרים את תהליך העבודה הרצוי כדי לעבור לדף הפרטים שלו.
בדף פרטי תהליך העבודה, לוחצים על הפעלה.
לוחצים שוב על Execute.
תוצאות תהליך העבודה מוצגות בחלונית Output.

אם הפעולה בוצעה ללא שגיאות, סטטוס הביצוע יהיה Succeeded וגוף התגובה יוחזר.

gcloud

מריצים את תהליך העבודה:

gcloud workflows run kubernetes-api-request \
    --location=LOCATION

אם הפעולה בוצעה ללא שגיאות, הסטטוס צריך להיות SUCCEEDED וגוף התגובה מוחזר.

שימוש במחבר להרצת משימת Kubernetes

אתם יכולים להשתמש במחבר Kubernetes API כדי לפרוס ולהריץ משימת Kubernetes באשכול GKE. תהליך העבודה הבא יוצר משימת Kubernetes שמריצה סקריפט Bash שחוזר על עצמו ברצף של מספרים. תהליך העבודה ממתין עד 90 שניות לסיום של משימת Kubernetes, אחרת מוצגת שגיאה. אם העבודה מסתיימת, היא נמחקת.

שימו לב: העלאה נחשבת להעלאה שהושלמה אם הסטטוס שלה כולל סוג תנאי של Complete. לדוגמה:

  "status": {
    "conditions": [
      {
        "type": "Complete",
        "status": "True"
      }
    ]
  }

אם העבודה נכשלת, מוחזר תג FailedJobError. לדוגמה:

{
  "tags": ["FailedJobError"]
  "job": {...}
  "message":"Kubernetes job failed"
}

מידע נוסף זמין בדפי ההפניה לפונקציות של מחבר Kubernetes API הבאות:

פריסת תהליך העבודה

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

המסוף

נכנסים לדף Workflows במסוף Google Cloud .

כניסה לדף Workflows
לוחצים על Create.
מזינים שם לתהליך העבודה החדש, למשל kubernetes-api-job.
ברשימה Region בוחרים באפשרות us-central1.
בוחרים את חשבון השירות שיצרתם קודם.
לוחצים על הבא.

בעורך תהליכי העבודה, מזינים את ההגדרה הבאה לתהליך העבודה:

YAML

main:
  steps:
    - init:
        assign:
          - project: "PROJECT_ID"
          - location: "LOCATION"
          - cluster_id: "CLUSTER_NAME"
          - job_name: "JOB_NAME"
          - namespace: "default"
    - create_job:
        call: gke.create_job
        args:
          cluster_id: '${cluster_id}'
          location: '${location}'
          project: '${project}'
          namespace: '${namespace}'
          job:
            apiVersion: batch/v1
            kind: Job
            metadata:
              name: "${job_name}"
            spec:
              template:
                spec:
                  containers:
                    - name: counter
                      image: centos:7
                      command:
                        - "bin/bash"
                        - "-c"
                        - "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                  restartPolicy: Never
        result: job
    - wait_for_job:  # if job fails, raise error with "FailedJobError" tag and "job" field
        call: gke.await_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          timeout: 90  # 90 seconds
        result: completed_job
    - cleanup_job:
        call: gke.delete_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          query:
            propagationPolicy: "Foreground"  # delete child Pods
    - return_job:
        return: '${completed_job}'

JSON

{
  "main": {
    "steps": [
      {
        "init": {
          "assign": [
            {
              "project": "PROJECT_ID"
            },
            {
              "location": "LOCATION"
            },
            {
              "cluster_id": "CLUSTER_NAME"
            },
            {
              "job_name": "JOB_NAME"
            },
            {
              "namespace": "default"
            }
          ]
        }
      },
      {
        "create_job": {
          "call": "gke.create_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "location": "${location}",
            "project": "${project}",
            "namespace": "${namespace}",
            "job": {
              "apiVersion": "batch/v1",
              "kind": "Job",
              "metadata": {
                "name": "${job_name}"
              },
              "spec": {
                "template": {
                  "spec": {
                    "containers": [
                      {
                        "name": "counter",
                        "image": "centos:7",
                        "command": [
                          "bin/bash",
                          "-c",
                          "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                        ]
                      }
                    ],
                    "restartPolicy": "Never"
                  }
                }
              }
            }
          },
          "result": "job"
        }
      },
      {
        "wait_for_job": {
          "call": "gke.await_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "timeout": 90
          },
          "result": "completed_job"
        }
      },
      {
        "cleanup_job": {
          "call": "gke.delete_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "query": {
              "propagationPolicy": "Foreground"
            }
          }
        }
      },
      {
        "return_job": {
          "return": "${completed_job}"
        }
      }
    ]
  }
}

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

‫LOCATION: האזור של האשכול, למשל us-central1
‫CLUSTER_NAME: השם של אשכול GKE, למשל hello-cluster
‫JOB_NAME: השם של משימת Kubernetes, למשל hello-job

לוחצים על פריסה.

gcloud

יוצרים קובץ קוד מקור לתהליך העבודה:
```
touch kubernetes-api-job.JSON_OR_YAML
```
מחליפים את JSON_OR_YAML ב-yaml או ב-json, בהתאם לפורמט של תהליך העבודה.

בכלי לעריכת טקסט, מעתיקים את זרימת העבודה הבאה לקובץ קוד המקור:

YAML

main:
  steps:
    - init:
        assign:
          - project: "PROJECT_ID"
          - location: "LOCATION"
          - cluster_id: "CLUSTER_NAME"
          - job_name: "JOB_NAME"
          - namespace: "default"
    - create_job:
        call: gke.create_job
        args:
          cluster_id: '${cluster_id}'
          location: '${location}'
          project: '${project}'
          namespace: '${namespace}'
          job:
            apiVersion: batch/v1
            kind: Job
            metadata:
              name: "${job_name}"
            spec:
              template:
                spec:
                  containers:
                    - name: counter
                      image: centos:7
                      command:
                        - "bin/bash"
                        - "-c"
                        - "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                  restartPolicy: Never
        result: job
    - wait_for_job:  # if job fails, raise error with "FailedJobError" tag and "job" field
        call: gke.await_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          timeout: 90  # 90 seconds
        result: completed_job
    - cleanup_job:
        call: gke.delete_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          query:
            propagationPolicy: "Foreground"  # delete child Pods
    - return_job:
        return: '${completed_job}'

JSON

{
  "main": {
    "steps": [
      {
        "init": {
          "assign": [
            {
              "project": "PROJECT_ID"
            },
            {
              "location": "LOCATION"
            },
            {
              "cluster_id": "CLUSTER_NAME"
            },
            {
              "job_name": "JOB_NAME"
            },
            {
              "namespace": "default"
            }
          ]
        }
      },
      {
        "create_job": {
          "call": "gke.create_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "location": "${location}",
            "project": "${project}",
            "namespace": "${namespace}",
            "job": {
              "apiVersion": "batch/v1",
              "kind": "Job",
              "metadata": {
                "name": "${job_name}"
              },
              "spec": {
                "template": {
                  "spec": {
                    "containers": [
                      {
                        "name": "counter",
                        "image": "centos:7",
                        "command": [
                          "bin/bash",
                          "-c",
                          "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                        ]
                      }
                    ],
                    "restartPolicy": "Never"
                  }
                }
              }
            }
          },
          "result": "job"
        }
      },
      {
        "wait_for_job": {
          "call": "gke.await_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "timeout": 90
          },
          "result": "completed_job"
        }
      },
      {
        "cleanup_job": {
          "call": "gke.delete_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "query": {
              "propagationPolicy": "Foreground"
            }
          }
        }
      },
      {
        "return_job": {
          "return": "${completed_job}"
        }
      }
    ]
  }
}

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

‫LOCATION: האזור של האשכול, למשל us-central1
‫CLUSTER_NAME: השם של אשכול GKE, למשל hello-cluster
‫JOB_NAME: השם של משימת Kubernetes, למשל hello-job

פריסת תהליך העבודה:

gcloud workflows deploy kubernetes-api-job \
    --source=kubernetes-api-job.JSON_OR_YAML \
    --location=LOCATION \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

ביצוע תהליך העבודה

המסוף

נכנסים לדף Workflows במסוף Google Cloud .

כניסה לדף Workflows
בדף Workflows (תהליכי עבודה), בוחרים את תהליך העבודה הרצוי כדי לעבור לדף הפרטים שלו.
בדף פרטי תהליך העבודה, לוחצים על הפעלה.
לוחצים שוב על Execute.

יכול להיות שיחלפו כמה דקות עד שהזרימה תפעל.

תוצאות תהליך העבודה מוצגות בחלונית Output.

התוצאות אמורות להיות דומות לתוצאות הבאות:

{
...
  },
  "status": {
    "completionTime": "2023-10-31T17:04:32Z",
    "conditions": [
      {
        "lastProbeTime": "2023-10-31T17:04:33Z",
        "lastTransitionTime": "2023-10-31T17:04:33Z",
        "status": "True",
        "type": "Complete"
      }
    ],
    "ready": 0,
    "startTime": "2023-10-31T17:04:28Z",
    "succeeded": 1,
    "uncountedTerminatedPods": {}
  }
}

gcloud

מריצים את תהליך העבודה:

gcloud workflows run kubernetes-api-job \
    --location=LOCATION

יכול להיות שיחלפו כמה דקות עד שהזרימה תפעל. התוצאות אמורות להיות דומות לתוצאות הבאות:

{
...
  },
  "status": {
    "completionTime": "2023-10-31T17:04:32Z",
    "conditions": [
      {
        "lastProbeTime": "2023-10-31T17:04:33Z",
        "lastTransitionTime": "2023-10-31T17:04:33Z",
        "status": "True",
        "type": "Complete"
      }
    ],
    "ready": 0,
    "startTime": "2023-10-31T17:04:28Z",
    "succeeded": 1,
    "uncountedTerminatedPods": {}
  }
}

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

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

הפעלת ממשקי ה-API

המסוף

gcloud

יצירה של חשבון שירות

המסוף

gcloud

יצירת אשכול GKE

המסוף

gcloud

שימוש במחבר לשליחת בקשת HTTP

פריסת תהליך העבודה

המסוף

YAML

JSON

gcloud

YAML

JSON

ביצוע תהליך העבודה

המסוף

gcloud

שימוש במחבר להרצת משימת Kubernetes

פריסת תהליך העבודה

המסוף

YAML

JSON

gcloud

YAML

JSON

ביצוע תהליך העבודה

המסוף

gcloud

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

גישה לאובייקטים של Kubernetes API באמצעות מחבר