หน้านี้ได้รับการแปลโดย Cloud Translation API

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

1. ภาพรวม

เกี่ยวกับ Micronaut

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

Micronaut มอบสิ่งต่อไปนี้

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

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

เกี่ยวกับ Kubernetes

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

ในห้องทดลองนี้ คุณติดตั้งใช้งาน Micronaut แบบ Micronaut แบบ Groovy ที่เรียบง่ายให้กับ Kubernetes ที่ทำงานบน Kubernetes Engine

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

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

Kubernetes Codelab แผนภาพ 1 (2).png

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

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

เกี่ยวกับ Jib

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

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

รวดเร็ว — นำการเปลี่ยนแปลงไปใช้อย่างรวดเร็ว Jib จะแยกแอปพลิเคชันของคุณออกเป็นหลายๆ เลเยอร์ โดยแยกทรัพยากร Dependency ออกจากคลาส คุณไม่จำเป็นต้องรอให้ Docker สร้างแอปพลิเคชัน Java ทั้งหมดขึ้นมาใหม่ เพียงแค่ปรับใช้เลเยอร์ที่มีการเปลี่ยนแปลง
ทำซ้ำได้ — การสร้างอิมเมจคอนเทนเนอร์ใหม่โดยใช้เนื้อหาเดียวกันจะสร้างอิมเมจเดียวกันเสมอ ไม่ต้องเรียกใช้การอัปเดตที่ไม่จำเป็นอีก
Daemonless — ลดทรัพยากร Dependency ของ CLI สร้างอิมเมจ Docker จากภายใน Maven หรือ Gradle แล้วพุชไปยังรีจิสทรีใดก็ได้ที่คุณต้องการ ไม่ต้องเขียน Dockerfiles และเรียกใช้บิลด์/พุช Docker อีกต่อไป

ดูข้อมูลเพิ่มเติมเกี่ยวกับ 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. การตั้งค่าและข้อกำหนด

การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก

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

dMbN6g9RawQj_VXCSYpdYncY-DbaRzr2GbnwoV7jFf1u3avxJtmGPmKpMYgiaMH-qu80a_NJ9p2IIXFppYk8x3wyymZXavjglNLJJhuXieCem56H30hwXtd8PvXGpXJO9gEUDu3cZw

ci9Oe6PgnbNuSYlMyvbXF1JdQyiHoEgnhl4PlV_MFagm2ppzhueRkqX4eLjJllZco_2zCp0V0bpTupUSKji9KkQyWqj11pqit1K1faS1V6aFxLGQdkuzGp4rsQTan7F01iePL5DtqQ

8-tA_Lheyo8SscAVKrGii2coplQp2_D1Iosb2ViABY0UUO1A8cimXUu6Wf1R9zJIRExL5OB2j946aIiFtyKTzxDcNnuznmR45vZ2HMoK3o67jxuoUJCAnqvEX6NgPGFjCVNgASc-lg

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

ถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินใน 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 กำลังตอบสนองคำขอภายใต้เส้นทาง /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"
    }
}

การทดสอบนี้นอกจากจะทำการทดสอบ 1 หน่วยแบบง่ายๆ แล้ว การทดสอบนี้ยังเรียกใช้สแต็กเซิร์ฟเวอร์ Micronaut เดียวกัน (อิงตามเฟรมเวิร์ก Netty) ที่มีการใช้งานในเวอร์ชันที่ใช้งานจริง ดังนั้น การทำงานของโค้ดในผลิตภัณฑ์จะเหมือนกันกับในการทดสอบ

หากต้องการทำการทดสอบ คุณสามารถเรียกใช้คำสั่งต่อไปนี้เพื่อดูว่าทุกอย่างเรียบร้อยดี

./gradlew test

5. เรียกใช้แอปพลิเคชันในเครื่อง

คุณสามารถเริ่มบริการ Micronaut ตามปกติด้วยคำสั่ง Gradle ต่อไปนี้

$ ./gradlew run

เมื่อแอปพลิเคชันเริ่มต้นแล้ว คุณสามารถเปิดอินสแตนซ์ Cloud Shell เพิ่มเติมได้ด้วยไอคอน + เล็กๆ จากนั้นตรวจสอบกับ curl ว่าคุณได้รับเอาต์พุตที่ต้องการ ดังนี้

$ curl localhost:8080/hello

แล้วคุณจะเห็นปุ่ม "สวัสดีโลก" จะปรากฏขึ้น

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

ตอนนี้อิมเมจของเราถูกสร้างขึ้นแล้ว ลองมาดูว่ามองเห็นข้อความ friendly หรือไม่โดยเรียกใช้อิมเมจ 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 และชุดโหนดของผู้ปฏิบัติงาน โหนดของผู้ปฏิบัติงานคือเครื่องเสมือน Compute Engine มาใช้ gcloud CLI จากเซสชัน CloudShell เพื่อสร้างคลัสเตอร์ที่มีโหนด n1-standard-1 2 โหนด (การดำเนินการนี้จะใช้เวลาสักครู่)

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

$ 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

หากคุณพอทราบเอาต์พุตจากบริการแล้ว เราจะย้อนกลับไปที่ "สวัสดีโลก" เบื้องต้นของเรา

14. สรุป

ในขั้นตอนนี้ คุณจะต้องตั้งค่าบริการ Micronaut Hello World จาก Apache Groovy แบบง่ายๆ และเรียกใช้จากใน Cloud Shell โดยตรง จากนั้นทำแพ็กเกจเป็นคอนเทนเนอร์ที่มี Jib และทำให้ใช้งานได้ใน Google Kubernetes Engine

15. ยินดีด้วย

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

ใบอนุญาต

ผลงานนี้ได้รับอนุญาตภายใต้ใบอนุญาตทั่วไปครีเอทีฟคอมมอนส์แบบระบุแหล่งที่มา 2.0