Codelab ของอิมเมจคอนเทนเนอร์ที่ลงนามแล้ว

1. ภาพรวม

Codelab นี้สร้างขึ้นจาก Codelab พื้นที่ทำงานลับ รองรับอิมเมจคอนเทนเนอร์ที่ลงนามเมื่อมีตัวเลือกในการตรวจสอบสิทธิ์คอนเทนเนอร์โดยใช้คีย์สาธารณะที่รับรองแล้วแทนที่จะระบุข้อมูลสรุปของอิมเมจในนโยบาย Workload Identity Pool (WIP)

สิ่งที่เปลี่ยนแปลงในการรองรับอิมเมจคอนเทนเนอร์ที่ลงนามใน Confidential Space มีดังนี้

ปรับปรุงความสามารถในการใช้งาน: การเปิดตัวฟีเจอร์อิมเมจคอนเทนเนอร์ที่ลงนามแล้วช่วยให้เราเปลี่ยนจากแนวทางไดเจสต์ของอิมเมจเวิร์กโหลดไปเป็นแนวทางลายเซ็นคอนเทนเนอร์สำหรับผู้ร่วมงาน/ผู้ตรวจสอบที่ให้สิทธิ์อิมเมจได้

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

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

ไม่มีการถดถอยด้านความปลอดภัย: วิธีการใช้ลายเซ็นคอนเทนเนอร์นี้จะไม่ทำให้เกิดการถดถอยด้านความปลอดภัยเมื่อเทียบกับวิธีการใช้ค่าแฮชของอิมเมจก่อนหน้านี้ เนื่องจากขอบเขตความน่าเชื่อถือยังคงเหมือนเดิม ในแนวทางการลงนามคอนเทนเนอร์ เจ้าของทรัพยากรจะให้สิทธิ์คีย์การยืนยันโดยการระบุลายนิ้วมือของคีย์สาธารณะที่เชื่อถือได้ในนโยบาย WIP และบริการ Attestation Verifier และ WIP จะทำการตรวจสอบการให้สิทธิ์ บริการ Attestation Verifier จะยืนยันว่าลายเซ็นเชื่อมโยงกับเวิร์กโหลดที่กำลังทำงาน และนโยบาย WIP จะตรวจสอบว่าคีย์สาธารณะที่บริการยืนยันนั้นได้รับอนุญาตจากนโยบาย

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

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

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

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

• วิธีลงนามในอิมเมจคอนเทนเนอร์ที่ตรวจสอบแล้วโดยใช้ cosign
• วิธีอัปโหลดลายเซ็นอิมเมจคอนเทนเนอร์ไปยังรีจิสทรี OCI เพื่อการค้นหาและการจัดเก็บลายเซ็น
• วิธีกำหนดค่าทรัพยากรระบบคลาวด์ที่จำเป็นสำหรับการเรียกใช้ Confidential Space
• วิธีเรียกใช้เวิร์กโหลดใน Confidential Space ที่รองรับอิมเมจคอนเทนเนอร์ที่ลงนามแล้ว

Codelab นี้จะแสดงวิธีใช้ Confidential Space เพื่อการรับรองจากระยะไกลสำหรับอิมเมจคอนเทนเนอร์ที่ลงนามด้วยคีย์ที่เชื่อถือได้ซึ่งทำงานบน Google Compute Engine

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

• ทำ Codelab ของ Confidential Space ให้เสร็จสมบูรณ์
• โปรเจ็กต์ Google Cloud Platform
• เบราว์เซอร์ เช่น Chrome หรือ Firefox
• คุ้นเคยกับโปรแกรมแก้ไขข้อความมาตรฐานของ Linux เช่น Vim, Emacs หรือ Nano
• ความรู้พื้นฐานเกี่ยวกับ Sigstore cosign
• ความรู้พื้นฐานเกี่ยวกับ Google Compute Engine ( Codelab), Confidential VM, Containers และที่เก็บข้อมูลระยะไกล
• ความรู้พื้นฐานเกี่ยวกับ Cloud KMS ( codelab)
• ความรู้พื้นฐานเกี่ยวกับบัญชีบริการ การรวมศูนย์ของ Workload Identity และเงื่อนไขของแอตทริบิวต์
• ความรู้พื้นฐานเกี่ยวกับ Artifact Registry
• ความรู้พื้นฐานเกี่ยวกับลายเซ็นดิจิทัล

บทบาทที่เกี่ยวข้องในพื้นที่ทำงานลับที่มีอิมเมจคอนเทนเนอร์ที่ลงนาม

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

1. การตั้งค่าทรัพยากรที่จำเป็นด้วยข้อมูลตัวอย่าง
2. การตรวจสอบโค้ดของภาระงาน
3. การใช้ cosign เพื่อลงนามในรูปภาพของภาระงาน
4. อัปโหลดลายเซ็นไปยังที่เก็บ
5. การกำหนดค่านโยบาย WIP เพื่อปกป้องข้อมูลลูกค้า

Secundus Bank จะเป็นผู้สร้างและผู้ดำเนินการภาระงาน รวมถึงรับผิดชอบในเรื่องต่อไปนี้

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

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

ทรัพยากรที่เกี่ยวข้องกับการตั้งค่า Confidential Space

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

กำหนดค่าต่อไปนี้ในโปรเจ็กต์ Primus

• $PRIMUS_INPUT_STORAGE_BUCKET: บัคเก็ตที่จัดเก็บไฟล์ข้อมูลลูกค้า
• $PRIMUS_WORKLOAD_IDENTITY_POOL: Workload Identity Pool (WIP) ที่ตรวจสอบความถูกต้องของคำกล่าวอ้าง
• $PRIMUS_WIP_PROVIDER: ผู้ให้บริการ Workload Identity Pool ซึ่งมีเงื่อนไขการให้สิทธิ์ที่จะใช้สำหรับโทเค็นที่ลงนามโดยบริการเครื่องมือยืนยันเอกสารรับรอง
• $PRIMUS_SERVICEACCOUNT: บัญชีบริการที่ $PRIMUS_WORKLOAD_IDENTITY_POOL ใช้เพื่อเข้าถึงทรัพยากรที่ได้รับการปกป้อง ในขั้นตอนนี้จะมีสิทธิ์ดูข้อมูลลูกค้าที่จัดเก็บไว้ในที่เก็บข้อมูล $PRIMUS_INPUT_STORAGE_BUCKET
• $PRIMUS_ENC_KEY: คีย์ KMS ที่ใช้เข้ารหัสข้อมูลที่จัดเก็บไว้ใน $PRIMUS_INPUT_STORAGE_BUCKET

แหล่งข้อมูลใหม่ใน Codelab นี้

• $PRIMUS_COSIGN_REPOSITORY: Artifact Registry เพื่อจัดเก็บลายเซ็นอิมเมจของเวิร์กโหลด
• $PRIMUS_SIGNING_KEY: คีย์ KMS ที่ผู้ตรวจสอบ/ผู้ทำงานร่วมกันด้านข้อมูลใช้เพื่อลงนามในอิมเมจของเวิร์กโหลด (เช่น ธนาคาร Primus ในกรณีนี้)

กำหนดค่าต่อไปนี้ในโปรเจ็กต์ Secundus

• $SECUNDUS_ARTIFACT_REGISTRY: Artifact Registry ที่จะพุชอิมเมจ Docker ของเวิร์กโหลด
• $WORKLOAD_IMAGE_NAME: ชื่อของอิมเมจ Docker ของภาระงาน
• $WORKLOAD_IMAGE_TAG: แท็กของอิมเมจ Docker ของเวิร์กโหลด
• $WORKLOAD_SERVICEACCOUNT: บัญชีบริการที่มีสิทธิ์เข้าถึง Confidential VM ที่เรียกใช้เวิร์กโหลด
• $SECUNDUS_RESULT_BUCKET: Bucket ที่จัดเก็บผลลัพธ์ของเวิร์กโหลด

แหล่งข้อมูลอื่นๆ

• primus_customer_list.csv มีข้อมูลลูกค้า เราจะอัปโหลดข้อมูลนี้ไปยัง $PRIMUS_INPUT_STORAGE_BUCKET และสร้างภาระงานที่จะค้นหาข้อมูลนี้

เวิร์กโฟลว์ที่มีอยู่

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

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

เวิร์กโฟลว์ใหม่ที่รองรับคอนเทนเนอร์ที่ลงนาม

การรองรับคอนเทนเนอร์ที่ลงนามแล้วจะผสานรวมเข้ากับเวิร์กโฟลว์ที่มีอยู่ดังที่ไฮไลต์ไว้ด้านล่าง เมื่อเรียกใช้เวิร์กโหลดใน Confidential Space ที่รองรับอิมเมจคอนเทนเนอร์ที่ลงชื่อแล้ว ระบบจะดำเนินการต่อไปนี้โดยใช้ทรัพยากรที่กำหนดค่าไว้

1. Confidential Space จะค้นหาลายเซ็นคอนเทนเนอร์ที่เกี่ยวข้องกับอิมเมจเวิร์กโหลดที่กำลังทำงานอยู่ และส่งลายเซ็นเหล่านี้ไปยังเครื่องมือยืนยันการรับรอง เครื่องมือตรวจสอบการรับรองจะยืนยันลายเซ็น และรวมลายเซ็นที่ถูกต้องไว้ในการอ้างสิทธิ์การรับรอง
2. เวิร์กโหลดจะขอโทเค็นเพื่อการเข้าถึง Google ทั่วไปสำหรับ $PRIMUS_SERVICEACCOUNT จาก WIP โดยจะเสนอโทเค็นบริการ Attestation Verifier พร้อมการอ้างสิทธิ์ของภาระงานและสภาพแวดล้อม
3. หากการอ้างสิทธิ์ลายเซ็นคอนเทนเนอร์ในโทเค็นบริการ Attestation Verifier ตรงกับเงื่อนไขแอตทริบิวต์ใน WIP ระบบจะแสดงโทเค็นเพื่อการเข้าถึงสำหรับ $PRIMUS_SERVICEACCOUNT
4. เวิร์กโหลดใช้โทเค็นเพื่อการเข้าถึงบัญชีบริการที่เชื่อมโยงกับ $PRIMUS_SERVICEACCOUNT เพื่อเข้าถึงข้อมูลลูกค้าในที่เก็บข้อมูล $PRIMUS_INPUT_STORAGE_BUCKET
5. โดยเวิร์กโหลดจะดำเนินการกับข้อมูลดังกล่าว
6. เวิร์กโหลดใช้ $WORKLOAD_SERVICEACCOUNT เพื่อเขียนผลลัพธ์ของการดำเนินการนั้นไปยังที่เก็บข้อมูล $SECUNDUS_RESULT_STORAGE_BUCKET

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

ในขั้นตอนการตั้งค่า Confidential Space คุณจะต้องสร้างทรัพยากรระบบคลาวด์ที่จำเป็นภายใต้โปรเจ็กต์ GCP ของธนาคาร Primus และ Secundus ก่อน แหล่งข้อมูลใหม่ใน Codelab นี้มีดังนี้

ในโปรเจ็กต์ Primus

• คีย์การลงนาม KMS ที่ใช้ในการลงนามภาระงาน Secundus หลังจากตรวจสอบโค้ด
• ที่เก็บ Artifact Registry สำหรับจัดเก็บลายเซ็น Cosign

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

ในขั้นตอนการตั้งค่า Confidential Space คุณจะต้องสร้างทรัพยากรระบบคลาวด์ที่จำเป็นในโปรเจ็กต์ GCP ของ Primus และ Secundus

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

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

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

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

cd confidential-space/codelabs/signed_container_codelab/scripts

• ตรวจสอบว่าคุณได้ตั้งค่าโปรเจ็กต์ที่จำเป็นตามที่แสดงด้านล่าง

export PRIMUS_PROJECT_ID=<GCP project id of primus bank>
export SECUNDUS_PROJECT_ID=<GCP project id of secundus bank>

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

source config_env.sh

• ติดตั้ง Cosign โดยทำตามวิธีการจากที่นี่

ตั้งค่าทรัพยากรของธนาคาร Primus

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

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

./setup_primus_bank_resources.sh

ตั้งค่าทรัพยากรธนาคาร Secundus

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

• Bucket ของพื้นที่เก็บข้อมูลระบบคลาวด์ ($SECUNDUS_RESULT_STORAGE_BUCKET) เพื่อจัดเก็บผลลัพธ์ของการเรียกใช้เวิร์กโหลดโดยธนาคาร Secundus

./setup_secundus_bank_resources.sh

3. สร้างและลงนามในเวิร์กโหลด

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

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

• บัญชีบริการของเวิร์กโหลดนี้ ($WORKLOAD_SERVICEACCOUNT) จะมีบทบาทต่อไปนี้
• confidentialcomputing.workloadUser เพื่อรับโทเค็นการรับรอง
• logging.logWriter เพื่อเขียนบันทึกลงใน Cloud Logging
• objectViewer เพื่ออ่านข้อมูลจาก $PRIMUS_INPUT_STORAGE_BUCKET Cloud Storage Bucket
• objectAdmin เพื่อเขียนผลลัพธ์ของภาระงานไปยัง $SECUNDUS_RESULT_STORAGE_BUCKET Bucket ของ Cloud Storage

./create_workload_serviceaccount.sh

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

ในขั้นตอนนี้ คุณจะต้องสร้างอิมเมจ Docker ของภาระงาน ปริมาณงานที่ใช้ใน Codelab นี้คือแอป Go แบบง่ายที่ใช้ CLI ซึ่งนับลูกค้า (จากข้อมูลลูกค้าของธนาคาร Primus) จากสถานที่ตั้งทางภูมิศาสตร์ที่ระบุในอาร์กิวเมนต์ เรียกใช้สคริปต์ต่อไปนี้เพื่อสร้างภาระงานที่จะดำเนินการตามขั้นตอนต่อไปนี้

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

./create_workload.sh

ลงนามในภาระงาน

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

ในที่นี้เราจะใช้ Artifact Registry เป็นตัวอย่าง นอกจากนี้ คุณยังเลือกรีจิสทรีอื่นๆ ที่ใช้ OCI เช่น Docker Hub, AWS CodeArtifact ตามความต้องการได้ด้วย

หมายเหตุ: ขอแนะนำอย่างยิ่งให้ทำขั้นตอนนี้สำหรับกรณีการใช้งานที่ผู้ลงนามไม่มีสิทธิ์เขียนในที่เก็บเวิร์กโหลด

1. สร้างที่เก็บ Docker ของ Artifact Registry

gcloud config set project $PRIMUS_PROJECT_ID

gcloud artifacts repositories create $PRIMUS_COSIGN_REPOSITORY \
  --repository-format=docker --location=${PRIMUS_PROJECT_REPOSITORY_REGION}

2. สร้างคีย์ริงและคีย์ใน KMS เพื่อลงนามในอิมเมจของภาระงาน

gcloud config set project $PRIMUS_PROJECT_ID

gcloud kms keyrings create $PRIMUS_SIGNING_KEYRING \
  --location=${PRIMUS_PROJECT_LOCATION}

gcloud kms keys create $PRIMUS_SIGNING_KEY \
  --keyring=$PRIMUS_SIGNING_KEYRING \
  --purpose=asymmetric-signing \
  --default-algorithm=ec-sign-p256-sha256 \
  --location=${PRIMUS_PROJECT_LOCATION}

3. สำหรับ Artifact Registry ระบบคาดหวังชื่อรูปภาพแบบเต็ม เช่น $LOCATION/$PROJECT/$REPOSITORY/$IMAGE_NAME คุณอัปโหลดอิมเมจคอนเทนเนอร์ใดก็ได้ไปยังที่เก็บเพื่อจัดเก็บลายเซ็น

export COSIGN_REPOSITORY=us-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_COSIGN_REPOSITORY}/demo

หมายเหตุ: รีจิสทรีต่างๆ อาจคาดหวังรูปแบบที่แตกต่างกันสำหรับ "ที่เก็บ"

• รีจิสทรี GCR จะคาดหวังรูปแบบดังนี้

$ export COSIGN_REPOSITORY=gcr.io/primus-signatures

• Artifact Registry จะคาดหวังชื่ออิมเมจแบบเต็ม เช่น $LOCATION-docker.pkg.dev/$PROJECT/$REPOSITORY/$STORAGE_IMAGE ไม่ใช่แค่ที่เก็บ ตัวอย่างเช่น

$ export COSIGN_REPOSITORY=us-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_COSIGN_REPOSITORY}/demo

การระบุเพียงรีโป เช่น us-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_COSIGN_REPOSITORY} จะใช้ไม่ได้ใน Artifact Registry

4. มอบบทบาทผู้ดูในที่เก็บ $PRIMUS_COSIGN_REPOSITORY ให้กับบัญชีบริการ $WORKLOAD_SERVICEACCOUNT ซึ่งจะช่วยให้ Confidential Space ค้นพบลายเซ็นของอิมเมจคอนเทนเนอร์ที่อัปโหลดไปยัง $PRIMUS_COSIGN_REPOSITORY ได้

gcloud artifacts repositories add-iam-policy-binding ${PRIMUS_COSIGN_REPOSITORY} \
--project=${PRIMUS_PROJECT_ID} --role='roles/viewer' --location=us \
--member="serviceAccount:${WORKLOAD_SERVICEACCOUNT}@${SECUNDUS_PROJECT_ID}.iam.gserviceaccount.com"

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

เมื่อลงนามด้วยคู่คีย์ คุณจะมี 2 ตัวเลือกดังนี้

1. ลงนามด้วยคู่คีย์ในเครื่องที่สร้างโดย Cosign
2. ลงชื่อด้วยคู่คีย์ที่จัดเก็บไว้ที่อื่น (เช่น ใน KMS)

หมายเหตุ: Confidential Space ที่รองรับอิมเมจคอนเทนเนอร์ที่ลงชื่อจะรองรับเฉพาะการลงชื่อ Cosign ด้วยคีย์ RSA และ ECDSA

1. สร้างคู่คีย์ใน Cosign หากยังไม่มี ดูรายละเอียดเพิ่มเติมได้ที่การลงนามด้วยคีย์ที่จัดการด้วยตนเอง ในที่นี้ เราได้ระบุทั้ง 2 วิธี (ในเครื่องและใช้ผู้ให้บริการ KMS) ในการสร้างคู่คีย์และลงนามในภาระงาน โปรดทำตามวิธีใดวิธีหนึ่งเพื่อลงนามในคอนเทนเนอร์ภาระงาน

// Set Application Default Credentials.
gcloud auth application-default login 

// Generate keys using a KMS provider.
cosign generate-key-pair --kms <provider>://<key>

// Generate keys using Cosign.
cosign generate-key-pair

ในข้อความด้านบน ให้แทนที่ <provider>://<key> ด้วย gcpkms://projects/$PRIMUS_PROJECT_ID/locations/global/keyRings/$PRIMUS_SIGNING_KEYRING/cryptoKeys/$PRIMUS_SIGNING_KEY/cryptoKeyVersions/$PRIMUS_SIGNING_KEYVERSION

• <provider> : หมายถึงโซลูชัน KMS ที่คุณใช้
• <key> : หมายถึงเส้นทางคีย์ใน KMS

2. เรียกข้อมูลคีย์สาธารณะเพื่อการยืนยัน

// For KMS providers.
cosign public-key --key <some provider>://<some key> > pub.pem

// For local key pair signing.
cosign public-key --key cosign.key > pub.pem

3. ลงนามในเวิร์กโหลดโดยใช้ Cosign ทำการเข้ารหัส Base64 แบบไม่มีการเพิ่ม Padding ในคีย์สาธารณะ

PUB=$(cat pub.pem | openssl base64)

// Remove spaces and trailing "=" signs.
PUB=$(echo $PUB | tr -d '[:space:]' | sed 's/[=]*$//')

หมายเหตุ: เราใช้รูปแบบ RFC4648 ที่ไม่มีการเพิ่ม Padding เพื่อเข้ารหัสคีย์สาธารณะ PEM เนื่องจาก Cosign ไม่อนุญาตให้มีเครื่องหมาย "=" เพิ่มเติมในคำอธิบายประกอบของเพย์โหลด

4. ลงนามในเวิร์กโหลดโดยใช้ Cosign ด้วยคีย์สาธารณะที่ส่งออกและอัลกอริทึมลายเซ็นที่แนบมา

IMAGE_REFERENCE=us-docker.pkg.dev/$SECUNDUS_PROJECT_ID/$SECUNDUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG

// Sign with KMS support.
cosign sign --key <some provider>://<some key> $IMAGE_REFERENCE \
-a dev.cosignproject.cosign/sigalg=ECDSA_P256_SHA256 \
-a dev.cosignproject.cosign/pub=$PUB

// Sign with a local key pair.
cosign sign --key cosign.key $IMAGE_REFERENCE \
-a dev.cosignproject.cosign/sigalg=ECDSA_P256_SHA256 \
-a dev.cosignproject.cosign/pub=$PUB

• --key [ต้องระบุ] ระบุคีย์การลงนามที่จะใช้ เมื่ออ้างอิงถึงคีย์ที่จัดการโดยผู้ให้บริการ KMS โปรดทำตามรูปแบบ URI ที่เฉพาะเจาะจงจากการรองรับ KMS ของ Sigstore เมื่ออ้างอิงถึงคีย์ที่ Cosign สร้าง ให้ใช้ cosign.key แทน
• $IMAGE_REFERENCE [ต้องระบุ] ระบุอิมเมจคอนเทนเนอร์ที่จะลงนาม รูปแบบของ IMAGE_REFERENCE สามารถระบุได้ด้วยแท็กหรือข้อมูลสรุปของรูปภาพ เช่น us-docker.pkg.dev/$SECUNDUS_PROJECT_ID/secundus-workloads/workload-container:latest or us-docker.pkg.dev/$SECUNDUS_PROJECT_ID/secundus-workloads/workload-container[IMAGE-digest]
• -a [REQUIRED] ระบุคำอธิบายประกอบที่แนบมากับเพย์โหลดลายเซ็น สำหรับอิมเมจคอนเทนเนอร์ที่ลงชื่อของ Confidential Space คุณต้องแนบคีย์สาธารณะและอัลกอริทึมลายเซ็นไปกับเพย์โหลดลายเซ็น

คำเตือน: อย่าเปลี่ยน dev.cosignproject.cosign/pub และ dev.cosignproject.cosign/sigalg เนื่องจาก Confidential Space จะยอมรับเฉพาะชื่อคีย์เหล่านี้

• dev.cosignproject.cosign/sigalg ONLY ยอมรับค่า 3 ค่าดังนี้
• RSASSA_PSS_SHA256: อัลกอริทึม RSASSA ที่มีการเพิ่ม PSS ที่มีไดเจสต์ SHA256
• RSASSA_PKCS1V15_SHA256: อัลกอริทึม RSASSA ที่มีการเพิ่ม PKCS#1 v1.5 ที่มีไดเจสต์ SHA256
• ECDSA_P256_SHA256: ECDSA บนเส้นโค้ง P-256 ที่มีไดเจสต์ SHA256 นอกจากนี้ยังเป็นอัลกอริทึมลายเซ็นเริ่มต้นสำหรับคู่คีย์ที่สร้างโดย Cosign ด้วย

หมายเหตุ: โปรดเลือกอัลกอริทึมลายเซ็นที่สอดคล้องกันเมื่อใช้ Cosign เพื่อลงนาม นอกจากนี้ คีย์ RSA ควรมีความยาวอย่างน้อย 2048 บิต

5. อัปโหลดลายเซ็นไปยังที่เก็บ Docker

Cosign จะอัปโหลดลายเซ็นไปยัง COSIGN_REPOSITORY. ที่ระบุโดยอัตโนมัติ

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

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

ในขั้นตอนนี้ เราจะตั้งค่าผู้ให้บริการ Workload Identity ภายใต้ Workload Identity Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) โดยมีการกำหนดค่าเงื่อนไขแอตทริบิวต์สำหรับ Workload Identity ดังที่แสดงด้านล่าง เงื่อนไขข้อหนึ่งคือการตรวจสอบลายนิ้วมือของลายเซ็นรูปภาพของเวิร์กโหลดกับลายนิ้วมือของคีย์สาธารณะสำหรับการลงนาม เมื่อใช้เงื่อนไขแอตทริบิวต์นี้ เมื่อ Secundus Bank เปิดตัวอิมเมจเวิร์กโหลดใหม่ Primus Bank จะตรวจสอบโค้ดเวิร์กโหลดและลงนามในอิมเมจเวิร์กโหลดใหม่โดยไม่ต้องอัปเดตนโยบาย WIP ด้วยค่าแฮชของอิมเมจ

gcloud config set project $PRIMUS_PROJECT_ID

PUBLIC_KEY_FINGERPRINT=$(openssl pkey -pubin -in pub.pem -outform DER | openssl sha256 | cut -d' ' -f2)

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
     && '${WORKLOAD_SERVICEACCOUNT}@${SECUNDUS_PROJECT_ID}.iam.gserviceaccount.com' in
     assertion.google_service_accounts
     && ['ECDSA_P256_SHA256:${PUBLIC_KEY_FINGERPRINT}']
       .exists(fingerprint, fingerprint in assertion.submods.container.image_signatures.map(sig,sig.signature_algorithm+':'+sig.key_id))"

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

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

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=MIGRATE \
 --scopes=cloud-platform \
 --zone=${SECUNDUS_PROJECT_ZONE} \
 --project=${SECUNDUS_PROJECT_ID} \
 --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}/${SECUNDUS_ARTIFACT_REPOSITORY}/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}~tee-restart-policy=Never~tee-cmd="[\"count-location\",\"Seattle\",\"gs://${SECUNDUS_RESULT_STORAGE_BUCKET}/seattle-result\"]"~tee-signed-image-repos=us-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_COSIGN_REPOSITORY}/demo"

ดูผลลัพธ์

ในโปรเจ็กต์ Secundus ให้ดูผลลัพธ์ของภาระงาน

gcloud config set project $SECUNDUS_PROJECT_ID

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/seattle-result

ผลลัพธ์ควรเป็น 3 เนื่องจากมีผู้ที่มาจากซีแอตเทิลจำนวน 3 คนในไฟล์ primus_customer_list.csv

5. ล้าง

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

• Input storage bucket of Primus bank ($PRIMUS_INPUT_STORAGE_BUCKET)
• บัญชีบริการของธนาคาร Primus ($PRIMUS_SERVICEACCOUNT)
• รีจิสทรีของ Primus Bank ที่เก็บลายเซ็นรูปภาพ ($PRIMUS_COSIGN_REPOSITORY)
• พูล Workload Identity ของ Primus Bank ($PRIMUS_WORKLOAD_IDENTITY_POOL)
• บัญชีบริการของภาระงานของ Secundus Bank ($WORKLOAD_SERVICEACCOUNT)
• อินสแตนซ์การประมวลผลของเวิร์กโหลด
• Bucket ที่เก็บผลลัพธ์ของ Secundus Bank ($SECUNDUS_RESULT_STORAGE_BUCKET)
• รีจิสทรีอาร์ติแฟกต์ของ Secundus Bank ($SECUNDUS_ARTIFACT_REGISTRY)
• VM ของภาระงานของ Secundus Bank ($WORKLOAD_VM)

./cleanup.sh

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

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

ขอแสดงความยินดี

ยินดีด้วย คุณทำ Codelab เสร็จเรียบร้อยแล้ว

คุณได้เรียนรู้วิธีใช้ประโยชน์จากฟีเจอร์อิมเมจคอนเทนเนอร์ที่ลงนามเพื่อปรับปรุงความสามารถในการใช้งาน Confidential Space

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

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

• ข้อมูลที่แชร์อย่างปลอดภัยซึ่งใช้กับ Confidential Space
• วิธีทำธุรกรรมเนื้อหาดิจิทัลด้วยการประมวลผลแบบหลายฝ่ายและพื้นที่ลับ
• วิเคราะห์ข้อมูลที่เป็นความลับด้วยพื้นที่ลับ

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

• หากรู้สึกโดดเดี่ยว Confidential Computing ช่วยได้
• การประมวลผลข้อมูลแบบเป็นความลับใน GCP
• Confidential Space: อนาคตของการทำงานร่วมกันที่รักษาความเป็นส่วนตัว
• วิธีที่ Google และ Intel ทำให้การประมวลผลแบบเป็นความลับปลอดภัยยิ่งขึ้น
• ความเป็นส่วนตัวเทียบกับความก้าวหน้า - การรักษาความปลอดภัยที่ดียิ่งขึ้นด้วยการประมวลผลแบบเป็นความลับของ Google Cloud