Scaling Scala: วิธีเทียบท่าโดยใช้ Kubernetes

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

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

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

Kubernetes คืออะไร?

ก่อนลงรายละเอียดเกี่ยวกับการนำไปใช้จริง เรามาพูดคุยกันก่อนว่า Kubernetes คืออะไรและเหตุใดจึงสำคัญ

คุณอาจเคยได้ยิน Docker แล้ว เรียกได้ว่าเป็นเครื่องเสมือนน้ำหนักเบา

ด้วยเหตุผลเหล่านี้ เครื่องมือนี้จึงเป็นหนึ่งในเครื่องมือที่ใช้กันอย่างแพร่หลายมากขึ้นในการปรับใช้แอปพลิเคชันในระบบคลาวด์ อิมเมจ Docker นั้นค่อนข้างง่ายและรวดเร็วในการสร้างและทำซ้ำได้ ง่ายกว่าเครื่องเสมือนแบบเดิมอย่าง VMWare, VirtualBox หรือ XEN

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

Kubernetes เป็นเครื่องมือโอเพ่นซอร์สที่พัฒนาโดย Google และได้รับการยอมรับจากผู้ขายรายอื่นๆ Kubernetes พร้อมใช้งานบนแพลตฟอร์มคลาวด์ของ Google แต่ผู้ให้บริการรายอื่นได้นำไปใช้กับบริการคลาวด์ OpenShift ด้วยเช่นกัน สามารถพบได้ใน Amazon AWS, Microsoft Azure, RedHat OpenShift และเทคโนโลยีคลาวด์อีกมากมาย เราสามารถพูดได้ว่าอยู่ในตำแหน่งที่ดีที่จะเป็นมาตรฐานสำหรับการปรับใช้แอปพลิเคชันระบบคลาวด์

ข้อกำหนดเบื้องต้น

เมื่อเราครอบคลุมพื้นฐานแล้ว ให้ตรวจสอบว่าคุณได้ติดตั้งซอฟต์แวร์ข้อกำหนดเบื้องต้นทั้งหมดแล้วหรือไม่ ก่อนอื่นคุณต้องมี Docker หากคุณใช้ Windows หรือ Mac คุณต้องมี Docker Toolbox หากคุณกำลังใช้ Linux คุณต้องติดตั้งแพ็คเกจเฉพาะที่มาจากการแจกจ่ายของคุณหรือเพียงทำตามคำแนะนำอย่างเป็นทางการ

เราจะเขียนโค้ดใน Scala ซึ่งเป็นภาษา JVM แน่นอนว่าคุณต้องมี Java Development Kit และเครื่องมือ scala SBT ที่ติดตั้งและพร้อมใช้งานในเส้นทางส่วนกลาง หากคุณเป็นโปรแกรมเมอร์ของ Scala อยู่แล้ว เป็นไปได้ว่าคุณจะมีเครื่องมือเหล่านั้นติดตั้งไว้แล้ว

หากคุณใช้ Windows หรือ Mac โดยค่าเริ่มต้น Docker จะสร้างเครื่องเสมือนที่ชื่อว่า default โดยมีหน่วยความจำเพียง 1GB ซึ่งอาจมีขนาดเล็กเกินไปสำหรับการเรียกใช้ Kubernetes จากประสบการณ์ของฉัน ฉันมีปัญหากับการตั้งค่าเริ่มต้น ฉันแนะนำให้คุณเปิด VirtualBox GUI เลือก virtual machine default และเปลี่ยนหน่วยความจำเป็นอย่างน้อย 2048MB

แอปพลิเคชันเพื่อจัดกลุ่ม

คำแนะนำในบทช่วยสอนนี้สามารถใช้ได้กับแอปพลิเคชันหรือโครงการของ Scala เพื่อให้บทความนี้มี "เนื้อหา" ที่ต้องใช้งาน ฉันเลือกตัวอย่างที่ใช้บ่อยมากเพื่อสาธิต REST microservice อย่างง่ายใน Scala ที่เรียกว่า Akka HTTP ฉันแนะนำให้คุณลองใช้ source kit กับตัวอย่างที่แนะนำก่อนที่จะพยายามใช้กับแอปพลิเคชันของคุณ ฉันได้ทดสอบชุดอุปกรณ์กับแอปพลิเคชันสาธิตแล้ว แต่ไม่สามารถรับประกันได้ว่าโค้ดของคุณจะไม่มีการขัดกัน

ก่อนอื่น เราเริ่มต้นด้วยการโคลนแอปพลิเคชันสาธิต:

 git clone https://github.com/theiterators/akka-http-microservice

ต่อไป ทดสอบว่าทุกอย่างถูกต้องหรือไม่:

 cd akka-http-microservice sbt run

จากนั้นเข้าไปที่ http://localhost:9000/ip/8.8.8.8 และคุณควรเห็นบางอย่างเช่นในภาพต่อไปนี้:

การเพิ่ม Source Kit

ตอนนี้เราสามารถเพิ่มชุดซอร์สด้วยเวทย์มนตร์ Git:

 git remote add ScalaGoodies https://github.com/sciabarra/ScalaGoodies git fetch --all git merge ScalaGoodies/kubernetes

ด้วยเหตุนี้ คุณจึงมีการสาธิตรวมถึงชุดแหล่งที่มา และคุณพร้อมที่จะลอง หรือคุณสามารถคัดลอกและวางโค้ดจากที่นั่นลงในแอปพลิเคชันของคุณ

เมื่อคุณรวมหรือคัดลอกไฟล์ในโครงการของคุณแล้ว คุณก็พร้อมที่จะเริ่มต้น

เริ่มต้น Kubernetes

เมื่อคุณดาวน์โหลดชุดคิทแล้ว เราต้องดาวน์โหลดไบนารี kubectl ที่จำเป็นโดยการเรียกใช้:

 bin/install.sh

โปรแกรมติดตั้งนี้ฉลาดพอที่จะดาวน์โหลดไบนารี kubectl ที่ถูกต้องสำหรับ OSX, Linux หรือ Windows ขึ้นอยู่กับระบบของคุณ หมายเหตุ โปรแกรมติดตั้งทำงานบนระบบที่ฉันเป็นเจ้าของ โปรดรายงานปัญหาใด ๆ เพื่อที่ฉันจะได้แก้ไขชุดอุปกรณ์

เมื่อคุณติดตั้งไบนารี kubectl แล้ว คุณสามารถเริ่ม Kubernetes ทั้งหมดใน Docker ในพื้นที่ของคุณได้ เพียงแค่เรียกใช้:

 bin/start-local-kube.sh

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

สมมติว่าคุณสามารถดาวน์โหลดทุกอย่างได้สำเร็จ เพื่อตรวจสอบว่า Kubernetes ทำงานได้ดีหรือไม่ คุณสามารถพิมพ์คำสั่งต่อไปนี้:

 bin/kubectl get nodes

คำตอบที่คาดหวังคือ:

 NAME STATUS AGE 127.0.0.1 Ready 2m

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

เชื่อมต่อแอป Scala ของคุณ

ตอนนี้คุณมี Kubernetes และทำงานอยู่ คุณสามารถปรับใช้แอปพลิเคชันของคุณในนั้นได้ ในสมัยก่อน ก่อน Docker คุณต้องปรับใช้เซิร์ฟเวอร์ทั้งหมดเพื่อเรียกใช้แอปพลิเคชันของคุณ ด้วย Kubernetes สิ่งที่คุณต้องทำเพื่อปรับใช้แอปพลิเคชันของคุณคือ:

• สร้างอิมเมจ Docker
• พุชในรีจิสทรีจากตำแหน่งที่สามารถเปิดใช้ได้
• เปิดใช้อินสแตนซ์ด้วย Kubernetes ซึ่งจะดึงรูปภาพจากรีจิสทรี

โชคดีที่มันดูซับซ้อนน้อยกว่า โดยเฉพาะอย่างยิ่งหากคุณใช้เครื่องมือสร้าง SBT อย่างที่หลายๆ คนทำ

ในชุดเครื่องมือนี้ ฉันได้รวมไฟล์สองไฟล์ที่มีคำจำกัดความที่จำเป็นทั้งหมดเพื่อสร้างรูปภาพที่สามารถเรียกใช้แอปพลิเคชัน Scala หรืออย่างน้อยก็จำเป็นสำหรับการเรียกใช้การสาธิต Akka HTTP ฉันไม่สามารถรับประกันได้ว่ามันจะทำงานกับแอปพลิเคชัน Scala อื่น ๆ แต่มันเป็นจุดเริ่มต้นที่ดีและควรใช้งานได้กับการกำหนดค่าที่แตกต่างกันมากมาย ไฟล์ที่ต้องการสร้างอิมเมจ Docker คือ:

 docker.sbt project/docker.sbt

มาดูกันดีกว่าว่ามีอะไรบ้าง ไฟล์ project/docker.sbt มีคำสั่งให้นำเข้าปลั๊กอิน sbt-docker :

 addSbtPlugin("se.marcuslonnberg" % "sbt-docker" % "1.4.0")

ปลั๊กอินนี้จัดการการสร้างอิมเมจ Docker ด้วย SBT สำหรับคุณ คำจำกัดความของ Docker อยู่ในไฟล์ docker.sbt และมีลักษณะดังนี้:

 imageNames in docker := Seq(ImageName("localhost:5000/akkahttp:latest")) dockerfile in docker := { val jarFile: File = sbt.Keys.`package`.in(Compile, packageBin).value val classpath = (managedClasspath in Compile).value val mainclass = mainClass.in(Compile, packageBin).value.getOrElse(sys.error("Expected exactly one main class")) val jarTarget = s"/app/${jarFile.getName}" val classpathString = classpath.files.map("/app/" + _.getName) .mkString(":") + ":" + jarTarget new Dockerfile { from("anapsix/alpine-java:8") add(classpath.files, "/app/") add(jarFile, jarTarget) entryPoint("java", "-cp", classpathString, mainclass) } }

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

โปรดทราบว่า classpath ถูกสร้างขึ้นโดยอัตโนมัติโดยคำสั่งต่อไปนี้:

 val classpath = (managedClasspath in Compile).value

โดยทั่วไป การรวบรวมไฟล์ JAR ทั้งหมดเพื่อเรียกใช้แอปพลิเคชันนั้นค่อนข้างซับซ้อน การใช้ SBT ไฟล์ Docker จะถูกสร้างขึ้นด้วย add(classpath.files, "/app/") ด้วยวิธีนี้ SBT จะรวบรวมไฟล์ JAR ทั้งหมดสำหรับคุณและสร้าง Dockerfile เพื่อเรียกใช้แอปพลิเคชันของคุณ

คำสั่งอื่นๆ รวบรวมชิ้นส่วนที่หายไปเพื่อสร้างอิมเมจ Docker รูปภาพจะถูกสร้างขึ้นโดยใช้ APT ของรูปภาพที่มีอยู่เพื่อเรียกใช้โปรแกรม Java ( anapsix/alpine-java:8 พร้อมใช้งานบนอินเทอร์เน็ตใน Docker Hub) คำแนะนำอื่นๆ กำลังเพิ่มไฟล์อื่นๆ เพื่อเรียกใช้แอปพลิเคชันของคุณ สุดท้าย โดยการระบุจุดเข้าใช้งาน เราสามารถเรียกใช้ได้ โปรดทราบว่าชื่อขึ้นต้นด้วย localhost:5000 โดยเจตนา เนื่องจาก localhost:5000 คือตำแหน่งที่ฉันติดตั้งรีจิสทรีในสคริปต์ start-kube-local.sh

การสร้าง Docker Image ด้วย SBT

ในการสร้างอิมเมจ Docker คุณสามารถละเว้นรายละเอียดทั้งหมดของ Dockerfile คุณเพียงแค่ต้องพิมพ์:

 sbt dockerBuildAndPush

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

หมายเหตุ หากคุณประสบปัญหา สิ่งที่ดีที่สุดที่ควรทำคือรีเซ็ตทุกอย่างเป็นสถานะที่รู้จักโดยเรียกใช้คำสั่งต่อไปนี้:

 bin/stop-kube-local.sh bin/start-kube-local.sh

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

การเริ่มต้นบริการใน Kubernetes

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

ขั้นตอนต่อไปของเราคือการเปิดตัวอินสแตนซ์เดียวของรูปภาพ อิมเมจที่รันอยู่เรียกว่า pod ในภาษา Kubernetes ให้สร้างพ็อดโดยเรียกใช้คำสั่งต่อไปนี้:

 bin/kubectl create -f kube/akkahttp-pod.yml

ตอนนี้คุณสามารถตรวจสอบสถานการณ์ด้วยคำสั่ง:

 bin/kubectl get pods

คุณควรเห็น:

 NAME READY STATUS RESTARTS AGE akkahttp 1/1 Running 0 33s k8s-etcd-127.0.0.1 1/1 Running 0 7d k8s-master-127.0.0.1 4/4 Running 0 7d k8s-proxy-127.0.0.1 1/1 Running 0 7d

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

คุณยังสามารถตรวจสอบว่าพ็อดของคุณทำงานอยู่ด้วยคำสั่งหรือไม่:

 bin/kubectl logs akkahttp

คุณควรเห็นผลลัพธ์ที่ลงท้ายด้วยสิ่งนี้:

 [DEBUG] [05/30/2016 12:19:53.133] [default-akka.actor.default-dispatcher-5] [akka://default/system/IO-TCP/selectors/$a/0] Successfully bound to /0:0:0:0:0:0:0:0:9000

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

การสร้างบริการ

การสร้างบริการและการตรวจสอบผลลัพธ์เป็นเรื่องของการดำเนินการ:

 bin/kubectl create -f kube/akkahttp-service.yaml bin/kubectl get svc

คุณควรเห็นสิ่งนี้:

 NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE akkahttp-service 10.0.0.54 9000/TCP 44s kubernetes 10.0.0.1 <none> 443/TCP 3m

โปรดทราบว่าพอร์ตอาจแตกต่างกัน Kubernetes จัดสรรพอร์ตสำหรับบริการและเริ่มต้น หากคุณใช้ Linux คุณสามารถเปิดเบราว์เซอร์ได้โดยตรงและพิมพ์ http://10.0.0.54:9000/ip/8.8.8.8 เพื่อดูผลลัพธ์ หากคุณกำลังใช้ Windows หรือ Mac กับ Docker Toolbox IP นั้นอยู่ในเครื่องเสมือนที่รัน Docker และน่าเสียดายที่มันยังไม่สามารถเข้าถึงได้

ฉันต้องการเน้นที่นี่ว่านี่ไม่ใช่ปัญหาของ Kubernetes แต่เป็นข้อจำกัดของ Docker Toolbox ซึ่งจะขึ้นอยู่กับข้อจำกัดที่กำหนดโดยเครื่องเสมือน เช่น VirtualBox ซึ่งทำหน้าที่เหมือนคอมพิวเตอร์ภายในคอมพิวเตอร์เครื่องอื่น เพื่อเอาชนะข้อจำกัดนี้ เราต้องสร้างอุโมงค์ เพื่อให้ง่ายขึ้น ฉันได้รวมสคริปต์อื่นซึ่งเปิดช่องสัญญาณบนพอร์ตใดก็ได้เพื่อเข้าถึงบริการที่เราปรับใช้ คุณสามารถพิมพ์คำสั่งต่อไปนี้:

 bin/forward-kube-local.sh akkahttp-service 9000

โปรดทราบว่าอุโมงค์จะไม่ทำงานในพื้นหลัง คุณต้องเปิดหน้าต่างเทอร์มินัลไว้ตราบเท่าที่คุณต้องการ และปิดเมื่อคุณไม่ต้องการใช้อุโมงค์ข้อมูลอีกต่อไป ขณะที่อุโมงค์กำลังทำงานอยู่ คุณสามารถเปิด: http://localhost:9000/ip/8.8.8.8 และในที่สุดก็เห็นแอปพลิเคชันที่ทำงานอยู่ใน Kubernetes

สัมผัสสุดท้าย: มาตราส่วน

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

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

เราจะหยุดพ็อดเดียวและเริ่มการทำให้ใช้งานได้แทน ให้ดำเนินการคำสั่งต่อไปนี้:

 bin/kubectl delete -f kube/akkahttp-pod.yml bin/kubectl create -f kube/akkahttp-deploy.yaml

ถัดไป ตรวจสอบสถานะ อีกครั้ง คุณอาจลองสองสามครั้งเนื่องจากการปรับใช้อาจใช้เวลาในการดำเนินการ:

 NAME READY STATUS RESTARTS AGE akkahttp-deployment-4229989632-mjp6u 1/1 Running 0 16s akkahttp-deployment-4229989632-s822x 1/1 Running 0 16s k8s-etcd-127.0.0.1 1/1 Running 0 6d k8s-master-127.0.0.1 4/4 Running 0 6d k8s-proxy-127.0.0.1 1/1 Running 0 6d

ตอนนี้เรามีสองพ็อด ไม่ใช่หนึ่งพ็อด นี่เป็นเพราะในไฟล์คอนฟิกูเรชันที่ฉันให้ไว้ มีการ replica: 2 โดยมีชื่อที่แตกต่างกันสองชื่อที่สร้างโดยระบบ ฉันจะไม่ลงรายละเอียดเกี่ยวกับไฟล์การกำหนดค่า เนื่องจากขอบเขตของบทความเป็นเพียงการแนะนำสำหรับโปรแกรมเมอร์ Scala เพื่อเริ่มต้นใช้งาน Kubernetes

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

เราสามารถตรวจสอบได้โดยเปิดใช้พรอกซีอีกครั้ง (หากคุณใช้ Windows และปิดไปแล้ว):

 bin/forward-kube-local.sh akkahttp-service 9000

จากนั้น เราสามารถลองเปิดหน้าต่างเทอร์มินัลสองหน้าต่าง และดูบันทึกสำหรับแต่ละพ็อด ตัวอย่างเช่นในประเภทแรก:

 bin/kubectl logs -f akkahttp-deployment-4229989632-mjp6u

และในประเภทที่สอง:

 bin/kubectl logs -f akkahttp-deployment-4229989632-s822x

แน่นอน แก้ไขบรรทัดคำสั่งตามค่าที่คุณมีในระบบของคุณ

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

บทสรุป

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