Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

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

1. บทนำ

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

Microservice Rainbow Rumpus

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

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

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

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

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

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

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

อารีน่าในอดีตมีลักษณะดังนี้

Example Battle One arena

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

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

ดูการแข่งขัน

หากต้องการดูว่าไมโครเซอร์วิสของคุณเป็นอย่างไรในการต่อสู้ โปรดดูอารีน่าสด

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

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

3. การติดตั้งใช้งาน Microservice

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

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

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

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

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

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

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

ยืนยันว่า 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 ของไมโครเซอร์วิส

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

[ในเครื่องของคุณ] แตกไฟล์ แล้วทำการเปลี่ยนแปลงและทดสอบ
[ในเครื่องของคุณ] ติดตั้ง 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
สร้างที่เก็บใหม่
หากทำงานในเครื่องของคุณ คุณจะใช้ได้ทั้งอินเทอร์เฟซบรรทัดคำสั่ง (CLI) ของ Git หรือแอปพลิเคชัน GUI ของ GitHub Desktop (Windows หรือ Mac) หากใช้ Cloud Shell คุณจะต้องใช้ git CLI หากต้องการรับโค้ดของ Microservice ใน 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 แล้ว คุณจะตั้งค่าการส่งมอบอย่างต่อเนื่องได้เพื่อให้ทุกครั้งที่มีการพุชคอมมิตใหม่ไปยัง Branch main Cloud Build จะสร้างและทำให้การเปลี่ยนแปลงใช้งานได้โดยอัตโนมัติ นอกจากนี้ คุณยังเพิ่มการรวมอย่างต่อเนื่องซึ่งจะเรียกใช้การทดสอบก่อนการทำให้ใช้งานได้ด้วย แต่เราจะเว้นขั้นตอนนี้ไว้ให้คุณทำเองเนื่องจากตัวอย่างที่พร้อมใช้งานไม่มีการทดสอบใดๆ

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

เลือกที่เก็บ GitHub แล้วตั้งค่า Branch เป็น ^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. ขอแสดงความยินดี

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

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

เอกสารประกอบของ Cloud Run