פריסת אפליקציית ASP.NET Core ב-Kubernetes ב-Google Kubernetes Engine

1. סקירה כללית

‫ASP.NET Core היא מסגרת חדשה בקוד פתוח ובפלטפורמות שונות ליצירת אפליקציות מודרניות מבוססות-ענן ומחוברות לאינטרנט באמצעות שפת התכנות C#.

‫Kubernetes הוא פרויקט קוד פתוח שיכול לפעול בסביבות שונות, ממחשבים ניידים ועד אשכולות מרובי צמתים עם זמינות גבוהה, מעננים ציבוריים ועד פריסות מקומיות, ממכונות וירטואליות ועד bare metal.

במעבדה הזו תפרסו אפליקציית ASP.NET Core פשוטה ב-Kubernetes שפועל ב-Kubernetes Engine. ה-codelab הזה מבוסס על ה-codelab Build and launch ASP.NET Core app from Google Cloud Shell (פיתוח והשקה של אפליקציית ASP.NET Core מ-Google Cloud Shell). כדאי לבצע את ה-Lab הזה לפני שמנסים את ה-Lab הזה.

המטרה של ה-codelab הזה היא להפוך את הקוד (אפליקציית Hello World פשוטה של ASP.NET Core) לאפליקציה משוכפלת שפועלת ב-Kubernetes. אתם לוקחים קוד שפיתחתם במחשב, הופכים אותו לקובץ אימג' של קונטיינר של Docker, ואז מריצים את הקובץ אימג' הזה ב-Google Kubernetes Engine.

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

לצורך ה-codelab הזה, שימוש בסביבה מנוהלת כמו Kubernetes Engine (גרסה של Kubernetes שמתארחת ב-Google ופועלת ב-Compute Engine) מאפשר לכם להתמקד יותר בהתנסות ב-Kubernetes ולא בהגדרת התשתית הבסיסית.

אם אתם רוצים להריץ Kubernetes במחשב המקומי שלכם, למשל במחשב נייד לפיתוח, כדאי לכם לבדוק את Minikube. האפשרות הזו מאפשרת הגדרה פשוטה של אשכול Kubernetes עם צומת יחיד למטרות פיתוח ובדיקה. אם רוצים, אפשר להשתמש ב-Minikube כדי לעבור על ה-codelab הזה.

מה תלמדו

• איך לארוז אפליקציית ASP.NET Core פשוטה כקובץ Docker.
• איך ליצור אשכול Kubernetes ב-Google Kubernetes Engine‏ (GKE).
• איך פורסים את אפליקציית ASP.NET Core לפוד.
• איך מאפשרים תנועה חיצונית ל-Pod.
• איך מרחיבים את השירות ומשיקים שדרוג.
• איך מריצים לוח בקרה גרפי של Kubernetes.

הדרישות

• דפדפן, כמו Chrome או Firefox

איך תשתמשו במדריך הזה?

רק לקרוא לקרוא ולבצע את התרגילים

איזה דירוג מגיע לדעתך לחוויה שלך עם Google Cloud Platform?

מתחילים ביניים מומחים

2. הגדרה ודרישות

הגדרת סביבה בקצב אישי

1. נכנסים ל-מסוף Google Cloud ויוצרים פרויקט חדש או משתמשים בפרויקט קיים. אם עדיין אין לכם חשבון Gmail או Google Workspace, אתם צריכים ליצור חשבון.

• שם הפרויקט הוא השם המוצג של הפרויקט הזה למשתתפים. זו מחרוזת תווים שלא נמצאת בשימוש ב-Google APIs. אפשר לעדכן את המיקום הזה בכל שלב.
• מזהה הפרויקט חייב להיות ייחודי בכל הפרויקטים ב-Google Cloud, והוא קבוע (אי אפשר לשנות אותו אחרי שמגדירים אותו). מסוף Cloud יוצר באופן אוטומטי מחרוזת ייחודית, ובדרך כלל לא צריך לדעת מה היא. ברוב ה-Codelabs, תצטרכו להפנות למזהה הפרויקט (בדרך כלל הוא מסומן כ-PROJECT_ID). אם אתם לא אוהבים את המזהה שנוצר, אתם יכולים ליצור מזהה אקראי אחר. אפשר גם לנסות שם משתמש משלכם ולבדוק אם הוא זמין. אי אפשר לשנות את ההגדרה הזו אחרי השלב הזה, והיא תישאר כזו למשך הפרויקט.
• לידיעתכם, יש ערך שלישי, מספר פרויקט, שחלק מממשקי ה-API משתמשים בו. במאמרי העזרה מפורט מידע נוסף על שלושת הערכים האלה.

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

הערה: אם אתם משתמשים בחשבון Gmail, אתם יכולים להשאיר את מיקום ברירת המחדל כפי שהוא, ללא ארגון. אם אתם משתמשים בחשבון Google Workspace, אתם צריכים לבחור מיקום שמתאים לארגון שלכם.

2. בשלב הבא, תצטרכו להפעיל את החיוב במסוף Cloud כדי להשתמש במשאבי Cloud או בממשקי API של Cloud. העלות של התרגול הזה לא אמורה להיות גבוהה, ואולי אפילו לא תצטרכו לשלם בכלל. כדי להשבית את המשאבים ולא לחייב אתכם מעבר למדריך הזה, אתם יכולים למחוק את המשאבים שיצרתם או למחוק את כל הפרויקט. משתמשים חדשים ב-Google Cloud זכאים לתוכנית תקופת ניסיון בחינם בשווי 300$.

מפעילים את Cloud Shell

אפשר להפעיל את Google Cloud מרחוק מהמחשב הנייד, אבל ב-codelab הזה תשתמשו ב-Google Cloud Shell, סביבת שורת פקודה שפועלת בענן.

הפעלת Cloud Shell

1. ב-Cloud Console, לוחצים על Activate Cloud Shell .

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

הקצאת המשאבים והחיבור ל-Cloud Shell נמשכים רק כמה רגעים.

המכונה הווירטואלית הזו כוללת את כל הכלים שדרושים למפתחים. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, מה שמשפר מאוד את הביצועים והאימות ברשת. אפשר לבצע את רוב העבודה ב-codelab הזה, אם לא את כולה, באמצעות דפדפן או Chromebook.

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

2. מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שעברתם אימות:

gcloud auth list

פלט הפקודה

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

הערה: כלי שורת הפקודה gcloud הוא כלי שורת הפקודה העוצמתי והמאוחד של Google Cloud. הוא מותקן מראש ב-Cloud Shell. תשימו לב לתמיכה שלו בהשלמה אוטומטית של כרטיסיות. למידע נוסף, ראו סקירה כללית של כלי שורת הפקודה של Google Cloud.

3. מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שפקודת gcloud מכירה את הפרויקט:

gcloud config list project

פלט הפקודה

[core]
project = <PROJECT_ID>

אם לא, אפשר להגדיר אותו באמצעות הפקודה הבאה:

gcloud config set project <PROJECT_ID>

פלט הפקודה

Updated property [core/project].

3. יצירת אפליקציית ASP.NET Core ב-Cloud Shell

בשורת הפקודה של Cloud Shell, אפשר לבדוק את הגרסה של כלי שורת הפקודה dotnet כדי לוודא שהוא כבר מותקן. הפקודה הזו אמורה להדפיס את הגרסה של כלי שורת הפקודה dotnet שהותקן:

dotnet --version

בשלב הבא, יוצרים אפליקציית אינטרנט בסיסית חדשה ב-ASP.NET Core.

dotnet new mvc -o HelloWorldAspNetCore

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

Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.

Restore succeeded.

4. הפעלת אפליקציית ASP.NET Core

כמעט סיימנו להכין את האפליקציה להרצה. עוברים לתיקיית האפליקציה.

cd HelloWorldAspNetCore

לבסוף, מפעילים את האפליקציה.

dotnet run --urls=http://localhost:8080

האפליקציה מתחילה להאזין ביציאה 8080.

Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.

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

יוצג דף האינטרנט שמוגדר כברירת מחדל ב-ASP.NET Core:

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

5. אריזת אפליקציית ASP.NET Core כקונטיינר Docker

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

בספריית הבסיס של האפליקציה, יוצרים קובץ Dockerfile כדי להגדיר את קובץ אימג' של Docker.

touch Dockerfile

מוסיפים את הקוד הבא ל-Dockerfile באמצעות העורך המועדף (vim, nano,emacs או עורך הקוד של Cloud Shell).

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Make sure the app binds to port 8080
ENV ASPNETCORE_URLS http://*:8080

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]

אחת מההגדרות החשובות שכלולות ב-קובץ Docker הוא הפורט שבו האפליקציה מאזינה לתעבורה נכנסת (8080). כדי לעשות את זה, מגדירים את משתנה הסביבה ASPNETCORE_URLS, שאפליקציות ASP.NET Core משתמשות בו כדי לקבוע באיזה פורט להאזין.

שמירת Dockerfile. עכשיו ניצור את התמונה:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .

אחרי שהתהליך יסתיים (ייקח זמן להוריד ולחלץ את כל הנתונים), תוכלו לראות שהתמונה נוצרה ונשמרה באופן מקומי:

docker images

REPOSITORY                             TAG   
gcr.io/yourproject-XXXX/hello-dotnet   v1            

בודקים את קובץ האימג' של הקונטיינר באופן מקומי באמצעות הפקודה הבאה, שתריץ קונטיינר של Docker באופן מקומי ביציאה 8080 מקובץ האימג' החדש של הקונטיינר שיצרתם:

docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

ושוב, אפשר להשתמש בתכונה 'תצוגה מקדימה באינטרנט' של Cloud Shell :

דף האינטרנט של ASP.NET Core שמוגדר כברירת מחדל אמור להופיע בכרטיסייה חדשה.

אחרי שמוודאים שהאפליקציה פועלת בצורה תקינה באופן מקומי בקונטיינר Docker, אפשר לעצור את הקונטיינר הפועל באמצעות Ctrl-> C.

עכשיו, אחרי שקובץ האימג' פועל כמו שרציתם, אתם יכולים להעביר אותו בדחיפה אל Google Container Registry, מאגר פרטי של קובצי Docker שאפשר לגשת אליו מכל פרויקט בענן (אבל גם מחוץ ל-Google Cloud Platform) :

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

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

שימו לב: בדוגמה הזו השתמשנו בדומיין גנרי עבור המרשם (gcr.io), אבל אפשר גם לציין באופן ספציפי יותר באיזה אזור ובאיזו קטגוריה להשתמש. פרטים נוספים מופיעים כאן: https://cloud.google.com/container-registry/docs/#pushing_to_the_registry

אם אתם רוצים, אתם יכולים לעיין בתמונות של הקונטיינרים כפי שהן מאוחסנות ב-Google Cloud Storage. לשם כך, צריך ללחוץ על הקישור הזה: https://console.cloud.google.com/storage/browser/ (הקישור המלא שיווצר צריך להיות מהצורה הזו: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).

6. יצירת אשכול Kubernetes

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

אשכול מורכב משרת API ראשי של Kubernetes שמנוהל על ידי Google ומקבוצה של צמתי עובד. צמתי העובדים הם מכונות וירטואליות של Compute Engine.

נשתמש ב-gcloud CLI מהסשן שלכם ב-Cloud Shell כדי ליצור אשכול. משנים את האזור למקום שקרוב אליכם ( רשימת האזורים). הפעולה תימשך כמה דקות:

gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b

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

Creating cluster hello-dotnet-cluster...done.
Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-dotnet-cluster  europe-west1-b  1.10.7-gke.6

לחלופין, אפשר ליצור את האשכול הזה דרך המסוף שמוצג למעלה: Compute > Kubernetes Engine > Container Clusters > Create a container cluster.

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

עכשיו אמור להיות לכם אשכול Kubernetes שפועל באופן מלא ומבוסס על Google Kubernetes Engine:

עכשיו הגיע הזמן לפרוס את האפליקציה שלכם בקונטיינר באשכול Kubernetes. מעכשיו תשתמשו בשורת הפקודה kubectl (שכבר מוגדרת בסביבת Cloud Shell). בשאר ה-codelab הזה נדרשת גרסת לקוח ושרת של kubernetes בגרסה 1.2 ומעלה. ‫kubectl version יציג את הגרסה הנוכחית של הפקודה.

7. יצירת פריסה

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

יוצרים קובץ hello-dotnet.yaml באמצעות העורך המועדף (vim, nano,emacs או עורך הקוד של Cloud Shell) ומגדירים את פריסת Kubernetes עבור ה-Pod:

חשוב להחליף את YOUR-PROJECT-ID במזהה הפרויקט.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: hello-dotnet
  template:
    metadata:
      labels:
        run: hello-dotnet
    spec:
      containers:
      - name: hello-dotnet
        image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

פריסה למרחב השמות שמוגדר כברירת מחדל באמצעות kubectl:

kubectl apply -f hello-dotnet.yaml

deployment.apps/hello-dotnet created

כפי שאפשר לראות, יצרתם אובייקט פריסה. פריסות הן הדרך המומלצת ליצור פודים ולהתאים אותם לעומס (scale). בדוגמה הזו, פריסה חדשה מנהלת העתק יחיד של Pod שמופעלת בו תמונת hello-dotnet:v1.

כדי לראות את הפריסה שיצרתם, פשוט מריצים את הפקודה:

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   1         1         1            1           37s

כדי להציג את ה-pod שנוצר על ידי הפריסה, מריצים את הפקודה הבאה:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-ztzrb   1/1       Running   0          57s

עכשיו זה זמן טוב לעבור על כמה פקודות מעניינות של kubectl (אף אחת מהן לא תשנה את מצב האשכול, תיעוד מלא זמין כאן):

kubectl get pods
kubectl cluster-info
kubectl config view
kubectl get events
kubectl logs <pod-name>

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

8. התרת תנועה חיצונית

כברירת מחדל, אפשר לגשת ל-Pod רק באמצעות כתובת ה-IP הפנימית שלו בתוך האשכול. כדי לאפשר גישה למאגר hello-dotnet מחוץ לרשת הווירטואלית של Kubernetes, צריך לחשוף את ה-Pod כשירות של Kubernetes.

מ-Cloud Shell אפשר לחשוף את ה-Pod לאינטרנט הציבורי באמצעות הפקודה kubectl expose בשילוב עם הדגל --type="LoadBalancer". חובה להשתמש בדגל הזה כדי ליצור כתובת IP עם גישה חיצונית :

kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080

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

ה-master של Kubernetes יוצר את מאזן העומסים ואת כללי ההעברה, מאגרי היעדים וכללי חומת האש שקשורים ל-Compute Engine, כדי שהשירות יהיה נגיש באופן מלא מחוץ ל-Google Cloud Platform.

כדי למצוא את כתובת ה-IP של השירות שנגישה לציבור, פשוט מבקשים מ-kubectl להציג רשימה של כל השירותים באשכול:

kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-dotnet 10.3.253.62   104.155.20.69   8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

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

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

עכשיו אמורה להיות לך גישה לשירות. כדי לגשת לשירות, צריך להזין את הכתובת הבאה בדפדפן: http://<EXTERNAL_IP>:8080

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

9. הרחבת השירות

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

kubectl scale deployment hello-dotnet --replicas=4

kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         4         4            3           16m

kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m
hello-dotnet-714049816-sh812   1/1       Running   0          1m
hello-dotnet-714049816-ztzrb   1/1       Running   0          16m

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

תרשים שמסכם את המצב של אשכול Kubernetes:

אפשר גם לצמצם את השירות בקלות רבה. כך מצמצמים את מספר הפודים מ-4 ל-2.

kubectl scale deployment hello-dotnet --replicas=2

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

10. בדיקת החוסן

‫Kubernetes (או ליתר דיוק ReplicaSet) עוקב אחרי הפודים, ואם משהו לא בסדר בפוד והוא מושבת, הוא יוצר פוד חדש באופן מיידי. בואו נבדוק את זה ונראה איך זה עובד.

קודם מקבלים את רשימת ה-Pods:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

כדי למחוק אחד מה-pods, מעבירים את שם ה-pod:

kubectl delete pod hello-dotnet-714049816-g4azy

אם תסתכלו שוב על רשימת ה-pods, תראו שנוצר pod חדש והוא מופעל שוב באופן מיידי:

kubectl get pods

NAME                         READY     STATUS           RESTARTS   AGE
hello-dotnet-714049816-abczy   1/1    ContainerCreating  0          1m
hello-dotnet-714049816-rk0u6   1/1    Running            0          1m

11. השקת שדרוג לשירות

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

קודם נשנה את האפליקציה. פותחים את עורך הקוד מ-Cloud Shell.

עוברים אל Index.cshtml בקטע HelloWorldAspNetCore > Views > Home ומעדכנים אחת מההודעות בקרוסלה.

מחפשים את השורה הבאה:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core 

ולשנות אותו כך:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud

שומרים את השינויים וחוזרים אל Cloud Shell. בתוך HelloWorldAspNetCore,, יוצרים את קובץ האימג' של Docker:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 . 

ומבצעים push ל-Container Registry:

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 

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

עכשיו אפשר לעדכן את בקר השכפול לגרסה החדשה של האפליקציה ב-Kubernetes בצורה חלקה. כדי לשנות את התווית של קובץ האימג' בקונטיינר הפועל, צריך לערוך את hello-dotnet deployment הקיים ולשנות את התמונה מ-gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 ל-gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2.

כדי לעשות את זה, משתמשים בפקודה kubectl edit. ייפתח כלי לעריכת טקסט שבו מוצגת הגדרת ה-YAML המלאה של הפריסה. לא צריך להבין את כל הגדרות ה-yaml בשלב הזה, אלא רק להבין שעדכון השדה spec.template.spec.containers.image בהגדרות אומר לפריסה לעדכן את ה-pods כדי להשתמש בתמונה החדשה.

kubectl edit deployment hello-dotnet

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2017-01-06T10:05:28Z
  generation: 3
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-dotnet
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-dotnet
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
        imagePullPolicy: IfNotPresent
        name: hello-dotnet
        ports:
        - containerPort: 8080
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}
      terminationGracePeriodSeconds: 30

אחרי שמבצעים את השינוי, שומרים את הקובץ וסוגרים אותו (כדי לעשות את זה ב-vi, מקישים על Esc, מקלידים :wq ומקישים על Enter).

deployment "hello-dotnet" edited

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

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         5         4            3           1h

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

פרטים נוספים על עדכונים מדורגים זמינים במסמכי התיעוד של Kubernetes.

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

12. Cloud Build

עד עכשיו, יצרנו קונטיינרים באמצעות פקודות Docker רגילות (docker build ...), ואז העברנו את קובץ האימג' באופן ידני אל Container Registry של Google Cloud Platform. אפשר גם להעביר את שני השלבים לצד השרת Cloud Build, שיכול ליצור ולדחוף את קובץ האימג' של הקונטיינר בלי להתקין את Docker באופן מקומי.

קודם צריך להפעיל את Cloud Build API בAPI Manager > Library. מחפשים את Cloud Build ולוחצים על Cloud Build API:

לוחצים על Enable API אם ה-API עדיין לא מופעל. בסוף, אתם אמורים לראות שה-API הופעל באופן הבא:

אחרי שמפעילים את Cloud Build API, אפשר להריץ את הפקודה הבאה כדי ליצור את קובץ האימג' ולדחוף אותו, והכול מתוך שירות Container Builder:

$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3

התמונה מאוחסנת באופן אוטומטי ב-Container Registry.

13. הפעלת לוח הבקרה הגרפי של Kubernetes

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

כדי להגדיר גישה ללוח הבקרה של אשכול Kubernetes, מזינים את הפקודות הבאות בחלון Cloud Shell :

gcloud container clusters get-credentials hello-dotnet-cluster \
    --zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}

kubectl proxy --port 8081

ואז משתמשים שוב בתכונת התצוגה המקדימה של Cloud Shell כדי לעבור ליציאה 8081:

הפעולה הזו אמורה להעביר אתכם לנקודת קצה ל-API. יכול להיות שיוצג לכם דף עם הכיתוב 'אין לך הרשאה', אבל אין סיבה לדאגה. כדי להגיע ללוח הבקרה, מסירים את המחרוזת '?authuser=3' ומחליפים אותה ב-'/ui'.

אתם יכולים ליהנות ממרכז הבקרה הגרפי של Kubernetes ולהשתמש בו לפריסת אפליקציות בקונטיינרים, וגם לניטור ולניהול של האשכולות שלכם.

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

אחרי שמסיימים להשתמש בלוח הבקרה, אפשר להקיש על Control + C כדי לעצור את ה-proxy. סיור במרכז הבקרה

14. רישום ביומן

אפשר להשתמש בפקודה kubectl logs כדי לאחזר את היומנים של קונטיינר שפועל בתוך Kubernetes. כשמשתמשים ב-Google Kubernetes Engine כדי להריץ אשכולות מנוהלים של Kubernetes, כל היומנים מועברים אוטומטית ומאוחסנים ב-Google Cloud Logging. כדי לראות את כל פלט היומן מה-pods, עוברים אל Stackdriver → Logging → Logs במסוף Google Cloud:

אחרי שנכנסים למסוף הרישום ביומן, אפשר לעבור אל GKE Container כדי לראות את כל היומנים שנאספו מ-STDOUT:

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

15. מעולה!

כאן מסתיים ה-codelab הפשוט הזה בנושא התחלת העבודה עם ASP.NET Core ו-Kubernetes. הצגנו כאן רק חלק קטן מהיכולות של הטכנולוגיה הזו, ואנחנו ממליצים לכם להמשיך לחקור אותה בעזרת Podים, בקרי רפליקציה ושירותים משלכם, וגם לבדוק את בקשות לבדיקת תקינות (בדיקות תקינות) ולשקול להשתמש ישירות ב-Kubernetes API.

הסרת המשאבים

זהו! הגיע הזמן לנקות את המשאבים שבהם נעשה שימוש (כדי לחסוך בעלויות ולשמור על סביבת ענן נקייה).

מוחקים את הפריסה (שמוחקת גם את הפודים הפועלים) ואת השירות (שמוחק גם את מאזן העומסים החיצוני):

קודם צריך למחוק את השירות ואת הפריסה, מה שיגרום גם למחיקה של מאזן העומסים החיצוני:

kubectl delete service,deployment hello-dotnet

service "hello-dotnet" deleted
deployment "hello-dotnet" deleted

לאחר מכן, מוחקים את האשכול:

gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b

The following clusters will be deleted.
 - [hello-dotnet-cluster] in [europe-west1-b]
Do you want to continue (Y/n)?  Y
Deleting cluster hello-dotnet-cluster...done.                                                                                                                                                                                            
Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].

הפעולה הזו תמחק את כל המופעים של Google Compute Engine שמריצים את האשכול.

לבסוף, מוחקים את קטגוריית האחסון של Docker registry שמארחת את קובצי האימג' שלכם:

gsutil ls

gs://artifacts.<PROJECT_ID>.appspot.com/

gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

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

מה נכלל

• איך לארוז אפליקציית ASP.NET Core פשוטה כקובץ Docker.
• איך יוצרים אשכול Kubernetes ב-Google Kubernetes Engine.
• איך פורסים את אפליקציית ASP.NET Core לפוד.
• איך מאפשרים תנועה חיצונית ל-Pod.
• איך מרחיבים את השירות ומשיקים שדרוג.
• איך מריצים לוח בקרה גרפי של Kubernetes.

השלבים הבאים

• מידע נוסף על Kubernetes ( http://kubernetes.io/)
• מידע נוסף על Windows ב-Google Cloud Platform
• מידע נוסף על ‎.NET ב-Google Cloud Platform
• מידע נוסף על שרת SQL ב-Google Cloud Platform
• מידע נוסף על Cloud Tools for Visual Studio
• מידע נוסף על Cloud Tools for PowerShell

רישיון

עבודה זו מורשית תחת רישיון Creative Commons שמותנה בייחוס 2.0 כללי.