แบทเทิลวัน - สมรภูมิรบขนาดเล็ก

1. บทนำ

อัปเดตล่าสุด 26-08-2020

สนามประลอง Microservice

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

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

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

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

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

ในสนามประลองจะมีผู้เล่นทั้งหมดสำหรับการรบครั้งหนึ่งๆ การประชุม SpringOne จะมีสนามกีฬาเป็นของตนเอง ผู้เล่นแต่ละคนจะเป็น 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 อยู่ 2 แบบที่คุณเริ่มต้นได้ ดังนี้

Java และ รองเท้าบูทฤดูใบไม้ผลิ	แหล่งที่มา	ทำให้ใช้งานได้ใน Cloud Run
Kotlin และ รองเท้าบูทฤดูใบไม้ผลิ	แหล่งที่มา	ทำให้ใช้งานได้ใน Cloud Run

หลังจากตัดสินใจเลือกตัวอย่างที่จะใช้แล้ว ให้คลิก "ติดตั้งใช้งานบน 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. ขอรวมในสนามประลอง

หากต้องการอยู่ในสนามประลอง คุณต้องส่งข้อความไปยังช่อง Slack ที่ #3-sponsor-google-cloud พร้อมชื่อของคุณ, URL ของบริการ Cloud Run และชื่อผู้ใช้ GitHub สำหรับรูปโปรไฟล์ / รูปโปรไฟล์ (ไม่บังคับ) เมื่อเราตรวจสอบข้อมูลแล้ว ผู้เล่นของคุณจะปรากฏในสนามกีฬา

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=java-springboot
export SAMPLE=kotlin-springboot

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

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

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

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

หลังจากบันทึกการเปลี่ยนแปลงแล้ว ให้เริ่มต้นแอปพลิเคชันใน Cloud Shell ดังนี้

cd cloudbowl-microservice-game/samples/$SAMPLE
./mvnw spring-boot:run

เมื่อแอปพลิเคชันทำงานแล้ว ให้เปิดแท็บ 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)

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\
          --memory=512Mi\
          --allow-unauthenticated

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

6. พัฒนาในเครื่อง

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

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

cd ~/cloudbowl-microservice-game/samples; zip -r cloudbowl-sample.zip $SAMPLE

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

cloudshell download-file cloudbowl-sample.zip

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

gcloud auth login

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

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

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

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

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

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

เรียนรู้ต่อ

• ห้องทดลองโค้ด Spring อื่นๆ

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

• เอกสาร Cloud Run

8. คำถามที่พบบ่อย

ทำไม Microservice ของฉันจึงไม่ปรากฏในสนามกีฬา

การเพิ่มบ็อตตัวใหม่ลงในอารีน่าต้องดำเนินการด้วยตนเอง จึงอาจใช้เวลาถึง 15 นาที คุณตรวจสอบบริการได้ในไฟล์การกำหนดค่าการสำรองข้อมูลที่ https://github.com/cloudbowl/arenas/blob/master/springone.json