พัฒนาสู่ผลิตภัณฑ์ใน 3 ขั้นตอนง่ายๆ ด้วย Cloud Run

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 ทั้งหมด (ชื่อด้านบนมีผู้ใช้แล้วและจะใช้ไม่ได้ ขออภัย) ซึ่งจะเรียกว่า PROJECT_ID ในภายหลังใน Codelab นี้

จากนั้นคุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร Google Cloud

การทำตาม Codelab นี้ไม่ควรมีค่าใช้จ่ายมากนัก หรืออาจไม่มีเลย โปรดทำตามวิธีการในส่วน "การล้างข้อมูล" ซึ่งจะแนะนำวิธีปิดทรัพยากรเพื่อไม่ให้มีการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ ผู้ใช้ Google Cloud รายใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรีมูลค่า$300 USD

เริ่ม Cloud Shell

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

เปิดใช้งาน Cloud Shell

จาก Cloud Console ให้คลิกเปิดใช้งาน Cloud Shell

หากไม่เคยเริ่มใช้ Cloud Shell มาก่อน คุณจะเห็นหน้าจอระดับกลาง (ด้านล่าง) ที่อธิบายว่า Cloud Shell คืออะไร ในกรณีนี้ ให้คลิกต่อไป (และคุณจะไม่เห็นหน้าจอนี้อีก) หน้าจอแบบครั้งเดียวจะมีลักษณะดังนี้

การจัดสรรและเชื่อมต่อกับ Cloud Shell จะใช้เวลาไม่นาน

เครื่องเสมือนนี้มีเครื่องมือพัฒนาซอฟต์แวร์ทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักแบบถาวรขนาด 5 GB และทำงานใน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก คุณสามารถทำงานในโค้ดแล็บนี้ได้โดยใช้เพียงเบราว์เซอร์หรือ 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 Code ซึ่งคุณสามารถสร้างโปรเจ็กต์ แก้ไขซอร์สโค้ด เรียกใช้โปรแกรม ฯลฯ หากหน้าจอแคบเกินไป คุณสามารถขยายหรือย่อเส้นแบ่งระหว่างคอนโซลกับหน้าต่างแก้ไข/เทอร์มินัลได้โดยการลากแถบแนวนอนระหว่าง 2 ภูมิภาคนี้ ซึ่งไฮไลต์ไว้ที่นี่

คุณสามารถสลับไปมาระหว่างตัวแก้ไขกับเทอร์มินัลได้โดยคลิกปุ่ม Open Editor และ Open Terminal ตามลำดับ ตอนนี้ลองสลับไปมาระหว่าง 2 สภาพแวดล้อมนี้

จากนั้นสร้างโฟลเดอร์เพื่อจัดเก็บงานสำหรับแล็บนี้โดยเลือก File->New Folder ป้อน hello แล้วคลิก OK ไฟล์ทั้งหมดที่คุณสร้างในแล็บนี้และงานทั้งหมดที่คุณทำใน Cloud Shell จะอยู่ในโฟลเดอร์นี้

ตอนนี้ให้สร้างไฟล์ requirements.txt ซึ่งจะบอก Python ว่าแอปของคุณขึ้นอยู่กับไลบรารีใด สำหรับเว็บแอปแบบง่ายนี้ คุณจะใช้โมดูล Python ยอดนิยมสำหรับสร้างเว็บเซิร์ฟเวอร์ที่ชื่อ Flask และเฟรมเวิร์กเว็บเซิร์ฟเวอร์ที่ชื่อ gunicorn ในหน้าต่าง Cloud Editor ให้คลิกเมนู File->New File เพื่อสร้างไฟล์ใหม่ เมื่อระบบแจ้งให้ตั้งชื่อไฟล์ใหม่ ให้ป้อน 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 เพื่อเปิดแท็บเว็บเบราว์เซอร์ไปยังแอปที่กำลังทำงานอยู่ คุณควรเห็นข้อความ "Hello world!" อีกครั้ง แต่ตอนนี้ให้แทนที่ข้อความ 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)

python3 main.py

อีกครั้ง ให้คลิกปุ่ม web preview แล้วคลิกรายการเมนู Preview on Port 8080 เพื่อเปิดแท็บเว็บเบราว์เซอร์ไปยังแอปที่กำลังทำงานอยู่ คุณควรเห็นข้อความที่สร้างขึ้นพร้อมด้วยคำต่อท้ายที่ระบุหรือสตริง "Hello world!" เริ่มต้น ซึ่งแสดงอยู่ด้านหน้าพื้นหลังที่มีสีแบบสุ่ม ดังนี้

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

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

4. สร้างคอนเทนเนอร์ให้แอป

คอนเทนเนอร์คืออะไร

โดยทั่วไปแล้ว คอนเทนเนอร์และโดยเฉพาะอย่างยิ่ง Docker ช่วยให้เราสร้างกล่องแบบแยกส่วนเพื่อเรียกใช้แอปพลิเคชันพร้อมกับการอ้างอิงทั้งหมดที่รวมไว้ด้วยกันได้ เราเรียกผลลัพธ์นี้ว่าอิมเมจคอนเทนเนอร์ ในส่วนนี้ คุณจะสร้างอิมเมจคอนเทนเนอร์ซึ่งจะใช้เพื่อห่อหุ้มแอปพลิเคชันและทรัพยากร Dependency ทั้งหมด

เมื่อพูดถึงการขึ้นต่อกัน ในขั้นตอนก่อนหน้านี้ เมื่อคุณเรียกใช้แอปในสภาพแวดล้อมของนักพัฒนาแอป คุณต้องเรียกใช้ pip3 install -r requirements.txt และตรวจสอบว่าไฟล์ requirements.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 เพื่อให้ข้อความเริ่มต้นเปลี่ยนจาก "Hello world!" เป็น "Hello from 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 Run จะค้นหาและทำให้ใช้งานได้สำหรับคุณได้เนื่องจากบริการ Cloud Build จัดเก็บอิมเมจผลลัพธ์ไว้ใน Google Container Registry

โปรดรอสักครู่จนกว่าการติดตั้งใช้งานจะเสร็จสมบูรณ์ เมื่อสำเร็จ บรรทัดคำสั่งจะแสดง 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 รองรับมาตรฐานโอเพนซอร์สที่เรียกว่า Buildpack ซึ่งมีไว้เพื่อเหตุผลนี้โดยเฉพาะ นั่นคือการทำให้กระบวนการสร้างคอนเทนเนอร์จากคอลเล็กชันของไฟล์ต้นฉบับเป็นไปโดยอัตโนมัติ

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

ก่อนอื่น มาแก้ไขแอปเพื่อให้คุณแยกความแตกต่างระหว่างการแก้ไขใหม่กับการแก้ไขเก่าได้ โดยแก้ไขไฟล์ main.py เพื่อให้ข้อความเริ่มต้นเปลี่ยนจาก "สวัสดีจาก Cloud Run!" เป็น "สวัสดีจาก Cloud Run ที่มี Buildpack!" กล่าวคือ เปลี่ยนบรรทัดนี้ใน 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

gcloud beta run deploy "$APP"  \
    --source .                 \
    --platform "managed"       \
    --region "$REGION"         \
    --allow-unauthenticated

ซึ่งคล้ายกับคำสั่งที่คุณเรียกใช้เพื่อติดตั้งใช้งานแอปในขั้นตอนสุดท้าย แต่ครั้งนี้คุณได้แทนที่ตัวเลือก --image ด้วยตัวเลือก --source . ซึ่งจะบอกคำสั่ง gcloud ว่าคุณต้องการให้ใช้ Buildpack เพื่อสร้างอิมเมจคอนเทนเนอร์ตามไฟล์ต้นฉบับที่พบในไดเรกทอรีปัจจุบัน (dot ใน --source . เป็นคำย่อของไดเรกทอรีปัจจุบัน) เนื่องจากบริการจะดูแลอิมเมจคอนเทนเนอร์โดยนัย คุณจึงไม่จำเป็นต้องระบุอิมเมจในคำสั่ง gcloud นี้

โปรดตรวจสอบอีกครั้งว่าการติดตั้งใช้งานนี้ใช้งานได้โดยคลิก Service URL ที่ไฮไลต์เพื่อเปิดแท็บเว็บเบราว์เซอร์ไปยังแอปที่กำลังทำงาน และตรวจสอบว่าบริการแสดงข้อความ "Hello from Cloud Run with Buildpacks!" ที่ด้านหน้าของพื้นหลังสีแบบสุ่ม

โปรดทราบว่าการใช้ Buildpack เพื่อสร้าง 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 ดังนี้

คลิกลิงก์ "สร้างบริการ" เพื่อเริ่มกระบวนการติดตั้งใช้งาน

ป้อน "hello-again" เป็นชื่อบริการ ใช้แพลตฟอร์มการติดตั้งใช้งานและภูมิภาคเริ่มต้น แล้วคลิก "ถัดไป"

ป้อน URL นี้สำหรับอิมเมจคอนเทนเนอร์: gcr.io/cloudrun/hello ซึ่งเป็นคอนเทนเนอร์ที่ Google สร้างขึ้นเพื่อวัตถุประสงค์ในการทดสอบ แล้วคลิกเมนูแบบเลื่อนลง "การตั้งค่าขั้นสูง" เพื่อดูการตั้งค่าการกำหนดค่าบางส่วนที่มีให้คุณ ตัวอย่างการปรับแต่งบางอย่างที่คุณทำได้มีดังนี้

หมายเลขพอร์ตและจุดแรกเข้าของคอนเทนเนอร์ (ซึ่งจะลบล้างจุดแรกเข้าที่ระบุเมื่อสร้างคอนเทนเนอร์)
ฮาร์ดแวร์: หน่วยความจำและจำนวน CPU
การปรับขนาด: อินสแตนซ์ขั้นต่ำและสูงสุด
ตัวแปรสภาพแวดล้อม
อื่นๆ: การตั้งค่าการหมดเวลาของคำขอ จำนวนคำขอสูงสุดต่อคอนเทนเนอร์ HTTP/2

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

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

ตอนนี้คลิกปุ่ม Create เพื่อสร้างบริการ Cloud Run หลังจากนั้นไม่กี่วินาที คุณควรเห็นบริการใหม่ปรากฏในรายการสรุปของบริการ Cloud Run บรรทัดสรุปจะแสดงการติดตั้งใช้งานล่าสุด (วันที่/เวลา และผู้ที่ติดตั้งใช้งาน) พร้อมกับการตั้งค่าการกำหนดค่าที่สำคัญบางอย่าง คลิกลิงก์ชื่อบริการเพื่อเจาะลึกรายละเอียดเกี่ยวกับบริการใหม่

หากต้องการยืนยันบริการ ให้คลิก URL ที่แสดงอยู่ใกล้ด้านบนของหน้าสรุปตามที่ไฮไลต์ไว้ในตัวอย่างด้านล่าง

คุณควรเห็นข้อความคล้ายกับข้อความต่อไปนี้

เมื่อทำให้บริการ Cloud Run ใหม่ใช้งานได้แล้ว ให้เลือกแท็บ REVISIONS เพื่อดูวิธีจัดการการทำให้ใช้งานได้หลายรายการ

หากต้องการติดตั้งใช้งานรีวิชันใหม่จากคอนโซลโดยตรง ให้คลิกปุ่ม EDIT & DEPLOY NEW REVISION ตามที่ไฮไลต์ในภาพหน้าจอตัวอย่างด้านล่าง

คลิกปุ่มนั้นตอนนี้เพื่อสร้างฉบับแก้ไขใหม่ คลิกปุ่ม SELECT ใกล้กับ URL ของคอนเทนเนอร์ ดังที่แสดงด้านล่าง

ในกล่องโต้ตอบที่ปรากฏขึ้น ให้ค้นหาเว็บแอปแบบง่ายที่คุณติดตั้งใช้งานจาก Cloud Build โดยใช้ Buildpack ก่อนหน้านี้ แล้วคลิกเลือก ตรวจสอบว่าคุณเลือกอิมเมจคอนเทนเนอร์ในส่วน

gcr.io/<project>/cloud-run-source-deploy

โฟลเดอร์ เช่น

เมื่อเลือกแล้ว ให้เลื่อนลงไปที่ด้านล่างแล้วคลิกปุ่ม DEPLOY ตอนนี้คุณได้ทําให้แอปเวอร์ชันใหม่ใช้งานได้แล้ว หากต้องการยืนยัน ให้ไปที่ URL ของบริการอีกครั้งและตรวจสอบว่าตอนนี้คุณเห็นเว็บแอป "สวัสดีจาก Cloud Run ด้วย Buildpack!" ที่มีสีสันแล้ว

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

ปุ่ม MANAGE TRAFFIC ช่วยให้คุณแก้ไขการกระจายคำขอขาเข้าที่ส่งไปยังรีวิชันที่ระบุได้ ความสามารถในการปรับแต่งปริมาณการเข้าชมที่ส่งไปยังการแก้ไขที่เฉพาะเจาะจงช่วยให้เกิด Use Case ที่มีคุณค่าหลายอย่าง ดังนี้

การทดสอบ Canary สำหรับแอปเวอร์ชันใหม่ด้วยการรับส่งข้อมูลขาเข้าเพียงเล็กน้อย
เปลี่ยนเส้นทางการรับส่งข้อมูลจากรุ่นที่มีปัญหาไปยังการแก้ไขก่อนหน้า
การทดสอบ A/B

ค้นหาปุ่ม MANAGE TRAFFIC ได้ที่นี่

กำหนดค่าการแยกการเข้าชม 50/50 ระหว่างการแก้ไข 2 รายการโดยระบุการแยกการเข้าชม 50/50 ดังนี้

ตอนนี้ให้คลิกปุ่มบันทึกและยืนยันการแยก 50/50 โดยไปที่ URL ของบริการซ้ำๆ และตรวจสอบว่าโดยเฉลี่ยแล้ว คำขอครึ่งหนึ่งจะได้รับการตอบสนองโดยการแก้ไขปัจจุบัน ("สวัสดีจาก Cloud Run ที่มี Buildpack!") และอีกครึ่งหนึ่งจะได้รับการตอบสนองโดยการแก้ไขก่อนหน้า ("ทำงานแล้ว!")

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

อินเทอร์เฟซแบบเป็นโปรแกรม

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

8. ทดสอบแอป

ในขั้นตอนสุดท้ายนี้ คุณจะต้องทำการทดสอบโหลดเทียมเพื่อทดสอบความทนทานของแอปและดูว่าแอปปรับขนาดตามดีมานด์ที่เข้ามาได้อย่างไร คุณจะใช้เครื่องมือที่ชื่อ hey ซึ่งติดตั้งไว้ล่วงหน้าใน 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,000 รายการต่อวินาทีเป็นเวลา 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 ที่ควรลอง

ฟีเจอร์เจ๋งๆ อื่นๆ ที่คุณสำรวจได้...

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

11. คำกระตุ้นให้ดำเนินการ (Call-To-Action)

หากคุณสนุกกับ Codelab นี้และมีแนวโน้มที่จะใช้เวลามากขึ้นในการลงมือปฏิบัติจริงกับ Google Cloud คุณควรเข้าร่วม Google Cloud Innovators วันนี้

Google Cloud Innovators ไม่มีค่าใช้จ่ายและมีสิทธิประโยชน์ดังนี้

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

คลิกที่นี่เพื่อลงทะเบียน