1. ภาพรวม
พร้อมที่จะยกระดับความปลอดภัยและความเป็นส่วนตัวของภาระงานที่เร่งด้วย GPU แล้วหรือยัง โค้ดแล็บนี้จะแนะนำความสามารถของ Trusted Space ซึ่งเป็นข้อเสนอที่ให้การแยกผู้ให้บริการที่แข็งแกร่งและการสนับสนุนตัวเร่งสำหรับภาระงาน AI/ML ที่มีความละเอียดอ่อน
การปกป้องข้อมูล โมเดล และคีย์ที่มีค่าเป็นสิ่งสำคัญมากกว่าที่เคย Trusted Space มีโซลูชันโดยการตรวจสอบว่าภาระงานของคุณทำงานภายในสภาพแวดล้อมที่ปลอดภัยและเชื่อถือได้ ซึ่งแม้แต่ผู้ปฏิบัติงานภาระงานก็ไม่มีสิทธิ์เข้าถึง
พื้นที่ที่เชื่อถือได้มีข้อดีดังนี้
- ความเป็นส่วนตัวและความปลอดภัยที่ดียิ่งขึ้น: พื้นที่ที่เชื่อถือได้มีสภาพแวดล้อมการดำเนินการที่เชื่อถือได้ซึ่งจะปกป้องชิ้นงานที่ละเอียดอ่อน (เช่น โมเดล ข้อมูลและคีย์ที่มีค่า) โดยได้รับการสนับสนุนจากหลักฐานการเข้ารหัส
- การแยกโอเปอเรเตอร์: ไม่ต้องกังวลเรื่องการรบกวนของโอเปอเรเตอร์ เมื่อใช้พื้นที่ที่เชื่อถือได้ แม้แต่ผู้ปฏิบัติงานด้านภาระงานก็ไม่มีสิทธิ์เข้าถึง ซึ่งจะป้องกันไม่ให้ผู้ปฏิบัติงานดังกล่าว SSH, เข้าถึงข้อมูล, ติดตั้งซอฟต์แวร์ หรือดัดแปลงโค้ดของคุณ
- การรองรับตัวเร่ง: Trusted Space ออกแบบมาให้ทำงานร่วมกับตัวเร่งฮาร์ดแวร์ที่หลากหลายได้อย่างราบรื่น ซึ่งรวมถึง GPU เช่น H100, A100, T4 และ L4 ซึ่งจะช่วยให้แอปพลิเคชัน AI/ML ที่มีความสำคัญต่อประสิทธิภาพทำงานได้อย่างราบรื่น
สิ่งที่คุณจะได้เรียนรู้
- ทำความเข้าใจข้อเสนอหลักของพื้นที่ที่เชื่อถือได้
- ดูวิธีติดตั้งใช้งานและกำหนดค่าสภาพแวดล้อมพื้นที่ที่เชื่อถือได้เพื่อรักษาความปลอดภัยของชิ้นงาน AI/ML ที่มีค่า
สิ่งที่คุณต้องมี
- โปรเจ็กต์ Google Cloud Platform
- ความรู้พื้นฐานเกี่ยวกับ Google Compute Engine และตัวเร่ง
- มีความรู้พื้นฐานเกี่ยวกับบัญชีบริการ การจัดการคีย์ การรวมศูนย์ของ Workload Identity และเงื่อนไขแอตทริบิวต์
- ความรู้พื้นฐานเกี่ยวกับคอนเทนเนอร์และ Artifact Registry
การปกป้องพรอมต์การสร้างโค้ดที่ละเอียดอ่อนด้วย Primus Company
ในโค้ดแล็บนี้ เราจะสวมบทบาทเป็น Primus ซึ่งเป็นบริษัทที่ให้ความสำคัญกับความเป็นส่วนตัวและความปลอดภัยของข้อมูลพนักงาน Primus ต้องการติดตั้งใช้งานโมเดลการสร้างโค้ดเพื่อช่วยนักพัฒนาซอฟต์แวร์ในงานการเขียนโค้ด อย่างไรก็ตาม บริษัทกังวลเกี่ยวกับการปกป้องความลับของพรอมต์ที่พนักงานส่ง เนื่องจากพรอมต์เหล่านี้มักมีข้อมูลโค้ดที่ละเอียดอ่อน รายละเอียดโปรเจ็กต์ภายใน หรืออัลกอริทึมที่เป็นกรรมสิทธิ์
ทำไมบริษัท Primus จึงไม่เชื่อถือผู้ให้บริการ
Primus Corp ดำเนินธุรกิจในตลาดที่มีการแข่งขันสูง ฐานโค้ดของบริษัทมีทรัพย์สินทางปัญญาที่มีคุณค่า ซึ่งรวมถึงอัลกอริทึมที่เป็นกรรมสิทธิ์และข้อมูลโค้ดที่ละเอียดอ่อนซึ่งช่วยให้บริษัทมีความได้เปรียบในการแข่งขัน โดยกังวลว่าผู้ให้บริการเวิร์กโหลดอาจจารกรรมข้อมูลของบริษัท นอกจากนี้ พรอมต์ของพนักงานอาจมีส่วนของโค้ดที่เป็นความลับซึ่ง "จำเป็นต้องทราบ" ที่ Primus Corp ต้องการปกป้อง
เพื่อแก้ไขข้อกังวลนี้ Primus Corp จะใช้ประโยชน์จากพื้นที่ที่เชื่อถือได้เพื่อแยกเซิร์ฟเวอร์การอนุมานที่เรียกใช้โมเดลสำหรับการสร้างโค้ด วิธีการมีดังนี้
- การเข้ารหัสพรอมต์: ก่อนส่งพรอมต์ไปยังเซิร์ฟเวอร์การอนุมาน พนักงานแต่ละคนจะเข้ารหัสพรอมต์โดยใช้คีย์ KMS ที่จัดการโดย Primus Corp ใน Google Cloud ซึ่งจะช่วยให้เฉพาะสภาพแวดล้อมของพื้นที่ทำงานที่เชื่อถือได้ซึ่งมีคีย์การถอดรหัสที่เกี่ยวข้องเท่านั้นที่ถอดรหัสและเข้าถึงพรอมต์ข้อความธรรมดาได้ ในสถานการณ์จริง ไลบรารีที่มีอยู่ (เช่น tink) จะจัดการการเข้ารหัสฝั่งไคลเอ็นต์ได้ ใน Codelab นี้ เราจะใช้แอปพลิเคชันไคลเอ็นต์ตัวอย่างนี้ที่มีการเข้ารหัสสองชั้น
- การแยกผู้ให้บริการ: เฉพาะเซิร์ฟเวอร์การอนุมานที่ทำงานภายในสภาพแวดล้อมพื้นที่ที่เชื่อถือได้เท่านั้นที่จะมีสิทธิ์เข้าถึงคีย์ที่ใช้สำหรับการเข้ารหัส และจะถอดรหัสพรอมต์ภายใต้สภาพแวดล้อมที่เชื่อถือได้ Workload Identity Pool จะปกป้องการเข้าถึงคีย์การเข้ารหัส เนื่องจากการรับประกันการแยกของพื้นที่ที่เชื่อถือได้ แม้แต่ผู้ปฏิบัติงานด้านภาระงานก็ไม่สามารถเข้าถึงคีย์ที่ใช้สำหรับการเข้ารหัสและเนื้อหาที่ถอดรหัสแล้ว
- การอนุมานที่ปลอดภัยโดยใช้ตัวเร่งความเร็ว: ระบบจะเปิดเซิร์ฟเวอร์การอนุมานใน Shielded VM (ซึ่งเป็นส่วนหนึ่งของการตั้งค่าพื้นที่ที่เชื่อถือได้) ซึ่งจะช่วยให้มั่นใจได้ว่าอินสแตนซ์ของเวิร์กโหลดจะไม่ถูกมัลแวร์หรือรูทคิตที่ระดับการเปิดเครื่องหรือระดับเคอร์เนลบุกรุก เซิร์ฟเวอร์นี้จะถอดรหัสพรอมต์ภายในสภาพแวดล้อมของพื้นที่ที่เชื่อถือได้ ทำการอนุมานโดยใช้โมเดลการสร้างโค้ด และส่งคืนโค้ดที่สร้างขึ้นให้แก่พนักงาน
2. ตั้งค่าทรัพยากรระบบคลาวด์
ก่อนเริ่มต้น
- โคลน ที่เก็บนี้โดยใช้คำสั่งด้านล่างเพื่อรับสคริปต์ที่จำเป็นซึ่งใช้เป็นส่วนหนึ่งของโค้ดแล็บนี้
git clone https://github.com/GoogleCloudPlatform/confidential-space.git
- เปลี่ยนไดเรกทอรีสำหรับ Codelab นี้
cd confidential-space/codelabs/trusted_space_codelab/scripts
- ตรวจสอบว่าคุณได้ตั้งค่าตัวแปรสภาพแวดล้อมของโปรเจ็กต์ที่จำเป็นตามที่แสดงด้านล่าง ดูข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่าโปรเจ็กต์ GCP ได้ที่ Codelab นี้ คุณดูรายละเอียดเกี่ยวกับวิธีดึงรหัสโปรเจ็กต์และวิธีที่รหัสโปรเจ็กต์แตกต่างจากชื่อโปรเจ็กต์และหมายเลขโปรเจ็กต์ได้ที่นี่
export PRIMUS_PROJECT_ID=<GCP project id of Primus>
- เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์
- เปิดใช้ Confidential Computing API และ API ต่อไปนี้สำหรับทั้ง 2 โปรเจ็กต์
gcloud services enable \
cloudapis.googleapis.com \
cloudresourcemanager.googleapis.com \
cloudkms.googleapis.com \
cloudshell.googleapis.com \
container.googleapis.com \
containerregistry.googleapis.com \
iam.googleapis.com \
confidentialcomputing.googleapis.com
- กำหนดค่าให้กับตัวแปรสำหรับชื่อทรัพยากรที่ระบุไว้ข้างต้นโดยใช้คำสั่งต่อไปนี้ ตัวแปรเหล่านี้ช่วยให้คุณปรับแต่งชื่อทรัพยากรได้ตามต้องการ และยังใช้ทรัพยากรที่มีอยู่ได้หากสร้างไว้แล้ว (เช่น
export PRIMUS_SERVICE_ACCOUNT='my-service-account')
- คุณตั้งค่าตัวแปรต่อไปนี้ได้โดยใช้ชื่อทรัพยากรระบบคลาวด์ที่มีอยู่ในโปรเจ็กต์ Primus หากตั้งค่าตัวแปร ระบบจะใช้ทรัพยากรระบบคลาวด์ที่มีอยู่ซึ่งสอดคล้องกันจากโปรเจ็กต์ Primus หากไม่ได้ตั้งค่าตัวแปร ระบบจะสร้างชื่อทรัพยากรระบบคลาวด์จากชื่อโปรเจ็กต์ และจะสร้างทรัพยากรระบบคลาวด์ใหม่โดยใช้ชื่อนั้น ตัวแปรที่รองรับสำหรับชื่อทรัพยากรมีดังนี้
| ภูมิภาคที่จะสร้างทรัพยากรระดับภูมิภาคสำหรับบริษัท Primus |
| ตำแหน่งที่จะสร้างทรัพยากรสำหรับบริษัท Primus |
| โซนที่จะสร้างทรัพยากรระดับโซนสำหรับบริษัท Primus |
| Workload Identity Pool ของบริษัท Primus สำหรับปกป้องทรัพยากรระบบคลาวด์ |
| ผู้ให้บริการ Workload Identity Pool ของบริษัท Primus ซึ่งรวมถึงเงื่อนไขการให้สิทธิ์ที่จะใช้กับโทเค็นที่ลงนามโดยบริการเครื่องมือตรวจสอบการรับรอง |
| บัญชีบริการของบริษัท Primus ที่ |
| ระบบจะใช้คีย์ KMS เพื่อเข้ารหัสพรอมต์ที่พนักงานของบริษัท Primus ระบุ |
| พวงกุญแจ KMS ที่จะใช้สร้างคีย์การเข้ารหัส |
| เวอร์ชันคีย์ KMS ของคีย์การเข้ารหัส |
| ที่เก็บที่เก็บอาร์ติแฟกต์ที่จะพุชอิมเมจ Docker ของเวิร์กโหลด |
| ภูมิภาคสำหรับที่เก็บที่เก็บอาร์ติแฟกต์ซึ่งจะมีอิมเมจ Docker ของภาระงานที่เผยแพร่ |
| ชื่อ VM ของภาระงาน |
| ชื่อของอิมเมจ Docker ของภาระงาน |
| แท็กของอิมเมจคอนเทนเนอร์ของภาระงาน |
| บัญชีบริการที่มีสิทธิ์เข้าถึง VM ที่ประมวลผลข้อมูลลับซึ่งเรียกใช้ภาระงาน |
| ชื่อของ VM ไคลเอ็นต์ที่จะเรียกใช้แอปพลิเคชันไคลเอ็นต์ของเซิร์ฟเวอร์การอนุมาน |
| บัญชีบริการที่ |
- คุณจะต้องมีบทบาทผู้ดูแลระบบพื้นที่เก็บข้อมูล ผู้ดูแลระบบ Artifact Registry ผู้ดูแลระบบ Cloud KMS ผู้ดูแลระบบบัญชีบริการ และผู้ดูแลระบบ IAM Workload Identity Pool สำหรับโปรเจ็กต์
$PRIMUS_PROJECT_IDคุณดูวิธีมอบบทบาท IAM โดยใช้คอนโซล GCP ได้ในคู่มือนี้ - สำหรับ
$PRIMUS_PROJECT_IDให้เรียกใช้สคริปต์ต่อไปนี้เพื่อตั้งค่าชื่อตัวแปรที่เหลือเป็นค่าตามรหัสโปรเจ็กต์สำหรับชื่อทรัพยากร
source config_env.sh
ตั้งค่าทรัพยากรของบริษัท Primus
ในขั้นตอนนี้ คุณจะต้องตั้งค่าทรัพยากรระบบคลาวด์ที่จำเป็นสำหรับ Primus เรียกใช้สคริปต์ต่อไปนี้เพื่อตั้งค่าทรัพยากรสำหรับ Primus ระบบจะสร้างทรัพยากรต่อไปนี้เป็นส่วนหนึ่งของการเรียกใช้สคริปต์
- คีย์การเข้ารหัส (
$PRIMUS_ENC_KEY) และพวงกุญแจ ($PRIMUS_ENC_KEYRING) ใน KMS เพื่อเข้ารหัสไฟล์ข้อมูลลูกค้าของบริษัท Primus - Workload Identity Pool (
$PRIMUS_WORKLOAD_IDENTITY_POOL) เพื่อตรวจสอบการอ้างสิทธิ์ตามเงื่อนไขของแอตทริบิวต์ที่กำหนดค่าไว้ภายใต้ผู้ให้บริการ - บัญชีบริการ (
$PRIMUS_SERVICE_ACCOUNT) ที่แนบกับพูลการระบุเวิร์กโหลดที่กล่าวถึงข้างต้น ($PRIMUS_WORKLOAD_IDENTITY_POOL) มีสิทธิ์เข้าถึงเพื่อถอดรหัสข้อมูลโดยใช้คีย์ KMS (โดยใช้บทบาทroles/cloudkms.cryptoKeyDecrypter) เข้ารหัสข้อมูลโดยใช้คีย์ KMS (โดยใช้บทบาทroles/cloudkms.cryptoKeyEncrypter) อ่านข้อมูลจากที่เก็บข้อมูล Cloud Storage (โดยใช้บทบาทobjectViewer) และเชื่อมต่อบัญชีบริการกับพูลการระบุเวิร์กโหลด (โดยใช้roles/iam.workloadIdentityUser)
./setup_primus_resources.sh
3. สร้างภาระงาน
สร้างบัญชีบริการของเวิร์กโหลด
ตอนนี้คุณจะสร้างบัญชีบริการสำหรับภาระงานที่มีบทบาทและสิทธิ์ที่จำเป็น เรียกใช้สคริปต์ต่อไปนี้เพื่อสร้างบัญชีบริการของเวิร์กโหลดในโปรเจ็กต์ Primus VM ที่เรียกใช้เซิร์ฟเวอร์การอนุมานจะใช้บัญชีบริการนี้
บัญชีบริการของเวิร์กโหลดนี้ ($WORKLOAD_SERVICEACCOUNT) จะมีบทบาทต่อไปนี้
confidentialcomputing.workloadUserเพื่อรับโทเค็นการรับรองlogging.logWriterเพื่อเขียนบันทึกลงใน Cloud Logging
./create_workload_service_account.sh
สร้างภาระงาน
ในขั้นตอนนี้ คุณจะต้องสร้างอิมเมจ Docker ของภาระงาน ภาระงานจะสร้างโดยบริษัท Primus เวิร์กโหลดที่ใช้ใน Codelab นี้คือโค้ด Python ซึ่งใช้โมเดล CodeGemma จากที่เก็บข้อมูล GCS ที่พร้อมใช้งานแบบสาธารณะ (ของ Vertex Model Garden) เวิร์กโหลดจะโหลดโมเดล CodeGemma และเปิดตัวเซิร์ฟเวอร์การอนุมานที่จะให้บริการคำขอการสร้างโค้ดจากนักพัฒนาซอฟต์แวร์ของ Primus
ในคำขอสร้างโค้ด Workload จะได้รับ DEK ที่ห่อหุ้มพร้อมกับพรอมต์ที่เข้ารหัส จากนั้นเวิร์กโหลดจะเรียกใช้ KMS API เพื่อถอดรหัส DEK แล้วถอดรหัสพรอมต์โดยใช้ DEK นี้ ระบบจะปกป้องคีย์การเข้ารหัส (สำหรับ DEK) ผ่านพูล Workload Identity และจะให้สิทธิ์เข้าถึงแก่เวิร์กโหลดที่มีคุณสมบัติตรงตามเงื่อนไข เงื่อนไขแอตทริบิวต์เหล่านี้จะอธิบายโดยละเอียดในส่วนถัดไปเกี่ยวกับการให้สิทธิ์เวิร์กโหลด เมื่อเซิร์ฟเวอร์การอนุมานมีพรอมต์ที่ถอดรหัสแล้ว เซิร์ฟเวอร์จะสร้างโค้ดโดยใช้โมเดลที่โหลดไว้และจะส่งคืนการตอบกลับ
เรียกใช้สคริปต์ต่อไปนี้เพื่อสร้างภาระงานที่จะดำเนินการตามขั้นตอนต่อไปนี้
- สร้าง Artifact Registry(
$PRIMUS_ARTIFACT_REGISTRY) ที่ Primus เป็นเจ้าของ - อัปเดตโค้ดภาระงานด้วยชื่อทรัพยากรที่จำเป็น
- สร้างภาระงานของเซิร์ฟเวอร์การอนุมานและสร้าง Dockerfile สำหรับสร้างอิมเมจ Docker ของโค้ดภาระงาน ที่นี่คือ Dockerfile ที่ใช้สำหรับ Codelab นี้
- สร้างและเผยแพร่อิมเมจ Docker ไปยัง Artifact Registry (
$PRIMUS_ARTIFACT_REGISTRY) ที่ Primus เป็นเจ้าของ - ให้สิทธิ์อ่านแก่
$WORKLOAD_SERVICEACCOUNTสำหรับ$PRIMUS_ARTIFACT_REGISTRYซึ่งจำเป็นสำหรับคอนเทนเนอร์ภาระงานในการดึงอิมเมจ Docker ของภาระงานจาก Artifact Registry
./create_workload.sh
เพื่อเป็นข้อมูลอ้างอิงของคุณ นี่คือเมธอด generate() ของภาระงานที่สร้างและใช้ใน Codelab นี้ (คุณดูโค้ดภาระงานทั้งหมดได้ที่นี่)
def generate():
try:
data = request.get_json()
ciphertext = base64.b64decode(data["ciphertext"])
wrapped_dek = base64.b64decode(data["wrapped_dek"])
unwrapped_dek_response = kms_client.decrypt(
request={"name": key_name, "ciphertext": wrapped_dek}
)
unwrapped_dek = unwrapped_dek_response.plaintext
f = Fernet(unwrapped_dek)
plaintext = f.decrypt(ciphertext)
prompt = plaintext.decode("utf-8")
tokens = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(**tokens, max_new_tokens=128)
generated_code = tokenizer.decode(outputs[0])
generated_code_bytes = generated_code.encode("utf-8")
response = f.encrypt(generated_code_bytes)
ciphertext_base64 = base64.b64encode(response).decode("utf-8")
response = {"generated_code_ciphertext": ciphertext_base64}
return jsonify(response)
except (ValueError, TypeError, KeyError) as e:
return jsonify({"error": str(e)}), 500
4. ให้สิทธิ์และเรียกใช้เวิร์กโหลด
ให้สิทธิ์ภาระงาน
Primus ต้องการให้สิทธิ์เวิร์กโหลดในการเข้าถึงคีย์ KMS ที่ใช้สำหรับการเข้ารหัสพรอมต์ตามแอตทริบิวต์ของทรัพยากรต่อไปนี้
- อะไร: รหัสที่ได้รับการยืนยัน
- ที่ไหน: สภาพแวดล้อมที่ปลอดภัย
- ใคร: ผู้ให้บริการที่เชื่อถือได้
Primus ใช้การเชื่อมโยงข้อมูลประจำตัวของเวิร์กโหลดเพื่อบังคับใช้นโยบายการเข้าถึงตามข้อกำหนดเหล่านี้ การรวมศูนย์ข้อมูล Workload Identity ช่วยให้คุณระบุเงื่อนไขแอตทริบิวต์ได้ เงื่อนไขเหล่านี้จะจำกัดข้อมูลประจำตัวที่สามารถตรวจสอบสิทธิ์ด้วย Workload Identity Pool (WIP) คุณสามารถเพิ่ม Attestation Verifier Service ลงใน WIP เป็นผู้ให้บริการ Workload Identity Pool เพื่อแสดงการวัดผลและบังคับใช้นโยบาย
ก่อนหน้านี้ได้สร้าง Workload Identity Pool ไว้แล้วเป็นส่วนหนึ่งของขั้นตอนการตั้งค่าทรัพยากรระบบคลาวด์ ตอนนี้ Primus จะสร้างผู้ให้บริการ Workload Identity Pool ของ OIDC ใหม่ --attribute-condition ที่ระบุจะให้สิทธิ์เข้าถึงคอนเทนเนอร์ของภาระงาน โดยต้องมีสิ่งต่อไปนี้
- สิ่งที่ทำ: อัปโหลด
$WORKLOAD_IMAGE_NAMEล่าสุดไปยังที่เก็บ$PRIMUS_ARTIFACT_REPOSITORY - ที่ไหน: สภาพแวดล้อมการดำเนินการที่เชื่อถือได้ของ Confidential Space ทำงานบนอิมเมจ VM ของ Confidential Space ที่รองรับอย่างเต็มรูปแบบ
- ใคร: บัญชีบริการ Primus
$WORKLOAD_SERVICE_ACCOUNT
export WORKLOAD_IMAGE_DIGEST=$(gcloud artifacts docker images describe ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG --format="value(image_summary.digest)" --project ${PRIMUS_PROJECT_ID})
gcloud iam workload-identity-pools providers create-oidc $PRIMUS_WIP_PROVIDER \
--location="global" \
--project="$PRIMUS_PROJECT_ID" \
--workload-identity-pool="$PRIMUS_WORKLOAD_IDENTITY_POOL" \
--issuer-uri="https://confidentialcomputing.googleapis.com/" \
--allowed-audiences="https://sts.googleapis.com" \
--attribute-mapping="google.subject='assertion.sub'" \
--attribute-condition="assertion.swname == 'HARDENED_SHIELDED' && assertion.hwmodel == 'GCP_SHIELDED_VM' &&
assertion.submods.container.image_digest == '${WORKLOAD_IMAGE_DIGEST}' &&
assertion.submods.container.image_reference == '${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG' &&
'$WORKLOAD_SERVICEACCOUNT@$PRIMUS_PROJECT_ID.iam.gserviceaccount.com' in assertion.google_service_accounts"
คำสั่งข้างต้นจะยืนยันว่าภาระงานทำงานในสภาพแวดล้อมพื้นที่ที่เชื่อถือได้โดยตรวจสอบว่า hwmodel ตั้งค่าเป็น "GCP_SHIELDED_VM" และ swname ตั้งค่าเป็น "HARDENED_SHIELDED" นอกจากนี้ ยังมีการยืนยันเฉพาะเวิร์กโหลด เช่น image_digest และ image_reference เพื่อเพิ่มความปลอดภัยและรับประกันความสมบูรณ์ของเวิร์กโหลดที่ทำงานอยู่
เรียกใช้ภาระงาน
ในขั้นตอนนี้ เราจะเรียกใช้เวิร์กโหลดใน VM ของพื้นที่ที่เชื่อถือได้ซึ่งจะมีตัวเร่งที่แนบมา ระบบจะส่งอาร์กิวเมนต์ TEE ที่จำเป็นโดยใช้แฟล็กข้อมูลเมตา อาร์กิวเมนต์สำหรับคอนเทนเนอร์ของเวิร์กโหลดจะส่งผ่านโดยใช้ส่วน "tee-cmd" ของแฟล็ก หากต้องการติดตั้ง GPU Nvidia Tesla T4 ให้กับ VM ของเวิร์กโหลด เราจะใช้แฟล็ก --accelerator=type=nvidia-tesla-t4,count=1 ซึ่งจะเป็นการแนบ GPU 1 ตัวกับ VM นอกจากนี้ เรายังต้องใส่ tee-install-gpu-driver=true ใน Flag ข้อมูลเมตาเพื่อทริกเกอร์การติดตั้งไดรเวอร์ GPU ที่เหมาะสมด้วย
gcloud compute instances create ${WORKLOAD_VM} \
--accelerator=type=nvidia-tesla-t4,count=1 \
--machine-type=n1-standard-16 \
--shielded-secure-boot \
--image-project=conf-space-images-preview \
--image=confidential-space-0-gpupreview-796705b \
--zone=${PRIMUS_PROJECT_ZONE} \
--maintenance-policy=TERMINATE \
--boot-disk-size=40 \
--scopes=cloud-platform \
--service-account=${WORKLOAD_SERVICEACCOUNT}@${PRIMUS_PROJECT_ID}.iam.gserviceaccount.com \
--metadata="^~^tee-image-reference=${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_ARTIFACT_REPOSITORY}/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}~tee-install-gpu-driver=true~tee-restart-policy=Never"
เรียกใช้การค้นหาการอนุมาน
หลังจากเปิดใช้เซิร์ฟเวอร์การอนุมานของเวิร์กโหลดเรียบร้อยแล้ว ตอนนี้พนักงานของบริษัท Primus สามารถส่งคำขอการสร้างโค้ดไปยังเซิร์ฟเวอร์การอนุมานได้แล้ว
ใน Codelab นี้ เราจะใช้สคริปต์ต่อไปนี้เพื่อตั้งค่าแอปพลิเคชันไคลเอ็นต์ที่จะโต้ตอบกับเซิร์ฟเวอร์การอนุมาน เรียกใช้สคริปต์นี้เพื่อตั้งค่า VM ไคลเอ็นต์
./setup_client.sh
ขั้นตอนต่อไปนี้แสดงวิธี SSH ไปยัง VM ไคลเอ็นต์และเรียกใช้แอปพลิเคชันไคลเอ็นต์ตัวอย่างภายในสภาพแวดล้อมเสมือนของ Python แอปพลิเคชันตัวอย่างนี้ใช้การเข้ารหัสซองจดหมายกับไลบรารี Fernet แต่โปรดทราบว่าคุณสามารถปรับไลบรารีการเข้ารหัสที่เฉพาะเจาะจงให้เหมาะกับกรณีการใช้งานต่างๆ ได้
gcloud compute ssh ${CLIENT_VM} --zone=${PRIMUS_PROJECT_ZONE}
เรียกใช้คำสั่งต่อไปนี้เพื่อเปิดใช้งานสภาพแวดล้อมเสมือนของ Python ใน VM ไคลเอ็นต์และเรียกใช้แอปพลิเคชันไคลเอ็นต์
source venv/bin/activate
python3 inference_client.py
เอาต์พุตของแอปพลิเคชันไคลเอ็นต์ตัวอย่างนี้จะแสดงคำขอพรอมต์ที่เข้ารหัสและข้อความธรรมดา รวมถึงการตอบกลับที่เข้ารหัสและถอดรหัสที่เกี่ยวข้อง
5. ล้าง
ที่นี่คือสคริปต์ที่ใช้ล้างข้อมูลทรัพยากรที่เราสร้างขึ้นเป็นส่วนหนึ่งของ Codelab นี้ได้ การล้างข้อมูลนี้จะลบทรัพยากรต่อไปนี้
- บัญชีบริการ Primus (
$PRIMUS_SERVICEACCOUNT) - คีย์การเข้ารหัส Primus (
$PRIMUS_ENC_KEY) - ที่เก็บอาร์ติแฟกต์ของ Primus (
$PRIMUS_ARTIFACT_REPOSITORY) - พูล Workload Identity ของ Primus (
$PRIMUS_WORKLOAD_IDENTITY_POOL) พร้อมผู้ให้บริการ - บัญชีบริการของเวิร์กโหลดของ Primus (
$WORKLOAD_SERVICEACCOUNT) - VM ของภาระงาน (
$WORKLOAD_VM) และ VM ของไคลเอ็นต์ ($CLIENT_VM)
./cleanup.sh
หากสำรวจเสร็จแล้ว โปรดลบโปรเจ็กต์
- ไปที่คอนโซล Cloud Platform
- เลือกโปรเจ็กต์ที่ต้องการปิด แล้วคลิก "ลบ" ที่ด้านบน ซึ่งจะเป็นการกำหนดเวลาให้ลบโปรเจ็กต์