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

1. نظرة عامة

لمحة عن Micronaut

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

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

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

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

لمحة عن Kubernetes

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

في هذا الدرس التطبيقي، ستنشر خدمة مصغّرة بسيطة مستندة إلى Groovy من Micronaut على 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 تتضمّن طبقات مختلفة: لعمليات التبعية والموارد والرمز البرمجي المجمَّع. على سبيل المثال، إذا عدّلت الرمز، سيتم تعديل الطبقة التي تحتوي على الفئات المجمَّعة فقط، ما يؤدي إلى توفير مدّة التصميم من خلال إعادة استخدام الطبقات السابقة التي لم يتم تعديلها.

بعد إنشاء الصورة، لننتقل إلى التحقّق مما إذا كان بإمكاننا رؤية رسالة الترحيب من خلال تشغيل صورة 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 (وكذلك من خارج 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 حيث سيتم إرشادك خلال عملية نشر تطبيق كامل الميزات.

الترخيص

يخضع هذا العمل لترخيص Creative Commons Attribution 2.0 Generic License.