Triển khai một ứng dụng Micronaut được chứa từ Jib đến Google Kubernetes Engine

1. Tổng quan

Giới thiệu về Micronaut

Micronaut là một khung full-stack hiện đại dựa trên JVM, dùng để xây dựng các mô-đun, dịch vụ vi mô và ứng dụng không máy chủ có thể kiểm thử dễ dàng. Mục tiêu của Micronaut là mang lại thời gian khởi động lớn, công suất nhanh và sử dụng bộ nhớ ở mức tối thiểu. Nhà phát triển có thể phát triển bằng Micronaut trong Java, Groovy hoặc Kotlin.

Micronaut cung cấp:

• Thời gian khởi động nhanh và mức tiêu thụ bộ nhớ thấp – Các khung IoC dựa trên phản chiếu sẽ tải và dữ liệu phản ánh bộ nhớ đệm cho mọi trường, phương thức và hàm khởi tạo trong mã của bạn. Trong khi đó, với Micronaut, thời gian khởi động ứng dụng và mức tiêu thụ bộ nhớ không bị ràng buộc bởi dung lượng cơ sở mã của bạn.
• Ứng dụng HTTP khai báo, phản ứng, tại thời điểm biên dịch – Khai báo tạo các ứng dụng HTTP phản ứng được triển khai tại thời điểm biên dịch, giúp giảm mức sử dụng bộ nhớ.
• Máy chủ HTTP không chặn xây dựng trên Netty — Với lộ trình học tập mượt mà, máy chủ HTTP của Micronaut giúp việc hiển thị các API mà máy khách HTTP có thể sử dụng một cách dễ dàng nhất có thể.
• Kiểm thử nhanh chóng và dễ dàng – Dễ dàng xoay vòng các máy chủ và ứng dụng trong các bài kiểm thử đơn vị và chạy chúng ngay lập tức.
• Chèn phần phụ thuộc trong thời gian biên dịch và AOP một cách hiệu quả – Micronaut cung cấp một API lập trình đơn giản hướng đến khía cạnh thời gian biên dịch và không sử dụng tính năng phản chiếu.
• Xây dựng các ứng dụng hoàn toàn phản ứng và không chặn – Micronaut hỗ trợ mọi khung triển khai Luồng phản ứng, bao gồm cả RxJava và React.

Để biết thêm thông tin, vui lòng truy cập vào trang web của Micronaut.

Giới thiệu về Kubernetes

Kubernetes là một dự án nguồn mở có thể chạy trên nhiều môi trường, từ máy tính xách tay cho đến cụm nhiều nút có khả năng hoạt động cao, từ đám mây công cộng đến triển khai tại chỗ, từ máy ảo đến kim loại trần.

Trong phòng thí nghiệm này, bạn triển khai một dịch vụ vi mô đơn giản dựa trên Groovy Micronaut cho Kubernetes chạy trên Kubernetes Engine.

Mục tiêu của lớp học lập trình này là giúp bạn chạy dịch vụ vi mô dưới dạng một dịch vụ được sao chép trên Kubernetes. Bạn lấy mã đã phát triển trên máy, biến mã đó thành hình ảnh vùng chứa Docker, rồi chạy hình ảnh đó trên Kubernetes Engine.

Dưới đây là sơ đồ gồm các phần đang hoạt động trong lớp học lập trình này để giúp bạn hiểu cách các thành phần kết hợp với nhau. Hãy dùng nội dung này làm tài liệu tham khảo khi tham gia lớp học lập trình; mọi thông tin sẽ có ý nghĩa vào thời điểm cuối cùng (nhưng tạm thời hãy bỏ qua phần này).

Để phục vụ mục đích của lớp học lập trình này, việc sử dụng một môi trường được quản lý như Kubernetes Engine (phiên bản Kubernetes chạy trên Compute Engine do Google lưu trữ) cho phép bạn tập trung nhiều hơn vào việc trải nghiệm Kubernetes thay vì thiết lập cơ sở hạ tầng cơ bản.

Nếu muốn chạy Kubernetes trên máy cục bộ, chẳng hạn như máy tính xách tay phát triển, bạn nên cân nhắc sử dụng Minikube. Giải pháp này cung cấp cách thiết lập đơn giản cho một cụm kubernetes nút duy nhất cho mục đích phát triển và thử nghiệm. Bạn có thể dùng Minikube để tham gia lớp học lập trình này nếu muốn.

Giới thiệu về Jib

Jib là một công cụ nguồn mở cho phép bạn tạo hình ảnh Docker và OCI cho các ứng dụng Java. Trình bổ trợ này được cung cấp dưới dạng trình bổ trợ cho Maven và Gradle và dưới dạng một thư viện Java.

Mục tiêu của Jib là:

• Nhanh chóng – Triển khai nhanh các thay đổi. Jib tách ứng dụng của bạn thành nhiều lớp, chia các phần phụ thuộc khỏi các lớp. Giờ đây, bạn không phải đợi Docker xây dựng lại toàn bộ ứng dụng Java – chỉ cần triển khai các lớp đã thay đổi.
• Có thể tái tạo — Việc tạo lại hình ảnh vùng chứa có cùng nội dung sẽ luôn tạo ra cùng một hình ảnh. Không bao giờ kích hoạt lại bản cập nhật không cần thiết.
• Không độc hại – Giảm các phần phụ thuộc CLI. Tạo hình ảnh Docker của bạn từ bên trong Maven hoặc Gradle rồi đẩy vào bất kỳ sổ đăng ký nào bạn chọn. Bạn không còn phải viết Dockerfiles và gọi bản dựng/đẩy docker nữa.

Bạn có thể tìm thêm thông tin về Jib trên trang dự án GitHub.

Giới thiệu về hướng dẫn này

Hướng dẫn này sử dụng mã mẫu trong công cụ Jib để tạo vùng chứa cho các ứng dụng Java.

Mẫu này là một dịch vụ hello world đơn giản, sử dụng khung Micronaut và ngôn ngữ lập trình Apache Groovy.

Kiến thức bạn sẽ học được

• Cách đóng gói một ứng dụng Java đơn giản dưới dạng vùng chứa Docker bằng cách sử dụng Jib
• Cách tạo cụm Kubernetes trên Kubernetes Engine.
• Cách triển khai dịch vụ Micronaut trong Kubernetes trên Kubernetes Engine
• Cách mở rộng quy mô dịch vụ và triển khai bản nâng cấp.
• Cách truy cập vào trang tổng quan đồ hoạ của Kubernetes.

Bạn cần có

• Một dự án trên Google Cloud Platform
• Một trình duyệt, chẳng hạn như Chrome hoặc Firefox
• Quen thuộc với các trình soạn thảo văn bản tiêu chuẩn của Linux như Vim, EMAC hoặc Nano

Bạn sẽ sử dụng hướng dẫn này như thế nào?

Chỉ có thể đọc Đọc và hoàn thành bài tập

Bạn đánh giá thế nào về kinh nghiệm xây dựng ứng dụng web HTML/CSS?

Người mới tập Trung cấp Thành thạo

Bạn đánh giá trải nghiệm sử dụng các dịch vụ của Google Cloud Platform như thế nào?

Người mới tập Trung cấp Thành thạo

2. Thiết lập và yêu cầu

Thiết lập môi trường theo tiến độ riêng

1. Đăng nhập vào Cloud Console rồi tạo dự án mới hoặc sử dụng lại dự án hiện có. (Nếu chưa có tài khoản Gmail hoặc G Suite, bạn phải tạo một tài khoản.)

Lưu ý: Bạn có thể dễ dàng truy cập vào Cloud Console bằng cách ghi nhớ URL của Cloud Console, đó là console.cloud.google.com.

Xin lưu ý rằng mã dự án là một tên riêng biệt trong tất cả dự án Google Cloud (tên ở trên đã được sử dụng nên sẽ không phù hợp với bạn!). Lớp này sẽ được đề cập sau trong lớp học lập trình này là PROJECT_ID.

Lưu ý:Nếu đang sử dụng tài khoản Gmail, bạn có thể đặt vị trí mặc định thành Không có tổ chức nào. Nếu bạn đang sử dụng tài khoản G Suite, hãy chọn một vị trí phù hợp với tổ chức của bạn.

2. Tiếp theo, bạn sẽ cần bật tính năng thanh toán trong Cloud Console để sử dụng tài nguyên của Google Cloud.

Việc chạy qua lớp học lập trình này sẽ không tốn nhiều chi phí. Hãy nhớ làm theo mọi hướng dẫn trong phần "Dọn dẹp" sẽ tư vấn cho bạn cách tắt tài nguyên để bạn không phải chịu thanh toán ngoài hướng dẫn này. Người dùng mới của Google Cloud đủ điều kiện tham gia chương trình Dùng thử miễn phí 300 USD.

3. Tải mã nguồn mẫu Micronaut

Sau khi Cloud Shell chạy, bạn có thể sử dụng dòng lệnh để sao chép mã nguồn mẫu trong thư mục gốc và cd vào thư mục chứa dịch vụ mẫu của chúng ta:

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

Kho lưu trữ dự án Jib cũng chứa các dự án mẫu cho các khung khác, chẳng hạn như Spring Boot hoặc Vert.x, nếu bạn cũng muốn thử các ví dụ khác.

4. Xem nhanh mã

Dịch vụ đơn giản Micronaut của chúng tôi được tạo thành từ một bộ điều khiển có chức năng xuất ra thông điệp Hello World khét tiếng:

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

Trình điều khiển HelloController đang phản hồi các yêu cầu theo đường dẫn /hello và phương thức index() sẽ chấp nhận các yêu cầu HTTP GET.

Bạn cũng có thể dùng lớp kiểm thử Spock để kiểm tra nhằm đảm bảo rằng thông báo được cung cấp trong dữ liệu đầu ra là chính xác.

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"
    }
}

Không chỉ là một kiểm thử đơn vị đơn giản, kiểm thử này thực sự chạy cùng một ngăn xếp máy chủ Micronaut (dựa trên khung Netty) được chạy trong phiên bản chính thức. Vì vậy, hành vi của mã trong sản phẩm sẽ giống như trong kiểm thử.

Để chạy kiểm thử, bạn có thể chạy lệnh sau để xem mọi thứ đều ổn:

./gradlew test

5. Chạy ứng dụng cục bộ

Bạn có thể khởi động dịch vụ Micronaut như bình thường bằng lệnh Gradle sau:

$ ./gradlew run

Sau khi ứng dụng khởi động, bạn có thể mở thêm một phiên bản Cloud Shell nhờ biểu tượng dấu + nhỏ rồi kiểm tra bằng curl xem bạn đã nhận được kết quả dự kiến chưa:

$ curl localhost:8080/hello

Bạn sẽ thấy một dòng chữ "Hello World" đơn giản tin nhắn xuất hiện.

6. Đóng gói ứng dụng dưới dạng vùng chứa Docker bằng Jib

Tiếp theo, hãy chuẩn bị để ứng dụng của bạn chạy trên Kubernetes. Vì mục đích đó, chúng ta sẽ lợi dụng Jib để làm phần việc khó khăn cho chúng ta, vì chúng ta sẽ không phải tự mình chạm vào Dockerfile!

Hãy chạy lệnh để tạo vùng chứa:

$ ./gradlew jibDockerBuild

Dưới đây là kết quả bạn sẽ thấy:

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 xây dựng hình ảnh Docker với nhiều lớp khác nhau: cho các phần phụ thuộc, tài nguyên và mã đã biên dịch. Ví dụ: nếu bạn sửa đổi mã, chỉ lớp có các lớp đã biên dịch mới được sửa đổi, giúp tiết kiệm thời gian xây dựng bằng cách sử dụng lại các lớp trước đó chưa được động đến.

Bây giờ, hình ảnh của chúng ta đã được tạo xong, hãy kiểm tra xem chúng ta có thể thấy thông báo chào thân thiện hay không bằng cách chạy hình ảnh Docker trong thẻ đầu tiên của 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

Dịch vụ của chúng ta đang chạy, vì vậy giờ chúng ta có thể khởi chạy lệnh curl, trong thẻ Cloud Shell thứ hai để xem lệnh này có hoạt động như mong đợi không:

$ curl localhost:8080/hello
Hello World

Bạn có thể dừng vùng chứa bằng cách nhấn vào Ctrl+C trong Cloud Shell.

7. Đẩy dịch vụ trong vùng chứa của chúng tôi vào sổ đăng ký

Giờ đây, khi hình ảnh hoạt động như dự kiến, bạn có thể đẩy hình ảnh này vào Google Container Registry, một kho lưu trữ riêng cho các hình ảnh Docker của bạn có thể truy cập được từ mọi dự án Google Cloud (nhưng cũng có thể truy cập từ bên ngoài Google Cloud Platform).

Trước khi có thể chuyển đến sổ đăng ký, hãy đảm bảo rằng Sổ đăng ký vùng chứa được bật cho dự án của chúng ta, bằng cách chuyển đến Công cụ > Container Registry. Nếu chưa bật, bạn sẽ thấy hộp thoại sau đây, sau đó vui lòng nhấp vào "Bật Container Registry API" để bật tính năng này:

Khi sổ đăng ký đã sẵn sàng, để đẩy hình ảnh vào sổ đăng ký, hãy khởi chạy các lệnh sau:

$ 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

Các lệnh trên cho phép gcloud SDK định cấu hình và uỷ quyền docker đẩy hình ảnh đến phiên bản Sổ đăng ký vùng chứa của bạn để gắn thẻ hình ảnh trỏ tới vị trí của hình ảnh trong sổ đăng ký rồi đẩy hình ảnh đó vào sổ đăng ký.

Nếu mọi việc đều tốt đẹp và sau một chút thời gian, bạn sẽ có thể thấy hình ảnh vùng chứa được liệt kê trong bảng điều khiển: Công cụ > Container Registry. Tại thời điểm này, bạn hiện đã có hình ảnh Docker trên toàn dự án mà Kubernetes có thể truy cập và sắp xếp như bạn thấy sau vài phút.

Lưu ý rằng mặc dù ở đây chúng tôi sử dụng một miền chung cho sổ đăng ký (gcr.io), bạn cũng có thể nêu cụ thể hơn về vùng và bộ chứa cần sử dụng. Chi tiết được ghi lại tại đây: https://cloud.google.com/container-registry/docs/#pushing_to_the_registry

8. Tạo cụm

Ok, bạn hiện đã sẵn sàng tạo cụm Kubernetes Engine. Tuy nhiên, trước đó, hãy chuyển đến mục Google Kubernetes Engine của bảng điều khiển web rồi đợi hệ thống khởi động (chỉ mất vài giây).

Một cụm bao gồm một máy chủ API chính của Kubernetes do Google quản lý và một tập hợp các nút worker. Các nút worker là máy ảo Compute Engine. Hãy sử dụng CLI gcloud từ phiên CloudShell của bạn để tạo một cụm có 2 nút n1-standard-1 (thao tác này sẽ mất vài phút để hoàn tất):

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

Cuối cùng, bạn sẽ thấy cụm đã tạo.

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

Ngoài ra, bạn có thể tạo cụm này thông qua Bảng điều khiển hiển thị ở trên: Compute > (Điện toán >) Kubernetes Engine > Cụm vùng chứa > Tạo một cụm vùng chứa.

Bạn có thể tạo cụm trong Vùng khác, nhưng bạn nên giữ cụm đó trong cùng khu vực với bộ chứa lưu trữ mà sổ đăng ký vùng chứa sử dụng (xem bước trước).

Giờ đây, bạn sẽ có một cụm Kubernetes với đầy đủ chức năng do Google Kubernetes Engine cung cấp:

Đã đến lúc triển khai ứng dụng trong vùng chứa của riêng bạn cho cụm Kubernetes! Từ giờ trở đi, bạn sẽ sử dụng dòng lệnh kubectl (đã thiết lập trong môi trường Cloud Shell). Phần còn lại của lớp học lập trình này yêu cầu cả phiên bản ứng dụng và máy chủ của Kubernetes là 1.2 trở lên. kubectl version sẽ cho bạn thấy phiên bản hiện tại của lệnh.

9. Triển khai ứng dụng trên Kubernetes

Việc triển khai Kubernetes có thể tạo, quản lý và mở rộng quy mô của nhiều thực thể của ứng dụng bằng hình ảnh vùng chứa bạn vừa tạo. Hãy cùng tạo một quy trình triển khai ứng dụng trong Kubernetes bằng lệnh kubectl create deployment:

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

Để xem phiên bản triển khai bạn vừa tạo, bạn chỉ cần chạy:

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

Để xem các phiên bản ứng dụng được tạo do quá trình triển khai, hãy chạy lệnh sau:

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

Tại thời điểm này, bạn nên chạy vùng chứa dưới sự kiểm soát của Kubernetes nhưng vẫn phải làm cho vùng chứa có thể tiếp cận với thế giới bên ngoài.

10. Cho phép lưu lượng truy cập bên ngoài

Theo mặc định, chỉ IP nội bộ của nhóm trong cụm mới có thể truy cập vào nhóm. Để có thể truy cập vùng chứa hello-micronaut từ bên ngoài mạng ảo kubernetes, bạn phải hiển thị nhóm quảng cáo dưới dạng dịch vụ kubernetes.

Trên Cloud Shell, bạn có thể hiển thị nhóm này trên Internet công cộng bằng lệnh kubectl expose kết hợp với cờ --type=LoadBalancer. Cờ này là bắt buộc để tạo IP có thể truy cập từ bên ngoài :

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

Cờ dùng trong lệnh này chỉ rõ rằng bạn sẽ sử dụng trình cân bằng tải do cơ sở hạ tầng cơ sở cung cấp (trong trường hợp này là Trình cân bằng tải của Compute Engine). Xin lưu ý rằng bạn sẽ hiển thị quá trình triển khai chứ không phải trực tiếp cho nhóm. Điều này sẽ khiến dịch vụ cuối cùng cân bằng lưu lượng truy cập trên tất cả các nhóm được triển khai quản lý (trong trường hợp này, chỉ có 1 nhóm, nhưng bạn sẽ thêm các bản sao khác sau).

Bậc thầy Kubernetes tạo trình cân bằng tải và các quy tắc chuyển tiếp Compute Engine, nhóm mục tiêu và quy tắc tường lửa có liên quan để giúp người dùng có thể sử dụng dịch vụ hoàn toàn từ bên ngoài Google Cloud Platform.

Để tìm địa chỉ IP có thể truy cập công khai của dịch vụ, bạn chỉ cần yêu cầu kubectl liệt kê tất cả các dịch vụ cụm:

$ 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

Có thể mất vài phút thì EXTERNAL-IP mới xuất hiện và xuất hiện. Nếu thiếu EXTERNAL-IP, hãy đợi vài phút rồi thử lại.

Lưu ý rằng có 2 địa chỉ IP được liệt kê cho dịch vụ của bạn, cả hai đều cung cấp cổng 8080. Một là IP nội bộ chỉ hiển thị trong mạng ảo trên đám mây của bạn; hai là IP cân bằng tải bên ngoài. Trong ví dụ này, địa chỉ IP bên ngoài là aaa.bbb.ccc.ddd.

Bây giờ, bạn có thể truy cập dịch vụ bằng cách trỏ trình duyệt của bạn tới địa chỉ sau: http://<EXTERNAL_IP>:8080/hello

11. Mở rộng quy mô dịch vụ

Một trong những tính năng mạnh mẽ mà Kubernetes cung cấp là dễ dàng mở rộng quy mô ứng dụng. Giả sử đột nhiên bạn cần thêm dung lượng cho ứng dụng của mình; bạn có thể chỉ cần yêu cầu trình kiểm soát sao chép quản lý số lượng bản sao mới cho các phiên bản của ứng dụng:

$ 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

Lưu ý về phương pháp khai báo ở đây — thay vì bắt đầu hoặc dừng các thực thể mới, bạn sẽ khai báo số lượng thực thể sẽ chạy mọi lúc. Vòng lặp điều chỉnh của Kubernetes chỉ cần đảm bảo rằng thông tin thực tế khớp với yêu cầu của bạn và xử lý nếu cần.

12. Ra mắt bản nâng cấp cho dịch vụ của bạn

Tại một số thời điểm, ứng dụng mà bạn đã triển khai phát hành công khai sẽ yêu cầu sửa lỗi hoặc bổ sung tính năng. Kubernetes sẵn sàng giúp bạn triển khai phiên bản mới vào giai đoạn phát hành chính thức mà không ảnh hưởng đến người dùng.

Trước tiên, hãy cùng sửa đổi ứng dụng. Mở trình soạn thảo mã của Cloud Shell.

Chuyển đến /jib/examples/micronaut/src/main/groovy/example/micronaut/HelloController.groovy rồi cập nhật giá trị của phản hồi:

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

Trong /jib/examples/micronaut/build.gradle, chúng ta sẽ nâng cấp phiên bản hình ảnh từ 0.1 lên 0.2 bằng cách cập nhật dòng sau:

version '0.2'

Sau đó, tạo lại và đóng gói ứng dụng với các thay đổi mới nhất:

$ ./gradlew jibDockerBuild

Đồng thời, gắn thẻ và đẩy hình ảnh vào đăng ký hình ảnh vùng chứa:

$ 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

Việc tạo và đẩy hình ảnh cập nhật này sẽ nhanh hơn nhiều vì chúng ta tận dụng toàn bộ chức năng lưu vào bộ nhớ đệm.

Giờ đây, bạn đã sẵn sàng để Kubernetes cập nhật bộ điều khiển sao chép lên phiên bản mới một cách suôn sẻ. Để thay đổi nhãn hình ảnh cho vùng chứa đang chạy, bạn cần chỉnh sửa hello-micronaut deployment hiện tại và thay đổi hình ảnh từ gcr.io/PROJECT_ID/micronaut-jib:0.1 thành gcr.io/PROJECT_ID/micronaut-jib:0.2.

Bạn có thể dùng lệnh kubectl set image để yêu cầu Kubernetes triển khai phiên bản mới của ứng dụng trên toàn bộ cụm tại mỗi thời điểm bằng phương thức cập nhật định kỳ:

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

deployment.apps "hello-micronaut" image updated

Trong khi quá trình này diễn ra, người dùng các dịch vụ có thể gặp phải tình trạng gián đoạn. Nguyên nhân là do bạn chưa thiết lập tính năng kiểm tra tình trạng. Đó là cấu hình nâng cao hơn một chút — chúng tôi sẽ không thêm tính năng kiểm tra tình trạng vào phòng thí nghiệm này.

Kiểm tra lại http://EXTERNAL_IP:8080 để xem trang này đang trả về phản hồi mới.

13. Khôi phục

Rất tiếc — có phải bạn đã mắc lỗi với phiên bản mới của ứng dụng không? Có thể phiên bản mới đã gặp lỗi và bạn cần phải khôi phục nhanh. Với Kubernetes, bạn có thể dễ dàng khôi phục về trạng thái trước đó. Hãy khôi phục ứng dụng này bằng cách chạy:

$ kubectl rollout undo deployment/hello-micronaut

Nếu bạn đã xem kết quả của dịch vụ, chúng ta sẽ trở lại câu lệnh "Hello World" ("Xin chào thế giới") .

14. Tóm tắt

Ở bước này, bạn sẽ thiết lập một dịch vụ Hello World Micronaut dựa trên Apache Groovy đơn giản và chạy dịch vụ này trực tiếp từ trong Cloud Shell, đóng gói dịch vụ này dưới dạng một vùng chứa bằng Jib, đồng thời triển khai dịch vụ này cho Google Kubernetes Engine.

15. Xin chúc mừng!

Bạn đã tìm hiểu cách xây dựng và triển khai một dịch vụ vi mô dựa trên web mới Apache Groovy / Micronaut cho Kubernetes trên Google Kubernetes Engine.

Tìm hiểu thêm

• Tài liệu và mẫu về Jib: https://github.com/GoogleContainerTools/jib/
• Trang web của Micronaut: http://micronaut.io/
• Java trên Google Cloud Platform: https://cloud.google.com/java/
• Đối với các ví dụ Java: https://cloud.google.com/java/samples
• Để xem hướng dẫn dài hơn và đầy đủ hơn về Kubernetes, hãy xem bit.ly/k8s-lab để biết cách triển khai ứng dụng full stack.

Giấy phép

Tác phẩm này được cấp phép theo Giấy phép chung Ghi nhận tác giả Creative Commons 2.0.