1. Tổng quan
Giới thiệu về Micronaut
Micronaut là một khung ngăn xếp đầy đủ, hiện đại, dựa trên JVM để xây dựng các ứng dụng vi dịch vụ và ứng dụng không máy chủ có thể kiểm thử dễ dàng và theo mô-đun. Micronaut hướng đến việc mang lại thời gian khởi động tuyệt vời, thông lượng nhanh với mức sử dụng bộ nhớ 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 tính năng phản chiếu tải và lưu vào bộ nhớ đệm dữ liệu phản chiếu cho từng 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 với kích thước của cơ sở mã.
- Ứng dụng HTTP khai báo, phản ứng, thời gian biên dịch – Xây dựng một cách khai báo các ứng dụng HTTP phản ứng được triển khai tại thời gian biên dịch, giúp giảm mức tiêu thụ bộ nhớ.
- Máy chủ HTTP không chặn được xây dựng trên Netty – Với đường cong học tập mượt mà, máy chủ HTTP của Micronaut giúp bạn dễ dàng nhất có thể để hiển thị các API mà máy khách HTTP có thể sử dụng.
- Kiểm thử nhanh chóng và dễ dàng – Dễ dàng tạo máy chủ và ứng dụng trong các kiểm thử đơn vị, đồng thời chạy chúng ngay lập tức.
- Tiêm phần phụ thuộc và AOP hiệu quả trong thời gian biên dịch – Micronaut cung cấp một API lập trình hướng khía cạnh đơn giản trong thời gian biên dịch mà không sử dụng tính năng phản chiếu.
- Tạo 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 Reactive Streams, bao gồm RxJava và Reactor.
Để 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 mã nguồn mở có thể chạy trong nhiều môi trường khác nhau, từ máy tính xách tay đến các cụm nhiều nút có tính sẵn sàng cao, từ đám mây công cộng đến các triển khai tại cơ sở hạ tầng riêng, từ máy ảo đến máy chủ vật lý.
Trong phòng thí nghiệm này, bạn sẽ triển khai một vi dịch vụ Micronaut đơn giản dựa trên Groovy 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 vi dịch vụ dưới dạng một dịch vụ được sao chép chạy trên Kubernetes. Bạn lấy mã đã phát triển trên máy của mình, biến mã đó thành một hình ảnh vùng chứa Docker, rồi chạy hình ảnh đó trên Kubernetes Engine.
Sau đây là sơ đồ về các phần khác nhau trong lớp học lập trình này để giúp bạn hiểu cách các phần khớp với nhau. Hãy dùng danh sách này làm tài liệu tham khảo khi bạn tham gia lớp học lập trình; mọi thứ sẽ trở nên rõ ràng khi bạn hoàn thành lớp học lập trình (nhưng bạn có thể bỏ qua danh sách này ở thời điểm hiện tại).
Trong phạm vi 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 (một phiên bản Kubernetes do Google lưu trữ chạy trên Compute Engine) cho phép bạn tập trung 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 tìm hiểu về Minikube. Điều này giúp thiết lập đơn giản một cụm Kubernetes có một nút cho mục đích phát triển và kiểm thử. Bạn có thể sử dụng Minikube để thực hiện 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. Bạn có thể dùng công cụ này dưới dạng trình bổ trợ cho Maven và Gradle, cũng như dưới dạng một thư viện Java.
Jib hướng đến mục tiêu:
- Nhanh chóng – Triển khai các thay đổi một cách nhanh chóng. Jib phân tách ứng dụng của bạn thành nhiều lớp, tách các phần phụ thuộc khỏi các lớp. Giờ đây, bạn không cần phải đợi Docker tạo lại toàn bộ ứng dụng Java của mình – 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 bằng cùng một nội dung sẽ luôn tạo ra cùng một hình ảnh. Không bao giờ kích hoạt một bản cập nhật không cần thiết nữa.
- Không có chương trình nền – Giảm các phần phụ thuộc của CLI. Tạo hình ảnh Docker trong Maven hoặc Gradle và chuyển đến bất kỳ sổ đăng ký nào bạn chọn. Không cần viết Dockerfile và gọi docker build/push nữa.
Bạn có thể tìm thêm thông tin về Jib trên trang dự án của Github.
Giới thiệu về hướng dẫn này
Hướng dẫn này sử dụng mã mẫu từ công cụ Jib để tạo các vùng chứa cho ứ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 một vùng chứa Docker bằng Jib
- Cách tạo cụm Kubernetes trên Kubernetes Engine.
- Cách triển khai dịch vụ Micronaut vào Kubernetes trên Kubernetes Engine
- Cách mở rộng quy mô dịch vụ và ra mắt 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
- Làm quen với các trình chỉnh sửa văn bản tiêu chuẩn của Linux, chẳng hạn như Vim, EMAC hoặc Nano
Bạn sẽ sử dụng hướng dẫn này như thế nào?
Bạn đánh giá thế nào về trải nghiệm xây dựng ứng dụng web HTML/CSS?
Bạn đánh giá thế nào về trải nghiệm sử dụng các dịch vụ của Google Cloud Platform?
2. Thiết lập và yêu cầu
Thiết lập môi trường theo tốc độ của riêng bạn
- Đăng nhập vào Cloud Console rồi tạo một dự án mới hoặc sử dụng lại một 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.)
Hãy nhớ mã dự án, một tên duy nhất trên tất cả các dự án trên Google Cloud (tên ở trên đã được sử dụng và sẽ không hoạt động đối với bạn, xin lỗi!). Sau này trong lớp học lập trình này, chúng ta sẽ gọi nó là PROJECT_ID.
- Tiếp theo, bạn cần bật tính năng thanh toán trong Cloud Console để sử dụng các tài nguyên của Google Cloud.
Việc thực hiện lớp học lập trình này sẽ không tốn nhiều chi phí, nếu có. Hãy nhớ làm theo mọi hướng dẫn trong phần "Dọn dẹp" để biết cách tắt các tài nguyên nhằm tránh bị tính phí ngoài phạm vi 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í trị giá 300 USD.
3. Tải mã nguồn mẫu Micronaut
Sau khi Cloud Shell khởi động, bạn có thể dùng dòng lệnh để sao chép mã nguồn ví dụ trong thư mục chính và chuyển đến thư mục chứa dịch vụ mẫu của chúng tôi:
$ git clone https://github.com/GoogleContainerTools/jib.git
$ cd jib/examples/micronaut/
4. Xem nhanh đoạn mã
Dịch vụ đơn giản của Micronaut được tạo thành từ một bộ điều khiển xuất thông báo Hello World nổi tiếng:
@Controller("/hello")
class HelloController {
@Get("/")
String index() {
"Hello World"
}
}
Bộ điều khiển HelloController đang phản hồi các yêu cầu trong đường dẫn /hello và phương thức index() chấp nhận các yêu cầu HTTP GET.
Lớp kiểm thử Spock cũng có sẵn để kiểm tra xem thông báo chính xác có được đưa ra trong đầu ra hay không.
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 quy trình kiểm thử đơn vị đơn giản, quy trình 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 quá trình sản xuất. Vì vậy, hành vi của mã sẽ giống hệt nhau trong sản phẩm như trong các bài kiểm thử.
Để chạy kiểm thử, bạn có thể chạy lệnh sau để xem mọi thứ có ổn không:
./gradlew test
5. Chạy ứng dụng cục bộ
Bạn có thể khởi động dịch vụ Micronaut theo cách thông thường bằng lệnh Gradle sau:
$ ./gradlew run
Sau khi ứng dụng bắt đầu, bạn có thể mở thêm một phiên bản Cloud Shell nhờ biểu tượng + nhỏ, sau đó kiểm tra bằng curl để đảm bảo bạn nhận được đầu ra như mong đợi:
$ curl localhost:8080/hello
Bạn sẽ thấy một thông báo đơn giản "Hello World" xuất hiện.
6. Đóng gói ứng dụng dưới dạng một vùng chứa Docker bằng Jib
Tiếp theo, hãy chuẩn bị ứng dụng để chạy trên Kubernetes. Vì mục đích đó, chúng ta sẽ tận dụng Jib để thực hiện công việc khó khăn cho chúng ta, vì chúng ta sẽ không phải tự động chạm vào Dockerfile!
Hãy chạy lệnh để tạo vùng chứa:
$ ./gradlew jibDockerBuild
Sau đây là kết quả mà 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
Bây giờ, sau khi tạo xong hình ảnh, hãy kiểm tra xem chúng ta có 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ờ đây, chúng ta có thể chạy lệnh curl trong thẻ Cloud Shell thứ hai để xem dịch vụ có hoạt động như mong đợi hay không:
$ curl localhost:8080/hello Hello World
Bạn có thể dừng vùng chứa bằng cách nhấn Ctrl+C trong Cloud Shell.
7. Đẩy dịch vụ được chứa trong vùng chứa của chúng ta vào sổ đăng ký
Giờ đây, khi hình ảnh hoạt động như mong đợi, bạn có thể đẩy hình ảnh đó vào Google Container Registry, một kho lưu trữ riêng cho các hình ảnh Docker của bạn mà mọi dự án trên Google Cloud đều có thể truy cập (nhưng cũng có thể truy cập từ bên ngoài Google Cloud Platform).
Trước khi có thể đẩy vào sổ đăng ký, hãy đảm bảo rằng Container Registry được bật cho dự án của chúng ta bằng cách chuyển đến Tools > Container Registry (Công cụ > Container Registry). Nếu chưa bật, bạn sẽ thấy hộp thoại sau. Vui lòng nhấp vào "Enable Container Registry API" (Bật Container Registry API) để bật:
Sau khi sổ đăng ký đã sẵn sàng, để đẩy hình ảnh vào sổ đăng ký, hãy 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 cho docker để đẩy hình ảnh vào phiên bản Container Registry của bạn, gắn thẻ hình ảnh để trỏ đến 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 thứ diễn ra suôn sẻ, sau một thời gian ngắn, bạn sẽ thấy hình ảnh vùng chứa xuất hiện trong bảng điều khiển: Công cụ > Container Registry. Lúc này, bạn đã có một hình ảnh Docker trên toàn dự án mà Kubernetes có thể truy cập và điều phối như bạn sẽ thấy trong vài phút nữa.
8. Tạo cụm
Được rồi, giờ đây bạn đã sẵn sàng tạo cụm Kubernetes Engine. Tuy nhiên, trước đó, hãy chuyển đến phần Google Kubernetes Engine của bảng điều khiển web và đợ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 Kubernetes do Google quản lý và một nhóm các nút worker. Các nút worker là máy ảo Compute Engine. Hãy sử dụng CLI gcloud trong phiên Cloud Shell để tạo một cụm có 2 nút n1-standard-1 (việ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 đã được 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
Giờ đây, bạn sẽ có một cụm Kubernetes hoạt động đầy đủ nhờ Google Kubernetes Engine:
Giờ là lúc bạn triển khai ứng dụng được chứa trong vùng chứa của riêng mình vào cụm Kubernetes! Từ giờ trở đi, bạn sẽ sử dụng dòng lệnh kubectl (đã được 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 máy chủ và ứng dụng Kubernetes đều phải là 1.2 trở lên. kubectl version sẽ cho bạn biết phiên bản hiện tại của lệnh.
9. Triển khai ứng dụng của bạn trên Kubernetes
Một hoạt động triển khai Kubernetes có thể tạo, quản lý và mở rộng nhiều phiên bản của ứng dụng bằng hình ảnh vùng chứa mà bạn vừa tạo. Hãy tạo một quy trình triển khai ứng dụng của bạn vào Kubernetes bằng lệnh kubectl create deployment:
$ kubectl create deployment hello-micronaut \ --image=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1
Để xem bản triển khai mà bạn vừa tạo, 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 do quá trình triển khai tạo ra, 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 sẽ có vùng chứa đang chạy dưới sự kiểm soát của Kubernetes nhưng vẫn phải cho phép thế giới bên ngoài truy cập vào vùng chứa đó.
10. Cho phép lưu lượng truy cập bên ngoài
Theo mặc định, chỉ có thể truy cập vào nhóm bằng IP nội bộ trong cụm. Để có thể truy cập vào vùng chứa hello-micronaut từ bên ngoài mạng ảo kubernetes, bạn phải hiển thị pod dưới dạng một dịch vụ kubernetes.
Từ Cloud Shell, bạn có thể hiển thị nhóm cho Internet công cộng bằng lệnh kubectl expose kết hợp với cờ --type=LoadBalancer. Bạn cần có cờ này để tạo một IP có thể truy cập từ bên ngoài :
$ kubectl expose deployment hello-micronaut --type=LoadBalancer --port=8080
Cờ được dùng trong lệnh này chỉ định rằng bạn sẽ sử dụng trình cân bằng tải do cơ sở hạ tầng cơ bản cung cấp (trong trường hợp này là Trình cân bằng tải Compute Engine). Xin lưu ý rằng bạn sẽ hiển thị việc triển khai chứ không phải pod một cách trực tiếp. Điều này sẽ khiến dịch vụ kết quả cân bằng tải lưu lượng truy cập trên tất cả các nhóm do quá trình triển khai quản lý (trong trường hợp này chỉ có 1 nhóm, nhưng sau này bạn sẽ thêm nhiều bản sao hơn).
Kubernetes master tạo bộ cân bằng tải và các quy tắc chuyển tiếp, nhóm mục tiêu và quy tắc tường lửa liên quan của Compute Engine để giúp dịch vụ có thể truy cập 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ủa 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
Xin lưu ý rằng có 2 địa chỉ IP được liệt kê cho dịch vụ của bạn, cả hai đều phục vụ cổng 8080. Một là IP nội bộ chỉ hiển thị bên trong mạng ảo trên đám mây của bạn; còn lại là IP bên ngoài được cân bằng tải. Trong ví dụ này, địa chỉ IP ngoài là aaa.bbb.ccc.ddd.
Giờ đây, bạn có thể truy cập vào dịch vụ bằng cách chuyển trình duyệt đến địa chỉ này: 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à khả năng dễ dàng mở rộng quy mô ứng dụng của bạn. Giả sử bạn đột nhiên cần thêm dung lượng cho ứng dụng của mình; bạn chỉ cần yêu cầu bộ điều khiển sao chép quản lý một số lượng bản sao mới cho các phiên bản ứng dụng của bạn:
$ 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 ý phương pháp khai báo ở đây – thay vì bắt đầu hoặc dừng các phiên bản mới, bạn khai báo số lượng phiên bản sẽ chạy mọi lúc. Vòng lặp điều phối Kubernetes chỉ cần đảm bảo rằng thực tế khớp với những gì bạn yêu cầu và thực hiện hành động nếu cần.
12. Ra mắt bản nâng cấp cho dịch vụ của bạn
Đến một thời điểm nào đó, ứng dụng mà bạn đã triển khai cho kênh phát hành công khai sẽ cần được sửa lỗi hoặc bổ sung tính năng. Kubernetes sẽ giúp bạn triển khai một phiên bản mới cho bản phát hành công khai mà không ảnh hưởng đến người dùng.
Trước tiên, hãy sửa đổi ứng dụng. Mở trình soạn thảo mã trong 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 này:
version '0.2'
Sau đó, hãy tạo lại và đóng gói ứng dụng bằng các thay đổi mới nhất:
$ ./gradlew jibDockerBuild
Sau đó, gắn thẻ và đẩy hình ảnh vào sổ đă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
Giờ đây, bạn đã sẵn sàng để Kubernetes cập nhật bộ điều khiển sao chép một cách suôn sẻ lên phiên bản mới của ứng dụng. Để 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 có 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, mỗi lần một phiên bản bằng cách cập nhật luân phiên:
$ kubectl set image deployment/hello-micronaut \
micronaut-jib=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2
deployment.apps "hello-micronaut" image updated
Kiểm tra lại http://EXTERNAL_IP:8080 để xem liệu nó có trả về phản hồi mới hay không.
13. Khôi phục
Rất tiếc – bạn có nhầm lẫn khi tạo phiên bản mới của ứng dụng không? Có thể phiên bản mới chứa lỗi và bạn cần nhanh chóng khôi phục về phiên bản cũ. Với Kubernetes, bạn có thể dễ dàng quay lại trạng thái trước đó. Hãy khôi phục ứng dụng bằng cách chạy:
$ kubectl rollout undo deployment/hello-micronaut
Nếu bạn xem xét đầu ra của dịch vụ, chúng ta sẽ quay lại thông báo "Hello World" ban đầu.
14. Tóm tắt
Trong bước này, bạn thiết lập một dịch vụ Micronaut hello world đơn giản dựa trên Apache Groovy và chạy dịch vụ đó ngay trong Cloud Shell, đóng gói dịch vụ đó dưới dạng một vùng chứa bằng Jib và triển khai dịch vụ đó vào Google Kubernetes Engine.
15. Xin chúc mừng!
Bạn đã tìm hiểu cách tạo và triển khai một vi dịch vụ mới dựa trên web Apache Groovy / Micronaut cho Kubernetes trên Google Kubernetes Engine.
Tìm hiểu thêm
- Tài liệu và mẫu Jib: https://github.com/GoogleContainerTools/jib/
- Trang web Micronaut: http://micronaut.io/
- Java trên Google Cloud Platform: https://cloud.google.com/java/
- Đối với các ví dụ về Java: https://cloud.google.com/java/samples
- Để xem hướng dẫn đầy đủ và chi tiết hơn về Kubernetes, hãy truy cập vào bit.ly/k8s-lab. Hướng dẫn này sẽ giúp bạn triển khai một ứ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 Ghi công theo Creative Commons 2.0 Chung.