หน้านี้ได้รับการแปลโดย Cloud Translation API

ห้องทดลอง: ส่วนขยายบริการใน Media CDN

1. บทนำ

อัปเดตล่าสุด:01-05-2024

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

Media CDN ซึ่งเป็นเครือข่าย Edge ระดับโลกของ GCP สำหรับสตรีมมิงสื่อ ซึ่งมี "แพลตฟอร์มหลัก" หรือมีในตัวมากมาย ความสามารถหลักมีจุดประสงค์เพื่อแก้ปัญหากรณีการใช้งานที่พบบ่อยที่สุด แต่คุณอาจมีข้อกำหนดที่ไม่ได้ระบุไว้ในชุดฟีเจอร์หลักนี้ด้วย

ส่วนขยายบริการสำหรับ Media CDN หรือบางครั้งเรียกว่า Edge Programmability จะช่วยให้คุณเรียกใช้โค้ดของคุณเองที่ Edge เพื่อปรับแต่งลักษณะการทำงานของ Media CDN ได้ ซึ่งจะปลดล็อกกรณีการใช้งานเพิ่มเติมตั้งแต่การทำให้คีย์แคชเป็นมาตรฐาน การตรวจสอบสิทธิ์โทเค็นที่กำหนดเองและการเพิกถอนโทเค็น ช่องบันทึกที่กำหนดเองเพิ่มเติม การทดสอบ A/B และหน้าข้อผิดพลาดที่กำหนดเอง

สิ่งที่คุณจะสร้าง

ใน Code Lab นี้ เราจะแนะนำขั้นตอนทำให้สภาพแวดล้อมการนำส่ง CDN ที่เปิดใช้ Edge Compute ทำงานร่วมกับ Media CDN (CDN) + Service Extensions (Edge Programmability) + Cloud Storage (แหล่งที่มาของ CDN)

สิ่งที่คุณจะได้เรียนรู้

วิธีตั้งค่า CDN สื่อโดยตั้งที่เก็บข้อมูล Cloud Storage เป็นต้นทาง
วิธีสร้างปลั๊กอินของส่วนขยายบริการที่มีการตรวจสอบสิทธิ์ HTTP ที่กำหนดเองและเชื่อมโยงกับ Media CDN
วิธีตรวจสอบว่าปลั๊กอินส่วนขยายบริการทำงานตามที่คาดไว้
(ไม่บังคับ) วิธีจัดการปลั๊กอินของส่วนขยายบริการ เช่น การอัปเดต การอ้างอิง การย้อนกลับ และลบปลั๊กอินเวอร์ชันใดเวอร์ชันหนึ่ง

สิ่งที่คุณต้องมี

เครือข่ายพื้นฐานและความรู้เกี่ยวกับ HTTP
ความรู้พื้นฐานเกี่ยวกับบรรทัดคำสั่ง Unix/Linux

2. ก่อนเริ่มต้น

คำขอรายการที่อนุญาตสำหรับ CDN ของสื่อและ รายการที่อนุญาตสำหรับส่วนขยายบริการ

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

หากต้องการขอสิทธิ์เข้าถึงทั้ง CDN ของสื่อและส่วนขยายบริการสำหรับ Media CDN โปรดติดต่อทีมดูแลลูกค้า Google เพื่อสร้างคำขอเข้าถึงในนามของคุณสำหรับ CDN และส่วนขยายบริการในนามของคุณ

3. การตั้งค่าและข้อกำหนด

เริ่มต้น Cloud Shell

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

จากคอนโซล GCP ให้คลิกไอคอน Cloud Shell บนแถบเครื่องมือด้านขวาบนดังนี้

การจัดสรรและเชื่อมต่อกับสภาพแวดล้อมนี้ควรใช้เวลาเพียงครู่เดียว เมื่อเสร็จแล้ว คุณจะเห็นข้อมูลต่อไปนี้

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

ก่อนเริ่มต้น

บทบาท IAM สิทธิ์เข้าถึง

สิทธิ์ Identity and Access Management (IAM) ที่จำเป็นต่อการสร้างทรัพยากร Media CDN และ Artifact Registry มีดังนี้

roles/networkservices.edgeCacheAdmin
roles/networkservices.edgeCacheUser
roles/networkservices.edgeCacheViewer
roles/artifactregistry.repoAdmin

ใน Cloud Shell ให้ตรวจสอบว่ามีการตั้งค่าตัวแปรสภาพแวดล้อม project_id, project_num, location และrepository

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
PROJECT_ID=[YOUR-PROJECT-NAME]
PROJECT_NUM=[YOUR-PROJECT-NUMBER]
LOCATION=us-central1
REPOSITORY=service-extension-$PROJECT_ID

เปิดใช้ API

เปิดใช้ Media CDN และ Service Extensions API โดยใช้คำสั่งด้านล่าง

gcloud services enable networkservices.googleapis.com
gcloud services enable networkactions.googleapis.com
gcloud services enable edgecache.googleapis.com
gcloud services enable artifactregistry.googleapis.com

4. สร้างที่เก็บข้อมูล Cloud Storage

เนื้อหา Media CDN อาจมาจากตำแหน่งต่างๆ เช่น ที่เก็บข้อมูล Cloud Storage, ตำแหน่งพื้นที่เก็บข้อมูลของบุคคลที่สาม หรือปลายทาง HTTP(HTTPS) ที่เข้าถึงได้แบบสาธารณะ

เราจะจัดเก็บเนื้อหาในที่เก็บข้อมูล Cloud Storage ใน Codelab นี้

เราจะใช้คำสั่ง gsutil mb เพื่อสร้างที่เก็บข้อมูล

gsutil mb gs://mediacdn-bucket-$PROJECT_ID

นอกจากนี้ คุณยังสร้างที่เก็บข้อมูล Cloud Storage โดยใช้ GUI ดังต่อไปนี้ได้

ในคอนโซล Google Cloud ให้ไปที่หน้า Cloud Storage
คลิกปุ่มสร้าง
ป้อนชื่อที่เก็บข้อมูล - เช่น "mediacdn-bucket-$PROJECT_ID"
ปล่อยการตั้งค่าที่เหลือเป็นค่าเริ่มต้น
คลิกปุ่มสร้าง

5. อัปโหลดออบเจ็กต์ทดสอบไปยังที่เก็บข้อมูล Cloud Storage

ตอนนี้เราจะอัปโหลดออบเจ็กต์ลงในที่เก็บข้อมูล Cloud Storage

สร้างไฟล์ใน Cloud Shell แล้วอัปโหลดไฟล์ดังกล่าวลงในที่เก็บข้อมูลโดยใช้ gsutil

echo media-cdn-service-extensions-test > file.txt

gsutil cp file.txt gs://mediacdn-bucket-$PROJECT_ID

ให้สิทธิ์ Media CDN เพื่อเข้าถึงที่เก็บข้อมูล

gsutil iam ch \
serviceAccount:service-$PROJECT_NUM@gcp-sa-mediaedgefill.iam.gserviceaccount.com:objectViewer gs://mediacdn-bucket-$PROJECT_ID

6. กำหนดค่า CDN สื่อ

ต่อไปเราจะสร้างการกำหนดค่า Media CDN

การกำหนดค่า Media CDN แต่ละรายการประกอบด้วยทรัพยากรหลัก 2 รายการ ได้แก่

EdgeCacheService รับผิดชอบการกำหนดค่าที่มีผลกับไคลเอ็นต์ (TLS, การกำหนดที่อยู่ IP), การกำหนดเส้นทาง, การกำหนดค่า CDN (โหมดแคช, TTL, การลงชื่อ) และนโยบายความปลอดภัย
EdgeCacheOrigin รับผิดชอบการกำหนดค่าแบบตามต้นทางสำหรับต้นทางที่อิงตาม HTTP รวมถึงเงื่อนไขการลองอีกครั้งเมื่อเนื้อหาไม่พร้อมใช้งานหรือเข้าถึงไม่ได้

กำหนดค่าต้นทางของแคช Edge

ตอนนี้เรามาสร้างต้นทางที่ชี้ไปยังที่เก็บข้อมูล Cloud Storage ที่คุณเพิ่งสร้างกัน

ในคอนโซล Google Cloud ให้ไปที่หน้า CDN ของสื่อ
คลิกแท็บต้นทาง
คลิกสร้างต้นทาง
ป้อน "cloud-storage-origin" เป็นชื่อสำหรับต้นทางของแคช Edge
ในส่วนที่อยู่ต้นทาง ให้ทำดังนี้
ให้เลือก "เลือกที่เก็บข้อมูล Google Cloud Storage"
เรียกดูไปยังที่เก็บข้อมูล Cloud Storage ชื่อ "mediacdn-bucket-$PROJECT_ID"
คลิก "เลือก"
ปล่อยการตั้งค่าที่เหลือเป็นค่าเริ่มต้น
คลิกสร้างต้นทาง

ทรัพยากร EdgeCacheOrigin ที่สร้างใหม่จะปรากฏในรายการต้นทางในโปรเจ็กต์ของคุณในหน้าต้นทาง

กำหนดค่าบริการ Edge Cache

ในคอนโซล Google Cloud ให้ไปที่หน้า CDN ของสื่อ
คลิกแท็บบริการ
คลิกสร้างบริการ
ป้อนชื่อที่ไม่ซ้ำกันสำหรับบริการ เช่น "media-cdn" - จากนั้นคลิกถัดไป

ในส่วนการกำหนดเส้นทาง ให้คลิกเพิ่มกฎของโฮสต์
ป้อนไวลด์การ์ด - "*" ในฟิลด์โฮสต์

คลิกเพิ่มกฎการกำหนดเส้นทาง
สำหรับลำดับความสำคัญ ให้ระบุ "1"
คลิกเพิ่มเงื่อนไขการจับคู่สำหรับการจับคู่เส้นทาง ให้เลือก "การจับคู่คำนำหน้า" เป็นประเภทการจับคู่ ให้ระบุ "/" ในช่องการจับคู่เส้นทาง แล้วคลิกเสร็จสิ้น
เลือกดึงข้อมูลจากต้นทางในส่วน "การดำเนินการหลัก" แล้วเลือกต้นทางที่คุณกำหนดค่าไว้ในรายการแบบเลื่อนลง

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

คลิกสร้างบริการ

ทรัพยากร EdgeCacheService ที่สร้างใหม่จะปรากฏในหน้าบริการในรายการบริการในโปรเจ็กต์

ดึงข้อมูลที่อยู่ IP ของ MediaCDN และการทดสอบ

ในคอนโซล Google Cloud ให้ไปที่หน้า CDN ของสื่อ
ไปที่ CDN สื่อ
คลิกแท็บบริการ
สำหรับบริการของคุณ โปรดดูที่คอลัมน์ที่อยู่

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

curl -svo /dev/null "http://MEDIA_CDN_IP_ADDRESS/file.txt"

คำสั่งควรสร้างเอาต์พุตที่คล้ายกับตัวอย่างต่อไปนี้

< HTTP/2 200 OK
...
media-cdn-service-extensions-test
...

ตอนนี้คุณสร้างการติดตั้งใช้งาน MediaCDN ด้วย Cloud Storage เป็นต้นทางเรียบร้อยแล้ว

7. กำหนดค่า Artifact Registry สำหรับส่วนขยายบริการ

ก่อนสร้าง Service Extensions เราต้องกำหนดค่า Artifact Registry Artifact Registry คือตัวจัดการแพ็กเกจสากลของ Google Cloud สำหรับการจัดการอาร์ติแฟกต์ของบิลด์ ปลั๊กอินส่วนขยายบริการ (Proxy-Wasm) ได้รับการเผยแพร่ไปยัง Artifact Registry เมื่อเผยแพร่ไปยัง Artifact Registry แล้ว คุณจะทำให้ปลั๊กอิน Proxy-Wasm ใช้งานได้กับการทำให้ Media CDN ใช้งานได้

เราจะใช้คำสั่งสร้างที่เก็บอาร์ติแฟกต์ gcloud เพื่อสร้างที่เก็บ

gcloud artifacts repositories create service-extension-$PROJECT_ID \
    --repository-format=docker \
    --location=$LOCATION \
    --description="Repo for Service Extension" \
    --async

นอกจากนี้ คุณยังสร้างที่เก็บโดยใช้ GUI ดังต่อไปนี้ได้

ในคอนโซล Google Cloud ให้ไปที่หน้า Artifact Registry
คลิกปุ่ม + สร้างที่เก็บ
ป้อนชื่อสำหรับที่เก็บ เช่น "service-extension-$PROJECT_ID"
รูปแบบ - "Docker" โหมด - "มาตรฐาน" ประเภทสถานที่ตั้ง - "ภูมิภาค" แล้วเลือก "us-central1 (ไอโอวา)"
คลิกปุ่มสร้าง

ทรัพยากร Artifact Registry Repository ที่สร้างใหม่จะปรากฏในหน้าที่เก็บ

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

gcloud auth configure-docker $LOCATION-docker.pkg.dev

เอาต์พุต:

...
Adding credentials for: us-central1-docker.pkg.dev
Docker configuration file updated.

8. กำหนดค่าส่วนขยายบริการใน Media CDN

ตอนนี้ เราจะสาธิตวิธีเขียนและสร้างปลั๊กอิน Service Extension (Proxy-Wasm) ที่สามารถทำให้ใช้งานได้กับ Media CDN โดยใช้ภาษาโปรแกรม Rust

ในตัวอย่างนี้ เราจะสร้างปลั๊กอิน Proxy-Wasm ที่ยืนยันว่าคำขอ HTTP แต่ละรายการมีส่วนหัว Authorization ที่มีค่าเป็น "secret" หากคำขอไม่มีส่วนหัวนี้ ปลั๊กอินจะสร้างการตอบกลับ HTTP 403 Forbidden

ทวนความจำสั้นๆ เกี่ยวกับส่วนขยายบริการ - มีทรัพยากรหลัก 3 แหล่ง ได้แก่ WasmAction, WasmPlugin และ WasmPluginVersion

ทรัพยากร WasmAction คือสิ่งที่แนบกับ Media CDN EdgeCacheService ของคุณ WasmAction อ้างอิงทรัพยากร WasmPlugin
ทรัพยากร WasmPlugin มีเวอร์ชันหลักที่สอดคล้องกับ WasmPluginVersion ที่ใช้งานอยู่ในปัจจุบัน
WasmPluginVersions จะอ้างอิงอิมเมจคอนเทนเนอร์จาก Artifact Registry ขณะที่คุณเปลี่ยนแปลงปลั๊กอิน Wasm ของพร็อกซี จะเป็นการสร้าง WasmPluginVersion ที่ต่างกันด้วย

โปรดดูแผนภาพด้านล่างเพื่อทำความเข้าใจความสัมพันธ์ระหว่างแหล่งข้อมูลเหล่านี้ให้ดียิ่งขึ้น

เขียนและสร้างปลั๊กอินส่วนขยายบริการ

ติดตั้ง Toolchain ของ Rust โดยทำตามวิธีการที่ https://www.rust-lang.org/tools/install

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

ถัดไป ให้เพิ่มการสนับสนุน Wasm ใน Toolchain ของ Rust โดยเรียกใช้คำสั่งต่อไปนี้

rustup target add wasm32-wasi

สร้างแพ็กเกจ Rust ชื่อ my-wasm-plugin ด้วยคำสั่งต่อไปนี้

cargo new --lib my-wasm-plugin

เอาต์พุต:

Created library `my-wasm-plugin` package

ป้อนไดเรกทอรี my-wasm-plugin จากนั้นคุณควรเห็นไฟล์ Cargo.toml และไดเรกทอรี src

cd my-wasm-plugin
ls

เอาต์พุต:

Cargo.toml  src

ถัดไป ให้กำหนดค่าแพ็กเกจ Rust โดยแก้ไขไฟล์ Cargo.toml หลังบรรทัด [dependencies] ในไฟล์ Cargo.toml ให้เพิ่มโค้ดต่อไปนี้

proxy-wasm = "0.2"
log = "0.4"

[lib]
crate-type = ["cdylib"]

[profile.release]
lto = true
opt-level = 3
codegen-units = 1
panic = "abort"
strip = "debuginfo"

หลังจากแก้ไขแล้ว ไฟล์ Cargo.toml ควรมีลักษณะโดยประมาณดังนี้

[package]
name = "my-wasm-plugin"
version = "0.1.0"
edition = "2021"

[dependencies]
proxy-wasm = "0.2"
log = "0.4"

[lib]
crate-type = ["cdylib"]

[profile.release]
lto = true
opt-level = 3
codegen-units = 1
panic = "abort"
strip = "debuginfo"

คัดลอกเนื้อหาทั้งหมดของไฟล์ sample_code ไปยังไฟล์ lib.rs ในไดเรกทอรี src ใน Cloud Shell

หลังจากแก้ไขแล้ว ไฟล์ lib.rs ควรมีลักษณะโดยประมาณดังนี้

use log::info;
use proxy_wasm::traits::*;
use proxy_wasm::types::*;

...

struct DemoPlugin;

impl HttpContext for DemoPlugin {
    fn on_http_request_headers(&mut self, _: usize, _: bool) -> Action {
        if self.get_http_request_header("Authorization") == Some(String::from("secret")) {
            info!("Access granted.");
            Action::Continue
        } else {
            self.send_http_response(403, vec![], Some(b"Access forbidden.\n"));
            Action::Pause
        }
    }
}

impl Context for DemoPlugin {}

เมื่อเรากำหนดค่าไฟล์ Manifest Cargo.toml และเขียนโค้ด Proxy-Wasm ในไฟล์ lib.rs แล้ว เราจึงสร้างปลั๊กอิน Proxy-Wasm ได้

cargo build --release --target wasm32-wasi

เมื่อการสร้างเสร็จสมบูรณ์ คุณจะเห็นข้อความตามที่แสดงด้านล่าง

Finished release [optimized] target(s) in 1.01s

นอกจากนี้ ลองยืนยันไดเรกทอรี target และตรวจสอบว่าไฟล์ที่สร้างไว้แล้วหรือไม่ ดังนี้

ls ./target

คุณจะเห็นผลลัพธ์ดังที่แสดงด้านล่าง

CACHEDIR.TAG release wasm32-wasi

เผยแพร่ปลั๊กอิน Proxy-Wasm ไปยัง Artifact Registry

ในตอนนี้ เราจะเผยแพร่ปลั๊กอิน Proxy-Wasm ไปยังที่เก็บ Artifact Registry ที่คุณสร้างไว้ก่อนที่จะทำให้ใช้งานได้ใน Media CDN

ก่อนอื่น เราจะจัดแพ็กเกจปลั๊กอิน Proxy-Wasm ในอิมเมจคอนเทนเนอร์

สร้างไฟล์ชื่อ Dockerfile ในไดเรกทอรีเดียวกัน my-wasm-plugin โดยใช้เนื้อหาต่อไปนี้

FROM scratch 
COPY target/wasm32-wasi/release/my_wasm_plugin.wasm plugin.wasm

จากนั้น สร้างอิมเมจคอนเทนเนอร์โดยทำดังนี้

docker build --no-cache --platform wasm -t my-wasm-plugin .

(ตัวประมวลผลที่ไม่ใช่ x86 เท่านั้น) จากนั้นสร้างอิมเมจคอนเทนเนอร์โดยทำดังนี้

docker build --no-cache --platform wasm --provenance=false -t my-wasm-plugin .

เอาต์พุต

[+] Building 0.2s (5/5) FINISHED                                     docker:default
...

ถัดไป เผยแพร่หรือ "พุช" ปลั๊กอิน Proxy-Wasm ไปยัง Artifact Registry เราจะติดแท็กอิมเมจคอนเทนเนอร์ของเราด้วย "prod" แท็ก

docker tag my-wasm-plugin $LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/my-wasm-plugin:prod

ต่อไปเราจะพุช "prod" อิมเมจคอนเทนเนอร์ไปยังที่เก็บ

docker push $LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/my-wasm-plugin:prod

เอาต์พุต:

The push refers to repository 
...
8564ddd9910a: Pushed 
prod: digest: sha256:f3ae4e392eb45393bfd9c200cf8c0c261762f7f39dde5c7cd4b9a8951c6f2812 size: 525

ตอนนี้มาตรวจสอบว่าได้พุชอิมเมจคอนเทนเนอร์ของปลั๊กอิน Proxy-Wasm ไปยัง Artifact Registry เรียบร้อยแล้ว คุณควรจะเห็นผลลัพธ์ที่คล้ายกัน ดังนี้

gcloud artifacts docker images list $LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/my-wasm-plugin --include-tags

เอาต์พุต:

Listing items under project 
...
IMAGE                                         DIGEST           TAGS  CREATE_TIME          UPDATE_TIME
<LOCATION>-docker.pkg.dev/.../my-wasm-plugin  sha256:08c12...  prod  2021-11-10T23:31:27  2021-11-10T23:31:27

เชื่อมโยงปลั๊กอิน Proxy-Wasm กับการติดตั้งใช้งาน Media CDN

ตอนนี้เราก็พร้อมที่จะเชื่อมโยงปลั๊กอิน Proxy-Wasm กับการทำให้ Media CDN ใช้งานได้แล้ว

ปลั๊กอิน Proxy-Wasm เชื่อมโยงกับเส้นทาง Media CDN ในทรัพยากร EdgeCacheService

ก่อนอื่น เราสร้างทรัพยากร Wasm-plugin สำหรับปลั๊กอิน Proxy-Wasm

gcloud alpha service-extensions wasm-plugins create my-wasm-plugin-resource

ต่อไป เราจะสร้าง WasmPluginVersion

gcloud alpha service-extensions wasm-plugin-versions create my-version-1 \
    --wasm-plugin=my-wasm-plugin-resource \
    --image="$LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/my-wasm-plugin:prod"

ถัดไป เราจะระบุเวอร์ชันหลักสำหรับปลั๊กอิน Proxy-Wasm

gcloud alpha service-extensions wasm-plugins update my-wasm-plugin-resource \
    --main-version=my-version-1

ในตอนนี้ ให้ตรวจสอบว่าปลั๊กอิน Proxy-Wasm เชื่อมโยงกับอิมเมจคอนเทนเนอร์อยู่ในที่เก็บ Artifact Registry เรียบร้อยแล้ว คุณควรเห็นผลลัพธ์ที่คล้ายกัน

gcloud alpha service-extensions wasm-plugin-versions list --wasm-plugin=my-wasm-plugin-resource

เอาต์พุต:

NAME   WASM_IMAGE WASM_IMAGE_DIGEST CONFIG_SIZE  CONFIG_IMAGE CONFIG_IMAGE_DIGEST UPDATE_TIME                                            
c7cfa2 <LOCATION>-docker.pkg.dev/.../my-wasm-plugin@sha256:6d663... ... ... 
...

ต่อไป เราจะสร้างทรัพยากร WasmAction ที่อ้างอิงทรัพยากรปลั๊กอิน Wasm ของเรา

gcloud alpha service-extensions wasm-actions create my-wasm-action-resource \
    --wasm-plugin=my-wasm-plugin-resource

นอกจากนี้ โปรดตรวจสอบด้วยว่าทรัพยากร WasmAction เชื่อมโยงกับปลั๊กอิน Proxy-Wasm สำเร็จ คุณควรเห็นผลลัพธ์ที่คล้ายกัน

gcloud alpha service-extensions wasm-actions list

เอาต์พุต:

NAME                                     WASMPLUGIN                                            
my-wasm-action-resource                  projects/805782461588/locations/global/wasmPlugins/myenvoyfilter-resource
...

ตอนนี้เราจำเป็นต้องส่งออกการกำหนดค่า Media CDN EdgeCacheService โดยทำตามขั้นตอนต่อไปนี้

gcloud edge-cache services export media-cdn --destination=my-service.yaml

จากนั้นเปิดไฟล์ my-service.yaml และเพิ่ม wasmAction ลงใน RouteAction สำหรับเส้นทางที่ระบุ ซึ่งอ้างอิงทรัพยากร WasmPlugin ที่สร้างขึ้นก่อนหน้านี้

wasmAction: "my-wasm-action-resource"

หลังจากแก้ไขแล้ว ไฟล์ my-service.yaml ควรมีลักษณะดังนี้

...

pathMatchers:
  - name: routes
    routeRules:
    - headerAction: {}
      matchRules:
      - prefixMatch: /
      origin: projects/<PROJECT_NUM>/locations/global/edgeCacheOrigins/cloud-storage-origin
      priority: '1'
      routeAction:
        cdnPolicy:
          cacheKeyPolicy: {}
          cacheMode: FORCE_CACHE_ALL
          defaultTtl: 3600s
          signedRequestMode: DISABLED
        wasmAction: "my-wasm-action-resource"
...

จากนั้น เราจะบันทึกการกำหนดค่าที่อัปเดตพร้อมการกำหนดค่า Proxy-Wasm ลงในไฟล์ my-service-with-wasm.yaml

สุดท้าย เราจะนำเข้าการกำหนดค่าที่อัปเดตแล้วสำหรับสภาพแวดล้อม CDN ของสื่อที่ใช้งานจริง

$ gcloud alpha edge-cache services import media-cdn --source=my-service-with-wasm.yaml

9. ตรวจสอบปลั๊กอิน Proxy-Wasm ของส่วนขยายบริการบน Media CDN

curl -svo /dev/null "http://IP_ADDRESS/file.txt"

คำสั่งควรสร้างเอาต์พุตที่คล้ายกับตัวอย่างต่อไปนี้

< HTTP/2 403 Forbidden
...
Access forbidden.
...

ตอนนี้ให้ออกคำขออีกครั้งด้วยส่วนหัวการให้สิทธิ์และค่าของข้อมูลลับ

curl -svo /dev/null "http://IP_ADDRESS/file.txt" -H "Authorization: secret"

คำสั่งควรสร้างเอาต์พุตที่คล้ายกับตัวอย่างต่อไปนี้

< HTTP/2 200 OK
...
media-cdn-service-extensions-test
...

10. ไม่บังคับ: การจัดการปลั๊กอิน Proxy-Wasm

การอัปเดตปลั๊กอิน Proxy-Wasm

ขณะปรับปรุงหรือเพิ่มฟังก์ชันใหม่ลงในปลั๊กอิน Proxy-Wasm คุณจะต้องทำให้ปลั๊กอินที่อัปเดตแล้วใช้งานได้กับ Media CDN ด้านล่างนี้เป็นขั้นตอนต่างๆ ในการทำให้ปลั๊กอินเวอร์ชันอัปเดตใช้งานได้

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

ก่อนอื่น ให้อัปเดตไฟล์ต้นฉบับ src/lib.rs ด้วยโค้ดที่แสดงด้านล่าง

use log::{info, warn};
use proxy_wasm::traits::*;
use proxy_wasm::types::*;

...

struct DemoPlugin;

impl HttpContext for DemoPlugin {
    fn on_http_request_headers(&mut self, _: usize, _: bool) -> Action {
        if self.get_http_request_header("Authorization") == Some(String::from("another_secret")) {
            info!("Access granted.");
            Action::Continue
        } else {
            warn!("Access forbidden.");
            self.send_http_response(403, vec![], Some(b"Access forbidden.\n"));
            Action::Pause
        }
    }
}

impl Context for DemoPlugin {}

จากนั้น สร้าง สร้างแพ็กเกจ และเผยแพร่ปลั๊กอินที่อัปเดตแล้ว:

cargo build --release --target wasm32-wasi
docker build --no-cache --platform wasm -t my-wasm-plugin .
docker tag my-wasm-plugin $LOCATION-docker.pkg.dev/$PROJECT_NUM/$REPOSITORY/my-wasm-plugin:prod
docker push $LOCATION-docker.pkg.dev/$PROJECT_NUM/$REPOSITORY>/my-wasm-plugin:prod

เมื่ออัปเดตอิมเมจคอนเทนเนอร์ใน Artifact Registry แล้ว เราต้องสร้าง WasmPluginVersion ใหม่ จากนั้นอัปเดต WasmPlugin เวอร์ชันเก่าเพื่ออ้างอิงเวอร์ชันใหม่

gcloud alpha service-extensions wasm-plugin-versions create my-version-2 \
    --wasm-plugin=my-wasm-plugin-resource \
   --image="$LOCATION-docker.pkg.dev/$PROJECT_NUM/$REPOSITORY>/my-wasm-plugin:prod"

gcloud alpha service-extensions wasm-plugins update my-wasm-plugin-resource \
    --main-version=my-version-2

ตอนนี้คุณอัปเดตเวอร์ชันของอิมเมจคอนเทนเนอร์ที่จะนำเข้าจาก Artifact Registry เรียบร้อยแล้ว และพุชไปยังการติดตั้งใช้งาน Media CDN ของคุณ

ย้อนกลับไปเป็นเวอร์ชันก่อนหน้า

หากต้องการย้อนกลับไปใช้ปลั๊กอินเวอร์ชันก่อนหน้า คุณอัปเดตทรัพยากรปลั๊กอิน Wasm ให้อ้างอิงเวอร์ชันก่อนหน้าได้

ก่อนอื่น เราจะแสดงเวอร์ชันที่พร้อมใช้งาน

gcloud alpha service-extensions wasm-plugin-versions list --wasm-plugin=my-wasm-plugin-resource

คุณควรจะเห็นผลลัพธ์:

NAME   WASM_IMAGE WASM_IMAGE_DIGEST CONFIG_SIZE  CONFIG_IMAGE CONFIG_IMAGE_DIGEST UPDATE_TIME                                            
c7cfa2 <LOCATION>-docker.pkg.dev/.../my-wasm-plugin@sha256:6d663... ... ... 
a2a8ce <LOCATION>-docker.pkg.dev/.../my-wasm-plugin@sha256:08c12... ... ...

ถัดไป เราอัปเดตทรัพยากรปลั๊กอิน Wasm ให้อ้างอิงเวอร์ชันก่อนหน้า "a2a8ce" ดังนี้

$ gcloud alpha service-extensions wasm-plugins update my-wasm-plugin-resource \
    --main-version="a2a8ce"

เมื่อการดำเนินการเสร็จสิ้นแล้ว คุณควรเห็นเอาต์พุตนี้

✓ WASM Plugin [my-wasm-plugin-resource] is now serving version "a2a8ce"

เนื่องจาก Media CDN จะบันทึกสรุปอิมเมจของอิมเมจ Docker ทุกครั้งที่มีการสร้างทรัพยากร Wasm-plugin ใหม่ การย้อนกลับจะใช้โค้ดเวอร์ชันที่ทำงานอยู่ก่อนการเปิดตัวครั้งล่าสุด

gcloud alpha service-extensions wasm-plugins describe my-wasm-plugin-resource \
  --expand-config

สำหรับเวอร์ชัน "a2a8ce" เวอร์ชันที่มีไดเจสต์ sha256:08c12...:

name: "my-wasm-plugin-resource"
mainVersion: "a2a8ce"
mainVersionDetails:
  image: "<LOCATION>-docker.pkg.dev/<PROJECT>/<REPOSITORY>/my-wasm-plugin"
  imageDigest: "<LOCATION>-docker.pkg.dev/<PROJECT>/<REPOSITORY>/my-wasm-plugin@sha256:08c121dd7fd1e4d3a116a28300e9fc1fa41b2e9775620ebf3d96cb7119bd9976"

การลบ WasmAction & WasmPlugin

หากต้องการลบ WasmAction, WasmPlugin และ WasmPluginVersions ที่เกี่ยวข้อง โปรดทำตามขั้นตอนต่อไปนี้

ก่อนอื่น ให้นำการอ้างอิงไปยัง WasmAction ออกในการกำหนดค่า Media CDN EdgeCacheService

บรรทัดอ้างอิงที่จะนำออก:

wasmAction: "my-wasm-action-resource"

จากนั้นเราจะอัปเดตการกำหนดค่า EdgeCacheService ที่มีการแก้ไข

gcloud alpha edge-cache services import prod-media-service --source=my-service.yaml

ต่อไป ให้อัปเดตเวอร์ชันหลักของ WasmPlugin เป็นสตริงว่าง ""

gcloud alpha service-extensions wasm-plugins update my-wasm-plugin-resource --main-version=

""

สุดท้าย โปรดทำตามขั้นตอนการลบด้านล่างตามลำดับ

gcloud alpha service-extensions wasm-actions delete my-wasm-action-resource

gcloud alpha service-extensions wasm-plugin-versions delete my-version \ --wasm-plugin=my-wasm-plugin-resource

gcloud alpha service-extensions wasm-plugins delete my-wasm-plugin-resource

11. ทำความสะอาดสภาพแวดล้อมของห้องทดลอง

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

คำสั่งต่อไปนี้จะลบบริการ Media CDN EdgeCache, การกำหนดค่า EdgeCache และปลั๊กอินส่วนขยายบริการ ทำตามขั้นตอนการลบด้านล่างตามลำดับ

gcloud edge-cache services delete media-cdn

gcloud edge-cache origins delete cloud-storage-origin

gcloud alpha service-extensions wasm-actions delete my-wasm-action-resource

gcloud alpha service-extensions wasm-plugins update my-wasm-plugin-resource --main-version=""

gcloud alpha service-extensions wasm-plugin-versions delete my-version-1 --wasm-plugin=my-wasm-plugin-resource

gcloud alpha service-extensions wasm-plugins delete my-wasm-plugin-resource

gcloud artifacts repositories delete service-extension-$PROJECT_ID --location=$LOCATION

คำสั่งแต่ละรายการข้างต้นควรขอให้คุณยืนยันการลบทรัพยากร

12. ยินดีด้วย

ยินดีด้วย คุณทำส่วนขยายบริการใน Codelab ของ Media CDN เสร็จสมบูรณ์แล้ว

หัวข้อที่ครอบคลุม

วิธีตั้งค่า CDN สื่อโดยตั้งที่เก็บข้อมูล Cloud Storage เป็นต้นทาง
วิธีสร้างปลั๊กอินของส่วนขยายบริการที่มีการตรวจสอบสิทธิ์ HTTP ที่กำหนดเองและเชื่อมโยงกับ Media CDN
วิธีตรวจสอบว่าปลั๊กอินส่วนขยายบริการทำงานตามที่คาดไว้
(ไม่บังคับ) วิธีจัดการปลั๊กอินของส่วนขยายบริการ เช่น การอัปเดต การอ้างอิง การย้อนกลับ และลบปลั๊กอินเวอร์ชันใดเวอร์ชันหนึ่ง

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

ลองดู Codelab เหล่านี้...

ห้องทดลอง: ส่วนขยายบริการใน Media CDN

1. บทนำ

สิ่งที่คุณจะสร้าง

สิ่งที่คุณจะได้เรียนรู้

สิ่งที่คุณต้องมี

2. ก่อนเริ่มต้น

คำขอรายการที่อนุญาตสำหรับ CDN ของสื่อและ รายการที่อนุญาตสำหรับส่วนขยายบริการ

3. การตั้งค่าและข้อกำหนด

เริ่มต้น Cloud Shell

ก่อนเริ่มต้น

บทบาท IAM สิทธิ์เข้าถึง

เปิดใช้ API

4. สร้างที่เก็บข้อมูล Cloud Storage

5. อัปโหลดออบเจ็กต์ทดสอบไปยังที่เก็บข้อมูล Cloud Storage

6. กำหนดค่า CDN สื่อ

กำหนดค่าต้นทางของแคช Edge

กำหนดค่าบริการ Edge Cache

ดึงข้อมูลที่อยู่ IP ของ MediaCDN และการทดสอบ

7. กำหนดค่า Artifact Registry สำหรับส่วนขยายบริการ

8. กำหนดค่าส่วนขยายบริการใน Media CDN

เขียนและสร้างปลั๊กอินส่วนขยายบริการ

เผยแพร่ปลั๊กอิน Proxy-Wasm ไปยัง Artifact Registry

เชื่อมโยงปลั๊กอิน Proxy-Wasm กับการติดตั้งใช้งาน Media CDN

9. ตรวจสอบปลั๊กอิน Proxy-Wasm ของส่วนขยายบริการบน Media CDN

10. ไม่บังคับ: การจัดการปลั๊กอิน Proxy-Wasm

การอัปเดตปลั๊กอิน Proxy-Wasm

ย้อนกลับไปเป็นเวอร์ชันก่อนหน้า

การลบ WasmAction & WasmPlugin

11. ทำความสะอาดสภาพแวดล้อมของห้องทดลอง

12. ยินดีด้วย

หัวข้อที่ครอบคลุม

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

อ่านเพิ่มเติม

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