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

1. ภาพรวม

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

สิ่งที่เปลี่ยนแปลงไปเมื่อรองรับอิมเมจคอนเทนเนอร์ที่เซ็นชื่อในพื้นที่ทำงานที่ปลอดภัย

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

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

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

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

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

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

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

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

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

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

สิ่งที่ต้องมี

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

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

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

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

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

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

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

แหล่งข้อมูลที่เกี่ยวข้องกับการตั้งค่าพื้นที่ทำงานที่ปลอดภัย

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

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

• $SECUNDUS_ARTIFACT_REGISTRY: 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 และสร้างภาระงานที่จะใช้ค้นหาข้อมูลนี้

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

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

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

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

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

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

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

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

ในโปรเจ็กต์ Primus ให้ทำดังนี้

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

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

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

• ที่เก็บข้อมูล 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 ที่กล่าวถึงข้างต้น ($PRIMUS_WORKLOAD_IDENTITY_POOL) ที่มีสิทธิ์เข้าถึง IAM ต่อไปนี้
• roles/cloudkms.cryptoKeyDecrypter เพื่อถอดรหัสข้อมูลโดยใช้คีย์ KMS
• objectViewer เพื่ออ่านข้อมูลจากที่เก็บข้อมูลระบบคลาวด์
• roles/iam.workloadIdentityUser สำหรับการเชื่อมต่อบัญชีบริการนี้กับพูลข้อมูลระบุตัวตนของภาระงาน

./setup_primus_bank_resources.sh

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

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

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

./setup_secundus_bank_resources.sh

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

สร้างบัญชีบริการของ Workload

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

• บัญชีบริการของเวิร์กโหลดนี้ ($WORKLOAD_SERVICEACCOUNT) จะมีบทบาทต่อไปนี้
• confidentialcomputing.workloadUser เพื่อรับโทเค็นการรับรอง
• logging.logWriter เพื่อเขียนบันทึกไปยัง Cloud Logging
• objectViewer เพื่ออ่านข้อมูลจากที่เก็บข้อมูลระบบคลาวด์ $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 นี้
• สร้างไบนารี Go และสร้าง Dockerfile สำหรับสร้างอิมเมจ Docker ของโค้ดภาระงาน ที่นี่คือ Dockerfile ที่ใช้สำหรับ Codelab นี้
• สร้างและเผยแพร่อิมเมจ Docker ไปยัง Artifact Registry ($SECUNDUS_ARTIFACT_REGISTRY) ของธนาคาร Secundus
• ให้สิทธิ์อ่าน $SECUNDUS_ARTIFACT_REGISTRY แก่ $WORKLOAD_SERVICEACCOUNT ซึ่งจำเป็นสำหรับคอนเทนเนอร์ภาระงานในการดึงอิมเมจ 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. สําหรับที่เก็บอาร์ติแฟกต์ คุณควรใช้ชื่อรูปภาพแบบเต็ม เช่น $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 ซึ่งจะช่วยให้พื้นที่ทำงานที่ปลอดภัยค้นพบลายเซ็นรูปภาพคอนเทนเนอร์ที่อัปโหลดไปยัง $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 ลงนามด้วยคู่คีย์เท่านั้น ฟีเจอร์นี้ไม่รองรับการลงชื่อแบบไม่ต้องใช้คีย์ร่วมลงชื่อ

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

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

หมายเหตุ: พื้นที่ทำงานที่ปลอดภัยซึ่งรองรับรูปภาพคอนเทนเนอร์ที่ลงชื่อรองรับเฉพาะการลงชื่อร่วมด้วยคีย์ 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 แบบไม่มีอักขระแทรกในคีย์สาธารณะ

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 ที่เฉพาะเจาะจงจากการสนับสนุน 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 [ต้องระบุ] ระบุคำอธิบายประกอบที่แนบมากับเพย์โหลดลายเซ็น สำหรับอิมเมจคอนเทนเนอร์ที่ลงนามใน "พื้นที่ส่วนบุคคล" จะต้องแนบคีย์สาธารณะและอัลกอริทึมลายเซ็นไปกับเพย์โหลดลายเซ็น

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

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

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

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

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

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

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

ในขั้นตอนนี้ เราจะตั้งค่าผู้ให้บริการข้อมูลประจำตัวของภาระงานภายใต้ Workload Identity Pool ($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" ของ Flag ภาระงานได้รับการเข้ารหัสเพื่อเผยแพร่ผลลัพธ์ไปยัง $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 เนื่องจากเป็นจํานวนผู้ที่มาจากซีแอตเทิลที่แสดงอยู่ในไฟล์ primus_customer_list.csv

5. ล้าง

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

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

./cleanup.sh

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

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

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

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

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

ขั้นตอนถัดไป

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

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

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

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