ทำให้แอป ASP.NET Core ใช้งานได้กับ Kubernetes บน Google Kubernetes Engine

1. ภาพรวม

ASP.NET Core เป็นเฟรมเวิร์กโอเพนซอร์สและข้ามแพลตฟอร์มใหม่สำหรับสร้างแอปพลิเคชันที่ทันสมัยซึ่งใช้ระบบคลาวด์และเชื่อมต่ออินเทอร์เน็ตโดยใช้ภาษาโปรแกรม C#

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

ใน Lab นี้ คุณจะทำให้แอป ASP.NET Core อย่างง่ายใช้งานได้ใน Kubernetes ที่ทำงานบน Kubernetes Engine Codelab นี้สร้างขึ้นจาก Codelab สร้างและเปิดใช้แอป ASP.NET Core จาก Google Cloud Shell คุณอาจต้องทำแล็บนั้นก่อนที่จะลองทำแล็บนี้

เป้าหมายของ Codelab นี้คือการเปลี่ยนโค้ดของคุณ (แอป ASP.NET Core แบบ Hello World อย่างง่ายที่นี่) ให้เป็นแอปพลิเคชันที่จำลองแบบซึ่งทำงานบน Kubernetes คุณนำโค้ดที่พัฒนาในเครื่องมาเปลี่ยนเป็นอิมเมจคอนเทนเนอร์ Docker แล้วเรียกใช้อิมเมจนั้นใน Google Kubernetes Engine

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

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

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

สิ่งที่คุณจะได้เรียนรู้

• วิธีแพ็กเกจแอป ASP.NET Core แบบง่ายเป็นคอนเทนเนอร์ Docker
• วิธีสร้างคลัสเตอร์ Kubernetes ใน Google Kubernetes Engine (GKE)
• วิธีติดตั้งใช้งานแอป ASP.NET Core ไปยังพ็อด
• วิธีอนุญาตให้การรับส่งข้อมูลภายนอกเข้าสู่พ็อด
• วิธีขยายขนาดบริการและเปิดตัวการอัปเกรด
• วิธีเรียกใช้แดชบอร์ดแบบกราฟิกของ Kubernetes

สิ่งที่คุณต้องมี

• เบราว์เซอร์ เช่น Chrome หรือ Firefox

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

อ่านอย่างเดียว อ่านและทำแบบฝึกหัด

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

ผู้ฝึกหัด ขั้นกลาง ผู้ชำนาญ

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

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

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

• ชื่อโปรเจ็กต์คือชื่อที่แสดงสำหรับผู้เข้าร่วมโปรเจ็กต์นี้ ซึ่งเป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ โดยคุณจะอัปเดตได้ทุกเมื่อ
• รหัสโปรเจ็กต์ต้องไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมดและเปลี่ยนแปลงไม่ได้ (เปลี่ยนไม่ได้หลังจากตั้งค่าแล้ว) Cloud Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ซึ่งโดยปกติแล้วคุณไม่จำเป็นต้องสนใจว่าสตริงนั้นคืออะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น PROJECT_ID) หากไม่ชอบรหัสที่สร้างขึ้น คุณก็สร้างรหัสแบบสุ่มอีกรหัสหนึ่งได้ หรือคุณจะลองใช้ชื่อของคุณเองเพื่อดูว่าพร้อมใช้งานหรือไม่ก็ได้ คุณจะเปลี่ยนแปลงรหัสนี้หลังจากขั้นตอนนี้ไม่ได้ และรหัสจะยังคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
• โปรดทราบว่ายังมีค่าที่ 3 ซึ่งคือหมายเลขโปรเจ็กต์ที่ API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 นี้ได้ในเอกสารประกอบ

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

หมายเหตุ: หากใช้บัญชี Gmail คุณสามารถปล่อยให้ตำแหน่งเริ่มต้นเป็นไม่มีองค์กรได้ หากใช้บัญชี Google Workspace ให้เลือกสถานที่ตั้งที่เหมาะสมกับองค์กร

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

เริ่มต้น Cloud Shell

แม้ว่าคุณจะใช้งาน Google Cloud จากระยะไกลจากแล็ปท็อปได้ แต่ใน Codelab นี้คุณจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์

เปิดใช้งาน Cloud Shell

1. จาก Cloud Console ให้คลิกเปิดใช้งาน Cloud Shell

หากไม่เคยเริ่มใช้ Cloud Shell มาก่อน คุณจะเห็นหน้าจอระดับกลาง (ด้านล่าง) ที่อธิบายว่า Cloud Shell คืออะไร ในกรณีนี้ ให้คลิกต่อไป (และคุณจะไม่เห็นหน้าจอนี้อีก) หน้าจอแบบครั้งเดียวจะมีลักษณะดังนี้

การจัดสรรและเชื่อมต่อกับ Cloud Shell จะใช้เวลาไม่นาน

เครื่องเสมือนนี้มีเครื่องมือพัฒนาซอฟต์แวร์ทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักแบบถาวรขนาด 5 GB และทำงานใน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก คุณสามารถทำงานในโค้ดแล็บนี้ได้โดยใช้เพียงเบราว์เซอร์หรือ Chromebook

เมื่อเชื่อมต่อกับ Cloud Shell แล้ว คุณควรเห็นว่าคุณได้รับการตรวจสอบสิทธิ์แล้วและโปรเจ็กต์ได้รับการตั้งค่าเป็นรหัสโปรเจ็กต์ของคุณแล้ว

2. เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว

gcloud auth list

เอาต์พุตของคำสั่ง

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

หมายเหตุ: gcloud เครื่องมือบรรทัดคำสั่งเป็นเครื่องมือบรรทัดคำสั่งที่มีประสิทธิภาพและเป็นหนึ่งเดียวใน Google Cloud โดยจะติดตั้งมาล่วงหน้าใน Cloud Shell คุณจะเห็นว่าเครื่องมือนี้รองรับการเติมข้อความอัตโนมัติด้วยการกด Tab ดูข้อมูลเพิ่มเติมได้ที่ภาพรวมเครื่องมือบรรทัดคำสั่ง gcloud

3. เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้จักโปรเจ็กต์ของคุณ

gcloud config list project

เอาต์พุตของคำสั่ง

[core]
project = <PROJECT_ID>

หากไม่ได้ตั้งค่าไว้ คุณตั้งค่าได้ด้วยคำสั่งนี้

gcloud config set project <PROJECT_ID>

เอาต์พุตของคำสั่ง

Updated property [core/project].

3. สร้างแอป ASP.NET Core ใน Cloud Shell

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

dotnet --version

จากนั้นสร้างเว็บแอป ASP.NET Core โครงร่างใหม่

dotnet new mvc -o HelloWorldAspNetCore

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

Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.

Restore succeeded.

4. เรียกใช้แอป ASP.NET Core

เราพร้อมที่จะเรียกใช้แอปแล้ว ไปที่โฟลเดอร์แอป

cd HelloWorldAspNetCore

สุดท้าย ให้เรียกใช้แอป

dotnet run --urls=http://localhost:8080

แอปพลิเคชันเริ่มฟังบนพอร์ต 8080

Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.

หากต้องการยืนยันว่าแอปทำงานอยู่ ให้คลิกปุ่มแสดงตัวอย่างเว็บที่ด้านขวาบน แล้วเลือก "แสดงตัวอย่างบนพอร์ต 8080"

คุณจะเห็นหน้าเว็บ ASP.NET Core เริ่มต้น

เมื่อยืนยันว่าแอปทำงานอยู่แล้ว ให้กด Ctrl+C เพื่อปิดแอป

5. แพ็กเกจแอป ASP.NET Core เป็นคอนเทนเนอร์ Docker

จากนั้นเตรียมแอปให้ทำงานเป็นคอนเทนเนอร์ ขั้นตอนแรกคือการกำหนดคอนเทนเนอร์และเนื้อหาของคอนเทนเนอร์

ในไดเรกทอรีฐานของแอป ให้สร้าง Dockerfile เพื่อกำหนดอิมเมจ Docker

touch Dockerfile

เพิ่มข้อมูลต่อไปนี้ลงใน Dockerfile โดยใช้โปรแกรมแก้ไขที่คุณชื่นชอบ (vim, nano,emacs หรือตัวแก้ไขโค้ดของ Cloud Shell)

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Make sure the app binds to port 8080
ENV ASPNETCORE_URLS http://*:8080

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]

การกำหนดค่าที่สำคัญอย่างหนึ่งซึ่งรวมอยู่ใน Dockerfile คือพอร์ตที่แอปใช้รับฟังการรับส่งข้อมูลขาเข้า (8080) ซึ่งทำได้โดยการตั้งค่าตัวแปรสภาพแวดล้อม ASPNETCORE_URLS ซึ่งแอป ASP.NET Core ใช้เพื่อกำหนดพอร์ตที่จะรับฟัง

บันทึก Dockerfile นี้ ตอนนี้มาสร้างอิมเมจกัน

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .

เมื่อกระบวนการนี้เสร็จสมบูรณ์ (ระบบจะใช้เวลาสักครู่ในการดาวน์โหลดและแตกไฟล์ทุกอย่าง) คุณจะเห็นว่าระบบสร้างและบันทึกอิมเมจไว้ในเครื่องแล้ว

docker images

REPOSITORY                             TAG   
gcr.io/yourproject-XXXX/hello-dotnet   v1            

ทดสอบอิมเมจในเครื่องด้วยคำสั่งต่อไปนี้ ซึ่งจะเรียกใช้คอนเทนเนอร์ Docker ในเครื่องบนพอร์ต 8080 จากอิมเมจคอนเทนเนอร์ที่สร้างขึ้นใหม่

docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

และใช้ประโยชน์จากฟีเจอร์ตัวอย่างเว็บของ Cloud Shell อีกครั้ง

คุณควรเห็นหน้าเว็บ ASP.NET Core เริ่มต้นในแท็บใหม่

เมื่อยืนยันว่าแอปทำงานได้ดีในเครื่องในคอนเทนเนอร์ Docker แล้ว คุณจะหยุดคอนเทนเนอร์ที่กำลังทำงานได้โดยใช้ Ctrl-> C

ตอนนี้อิมเมจทำงานได้ตามที่ต้องการแล้ว คุณสามารถพุชอิมเมจไปยัง Google Container Registry ซึ่งเป็นที่เก็บส่วนตัวสำหรับอิมเมจ Docker ที่เข้าถึงได้จากทุกโปรเจ็กต์ Google Cloud (รวมถึงจากภายนอก Google Cloud Platform) ดังนี้

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

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

โปรดทราบว่าแม้ว่าเราจะใช้โดเมนทั่วไปสำหรับรีจิสทรี (gcr.io) แต่คุณก็สามารถระบุโซนและ Bucket ที่จะใช้ให้เจาะจงมากขึ้นได้ ดูรายละเอียดได้ที่ https://cloud.google.com/container-registry/docs/#pushing_to_the_registry

หากสนใจ คุณสามารถไปยังส่วนต่างๆ ของอิมเมจคอนเทนเนอร์ขณะที่จัดเก็บไว้ใน Google Cloud Storage ได้โดยไปที่ลิงก์ https://console.cloud.google.com/storage/browser/ (ลิงก์ที่สมบูรณ์ควรมีรูปแบบดังนี้ https://console.cloud.google.com/project/PROJECT_ID/storage/browser/)

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

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

คลัสเตอร์ประกอบด้วยเซิร์ฟเวอร์ API ต้นแบบของ Kubernetes ที่ Google จัดการ และชุดโหนด Worker โหนดผู้ปฏิบัติงานคือเครื่องเสมือน Compute Engine

มาใช้ gcloud CLI จากเซสชัน Cloud Shell เพื่อสร้างคลัสเตอร์กัน ปรับโซนให้ใกล้กับคุณ ( รายชื่อโซน) โดยจะใช้เวลาสักครู่

gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b

ในท้ายที่สุด คุณควรเห็นคลัสเตอร์ที่สร้างขึ้น

Creating cluster hello-dotnet-cluster...done.
Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-dotnet-cluster  europe-west1-b  1.10.7-gke.6

หรือจะสร้างคลัสเตอร์นี้ผ่านคอนโซลที่แสดงด้านบนก็ได้ โดยไปที่Compute > Kubernetes Engine > คลัสเตอร์คอนเทนเนอร์ > สร้างคลัสเตอร์คอนเทนเนอร์

คุณสร้างคลัสเตอร์ในโซนอื่นได้ แต่ขอแนะนำให้เก็บไว้ในภูมิภาคเดียวกับที่เก็บข้อมูลที่ใช้โดย Container Registry (ดูขั้นตอนก่อนหน้า)

ตอนนี้คุณควรมีคลัสเตอร์ Kubernetes ที่ทำงานได้อย่างสมบูรณ์ซึ่งขับเคลื่อนโดย Google Kubernetes Engine ดังนี้

ตอนนี้ก็ถึงเวลาทำให้แอปพลิเคชันที่มีคอนเทนเนอร์ของคุณเองใช้งานได้ในคลัสเตอร์ Kubernetes แล้ว นับจากนี้ไป คุณจะใช้บรรทัดคำสั่ง kubectl (ตั้งค่าไว้แล้วในสภาพแวดล้อม Cloud Shell) Codelab ที่เหลือนี้กำหนดให้ทั้งไคลเอ็นต์และเซิร์ฟเวอร์ Kubernetes ต้องเป็นเวอร์ชัน 1.2 ขึ้นไป kubectl version จะแสดงเวอร์ชันปัจจุบันของคำสั่ง

7. สร้างการทำให้ใช้งานได้

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

สร้างไฟล์ hello-dotnet.yaml โดยใช้โปรแกรมแก้ไขที่คุณชื่นชอบ (vim, nano,emacs หรือโปรแกรมแก้ไขโค้ดของ Cloud Shell) และกำหนดการติดตั้งใช้งาน Kubernetes สำหรับพ็อด

อย่าลืมแทนที่ YOUR-PROJECT-ID ด้วยรหัสของโปรเจ็กต์

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: hello-dotnet
  template:
    metadata:
      labels:
        run: hello-dotnet
    spec:
      containers:
      - name: hello-dotnet
        image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

ติดตั้งใช้งานในเนมสเปซเริ่มต้นด้วย kubectl

kubectl apply -f hello-dotnet.yaml

deployment.apps/hello-dotnet created

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

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

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   1         1         1            1           37s

หากต้องการดูพ็อดที่การทำให้ใช้งานได้สร้างขึ้น ให้เรียกใช้คำสั่งนี้

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-ztzrb   1/1       Running   0          57s

ตอนนี้เป็นเวลาที่เหมาะที่จะลองใช้kubectlคำสั่งที่น่าสนใจ (คำสั่งเหล่านี้จะไม่เปลี่ยนสถานะของคลัสเตอร์ และคุณสามารถดูเอกสารประกอบฉบับเต็มได้ที่นี่)

kubectl get pods
kubectl cluster-info
kubectl config view
kubectl get events
kubectl logs <pod-name>

ตอนนี้คุณควรมีคอนเทนเนอร์ที่ทำงานภายใต้การควบคุมของ Kubernetes แต่คุณยังคงต้องทำให้คอนเทนเนอร์เข้าถึงได้จากภายนอก

8. อนุญาตการรับส่งข้อมูลภายนอก

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

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

kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080

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

มาสเตอร์ Kubernetes จะสร้างตัวจัดสรรภาระงานและกฎการส่งต่อ, กลุ่มเป้าหมาย และกฎไฟร์วอลล์ที่เกี่ยวข้องของ Compute Engine เพื่อให้เข้าถึงบริการได้อย่างเต็มที่จากภายนอก Google Cloud Platform

หากต้องการค้นหาที่อยู่ IP ที่เข้าถึงได้แบบสาธารณะของบริการ ให้ขอ kubectl เพื่อแสดงบริการคลัสเตอร์ทั้งหมด

kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-dotnet 10.3.253.62   104.155.20.69   8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

โปรดทราบว่ามีที่อยู่ IP 2 รายการสำหรับบริการของคุณ ซึ่งทั้ง 2 รายการใช้พอร์ต 8080 โดย IP หนึ่งคือ IP ภายในที่มองเห็นได้เฉพาะภายในเครือข่ายเสมือนระบบคลาวด์ ส่วนอีก IP คือ IP ภายนอกที่โหลดบาลานซ์ ในตัวอย่างนี้ ที่อยู่ IP ภายนอกคือ 104.155.20.69

EXTERNAL-IP อาจใช้เวลาหลายนาทีจึงจะพร้อมใช้งานและปรากฏ หากไม่เห็น EXTERNAL-IP ให้รอสักครู่แล้วลองอีกครั้ง

ตอนนี้คุณควรเข้าถึงบริการได้โดยชี้เบราว์เซอร์ไปที่ที่อยู่ http://<EXTERNAL_IP>:8080

ตอนนี้คุณได้รับฟีเจอร์อย่างน้อย 2-3 อย่างจากการย้ายไปใช้คอนเทนเนอร์และ Kubernetes แล้ว คุณไม่จำเป็นต้องระบุโฮสต์ที่จะเรียกใช้เวิร์กโหลด และยังได้รับประโยชน์จากการตรวจสอบและรีสตาร์ทบริการด้วย มาดูกันว่าคุณจะได้รับประโยชน์อะไรอีกบ้างจากโครงสร้างพื้นฐาน Kubernetes ใหม่

9. ขยายขนาดบริการ

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

kubectl scale deployment hello-dotnet --replicas=4

kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         4         4            3           16m

kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m
hello-dotnet-714049816-sh812   1/1       Running   0          1m
hello-dotnet-714049816-ztzrb   1/1       Running   0          16m

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

ต่อไปนี้คือแผนภาพที่สรุปสถานะของคลัสเตอร์ Kubernetes

นอกจากนี้ คุณยังลดขนาดบริการได้อย่างง่ายดาย ตัวอย่างวิธีลดขนาดจาก 4 พ็อดเป็น 2 พ็อด

kubectl scale deployment hello-dotnet --replicas=2

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

10. ทดสอบความยืดหยุ่น

Kubernetes (หรือ ReplicaSet โดยเฉพาะ) จะตรวจสอบพ็อด และหากพ็อดมีปัญหาและหยุดทำงาน ระบบจะสร้างพ็อดใหม่ทันที มาทดสอบและดูวิธีการทำงานกัน

ก่อนอื่น ให้รับรายการพ็อดโดยใช้คำสั่งต่อไปนี้

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

ลบพ็อดโดยส่งชื่อพ็อด

kubectl delete pod hello-dotnet-714049816-g4azy

หากดูรายการพ็อดอีกครั้ง คุณจะเห็นว่าระบบกำลังสร้างพ็อดใหม่และเรียกใช้พ็อดนั้นอีกครั้งทันที

kubectl get pods

NAME                         READY     STATUS           RESTARTS   AGE
hello-dotnet-714049816-abczy   1/1    ContainerCreating  0          1m
hello-dotnet-714049816-rk0u6   1/1    Running            0          1m

11. เปิดตัวการอัปเกรดบริการ

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

ก่อนอื่น มาแก้ไขแอปพลิเคชันกัน เปิดตัวแก้ไขโค้ดจาก Cloud Shell

ไปที่ Index.cshtml ในส่วน HelloWorldAspNetCore > Views > Home แล้วอัปเดตข้อความภาพสไลด์

ค้นหาบรรทัดต่อไปนี้

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core 

และเปลี่ยนเป็น

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud

บันทึกการเปลี่ยนแปลง แล้วกลับไปที่ Cloud Shell ภายใน HelloWorldAspNetCore,สร้างอิมเมจ Docker โดยใช้คำสั่งต่อไปนี้

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 . 

และพุชไปยัง Container Registry

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 

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

ตอนนี้คุณพร้อมแล้วสำหรับ Kubernetes ที่จะอัปเดต Replication Controller เป็นแอปพลิเคชันเวอร์ชันใหม่ได้อย่างราบรื่น หากต้องการเปลี่ยนป้ายกำกับรูปภาพสำหรับคอนเทนเนอร์ที่ทำงานอยู่ คุณต้องแก้ไข hello-dotnet deployment ที่มีอยู่และเปลี่ยนรูปภาพจาก gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 เป็น gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2

โดยใช้คำสั่ง kubectl edit ซึ่งจะเปิดเครื่องมือแก้ไขข้อความที่แสดงการกำหนดค่า YAML ของการติดตั้งใช้งานแบบเต็ม คุณไม่จำเป็นต้องเข้าใจการกำหนดค่า YAML ทั้งหมดในตอนนี้ เพียงแค่เข้าใจว่าการอัปเดตฟิลด์ spec.template.spec.containers.image ในการกำหนดค่าเป็นการบอกให้การติดตั้งใช้งานอัปเดตพ็อดเพื่อใช้รูปภาพใหม่

kubectl edit deployment hello-dotnet

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2017-01-06T10:05:28Z
  generation: 3
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-dotnet
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-dotnet
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
        imagePullPolicy: IfNotPresent
        name: hello-dotnet
        ports:
        - containerPort: 8080
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}
      terminationGracePeriodSeconds: 30

หลังจากทำการเปลี่ยนแปลงแล้ว ให้บันทึกและปิดไฟล์ (ใช้ vi ดังนั้นให้กด "Esc" แล้วพิมพ์ :wq แล้วกดปุ่ม "Enter")

deployment "hello-dotnet" edited

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

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         5         4            3           1h

ในระหว่างนี้ ผู้ใช้บริการไม่ควรเห็นการหยุดชะงักใดๆ หลังจากนั้นไม่นาน ผู้ใช้จะเริ่มเข้าถึงแอปพลิเคชันเวอร์ชันใหม่

ดูรายละเอียดเพิ่มเติมเกี่ยวกับการอัปเดตแบบต่อเนื่องได้ในเอกสารประกอบของ Kubernetes

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

12. Cloud Build

ที่ผ่านมา เราสร้างคอนเทนเนอร์ด้วยคำสั่ง Docker ปกติ (docker build ...) แล้วจึงพุชอิมเมจไปยัง Container Registry ของ Google Cloud Platform ด้วยตนเอง นอกจากนี้ คุณยังเลื่อนทั้ง 2 ขั้นตอนไปที่ฝั่งเซิร์ฟเวอร์ Cloud Build ได้ด้วย ซึ่งจะสร้างและพุชอิมเมจคอนเทนเนอร์ได้โดยไม่ต้องติดตั้ง Docker ในเครื่อง

ก่อนอื่น ให้เปิดใช้ Cloud Build API ใน API Manager > Library ค้นหา Cloud Build แล้วคลิก Cloud Build API

คลิกเปิดใช้ API หากยังไม่ได้เปิดใช้ ในตอนท้าย คุณควรเห็นว่า API เปิดใช้แล้วดังนี้

เมื่อเปิดใช้ Cloud Build API แล้ว คุณจะเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างและพุชอิมเมจจากบริการ Container Builder ได้

$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3

ระบบจะจัดเก็บอิมเมจใน Container Registry โดยอัตโนมัติ

13. เรียกใช้แดชบอร์ดแบบกราฟิกของ Kubernetes

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

หากต้องการกำหนดค่าการเข้าถึงแดชบอร์ดคลัสเตอร์ Kubernetes ให้พิมพ์คำสั่งต่อไปนี้จากหน้าต่าง Cloud Shell

gcloud container clusters get-credentials hello-dotnet-cluster \
    --zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}

kubectl proxy --port 8081

จากนั้นใช้ฟีเจอร์เวอร์ชันตัวอย่างของ Cloud Shell อีกครั้งเพื่อไปยังพอร์ต 8081

ซึ่งจะนำคุณไปยังปลายทาง API คุณอาจเห็นหน้า "ไม่ได้รับอนุญาต" แต่ไม่ต้องกังวล หากต้องการไปที่แดชบอร์ด ให้นำ "?authuser=3" ออกแล้วแทนที่ด้วย "/ui"

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

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

เมื่อใช้แดชบอร์ดเสร็จแล้ว คุณสามารถกด Control + C เพื่อหยุดพร็อกซี ดูข้อมูลเพิ่มเติมเกี่ยวกับแดชบอร์ด Kubernetes ได้โดยทัวร์แดชบอร์ด

14. การบันทึก

คุณใช้คำสั่ง kubectl logs เพื่อดึงข้อมูลบันทึกของคอนเทนเนอร์ที่ทำงานภายใน Kubernetes ได้ เมื่อใช้ Google Kubernetes Engine เพื่อเรียกใช้คลัสเตอร์ Kubernetes ที่มีการจัดการ ระบบจะส่งต่อและจัดเก็บบันทึกทั้งหมดไว้ใน Google Cloud Logging โดยอัตโนมัติ คุณดูเอาต์พุตบันทึกทั้งหมดจากพ็อดได้โดยไปที่ Stackdriver → Logging → Logs ใน Google Cloud Console

เมื่ออยู่ในคอนโซลการบันทึก คุณจะไปที่คอนเทนเนอร์ GKE เพื่อดูบันทึกทั้งหมดที่รวบรวมจาก STDOUT ได้

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

15. ยินดีด้วย

จบ Codelab การเริ่มต้นใช้งาน ASP.NET Core และ Kubernetes อย่างง่ายนี้ เราเพิ่งเริ่มต้นใช้เทคโนโลยีนี้ และขอแนะนำให้คุณสำรวจเพิ่มเติมด้วยพ็อด ตัวควบคุมการจำลอง และบริการของคุณเอง รวมถึงตรวจสอบการตรวจสอบสถานะ (การตรวจสอบสุขภาพ) และพิจารณาใช้ Kubernetes API โดยตรง

ล้างข้อมูล

เท่านี้ก็เรียบร้อย ได้เวลาทำความสะอาดทรัพยากรที่ใช้ (เพื่อประหยัดค่าใช้จ่ายและเป็นพลเมืองที่ดีของระบบคลาวด์)

ลบการติดตั้งใช้งาน (ซึ่งจะลบพ็อดที่ทำงานอยู่ด้วย) และบริการ (ซึ่งจะลบตัวจัดสรรภาระงานภายนอกด้วย) โดยทำดังนี้

ก่อนอื่น ให้ลบบริการและการติดตั้งใช้งาน ซึ่งจะลบตัวจัดสรรภาระงานภายนอกด้วย โดยทำดังนี้

kubectl delete service,deployment hello-dotnet

service "hello-dotnet" deleted
deployment "hello-dotnet" deleted

จากนั้นให้ลบคลัสเตอร์โดยทำดังนี้

gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b

The following clusters will be deleted.
 - [hello-dotnet-cluster] in [europe-west1-b]
Do you want to continue (Y/n)?  Y
Deleting cluster hello-dotnet-cluster...done.                                                                                                                                                                                            
Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].

การดำเนินการนี้จะลบอินสแตนซ์ Google Compute Engine ทั้งหมดที่เรียกใช้คลัสเตอร์

สุดท้าย ให้ลบที่เก็บข้อมูลของ Docker Registry ที่โฮสต์รูปภาพของคุณ

gsutil ls

gs://artifacts.<PROJECT_ID>.appspot.com/

gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

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

สิ่งที่เราได้พูดถึง

• วิธีแพ็กเกจแอป ASP.NET Core แบบง่ายเป็นคอนเทนเนอร์ Docker
• วิธีสร้างคลัสเตอร์ Kubernetes ใน Google Kubernetes Engine
• วิธีติดตั้งใช้งานแอป ASP.NET Core ไปยังพ็อด
• วิธีอนุญาตให้การรับส่งข้อมูลภายนอกเข้าสู่พ็อด
• วิธีขยายขนาดบริการและเปิดตัวการอัปเกรด
• วิธีเรียกใช้แดชบอร์ดแบบกราฟิกของ Kubernetes

ขั้นตอนถัดไป

• ดูข้อมูลเพิ่มเติมเกี่ยวกับ Kubernetes ( http://kubernetes.io/)
• ดูข้อมูลเพิ่มเติมเกี่ยวกับ Windows ใน Google Cloud Platform
• ดูข้อมูลเพิ่มเติมเกี่ยวกับ .NET ใน Google Cloud Platform
• ดูข้อมูลเพิ่มเติมเกี่ยวกับ SQL Server ใน Google Cloud Platform
• ดูข้อมูลเพิ่มเติมเกี่ยวกับ Cloud Tools for Visual Studio
• ดูข้อมูลเพิ่มเติมเกี่ยวกับ Cloud Tools for PowerShell

ใบอนุญาต

ผลงานนี้ได้รับอนุญาตภายใต้สัญญาอนุญาตครีเอทีฟคอมมอนส์สำหรับยอมรับสิทธิของผู้สร้าง (Creative Commons Attribution License) 2.0 แบบทั่วไป