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

จุกสีรุ้งแบบ Microservice

1. บทนำ

อัปเดตล่าสุด 06-05-2021

Microservice Rainbow Rumpus

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

คุณอาจสงสัยว่า... แต่ Microservice สายรุ้งที่ Microservice อื่นๆ Microservice สามารถรับคำขอของเครือข่าย (โดยปกติจะส่งผ่าน HTTP) และแสดงผลการตอบกลับ มี "ผู้จัดการสถานที่" ซึ่งจะส่ง Microservice สถานะปัจจุบันของสนาม จากนั้น Microservice จะตอบสนองด้วยคำสั่งที่ระบุสิ่งที่ต้องทำ

แน่นอนว่าเป้าหมายคือการเอาชนะ แต่ระหว่างที่ดำเนินการ คุณจะได้เรียนรู้เกี่ยวกับการสร้างและทำให้ Microservice ใช้งานได้บน Google Cloud

วิธีการทำงาน

คุณจะสร้าง Microservice ด้วยเทคโนโลยีที่ต้องการ (หรือเลือกจากเงื่อนไขเริ่มต้น Go, Java, Kotlin, Scala, NodeJS หรือ Python) จากนั้นติดตั้งใช้งาน Microservice บน Google Cloud เมื่อติดตั้งใช้งานแล้ว โปรดแจ้ง URL สำหรับ Microservice ให้เราทราบ จากนั้นเราจะเพิ่มลงในสนามประลอง

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

ประมาณ 1 วินาที ผู้จัดการสนามของเราจะโทรหา Microservice เพื่อแจ้งสถานะสนามปัจจุบัน (ที่ผู้เล่นอยู่) และ Microservice จะตอบด้วยคำสั่งว่าต้องทำอะไรบ้าง ในสนามประลอง คุณสามารถเดินหน้า เลี้ยวซ้าย หรือขวา หรือโยนสายรุ้ง สายรุ้งจะเดินทางไปยังพื้นที่ 3 ช่องในทิศทางที่ผู้เล่นหันหน้าไป ถ้าเกิด "Hit" สีรุ้ง ผู้เล่นอีกคน ผู้ขว้างจะได้ 1 แต้ม และผู้เล่นที่โดนระเบิดจะได้ 1 คะแนน ขนาดสนามจะปรับขนาดโดยอัตโนมัติตามจำนวนผู้เล่นปัจจุบัน

สนามแข่งที่ผ่านมามีลักษณะดังต่อไปนี้

ตัวอย่างสนามแบทเทิลวัน

ความขัดแย้งที่เกี่ยวข้อง

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

การดูการสู้รบ

หากต้องการดูประสิทธิภาพ Microservice ของคุณในการสู้รบ โปรดดูในสนามประลอง

Battle API

Microservice จะต้องใช้ API ที่เฉพาะเจาะจงเพื่อเข้าร่วมในสนามเพื่อทำงานร่วมกับผู้จัดการสนามของเรา ผู้จัดการสนามจะส่งสถานะสนามปัจจุบันใน HTTP POST ไปยัง URL ที่คุณให้ไว้กับเราโดยมีโครงสร้าง JSON ต่อไปนี้

{
  "_links": {
    "self": {
      "href": "https://YOUR_SERVICE_URL"
    }
  },
  "arena": {
    "dims": [4,3], // width, height
    "state": {
      "https://A_PLAYERS_URL": {
        "x": 0, // zero-based x position, where 0 = left
        "y": 0, // zero-based y position, where 0 = top
        "direction": "N", // N = North, W = West, S = South, E = East
        "wasHit": false,
        "score": 0
      }
      ... // also you and the other players
    }
  }
}

การตอบกลับ HTTP ต้องเป็นรหัสสถานะ 200 (OK) โดยมีเนื้อหาการตอบกลับที่มีการย้ายครั้งถัดไป โดยเข้ารหัสเป็นอักขระตัวพิมพ์ใหญ่ตัวเดียวของตัวเลือกต่อไปนี้

F <- move Forward
R <- turn Right
L <- turn Left
T <- Throw

เท่านี้ก็เรียบร้อย ลองมาดูรายละเอียดการทำให้ Microservice ใช้งานได้บน Cloud Run ซึ่งเป็นบริการ Google Cloud สำหรับการเรียกใช้ Microservice และแอปพลิเคชันอื่นๆ

2. เข้าสู่ระบบ Google Cloud

คุณต้องเข้าสู่ระบบ Google Cloud เพื่อทำให้ Microservice ใช้งานได้บน Cloud Run เราจะให้เครดิตแก่บัญชีของคุณและคุณไม่จำเป็นต้องป้อนบัตรเครดิต การใช้บัญชีส่วนตัว (เช่น gmail.com) แทนบัญชี G Suite มักจะไม่ยุ่งยากนัก เนื่องจากบางครั้งผู้ดูแลระบบ G Suite อาจป้องกันไม่ให้ผู้ใช้ใช้ฟีเจอร์บางอย่างของ Google Cloud นอกจากนี้ เว็บคอนโซลที่เราจะใช้ควรจะทำงานได้ดีกับ Chrome หรือ Firefox แต่อาจมีปัญหาใน Safari

3. การทำให้ Microservice ใช้งานได้

คุณสามารถสร้าง Microservice ด้วยเทคโนโลยีใดก็ได้ และทำให้ใช้งานได้ที่ใดก็ได้ ตราบใดที่เข้าถึงได้แบบสาธารณะและสอดคล้องกับ Battle API แต่เพื่อทำให้ทุกอย่างง่ายขึ้น เราจะช่วยคุณเริ่มต้นจากบริการตัวอย่างและทำให้ใช้งานได้ใน Cloud Run

เลือกตัวอย่างของคุณเพื่อเริ่มต้น

คุณสามารถเริ่มตัวอย่าง Battle Microservice ได้อีกมากมาย ดังนี้

Kotlin และ รองเท้าบูทฤดูใบไม้ผลิ	แหล่งที่มา
Kotlin และ Micronaut	แหล่งที่มา
Kotlin และ ควาร์คุส	แหล่งที่มา
Java และ รองเท้าบูทฤดูใบไม้ผลิ	แหล่งที่มา
Java และ ควาร์คุส	แหล่งที่มา
Go	แหล่งที่มา
Node.js และ รถไฟด่วน	แหล่งที่มา
Python และ ฟลาสก์	แหล่งที่มา

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

เมื่อระบบขอ ให้ระบุภูมิภาค us-central1

ภาพหน้าจอด้านล่างแสดงเอาต์พุต Cloud Shell สำหรับบิลด์และการทำให้ใช้งานได้ของ Microservice

ยืนยันว่า Microservice ใช้งานได้

ใน Cloud Shell คุณจะส่งคำขอไปยัง Microservice ที่ทำให้ใช้งานได้ใหม่โดยแทนที่ YOUR_SERVICE_URL ด้วย URL สำหรับบริการ (ซึ่งอยู่ใน Cloud Shell หลังจากบรรทัด "แอปพลิเคชันของคุณพร้อมใช้งานแล้ว") ดังนี้

curl -d '{
  "_links": {
    "self": {
      "href": "https://foo.com"
    }
  },
  "arena": {
    "dims": [4,3],
    "state": {
      "https://foo.com": {
        "x": 0,
        "y": 0,
        "direction": "N",
        "wasHit": false,
        "score": 0
      }
    }
  }
}' -H "Content-Type: application/json" -X POST -w "\n" \
  https://YOUR_SERVICE_URL

คุณควรเห็นสตริงการตอบกลับเป็น F, L, R หรือ T

4. ขอรวมในสนามประลอง

คุณต้องเข้าร่วมอารีน่าก่อนจึงจะเข้าร่วม Rainbow Rumpus ได้ เปิด rainbowrumpus.dev คลิก "เข้าร่วม" ในสนามที่คุณจะใส่ URL ของ Microservice

5. ทำ & นำการเปลี่ยนแปลงไปใช้

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

gcloud projects list

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

export PROJECT_ID=YOUR_PROJECT_ID

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

# Copy and paste ONLY ONE of these
export SAMPLE=kotlin-micronaut
export SAMPLE=kotlin-quarkus
export SAMPLE=kotlin-springboot
export SAMPLE=java-quarkus
export SAMPLE=java-springboot
export SAMPLE=go
export SAMPLE=nodejs
export SAMPLE=python

ขณะนี้คุณแก้ไขต้นทางสำหรับ Microservice จากภายใน Cloud Shell ได้ หากต้องการเปิดเครื่องมือแก้ไขบนเว็บของ Cloud Shell ให้เรียกใช้คำสั่งนี้

cloudshell edit cloudbowl-microservice-game/samples/$SAMPLE/README.md

จากนั้นคุณจะเห็นคำแนะนำเพิ่มเติมสำหรับการเปลี่ยนแปลง

Cloud Shell ที่มีตัวแก้ไขพร้อมโปรเจ็กต์ตัวอย่างเปิดอยู่

หลังจากบันทึกการเปลี่ยนแปลงแล้ว ให้เริ่มต้นแอปพลิเคชันใน Cloud Shell โดยใช้คำสั่งจากไฟล์ README.md แต่ก่อนอื่นให้ตรวจสอบว่าคุณได้อยู่ในไดเรกทอรีตัวอย่างที่ถูกต้องใน Cloud Shell แล้ว

cd cloudbowl-microservice-game/samples/$SAMPLE

เมื่อแอปพลิเคชันทำงานแล้ว ให้เปิดแท็บ Cloud Shell ใหม่และทดสอบบริการโดยใช้ curl ดังนี้

curl -d '{
  "_links": {
    "self": {
      "href": "https://foo.com"
    }
  },
  "arena": {
    "dims": [4,3],
    "state": {
      "https://foo.com": {
        "x": 0,
        "y": 0,
        "direction": "N",
        "wasHit": false,
        "score": 0
      }
    }
  }
}' -H "Content-Type: application/json" -X POST -w "\n" \
  http://localhost:8080

เมื่อพร้อมที่จะทำให้การเปลี่ยนแปลงใช้งานได้แล้ว ให้สร้างโปรเจ็กต์ใน Cloud Shell โดยใช้คำสั่ง pack คำสั่งนี้ใช้ Buildpack เพื่อตรวจหาประเภทโปรเจ็กต์ คอมไพล์ และสร้างอาร์ติแฟกต์ที่ทำให้ใช้งานได้ (อิมเมจคอนเทนเนอร์ Docker)

# Make sure you are in a Cloud Shell tab where you set the PROJECT_ID
# and SAMPLE env vars. Otherwise, set them again.
pack build gcr.io/$PROJECT_ID/$SAMPLE \
  --path ~/cloudbowl-microservice-game/samples/$SAMPLE \
  --builder gcr.io/buildpacks/builder

เมื่อสร้างอิมเมจคอนเทนเนอร์แล้ว ให้ใช้คำสั่ง Docker (ใน Cloud Shell) เพื่อพุชอิมเมจคอนเทนเนอร์ไปยัง Google Container Registry เพื่อให้ Cloud Run เข้าถึงอิมเมจดังกล่าวได้

docker push gcr.io/$PROJECT_ID/$SAMPLE

ทำให้เวอร์ชันใหม่ใช้งานได้ใน Cloud Run ด้วยคำสั่งต่อไปนี้

gcloud run deploy $SAMPLE \
          --project=$PROJECT_ID \
          --platform=managed \
          --region=us-central1 \
          --image=gcr.io/$PROJECT_ID/$SAMPLE \
          --allow-unauthenticated

ตอนนี้สนามประลองจะใช้เวอร์ชันใหม่ของคุณแล้ว!

6. พัฒนาในเครื่อง (ไม่บังคับ)

คุณสามารถทำงานในโปรเจ็กต์ภายในเครื่องโดยใช้ IDE ของคุณเอง โดยทำตามขั้นตอนต่อไปนี้

[ใน Cloud Shell] ซิปตัวอย่าง:

# Make sure the SAMPLE env var is still set. If not, re-set it.
cd ~/cloudbowl-microservice-game/samples
zip -r cloudbowl-sample.zip $SAMPLE

[ใน Cloud Shell] ดาวน์โหลดไฟล์ ZIP ลงในเครื่องของคุณดังนี้

cloudshell download-file cloudbowl-sample.zip

[บนเครื่องของคุณ] แตกไฟล์ ZIP จากนั้นสร้าง & ทดสอบการเปลี่ยนแปลง
[ในเครื่องของคุณ] ติดตั้ง gcloud CLI
[ในเครื่องของคุณ] เข้าสู่ระบบ Google Cloud

gcloud auth login

[ในเครื่องของคุณ] ตั้งค่าตัวแปรสภาพแวดล้อม PROJECT_ID และ SAMPLE เป็นค่าเดียวกับใน Cloud Shell
[ในเครื่องของคุณ] ใช้ Cloud Build เพื่อสร้างคอนเทนเนอร์ (จากไดเรกทอรีโปรเจ็กต์รูท) ดังนี้

gcloud alpha builds submit . \
  --pack=image=gcr.io/$PROJECT_ID/$SAMPLE \
  --project=$PROJECT_ID

[ในเครื่องของคุณ] ทำให้คอนเทนเนอร์ใหม่ใช้งานได้:

gcloud run deploy $SAMPLE \
  --project=$PROJECT_ID \
  --platform=managed \
  --region=us-central1 \
  --image=gcr.io/$PROJECT_ID/$SAMPLE \
  --allow-unauthenticated

7. การส่งมอบอย่างต่อเนื่อง

ตั้งค่า SCM

ตั้งค่า GitHub เพื่อให้คุณทำงานร่วมกับทีมใน Microservice ได้

เข้าสู่ระบบ GitHub
สร้างที่เก็บใหม่
หากกำลังทำงานในเครื่องของคุณ คุณสามารถใช้อินเทอร์เฟซบรรทัดคำสั่ง git (CLI) หรือแอปพลิเคชัน GitHub Desktop GUI (Windows หรือ Mac) หากใช้ Cloud Shell คุณจะต้องใช้ git CLI หากต้องการรับโค้ดของ Microservice บน GitHub ให้ทำตามวิธีการ CLI หรือ GitHub Desktop

พุชโค้ดด้วย git CLI

ทำตาม git-over https พร้อมวิธีการสำหรับโทเค็นเพื่อการเข้าถึงส่วนบุคคล
เลือก "ที่เก็บ" ขอบเขต
ตั้งค่า Git:

git config --global credential.helper \
  'cache --timeout=172800'
git config --global push.default current
git config --global user.email "YOUR@EMAIL"
git config --global user.name "YOUR NAME"

ตั้งค่าตัวแปร env สำหรับองค์กรและที่เก็บ GitHub (https://github.com/ORG/REPO)

export GITHUB_ORG=YOUR_GITHUB_ORG
export GITHUB_REPO=YOUR_GITHUB_REPO

พุชโค้ดไปยังที่เก็บใหม่

# Make sure the SAMPLE env var is still set. If not, re-set it.
cd ~/cloudbowl-microservice-game/samples/$SAMPLE
git init
git add .
git commit -m init
git remote add origin https://github.com/$GITHUB_ORG/$GITHUB_REPO.git
git branch -M main

# This will now ask for your GitHub username & password
# for the password use the personal access token
git push -u origin main

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

git add .
git status
git diff --staged
git commit -am "my changes"
git push

พุชโค้ดด้วย GitHub สำหรับเดสก์ท็อป

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

เปิด File Explorer และคัดลอกโปรเจ็กต์ไปยังที่เก็บใหม่
ใช้การเปลี่ยนแปลง

เผยแพร่ Branch หลักไปยัง GitHub

ตั้งค่าการทำให้ใช้งานได้อย่างต่อเนื่องของ Cloud Run

เมื่อตั้งค่า SCM บน GitHub แล้ว คุณสามารถตั้งค่าการนำส่งอย่างต่อเนื่องได้เพื่อให้ทุกครั้งที่มีการพุชคอมมิตใหม่ไปยัง Branch ของ main Cloud Build จะสร้างการเปลี่ยนแปลงและทำให้การเปลี่ยนแปลงใช้งานได้โดยอัตโนมัติ นอกจากนี้ คุณยังเพิ่มการผสานรวมแบบต่อเนื่องซึ่งจะทำการทดสอบก่อนนำไปใช้งานได้ด้วย แต่ขั้นตอนนี้จะไว้เป็นแบบฝึกหัดสำหรับคุณเนื่องจากตัวอย่างพร้อมใช้งานไม่มีการทดสอบใดๆ

ไปที่บริการ Cloud Run ในคอนโซล Cloud
คลิก "ตั้งค่าการทำให้ใช้งานได้ของบริบท" ปุ่ม
ตรวจสอบสิทธิ์ด้วย GitHub และเลือกที่เก็บของ Microserivce

เลือกที่เก็บ GitHub และตั้งค่า Branch เป็น ^main$

ตั้งค่าประเภทบิลด์เพื่อใช้ Buildpack
คลิก "บันทึก" เพื่อตั้งค่าการทำให้ใช้งานได้อย่างต่อเนื่อง

8. ความสามารถในการสังเกต

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

เมตริก

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

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

บันทึก

ระบบจะส่งเอาต์พุต STDOUT จากบริการไปยังระบบ Google Cloud Logging คุณจะเข้าถึงมุมมองบันทึกพื้นฐานได้จากหน้าผู้ดูแลระบบบริการ Cloud Run เช่น

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

การแจ้งเตือน

สร้าง URL ของ Heathcheck สำหรับบริการของคุณ
สำหรับ Spring Boot ให้เพิ่มทรัพยากร Dependency ต่อไปนี้

org.springframework.boot:spring-boot-starter-actuator

สร้างหรืออัปเดต src/main/resources/application.properties และปิดใช้การตรวจสอบพื้นที่ดิสก์ ดังนี้

management.health.diskspace.enabled=false

สร้างการแจ้งเตือนระยะเวลาทำงาน โดยระบุโปรโตคอล ชื่อโฮสต์ และเส้นทาง สำหรับ Spring Boot คือ /actuator/health
ทดสอบการแจ้งเตือน

สร้างการแจ้งเตือน

9. ขอแสดงความยินดี

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

เอกสารอ้างอิง

เอกสาร Cloud Run