การรักษาความปลอดภัยของโมเดล ML และทรัพย์สินทางปัญญาโดยใช้ Confidential Space

1. ภาพรวม

พื้นที่ทำงานลับมีสภาพแวดล้อมที่ปลอดภัยสำหรับการทำงานร่วมกันระหว่างหลายฝ่าย Codelab นี้แสดงวิธีใช้ Confidential Space เพื่อปกป้องทรัพย์สินทางปัญญาที่ละเอียดอ่อน เช่น โมเดลแมชชีนเลิร์นนิง

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

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

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

วิธีกำหนดค่าสภาพแวดล้อมที่ฝ่ายหนึ่งสามารถแชร์โมเดล ML ที่เป็นกรรมสิทธิ์ของตนกับอีกฝ่ายหนึ่งได้โดยไม่สูญเสียการควบคุมทรัพย์สินทางปัญญา

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

โปรเจ็กต์ Google Cloud Platform
มีความรู้พื้นฐานเกี่ยวกับ Google Compute Engine ( Codelab), Confidential VM, คอนเทนเนอร์ และที่เก็บข้อมูลระยะไกล
ความรู้พื้นฐานเกี่ยวกับบัญชีบริการ การรวมศูนย์ของ Workload Identity และเงื่อนไขของแอตทริบิวต์

บทบาทที่เกี่ยวข้องกับการตั้งค่าพื้นที่ทำงานลับ

ในโค้ดแล็บนี้ บริษัท Primus จะเป็นเจ้าของทรัพยากรและผู้เขียนเวิร์กโหลด ซึ่งจะรับผิดชอบในส่วนต่อไปนี้

การตั้งค่าทรัพยากรระบบคลาวด์ที่จำเป็นด้วยโมเดลแมชชีนเลิร์นนิง
การเขียนโค้ดภาระงาน
การเผยแพร่รูปภาพของภาระงาน
การกำหนดค่านโยบาย Workload Identity Pool เพื่อปกป้องโมเดล ML จากผู้ปฏิบัติงานที่ไม่น่าเชื่อถือ

Secundus Company จะเป็นผู้ให้บริการและรับผิดชอบในเรื่องต่อไปนี้

การตั้งค่าทรัพยากรระบบคลาวด์ที่จำเป็นเพื่อจัดเก็บรูปภาพตัวอย่างที่ภาระงานใช้และผลลัพธ์
การเรียกใช้เวิร์กโหลด ML ใน Confidential Space โดยใช้โมเดลที่ Primus จัดหาให้

วิธีการทำงานของพื้นที่ส่วนตัว

เมื่อคุณเรียกใช้เวิร์กโหลดใน Confidential Space กระบวนการต่อไปนี้จะเกิดขึ้นโดยใช้ทรัพยากรที่กำหนดค่าไว้

ภาระงานขอโทเค็นการเข้าถึง Google ทั่วไปสำหรับ $PRIMUS_SERVICEACCOUNT จาก Workload Identity Pool โดยจะเสนอโทเค็นบริการ Attestation Verifier พร้อมการอ้างสิทธิ์ของภาระงานและสภาพแวดล้อม
หากการอ้างสิทธิ์การวัดภาระงานในโทเค็นบริการเครื่องมือตรวจสอบการรับรองตรงกับเงื่อนไขแอตทริบิวต์ใน WIP ระบบจะแสดงโทเค็นเพื่อการเข้าถึงสำหรับ $PRIMUS_SERVICEACCOUNT.
เวิร์กโหลดใช้โทเค็นเพื่อการเข้าถึงบัญชีบริการที่เชื่อมโยงกับ $PRIMUS_SERVICEACCOUNT เพื่อเข้าถึงโมเดลแมชชีนเลิร์นนิงที่จัดเก็บไว้ในที่เก็บข้อมูล $PRIMUS_INPUT_STORAGE_BUCKET
ภาระงานจะดำเนินการกับข้อมูลที่เป็นของ Secundus และ Secundus จะเป็นผู้ดำเนินการและเรียกใช้ภาระงานนั้นในโปรเจ็กต์ของตน
เวิร์กโหลดใช้บัญชีบริการ $WORKLOAD_SERVICEACCOUNT เพื่อเขียนผลลัพธ์ของการดำเนินการนั้นไปยัง Bucket $SECUNDUS_RESULT_STORAGE_BUCKET

2. ตั้งค่าทรัพยากรระบบคลาวด์

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

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

git clone https://github.com/GoogleCloudPlatform/confidential-space.git

เปลี่ยนไดเรกทอรีสำหรับ Codelab นี้

cd confidential-space/codelabs/ml_model_protection/scripts

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

export PRIMUS_PROJECT_ID=<GCP project id of Primus>
export SECUNDUS_PROJECT_ID=<GCP project id of Secundus>

เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์
เปิดใช้ Confidential Computing API และ API ต่อไปนี้สำหรับทั้ง 2 โปรเจ็กต์

gcloud services enable \
    cloudapis.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudshell.googleapis.com \
    container.googleapis.com \
    containerregistry.googleapis.com \
    iam.googleapis.com \
    confidentialcomputing.googleapis.com

กำหนดค่าให้กับตัวแปรสำหรับชื่อทรัพยากรที่ระบุไว้ข้างต้นโดยใช้คำสั่งต่อไปนี้ ตัวแปรเหล่านี้ช่วยให้คุณปรับแต่งชื่อทรัพยากรได้ตามต้องการ และยังใช้ทรัพยากรที่มีอยู่ได้หากสร้างไว้แล้ว (เช่น export PRIMUS_INPUT_STORAGE_BUCKET='my-input-bucket')

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

`$PRIMUS_INPUT_STORAGE_BUCKET`	ที่เก็บข้อมูลที่จัดเก็บโมเดลแมชชีนเลิร์นนิงของ Primus
`$PRIMUS_WORKLOAD_IDENTITY_POOL`	Workload Identity Pool (WIP) ของ Primus ที่ตรวจสอบการอ้างสิทธิ์
`$PRIMUS_WIP_PROVIDER`	ผู้ให้บริการกลุ่ม Workload Identity ของ Primus ซึ่งรวมถึงเงื่อนไขการให้สิทธิ์ที่จะใช้สำหรับโทเค็นที่ลงนามโดยบริการ Attestation Verifier
`$PRIMUS_SERVICE_ACCOUNT`	บัญชีบริการ Primus ที่ `$PRIMUS_WORKLOAD_IDENTITY_POOL` ใช้เพื่อเข้าถึงทรัพยากรที่ได้รับการปกป้อง (โมเดล ML ในโค้ดแล็บนี้) ในขั้นตอนนี้จะมีสิทธิ์อ่านโมเดลแมชชีนเลิร์นนิงที่จัดเก็บไว้ในที่เก็บข้อมูล `$PRIMUS_INPUT_STORAGE_BUCKET`
`$PRIMUS_ARTIFACT_REPOSITORY`	ที่เก็บที่เก็บอาร์ติแฟกต์ที่จะพุชอิมเมจ Docker ของเวิร์กโหลด

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

`$SECUNDUS_INPUT_STORAGE_BUCKET`	ที่เก็บข้อมูลที่จัดเก็บรูปภาพตัวอย่างที่ Secundus ต้องการจัดประเภทโดยใช้โมเดลที่ Primus จัดหาให้
`$SECUNDUS_RESULT_STORAGE_BUCKET`	ที่เก็บข้อมูลที่จัดเก็บผลลัพธ์ของภาระงาน
`$WORKLOAD_IMAGE_NAME`	ชื่อของอิมเมจคอนเทนเนอร์ของภาระงาน
`$WORKLOAD_IMAGE_TAG`	แท็กของอิมเมจคอนเทนเนอร์ของภาระงาน
`$WORKLOAD_SERVICE_ACCOUNT`	บัญชีบริการที่มีสิทธิ์เข้าถึง VM ที่ประมวลผลข้อมูลลับซึ่งเรียกใช้ภาระงาน

คุณจะต้องมีสิทธิ์บางอย่างสำหรับโปรเจ็กต์ทั้ง 2 นี้ และดูวิธีมอบบทบาท IAM โดยใช้คอนโซล GCP ได้ในคู่มือนี้
สำหรับ $PRIMUS_PROJECT_ID คุณจะต้องมีผู้ดูแลระบบพื้นที่เก็บข้อมูล ผู้ดูแลระบบ Artifact Registry ผู้ดูแลระบบบัญชีบริการ และผู้ดูแลระบบพูล Workload Identity ของ IAM
สำหรับ $SECUNDUS_PROJECT_ID คุณจะต้องมีผู้ดูแลระบบ Compute, ผู้ดูแลระบบพื้นที่เก็บข้อมูล, ผู้ดูแลระบบบัญชีบริการ, ผู้ดูแลระบบพูล Workload Identity ของ IAM, ผู้ดูแลระบบความปลอดภัย (ไม่บังคับ)
เรียกใช้สคริปต์ต่อไปนี้เพื่อตั้งค่าชื่อตัวแปรที่เหลือเป็นค่าตามรหัสโปรเจ็กต์สำหรับชื่อทรัพยากร

source config_env.sh

ตั้งค่าทรัพยากรของบริษัท Primus

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

ที่เก็บข้อมูล Cloud Storage ($PRIMUS_INPUT_STORAGE_BUCKET) เพื่อจัดเก็บโมเดลแมชชีนเลิร์นนิงของ Primus
Workload Identity Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) เพื่อตรวจสอบการอ้างสิทธิ์ตามเงื่อนไขแอตทริบิวต์ที่กำหนดค่าไว้ภายใต้ผู้ให้บริการ
บัญชีบริการ ($PRIMUS_SERVICEACCOUNT) ที่แนบกับพูล Workload Identity ที่กล่าวถึงข้างต้น ($PRIMUS_WORKLOAD_IDENTITY_POOL) พร้อมสิทธิ์เข้าถึง IAM เพื่ออ่านข้อมูลจากที่เก็บข้อมูล Cloud Storage (ใช้บทบาท objectViewer) และสำหรับการเชื่อมต่อบัญชีบริการนี้กับพูล Workload Identity (ใช้บทบาท roles/iam.workloadIdentityUser)

เราจะใช้โมเดล TensorFlow ในการตั้งค่าทรัพยากรระบบคลาวด์นี้ เราสามารถบันทึกโมเดลทั้งหมดซึ่งรวมถึงสถาปัตยกรรม น้ำหนัก และการกำหนดค่าการฝึกในไฟล์ ZIP เพื่อวัตถุประสงค์ของโค้ดแล็บนี้ เราจะใช้โมเดล MobileNet V1 ที่ฝึกในชุดข้อมูล ImageNet ซึ่งดูได้ที่นี่

./setup_primus_company_resources.sh

สคริปต์ที่กล่าวถึงข้างต้นจะตั้งค่าทรัพยากรระบบคลาวด์ ตอนนี้เราจะดาวน์โหลดและเผยแพร่โมเดลไปยังที่เก็บข้อมูล Cloud Storage ที่สร้างโดยสคริปต์

ดาวน์โหลดโมเดลที่ผ่านการฝึกมาก่อนแล้วได้ที่นี่
เมื่อดาวน์โหลดแล้ว ให้เปลี่ยนชื่อไฟล์ tar ที่ดาวน์โหลดเป็น model.tar.gz
เผยแพร่ไฟล์ model.tar.gz ไปยังที่เก็บข้อมูล Cloud Storage โดยใช้คำสั่งต่อไปนี้จากไดเรกทอรีที่มีไฟล์ model.tar.gz

gsutil cp model.tar.gz gs://${PRIMUS_INPUT_STORAGE_BUCKET}/

ตั้งค่าทรัพยากรของบริษัท Secundus

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

Bucket ของ Cloud Storage ($SECUNDUS_INPUT_STORAGE_BUCKET) เพื่อจัดเก็บรูปภาพตัวอย่างสำหรับการเรียกใช้การอนุมานโดย Secundus
ที่เก็บข้อมูล Cloud Storage ($SECUNDUS_RESULT_STORAGE_BUCKET) เพื่อจัดเก็บผลลัพธ์ของการเรียกใช้ภาระงาน ML โดย Secundus

เราได้จัดเตรียมรูปภาพตัวอย่างบางส่วนไว้ที่นี่สำหรับโค้ดแล็บนี้

./setup_secundus_company_resources.sh

3. สร้างภาระงาน

สร้างบัญชีบริการของเวิร์กโหลด

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

บัญชีบริการของเวิร์กโหลดนี้ ($WORKLOAD_SERVICEACCOUNT) จะมีบทบาทต่อไปนี้

confidentialcomputing.workloadUser เพื่อรับโทเค็นการรับรอง
logging.logWriter เพื่อเขียนบันทึกลงใน Cloud Logging
objectViewer เพื่ออ่านข้อมูลจาก $SECUNDUS_INPUT_STORAGE_BUCKET Cloud Storage Bucket
objectUser เพื่อเขียนผลลัพธ์ของภาระงานไปยัง $SECUNDUS_RESULT_STORAGE_BUCKET Bucket ของ Cloud Storage

./create_workload_service_account.sh

สร้างภาระงาน

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

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

ต่อไปนี้คือเมธอด run_inference() ของเวิร์กโหลดที่จะสร้างและใช้ใน Codelab นี้ ดูโค้ดเวิร์กโหลดทั้งหมดได้ที่นี่

def run_inference(image_path, model):
  try:
    # Read and preprocess the image
    image = tf.image.decode_image(tf.io.read_file(image_path), channels=3)
    image = tf.image.resize(image, (128, 128))
    image = tf.image.convert_image_dtype(image, tf.float32)
    image = tf.expand_dims(image, axis=0)

    # Get predictions from the model
    predictions = model(image)
    predicted_class = np.argmax(predictions)

    top_k = 5
    top_indices = np.argsort(predictions[0])[-top_k:][::-1]

    # Convert top_indices to a TensorFlow tensor
    top_indices_tensor = tf.convert_to_tensor(top_indices, dtype=tf.int32)

    # Use TensorFlow tensor for indexing
    top_scores = tf.gather(predictions[0], top_indices_tensor)

    return {
        "predicted_class": int(predicted_class),
        "top_k_predictions": [
            {"class_index": int(idx), "score": float(score)}
            for idx, score in zip(top_indices, top_scores)
        ],
    }
  except Exception as e:
    return {"error": str(e)}

เรียกใช้สคริปต์ต่อไปนี้เพื่อสร้างภาระงานที่จะดำเนินการตามขั้นตอนต่อไปนี้

สร้าง Artifact Registry($PRIMUS_ARTIFACT_REGISTRY) ที่ Primus เป็นเจ้าของ
อัปเดตโค้ดภาระงานด้วยชื่อทรัพยากรที่จำเป็น
สร้างภาระงาน ML และสร้าง Dockerfile สำหรับสร้างอิมเมจ Docker ของโค้ดภาระงาน ที่นี่คือ Dockerfile ที่ใช้สำหรับ Codelab นี้
สร้างและเผยแพร่อิมเมจ Docker ไปยัง Artifact Registry ($PRIMUS_ARTIFACT_REGISTRY) ที่ Primus เป็นเจ้าของ
ให้สิทธิ์อ่านแก่ $WORKLOAD_SERVICEACCOUNT สำหรับ $PRIMUS_ARTIFACT_REGISTRY ซึ่งจำเป็นสำหรับคอนเทนเนอร์ภาระงานในการดึงอิมเมจ Docker ของภาระงานจาก Artifact Registry

./create_workload.sh

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

4. ให้สิทธิ์และเรียกใช้เวิร์กโหลด

ให้สิทธิ์ภาระงาน

Primus ต้องการให้สิทธิ์เวิร์กโหลดเข้าถึงโมเดลแมชชีนเลิร์นนิงตามแอตทริบิวต์ของทรัพยากรต่อไปนี้

อะไร: รหัสที่ได้รับการยืนยัน
ที่ไหน: สภาพแวดล้อมที่ปลอดภัย
ใคร: ผู้ให้บริการที่เชื่อถือได้

Primus ใช้การเชื่อมโยงข้อมูลประจำตัวของเวิร์กโหลดเพื่อบังคับใช้นโยบายการเข้าถึงตามข้อกำหนดเหล่านี้ การรวมศูนย์ข้อมูลระบบตัวตนของภาระงานช่วยให้คุณระบุเงื่อนไขแอตทริบิวต์ได้ เงื่อนไขเหล่านี้จะจำกัดข้อมูลประจำตัวที่สามารถตรวจสอบสิทธิ์ด้วย 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 ที่รองรับอย่างเต็มรูปแบบ
ใคร: บัญชีบริการ Secundus $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 config set project $PRIMUS_PROJECT_ID

gcloud iam workload-identity-pools providers create-oidc $PRIMUS_WIP_PROVIDER \
  --location="global" \
  --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 == 'CONFIDENTIAL_SPACE' && 
'STABLE' in assertion.submods.confidential_space.support_attributes && 
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@$SECUNDUS_PROJECT_ID.iam.gserviceaccount.com' in assertion.google_service_accounts"

เรียกใช้ภาระงาน

ในขั้นตอนนี้ เราจะเรียกใช้เวิร์กโหลดใน VM ของ Confidential Space ระบบจะส่งอาร์กิวเมนต์ TEE ที่จำเป็นโดยใช้แฟล็กข้อมูลเมตา อาร์กิวเมนต์สำหรับคอนเทนเนอร์ของเวิร์กโหลดจะส่งผ่านโดยใช้ส่วน "tee-cmd" ของแฟล็ก ผลการดำเนินการของเวิร์กโหลดจะเผยแพร่ไปยัง $SECUNDUS_RESULT_STORAGE_BUCKET

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --project=${SECUNDUS_PROJECT_ID} \
 --maintenance-policy=MIGRATE \
 --scopes=cloud-platform --zone=${SECUNDUS_PROJECT_ZONE} \
 --image-project=confidential-space-images \
 --image-family=confidential-space \
 --service-account=${WORKLOAD_SERVICEACCOUNT}@${SECUNDUS_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}

หมายเหตุ: คุณใช้ตระกูลรูปภาพได้ 2 ตระกูลสำหรับอินสแตนซ์ ได้แก่ confidential-space-debug และ confidential-space คุณจะเลือกใช้ตัวเลือกใดตัวเลือกหนึ่งก็ได้ ความแตกต่างหลักคือ confidential-space จะปิดใช้บริการซึ่งไม่อนุญาตให้ผู้ปฏิบัติงานรบกวนเวิร์กโหลด ในขณะที่ confidential-space-debug จะเปิดใช้ SSH และผู้ปฏิบัติงานสามารถ SSH เข้าสู่ VM ได้ ซึ่งจะช่วยให้ผู้ให้บริการแก้ไขข้อบกพร่องได้ (แต่บริการการรับรองจะบันทึกในโทเค็นการรับรองว่ามีการเปิดใช้สถานะการแก้ไขข้อบกพร่อง) อย่างไรก็ตาม คุณจะต้องปิด VM ด้วยตนเองในภายหลัง

ดูผลลัพธ์

หลังจากเวิร์กโหลดเสร็จสมบูรณ์แล้ว ระบบจะเผยแพร่ผลลัพธ์ของเวิร์กโหลด ML ไปยัง $SECUNDUS_RESULT_STORAGE_BUCKET

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

ตัวอย่างผลลัพธ์การอนุมานในรูปภาพตัวอย่างมีดังนี้

Image: sample_image_1.jpeg, Response: {'predicted_class': 531, 'top_k_predictions': [{'class_index': 531, 'score': 12.08437442779541}, {'class_index': 812, 'score': 10.269512176513672}, {'class_index': 557, 'score': 9.202644348144531}, {'class_index': 782, 'score': 9.08737564086914}, {'class_index': 828, 'score': 8.912498474121094}]}

Image: sample_image_2.jpeg, Response: {'predicted_class': 905, 'top_k_predictions': [{'class_index': 905, 'score': 9.53619384765625}, {'class_index': 557, 'score': 7.928380966186523}, {'class_index': 783, 'score': 7.70129919052124}, {'class_index': 531, 'score': 7.611623287200928}, {'class_index': 906, 'score': 7.021416187286377}]}

Image: sample_image_3.jpeg, Response: {'predicted_class': 905, 'top_k_predictions': [{'class_index': 905, 'score': 6.09878396987915}, {'class_index': 447, 'score': 5.992854118347168}, {'class_index': 444, 'score': 5.9582319259643555}, {'class_index': 816, 'score': 5.502010345458984}, {'class_index': 796, 'score': 5.450454235076904}]}

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

ดัชนีของ predicted_class: นี่คือดัชนีตัวเลขที่แสดงถึงคลาสที่โมเดลคาดการณ์ว่ารูปภาพเป็นของคลาสใด
Top_k_predictions: แสดงการคาดการณ์สูงสุด k รายการสำหรับรูปภาพ โดยจัดอันดับจากความเป็นไปได้มากที่สุดไปน้อยที่สุด ค่าของ k ตั้งไว้ที่ 5 ในโค้ดแล็บนี้ แต่คุณสามารถปรับค่าในโค้ดภาระงานเพื่อรับการคาดการณ์มากขึ้นหรือน้อยลงได้

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

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

เรียกใช้ภาระงานที่ไม่ได้รับอนุญาต

Secundus เปลี่ยนอิมเมจของภาระงานโดยการดึงอิมเมจของภาระงานอื่นจากที่เก็บที่เก็บอาร์ติแฟกต์ของตนเองซึ่ง Primus ไม่ได้ให้สิทธิ์ พูล Workload Identity ของ Primus ได้ให้สิทธิ์เฉพาะ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAGอิมเมจของภาระงาน

เรียกใช้ภาระงานอีกครั้ง

เมื่อ Secundus พยายามเรียกใช้เวิร์กโหลดเดิมด้วยอิมเมจเวิร์กโหลดใหม่นี้ ระบบจะเรียกใช้ไม่สำเร็จ หากต้องการดูข้อผิดพลาด ให้ลบไฟล์ผลลัพธ์และอินสแตนซ์ VM เดิม แล้วลองเรียกใช้เวิร์กโหลดอีกครั้ง

โปรดตรวจสอบว่ามีการเผยแพร่อิมเมจ Docker ใหม่ภายใต้ Artifact Registry ของ Secundus (เป็น us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}) และบัญชีบริการของเวิร์กโหลด ($WORKLOAD_SERVICEACCOUNT) ได้รับสิทธิ์ผู้อ่าน Artifact Registry เพื่ออ่านอิมเมจเวิร์กโหลดใหม่นี้ เพื่อให้มั่นใจว่าเวิร์กโหลดจะไม่สิ้นสุดก่อนที่นโยบาย WIP ของ Primus จะปฏิเสธโทเค็นที่เวิร์กโหลดแสดง

ลบไฟล์ผลลัพธ์และอินสแตนซ์ VM ที่มีอยู่

ตั้งค่าโปรเจ็กต์เป็นโปรเจ็กต์ $SECUNDUS_PROJECT_ID

gcloud config set project $SECUNDUS_PROJECT_ID

ลบไฟล์ผลลัพธ์

gsutil rm gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

ลบอินสแตนซ์ Confidential VM

gcloud compute instances delete ${WORKLOAD_VM} --zone=${SECUNDUS_PROJECT_ZONE}

เรียกใช้ภาระงานที่ไม่ได้รับอนุญาต

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=MIGRATE \
 --scopes=cloud-platform --zone=${SECUNDUS_PROJECT_ZONE} \
 --image-project=confidential-space-images \
 --image-family=confidential-space \
 --service-account=${WORKLOAD_SERVICEACCOUNT}@${SECUNDUS_PROJECT_ID}.iam.gserviceaccount.com \
 --metadata  ^~^tee-image-reference=us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}

ดูข้อผิดพลาด

คุณเห็นข้อผิดพลาด (The given credential is rejected by the attribute condition) แทนผลลัพธ์ของภาระงาน

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

5. ล้าง

ที่นี่คือสคริปต์ที่ใช้ล้างข้อมูลทรัพยากรที่เราสร้างขึ้นเป็นส่วนหนึ่งของ Codelab นี้ การล้างข้อมูลนี้จะลบทรัพยากรต่อไปนี้

Input storage bucket of Primus ($PRIMUS_INPUT_STORAGE_BUCKET).
บัญชีบริการ Primus ($PRIMUS_SERVICEACCOUNT)
ที่เก็บอาร์ติแฟกต์ของ Primus ($PRIMUS_ARTIFACT_REPOSITORY)
พูล Workload Identity ของ Primus ($PRIMUS_WORKLOAD_IDENTITY_POOL)
บัญชีบริการของเวิร์กโหลดของ Secundus ($WORKLOAD_SERVICEACCOUNT)
ที่เก็บข้อมูลอินพุตของ Secundus ($SECUNDUS_INPUT_STORAGE_BUCKET)
อินสแตนซ์การประมวลผลของภาระงาน
ที่เก็บข้อมูลผลลัพธ์ของ Secundus ($SECUNDUS_RESULT_STORAGE_BUCKET)

$ ./cleanup.sh

หากสำรวจเสร็จแล้ว โปรดพิจารณาลบโปรเจ็กต์

ไปที่คอนโซล Cloud Platform
เลือกโปรเจ็กต์ที่ต้องการปิด แล้วคลิก "ลบ" ที่ด้านบน ซึ่งจะเป็นการกำหนดเวลาให้ลบโปรเจ็กต์

สิ่งต่อไปที่ควรทำ

ลองดู Codelab ที่คล้ายกันเหล่านี้