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

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

1. ภาพรวม

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

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

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

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

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

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

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

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

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

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

บริษัท Secundus จะเป็นผู้ดำเนินงานและรับผิดชอบ

การตั้งค่าทรัพยากรระบบคลาวด์ที่จำเป็นสำหรับการจัดเก็บรูปภาพตัวอย่างที่ภาระงานและผลลัพธ์ใช้
การเรียกใช้ภาระงาน 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 เพื่อเขียนผลลัพธ์ของการดำเนินการดังกล่าวลงในที่เก็บข้อมูล $SECUNDUS_RESULT_STORAGE_BUCKET

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

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

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

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

`$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 ใน Codelab นี้) ในขั้นตอนนี้ มีสิทธิ์อ่านโมเดลแมชชีนเลิร์นนิงที่จัดเก็บไว้ในที่เก็บข้อมูล `$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`	บัญชีบริการที่มีสิทธิ์เข้าถึง Confidential VM ที่เรียกใช้ภาระงาน

คุณจะต้องมีสิทธิ์บางอย่างสําหรับทั้ง 2 โปรเจ็กต์นี้ และดูคู่มือนี้เกี่ยวกับวิธีมอบบทบาท IAM โดยใช้คอนโซล GCP ได้
สำหรับ $PRIMUS_PROJECT_ID คุณจะต้องมีผู้ดูแลระบบพื้นที่เก็บข้อมูล, ผู้ดูแลระบบ Artifact Registry, ผู้ดูแลระบบบัญชีบริการ และผู้ดูแลระบบ IAM Workload Identity Pool
สำหรับ $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 Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) ที่กล่าวถึงข้างต้นซึ่งมีการเข้าถึง IAM เพื่ออ่านข้อมูลจากที่เก็บข้อมูลพื้นที่เก็บข้อมูลระบบคลาวด์ (โดยใช้บทบาท objectViewer) และเชื่อมต่อบัญชีบริการนี้กับ Workload Identity Pool (โดยใช้บทบาท roles/iam.workloadIdentityUser)

เราจะใช้โมเดล TensorFlow เป็นส่วนหนึ่งของการตั้งค่าทรัพยากรระบบคลาวด์นี้ เราสามารถบันทึกทั้งโมเดลที่มีสถาปัตยกรรม น้ำหนัก และการกำหนดค่าการฝึกของโมเดลไว้ในไฟล์ ZIP สำหรับวัตถุประสงค์ของ Codelab นี้ เราจะใช้โมเดล 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 ระบบจะสร้างทรัพยากรต่อไปนี้เป็นส่วนหนึ่งของขั้นตอนเหล่านี้

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

ดูรูปภาพตัวอย่างสำหรับ Codelab ได้ที่นี่

./setup_secundus_company_resources.sh

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

สร้างบัญชีบริการภาระงาน

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

บัญชีบริการภาระงานนี้ ($WORKLOAD_SERVICEACCOUNT) จะมีบทบาทต่อไปนี้

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

./create_workload_service_account.sh

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

ในขั้นตอนนี้ คุณจะได้สร้างอิมเมจ Docker ภาระงาน ภาระงานจะเขียนโดย Primus ภาระงานที่ใช้ใน Codelab นี้คือโค้ด 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 เพื่อบังคับใช้นโยบายการเข้าถึงตามข้อกำหนดเหล่านี้ การรวมศูนย์ Workload Identity ช่วยให้คุณระบุเงื่อนไขแอตทริบิวต์ได้ เงื่อนไขเหล่านี้จะจำกัดข้อมูลระบุตัวตนที่ตรวจสอบสิทธิ์ได้ด้วย Workload Identity Pool (WIP) คุณสามารถเพิ่มบริการยืนยันเอกสารรับรองลงใน WIP ในฐานะผู้ให้บริการพูลข้อมูลระบุตัวตนเพื่อแสดงการวัดผลและบังคับใช้นโยบายได้

สร้าง Workload Identity Pool ไว้แล้วก่อนหน้านี้ซึ่งเป็นส่วนหนึ่งของขั้นตอนการตั้งค่าทรัพยากรระบบคลาวด์ ตอนนี้ Primus จะสร้างผู้ให้บริการพูลภาระงาน OIDC ใหม่ --attribute-condition ที่ระบุให้สิทธิ์เข้าถึงคอนเทนเนอร์ภาระงาน สิ่งที่ต้องมี

อะไร: $WORKLOAD_IMAGE_NAME ล่าสุดที่อัปโหลดไปยังที่เก็บ $PRIMUS_ARTIFACT_REPOSITORY
ตำแหน่ง: สภาพแวดล้อมการดำเนินการที่เชื่อถือได้ของ Confidential Space กำลังทำงานในอิมเมจ VM ของ Confidential Space ที่รองรับอย่างเต็มรูปแบบ
ใคร: บัญชีบริการ $WORKLOAD_SERVICE_ACCOUNT ของ Secundus

export WORKLOAD_IMAGE_DIGEST=$(docker images –digests ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_ARTIFACT_REPOSITORY}/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}| awk 'NR>1{ print $3 }')

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"

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

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

gcloud config set project $SECUNDUS_PROJECT_ID

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=TERMINATE \
 --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 ข้อมูล ได้แก่

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

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

ใน Codelab นี้ เราได้แสดงให้เห็นว่าโมเดลที่เป็นของ 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 ใหม่ภายใต้รีจิสทรีอาร์ติแฟกต์ของ Secundus (เป็น us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}) และบัญชีบริการภาระงาน ($WORKLOAD_SERVICEACCOUNT) ได้ให้สิทธิ์โปรแกรมอ่านอาร์ติแฟกต์รีจิสทรีเพื่ออ่านอิมเมจภาระงานใหม่นี้ ทั้งนี้เพื่อให้มั่นใจว่าภาระงานจะไม่ออกก่อนที่นโยบาย 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}

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

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=TERMINATE \
 --scopes=cloud-platform --zone=${SECUNDUS_PROJECT_ZONE} \
 --image-project=confidential-space-images \
 --image-family=confidential-space \ 
--service-account=${WORKLOAD_SERVICE_ACCOUNT}@${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 นี้ ทรัพยากรต่อไปนี้จะถูกลบหลังจากทำความสะอาด

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

$ ./cleanup.sh

หากสำรวจเสร็จแล้ว โปรดลองลบโปรเจ็กต์

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

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

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