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

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

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

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

במעבדה הזו פורסים אפליקציית ASP.NET Core פשוטה ל-Kubernetes שפועל ב-Kubernetes Engine. שיעור ה-Codelab הזה מבוסס על שיעור ה-Codelab יצירה והפעלה של אפליקציית ASP.NET Core מ-Google Cloud Shell. כדאי לעבור קודם את שיעור ה-Lab הזה לפני שמנסים את שיעור ה-Lab הזה.

המטרה של שיעור ה-Codelab הזה היא להפוך את הקוד (אפליקציית ASP.NET Core פשוטה של Hello World) לאפליקציה משוכפלת שפועלת ב-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"]

הגדרה חשובה אחת שכלולה ב-Dockerfile היא היציאה שדרכה האפליקציה מאזינה לתעבורה נכנסת (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

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

דף האינטרנט של 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 הזה נדרשת גרסת 1.2 ומעלה של לקוח ושרת Kubernetes. ‫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

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

השרת הראשי של 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

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

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. הצגנו כאן רק חלק קטן מהיכולות של הטכנולוגיה הזו, ואנחנו ממליצים לך להמשיך לחקור את הנושא בעזרת פודים, בקרי שכפול ושירותים משלך, וגם לבדוק את בדיקות הפעילות (בדיקות תקינות) ולשקול שימוש ישיר ב-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.