เกี่ยวกับ Codelab นี้
1 บทนำ
ทำไมการจัดการแอปพลิเคชันจึงเป็นเรื่องยาก
เหตุผลหลักอย่างหนึ่งก็คือนักพัฒนาซอฟต์แวร์มักจะต้องเป็นผู้ดูแลระบบแบบไม่พาร์ทไทม์ ลองพิจารณาข้อกังวลนี้ (บางส่วน) เพื่อพัฒนา ทำให้ใช้งานได้ และจัดการเว็บแอปพลิเคชันระดับการผลิตที่ทันสมัย :
ฉันไม่ทราบเกี่ยวกับคุณเลย แต่ไม่ต้องกังวลไป สิ่งที่ฉันต้องการจริงๆ คือตรรกะของแอปพลิเคชัน
กล่าวโดยสรุปคือ Cloud Run ทำให้คุณโฟกัสที่แอปได้ และปล่อยให้การดูแลระบบและการบำรุงรักษาทั้งหมดทำงานให้กับคนอื่น ซึ่งก็คือ Google ที่ใช้เวลาหลายล้านชั่วโมงเพื่อปรับปรุงและทำให้ทักษะของตนเองในโดเมนนี้สมบูรณ์แบบ
นอกจากอุปสรรคด้านการดูแลระบบที่กล่าวถึงข้างต้นแล้ว คุณยังต้องจัดการกับสิ่งต่อไปนี้ด้วย
- การขึ้นต่อกัน - สภาพแวดล้อมที่แอปทำงานควรสอดคล้องกับสภาพแวดล้อมที่ทดสอบทุกประการ (เมื่อเป็นไปได้) ซึ่งครอบคลุมมิติข้อมูลที่หลากหลาย ซึ่งรวมถึงระบบปฏิบัติการ ไลบรารีการสนับสนุน อินเทอร์พรีเตอร์หรือคอมไพเลอร์ภาษา การกำหนดค่าฮาร์ดแวร์ และปัจจัยอื่นๆ อีกมากมาย
- การเผยแพร่ - การย้ายจากการเกิดแอปในท้องถิ่นไปยังแอปที่แชร์ในวงกว้างบนอินเทอร์เน็ตมักจะต้องมีการเปลี่ยนแปลงสภาพแวดล้อมรันไทม์ ความซับซ้อนในการก้าวกระโดดแบบควอนตัม และทำให้ต้องเรียนรู้มากขึ้นเรื่อยๆ
Cloud Run ดูแลข้อกังวลเหล่านี้และข้อกังวลอื่นๆ อีกมากมายให้คุณ แทนที่จะพูดตามตรง เรามาสร้างแอปไปด้วยกันและดูว่าการเปลี่ยนจากสภาพแวดล้อมการพัฒนาในท้องถิ่นไปใช้แอประบบคลาวด์ระดับเวอร์ชันที่ใช้งานจริงได้ง่ายๆ ในไม่กี่ขั้นตอนได้อย่างไร
สิ่งที่จะต้องทำ...
- คุณจะสร้างเว็บแอปแบบง่ายและยืนยันว่าแอปดังกล่าวทำงานตามที่ต้องการในสภาพแวดล้อมการพัฒนาของคุณ
- จากนั้นจึงย้ายไปยังเวอร์ชันที่มีคอนเทนเนอร์ของแอปเดียวกัน ระหว่างนี้คุณจะได้สำรวจความหมายของการสร้างคอนเทนเนอร์และเหตุผลที่ทำให้คอนเทนเนอร์นี้มีประโยชน์
- ขั้นตอนสุดท้าย คุณจะทำให้แอปใช้งานได้ในระบบคลาวด์ แล้วคุณจะเห็นว่าการจัดการบริการ Cloud Run นั้นทำได้ง่ายเพียงใดโดยใช้บรรทัดคำสั่งและ Google Cloud Console
สิ่งที่คุณจะได้เรียนรู้...
- วิธีสร้างแอปเว็บเซิร์ฟเวอร์แบบง่ายใน Python
- วิธีจัดแพ็กเกจแอปลงในคอนเทนเนอร์ Docker ที่ทำงานได้ทุกที่
- วิธีทำให้แอปใช้งานได้กับระบบคลาวด์เพื่อให้ทุกคนได้ลองใช้ผลงานใหม่ของคุณ
- วิธีทำให้ขั้นตอนข้างต้นง่ายขึ้นไปอีกโดยใช้ Buildpack
- วิธีใช้เครื่องมือบรรทัดคำสั่ง Google Cloud และ UI ทางเว็บของ Cloud Console
สิ่งที่คุณต้องมี...
- เว็บเบราว์เซอร์
- บัญชี Google
ห้องทดลองนี้มุ่งเป้าไปที่นักพัฒนาซอฟต์แวร์ทุกระดับ รวมถึงผู้เริ่มต้น แม้ว่าคุณจะใช้ Python แต่คุณไม่จำเป็นต้องคุ้นเคยกับการเขียนโปรแกรม Python เพื่อที่จะเข้าใจว่าเกิดอะไรขึ้น เนื่องจากเราจะอธิบายโค้ดทั้งหมดที่คุณใช้
2 เตรียมตัว
ส่วนนี้จะครอบคลุมทุกสิ่งที่คุณต้องทำเพื่อเริ่มต้นใช้งานห้องทดลองนี้
การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก
- ลงชื่อเข้าใช้ Cloud Console และสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ (หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี)
โปรดจดจำรหัสโปรเจ็กต์ ซึ่งเป็นชื่อที่ไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมด (ชื่อด้านบนมีคนใช้แล้ว และจะใช้ไม่ได้ ขออภัย) และจะมีการอ้างอิงใน Codelab ว่า PROJECT_ID
ในภายหลัง
- ถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร Google Cloud
การใช้งาน Codelab นี้น่าจะไม่มีค่าใช้จ่ายใดๆ หากมี ตรวจสอบว่าคุณได้ทำตามวิธีการใน "การล้างข้อมูล" ซึ่งจะแนะนำคุณเกี่ยวกับวิธีปิดทรัพยากรเพื่อไม่ให้มีการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ ผู้ใช้ใหม่ของ Google Cloud จะมีสิทธิ์เข้าร่วมโปรแกรมทดลองใช้ฟรี$300 USD
เริ่มต้น Cloud Shell
ในห้องทดลองนี้ คุณจะได้ทำงานในเซสชัน Cloud Shell ซึ่งเป็นล่ามคำสั่งที่เครื่องเสมือนทำงานในระบบคลาวด์ของ Google คุณสามารถเรียกใช้ส่วนนี้ในคอมพิวเตอร์ของคุณเองได้ง่ายๆ แต่การใช้ Cloud Shell จะทำให้ทุกคนเข้าถึงประสบการณ์ที่ทำซ้ำได้ในสภาพแวดล้อมที่สอดคล้องกัน หลังจากการทดลองแล้ว คุณสามารถลองดำเนินการในส่วนนี้อีกครั้งในคอมพิวเตอร์ของคุณเอง
เปิดใช้งาน Cloud Shell
- คลิกเปิดใช้งาน Cloud Shell
จาก Cloud Console
หากคุณไม่เคยเริ่มต้นใช้งาน Cloud Shell มาก่อน คุณจะเห็นหน้าจอตรงกลาง (ครึ่งหน้าล่าง) ซึ่งอธิบายว่านี่คืออะไร หากเป็นเช่นนั้น ให้คลิกดำเนินการต่อ (คุณจะไม่เห็นการดำเนินการนี้อีก) หน้าจอแบบครั้งเดียวมีลักษณะดังนี้
การจัดสรรและเชื่อมต่อกับ Cloud Shell ใช้เวลาเพียงไม่กี่นาที
เครื่องเสมือนนี้เต็มไปด้วยเครื่องมือการพัฒนาทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักขนาด 5 GB ที่ทำงานอย่างต่อเนื่องใน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพของเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก งานส่วนใหญ่ใน Codelab นี้สามารถทำได้โดยใช้เบราว์เซอร์หรือ Chromebook เท่านั้น
เมื่อเชื่อมต่อกับ Cloud Shell คุณควรเห็นว่าได้รับการตรวจสอบแล้ว และโปรเจ็กต์ได้รับการตั้งค่าเป็นรหัสโปรเจ็กต์แล้ว
- เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว
gcloud auth list
เอาต์พุตจากคำสั่ง
Credentialed Accounts ACTIVE ACCOUNT * <my_account>@<my_domain.com> To set the active account, run: $ gcloud config set account `ACCOUNT`
- เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้เกี่ยวกับโปรเจ็กต์ของคุณ
gcloud config list project
เอาต์พุตจากคำสั่ง
[core] project = <PROJECT_ID>
หากไม่ใช่ ให้ตั้งคำสั่งด้วยคำสั่งนี้
gcloud config set project <PROJECT_ID>
เอาต์พุตจากคำสั่ง
Updated property [core/project].
ตั้งค่าตัวแปรสภาพแวดล้อมบางอย่างในเทอร์มินัลซึ่งจะช่วยให้การทำงานง่ายขึ้นในขั้นตอนถัดไป
export PROJ=$GOOGLE_CLOUD_PROJECT export APP=hello export PORT=8080 export REGION="us-central1" export TAG="gcr.io/$PROJ/$APP"
เปิดใช้ API
ในขั้นตอนหลังจากนี้ คุณจะเห็นว่าต้องใช้บริการเหล่านี้ (และเหตุผล) ที่ใดบ้าง แต่ตอนนี้ให้เรียกใช้คำสั่งนี้เพื่อให้สิทธิ์เข้าถึงบริการ Cloud Build, Container Registry และ Cloud Run แก่โปรเจ็กต์
gcloud services enable cloudbuild.googleapis.com \ containerregistry.googleapis.com \ run.googleapis.com
ซึ่งจะสร้างข้อความที่ประสบความสำเร็จในลักษณะเดียวกับข้อความต่อไปนี้
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
3 สร้างเว็บแอปแบบง่าย
เริ่มต้นโดยคลิกปุ่ม Open Editor
ที่ด้านบนของแผง Cloud Shell ซึ่งมีลักษณะดังนี้
จากนั้นคุณจะอยู่ในสภาพแวดล้อม IDE ที่คล้ายกับโค้ด Visual Studio ซึ่งคุณสามารถสร้างโปรเจ็กต์ แก้ไขซอร์สโค้ด เรียกใช้โปรแกรม ฯลฯ หากหน้าจอแคบเกินไป คุณสามารถขยายหรือย่อเส้นแบ่งระหว่างคอนโซลกับหน้าต่างแก้ไข/เทอร์มินัลด้วยการลากแถบแนวนอนระหว่าง 2 พื้นที่ที่ไฮไลต์ไว้ที่นี่
คุณสลับไปมาระหว่างเครื่องมือแก้ไขและเทอร์มินัลได้โดยคลิกปุ่ม Open Editor
และ Open Terminal
ตามลำดับ ลองสลับไปมาระหว่างสภาพแวดล้อมทั้งสองตอนนี้เลย
จากนั้น สร้างโฟลเดอร์ที่ใช้เก็บงานสำหรับห้องทดลองนี้ โดยเลือก ไฟล์ ->โฟลเดอร์ใหม่ ป้อน hello
และคลิก OK
ไฟล์ทั้งหมดที่คุณสร้างในห้องทดลองนี้และงานทั้งหมดที่คุณทำใน Cloud Shell จะอยู่ในโฟลเดอร์นี้
จากนั้นสร้างไฟล์ requirements.txt
การดำเนินการนี้จะแจ้งให้ Python ทราบว่าแอปของคุณต้องใช้ไลบรารีใด สำหรับเว็บแอปแบบง่ายนี้ คุณจะใช้โมดูล Python ที่ได้รับความนิยมในการสร้างเว็บเซิร์ฟเวอร์ชื่อ Flask
และเฟรมเวิร์กเว็บเซิร์ฟเวอร์ชื่อ gunicorn
ในหน้าต่าง Cloud Editor ให้คลิกเมนู ไฟล์->ไฟล์ใหม่ เพื่อสร้างไฟล์ใหม่ เมื่อระบบแจ้งให้ระบุชื่อไฟล์ใหม่ ให้ป้อน requirements.txt
แล้วกดปุ่ม OK
ตรวจสอบว่าไฟล์ใหม่อยู่ในโฟลเดอร์โปรเจ็กต์ hello
ป้อนบรรทัดต่อไปนี้ในไฟล์ใหม่เพื่อระบุว่าแอปของคุณต้องใช้แพ็กเกจ Flask ของ Python และเว็บเซิร์ฟเวอร์ gunicorn
Flask gunicorn
คุณไม่จำเป็นต้องบันทึกไฟล์นี้อย่างชัดแจ้ง เนื่องจาก Cloud Editor จะบันทึกการเปลี่ยนแปลงให้คุณโดยอัตโนมัติ
รูปแบบ 1: สวัสดีทุกคน!
ใช้เทคนิคเดียวกันเพื่อสร้างไฟล์ใหม่อีกไฟล์ชื่อ main.py
ไฟล์นี้จะเป็นไฟล์ต้นฉบับ Python หลัก (เท่านั้น) ของแอป โปรดตรวจสอบว่าไฟล์ใหม่อยู่ในโฟลเดอร์โปรเจ็กต์ hello
แทรกรหัสต่อไปนี้ลงในไฟล์นี้:
from flask import Flask
import os
import random
app = Flask(__name__) # Create a Flask object.
PORT = os.environ.get("PORT") # Get PORT setting from the environment.
# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
@app.route("/", methods=["GET"])
def say_hello():
html = "<h1>Hello world!</h1>"
return html
# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
app.run(host="0.0.0.0", port=PORT)
สลับกลับไปที่เทอร์มินัลและเปลี่ยนไปยังโฟลเดอร์โปรเจ็กต์ด้วยคำสั่งนี้
cd hello
เรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้งทรัพยากร Dependency ของโปรเจ็กต์
pip3 install -r requirements.txt
คราวนี้ให้เปิดแอปของคุณโดยเรียกใช้คำสั่งนี้ในเทอร์มินัล
python3 main.py
ในขณะนี้แอปกำลังทำงานบนเครื่องเสมือนสำหรับเซสชัน Cloud Shell โดยเฉพาะ Cloud Shell มีกลไกพร็อกซีที่ช่วยให้คุณเข้าถึงเว็บเซิร์ฟเวอร์ (เช่น เซิร์ฟเวอร์ที่คุณเพิ่งเริ่มต้น) ที่ทำงานบนเครื่องเสมือนได้จากทุกที่บนอินเทอร์เน็ตทั่วโลก
คลิกปุ่ม web preview
จากนั้นคลิกรายการในเมนู Preview on Port 8080
แบบนี้
วิธีนี้จะเปิดแท็บเว็บเบราว์เซอร์ไปยังแอปที่ทำงานอยู่ ซึ่งควรมีลักษณะดังนี้
แบบ 2: การสะท้อนเส้นทาง URL
กลับไปที่ Cloud Editor (ผ่านปุ่ม Open Editor
) และเพิ่มการรองรับการพูดค่าต่อท้าย URL ที่ไม่บังคับด้วยการอัปเดตไฟล์ main.py
ดังนี้
from flask import Flask
import os
import random
app = Flask(__name__) # Create a Flask object.
PORT = os.environ.get("PORT") # Get PORT setting from environment.
# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"]) # ← NEW
def say_hello(name="world"): # ← MODIFIED
html = f"<h1>Hello {name}!</h1>" # ← MODIFIED
return html
# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
app.run(host="0.0.0.0", port=PORT)
เปลี่ยนกลับไปใช้เทอร์มินัล (ผ่านปุ่ม Open Terminal
) และป้อน control-C
(กดแป้นควบคุมค้างไว้ขณะกด "C") เพื่อหยุดแอปที่ทำงานอยู่ แล้วรีสตาร์ทแอปด้วยการป้อน
python3 main.py
คลิกปุ่ม web preview
อีกครั้งแล้วคลิกรายการในเมนู Preview on Port 8080
เพื่อเปิดแท็บเว็บเบราว์เซอร์ไปยังแอปที่กำลังทำงาน คุณควรเห็นข้อความ "สวัสดีทุกคน" อีกครั้ง แต่ตอนนี้ จะแทนที่ข้อความ URL ที่ตามหลังอักขระเครื่องหมายทับด้วยสตริงใดก็ได้ตามต้องการ (เช่น /your-name
) และยืนยันว่าคุณได้เห็นข้อความดังนี้
รูปแบบ 3: สีแบบสุ่ม
ตอนนี้ ให้เพิ่มการรองรับสีพื้นหลังแบบสุ่มโดยกลับไปที่ Cloud Editor (ผ่านปุ่ม Open Editor
) และอัปเดตไฟล์ main.py
ดังนี้
from flask import Flask
import os
import random
app = Flask(__name__) # Create a Flask object.
PORT = os.environ.get("PORT") # Get PORT setting from the environment.
# This function decides whether foreground text should be
# displayed in black or white, to maximize fg/bg contrast.
def set_text_color(rgb): # ← NEW
sum = round( # ← NEW
(int(rgb[0]) * 0.299) # ← NEW
+ (int(rgb[1]) * 0.587) # ← NEW
+ (int(rgb[2]) * 0.114) # ← NEW
) # ← NEW
return "black" if sum > 186 else "white" # ← NEW
# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
# To verify each new invocation of these requests, the HTML document
# includes CSS styling to produce a randomly colored background.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"])
def say_hello(name="world"):
bg = random.sample(range(1, 255), 3) # ← NEW
hex = (int(bg[0]) * 256) + (int(bg[1]) * 16) + int(bg[2]) # ← NEW
fg_color = set_text_color(bg) # ← NEW
bg_color = f"#{hex:06x}" # ← NEW
style = f"color:{fg_color}; background-color:{bg_color}" # ← NEW
html = f'<h1 style="{style}">Hello {name}!</h1>' # ← MODIFIED
return html
# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
app.run(host="0.0.0.0", port=PORT)
เปลี่ยนกลับไปใช้เทอร์มินัล (ผ่านปุ่ม Open Terminal
) และป้อน control-C
(กดแป้นควบคุมค้างไว้ขณะกด "C") เพื่อหยุดแอปที่ทำงานอยู่ แล้วรีสตาร์ทแอปด้วยการป้อน
python3 main.py
คลิกปุ่ม web preview
อีกครั้งแล้วคลิกรายการในเมนู Preview on Port 8080
เพื่อเปิดแท็บเว็บเบราว์เซอร์ไปยังแอปที่กำลังทำงาน คุณควรเห็นข้อความที่สร้างขึ้นพร้อมคำต่อท้ายใดๆ ที่ระบุไว้ หรือ "สวัสดีโลก!" ตามค่าเริ่มต้น สตริงนั้น ๆ แสดงอยู่หน้าพื้นหลังที่มีสีแบบสุ่มดังนี้:
โหลดหน้าเว็บซ้ำ 2-3 ครั้งเพื่อดูว่าพื้นหลังแบบสุ่มมีการเปลี่ยนแปลงทุกครั้งที่คุณไปยังแอป
ขอแสดงความยินดีด้วย แอปของคุณก็จบลงแล้ว ในขั้นตอนถัดไป คุณจะได้เรียนรู้วิธีทำแพ็กเกจแอปในคอนเทนเนอร์ และเหตุผลที่ทำให้เป็นเช่นนั้น
4 สร้างคอนเทนเนอร์ให้กับแอป
คอนเทนเนอร์คืออะไร
คอนเทนเนอร์โดยทั่วไป และ Docker ช่วยให้เราสร้างกล่องแบบโมดูลสำหรับเรียกใช้แอปพลิเคชันที่มีทรัพยากร Dependency ทั้งหมดรวมกันได้ เราเรียกผลลัพธ์ว่าอิมเมจคอนเทนเนอร์ ในส่วนนี้ คุณจะได้สร้างอิมเมจคอนเทนเนอร์ที่คุณจะใช้เพื่อสรุปแอปพลิเคชันและทรัพยากร Dependency ทั้งหมด
เมื่อพูดถึงทรัพยากร Dependency ในขั้นตอนก่อนหน้า เมื่อเรียกใช้แอปในสภาพแวดล้อมของนักพัฒนาซอฟต์แวร์ คุณต้องเรียกใช้ pip3 install -r requirements.txt
และตรวจสอบว่าไฟล์ required.txt มีไลบรารีที่ต้องพึ่งพาและเวอร์ชันที่เกี่ยวข้องทั้งหมด เมื่อใช้คอนเทนเนอร์ คุณจะติดตั้งข้อกำหนดดังกล่าวเมื่อสร้างอิมเมจคอนเทนเนอร์ ดังนั้นผู้บริโภคของคอนเทนเนอร์จึงไม่ต้องกังวลว่าจะติดตั้งอะไรเลย
อิมเมจคอนเทนเนอร์นี้จะเป็นองค์ประกอบพื้นฐานสำหรับการทำให้แอปพลิเคชันใช้งานได้บน Cloud Run เนื่องจากคอนเทนเนอร์สามารถใช้บนเซิร์ฟเวอร์เสมือนหรือเซิร์ฟเวอร์จริงได้เกือบทุกประเภท ทำให้เราติดตั้งใช้งานแอปพลิเคชันได้ทุกที่ที่ต้องการ และย้ายแอปพลิเคชันจากผู้ให้บริการรายหนึ่งไปยังอีกรายหนึ่ง หรือจากภายในองค์กรไปยังระบบคลาวด์ได้
คอนเทนเนอร์ช่วยให้แอปพลิเคชันของคุณ
- สามารถทำซ้ำได้ - คอนเทนเนอร์เป็นแบบเก็บในตัวเองและสมบูรณ์
- แบบพกพา - คอนเทนเนอร์เป็นองค์ประกอบที่ใช้สร้างสรรค์ข้ามอุตสาหกรรม ซึ่งช่วยให้สามารถเคลื่อนย้ายแอปพลิเคชันข้ามผู้ให้บริการและสภาพแวดล้อมได้ในระบบคลาวด์
กล่าวโดยสรุปคือ คอนเทนเนอร์มีความสามารถในการ "เขียนครั้งเดียวและทำงานได้ทุกที่" ข้อยกเว้นประการหนึ่งสำหรับกฎดังกล่าวคือ คอนเทนเนอร์ที่สร้างขึ้นจะถูกจำกัดให้ทำงานในประเภทโปรเซสเซอร์ที่คุณสร้าง แต่ก็ยังมีวิธีสร้างเวอร์ชันคอนเทนเนอร์สำหรับการกำหนดค่าฮาร์ดแวร์อื่นๆ ด้วย
พอแล้ว มาสร้างคอนเทนเนอร์กันเถอะ แต่จะใช้เทคโนโลยีเฉพาะในการสร้างคอนเทนเนอร์ที่ชื่อ Docker
สร้างไฟล์ใหม่ชื่อ Dockerfile
ใน Cloud Editor ไฟล์นี้เป็นพิมพ์เขียวสำหรับการสร้างรูปภาพ ซึ่งจะแจ้งให้ Docker ทราบเกี่ยวกับสภาพแวดล้อมการทำงานและซอร์สโค้ด วิธีติดตั้งทรัพยากร Dependency สร้างแอป และเรียกใช้โค้ด
# Use an official lightweight Python image.
FROM python:3.9-slim
# Copy local code to the container image.
WORKDIR /app
COPY main.py .
COPY requirements.txt .
# Install dependencies into this container so there's no need to
# install anything at container run time.
RUN pip install -r requirements.txt
# Service must listen to $PORT environment variable.
# This default value facilitates local development.
ENV PORT 8080
# Run the web service on container startup. Here you use the gunicorn
# server, with one worker process and 8 threads. For environments
# with multiple CPU cores, increase the number of workers to match
# the number of cores available.
CMD exec gunicorn --bind 0.0.0.0:$PORT --workers 1 --threads 8 --timeout 0 main:app
สร้างอิมเมจคอนเทนเนอร์ใน Cloud Terminal โดยใช้ Cloud Build โดยเรียกใช้คำสั่งต่อไปนี้
gcloud builds submit --tag $TAG
เมื่อพุชไปยังรีจิสทรีแล้ว คุณจะเห็นข้อความ SUCCESS
ที่มีชื่ออิมเมจ ซึ่งควรมีลักษณะดังนี้ gcr.io/<project-id>/hello
ตอนนี้ระบบจะจัดเก็บอิมเมจใน Google Container Registry และสามารถนำกลับมาใช้ใหม่ได้ทุกที่ทุกเวลาที่ต้องการ
คุณแสดงรายการอิมเมจคอนเทนเนอร์ทั้งหมดที่เชื่อมโยงกับโปรเจ็กต์ปัจจุบันได้โดยใช้คำสั่งนี้
gcloud container images list
เรียกใช้และทดสอบแอปพลิเคชันภายในจาก Cloud Shell โดยใช้คำสั่ง docker
ต่อไปนี้
docker run -p $PORT:$PORT -e PORT=$PORT $TAG
ตัวเลือก -p $PORT:$PORT
จะบอกให้ Docker แมปพอร์ตภายนอก $PORT
(ตั้งค่าเป็น 8080 ด้านบน) ในสภาพแวดล้อมโฮสต์เข้ากับหมายเลขพอร์ตเดียวกันภายในคอนเทนเนอร์ที่ทำงานอยู่ ซึ่งทำให้การทำงานง่ายขึ้นเนื่องจากรหัสเซิร์ฟเวอร์ที่คุณเขียนและหมายเลขพอร์ตภายนอกที่คุณเชื่อมต่อเมื่อทดสอบแอปจะเหมือนกัน (8080) แต่คุณสามารถใช้ตัวเลือก -p เพื่อแมปพอร์ตภายนอกบนโฮสต์กับพอร์ตภายในที่ต้องการภายในคอนเทนเนอร์ได้อย่างง่ายดาย
ตัวเลือก -e PORT=$PORT
จะบอกให้ Docker ทำให้ตัวแปรสภาพแวดล้อม $PORT
(ตั้งค่าเป็น 8080 ด้านบน) พร้อมใช้งานสำหรับแอปที่ทำงานในคอนเทนเนอร์
ตอนนี้คุณก็พร้อมทดสอบแอปโดยชี้เว็บเบราว์เซอร์ไปยังโค้ด Python ที่ทำงานอยู่ในคอนเทนเนอร์แล้ว ในหน้าต่าง Cloud Shell ให้คลิก "ตัวอย่างเว็บ" และเลือก "ดูตัวอย่างบนพอร์ต 8080" เหมือนกับการดำเนินการในขั้นตอนก่อนหน้า
ผลลัพธ์ควรดูคุ้นเคย คุณควรเห็นข้อความที่สร้างขึ้นอยู่หน้าพื้นหลังที่มีสีแบบสุ่ม เช่นเดียวกับที่คุณเรียกใช้แอปในเทอร์มินัล Cloud Shell โดยตรง โหลดหน้าเว็บซ้ำ 2-3 ครั้งเพื่อดูว่าพื้นหลังแบบสุ่มมีการเปลี่ยนแปลงทุกครั้งที่คุณไปยังแอป
ยินดีด้วย ตอนนี้คุณเรียกใช้แอปเวอร์ชันที่มีคอนเทนเนอร์แล้ว ในส่วนถัดไป คุณสามารถเปลี่ยนอิมเมจคอนเทนเนอร์ให้เป็นเว็บแอปที่มีคุณภาพการผลิตใช้งานจริงได้โดยไม่ต้องแตะบรรทัดโค้ดเลย
5 ไปที่ระบบคลาวด์...
หลังจากสร้างคอนเทนเนอร์แอปแล้ว คุณคงอยากแชร์ความเจ๋งเล็กๆ น้อยๆ นี้ให้คนอื่นๆ ทั่วโลกได้ดู ดังนั้นได้เวลานำแอปมาใช้งานบนระบบคลาวด์แล้ว แต่จริงๆ แล้วคุณต้องการที่จะทำมากกว่าแค่การแชร์ คุณต้องการที่จะตรวจสอบให้แน่ใจว่า
- ทำงานได้เสถียร - คุณจะได้รับการยอมรับข้อผิดพลาดโดยอัตโนมัติในกรณีที่คอมพิวเตอร์ที่เรียกใช้แอปของคุณขัดข้อง
- ปรับขนาดโดยอัตโนมัติ แอปจะติดตามการเข้าชมในปริมาณมากและลดรอยเท้าแอปโดยอัตโนมัติเมื่อไม่ได้ใช้งาน
- ลดค่าใช้จ่ายของคุณลง โดยไม่เรียกเก็บเงินจากคุณสำหรับทรัพยากรที่ไม่ได้ใช้ คุณจะถูกเรียกเก็บเงินสำหรับทรัพยากรที่ใช้ไปในขณะที่ตอบสนองต่อการเข้าชมเท่านั้น
- เข้าถึงได้ผ่านชื่อโดเมนที่กำหนดเอง - คุณมีสิทธิ์เข้าถึงโซลูชันแบบคลิกเดียวในการกำหนดชื่อโดเมนที่กำหนดเองให้กับบริการของคุณ
- ให้เวลาตอบสนองที่ยอดเยี่ยม - Cold Start จะตอบสนองอย่างสมเหตุสมผล แต่คุณสามารถปรับแต่งได้โดยระบุการกำหนดค่าอินสแตนซ์ขั้นต่ำ
- รองรับการเข้ารหัสจากต้นทางถึงปลายทางโดยใช้การรักษาความปลอดภัยเว็บแบบ SSL/TLS มาตรฐาน - เมื่อคุณทำให้บริการใช้งานได้ คุณจะได้รับการเข้ารหัสเว็บแบบมาตรฐานและใบรับรองที่จำเป็นที่เกี่ยวข้องได้ฟรีโดยอัตโนมัติ
การทำให้แอปใช้งานได้กับ Google Cloud Run คุณจะได้รับสิทธิประโยชน์ทั้งหมดข้างต้นและอีกมากมาย
ทำให้แอปใช้งานได้ใน Cloud Run
ขั้นแรก ให้ปรับเปลี่ยนแอปเพื่อให้คุณบอกการแก้ไขใหม่จากเวอร์ชันเก่าได้ ดำเนินการโดยแก้ไขไฟล์ main.py
เพื่อให้ข้อความเริ่มต้นเปลี่ยนจาก "สวัสดีทุกคน" ว่า "สวัสดีจาก Cloud Run!" กล่าวคือ ให้เปลี่ยนบรรทัดนี้ใน main.py
จากตัวเลือกต่อไปนี้
def say_hello(name="world"):
เป็น
def say_hello(name="from Cloud Run"):
Cloud Run เป็นแบบภูมิภาค ซึ่งหมายความว่าโครงสร้างพื้นฐานที่เรียกใช้บริการ Cloud Run จะอยู่ในภูมิภาคเฉพาะและได้รับการจัดการโดย Google เพื่อให้ใช้งานได้ซ้ำซ้อนกันในทุกโซนภายในภูมิภาคนั้น ในส่วน "ตั้งค่า" ส่วนด้านบน คุณได้กำหนดภูมิภาคเริ่มต้นผ่านตัวแปรสภาพแวดล้อม REGION
สร้างอิมเมจคอนเทนเนอร์อีกครั้งและทำให้แอปพลิเคชันที่มีคอนเทนเนอร์ใช้งานได้ใน Cloud Run ด้วยคำสั่งต่อไปนี้
gcloud builds submit --tag $TAG gcloud run deploy "$APP" \ --image "$TAG" \ --platform "managed" \ --region "$REGION" \ --allow-unauthenticated
- นอกจากนี้ คุณยังกำหนดภูมิภาคเริ่มต้นด้วย
gcloud config set run/region $REGION
ได้ด้วย - ตัวเลือก
--allow-unauthenticated
จะทำให้บริการพร้อมใช้งานแบบสาธารณะ โปรดใช้--no-allow-unauthenticated
แทนเพื่อหลีกเลี่ยงคำขอที่ไม่ผ่านการตรวจสอบสิทธิ์
อิมเมจที่ระบุที่นี่คืออิมเมจ Docker ที่คุณสร้างในขั้นตอนสุดท้าย ด้วยบริการ Cloud Build ซึ่งจัดเก็บอิมเมจผลลัพธ์ใน Google Container Registry บริการ Cloud Run จะค้นหาและทำให้ อิมเมจนั้นใช้งานได้สำหรับคุณ
รอสักครู่จนกว่าการติดตั้งใช้งานจะเสร็จสมบูรณ์ เมื่อทำสำเร็จ บรรทัดคำสั่งจะแสดง URL ของบริการดังนี้
Deploying container to Cloud Run service [hello] in project [PROJECT_ID... ✓ Deploying new service... Done. ✓ Creating Revision... Revision deployment finished. Waiting for health check... ✓ Routing traffic... ✓ Setting IAM Policy... Done. Service [hello] revision [hello-...] has been deployed and is serving 100 percent of traffic. Service URL: https://hello-....a.run.app
นอกจากนี้ คุณยังเรียก URL ของบริการได้ด้วยคำสั่งนี้
gcloud run services describe hello \ --platform managed \ --region $REGION \ --format "value(status.url)"
ซึ่งควรแสดง เช่น
https://hello-....a.run.app
ลิงก์นี้เป็น URL เฉพาะที่มีการรักษาความปลอดภัย TLS สำหรับบริการ Cloud Run ของคุณ ลิงก์นี้จะมีผลถาวร (ตราบใดที่คุณไม่ได้ปิดใช้บริการของคุณ) และสามารถใช้ได้ที่ใดก็ได้บนอินเทอร์เน็ต โดยไม่ได้ใช้กลไกพร็อกซีของ Cloud Shell ที่กล่าวถึงก่อนหน้านี้ ซึ่งขึ้นอยู่กับเครื่องเสมือนชั่วคราว
คลิก Service URL
ที่ไฮไลต์เพื่อเปิดแท็บเว็บเบราว์เซอร์ไปยังแอปที่ทำงานอยู่ ผลลัพธ์ควรแสดงข้อความ "สวัสดีจาก Cloud Run!" ด้านหน้าพื้นหลังที่มีสีแบบสุ่ม
ยินดีด้วย แอปของคุณกำลังทำงานในระบบคลาวด์ของ Google แอปของคุณพร้อมใช้งานแบบสาธารณะด้วยการเข้ารหัส TLS (HTTPS) และการปรับขนาดอัตโนมัติเพื่อให้ได้การเข้าชมในระดับที่น่าเหลือเชื่อโดยไม่ต้องคิดเลย
แต่ผมคิดว่ากระบวนการนี้อาจง่ายกว่า...
6 สร้างคอนเทนเนอร์โดยอัตโนมัติ
ทุกอย่างนี้เจ๋งมาก แต่ถ้าฉันไม่อยากคิดเกี่ยวกับ Dockerfile และคอนเทนเนอร์ เช่นเดียวกับนักพัฒนาซอฟต์แวร์ส่วนใหญ่ ผมแค่ต้องการมุ่งเน้นไปที่การเขียนโค้ดแอปพลิเคชันและปล่อยให้คนอื่นต้องกังวลเกี่ยวกับคอนเทนเนอร์โค้ด คุณโชคดีแล้วเพราะ Cloud Run รองรับมาตรฐานโอเพนซอร์สที่เรียกว่า Buildpacks ซึ่งมีอยู่แล้วด้วยเหตุผลนี้ นั่นคือการทำให้กระบวนการผลิตคอนเทนเนอร์จากคอลเล็กชันไฟล์ต้นฉบับเป็นไปโดยอัตโนมัติ
โปรดทราบว่าในบางกรณีนักพัฒนาซอฟต์แวร์อาจต้องการใช้ Dockerfile อย่างชัดแจ้ง เช่น ในกรณีที่ต้องการให้สร้างคอนเทนเนอร์ด้วยตนเองในระดับสูง แต่สำหรับกรณีทั่วไปอย่างแบบฝึกหัดนี้ ชุดบิลด์จะทำงานได้ดีและไม่จำเป็นต้องสร้าง Dockerfile
มาแก้ไขโค้ดเพื่อใช้ชุดบิลด์กัน
ขั้นแรก ให้ปรับเปลี่ยนแอปเพื่อให้คุณบอกการแก้ไขใหม่จากเวอร์ชันเก่าได้ ดำเนินการโดยแก้ไขไฟล์ main.py
เพื่อให้ข้อความเริ่มต้นเปลี่ยนจาก "สวัสดีจาก Cloud Run!" เป็น "สวัสดีจาก Cloud Run กับ Buildpacks!" กล่าวคือ ให้เปลี่ยนบรรทัดนี้ใน main.py
จากตัวเลือกต่อไปนี้
def say_hello(name="from Cloud Run"):
เป็น
def say_hello(name="from Cloud Run with Buildpacks"):
คราวนี้มาใช้ประโยชน์จาก Buildpack โดยการสร้างไฟล์ใหม่ชื่อ Procfile
กัน ลองสร้างไฟล์ดังกล่าวใน Cloud Editor แล้วแทรกข้อความ 1 บรรทัดต่อไปนี้
web: python3 main.py
ข้อมูลนี้จะบอกระบบบิลด์กลับถึงวิธีเรียกใช้แอปในคอนเทนเนอร์ที่สร้างขึ้นโดยอัตโนมัติ คุณไม่จำเป็นต้องใช้ Dockerfile อีกต่อไปเมื่อใช้วิธีการนี้ หากต้องการตรวจสอบการดำเนินการนี้ ให้ลบ Dockerfile แล้วเรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell Terminal
gcloud beta run deploy "$APP" \ --source . \ --platform "managed" \ --region "$REGION" \ --allow-unauthenticated
ซึ่งคล้ายกับคำสั่งที่คุณใช้เพื่อทำให้แอปในขั้นตอนสุดท้ายได้ แต่ครั้งนี้คุณได้แทนที่ตัวเลือก --image
ด้วยตัวเลือก --source .
ซึ่งจะบอกคำสั่ง gcloud
ว่าคุณต้องการใช้ Buildpack เพื่อสร้างอิมเมจคอนเทนเนอร์ โดยอิงตามไฟล์ต้นฉบับที่พบในไดเรกทอรีปัจจุบัน (dot
ใน --source .
คือชวเลขสำหรับไดเรกทอรีปัจจุบัน) เนื่องจากบริการนี้ดูแลอิมเมจคอนเทนเนอร์โดยปริยาย คุณจึงไม่จำเป็นต้องระบุอิมเมจในคำสั่ง gcloud
นี้
โปรดตรวจสอบอีกครั้งว่าการติดตั้งใช้งานนี้ใช้งานได้โดยคลิกที่ Service URL
ที่ไฮไลต์ เพื่อเปิดแท็บเว็บเบราว์เซอร์ไปยังแอปที่ทำงานอยู่ และตรวจสอบให้แน่ใจว่าบริการแสดงข้อความ "สวัสดีจาก Cloud Run กับ Buildpacks!" หน้าพื้นหลังที่มีสีแบบสุ่ม
โปรดทราบว่าการใช้บิลด์แพ็กในการผลิต Dockerfile
ช่วยลด 3 ขั้นตอนง่ายๆ ให้เหลือเพียง 2 ขั้นตอน ดังนี้
- สร้างแอปในสภาพแวดล้อมในการพัฒนาซอฟต์แวร์
- ทำให้โค้ดที่เหมือนกันใช้งานได้กับระบบคลาวด์ด้วยคำสั่งเดียว
7 ฉันต้องใช้บรรทัดคำสั่งไหม
ไม่เอาด้วยหรอก เช่นเดียวกับบริการของ Google Cloud เกือบทุกบริการ คุณสามารถโต้ตอบกับ Cloud Run ได้ 3 วิธีดังนี้
- เครื่องมือบรรทัดคำสั่ง gcloud ที่คุณเพิ่งเห็น
- อินเทอร์เฟซผู้ใช้แบบเว็บที่สมบูรณ์ผ่าน Cloud Console ซึ่งรองรับรูปแบบการโต้ตอบแบบจุดและการคลิกที่ใช้งานง่าย
- ในการเขียนโปรแกรมโดยใช้ไลบรารีของไคลเอ็นต์ Google ที่มีให้ใช้งานสำหรับภาษายอดนิยมหลากหลายภาษา ซึ่งรวมถึง Java, C#, Python, Go, JavaScript, Ruby, C/C++ และอื่นๆ
มาทำให้อินสแตนซ์เพิ่มเติมของแอป Cloud Run ใช้งานได้โดยใช้ UI ของคอนโซลกัน ไปที่หน้า Landing Page ของบริการ Cloud Run ผ่านเมนูด้านซ้ายบน
จากนั้นคุณควรเห็นสรุปของบริการ Cloud Run ของคุณดังนี้
คลิก "สร้างบริการ" ลิงก์สำหรับเริ่มกระบวนการติดตั้งใช้งาน
ป้อน "สวัสดีอีกครั้ง" เป็นชื่อบริการ แล้วใช้แพลตฟอร์มและภูมิภาคการติดตั้งใช้งานเริ่มต้น แล้วคลิก "ถัดไป"
ป้อน URL นี้สำหรับอิมเมจคอนเทนเนอร์: gcr.io/cloudrun/hello
ซึ่งเป็นคอนเทนเนอร์ที่ Google สร้างขึ้นเพื่อวัตถุประสงค์ในการทดสอบ แล้วคลิก "การตั้งค่าขั้นสูง" เพื่อดูการตั้งค่าบางส่วนที่คุณสามารถใช้ได้ ต่อไปนี้เป็นตัวอย่างที่คุณสามารถปรับแต่งได้
- หมายเลขพอร์ตและจุดแรกเข้าของคอนเทนเนอร์ (ซึ่งจะลบล้างจุดแรกเข้าที่ระบุเมื่อสร้างคอนเทนเนอร์)
- ฮาร์ดแวร์: หน่วยความจำและจำนวน CPU
- การปรับขนาด: อินสแตนซ์ขั้นต่ำและสูงสุด
- ตัวแปรสภาพแวดล้อม
- อื่นๆ: การตั้งค่าระยะหมดเวลาของคำขอ, จำนวนคำขอสูงสุดต่อคอนเทนเนอร์, HTTP/2
คลิกปุ่ม "ถัดไป" เพื่อเลื่อนกล่องโต้ตอบ กล่องโต้ตอบถัดไปจะให้คุณระบุวิธีการทริกเกอร์บริการ สำหรับ "ขาเข้า" ให้เลือก "อนุญาตการรับส่งข้อมูลทั้งหมด" และสำหรับ "การตรวจสอบสิทธิ์" ให้เลือก "อนุญาตการรับส่งข้อมูลที่ไม่ได้ตรวจสอบสิทธิ์"
การตั้งค่าเหล่านี้ถือเป็นการตั้งค่าที่เข้มงวดที่สุด เนื่องจากอนุญาตให้ทุกคนเข้าถึงแอป Cloud Run ได้จากทุกที่บนอินเทอร์เน็ตสาธารณะ โดยไม่ต้องระบุข้อมูลเข้าสู่ระบบการตรวจสอบสิทธิ์ คุณอาจต้องการการตั้งค่าที่จำกัดมากขึ้นสำหรับแอป แต่ขอให้ทำให้ง่ายสำหรับแบบฝึกหัดการเรียนรู้นี้
ตอนนี้ให้คลิกปุ่ม Create
เพื่อสร้างบริการ Cloud Run หลังจากผ่านไป 2-3 วินาที คุณควรเห็นบริการใหม่ปรากฏในรายการสรุปของบริการ Cloud Run บรรทัดสรุปจะมีข้อมูลการติดตั้งใช้งานล่าสุด (วันที่/เวลาและผู้ใด) พร้อมด้วยการตั้งค่ากำหนดที่สำคัญบางส่วน คลิกที่ลิงก์ชื่อบริการเพื่อเจาะลึกลงไปในรายละเอียดเกี่ยวกับบริการใหม่ของคุณ
หากต้องการยืนยันบริการ ให้คลิก URL ที่แสดงอยู่ใกล้กับด้านบนของหน้าสรุปตามที่ไฮไลต์ในตัวอย่างด้านล่าง
คุณควรจะเห็นบางสิ่งเช่นนี้:
ตอนนี้คุณทำให้บริการ Cloud Run ใหม่ใช้งานได้แล้ว โปรดเลือกแท็บ REVISIONS
เพื่อดูวิธีจัดการการทำให้ใช้งานได้หลายรายการ
หากต้องการปรับใช้การแก้ไขใหม่จากคอนโซลโดยตรง คุณสามารถคลิกปุ่ม EDIT & DEPLOY NEW REVISION
ตามที่ไฮไลต์ในภาพหน้าจอตัวอย่างด้านล่าง
คลิกปุ่มนั้นเพื่อสร้างการแก้ไขใหม่ ใกล้กับ URL ของคอนเทนเนอร์ ให้คลิกปุ่ม SELECT
ตามที่แสดงด้านล่าง
ในกล่องโต้ตอบที่ปรากฏขึ้น ให้ค้นหาเว็บแอปแบบง่ายที่คุณทำให้ใช้งานได้จาก Cloud Build โดยใช้ Buildpacks ก่อนหน้านี้ แล้วคลิกเลือก ตรวจสอบว่าคุณเลือกอิมเมจคอนเทนเนอร์ใต้
gcr.io/<project>/cloud-run-source-deploy
โฟลเดอร์ ดังนี้
เมื่อเลือกแล้ว ให้เลื่อนลงไปด้านล่างแล้วคลิกปุ่ม DEPLOY
คุณทำให้แอปเวอร์ชันใหม่ใช้งานได้แล้ว หากต้องการยืนยัน ให้ไปที่ URL บริการของคุณอีกครั้งและยืนยันว่าคุณเห็นข้อความ "สวัสดีจาก Cloud Run กับ Buildpacks!" สีสันสดใส เว็บแอป
จากที่คุณเห็น แท็บการแก้ไขจะแสดงข้อมูลสรุปเกี่ยวกับการแก้ไขทั้งหมดที่คุณได้ปรับใช้ และตอนนี้คุณควรเห็นการแก้ไข 2 รายการสำหรับบริการนี้ คุณสามารถเลือกการแก้ไขที่ต้องการโดยคลิกที่ปุ่มตัวเลือกทางด้านซ้ายของชื่อการแก้ไข ซึ่งจะแสดงสรุปรายละเอียดการแก้ไขที่ด้านขวาของหน้าจอ เมื่อเลือกปุ่มเหล่านี้ คุณจะเห็นว่าการแก้ไขทั้ง 2 รายการมาจากอิมเมจคอนเทนเนอร์ 2 ภาพที่ต่างกัน
ปุ่ม MANAGE TRAFFIC
ช่วยให้คุณสามารถแก้ไขการกระจายคำขอที่เข้ามาส่งไปถึงการแก้ไขที่กำหนด ความสามารถในการปรับแต่งจำนวนการเข้าชมที่ส่งไปยังการแก้ไขที่กำหนดนี้ช่วยให้มีกรณีการใช้งานที่เป็นประโยชน์หลายประการดังนี้
- การทดสอบแอปเวอร์ชัน Canary ที่มีการรับส่งข้อมูลขาเข้าจำนวนเล็กน้อย
- เปลี่ยนการรับส่งข้อมูลจากรุ่นที่มีปัญหากลับไปเป็นเวอร์ชันก่อนหน้า
- การทดสอบ A/B
ค้นหาปุ่ม MANAGE TRAFFIC
ที่นี่:
กําหนดค่าการแยกการเข้าชมแบบ 50/50 ระหว่างการแก้ไข 2 รายการโดยการระบุการแยกการเข้าชมเป็น 50/50 ดังนี้
จากนั้นคลิกปุ่ม "บันทึก" และยืนยันการแบ่ง 50/50 โดยไปที่ URL ของบริการซ้ำๆ แล้วตรวจสอบว่า โดยเฉลี่ยแล้วคำขอครึ่งหนึ่งมาจากการแก้ไขปัจจุบัน ("สวัสดีจาก Cloud Run ด้วย Buildpacks!") และอีกครึ่งหนึ่งจะแสดงโดยการแก้ไขก่อนหน้า ("กำลังทำงานอยู่!")
แท็บอื่นๆ ในหน้ารายละเอียดบริการมีความสามารถในการตรวจสอบประสิทธิภาพ การรับส่งข้อมูล และบันทึก ซึ่งให้ข้อมูลเชิงลึกอันเป็นประโยชน์ว่าบริการของคุณทำงานได้ดีเพียงใด นอกจากนี้ยังปรับแต่งการเข้าถึงบริการผ่าน "สิทธิ์" ได้อีกด้วย ใช้เวลาสักครู่เพื่อสำรวจแท็บในหน้านี้เพื่อให้เข้าใจถึงความสามารถที่มีที่นี่
อินเทอร์เฟซแบบเป็นโปรแกรม
ดังที่กล่าวไว้ก่อนหน้านี้ คุณยังมีตัวเลือกในการสร้าง ทำให้ใช้งานได้ และจัดการบริการ Cloud Run แบบเป็นโปรแกรมด้วย สำหรับงานที่ต้องทำด้วยตนเอง ตัวเลือกนี้จะขั้นสูงกว่าบรรทัดคำสั่งหรือเว็บคอนโซล แต่วิธีนี้เป็นวิธีที่จะทำให้บริการ Cloud Run เป็นแบบอัตโนมัติ คุณมีตัวเลือกในการใช้ไลบรารีไคลเอ็นต์ของ Google ในภาษาโปรแกรมยอดนิยมหลายภาษา
8 ทดสอบแอป
ในขั้นตอนสุดท้ายนี้ คุณจะต้องทำการทดสอบโหลดจริงเพื่อทดสอบสมรรถนะของแอปและดูว่าแอปปรับขนาดอย่างไรตามความต้องการที่เข้ามา คุณจะต้องใช้เครื่องมือชื่อ Ok ซึ่งติดตั้งไว้ล่วงหน้าใน Cloud Shell เพื่อให้เราทำการทดสอบโหลดและนำเสนอผลลัพธ์ได้
ดำเนินการทดสอบ
ในเทอร์มินัล Cloud Shell ให้เรียกใช้คำสั่งนี้เพื่อทำการทดสอบการโหลด
hey -q 1000 -c 200 -z 30s https://hello-...run.app
ระบบจะตีความอาร์กิวเมนต์ของคำสั่งดังนี้
-q 1000
- พยายามรับโหลดด้วยคำขอต่อวินาทีประมาณ 1,000 รายการ-c 200
- จัดสรรผู้ปฏิบัติงานพร้อมกัน 200 คน-z 30s
- ทำการทดสอบการโหลดเป็นเวลา 30 วินาที- โปรดตรวจสอบว่าได้ใช้ URL บริการของคุณเป็นอาร์กิวเมนต์สุดท้ายในบรรทัดคำสั่งนี้
ผลการทดสอบควรมีลักษณะเช่นนี้
Summary:
Total: 30.2767 secs
Slowest: 3.3633 secs
Fastest: 0.1071 secs
Average: 0.1828 secs
Requests/sec: 1087.2387
Total data: 3028456 bytes
Size/request: 92 bytes
Response time histogram:
0.107 [1] |
0.433 [31346] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
0.758 [1472] |■■
1.084 [82] |
1.410 [4] |
...
Latency distribution:
...
50% in 0.1528 secs
75% in 0.1949 secs
90% in 0.2442 secs
95% in 0.4052 secs
99% in 0.7062 secs
Details (average, fastest, slowest):
...
req write: 0.0000 secs, 0.0000 secs, 0.0232 secs
resp wait: 0.1824 secs, 0.1070 secs, 3.2953 secs
resp read: 0.0000 secs, 0.0000 secs, 0.0010 secs
Status code distribution:
[200] 32918 responses
ข้อมูลสรุปนี้แจ้งให้เราทราบถึงรายการต่างๆ ที่น่าสนใจ ดังนี้
- มีการส่งคำขอ 32,918 รายการด้วยความเร็วประมาณ 1 พัน/วินาทีเป็นเวลา 30 วินาที
- ไม่มีข้อผิดพลาด (การตอบกลับ HTTP เพียง 200 รายการ)
- เวลาในการตอบสนองโดยเฉลี่ยคือ 180 มิลลิวินาที
- เวลาในการตอบสนองขั้นต่ำคือ 107 มิลลิวินาที กรณีที่แย่ที่สุดคือ 3.3 วินาที
- เวลาในการตอบสนองของเปอร์เซ็นไทล์ที่ 90 คือ 244 มิลลิวินาที
หากตรวจสอบแท็บ METRICS
ในคอนโซล Cloud Run คุณจะดูเรื่องราวเกี่ยวกับประสิทธิภาพฝั่งเซิร์ฟเวอร์ได้โดยทำดังนี้
9 ล้างข้อมูล
แม้ว่า Cloud Run จะไม่เรียกเก็บเงินเมื่อไม่ได้ใช้งานบริการ แต่คุณก็ยังอาจเรียกเก็บเงินสำหรับการจัดเก็บอิมเมจคอนเทนเนอร์ที่สร้าง
คุณจะลบโปรเจ็กต์ GCP เพื่อหลีกเลี่ยงการเรียกเก็บเงินได้ ซึ่งจะเป็นการหยุดการเรียกเก็บเงินสำหรับทรัพยากรทั้งหมดที่ใช้ในโปรเจ็กต์นั้น หรือเพียงลบอิมเมจคอนเทนเนอร์โดยใช้คำสั่งนี้
gcloud container images delete $TAG
หากต้องการลบบริการ Cloud Run ให้ใช้คำสั่งต่อไปนี้
gcloud run services delete hello --platform managed --region $REGION --quiet gcloud run services delete hello-again --platform managed --region $REGION --quiet
10 คุณทำสำเร็จแล้ว!
ยินดีด้วย คุณสร้างและทำให้แอป Cloud Run เวอร์ชันที่ใช้งานจริงใช้งานได้เรียบร้อยแล้ว ในระหว่างนั้น คุณได้เรียนรู้เกี่ยวกับคอนเทนเนอร์และวิธีสร้างคอนเทนเนอร์ของตัวเอง และคุณได้เห็นว่าการทำให้แอปใช้งานได้ด้วย Cloud Run นั้นง่ายดายเพียงใด โดยการใช้ทั้งเครื่องมือบรรทัดคำสั่ง gcloud
และ Cloud Console ตอนนี้คุณรู้วิธีแชร์ผลงานที่ยอดเยี่ยมกับคนทั่วโลกแล้ว!
ผมอยากฝากคำถามสำคัญข้อหนึ่งให้คุณทราบ
เมื่อแอปทำงานในสภาพแวดล้อมสำหรับนักพัฒนาซอฟต์แวร์ได้แล้ว คุณต้องแก้ไขโค้ดกี่บรรทัดจึงจะทำให้ใช้งานได้ในระบบคลาวด์ พร้อมด้วยแอตทริบิวต์ระดับเวอร์ชันที่ใช้งานจริงทั้งหมดที่ Cloud Run นำเสนอ
แน่นอนว่าคำตอบคือ 0 :)
Codelab ที่น่าสนใจสำหรับการตรวจสอบ...
- สร้างบ็อต Slack ด้วย Node.js ใน Cloud Run
- ทริกเกอร์ Cloud Run ด้วยเหตุการณ์จาก Eventarc
- สวัสดี Cloud Run สำหรับ Anthos Codelab
- ทำให้คอนเทนเนอร์ใช้งานได้และเรียกใช้คอนเทนเนอร์ด้วย Cloud Run บน Node.js
- Codelab อื่นๆ ใน Cloud Run
ฟีเจอร์สุดเจ๋งอื่นๆ ที่น่าสำรวจ...
- การทำให้ใช้งานได้อย่างต่อเนื่องจาก Git โดยใช้ Cloud Build
- การใช้ข้อมูลลับจาก Secret Manager
- ขอแนะนำสตรีมแบบ 2 ทิศทางของ WebSockets, HTTP/2 และ gRPC สำหรับ Cloud Run
- อินสแตนซ์ขั้นต่ำของ Cloud Run: ลด Cold Start แบบ Serverless ให้เหลือน้อยที่สุด
- การแสดงการรับส่งข้อมูลจากหลายภูมิภาค
เอกสารอ้างอิง...
11 คำกระตุ้นให้ดำเนินการ (Call-To-Action)
หากคุณชื่นชอบ Codelab และมีแนวโน้มที่จะใช้เวลาไปกับ Google Cloud มากกว่านี้ คุณควรเข้าร่วม Google Cloud Innovators เลยวันนี้
Google Cloud Innovators ให้บริการฟรีและประกอบด้วย
- สนทนาสด, AMA และเซสชันแผนกลยุทธ์เพื่อเรียนรู้ข่าวสารล่าสุดจาก Googler โดยตรง
- ข่าวสาร Google Cloud ล่าสุดได้ในกล่องจดหมาย
- ป้ายดิจิทัลและพื้นหลังการประชุมทางวิดีโอ
- 500 เครดิตสำหรับห้องทดลองและการเรียนรู้เกี่ยวกับ Skills Boost
คลิกที่นี่เพื่อลงทะเบียน