1. ภาพรวม
พร้อมยกระดับความปลอดภัยและความเป็นส่วนตัวของภาระงานที่เร่งด้วย GPU แล้วหรือยัง โค้ดแล็บนี้จะแนะนำความสามารถของ Trusted Space ซึ่งเป็นข้อเสนอที่ให้การสนับสนุนการแยกผู้ดำเนินการที่มีประสิทธิภาพและการสนับสนุนตัวเร่งสำหรับภาระงาน AI/ML ที่มีความละเอียดอ่อน
การปกป้องข้อมูล โมเดล และคีย์ที่มีคุณค่าเป็นสิ่งสำคัญมากกว่าที่เคย Trusted Space นำเสนอโซลูชันโดยการตรวจสอบว่าภาระงานทำงานในสภาพแวดล้อมที่ปลอดภัยและเชื่อถือได้ ซึ่งแม้แต่ผู้ดำเนินการภาระงานก็ไม่มีสิทธิ์เข้าถึง
สิ่งที่พื้นที่ที่เชื่อถือได้มอบให้มีดังนี้
- ความเป็นส่วนตัวและความปลอดภัยที่เพิ่มขึ้น: Trusted Space เป็นสภาพแวดล้อมการเรียกใช้ที่เชื่อถือได้ซึ่งจะปกป้องเนื้อหาที่มีความละเอียดอ่อน (เช่น โมเดล ข้อมูลที่มีค่า และคีย์) ของคุณอยู่เสมอ โดยได้รับการสนับสนุนจากหลักฐานการเข้ารหัส
- การแยกโอเปอเรเตอร์: หมดกังวลเรื่องการแทรกแซงจากโอเปอเรเตอร์ เมื่อใช้พื้นที่ที่เชื่อถือได้ แม้แต่ผู้ปฏิบัติการเวิร์กโหลดก็ไม่มีสิทธิ์เข้าถึง ซึ่งจะป้องกันไม่ให้ผู้ใช้ดังกล่าวใช้ SSH, เข้าถึงข้อมูล, ติดตั้งซอฟต์แวร์ หรือแก้ไขโค้ดของคุณ
- การรองรับโปรแกรมเร่งความเร็ว: พื้นที่ที่เชื่อถือได้ออกแบบมาเพื่อทำงานร่วมกับโปรแกรมเร่งความเร็วฮาร์ดแวร์ได้หลากหลาย รวมถึง GPU เช่น H100, A100, T4 และ L4 วิธีนี้ช่วยให้แอปพลิเคชัน AI/ML ที่สำคัญต่อประสิทธิภาพทำงานได้อย่างราบรื่น
สิ่งที่คุณจะได้เรียนรู้
- ทําความเข้าใจข้อเสนอหลักของพื้นที่ที่เชื่อถือได้
- ดูวิธีทำให้ใช้งานได้และกำหนดค่าสภาพแวดล้อมพื้นที่ที่เชื่อถือได้เพื่อรักษาความปลอดภัยให้กับเนื้อหาที่มีคุณค่าของเวิร์กโหลด AI/Ml
สิ่งที่ต้องมี
- โปรเจ็กต์ Google Cloud Platform
- ความรู้พื้นฐานเกี่ยวกับ Google Compute Engine และ Accelerator
- ความรู้พื้นฐานเกี่ยวกับบัญชีบริการ การจัดการคีย์ การรวมศูนย์ Workload Identity และเงื่อนไขแอตทริบิวต์
- ความรู้พื้นฐานเกี่ยวกับคอนเทนเนอร์และ Artifact Registry
การปกป้องพรอมต์การสร้างโค้ดที่มีความละเอียดอ่อนด้วย Primus Company
ในโค้ดแล็บนี้ เราจะลองสวมบทบาทเป็น Primus ซึ่งเป็นบริษัทที่ให้ความสำคัญกับความเป็นส่วนตัวและความปลอดภัยของข้อมูลพนักงาน Primus ต้องการทำให้โมเดลการสร้างโค้ดใช้งานได้จริงเพื่อช่วยเหลือนักพัฒนาซอฟต์แวร์เกี่ยวกับงานเขียนโค้ด อย่างไรก็ตาม บริษัทกังวลเกี่ยวกับการปกป้องความลับของพรอมต์ที่พนักงานส่งมา เนื่องจากพรอมต์เหล่านี้มักมีข้อมูลโค้ดที่ละเอียดอ่อน รายละเอียดโปรเจ็กต์ภายใน หรืออัลกอริทึมที่เป็นเจ้าของ
เหตุใดบริษัท Primus จึงไม่เชื่อถือผู้ให้บริการ
Primus Corp ดำเนินธุรกิจในตลาดที่มีการแข่งขันสูง โค้ดเบสมีทรัพย์สินทางปัญญาที่มีคุณค่า รวมถึงอัลกอริทึมที่เป็นกรรมสิทธิ์และข้อมูลโค้ดที่มีความละเอียดอ่อนซึ่งช่วยให้ได้เปรียบในการแข่งขัน พวกเขากังวลเกี่ยวกับโอกาสที่จะมีกิจกรรมจารกรรมของบริษัทโดยผู้ดำเนินการเกี่ยวกับปริมาณงาน นอกจากนี้ พรอมต์ของพนักงานอาจรวมถึงส่วน "จําเป็นต้องทราบ" ของโค้ดซึ่งเป็นความลับที่ Primus Corp ต้องการปกป้อง
Primus Corp จะใช้พื้นที่ที่เชื่อถือได้เพื่อแยกเซิร์ฟเวอร์การอนุมานที่ใช้โมเดลในการสร้างโค้ด เพื่อคลายข้อกังวลนี้ วิธีการมีดังนี้
- การเข้ารหัสพรอมต์: ก่อนส่งพรอมต์ไปยังเซิร์ฟเวอร์การอนุมาน พนักงานแต่ละคนจะเข้ารหัสพรอมต์โดยใช้คีย์ KMS ที่ Primus Corp จัดการใน Google Cloud วิธีนี้ช่วยให้มั่นใจได้ว่ามีเพียงสภาพแวดล้อมของพื้นที่ทำงานที่เชื่อถือซึ่งมีคีย์การถอดรหัสที่เกี่ยวข้องเท่านั้นที่จะถอดรหัสและเข้าถึงพรอมต์ที่เป็นข้อความธรรมดาได้ ในสถานการณ์จริง การเข้ารหัสฝั่งไคลเอ็นต์จะจัดการโดยไลบรารีที่มีอยู่ (เช่น tink) ใน Codelab นี้ เราจะใช้แอปพลิเคชันไคลเอ็นต์ตัวอย่างนี้กับการเข้ารหัสสองชั้น
- การแยกผู้ดำเนินการ: เฉพาะเซิร์ฟเวอร์การอนุมานที่ทำงานภายในสภาพแวดล้อมพื้นที่ที่เชื่อถือเท่านั้นที่จะเข้าถึงคีย์ที่ใช้สําหรับการเข้ารหัสได้ และจะสามารถถอดรหัสพรอมต์ภายใต้สภาพแวดล้อมที่เชื่อถือได้ การเข้าถึงคีย์การเข้ารหัสจะได้รับการปกป้องโดยพูล Workload Identity แม้แต่ผู้ดำเนินการเวิร์กโหลดก็ไม่สามารถเข้าถึงคีย์ที่ใช้สําหรับการเข้ารหัสและเนื้อหาที่ถอดรหัสแล้วได้ เนื่องจากมีการรับประกันการแยกพื้นที่ทำงานของพื้นที่ที่เชื่อถือ
- การอนุมานที่ปลอดภัยโดยใช้ตัวเร่ง: ระบบจะเปิดเซิร์ฟเวอร์การอนุมานใน VM ที่มีการป้องกัน (เป็นส่วนหนึ่งของการตั้งค่าพื้นที่ที่เชื่อถือได้) ซึ่งจะช่วยให้มั่นใจว่าอินสแตนซ์ของเวิร์กโหลดไม่ได้รับผลกระทบจากมัลแวร์หรือ Rootkit ที่ระดับการบูตหรือเคอร์เนล เซิร์ฟเวอร์นี้จะถอดรหัสพรอมต์ภายในสภาพแวดล้อมของพื้นที่ที่เชื่อถือ ทำการอนุมานโดยใช้รูปแบบการสร้างโค้ด และส่งโค้ดที่สร้างขึ้นกลับไปยังพนักงาน
2. ตั้งค่าทรัพยากรระบบคลาวด์
ก่อนเริ่มต้น
- โคลน ที่เก็บนี้โดยใช้คําสั่งด้านล่างเพื่อรับสคริปต์ที่จําเป็นซึ่งใช้ในโค้ดแล็บนี้
git clone https://github.com/GoogleCloudPlatform/confidential-space.git
- เปลี่ยนไดเรกทอรีของ Codelab นี้
cd confidential-space/codelabs/trusted_space_codelab/scripts
- ตรวจสอบว่าคุณได้ตั้งค่าตัวแปรสภาพแวดล้อมของโปรเจ็กต์ที่จําเป็นดังที่แสดงด้านล่าง ดูข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่าโปรเจ็กต์ GCP ได้ที่ โค้ดแล็บนี้ โปรดดูรายละเอียดเกี่ยวกับวิธีเรียกข้อมูลรหัสโปรเจ็กต์และความแตกต่างระหว่างรหัสโปรเจ็กต์กับชื่อโปรเจ็กต์และหมายเลขโปรเจ็กต์ได้ที่นี่
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 หากไม่ได้ตั้งค่าตัวแปร ระบบจะสร้างชื่อทรัพยากรระบบคลาวด์จาก project-name และสร้างทรัพยากรระบบคลาวด์ใหม่โดยใช้ชื่อนั้น ตัวแปรที่รองรับสำหรับชื่อทรัพยากรมีดังนี้
| ภูมิภาคที่จะสร้างทรัพยากรระดับภูมิภาคสำหรับบริษัท Primus |
| ตำแหน่งที่จะสร้างทรัพยากรสําหรับบริษัท Primus |
| โซนที่จะสร้างทรัพยากรระดับโซนสำหรับบริษัท Primus |
| Workload Identity Pool ของบริษัท Primus เพื่อปกป้องทรัพยากรในระบบคลาวด์ |
| ผู้ให้บริการ Workload Identity Pool ของบริษัท Primus ซึ่งระบุเงื่อนไขการให้สิทธิ์เพื่อใช้กับโทเค็นที่ Service Attestation Verifier ลงนาม |
| บัญชีบริการของบริษัท Primus ที่ |
| ระบบจะใช้คีย์ KMS เพื่อเข้ารหัสพรอมต์ที่พนักงานของบริษัท Primus ระบุ |
| กระเป๋าสตางค์ KMS ที่จะใช้สําหรับสร้างคีย์การเข้ารหัส |
| เวอร์ชันคีย์ KMS ของคีย์การเข้ารหัส |
| ที่เก็บอาร์ติแฟกต์ที่จะพุชอิมเมจ Docker ของเวิร์กโหลด |
| ภูมิภาคสำหรับที่เก็บอาร์ติแฟกต์ซึ่งจะมีอิมเมจ Docker ของภาระงานที่เผยแพร่ |
| ชื่อ VM ของภาระงาน |
| ชื่อของอิมเมจ Docker ของภาระงาน |
| แท็กของอิมเมจคอนเทนเนอร์ของภาระงาน |
| บัญชีบริการที่มีสิทธิ์เข้าถึง VM ข้อมูลที่เป็นความลับซึ่งเรียกใช้ภาระงาน |
| ชื่อ VM ของลูกค้าที่จะเรียกใช้แอปพลิเคชันไคลเอ็นต์ของเซิร์ฟเวอร์การอนุมาน |
| บัญชีบริการที่ |
- คุณจะต้องมีบทบาทผู้ดูแลระบบพื้นที่เก็บข้อมูล ผู้ดูแลระบบรีจิสทรีอาร์ติแฟกต์ ผู้ดูแลระบบ Cloud KMS ผู้ดูแลระบบบัญชีบริการ ผู้ดูแลระบบกลุ่มข้อมูลประจำตัวของภาระงาน IAM สำหรับโปรเจ็กต์
$PRIMUS_PROJECT_IDโปรดดูคู่มือนี้เกี่ยวกับวิธีมอบบทบาท IAM โดยใช้คอนโซล GCP - สําหรับ
$PRIMUS_PROJECT_IDให้เรียกใช้สคริปต์ต่อไปนี้เพื่อตั้งค่าชื่อตัวแปรที่เหลือเป็นค่าตามรหัสโปรเจ็กต์สําหรับชื่อทรัพยากร
source config_env.sh
ตั้งค่าทรัพยากรของ Primus Company
ในขั้นตอนนี้ คุณจะต้องตั้งค่าทรัพยากรระบบคลาวด์ที่จำเป็นสำหรับ 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) อ่านข้อมูลจากที่เก็บข้อมูลระบบคลาวด์ (โดยใช้บทบาทobjectViewer) และเชื่อมต่อบัญชีบริการกับพูลข้อมูลระบุตัวตนของเวิร์กโหลด (โดยใช้roles/iam.workloadIdentityUser)
./setup_primus_resources.sh
3. สร้างภาระงาน
สร้างบัญชีบริการของ Workload
ตอนนี้คุณจะต้องสร้างบัญชีบริการสำหรับเวิร์กโหลดที่มีบทบาทและสิทธิ์ที่จำเป็น เรียกใช้สคริปต์ต่อไปนี้เพื่อสร้างบัญชีบริการเวิร์กโหลดในโปรเจ็กต์ Primus VM ที่เรียกใช้เซิร์ฟเวอร์การอนุมานจะใช้บัญชีบริการนี้
บัญชีบริการของเวิร์กโหลดนี้ ($WORKLOAD_SERVICEACCOUNT) จะมีบทบาทต่อไปนี้
confidentialcomputing.workloadUserเพื่อรับโทเค็นการรับรองlogging.logWriterเพื่อเขียนบันทึกไปยัง Cloud Logging
./create_workload_service_account.sh
สร้างภาระงาน
ในขั้นตอนนี้ คุณจะต้องสร้างอิมเมจ Docker ของภาระงาน ภาระงานจะเขียนโดยบริษัท Primus เวิร์กโหลดที่ใช้ใน Codelab นี้คือโค้ด Python ที่ใช้โมเดล codegemma จากที่เก็บข้อมูล GCS ที่เผยแพร่ต่อสาธารณะ (ของสวนโมเดล Vertex) เวิร์กโหลดจะโหลดโมเดล 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 - ให้สิทธิ์อ่าน
$PRIMUS_ARTIFACT_REGISTRYแก่$WORKLOAD_SERVICEACCOUNTซึ่งจำเป็นสำหรับคอนเทนเนอร์ภาระงานในการดึงอิมเมจ 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) ได้ คุณสามารถเพิ่มบริการโปรแกรมตรวจสอบความถูกต้องไปยัง WIP ในฐานะผู้ให้บริการ Workload Identity Pool เพื่อแสดงการวัดผลและบังคับใช้นโยบาย
ระบบได้สร้าง Workload Identity Pool ไว้แล้วก่อนหน้านี้ในขั้นตอนการตั้งค่าทรัพยากรระบบคลาวด์ ตอนนี้ Primus จะสร้างผู้ให้บริการ Workload Identity Pool ของ OIDC ใหม่ --attribute-condition ที่ระบุจะให้สิทธิ์เข้าถึงคอนเทนเนอร์ภาระงาน โดยต้องมีสิ่งต่อไปนี้
- สิ่งที่ทำ:
$WORKLOAD_IMAGE_NAMEล่าสุดที่อัปโหลดไปยังที่เก็บ$PRIMUS_ARTIFACT_REPOSITORY - ตำแหน่ง: สภาพแวดล้อมการดำเนินการที่เชื่อถือได้ของพื้นที่ทำงานที่เป็นความลับกำลังทำงานบนอิมเมจ VM ของพื้นที่ทำงานที่เป็นความลับที่รองรับอย่างเต็มรูปแบบ
- ผู้ใช้: บัญชีบริการ
$WORKLOAD_SERVICE_ACCOUNTของ Primus
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 ที่จำเป็นโดยใช้Flag ข้อมูลเมตา ระบบจะส่งอาร์กิวเมนต์สำหรับคอนเทนเนอร์เวิร์กโหลดโดยใช้ส่วน "tee-cmd" ของ Flag หากต้องการติดตั้ง GPU Nvidia Tesla T4 ให้กับ VM ของเวิร์กโหลด เราจะใช้ Flag --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
หากสำรวจเสร็จแล้ว โปรดพิจารณาลบโปรเจ็กต์
- ไปที่คอนโซลแพลตฟอร์มระบบคลาวด์
- เลือกโปรเจ็กต์ที่ต้องการปิด แล้วคลิก "ลบ" ที่ด้านบน ซึ่งจะเป็นการกำหนดเวลาการลบโปรเจ็กต์