این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.

یک برنامه Micronaut محفظه شده با Jib را در Google Kubernetes Engine مستقر کنید

۱. مرور کلی

درباره میکرونات

Micronaut یک چارچوب مدرن، مبتنی بر JVM و فول‌استک برای ساخت برنامه‌های میکروسرویس ماژولار، به راحتی قابل آزمایش و بدون سرور است. Micronaut قصد دارد زمان راه‌اندازی عالی، توان عملیاتی سریع و حداقل فضای حافظه را ارائه دهد. توسعه‌دهندگان می‌توانند با Micronaut در جاوا، Groovy یا Kotlin توسعه دهند.

میکرونات موارد زیر را ارائه می‌دهد:

زمان راه‌اندازی سریع و مصرف کم حافظه - چارچوب‌های IoC مبتنی بر Reflection، داده‌های بازتاب را برای هر فیلد، متد و سازنده در کد شما بارگذاری و ذخیره می‌کنند، در حالی که با Micronaut، زمان راه‌اندازی برنامه و مصرف حافظه شما به اندازه پایگاه کد شما محدود نمی‌شود.
کلاینت HTTP اعلانی، واکنشی، زمان کامپایل — کلاینت‌های HTTP واکنشی را به صورت اعلانی بسازید که در زمان کامپایل پیاده‌سازی می‌شوند و مصرف حافظه را کاهش می‌دهند.
سرور HTTP غیر مسدودکننده ساخته شده بر روی Netty — با یک منحنی یادگیری روان، سرور HTTP Micronaut ارائه APIهایی را که می‌توانند توسط کلاینت‌های HTTP استفاده شوند، تا حد امکان آسان می‌کند.
تست سریع و آسان - به راحتی سرورها و کلاینت‌ها را در تست‌های واحد خود فعال کنید و آنها را فوراً اجرا کنید.
تزریق وابستگی و AOP کارآمد در زمان کامپایل - Micronaut یک API برنامه‌نویسی جنبه‌گرا در زمان کامپایل ساده ارائه می‌دهد که از بازتاب استفاده نمی‌کند.
برنامه‌های کاملاً واکنشی و غیر مسدودکننده بسازید - Micronaut از هر چارچوبی که جریان‌های واکنشی را پیاده‌سازی می‌کند، از جمله RxJava و Reactor، پشتیبانی می‌کند.

برای اطلاعات بیشتر، لطفاً به وب‌سایت Micronaut مراجعه کنید.

درباره کوبرنتیز

کوبرنتیز یک پروژه متن‌باز است که می‌تواند در محیط‌های مختلفی اجرا شود، از لپ‌تاپ‌ها گرفته تا کلاسترهای چندگره‌ای با دسترسی بالا، از ابرهای عمومی گرفته تا استقرارهای درون سازمانی، و از ماشین‌های مجازی گرفته تا سیستم‌های فیزیکی ساده.

در این آزمایش، شما یک میکروسرویس ساده Micronaut مبتنی بر Groovy را در Kubernetes که روی Kubernetes Engine اجرا می‌شود، مستقر می‌کنید.

هدف این آزمایشگاه کد این است که شما بتوانید میکروسرویس خود را به عنوان یک سرویس تکثیر شده که روی Kubernetes اجرا می‌شود، اجرا کنید. شما کدی را که روی دستگاه خود توسعه داده‌اید، می‌گیرید، آن را به یک تصویر کانتینر Docker تبدیل می‌کنید و سپس آن تصویر را روی Kubernetes Engine اجرا می‌کنید.

در اینجا نموداری از بخش‌های مختلف این آزمایشگاه کد آمده است تا به شما در درک نحوه‌ی کنار هم قرار گرفتن قطعات کمک کند. در حین پیشرفت در آزمایشگاه کد، از این به عنوان مرجع استفاده کنید؛ وقتی به پایان می‌رسید، همه چیز باید منطقی به نظر برسد (اما فعلاً می‌توانید از این مورد صرف نظر کنید).

نمودار کد آزمایشگاه Kubernetes 1 (2).png

برای هدف این آزمایشگاه کد، استفاده از یک محیط مدیریت‌شده مانند Kubernetes Engine (نسخه‌ای از Kubernetes که توسط گوگل میزبانی می‌شود و روی Compute Engine اجرا می‌شود) به شما این امکان را می‌دهد که بیشتر بر روی تجربه Kubernetes تمرکز کنید تا راه‌اندازی زیرساخت‌های اساسی.

اگر به اجرای Kubernetes روی دستگاه محلی خود، مانند یک لپ‌تاپ توسعه، علاقه‌مند هستید، احتمالاً باید Minikube را بررسی کنید. این ابزار، راه‌اندازی ساده‌ای از یک کلاستر kubernetes تک گره‌ای را برای اهداف توسعه و آزمایش ارائه می‌دهد. در صورت تمایل می‌توانید از Minikube برای بررسی این آزمایشگاه کد استفاده کنید.

درباره جیب

Jib یک ابزار متن‌باز است که به شما امکان می‌دهد ایمیج‌های Docker و OCI را برای برنامه‌های جاوای خود بسازید. این ابزار به صورت افزونه‌هایی برای Maven و Gradle و همچنین به عنوان یک کتابخانه جاوا در دسترس است.

جیب قصد دارد:

سریع - تغییرات خود را به سرعت اعمال کنید. Jib برنامه شما را به چندین لایه تقسیم می‌کند و وابستگی‌ها را از کلاس‌ها جدا می‌کند. اکنون لازم نیست منتظر بمانید تا Docker کل برنامه جاوا شما را بازسازی کند - فقط لایه‌هایی را که تغییر کرده‌اند، اعمال کنید.
قابلیت تکثیر - بازسازی تصویر کانتینر شما با همان محتوا، همیشه همان تصویر را تولید می‌کند. دیگر هرگز به‌روزرسانی غیرضروری انجام نمی‌شود.
بدون نیاز به Daemon - وابستگی‌های CLI خود را کاهش دهید. تصویر Docker خود را از داخل Maven یا Gradle بسازید و به هر رجیستری دلخواه خود ارسال کنید. دیگر نیازی به نوشتن Dockerfiles و فراخوانی docker build/push نیست.

می‌توانید اطلاعات بیشتر در مورد Jib را در صفحه پروژه Github پیدا کنید.

درباره این آموزش

این آموزش از کد نمونه ابزار Jib برای ساخت کانتینرهایی برای برنامه‌های جاوا استفاده می‌کند.

نمونه، یک سرویس ساده‌ی hello world است که از فریم‌ورک Micronaut و زبان برنامه‌نویسی Apache Groovy استفاده می‌کند.

آنچه یاد خواهید گرفت

نحوه بسته‌بندی یک برنامه ساده جاوا به عنوان یک کانتینر داکر با استفاده از Jib
چگونه کلاستر Kubernetes خود را در Kubernetes Engine ایجاد کنیم؟
نحوه استقرار سرویس Micronaut خود در Kubernetes در Kubernetes Engine
چگونه سرویس خود را گسترش داده و ارتقاء دهید.
نحوه دسترسی به داشبورد گرافیکی Kubernetes.

آنچه نیاز دارید

یک پروژه پلتفرم ابری گوگل
یک مرورگر، مانند کروم یا فایرفاکس
آشنایی با ویرایشگرهای متن استاندارد لینوکس مانند Vim، EMACs یا Nano

چگونه از این آموزش استفاده خواهید کرد؟

فقط تا انتها بخوانید

آن را بخوانید و تمرین‌ها را انجام دهید

تجربه خود را در ساخت برنامه‌های وب HTML/CSS چگونه ارزیابی می‌کنید؟

تازه کار

متوسط

ماهر

تجربه خود را در استفاده از خدمات پلتفرم ابری گوگل چگونه ارزیابی می‌کنید؟

تازه کار

متوسط

ماهر

۲. تنظیمات و الزامات

تنظیم محیط خودتنظیم

وارد Cloud Console شوید و یک پروژه جدید ایجاد کنید یا از یک پروژه موجود دوباره استفاده کنید. (اگر از قبل حساب Gmail یا G Suite ندارید، باید یکی ایجاد کنید .)

dMbN6g9RawQj_VXCSYpdYncY-DbaRzr2GbnwoV7jFf1u3avxJtmGPmKpMYgiaMH-qu80a_NJ9p2IIXFppYk8x3wyymZXavjglNLJJhuXieCem56H30hwXtd8PvXGpXJO9gEUDu3cZw

ci9Oe6PgnbNuSYlMyvbXF1JdQyiHoEgnhl4PlV_MFagm2ppzhueRkqX4eLjJllZco_2zCp0V0bpTupUSKji9KkQyWqj11pqit1K1faS1V6aTQz5GpG0T

8-tA_Lheyo8SscAVKrGii2coplQp2_D1Iosb2ViABY0UUO1A8cimXUu6Wf1R9zJIRExL5 OB2j946aIiFtyKTzxDcNnuznmR45vZ2HMoK3o67jxuoUJCAnqvEX6NgPGFjCVNgASc-lg

شناسه پروژه را به خاطر بسپارید، یک نام منحصر به فرد در تمام پروژه‌های Google Cloud (نام بالا قبلاً گرفته شده و برای شما کار نخواهد کرد، متاسفیم!). بعداً در این آزمایشگاه کد به آن PROJECT_ID گفته خواهد شد.

در مرحله بعد، برای استفاده از منابع گوگل کلود، باید پرداخت را در Cloud Console فعال کنید .

اجرای این آزمایشگاه کد، اگر اصلاً هزینه‌ای نداشته باشد، نباید هزینه زیادی داشته باشد. حتماً دستورالعمل‌های بخش «پاکسازی» را که به شما نحوه خاموش کردن منابع را آموزش می‌دهد، دنبال کنید تا پس از این آموزش، متحمل هزینه نشوید. کاربران جدید Google Cloud واجد شرایط برنامه آزمایشی رایگان ۳۰۰ دلاری هستند.

۳. کد منبع نمونه Micronaut را دریافت کنید

پس از راه‌اندازی Cloud Shell، می‌توانید از خط فرمان برای کپی کردن کد منبع نمونه در دایرکتوری خانگی استفاده کنید و با دستور cd به دایرکتوری حاوی سرویس نمونه ما بروید:

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

۴. نگاهی سریع به کد

سرویس ساده‌ی 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

۵. اجرای برنامه به صورت محلی

شما می‌توانید سرویس Micronaut را به طور معمول با دستور Gradle زیر شروع کنید:

$ ./gradlew run

پس از شروع برنامه، می‌توانید به لطف آیکون کوچک +، یک نمونه Cloud Shell اضافی باز کنید و سپس با curl بررسی کنید که خروجی مورد انتظار را دریافت می‌کنید:

$ curl localhost:8080/hello

و شما باید یک پیام ساده "سلام دنیا" را ببینید که ظاهر می‌شود.

۶. بسته‌بندی برنامه به عنوان یک کانتینر داکر با 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

حالا که ایمیج ما ساخته شده است، بیایید با اجرای ایمیج داکر در اولین تب 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، کانتینر را متوقف کنید.

۷. انتقال سرویس کانتینر شده ما به رجیستری

حالا که ایمیج طبق برنامه کار می‌کند، می‌توانید آن را به Google Container Registry ، یک مخزن خصوصی برای ایمیج‌های داکر شما که از هر پروژه Google Cloud (و همچنین از خارج از پلتفرم Google Cloud) قابل دسترسی است، منتقل کنید.

قبل از اینکه بتوانیم به رجیستری وارد شویم، بیایید با رفتن به Tools > Container Registry مطمئن شویم که 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 شما ارسال کند، تصویر را به محل آن در رجیستری برچسب‌گذاری کند و سپس آن را به رجیستری ارسال کند.

اگر همه چیز خوب پیش برود، پس از مدتی باید بتوانید تصویر کانتینر را در کنسول مشاهده کنید: ابزارها > رجیستری کانتینر . در این مرحله، شما یک تصویر داکر در سطح پروژه دارید که Kubernetes می‌تواند به آن دسترسی داشته باشد و آن را هماهنگ کند، همانطور که در چند دقیقه آینده خواهید دید.

۱۲۲۲۴c4e42183b4e.png

۸. خوشه خود را ایجاد کنید

بسیار خب، اکنون آماده ایجاد خوشه Kubernetes Engine خود هستید، اما قبل از آن، به بخش Google Kubernetes Engine در کنسول وب بروید و منتظر بمانید تا سیستم راه‌اندازی شود (فقط چند ثانیه طول می‌کشد).

یک کلاستر شامل یک سرور API اصلی Kubernetes است که توسط گوگل مدیریت می‌شود و مجموعه‌ای از گره‌های کارگر. گره‌های کارگر، ماشین‌های مجازی 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

اکنون باید یک کلاستر Kubernetes کاملاً کارآمد داشته باشید که توسط Google Kubernetes Engine پشتیبانی می‌شود:

اکنون زمان آن رسیده است که برنامه کانتینر شده خود را در کلاستر Kubernetes مستقر کنید! از این پس از خط فرمان kubectl (که از قبل در محیط Cloud Shell شما تنظیم شده است) استفاده خواهید کرد. ادامه این آزمایشگاه کد نیاز دارد که نسخه کلاینت و سرور Kubernetes هر دو ۱.۲ یا بالاتر باشد. kubectl version نسخه فعلی دستور را به شما نشان می‌دهد.

۹. برنامه خود را روی Kubernetes مستقر کنید

یک استقرار Kubernetes می‌تواند چندین نمونه از برنامه شما را با استفاده از تصویر کانتینری که اخیراً ایجاد کرده‌اید، ایجاد، مدیریت و مقیاس‌بندی کند. بیایید با استفاده از دستور kubectl create deployment یک استقرار از برنامه خود را در Kubernetes ایجاد کنیم:

$ 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 در حال اجرا باشد، اما هنوز باید آن را برای دنیای خارج قابل دسترسی کنید.

۱۰. اجازه دادن به ترافیک خارجی

به طور پیش‌فرض، پاد فقط از طریق IP داخلی خود در داخل کلاستر قابل دسترسی است. برای اینکه کانتینر hello-micronaut از خارج از شبکه مجازی kubernetes قابل دسترسی باشد، باید پاد را به عنوان یک سرویس kubernetes در معرض نمایش قرار دهید.

از طریق Cloud Shell می‌توانید با استفاده از دستور kubectl expose به همراه پرچم --type=LoadBalancer پاد را در معرض اینترنت عمومی قرار دهید. این پرچم برای ایجاد یک IP قابل دسترسی از خارج مورد نیاز است:

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

پرچم استفاده شده در این دستور مشخص می‌کند که شما از متعادل‌کننده بار ارائه شده توسط زیرساخت اصلی (در این مورد متعادل‌کننده بار موتور محاسباتی ) استفاده خواهید کرد. توجه داشته باشید که شما استقرار را در معرض دید قرار می‌دهید، نه مستقیماً پاد را. این باعث می‌شود سرویس حاصل، ترافیک را در تمام پادهای مدیریت شده توسط استقرار متعادل کند (در این مورد فقط ۱ پاد، اما بعداً کپی‌های بیشتری اضافه خواهید کرد).

Kubernetes master، متعادل‌کننده بار و قوانین مربوط به ارسال موتور محاسباتی، مخازن هدف و قوانین فایروال را ایجاد می‌کند تا سرویس را از خارج از پلتفرم ابری گوگل کاملاً در دسترس قرار دهد.

برای یافتن آدرس 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

توجه داشته باشید که دو آدرس IP برای سرویس شما فهرست شده است که هر دو به پورت 8080 سرویس می‌دهند. یکی IP داخلی است که فقط در داخل شبکه مجازی ابری شما قابل مشاهده است؛ دیگری IP خارجی با بارگذاری متعادل است. در این مثال، آدرس IP خارجی aaa.bbb.ccc.ddd است.

اکنون باید بتوانید با قرار دادن مرورگر خود روی این آدرس به سرویس دسترسی پیدا کنید: http://<EXTERNAL_IP> :8080 /hello

۱۱. خدمات خود را گسترش دهید

یکی از ویژگی‌های قدرتمند ارائه شده توسط 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 به سادگی اطمینان حاصل می‌کنند که واقعیت با آنچه شما درخواست کرده‌اید مطابقت دارد و در صورت نیاز اقدام می‌کنند.

۱۲. خدمات خود را ارتقا دهید

در برهه‌ای از زمان، برنامه‌ای که به محیط عملیاتی منتقل کرده‌اید، نیاز به رفع اشکالات یا ویژگی‌های اضافی خواهد داشت. کوبرنتیز اینجاست تا به شما کمک کند نسخه جدیدی را بدون تأثیر بر کاربران، به محیط عملیاتی منتقل کنید.

ابتدا، بیایید برنامه را تغییر دهیم. ویرایشگر کد را از 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 ، با به‌روزرسانی این خط، نسخه تصویر خود را از ۰.۱ به ۰.۲ ارتقا خواهیم داد:

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

دوباره http://EXTERNAL_IP:8080 را بررسی کنید تا ببینید آیا پاسخ جدید را برمی‌گرداند یا خیر.

۱۳. به عقب برگردید

اوه - آیا در نسخه جدید برنامه اشتباه کردید؟ شاید نسخه جدید حاوی خطایی باشد و شما نیاز دارید که به سرعت به حالت قبل برگردید. با Kubernetes، می‌توانید به راحتی به حالت قبل برگردید. بیایید با اجرای دستور زیر برنامه را به حالت قبل بازگردانیم:

$ kubectl rollout undo deployment/hello-micronaut

اگر به خروجی سرویس نگاهی بیندازید، به پیام اولیه‌ی «سلام دنیا» برمی‌گردیم.

۱۴. خلاصه

در این مرحله، شما یک سرویس ساده‌ی Hello World مبتنی بر Apache Groovy به نام Micronaut راه‌اندازی کردید و آن را مستقیماً از داخل Cloud Shell اجرا کردید، آن را به عنوان یک کانتینر با Jib بسته‌بندی کردید و در Google Kubernetes Engine مستقر نمودید.

۱۵. تبریک می‌گویم!

شما یاد گرفتید که چگونه یک میکروسرویس جدید مبتنی بر وب Apache Groovy / Micronaut را روی Kubernetes روی Google Kubernetes Engine بسازید و مستقر کنید.

اطلاعات بیشتر

مستندات و نمونه‌های Jib: https://github.com/GoogleContainerTools/jib/
وب‌سایت میکرونات: http://micronaut.io/
جاوا در پلتفرم ابری گوگل: https://cloud.google.com/java/
برای مثال‌های جاوا: https://cloud.google.com/java/samples
برای آموزش کامل‌تر و طولانی‌تر Kubernetes، به bit.ly/k8s-lab مراجعه کنید که در آن نحوه‌ی استقرار یک برنامه‌ی فول‌استک را خواهید آموخت.

مجوز

این اثر تحت مجوز عمومی Creative Commons Attribution 2.0 منتشر شده است.