نشر تطبيق Micronaut يحتوى على Jib على Google Kubernetes Engine

1. نظرة عامة

لمحة عن Micronaut

‫Micronaut هو إطار عمل حديث ومتكامل يستند إلى آلة جافا الافتراضية (JVM) لإنشاء تطبيقات معيارية وسهلة الاختبار للخدمات الدقيقة وتطبيقات الحوسبة بدون خادم. يهدف إطار عمل Micronaut إلى توفير وقت بدء تشغيل رائع وسرعة معالجة بيانات سريعة مع الحد الأدنى من استهلاك الذاكرة. يمكن للمطوّرين استخدام Micronaut في Java أو Groovy أو Kotlin.

توفّر Micronaut ما يلي:

• سرعة بدء التشغيل وانخفاض استهلاك الذاكرة: تعمل أُطر عمل IoC المستندة إلى Reflection على تحميل بيانات Reflection وتخزينها مؤقتًا لكل حقل وطريقة وبنية في الرمز البرمجي، بينما لا يرتبط وقت بدء تشغيل التطبيق واستهلاك الذاكرة في Micronaut بحجم قاعدة الرموز البرمجية.
• برنامج HTTP للعميل تعريفي وتفاعلي ووقت التجميع: يمكنك إنشاء برامج HTTP للعميل تفاعلية وتعريفية، ويتم تنفيذها في وقت التجميع، ما يقلّل من استهلاك الذاكرة.
• خادم HTTP غير حاصر مستند إلى Netty: يسهّل خادم HTTP من Micronaut عرض واجهات برمجة التطبيقات التي يمكن أن تستخدمها برامج HTTP، وذلك بفضل منحنى التعلّم السلس.
• اختبار سريع وسهل: يمكنك إعداد الخوادم والعملاء بسهولة في اختبارات الوحدات وتشغيلها على الفور.
• إدخال الاعتمادية الفعّال في وقت التجميع وبرمجة AOP: توفّر Micronaut واجهة برمجة تطبيقات بسيطة لبرمجة AOP في وقت التجميع لا تستخدم الانعكاس.
• إنشاء تطبيقات تفاعلية بالكامل وغير حاصرة: تتوافق Micronaut مع أي إطار عمل ينفّذ Reactive Streams، بما في ذلك RxJava وReactor.

لمزيد من المعلومات، يُرجى الانتقال إلى موقع Micronaut الإلكتروني.

لمحة عن Kubernetes

‫Kubernetes هو مشروع مفتوح المصدر يمكن تشغيله في العديد من البيئات المختلفة، بدءًا من أجهزة الكمبيوتر المحمول إلى المجموعات المتعددة العُقد ذات التوفّر العالي، ومن السُحب الإلكترونية العامة إلى عمليات النشر المحلية، ومن الأجهزة الافتراضية إلى الأجهزة المجردة.

في هذا الدرس التطبيقي، ستنشر خدمة مصغّرة بسيطة مستندة إلى Groovy في Kubernetes التي تعمل على Kubernetes Engine.

الهدف من هذا الدرس التطبيقي حول الترميز هو تشغيل خدمتك المصغّرة كخدمة مكرّرة تعمل على Kubernetes. يمكنك أخذ الرمز الذي طوّرته على جهازك وتحويله إلى صورة حاوية Docker، ثم تشغيل هذه الصورة على Kubernetes Engine.

إليك رسم بياني للأجزاء المختلفة التي يتم استخدامها في هذا الدرس التطبيقي حول الترميز لمساعدتك في فهم كيفية عملها معًا. استخدِم هذا المستند كمرجع أثناء تقدّمك في درس تطبيقي حول الترميز؛ ومن المفترض أن يصبح كل شيء واضحًا بحلول نهاية الدرس التطبيقي حول الترميز (ولكن يمكنك تجاهل هذا المستند في الوقت الحالي).

لأغراض هذا الدرس التطبيقي حول الترميز، يتيح لك استخدام بيئة مُدارة، مثل Kubernetes Engine (إصدار من Kubernetes تستضيفه Google ويعمل على Compute Engine)، التركيز بشكل أكبر على تجربة Kubernetes بدلاً من إعداد البنية الأساسية.

إذا كنت مهتمًا بتشغيل Kubernetes على جهازك المحلي، مثل جهاز كمبيوتر محمول مخصّص للتطوير، من المفترض أن تبحث عن Minikube. يوفّر هذا الإعداد البسيط لمجموعة واحدة من عقد kubernetes لأغراض التطوير والاختبار. يمكنك استخدام Minikube لتجربة هذا الدرس التطبيقي حول الترميز إذا أردت.

لمحة عن Jib

‫Jib هي أداة مفتوحة المصدر تتيح لك إنشاء صور Docker وOCI لتطبيقات Java. وهي متاحة كمكوّنات إضافية لكلّ من Maven وGradle، وكمكتبة Java.

تهدف Jib إلى أن تكون:

• السرعة: يمكنك نشر تغييراتك بسرعة. يفصل Jib تطبيقك إلى طبقات متعددة، ويقسم التبعيات عن الفئات. لن تحتاج الآن إلى انتظار Docker لإعادة إنشاء تطبيق Java بالكامل، بل يمكنك نشر الطبقات التي تم تغييرها فقط.
• قابلة لإعادة الإنتاج: يؤدي إعادة إنشاء صورة الحاوية باستخدام المحتوى نفسه دائمًا إلى إنشاء الصورة نفسها. لن يتم تشغيل تحديث غير ضروري مرة أخرى.
• بدون عملية خفية: تقليل التبعيات في واجهة سطر الأوامر يمكنك إنشاء صورة Docker من داخل Maven أو Gradle ونشرها في أي سجلّ من اختيارك. لن تحتاج بعد الآن إلى كتابة ملفات Dockerfile واستخدام الأمر 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 (الاسم أعلاه مستخدَم حاليًا ولن يكون متاحًا لك، نأسف لذلك). سيتم الإشارة إليه لاحقًا في هذا الدرس العملي باسم 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 تتضمّن طبقات مختلفة: لعمليات التبعية والموارد والرمز البرمجي الذي تم تجميعه. على سبيل المثال، إذا عدّلت الرمز، سيتم تعديل الطبقة التي تحتوي على الفئات المجمَّعة فقط، ما يؤدي إلى توفير مدّة التصميم من خلال إعادة استخدام الطبقات السابقة التي لم يتم تعديلها.

بعد إنشاء الصورة، لننتقل إلى علامة التبويب الأولى في Cloud Shell ونشغّل صورة Docker للتحقّق ممّا إذا كان بإمكاننا رؤية رسالة الترحيب:

$ 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 (ومن خارج Google Cloud Platform أيضًا).

قبل أن تتمكّن من إرسال البيانات إلى السجلّ، تأكَّد من تفعيل Container Registry لمشروعك من خلال الانتقال إلى الأدوات > Container Registry. إذا لم يتم تفعيلها، سيظهر لك مربع الحوار التالي، يُرجى النقر على تفعيل 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

تتيح الأوامر أعلاه لحزمة تطوير البرامج (SDK) الخاصة بأداة gcloud ضبط 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 في وحدة تحكّم الويب وانتظِر إلى أن يتم تهيئة النظام (لن يستغرق ذلك سوى بضع ثوانٍ).

تتألف المجموعة من خادم واجهة برمجة تطبيقات رئيسي في Kubernetes تديره Google ومجموعة من عُقد العامل. عُقد العامل هي أجهزة Compute Engine الافتراضية. لنستخدِم واجهة سطر الأوامر gcloud من جلسة CloudShell لإنشاء مجموعة تتضمّن عقدتَين من 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 > مجموعات الحاويات > إنشاء مجموعة حاويات.

يمكنك إنشاء المجموعة في منطقة أخرى، ولكن يُنصح بإبقائها في المنطقة نفسها التي يتم فيها استخدام حزمة التخزين المستخدَمة في سجلّ الحاويات (راجِع الخطوة السابقة).

من المفترض أن تتوفّر لديك الآن مجموعة Kubernetes تعمل بكامل طاقتها ومزوّدة بخدمة Google Kubernetes Engine:

حان الوقت الآن لنشر تطبيقك الخاص المحفوظ في حاوية إلى مجموعة Kubernetes. من الآن فصاعدًا، ستستخدم سطر الأوامر kubectl (الذي تم إعداده مسبقًا في بيئة Cloud Shell). تتطلّب بقية هذا الدرس العملي توفّر الإصدار 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 التي يديرها النشر (في هذه الحالة وحدة Pod واحدة فقط، ولكن ستضيف المزيد من النُسخ المتماثلة لاحقًا).

ينشئ خادم 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، انتظِر بضع دقائق وأعِد المحاولة.

يُرجى العِلم أنّ هناك عنوانَي 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 لطلب نشر الإصدار الجديد من تطبيقك على مستوى المجموعة بأكملها، مثيل واحد في كل مرة، باستخدام التحديث المتداول:

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

deployment.apps "hello-micronaut" image updated

وخلال هذه العملية، قد يواجه مستخدمو الخدمات انقطاعًا. لكن ذلك يرجع إلى عدم إعداد عملية تحقّق من الصحة. هذا الإعداد أكثر تقدّمًا بعض الشيء، ولن نضيف عملية التحقّق من الصحة في هذا الدرس التطبيقي.

تحقَّق من http://EXTERNAL_IP:8080 مرة أخرى للتأكّد من أنّه يعرض الرد الجديد.

13. مُعاد إلى الإصدار السابق

عفوًا، هل حدث خطأ في الإصدار الجديد من التطبيق؟ ربما كان الإصدار الجديد يتضمّن خطأ وعليك العودة إلى الحالة السابقة بسرعة. باستخدام Kubernetes، يمكنك العودة إلى الحالة السابقة بسهولة. لنرجع إلى الإصدار السابق من التطبيق من خلال تنفيذ ما يلي:

$ kubectl rollout undo deployment/hello-micronaut

إذا ألقيت نظرة على ناتج الخدمة، ستظهر لك رسالة "Hello World" الأولية.

14. ملخّص

في هذه الخطوة، يمكنك إعداد خدمة بسيطة تستند إلى Apache Groovy من Micronaut hello world وتشغيلها مباشرةً من داخل 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 حيث سيتم إرشادك خلال عملية نشر تطبيق كامل الميزات.

الترخيص

يخضع هذا العمل لترخيص المشاع الإبداعي مع نسب العمل إلى مؤلفه 2.0 Generic License.