Mengamankan model ML dan Kekayaan Intelektual menggunakan Confidential Space

1. Ringkasan

Ruang Rahasia menawarkan lingkungan yang aman untuk kolaborasi antara beberapa pihak. Codelab ini menunjukkan cara Confidential Space dapat digunakan untuk melindungi kekayaan intelektual sensitif, seperti model machine learning.

Dalam codelab ini, Anda akan menggunakan Confidential Space untuk memungkinkan satu perusahaan membagikan model machine learning eksklusifnya secara aman kepada perusahaan lain yang ingin menggunakan model tersebut. Secara khusus, Company Primus memiliki model machine learning yang hanya akan dirilis ke workload yang berjalan di Confidential Space, sehingga memungkinkan Primus mempertahankan kontrol penuh atas kekayaan intelektualnya. Company Secundus akan menjadi operator workload dan akan menjalankan workload machine learning di Confidential Space. Secundus akan memuat model ini dan menjalankan inferensi menggunakan data sampel yang dimiliki oleh Secundus.

Di sini, Primus adalah penulis workload yang menulis kode workload, dan kolaborator yang ingin melindungi kekayaan intelektualnya dari operator workload yang tidak tepercaya, Secundus. Secundus adalah operator workload dari workload machine learning.

Yang akan Anda pelajari

Cara mengonfigurasi lingkungan tempat satu pihak dapat membagikan model ML eksklusifnya kepada pihak lain tanpa kehilangan kontrol atas kekayaan intelektualnya.

Yang Anda butuhkan

Project Google Cloud Platform
Pengetahuan dasar tentang Google Compute Engine ( codelab), Confidential VM, container, dan repositori jarak jauh
Pengetahuan dasar tentang Akun Layanan, Workload Identity Federation, dan kondisi atribut.

Peran yang terlibat dalam penyiapan Confidential Space

Dalam codelab ini, Company Primus akan menjadi pemilik resource dan penulis beban kerja, yang akan bertanggung jawab atas hal berikut:

Menyiapkan resource cloud yang diperlukan dengan model machine learning
Menulis kode workload
Mempublikasikan image workload
Mengonfigurasi kebijakan Kumpulan Workload Identity untuk melindungi model ML dari operator yang tidak tepercaya

Secundus Company akan menjadi operator, dan bertanggung jawab atas:

Menyiapkan resource cloud yang diperlukan untuk menyimpan contoh gambar yang digunakan oleh beban kerja dan hasilnya
Menjalankan workload ML di Confidential Space menggunakan model yang disediakan oleh Primus

Cara kerja Ruang Rahasia

Saat Anda menjalankan workload di Confidential Space, proses berikut akan terjadi, menggunakan resource yang dikonfigurasi:

Workload meminta token akses Google umum untuk $PRIMUS_SERVICEACCOUNT dari Workload Identity Pool. Layanan ini menawarkan token layanan Attestation Verifier dengan klaim beban kerja dan lingkungan.
Jika klaim pengukuran workload dalam token layanan Pengesah Pengesahan cocok dengan kondisi atribut di WIP, token akses untuk $PRIMUS_SERVICEACCOUNT. akan ditampilkan
Workload menggunakan token akses akun layanan yang terkait dengan $PRIMUS_SERVICEACCOUNT untuk mengakses model machine learning yang disimpan di bucket $PRIMUS_INPUT_STORAGE_BUCKET.
Beban kerja melakukan operasi pada data yang dimiliki oleh Secundus dan beban kerja tersebut dioperasikan dan dijalankan oleh Secundus dalam project-nya.
Workload menggunakan akun layanan $WORKLOAD_SERVICEACCOUNT untuk menulis hasil operasi tersebut ke bucket $SECUNDUS_RESULT_STORAGE_BUCKET.

2. Menyiapkan Resource Cloud

Sebelum memulai

Clone repositori ini menggunakan perintah di bawah untuk mendapatkan skrip yang diperlukan yang digunakan sebagai bagian dari codelab ini.

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

Ubah direktori untuk codelab ini.

cd confidential-space/codelabs/ml_model_protection/scripts

Pastikan Anda telah menetapkan variabel lingkungan project yang diperlukan seperti yang ditunjukkan di bawah. Untuk mengetahui informasi selengkapnya tentang cara menyiapkan project GCP, lihat codelab ini. Anda dapat melihat artikel ini untuk mendapatkan detail tentang cara mengambil project ID dan perbedaannya dengan nama project dan nomor project.

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

Aktifkan Penagihan untuk project Anda.
Aktifkan Confidential Computing API dan API berikut untuk kedua project.

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

Tetapkan nilai ke variabel untuk nama resource yang ditentukan di atas menggunakan perintah berikut. Variabel ini memungkinkan Anda menyesuaikan nama resource sesuai kebutuhan dan juga menggunakan resource yang ada jika sudah dibuat. (misalnya, export PRIMUS_INPUT_STORAGE_BUCKET='my-input-bucket')

Anda dapat menetapkan variabel berikut dengan nama resource cloud yang ada di project Primus. Jika variabel ditetapkan, resource cloud yang ada dan sesuai dari project Primus akan digunakan. Jika variabel tidak disetel, nama resource cloud akan dibuat dari nama project dan resource cloud baru akan dibuat dengan nama tersebut. Berikut adalah variabel yang didukung untuk nama resource:

`$PRIMUS_INPUT_STORAGE_BUCKET`	Bucket yang menyimpan model machine learning Primus.
`$PRIMUS_WORKLOAD_IDENTITY_POOL`	Workload identity pool (WIP) Primus yang memvalidasi klaim.
`$PRIMUS_WIP_PROVIDER`	Penyedia kumpulan workload identity Primus yang mencakup kondisi otorisasi yang akan digunakan untuk token yang ditandatangani oleh layanan Pengesah Verifikasi.
`$PRIMUS_SERVICE_ACCOUNT`	Akun layanan Primus yang digunakan `$PRIMUS_WORKLOAD_IDENTITY_POOL` untuk mengakses resource yang dilindungi (model ML dalam codelab ini). Pada langkah ini, akun layanan memiliki izin untuk membaca model machine learning yang disimpan di bucket `$PRIMUS_INPUT_STORAGE_BUCKET`.
`$PRIMUS_ARTIFACT_REPOSITORY`	Repositori artefak tempat image Docker beban kerja akan dikirim.

Anda dapat menetapkan variabel berikut dengan nama resource cloud yang ada di project Secundus. Jika variabel ditetapkan, resource cloud yang ada dan sesuai dari project Secundus akan digunakan. Jika variabel tidak disetel, nama resource cloud akan dibuat dari nama project dan resource cloud baru akan dibuat dengan nama tersebut. Berikut adalah variabel yang didukung untuk nama resource:

`$SECUNDUS_INPUT_STORAGE_BUCKET`	Bucket yang menyimpan contoh gambar yang ingin diklasifikasikan Secundus menggunakan model yang disediakan oleh Primus.
`$SECUNDUS_RESULT_STORAGE_BUCKET`	Bucket yang menyimpan hasil workload.
`$WORKLOAD_IMAGE_NAME`	Nama image container workload.
`$WORKLOAD_IMAGE_TAG`	Tag image container workload.
`$WORKLOAD_SERVICE_ACCOUNT`	Akun layanan yang memiliki izin untuk mengakses Confidential VM yang menjalankan workload.

Anda akan memerlukan izin tertentu untuk kedua project ini dan Anda dapat melihat panduan ini tentang cara memberikan peran IAM menggunakan konsol GCP:
Untuk $PRIMUS_PROJECT_ID, Anda memerlukan Storage Admin, Administrator Artifact Registry, Admin Akun Layanan, Admin IAM Workload Identity Pool.
Untuk $SECUNDUS_PROJECT_ID, Anda memerlukan Compute Admin, Storage Admin, Service Account Admin, IAM Workload Identity Pool Admin, Security Admin (opsional).
Jalankan skrip berikut untuk menetapkan nama variabel yang tersisa ke nilai berdasarkan project ID Anda untuk nama resource.

source config_env.sh

Menyiapkan resource Perusahaan Primus

Sebagai bagian dari langkah ini, Anda akan menyiapkan resource cloud yang diperlukan untuk Primus. Jalankan skrip berikut untuk menyiapkan resource untuk Primus. Resource berikut akan dibuat sebagai bagian dari eksekusi skrip:

Bucket penyimpanan cloud ($PRIMUS_INPUT_STORAGE_BUCKET) untuk menyimpan model machine learning Primus.
Workload identity pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) untuk memvalidasi klaim berdasarkan kondisi atribut yang dikonfigurasi di penyedianya.
Akun layanan ($PRIMUS_SERVICEACCOUNT) yang terlampir ke pool identitas beban kerja yang disebutkan di atas ($PRIMUS_WORKLOAD_IDENTITY_POOL) dengan akses IAM untuk membaca data dari bucket Cloud Storage (menggunakan peran objectViewer) dan untuk menghubungkan akun layanan ini ke pool identitas beban kerja (menggunakan peran roles/iam.workloadIdentityUser).

Sebagai bagian dari penyiapan resource cloud ini, kita akan menggunakan model TensorFlow. Kita dapat menyimpan seluruh model yang mencakup arsitektur, bobot, dan konfigurasi pelatihan model dalam arsip ZIP. Untuk tujuan codelab ini, kita akan menggunakan model MobileNet V1 yang dilatih pada set data ImageNet yang dapat ditemukan di sini.

./setup_primus_company_resources.sh

Skrip yang disebutkan di atas akan menyiapkan resource cloud. Sekarang kita akan mendownload dan memublikasikan model ke bucket Cloud Storage yang dibuat oleh skrip.

Download model terlatih dari sini.
Setelah didownload, ganti nama file tar yang didownload menjadi model.tar.gz.
Publikasikan file model.tar.gz ke bucket Cloud Storage menggunakan perintah berikut dari direktori yang berisi file model.tar.gz.

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

Menyiapkan resource Perusahaan Secundus

Sebagai bagian dari langkah ini, Anda akan menyiapkan resource cloud yang diperlukan untuk Secundus. Jalankan skrip berikut untuk menyiapkan resource untuk Secundus. Sebagai bagian dari langkah-langkah ini, resource berikut akan dibuat:

Bucket penyimpanan cloud ($SECUNDUS_INPUT_STORAGE_BUCKET) untuk menyimpan gambar contoh guna menjalankan inferensi oleh Secundus.
Bucket penyimpanan cloud ($SECUNDUS_RESULT_STORAGE_BUCKET) untuk menyimpan hasil eksekusi beban kerja ML oleh Secundus.

Beberapa contoh gambar disediakan di sini untuk codelab ini.

./setup_secundus_company_resources.sh

3. Membuat Beban Kerja

Buat akun layanan workload

Sekarang, Anda akan membuat akun layanan untuk workload dengan peran dan izin yang diperlukan. Jalankan skrip berikut untuk membuat akun layanan workload di project Secundus. Akun layanan ini akan digunakan oleh VM yang menjalankan beban kerja ML.

Akun layanan beban kerja ini ($WORKLOAD_SERVICEACCOUNT) akan memiliki peran berikut:

confidentialcomputing.workloadUser untuk mendapatkan token pengesahan
logging.logWriter untuk menulis log ke Cloud Logging.
objectViewer untuk membaca data dari bucket penyimpanan cloud $SECUNDUS_INPUT_STORAGE_BUCKET.
objectUser untuk menulis hasil beban kerja ke bucket Cloud Storage $SECUNDUS_RESULT_STORAGE_BUCKET.

./create_workload_service_account.sh

Membuat beban kerja

Sebagai bagian dari langkah ini, Anda akan membuat image Docker workload. Beban kerja akan dibuat oleh Primus. Beban kerja yang digunakan dalam codelab ini adalah kode Python machine learning yang mengakses model ML yang disimpan di bucket penyimpanan Primus dan menjalankan inferensi dengan gambar contoh yang disimpan di bucket penyimpanan.

Model machine learning yang disimpan di bucket penyimpanan Primus hanya dapat diakses oleh workload yang memenuhi kondisi atribut yang diperlukan. Kondisi atribut ini dijelaskan secara lebih mendetail di bagian berikutnya tentang memberikan otorisasi pada beban kerja.

Berikut adalah metode run_inference() dari beban kerja yang akan dibuat dan digunakan dalam codelab ini. Anda dapat menemukan seluruh kode beban kerja di sini.

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)}

Jalankan skrip berikut untuk membuat workload yang melakukan langkah-langkah berikut:

Buat Artifact Registry($PRIMUS_ARTIFACT_REGISTRY) yang dimiliki oleh Primus.
Perbarui kode beban kerja dengan nama resource yang diperlukan.
Bangun beban kerja ML dan buat Dockerfile untuk membangun image Docker dari kode beban kerja. Berikut adalah Dockerfile yang digunakan untuk codelab ini.
Bangun dan publikasikan image Docker ke Artifact Registry ($PRIMUS_ARTIFACT_REGISTRY) yang dimiliki oleh Primus.
Beri izin baca $WORKLOAD_SERVICEACCOUNT untuk $PRIMUS_ARTIFACT_REGISTRY. Tindakan ini diperlukan agar container workload dapat menarik image Docker workload dari Artifact Registry.

./create_workload.sh

Selain itu, workload dapat dikodekan untuk memastikan bahwa workload memuat versi model machine learning yang diharapkan dengan memeriksa hash atau tanda tangan model sebelum menggunakannya. Keuntungan dari pemeriksaan tambahan tersebut adalah memastikan integritas model machine learning. Dengan demikian, operator workload juga perlu memperbarui image workload atau parameternya saat workload diharapkan menggunakan versi model ML yang berbeda.

4. Memberi Otorisasi dan Menjalankan Beban Kerja

Memberi Otorisasi Beban Kerja

Primus ingin mengizinkan workload mengakses model machine learning-nya berdasarkan atribut resource berikut:

Apa: Kode yang diverifikasi
Tempat: Lingkungan yang aman
Siapa: Operator yang tepercaya

Primus menggunakan Workload identity federation untuk menerapkan kebijakan akses berdasarkan persyaratan ini. Workload identity federation memungkinkan Anda menentukan kondisi atribut. Kondisi ini membatasi identitas yang dapat melakukan autentikasi dengan workload identity pool (WIP). Anda dapat menambahkan Layanan Verifikasi Pengesahan ke WIP sebagai penyedia workload identity pool untuk menyajikan pengukuran dan menerapkan kebijakan.

Workload identity pool sudah dibuat sebelumnya sebagai bagian dari langkah penyiapan resource cloud. Sekarang Primus akan membuat penyedia workload identity pool OIDC baru. --attribute-condition yang ditentukan mengizinkan akses ke container workload. API ini memerlukan:

Perihal: $WORKLOAD_IMAGE_NAME terbaru diupload ke repositori $PRIMUS_ARTIFACT_REPOSITORY.
Lokasi: Trusted execution environment Confidential Space berjalan di image VM Confidential Space yang didukung sepenuhnya.
Siapa: Akun layanan Secundus $WORKLOAD_SERVICE_ACCOUNT.

export WORKLOAD_IMAGE_DIGEST=$(gcloud artifacts docker images describe ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG  --format="value(image_summary.digest)" --project ${PRIMUS_PROJECT_ID})

gcloud config set project $PRIMUS_PROJECT_ID

gcloud iam workload-identity-pools providers create-oidc $PRIMUS_WIP_PROVIDER \
  --location="global" \
  --workload-identity-pool="$PRIMUS_WORKLOAD_IDENTITY_POOL" \
  --issuer-uri="https://confidentialcomputing.googleapis.com/" \
  --allowed-audiences="https://sts.googleapis.com" \
  --attribute-mapping="google.subject='assertion.sub'" \
  --attribute-condition="assertion.swname == 'CONFIDENTIAL_SPACE' && 
'STABLE' in assertion.submods.confidential_space.support_attributes && 
assertion.submods.container.image_digest == '${WORKLOAD_IMAGE_DIGEST}' &&
 assertion.submods.container.image_reference == '${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG' && 
'$WORKLOAD_SERVICEACCOUNT@$SECUNDUS_PROJECT_ID.iam.gserviceaccount.com' in assertion.google_service_accounts"

Menjalankan Beban Kerja

Sebagai bagian dari langkah ini, kita akan menjalankan beban kerja di VM Confidential Space. Argumen TEE yang diperlukan diteruskan menggunakan flag metadata. Argumen untuk container workload diteruskan menggunakan bagian "tee-cmd" dari flag. Hasil eksekusi workload akan dipublikasikan ke $SECUNDUS_RESULT_STORAGE_BUCKET.

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

Melihat hasilnya

Setelah beban kerja berhasil diselesaikan, hasil beban kerja ML akan dipublikasikan ke $SECUNDUS_RESULT_STORAGE_BUCKET.

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

Berikut beberapa contoh tampilan hasil inferensi pada contoh gambar:

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}]}

Untuk setiap gambar sampel di bucket penyimpanan Secundus, Anda akan melihat entri dalam hasil. Entri ini akan menyertakan dua informasi utama:

Indeks predicted_class: Ini adalah indeks numerik yang merepresentasikan class yang diprediksi oleh model sebagai class gambar.
Top_k_predictions: Ini memberikan hingga k prediksi untuk gambar, yang diurutkan dari yang paling mungkin hingga yang paling tidak mungkin. Nilai k ditetapkan ke 5 dalam codelab ini, tetapi Anda dapat menyesuaikannya dalam kode workload untuk mendapatkan lebih banyak atau lebih sedikit prediksi.

Untuk menerjemahkan indeks class menjadi nama class yang dapat dibaca manusia, lihat daftar label yang tersedia di sini. Misalnya, jika Anda melihat indeks kelas 2, indeks tersebut sesuai dengan label kelas "tench" dalam daftar label.

Dalam codelab ini, kita telah mendemonstrasikan bahwa model yang dimiliki oleh Primus hanya dirilis ke beban kerja yang berjalan di TEE. Secundus menjalankan workload ML di TEE dan workload ini dapat menggunakan model yang dimiliki oleh Primus, sementara Primus tetap memiliki kontrol penuh atas model tersebut.

Menjalankan Workload yang Tidak Sah

Secundus mengubah image workload dengan menarik image workload lain dari repositori artefaknya sendiri yang tidak diizinkan oleh Primus. Workload identity pool Primus hanya mengizinkan ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG Image workload.

Menjalankan kembali workload

Saat Secundus mencoba menjalankan workload asli dengan image workload baru ini, operasi akan gagal. Untuk melihat error, hapus file hasil dan instance VM asli, lalu coba jalankan workload lagi.

Pastikan ada image Docker baru yang dipublikasikan di artifact registry Secundus (sebagai us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}) dan akun layanan workload ($WORKLOAD_SERVICEACCOUNT) telah diberi izin pembaca artifact registry untuk membaca image workload baru ini. Hal ini untuk memastikan bahwa workload tidak keluar sebelum kebijakan WIP Primus menolak token yang diberikan oleh workload.

Menghapus file hasil dan instance VM yang ada

Tetapkan project ke project $SECUNDUS_PROJECT_ID.

gcloud config set project $SECUNDUS_PROJECT_ID

Hapus file hasil.

gsutil rm gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

Hapus instance Confidential VM.

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

Jalankan workload yang tidak sah:

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

Lihat error

Alih-alih hasil beban kerja, Anda akan melihat error (The given credential is rejected by the attribute condition).

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

5. Pembersihan

Berikut adalah skrip yang dapat digunakan untuk membersihkan resource yang telah kita buat sebagai bagian dari codelab ini. Sebagai bagian dari pembersihan ini, resource berikut akan dihapus:

Bucket penyimpanan input Primus ($PRIMUS_INPUT_STORAGE_BUCKET).
Akun layanan Primus ($PRIMUS_SERVICEACCOUNT).
Repositori artefak Primus ($PRIMUS_ARTIFACT_REPOSITORY).
Workload identity pool Primus ($PRIMUS_WORKLOAD_IDENTITY_POOL).
Akun layanan workload Secundus ($WORKLOAD_SERVICEACCOUNT).
Bucket penyimpanan input Secundus ($SECUNDUS_INPUT_STORAGE_BUCKET).
Instance Compute Beban Kerja.
Bucket penyimpanan hasil Secundus ($SECUNDUS_RESULT_STORAGE_BUCKET).

$ ./cleanup.sh

Jika Anda sudah selesai menjelajah, pertimbangkan untuk menghapus project Anda.

Buka Cloud Platform Console
Pilih project yang ingin Anda nonaktifkan, lalu klik 'Hapus' di bagian atas: tindakan ini akan menjadwalkan penghapusan project

Apa selanjutnya?

Lihat beberapa codelab serupa ini...