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

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

1. บทนำ

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

Microservice Rainbow Rumpus

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

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

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

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

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

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

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

เวทีที่ผ่านมามีหน้าตาดังนี้

ตัวอย่างอารีน่าการต่อสู้ 1

ความขัดแย้งที่เกิดขึ้นซ้ำๆ

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

การดูการต่อสู้

หากต้องการดูประสิทธิภาพของไมโครเซอร์วิสในการต่อสู้ โปรดไปที่เวทีการต่อสู้แบบเรียลไทม์

Battle API

หากต้องการทำงานร่วมกับผู้จัดการอารีน่า ไมโครเซอร์วิสของคุณจะต้องใช้ 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

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

3. การนำ Microservice ไปใช้งานจริง

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

เลือกตัวอย่างเพลงที่จะใช้

ตัวอย่างไมโครเซอร์วิสที่ใช้งานได้จริงมีมากมายที่คุณสามารถใช้เริ่มต้นได้ ดังนี้

Kotlin และ Spring Boot	แหล่งที่มา
Kotlin และ Micronaut	แหล่งที่มา
Kotlin และ Quarkus	แหล่งที่มา
Java และ Spring Boot	แหล่งที่มา
Java และ Quarkus	แหล่งที่มา
Go	แหล่งที่มา
Node.js และ Express	แหล่งที่มา
Python และ Flask	แหล่งที่มา

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

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

ภาพหน้าจอด้านล่างแสดงเอาต์พุต Cloud Shell สำหรับการสร้างและการนำส่งไมโครเซอร์วิส

ยืนยันว่าไมโครเซอร์วิสทํางาน

ใน Cloud Shell คุณสามารถส่งคำขอไปยังไมโครเซอร์วิสที่เพิ่งทำให้ใช้งานได้ โดยแทนที่ 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 ของไมโครเซอร์วิส

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

ตอนนี้คุณสามารถแก้ไขซอร์สโค้ดของไมโครเซอร์วิสได้จากภายใน 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] ใส่ไฟล์ตัวอย่างลงในไฟล์ ZIP โดยทำดังนี้

# 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

[ในเครื่อง] แตกไฟล์ จากนั้นทําการเปลี่ยนแปลงและทดสอบ
[ในเครื่อง] ติดตั้ง 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 เพื่อให้คุณทำงานร่วมกับทีมในไมโครเซอร์วิสได้

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

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

ทำตามวิธีการใช้ git ผ่าน https ด้วยโทเค็นการเข้าถึงส่วนบุคคล
เลือกขอบเขต "repo"
ตั้งค่า 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"

ตั้งค่าตัวแปรสภาพแวดล้อมสําหรับองค์กรและที่เก็บ 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 Desktop

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

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

เผยแพร่สาขาหลักไปยัง GitHub

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

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

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

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

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

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

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

เมตริก

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

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

บันทึก

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

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

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

สร้าง URL การตรวจสอบประสิทธิภาพสำหรับบริการ
สําหรับ 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. ขอแสดงความยินดี

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

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

เอกสาร Cloud Run