แบทเทิลพีช - สมรภูมิ Microservice

1. บทนำ

อัปเดตล่าสุด 12-02-2020

สนามประลอง Microservice

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

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

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

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

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

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

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

สนามแข่งมีผู้เล่น 3 คนที่ด้วยกันเป็นดังนี้

9e4775d13ff18d4d.png

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

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

ในสนามประลอง อาจมีผู้เล่นหลายคนพยายามทำสิ่งที่ขัดแย้งกัน เช่น มีผู้เล่น 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. การทำให้ Microservice ใช้งานได้

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

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

มีตัวอย่าง Battle Microservice อยู่ 3 แบบที่คุณเริ่มต้นได้ ดังนี้

Java และ รองเท้าบูทฤดูใบไม้ผลิ

แหล่งที่มา

ทำให้ใช้งานได้ใน Cloud Run

Java และ ควาร์คุส

แหล่งที่มา

ทำให้ใช้งานได้ใน Cloud Run

Kotlin และ Micronaut

แหล่งที่มา

ทำให้ใช้งานได้ใน Cloud Run

Kotlin และ ควาร์คุส

แหล่งที่มา

ทำให้ใช้งานได้ใน Cloud Run

สกาลาและ เฟรมเวิร์ก Play

แหล่งที่มา

ทำให้ใช้งานได้ใน Cloud Run

Go

แหล่งที่มา

ทำให้ใช้งานได้ใน Cloud Run

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

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

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

d88e40430706a32b.png

ยืนยันว่า 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

ขอรวมอยู่ในสนามประลอง

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

สร้างและ นำการเปลี่ยนแปลงไปใช้

ก่อนที่จะทำการเปลี่ยนแปลง คุณต้องตั้งค่าข้อมูลบางอย่างใน 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=java-springboot
export SAMPLE=kotlin-micronaut
export SAMPLE=scala-play

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

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

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

f910c9ef7b51c406.png

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

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

pack build gcr.io/$PROJECT_ID/$SAMPLE \
  --path cloudbowl-microservice-game/samples/$SAMPLE \
  --builder heroku/buildpacks

เมื่อสร้างอิมเมจคอนเทนเนอร์แล้ว ให้ใช้คำสั่ง 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\
          --memory=512Mi\
          --allow-unauthenticated

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

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

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

สิ่งที่ต้องทำต่อไป

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