1. ภาพรวม
เกี่ยวกับ Micronaut
Micronaut เป็นเฟรมเวิร์กแบบฟูลสแต็กที่ทันสมัยซึ่งใช้ JVM สำหรับสร้างแอปพลิเคชัน Microservice และแอปพลิเคชันแบบ Serverless ที่เป็นโมดูลและทดสอบได้ง่าย Micronaut มุ่งมั่นที่จะมอบเวลาเริ่มต้นที่ยอดเยี่ยม ปริมาณงานที่รวดเร็ว และใช้หน่วยความจำน้อยที่สุด นักพัฒนาแอปสามารถพัฒนาด้วย Micronaut ใน Java, Groovy หรือ Kotlin
Micronaut มีฟีเจอร์ต่อไปนี้
- เวลาเริ่มต้นที่รวดเร็วและการใช้หน่วยความจำต่ำ - เฟรมเวิร์ก IoC ที่อิงตามการสะท้อนจะโหลดและแคชข้อมูลการสะท้อนสำหรับทุกฟิลด์ เมธอด และตัวสร้างในโค้ดของคุณ ในขณะที่เมื่อใช้ Micronaut เวลาเริ่มต้นของแอปพลิเคชันและการใช้หน่วยความจำจะไม่ขึ้นอยู่กับขนาดของโค้ดเบส
- ไคลเอ็นต์ HTTP แบบประกาศ แบบรีแอกทีฟ และแบบคอมไพล์ไทม์ - สร้างไคลเอ็นต์ HTTP แบบรีแอกทีฟแบบประกาศ ซึ่งจะใช้งานที่คอมไพล์ไทม์เพื่อลดการใช้หน่วยความจำ
- เซิร์ฟเวอร์ HTTP แบบไม่บล็อกที่สร้างขึ้นบน Netty - เซิร์ฟเวอร์ HTTP ของ Micronaut ช่วยให้การเปิดเผย API ที่ไคลเอ็นต์ HTTP ใช้ได้เป็นเรื่องง่ายที่สุด
- การทดสอบที่รวดเร็วและง่ายดาย - สร้างเซิร์ฟเวอร์และไคลเอ็นต์ในการทดสอบหน่วยได้อย่างง่ายดาย และเรียกใช้ได้ทันที
- การแทรกทรัพยากร Dependency และ AOP ที่มีประสิทธิภาพในเวลาคอมไพล์ - Micronaut มี API การเขียนโปรแกรมเชิงแง่มุมอย่างง่ายในเวลาคอมไพล์ซึ่งไม่ได้ใช้การสะท้อน
- สร้างแอปที่ตอบสนองได้อย่างเต็มที่และไม่บล็อก - Micronaut รองรับเฟรมเวิร์กที่ใช้ Reactive Streams รวมถึง RxJava และ Reactor
ดูข้อมูลเพิ่มเติมได้ที่เว็บไซต์ Micronaut
เกี่ยวกับ Kubernetes
Kubernetes เป็นโปรเจ็กต์โอเพนซอร์สที่สามารถทำงานในสภาพแวดล้อมที่แตกต่างกันได้มากมาย ตั้งแต่แล็ปท็อปไปจนถึงคลัสเตอร์แบบหลายโหนดที่มีความพร้อมใช้งานสูง ตั้งแต่ระบบคลาวด์สาธารณะไปจนถึงการติดตั้งใช้งานในองค์กร ตั้งแต่เครื่องเสมือนไปจนถึง Bare Metal
ใน Lab นี้ คุณจะได้ทำให้ Microservice ของ Micronaut ที่สร้างด้วย Groovy แบบง่ายๆ ใช้งานได้ใน Kubernetes ที่ทำงานใน Kubernetes Engine
เป้าหมายของ Codelab นี้คือการให้คุณเรียกใช้ Microservice เป็นบริการที่จำลองแบบซึ่งทำงานใน Kubernetes คุณนำโค้ดที่พัฒนาในเครื่องมาเปลี่ยนเป็นอิมเมจคอนเทนเนอร์ Docker แล้วเรียกใช้อิมเมจนั้นใน Kubernetes Engine
ต่อไปนี้เป็นแผนภาพของส่วนต่างๆ ที่ทำงานร่วมกันใน Codelab นี้เพื่อช่วยให้คุณเข้าใจว่าส่วนต่างๆ ทำงานร่วมกันอย่างไร ใช้ข้อมูลนี้เป็นข้อมูลอ้างอิงขณะที่คุณทำตาม Codelab ไปเรื่อยๆ ทุกอย่างควรจะสมเหตุสมผลเมื่อคุณไปถึงตอนท้าย (แต่คุณจะข้ามส่วนนี้ไปก่อนก็ได้)
สำหรับ Codelab นี้ การใช้สภาพแวดล้อมที่มีการจัดการ เช่น 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 คุณต้องสร้างบัญชี)
โปรดจดจำรหัสโปรเจ็กต์ ซึ่งเป็นชื่อที่ไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมด (ชื่อด้านบนมีผู้ใช้แล้วและจะใช้ไม่ได้ ขออภัย) ซึ่งจะเรียกว่า PROJECT_ID ในภายหลังใน Codelab นี้
- จากนั้นคุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร Google Cloud
การทำตาม Codelab นี้ไม่ควรมีค่าใช้จ่ายมากนัก หรืออาจไม่มีเลย โปรดทำตามวิธีการในส่วน "การล้างข้อมูล" ซึ่งจะแนะนำวิธีปิดทรัพยากรเพื่อไม่ให้มีการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ ผู้ใช้ใหม่ของ Google Cloud มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรีมูลค่า$300USD
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 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 โหนด 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 (ตั้งค่าไว้แล้วในสภาพแวดล้อมของ Shell ใน 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. ยินดีด้วย
คุณได้เรียนรู้วิธีสร้างและติดตั้งใช้งาน 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 ซึ่งจะแนะนำวิธีทําให้แอปพลิเคชันแบบฟูลสแต็กใช้งานได้
ใบอนุญาต
ผลงานนี้ได้รับอนุญาตภายใต้สัญญาอนุญาตครีเอทีฟคอมมอนส์สำหรับยอมรับสิทธิของผู้สร้าง (Creative Commons Attribution License) 2.0 แบบทั่วไป