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

1. ภาพรวม

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Codelab นี้อ้างอิงตัวแปรจำนวนหนึ่งที่คุณควรตั้งเป็นค่าที่เหมาะสมสำหรับโปรเจ็กต์ GCP ของคุณ คำสั่งใน Codelab นี้จะถือว่าตัวแปรเหล่านี้ได้รับการตั้งค่าแล้ว (เช่น 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 ซึ่งมีเงื่อนไขการให้สิทธิ์เพื่อใช้กับโทเค็นที่ลงนามโดยบริการยืนยันเอกสารรับรอง
• $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 ที่ใช้ในการลงนามอิมเมจภาระงานโดยผู้ตรวจสอบ/ผู้ทำงานร่วมกันข้อมูล (เช่น ธนาคาร Primetime ในกรณีนี้)

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

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

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

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

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

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

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

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

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

1. Confidential Space จะค้นหาลายเซ็นของคอนเทนเนอร์ที่เกี่ยวข้องกับอิมเมจภาระงานที่กำลังทำงานปัจจุบันและส่งลายเซ็นดังกล่าวไปยังผู้ยืนยันเอกสารรับรอง ผู้ยืนยันเอกสารรับรองจะยืนยันลายเซ็น และรวมลายเซ็นที่ถูกต้องไว้ในการอ้างสิทธิ์ในเอกสารรับรอง
2. ภาระงานจะขอโทเค็นเพื่อการเข้าถึงทั่วไปของ Google สำหรับ $PRIMUS_SERVICEACCOUNT จาก WIP โดยมีโทเค็นบริการ Attestation Verifier พร้อมภาระงานและการอ้างสิทธิ์สภาพแวดล้อม
3. หากการอ้างสิทธิ์ลายเซ็นคอนเทนเนอร์ในโทเค็นบริการเครื่องมือยืนยันเอกสารรับรองตรงกับเงื่อนไขแอตทริบิวต์ใน 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 หลังจากตรวจสอบโค้ด
• อาร์ติแฟกต์ที่เก็บรีจิสทรีเพื่อจัดเก็บลายเซ็น Cosign

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

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

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

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

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

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

$ 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

• ติดตั้งลายเซ็นร่วมตามคำแนะนำจากที่นี่

TODO(meetraj): ตรวจสอบข้อมูลอ้างอิงของ GitHub สำหรับ Codelab ของพื้นที่ทำงานลับ

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

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

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

$ ./setup_primus_bank_resources.sh

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

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

• ที่เก็บข้อมูล Cloud Storage ($SECUNDUS_RESULT_STORAGE_BUCKET) สำหรับจัดเก็บผลลัพธ์ของการดำเนินการของภาระงานโดยธนาคาร Secundus

$ ./setup_secundus_bank_resources.sh

3. สร้างและลงนามภาระงาน

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

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

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

$ ./create_workload_serviceaccount.sh

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

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

• สร้าง Artifact Registry($SECUNDUS_ARTIFACT_REGISTRY) ที่เป็นของธนาคาร Secundus
• อัปเดตโค้ดภาระงานด้วยชื่อทรัพยากรที่จำเป็น ที่นี่คือโค้ดภาระงานที่ใช้สำหรับ Codelab นี้
• ไบนารี Build 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=us

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

$ gcloud config set project $PRIMUS_PROJECT_ID

$ gcloud kms keyrings create $PRIMUS_SIGNING_KEYRING \
  --location=global

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

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 หากยังไม่มี โปรดดูรายละเอียดเพิ่มเติมที่หัวข้อการรับรองด้วยคีย์ที่จัดการด้วยตนเอง

// 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

• &lt;provider&gt; : หมายถึงโซลูชัน KMS ที่คุณใช้
• &lt;key&gt; : หมายถึงเส้นทางคีย์ใน 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 แบบไม่ใช้กับคีย์สาธารณะ

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

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

หมายเหตุ: เราใช้รูปแบบ RFC4648 ที่ไม่มีอักขระเสริมเพื่อเข้ารหัสคีย์สาธารณะ 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 ที่เฉพาะเจาะจงจากทีมสนับสนุนของ Sigstore KMS เมื่ออ้างถึงคีย์ที่ 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 ยอมรับค่า 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 ควรมีความยาวอย่างน้อย 2, 048 บิตด้วย

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

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

4. ให้สิทธิ์และเรียกใช้ภาระงาน

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

ในขั้นตอนนี้ เราจะตั้งค่าผู้ให้บริการข้อมูลประจำตัวภาระงานภายใต้พูล Workload Identity ($PRIMUS_WORKLOAD_IDENTITY_POOL) มีการกำหนดค่าเงื่อนไขแอตทริบิวต์สำหรับข้อมูลประจำตัวภาระงานดังที่แสดงด้านล่าง เงื่อนไขอย่างหนึ่งคือตรวจสอบลายนิ้วมือของลายเซ็นของอิมเมจภาระงานเทียบกับลายเซ็นลายนิ้วมือของคีย์สาธารณะ เมื่อใช้เงื่อนไขแอตทริบิวต์นี้ เมื่อ 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 config set project $SECUNDUS_PROJECT_ID

$ gcloud compute instances create signed-container-vm \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=TERMINATE \
 --scopes=cloud-platform --zone=us-west1-b \
 --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 เพราะนี่คือจำนวนคนจากซีแอตเทิลที่แสดงในไฟล์ primus_customer_list.csv

5. ล้างข้อมูล

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

• ที่เก็บข้อมูลพื้นที่เก็บข้อมูลเข้าของธนาคาร Primus ($PRIMUS_INPUT_STORAGE_BUCKET)
• บัญชีบริการของธนาคาร Primus ($PRIMUS_SERVICEACCOUNT)
• รีจิสทรีอาร์ติแฟกต์ของธนาคาร Primus Bank ที่มีลายเซ็นรูปภาพ ($PRIMUS_COSIGN_REPOSITORY)
• พูลภาระงานของ Primus Bank ($PRIMUS_WORKLOAD_IDENTITY_POOL)
• บัญชีบริการภาระงานของ Secundus Bank ($WORKLOAD_SERVICEACCOUNT)
• อินสแตนซ์ Compute Workload
• ที่เก็บข้อมูลพื้นที่เก็บผลลัพธ์ของ Secundus Bank ($SECUNDUS_RESULT_STORAGE_BUCKET)
• สำนักทะเบียนวัตถุของ Secundus Bank ($SECUNDUS_ARTIFACT_REGISTRY)

// run the clean up script to delete the resources created as part of this codelab.
$ ./cleanup.sh

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

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

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

ขอแสดงความยินดี คุณศึกษา Codelab เสร็จสมบูรณ์แล้ว

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

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

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

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

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

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