פריסת אפליקציית מיקרונאוט בקונטיינרים באמצעות Jib ל-Google Kubernetes Engine

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

מידע על Micronaut

‫Micronaut היא מסגרת מודרנית מבוססת-JVM, מלאה, ליצירת מיקרו-שירותים מודולריים ואפליקציות ללא שרת (serverless) שקל לבדוק. היעד של Micronaut הוא לספק זמן הפעלה קצר, קצב העברה מהיר ושימוש מינימלי בזיכרון. מפתחים יכולים לפתח באמצעות Micronaut ב-Java, ב-Groovy או ב-Kotlin.

‫Micronaut מספק:

• זמן הפעלה מהיר וצריכת זיכרון נמוכה – מסגרות IoC שמבוססות על רפלקציה טוענות ומאחסנות במטמון נתוני רפלקציה לכל שדה, שיטה ובונה בקוד, בעוד שב-Micronaut, זמן ההפעלה של האפליקציה וצריכת הזיכרון לא מוגבלים לגודל בסיס הקוד.
• לקוח HTTP הצהרתי, תגובתי, בזמן קומפילציה – אפשר ליצור לקוחות HTTP תגובתיים באופן הצהרתי, והם מיושמים בזמן הקומפילציה, וכך מצמצמים את צריכת הזיכרון.
• שרת HTTP לא חוסם שמבוסס על Netty – שרת ה-HTTP של Micronaut מאפשר לכם לחשוף ממשקי API שניתן לצרוך על ידי צד הלקוח ב-HTTP בקלות רבה, עם עקומת למידה חלקה.
• בדיקות מהירות ופשוטות – אפשר להפעיל בקלות שרתים ולקוחות בבדיקות היחידה ולהריץ אותם באופן מיידי.
• הזרקת תלות יעילה בזמן קומפילציה ו-AOP –‏ Micronaut מספק API פשוט לתכנות מונחה-היבטים בזמן קומפילציה שלא משתמש ברפלקציה.
• פיתוח אפליקציות לא חוסמות עם תגובה מלאה –‏ Micronaut תומכת בכל מסגרת שמטמיעה Reactive Streams, כולל RxJava ו-Reactor.

מידע נוסף זמין באתר האינטרנט של Micronaut.

מידע על Kubernetes

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

במעבדה הזו תפרסו מיקרו-שירות פשוט של Micronaut מבוסס-Groovy ב-Kubernetes שפועל ב-Kubernetes Engine.

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

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

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

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

מידע על Jib

‫Jib הוא כלי בקוד פתוח שמאפשר ליצור קובצי אימג' של Docker ו-OCI לאפליקציות Java. הוא זמין כתוסף ל-Maven ול-Gradle, וכספריית Java.

השאיפה של Jib היא להיות:

• מהירות – הטמעה מהירה של השינויים. ‫Jib מפריד את האפליקציה לכמה שכבות, ומפצל את התלויות מהמחלקות. עכשיו לא צריך לחכות ש-Docker יבנה מחדש את כל אפליקציית Java – אפשר פשוט לפרוס את השכבות שהשתנו.
• ניתן לשחזור – בנייה מחדש של קובץ אימג' של קונטיינר עם אותם תכנים תמיד יוצרת את אותו קובץ אימג' של קונטיינר. לא תפעילו יותר עדכון מיותר.
• ללא שירות רקע – צמצום התלות ב-CLI. יוצרים את קובץ האימג' של Docker מתוך Maven או Gradle ומעבירים אותו בדחיפה לכל מאגר שתבחרו. לא צריך יותר לכתוב קובצי Docker ולבצע docker build/push.

מידע נוסף על Jib זמין בדף הפרויקט ב-GitHub.

מידע על המדריך הזה

במדריך הזה נעשה שימוש בקוד לדוגמה מהכלי Jib כדי ליצור קונטיינרים לאפליקציות Java.

הדוגמה היא שירות פשוט של hello world, שמשתמש במסגרת Micronaut ובשפת התכנות Apache Groovy.

מה תלמדו

• איך לארוז אפליקציית Java פשוטה כקונטיינר Docker באמצעות Jib
• איך ליצור אשכול Kubernetes ב-Kubernetes Engine.
• איך פורסים את שירות Micronaut ב-Kubernetes ב-Kubernetes Engine
• איך מרחיבים את השירות ומשיקים שדרוג.
• איך לגשת למרכז הבקרה הגרפי של Kubernetes.

מה תצטרכו

• פרויקט ב-Google Cloud Platform
• דפדפן, כמו Chrome או Firefox
• היכרות עם כלים לעריכת טקסט של Linux, כמו Vim,‏ EMACs או Nano

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

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

מה מידת שביעות הרצון שלך מחוויית השימוש ב-HTML/CSS ליצירת אפליקציות אינטרנט?

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

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

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

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

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

1. נכנסים אל Cloud Console ויוצרים פרויקט חדש או משתמשים בפרויקט קיים. (אם עדיין אין לכם חשבון Gmail או G Suite, אתם צריכים ליצור חשבון).

הערה: אפשר לגשת בקלות ל-Cloud Console אם זוכרים את כתובת ה-URL שלו, שהיא console.cloud.google.com.

חשוב לזכור את מזהה הפרויקט, שהוא שם ייחודי בכל הפרויקטים ב-Google Cloud (השם שלמעלה כבר תפוס ולא יתאים לכם, מצטערים!). בהמשך ה-codelab הזה נתייחס אליו כאל PROJECT_ID.

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

2. לאחר מכן, תצטרכו להפעיל את החיוב ב-Cloud Console כדי להשתמש במשאבים של Google Cloud.

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

3. קבלת קוד המקור לדוגמה של Micronaut

אחרי ש-Cloud Shell מופעל, אפשר להשתמש בשורת הפקודה כדי לשכפל את קוד המקור לדוגמה בספריית הבית, ולעבור לספרייה שמכילה את שירות הדוגמה שלנו:

$ git clone https://github.com/GoogleContainerTools/jib.git
$ cd jib/examples/micronaut/

מאגר הפרויקטים של Jib מכיל גם פרויקטים לדוגמה למסגרות אחרות, כמו Spring Boot או Vert.x, אם אתם רוצים להתנסות בדוגמאות אחרות.

4. סקירה מהירה של הקוד

השירות הפשוט שלנו ב-Micronaut מורכב מבקר שמפיק את ההודעה הידועה לשמצה Hello World:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello World"
    }
}

הבקר HelloController מגיב לבקשות בנתיב /hello, והשיטה index() מקבלת את בקשות ה-HTTP GET.

יש גם מחלקת בדיקה של Spock כדי לוודא שההודעה הנכונה מופיעה בפלט.

class HelloControllerSpec extends Specification {
    @Shared
    @AutoCleanup
    EmbeddedServer embeddedServer = ApplicationContext.run(EmbeddedServer)

    @Shared
    @AutoCleanup
    RxHttpClient client = embeddedServer.applicationContext.createBean(RxHttpClient, embeddedServer.getURL()) 

    void "test hello world response"() {
        when:
        HttpRequest request = HttpRequest.GET('/hello')
        String rsp  = client.toBlocking().retrieve(request)

        then:
        rsp == "Hello World"
    }
}

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

כדי להריץ את הבדיקות, אפשר להריץ את הפקודה הבאה כדי לוודא שהכול תקין:

./gradlew test

5. הרצת האפליקציה באופן מקומי

אפשר להפעיל את שירות Micronaut כרגיל באמצעות פקודת Gradle הבאה:

$ ./gradlew run

אחרי שהאפליקציה תתחיל לפעול, תוכלו לפתוח עוד מופע של Cloud Shell באמצעות סמל הפלוס הקטן, ואז לבדוק באמצעות curl שמתקבל הפלט הצפוי:

$ curl localhost:8080/hello

אמורה להופיע הודעה פשוטה עם הכיתוב Hello World.

6. אריזת האפליקציה כקונטיינר Docker באמצעות Jib

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

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

$ ./gradlew jibDockerBuild

זה הפלט שצריך להופיע:

Tagging image with generated image reference micronaut-jib:0.1. If you'd like to specify a different tag, you can set the jib.to.image parameter in your build.gradle, or use the --im
age=<MY IMAGE> commandline flag.

Containerizing application to Docker daemon as micronaut-jib:0.1...
warning: Base image 'gcr.io/distroless/java' does not use a specific image digest - build may not be reproducible
Getting base image gcr.io/distroless/java...
Building dependencies layer...
Building resources layer...
Building classes layer...
Finalizing...

Container entrypoint set to [java, -cp, /app/resources:/app/classes:/app/libs/*, example.micronaut.Application]
Loading to Docker daemon...

Built image to Docker daemon as micronaut-jib:0.1

‫Jib יוצר קובץ אימג' של Docker עם שכבות שונות: עבור יחסי התלות, עבור המשאבים ועבור הקוד שעבר קומפילציה. לדוגמה, אם משנים את הקוד, רק השכבה עם המחלקות המהודרות תשתנה, וכך יתקצר משך זמן של תהליך build כי נעשה שימוש חוזר בשכבות קודמות שלא השתנו.

אחרי שיצרנו את קובץ האימג', נבדוק אם אנחנו יכולים לראות את הודעת השלום הידידותית שלנו. לשם כך, נריץ את קובץ האימג' של Docker בכרטיסייה הראשונה של Cloud Shell:

$ docker run -it -p 8080:8080 micronaut-jib:0.1
16:57:20.255 [main] INFO  i.m.context.env.DefaultEnvironment - Established active environments: [cloud, gcp]
16:57:23.203 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 2926ms. Server Running: http://97b7d76ccf3f:8080

השירות שלנו פועל, אז עכשיו אנחנו יכולים להריץ את פקודת curl בכרטיסייה השנייה של Cloud Shell, כדי לבדוק אם הוא פועל כמו שציפינו:

$ curl localhost:8080/hello
Hello World

אפשר להפסיק את הקונטיינר על ידי הקשה על Ctrl+C ב-Cloud Shell.

7. העברת השירות שלנו בקונטיינר אל המאגר

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

לפני שדוחפים את התמונה ל-Container Registry, צריך לוודא ש-Container Registry מופעל בפרויקט. לשם כך, עוברים אל Tools > Container Registry. אם היא לא מופעלת, יופיע הדו-שיח הבא, ואז צריך ללחוץ על Enable Container Registry API כדי להפעיל אותה:

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

$ gcloud auth configure-docker
$ docker tag micronaut-jib:0.1 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

הפקודות שלמעלה מאפשרות ל-gcloud SDK להגדיר את Docker ולתת לו הרשאה להעביר תמונות בדחיפה למופע של Container Registry, לתייג את התמונה כדי להצביע על המיקום שלה במאגר ואז להעביר אותה בדחיפה למאגר.

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

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

8. יצירת האשכול

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

אשכול מורכב משרת API ראשי של Kubernetes שמנוהל על ידי Google ומקבוצה של צמתי עובד. צמתי העובדים הם מכונות וירטואליות של Compute Engine. נשתמש ב-gcloud CLI מהסשן של Cloud Shell כדי ליצור אשכול עם שני צמתים של n1-standard-1 (התהליך יימשך כמה דקות):

$ gcloud container clusters create hello-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

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

Creating cluster hello-cluster in us-central1-c...done.
Created [https://container.googleapis.com/v1/projects/mn-gke-test/zones/us-central1-c/clusters/hello-cluster].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-central1-c/hello-cluster?project=mn-gke-test
kubeconfig entry generated for hello-cluster.
NAME           LOCATION       MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
hello-cluster  us-central1-c  1.9.7-gke.7     35.239.224.115  n1-standard-1  1.9.7-gke.7   2          RUNNING

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

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

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

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

9. פריסת האפליקציה ב-Kubernetes

פריסת Kubernetes יכולה ליצור, לנהל ולשנות את גודלן של כמה מכונות של האפליקציה באמצעות קובץ האימג' של הקונטיינר שיצרתם. ניצור פריסה של האפליקציה ב-Kubernetes באמצעות הפקודה kubectl create deployment:

$ kubectl create deployment hello-micronaut \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

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

$ kubectl get deployments
NAME              DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-micronaut   1         1         1            1           5m

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

$ kubectl get pods
NAME                               READY     STATUS    RESTARTS   AGE
hello-micronaut-5647fb98c5-lh5h7   1/1       Running   0          5m

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

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

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

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

$ kubectl expose deployment hello-micronaut --type=LoadBalancer --port=8080

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

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

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

$ kubectl get services
NAME              TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
hello-micronaut   LoadBalancer   10.39.243.251   aaa.bbb.ccc.ddd 8080:30354/TCP   1m
kubernetes        ClusterIP      10.39.240.1     <none>          443/TCP          31m

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

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

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

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

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

$ kubectl scale deployment hello-micronaut --replicas=3
deployment.extensions "hello-micronaut" scaled

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

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

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

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

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

עוברים אל /jib/examples/micronaut/src/main/groovy/example/micronaut/HelloController.groovy ומעדכנים את ערך התשובה:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello Kubernetes World"
    }
}

ב-/jib/examples/micronaut/build.gradle, נשדרג את גרסת התמונה מ-0.1 ל-0.2 על ידי עדכון השורה הזו:

version '0.2'

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

$ ./gradlew jibDockerBuild

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

$ docker tag micronaut-jib:0.2 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

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

עכשיו אפשר לעדכן את בקר השכפול לגרסה החדשה של האפליקציה ב-Kubernetes בצורה חלקה. כדי לשנות את התווית של קובץ האימג' בקונטיינר הפועל, צריך לערוך את hello-micronaut deployment הקיים ולשנות את התמונה מ-gcr.io/PROJECT_ID/micronaut-jib:0.1 ל-gcr.io/PROJECT_ID/micronaut-jib:0.2.

אפשר להשתמש בפקודה kubectl set image כדי לבקש מ-Kubernetes לפרוס את הגרסה החדשה של האפליקציה בכל האשכול, מופע אחד בכל פעם, באמצעות עדכון מדורג:

$ kubectl set image deployment/hello-micronaut \
          micronaut-jib=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

deployment.apps "hello-micronaut" image updated

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

כדאי לבדוק שוב את הכתובת http://EXTERNAL_IP:8080 כדי לוודא שהתשובה החדשה חוזרת.

13. הוחזר למצב קודם

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

$ kubectl rollout undo deployment/hello-micronaut

אם תסתכלו על הפלט של השירות, תראו שחזרנו להודעה הראשונית 'Hello World'.

14. סיכום

בשלב הזה, מגדירים שירות פשוט של Micronaut hello world שמבוסס על Apache Groovy ומריצים אותו ישירות מתוך Cloud Shell, אורזים אותו כקונטיינר באמצעות Jib ומפריסים אותו ב-Google Kubernetes Engine.

15. מעולה!

למדתם איך ליצור ולפרוס מיקרו-שירות חדש מבוסס-אינטרנט של Apache Groovy / Micronaut ב-Kubernetes ב-Google Kubernetes Engine.

מידע נוסף

• דוגמאות ומסמכי תיעוד של Jib: ‏ https://github.com/GoogleContainerTools/jib/
• אתר האינטרנט של Micronaut: http://micronaut.io/
• ‫Java ב-Google Cloud Platform: ‏ https://cloud.google.com/java/
• דוגמאות ל-Java: https://cloud.google.com/java/samples
• למדריך ארוך ומלא יותר בנושא Kubernetes, אפשר לעבור אל bit.ly/k8s-lab, שבו מוסבר איך לפרוס אפליקציה מלאה.

רישיון

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