ทำให้แอปพลิเคชัน Micronaut ที่มีคอนเทนเนอร์ด้วย Jib ใช้งานได้กับ Google Kubernetes Engine

1. ภาพรวม

เกี่ยวกับ Micronaut

Micronaut เป็นเฟรมเวิร์กแบบฟูลสแต็กที่ทันสมัยซึ่งใช้ JVM สำหรับสร้างแอปพลิเคชัน Microservice และแอปพลิเคชันแบบ Serverless ที่เป็นโมดูลและทดสอบได้ง่าย Micronaut มุ่งมั่นที่จะมอบเวลาเริ่มต้นที่ยอดเยี่ยม ปริมาณงานที่รวดเร็ว และใช้หน่วยความจำน้อยที่สุด นักพัฒนาแอปสามารถพัฒนาด้วย Micronaut ใน Java, Groovy หรือ Kotlin

Micronaut มีบริการต่อไปนี้

เวลาเริ่มต้นที่รวดเร็วและการใช้หน่วยความจำต่ำ - เฟรมเวิร์ก IoC ที่อิงตามการสะท้อนจะโหลดและแคชข้อมูลการสะท้อนสำหรับทุกฟิลด์ เมธอด และตัวสร้างในโค้ดของคุณ ในขณะที่เมื่อใช้ Micronaut เวลาเริ่มต้นของแอปพลิเคชันและการใช้หน่วยความจำจะไม่ขึ้นอยู่กับขนาดของโค้ดเบส
ไคลเอ็นต์ HTTP แบบประกาศ แบบรีแอกทีฟ และแบบคอมไพล์ไทม์ - สร้างไคลเอ็นต์ HTTP แบบรีแอกทีฟแบบประกาศ ซึ่งจะได้รับการติดตั้งใช้งานที่คอมไพล์ไทม์เพื่อลดการใช้หน่วยความจำ
เซิร์ฟเวอร์ HTTP แบบไม่บล็อกที่สร้างขึ้นบน Netty - เซิร์ฟเวอร์ HTTP ของ Micronaut ช่วยให้การเปิดเผย API ที่ไคลเอ็นต์ HTTP ใช้ได้เป็นเรื่องง่ายที่สุด
การทดสอบที่รวดเร็วและง่ายดาย - สร้างเซิร์ฟเวอร์และไคลเอ็นต์ในการทดสอบหน่วยได้อย่างง่ายดาย และเรียกใช้ได้ทันที
การแทรกการอ้างอิงและ AOP ที่มีประสิทธิภาพในเวลาคอมไพล์ - Micronaut มี API การเขียนโปรแกรมเชิงแง่มุมอย่างง่ายในเวลาคอมไพล์ซึ่งไม่ได้ใช้การสะท้อน
สร้างแอปที่ตอบสนองได้อย่างเต็มที่และไม่บล็อก - Micronaut รองรับเฟรมเวิร์กที่ใช้ Reactive Streams รวมถึง RxJava และ Reactor

ดูข้อมูลเพิ่มเติมได้ที่เว็บไซต์ Micronaut

เกี่ยวกับ Kubernetes

Kubernetes เป็นโปรเจ็กต์โอเพนซอร์สที่สามารถทำงานในสภาพแวดล้อมที่แตกต่างกันได้มากมาย ตั้งแต่แล็ปท็อปไปจนถึงคลัสเตอร์แบบหลายโหนดที่มีความพร้อมใช้งานสูง ตั้งแต่ระบบคลาวด์สาธารณะไปจนถึงการติดตั้งใช้งานในองค์กร ตั้งแต่เครื่องเสมือนไปจนถึง Bare Metal

ในแล็บนี้ คุณจะทำให้ไมโครเซอร์วิส Micronaut ที่ใช้ Groovy แบบง่ายใช้งานได้ใน Kubernetes ที่ทำงานบน Kubernetes Engine

เป้าหมายของโค้ดแล็บนี้คือการให้คุณเรียกใช้ไมโครเซอร์วิสเป็นบริการที่จำลองแบบซึ่งทำงานบน Kubernetes คุณนำโค้ดที่พัฒนาในเครื่องมาเปลี่ยนเป็นอิมเมจคอนเทนเนอร์ Docker แล้วเรียกใช้อิมเมจนั้นใน Kubernetes Engine

ต่อไปนี้เป็นแผนภาพของส่วนต่างๆ ที่ทำงานร่วมกันในโค้ดแล็บนี้เพื่อช่วยให้คุณเข้าใจว่าส่วนต่างๆ ทำงานร่วมกันอย่างไร ใช้ข้อมูลนี้เป็นข้อมูลอ้างอิงขณะที่คุณทำตาม Codelab ไปเรื่อยๆ ทุกอย่างควรจะสมเหตุสมผลเมื่อคุณไปถึงตอนท้าย (แต่คุณสามารถข้ามส่วนนี้ไปก่อนได้)

Kubernetes Codelab Diagram 1 (2).png

สำหรับวัตถุประสงค์ของโค้ดแล็บนี้ การใช้สภาพแวดล้อมที่มีการจัดการ เช่น Kubernetes Engine (Kubernetes เวอร์ชันที่ Google โฮสต์ซึ่งทำงานบน Compute Engine) จะช่วยให้คุณมุ่งเน้นไปที่การสัมผัสประสบการณ์การใช้งาน Kubernetes มากกว่าการตั้งค่าโครงสร้างพื้นฐานที่อยู่เบื้องหลัง

หากสนใจเรียกใช้ Kubernetes ในเครื่อง เช่น แล็ปท็อปสำหรับพัฒนาซอฟต์แวร์ คุณควรลองใช้ Minikube ซึ่งช่วยให้ตั้งค่าคลัสเตอร์ Kubernetes แบบโหนดเดียวได้อย่างง่ายดายเพื่อวัตถุประสงค์ในการพัฒนาและการทดสอบ คุณใช้ Minikube เพื่อทำตาม Codelab นี้ได้หากต้องการ

เกี่ยวกับ Jib

Jib เป็นเครื่องมือแบบโอเพนซอร์สที่ช่วยให้คุณสร้างอิมเมจ Docker และ OCI สำหรับแอปพลิเคชัน Java ได้ โดยมีให้ใช้งานเป็นปลั๊กอินสำหรับ Maven และ Gradle รวมถึงเป็นไลบรารี Java

Jib มีเป้าหมายที่จะเป็น

รวดเร็ว - นำการเปลี่ยนแปลงไปใช้ได้อย่างรวดเร็ว Jib จะแยกแอปพลิเคชันออกเป็นหลายเลเยอร์ โดยแยกการอ้างอิงออกจากคลาส ตอนนี้คุณไม่ต้องรอให้ Docker สร้างแอปพลิเคชัน Java ทั้งหมดใหม่ เพียงแค่ติดตั้งใช้งานเลเยอร์ที่มีการเปลี่ยนแปลง
ทำซ้ำได้ - การสร้างอิมเมจคอนเทนเนอร์ใหม่ด้วยเนื้อหาเดียวกันจะสร้างอิมเมจเดียวกันเสมอ ไม่ต้องทริกเกอร์การอัปเดตที่ไม่จำเป็นอีก
Daemonless - ลดการอ้างอิง CLI สร้างอิมเมจ 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, EMAC หรือ Nano

คุณจะใช้บทแนะนำนี้อย่างไร

อ่านอย่างเดียว

อ่านและทำแบบฝึกหัด

คุณจะให้คะแนนประสบการณ์ในการสร้างเว็บแอป HTML/CSS เท่าใด

ผู้ฝึกหัด

ขั้นกลาง

ผู้ชำนาญ

คุณจะให้คะแนนประสบการณ์การใช้บริการ Google Cloud Platform เท่าใด

ผู้ฝึกหัด

ขั้นกลาง

ผู้ชำนาญ

2. การตั้งค่าและข้อกำหนด

การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง

ลงชื่อเข้าใช้ Cloud Console แล้วสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ (หากยังไม่มีบัญชี Gmail หรือ G Suite คุณต้องสร้างบัญชี)

dMbN6g9RawQj_VXCSYpdYncY-DbaRzr2GbnwoV7jFf1u3avxJtmGPmKpMYgiaMH-qu80a_NJ9p2IIXFppYk8x3wyymZXavjglNLJJhuXieCem56H30hwXtd8PvXGpXJO9gEUDu3cZw

ci9Oe6PgnbNuSYlMyvbXF1JdQyiHoEgnhl4PlV_MFagm2ppzhueRkqX4eLjJllZco_2zCp0V0bpTupUSKji9KkQyWqj11pqit1K1faS1V6aFxLGQdkuzGp4rsQTan7F01iePL5DtqQ

8-tA_Lheyo8SscAVKrGii2coplQp2_D1Iosb2ViABY0UUO1A8cimXUu6Wf1R9zJIRExL5OB2j946aIiFtyKTzxDcNnuznmR45vZ2HMoK3o67jxuoUJCAnqvEX6NgPGFjCVNgASc-lg

โปรดจดจำรหัสโปรเจ็กต์ ซึ่งเป็นชื่อที่ไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมด (ชื่อด้านบนมีผู้ใช้แล้วและจะใช้ไม่ได้ ขออภัย) ซึ่งจะเรียกว่า PROJECT_ID ในภายหลังใน Codelab นี้

จากนั้นคุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร Google Cloud

การทำตาม Codelab นี้ไม่ควรมีค่าใช้จ่ายมากนัก หรืออาจไม่มีเลย โปรดทำตามวิธีการในส่วน "การล้างข้อมูล" ซึ่งจะแนะนำวิธีปิดทรัพยากรเพื่อไม่ให้มีการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ ผู้ใช้ Google Cloud รายใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรีมูลค่า$300 USD

3. รับซอร์สโค้ดตัวอย่างของ Micronaut

หลังจากเปิดใช้ Cloud Shell แล้ว คุณสามารถใช้บรรทัดคำสั่งเพื่อโคลนซอร์สโค้ดตัวอย่างในไดเรกทอรีหน้าแรก และใช้คำสั่ง cd เพื่อไปยังไดเรกทอรีที่มีบริการตัวอย่างของเราได้

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

4. ดูโค้ดอย่างรวดเร็ว

บริการ Micronaut แบบง่ายของเราประกอบด้วยตัวควบคุมที่แสดงข้อความ Hello World ที่มีชื่อเสียง

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

HelloController Controller ตอบสนองต่อคำขอภายใต้เส้นทาง /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

ตอนนี้เราสร้างอิมเมจแล้ว มาตรวจสอบกันว่าเราจะเห็นข้อความทักทายที่เป็นมิตรหรือไม่ โดยการเรียกใช้อิมเมจ 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 ที่ 2 เพื่อดูว่าบริการทำงานได้ตามที่คาดไว้หรือไม่

$ 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

คำสั่งข้างต้นช่วยให้ gcloud SDK กำหนดค่าและให้สิทธิ์ Docker ในการพุชอิมเมจไปยังอินสแตนซ์ของ Container Registry ติดแท็กอิมเมจเพื่อชี้ไปยังตำแหน่งในรีจิสทรี แล้วพุชไปยังรีจิสทรี

หากทุกอย่างเป็นไปด้วยดี หลังจากผ่านไปสักครู่ คุณควรจะเห็นอิมเมจคอนเทนเนอร์แสดงอยู่ในคอนโซลที่เครื่องมือ > Container Registry ตอนนี้คุณมีอิมเมจ Docker ระดับโปรเจ็กต์ที่พร้อมใช้งานแล้ว ซึ่ง Kubernetes สามารถเข้าถึงและจัดระเบียบได้ตามที่คุณจะเห็นในอีกไม่กี่นาที

8. สร้างคลัสเตอร์

ตอนนี้คุณพร้อมที่จะสร้างคลัสเตอร์ Kubernetes Engine แล้ว แต่ก่อนอื่น ให้ไปที่ส่วน Google Kubernetes Engine ของเว็บคอนโซล แล้วรอให้ระบบเริ่มต้น (ซึ่งใช้เวลาเพียงไม่กี่วินาที)

คลัสเตอร์ประกอบด้วยเซิร์ฟเวอร์ API ต้นแบบของ Kubernetes ที่ Google จัดการ และชุดโหนด Worker โหนดผู้ปฏิบัติงานคือเครื่องเสมือน Compute Engine มาใช้ gcloud CLI จากเซสชัน Cloud Shell เพื่อสร้างคลัสเตอร์ที่มีโหนด n1-standard-1 จำนวน 2 โหนดกัน (การดำเนินการนี้จะใช้เวลา 2-3 นาที)

$ 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) Codelab ที่เหลือนี้กำหนดให้ทั้งไคลเอ็นต์และเซิร์ฟเวอร์ Kubernetes ต้องเป็นเวอร์ชัน 1.2 ขึ้นไป 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. อนุญาตการรับส่งข้อมูลภายนอก

โดยค่าเริ่มต้น พ็อดจะเข้าถึงได้ด้วย IP ภายในภายในคลัสเตอร์เท่านั้น หากต้องการทำให้เข้าถึงคอนเทนเนอร์ hello-micronaut จากภายนอกเครือข่ายเสมือนของ Kubernetes ได้ คุณต้องเปิดเผยพ็อดเป็นบริการ Kubernetes

จาก Cloud Shell คุณสามารถเปิดเผยพ็อดต่ออินเทอร์เน็ตสาธารณะได้ด้วยคำสั่ง kubectl expose ร่วมกับแฟล็ก --type=LoadBalancer ต้องใช้แฟล็กนี้ในการสร้าง IP ที่เข้าถึงได้จากภายนอก

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

แฟล็กที่ใช้ในคำสั่งนี้ระบุว่าคุณจะใช้ตัวจัดสรรภาระงานที่โครงสร้างพื้นฐานที่อยู่เบื้องหลังจัดหาให้ (ในกรณีนี้คือตัวจัดสรรภาระงานของ Compute Engine) โปรดทราบว่าคุณจะเปิดเผยการติดตั้งใช้งาน ไม่ใช่พ็อดโดยตรง ซึ่งจะทำให้บริการที่ได้โหลดบาลานซ์การรับส่งข้อมูลในพ็อดทั้งหมดที่การติดตั้งใช้งานจัดการ (ในกรณีนี้มีเพียง 1 พ็อด แต่คุณจะเพิ่มรีพลิกาในภายหลัง)

มาสเตอร์ 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

โปรดทราบว่ามีที่อยู่ IP 2 รายการสำหรับบริการของคุณ ซึ่งทั้ง 2 รายการใช้พอร์ต 8080 โดย IP หนึ่งคือ IP ภายในที่มองเห็นได้เฉพาะภายในเครือข่ายเสมือนระบบคลาวด์ ส่วนอีก 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 ที่จะอัปเดต Replication Controller เป็นแอปพลิเคชันเวอร์ชันใหม่ได้อย่างราบรื่น หากต้องการเปลี่ยนป้ายกำกับรูปภาพสำหรับคอนเทนเนอร์ที่ทำงานอยู่ คุณต้องแก้ไข 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 อีกครั้งเพื่อดูว่าระบบแสดงการตอบกลับใหม่

13. ย้อนกลับ

อ๊ะ คุณทำผิดพลาดกับแอปพลิเคชันเวอร์ชันใหม่ใช่ไหม บางทีเวอร์ชันใหม่อาจมีข้อผิดพลาดและคุณต้องย้อนกลับอย่างรวดเร็ว Kubernetes ช่วยให้คุณย้อนกลับไปใช้สถานะก่อนหน้าได้อย่างง่ายดาย มาทำการย้อนกลับแอปพลิเคชันโดยการเรียกใช้คำสั่งต่อไปนี้

$ kubectl rollout undo deployment/hello-micronaut

หากดูเอาต์พุตของบริการ เราจะกลับไปที่ข้อความ "Hello World" เริ่มต้น

14. สรุป

ในขั้นตอนนี้ คุณได้ตั้งค่าบริการ Micronaut hello world อย่างง่ายที่ใช้ Apache Groovy และเรียกใช้บริการดังกล่าวโดยตรงจากภายใน 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 License) 2.0 แบบทั่วไป