Ochrona modeli ML i własności intelektualnej z wykorzystaniem przestrzeni poufnych

1. Przegląd

Poufna przestrzeń to bezpieczne środowisko do współpracy wielu podmiotów. W tych ćwiczeniach z programowania dowiesz się, jak za pomocą Poufnej przestrzeni chronić wrażliwą własność intelektualną, np. modele uczenia maszynowego.

W tym ćwiczeniu w Codelabs użyjesz Poufnej przestrzeni, aby umożliwić jednej firmie bezpieczne udostępnianie własnego modelu uczenia maszynowego innej firmie, która chce go używać. Firma Primus ma model uczenia maszynowego, który będzie udostępniany tylko w przypadku obciążenia działającego w Poufnej przestrzeni, co pozwoli jej zachować pełną kontrolę nad własnością intelektualną. Firma Secundus będzie operatorem zadania i uruchomi zadanie uczenia maszynowego w Poufnej przestrzeni. Secundus wczyta ten model i przeprowadzi wnioskowanie przy użyciu danych próbnych należących do Secundusa.

W tym przypadku Primus jest autorem kodu zadania i współpracownikiem, który chce chronić swoją własność intelektualną przed niezaufanym operatorem zadania, Secundusem. Secundus to operator zadania uczenia maszynowego.

Czego się nauczysz

Jak skonfigurować środowisko, w którym jedna strona może udostępniać drugiej stronie swój zastrzeżony model uczenia maszynowego, nie tracąc kontroli nad swoją własnością intelektualną.

Czego potrzebujesz

Projekt Google Cloud Platform
Podstawowa wiedza o Google Compute Engine ( codelab), maszynach wirtualnych poufnych, kontenerach i repozytoriach zdalnych
Podstawowa wiedza o kontach usługi, federacji tożsamości zadań i warunkach atrybutów.

Role w konfiguracji Poufnej przestrzeni

W tym ćwiczeniu firma Primus będzie właścicielem zasobów i autorem zbioru zadań, który będzie odpowiedzialny za:

Konfigurowanie wymaganych zasobów w chmurze za pomocą modelu uczenia maszynowego
Pisanie kodu zbioru zadań
Publikowanie obrazu zbioru zadań
Konfigurowanie zasad puli tożsamości zadań w celu ochrony modelu ML przed niezaufanym operatorem

Secundus Company będzie operatorem i będzie odpowiadać za:

konfigurowanie wymaganych zasobów w chmurze do przechowywania przykładowych obrazów używanych przez zbiór zadań i wyników;
Uruchamianie zadań uczenia maszynowego w Poufnej przestrzeni przy użyciu modelu dostarczonego przez Primus

Jak działa Poufna przestrzeń

Gdy uruchomisz zadanie w Poufnej przestrzeni, przy użyciu skonfigurowanych zasobów zostanie przeprowadzony ten proces:

Zadanie wysyła ogólny token dostępu Google dla $PRIMUS_SERVICEACCOUNT z puli tożsamości zadań. Oferuje token usługi weryfikacji atestu z deklaracjami dotyczącymi obciążenia i środowiska.
Jeśli roszczenia dotyczące pomiaru obciążenia w tokenie usługi weryfikacji atestów pasują do warunku atrybutu w tożsamości puli zadań, zwraca token dostępu do $PRIMUS_SERVICEACCOUNT.
Zadanie korzysta z tokena dostępu konta usługi powiązanego z $PRIMUS_SERVICEACCOUNT, aby uzyskać dostęp do modelu uczenia maszynowego przechowywanego w zasobniku $PRIMUS_INPUT_STORAGE_BUCKET.
Zadanie wykonuje operację na danych należących do firmy Secundus, a firma Secundus obsługuje i uruchamia to zadanie w swoim projekcie.
Zadanie używa konta usługi $WORKLOAD_SERVICEACCOUNT do zapisywania wyników tej operacji w zasobniku $SECUNDUS_RESULT_STORAGE_BUCKET.

2. Konfigurowanie zasobów w chmurze

Zanim zaczniesz

Sklonuj to repozytorium za pomocą poniższego polecenia, aby uzyskać wymagane skrypty, które są używane w tym laboratorium.

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

Zmień katalog tego ćwiczenia.

cd confidential-space/codelabs/ml_model_protection/scripts

Sprawdź, czy masz ustawione wymagane zmienne środowiskowe projektu, jak pokazano poniżej. Więcej informacji o konfigurowaniu projektu GCP znajdziesz w tym samouczku. Więcej informacji o tym, jak uzyskać identyfikator projektu i czym różni się on od nazwy i numeru projektu, znajdziesz tutaj.

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

Włącz płatności w swoich projektach.
Włącz interfejs Confidential Computing API i te interfejsy API w obu projektach.

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

Przypisz wartości do zmiennych dla nazw zasobów określonych powyżej za pomocą tego polecenia. Te zmienne umożliwiają dostosowywanie nazw zasobów do potrzeb użytkownika, a także korzystanie z istniejących zasobów, jeśli zostały już utworzone. (np.export PRIMUS_INPUT_STORAGE_BUCKET='my-input-bucket')

W projekcie Primus możesz ustawić te zmienne, używając nazw istniejących zasobów w chmurze. Jeśli zmienna jest ustawiona, zostanie użyty odpowiedni istniejący zasób w chmurze z projektu Primus. Jeśli zmienna nie jest ustawiona, nazwa zasobu w chmurze zostanie wygenerowana na podstawie nazwy projektu i zostanie utworzony nowy zasób w chmurze o tej nazwie. Poniżej znajdziesz obsługiwane zmienne nazw zasobów:

`$PRIMUS_INPUT_STORAGE_BUCKET`	Zasobnik, w którym jest przechowywany model uczenia maszynowego Primus.
`$PRIMUS_WORKLOAD_IDENTITY_POOL`	Pula tożsamości zadań Primus, która weryfikuje roszczenia.
`$PRIMUS_WIP_PROVIDER`	Dostawca puli tożsamości zadań Primus, który zawiera warunek autoryzacji do użycia w przypadku tokenów podpisanych przez usługę weryfikacji atestów.
`$PRIMUS_SERVICE_ACCOUNT`	Konto usługi Primus, którego `$PRIMUS_WORKLOAD_IDENTITY_POOL` używa do uzyskiwania dostępu do chronionych zasobów (w tym przypadku modelu ML). Na tym etapie ma uprawnienia do odczytu modelu uczenia maszynowego przechowywanego w zasobniku `$PRIMUS_INPUT_STORAGE_BUCKET`.
`$PRIMUS_ARTIFACT_REPOSITORY`	Repozytorium artefaktów, do którego zostanie przesłany obraz Dockera zadania.

W projekcie Secundus możesz ustawić te zmienne, podając nazwy istniejących zasobów w chmurze. Jeśli zmienna jest ustawiona, zostanie użyty odpowiedni istniejący zasób w projekcie Secundus. Jeśli zmienna nie jest ustawiona, nazwa zasobu w chmurze zostanie wygenerowana na podstawie nazwy projektu i zostanie utworzony nowy zasób w chmurze o tej nazwie. Poniżej znajdziesz obsługiwane zmienne nazw zasobów:

`$SECUNDUS_INPUT_STORAGE_BUCKET`	Zasobnik, w którym są przechowywane przykładowe obrazy, które Secundus chce sklasyfikować za pomocą modelu dostarczonego przez Primusa.
`$SECUNDUS_RESULT_STORAGE_BUCKET`	Zasobnik, w którym są przechowywane wyniki zadania.
`$WORKLOAD_IMAGE_NAME`	Nazwa obrazu kontenera zadania.
`$WORKLOAD_IMAGE_TAG`	Tag obrazu kontenera zbioru zadań.
`$WORKLOAD_SERVICE_ACCOUNT`	Konto usługi, które ma uprawnienia dostępu do maszyny wirtualnej poufnego środowiska, na której działa zadanie.

W przypadku tych 2 projektów musisz mieć określone uprawnienia. W tym przewodniku znajdziesz informacje o tym, jak przyznawać role uprawnień za pomocą konsoli GCP:
W przypadku $PRIMUS_PROJECT_ID musisz mieć rolę administratora pamięci, administratora Artifact Registry, administratora konta usługi i administratora puli tożsamości zadań w Uprawnieniach.
W przypadku $SECUNDUS_PROJECT_ID musisz mieć role Administrator Compute, Administrator pamięci, Administrator konta usługi, Administrator puli tożsamości zadań w Uprawnieniach i Administrator zabezpieczeń (opcjonalnie).
Uruchom ten skrypt, aby ustawić pozostałe nazwy zmiennych na wartości oparte na identyfikatorze projektu w przypadku nazw zasobów.

source config_env.sh

Konfigurowanie zasobów firmy Primus

W ramach tego kroku skonfigurujesz wymagane zasoby w chmurze dla Primusa. Aby skonfigurować zasoby dla Primusa, uruchom ten skrypt. W ramach wykonania skryptu zostaną utworzone te zasoby:

Zasobnik Cloud Storage ($PRIMUS_INPUT_STORAGE_BUCKET) do przechowywania modelu uczenia maszynowego Primus.
Pula tożsamości zadań ($PRIMUS_WORKLOAD_IDENTITY_POOL) do weryfikowania roszczeń na podstawie warunków atrybutów skonfigurowanych u jej dostawcy.
Konto usługi ($PRIMUS_SERVICEACCOUNT) dołączone do wspomnianej puli tożsamości zadań ($PRIMUS_WORKLOAD_IDENTITY_POOL) z dostępem do Uprawnień umożliwiającym odczytywanie danych z zasobnika Cloud Storage (za pomocą roli objectViewer) i łączenie tego konta usługi z pulą tożsamości zadań (za pomocą roli roles/iam.workloadIdentityUser).

W ramach konfiguracji zasobów w chmurze będziemy używać modelu TensorFlow. Możemy zapisać cały model, który zawiera architekturę, wagi i konfigurację trenowania modelu, w archiwum ZIP. Na potrzeby tego samouczka użyjemy modelu MobileNet V1 wytrenowanego na zbiorze danych ImageNet, który znajdziesz tutaj.

./setup_primus_company_resources.sh

Wymieniony wyżej skrypt skonfiguruje zasób w chmurze. Teraz pobierzemy model i opublikujemy go w zasobniku Cloud Storage utworzonym przez skrypt.

Pobierz wytrenowany model tutaj.
Po pobraniu zmień nazwę pobranego pliku tar na model.tar.gz.
Opublikuj plik model.tar.gz w zasobniku Cloud Storage, używając tego polecenia z katalogu zawierającego plik model.tar.gz.

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

Konfigurowanie zasobów firmy Secundus

W ramach tego kroku skonfigurujesz wymagane zasoby w chmurze dla Secundusa. Aby skonfigurować zasoby dla Secundusa, uruchom ten skrypt. W ramach tych działań zostaną utworzone te zasoby:

Zasobnik Cloud Storage ($SECUNDUS_INPUT_STORAGE_BUCKET) do przechowywania przykładowych obrazów na potrzeby wnioskowania przez Secundusa.
Zasobnik Cloud Storage ($SECUNDUS_RESULT_STORAGE_BUCKET) do przechowywania wyników wykonania zbioru zadań ML przez Secundusa.

Przykładowe obrazy są dostępne tutaj.

./setup_secundus_company_resources.sh

3. Tworzenie zadania

Tworzenie konta usługi zadania

Teraz utworzysz konto usługi dla obciążenia z wymaganymi rolami i uprawnieniami. Uruchom ten skrypt, aby utworzyć konto usługi obciążenia w projekcie Secundus. To konto usługi będzie używane przez maszynę wirtualną, na której działa obciążenie ML.

To konto usługi obciążenia ($WORKLOAD_SERVICEACCOUNT) będzie miało przypisane te role:

confidentialcomputing.workloadUser, aby uzyskać token atestu.
logging.logWriter – zapisywanie logów w Cloud Logging.
objectViewer – odczytywanie danych z zasobnika Cloud Storage $SECUNDUS_INPUT_STORAGE_BUCKET.
objectUser, aby zapisać wynik zbioru zadań w zasobniku Cloud Storage $SECUNDUS_RESULT_STORAGE_BUCKET.

./create_workload_service_account.sh

Tworzenie zadania

W ramach tego kroku utworzysz obraz Dockera zbioru zadań. Zadanie zostanie utworzone przez Primusa. Zadanie użyte w tym module to kod w Pythonie do uczenia maszynowego, który uzyskuje dostęp do modelu ML przechowywanego w zasobniku Primusa i przeprowadza wnioskowanie na podstawie przykładowych obrazów przechowywanych w zasobniku.

Model uczenia maszynowego przechowywany w zasobniku Primus będzie dostępny tylko dla zadań spełniających wymagane warunki atrybutów. Warunki atrybutów są opisane bardziej szczegółowo w następnej sekcji dotyczącej autoryzacji obciążenia.

Oto metoda run_inference() obciążenia, które zostanie utworzone i użyte w tym ćwiczeniu. Pełny kod obciążenia znajdziesz tutaj.

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

Uruchom ten skrypt, aby utworzyć zadanie, w którym wykonywane są te czynności:

Utwórz Artifact Registry($PRIMUS_ARTIFACT_REGISTRY) należący do Primusa.
Zaktualizuj kod zbioru zadań, podając nazwy wymaganych zasobów.
Skompiluj zadanie ML i utwórz plik Dockerfile do skompilowania obrazu Dockera z kodem zadania. Tutaj znajdziesz plik Dockerfile użyty w tych ćwiczeniach z programowania.
Utwórz obraz Dockera i opublikuj go w Artifact Registry ($PRIMUS_ARTIFACT_REGISTRY) należącym do firmy Primus.
Przyznaj usłudze $WORKLOAD_SERVICEACCOUNT uprawnienia do odczytu $PRIMUS_ARTIFACT_REGISTRY. Jest to potrzebne, aby kontener zbioru zadań mógł pobrać obraz Dockera zbioru zadań z Artifact Registry.

./create_workload.sh

Dodatkowo obciążenia można kodować tak, aby przed użyciem modelu uczenia maszynowego sprawdzać jego skrót lub sygnaturę, co pozwala mieć pewność, że wczytywana jest oczekiwana wersja modelu. Zaletą takich dodatkowych kontroli jest to, że zapewniają one integralność modelu uczenia maszynowego. W takim przypadku operator obciążenia musi też zaktualizować obraz obciążenia lub jego parametry, gdy obciążenie ma używać różnych wersji modelu ML.

4. Autoryzowanie i uruchamianie zbioru zadań

Autoryzowanie zadania

Firma Primus chce autoryzować obciążenia, aby miały dostęp do jej modelu uczenia maszynowego na podstawie atrybutów tych zasobów:

Co: kod, który został zweryfikowany.
Gdzie: bezpieczne środowisko.
Kto: zaufany operator

Primus używa federacji tożsamości zadań, aby egzekwować zasady dostępu oparte na tych wymaganiach. Federacja tożsamości zadań umożliwia określanie warunków atrybutów. Te warunki ograniczają tożsamości, które mogą uwierzytelniać się w puli tożsamości zadań. Usługę weryfikacji zaświadczeń możesz dodać do puli tożsamości zadań jako dostawcę puli tożsamości zadań, aby przedstawiać pomiary i egzekwować zasady.

Pula tożsamości zadań została utworzona wcześniej w ramach konfiguracji zasobów w chmurze. Primus utworzy teraz nowego dostawcę puli tożsamości zadań OIDC. Określony --attribute-condition autoryzuje dostęp do kontenera zbioru zadań. Wymagania:

Co: najnowsza wersja $WORKLOAD_IMAGE_NAME została przesłana do repozytorium $PRIMUS_ARTIFACT_REPOSITORY.
Miejsce: zaufane środowisko wykonawcze Poufnej przestrzeni działa na w pełni obsługiwanym obrazie maszyny wirtualnej Poufnej przestrzeni.
Kto: konto usługi 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"

Uruchamianie zadania

W ramach tego kroku uruchomimy zadanie w maszynie wirtualnej Poufnej przestrzeni. Wymagane argumenty TEE są przekazywane za pomocą flagi metadanych. Argumenty kontenera zbioru zadań są przekazywane za pomocą części „tee-cmd” flagi. Wynik wykonania zadania zostanie opublikowany w $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}

Pokaż wyniki

Po zakończeniu zadania ML jego wynik zostanie opublikowany w $SECUNDUS_RESULT_STORAGE_BUCKET.

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

Oto kilka przykładów wyników wnioskowania na przykładowych obrazach:

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

W przypadku każdego przykładowego obrazu w zasobniku Secundus w wynikach zobaczysz wpis. Wpis ten będzie zawierać 2 najważniejsze informacje:

Indeks predicted_class: jest to indeks numeryczny reprezentujący klasę, do której według modelu należy obraz.
Top_k_predictions: ta funkcja podaje do k prognoz dla obrazu, uszeregowanych od najbardziej do najmniej prawdopodobnych. W tym laboratorium wartość k jest ustawiona na 5, ale możesz ją dostosować w kodzie zadania, aby uzyskać więcej lub mniej prognoz.

Aby przetłumaczyć indeks klasy na czytelną nazwę klasy, zapoznaj się z listą etykiet dostępną tutaj. Jeśli na przykład zobaczysz indeks klasy 2, odpowiada on etykiecie klasy „tench” na liście etykiet.

W tym laboratorium kodowania pokazaliśmy, że model należący do firmy Primus jest udostępniany tylko zadaniu działającemu w środowisku TEE. Secundus uruchamia zadanie uczenia maszynowego w środowisku TEE, które może korzystać z modelu należącego do Primusa, a Primus zachowuje pełną kontrolę nad tym modelem.

Uruchamianie nieautoryzowanego zadania

Secundus zmienia obraz zadania, pobierając inny obraz zadania z własnego repozytorium artefaktów, które nie jest autoryzowane przez Primusa. Pula tożsamości zadań Primus autoryzowała tylko obraz zadania ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG.

Ponowne uruchomienie zadania

Gdy Secundus spróbuje uruchomić pierwotne zadanie za pomocą tego nowego obrazu zadania, operacja się nie powiedzie. Aby wyświetlić błąd, usuń oryginalny plik wyników i instancję maszyny wirtualnej, a potem spróbuj ponownie uruchomić zadanie.

Sprawdź, czy w Artifact Registry w Secundus (jako us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}) opublikowano nowy obraz Dockera i czy konto usługi obciążenia ($WORKLOAD_SERVICEACCOUNT) ma uprawnienia czytelnika Artifact Registry do odczytu tego nowego obrazu obciążenia. Dzięki temu zadanie nie zostanie zakończone, zanim zasady WIP usługi Primus odrzucą token przedstawiony przez zadanie.

Usuwanie istniejącego pliku wyników i instancji maszyny wirtualnej

Ustaw projekt na projekt $SECUNDUS_PROJECT_ID.

gcloud config set project $SECUNDUS_PROJECT_ID

Usuń plik z wynikami.

gsutil rm gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

Usuń instancję poufnej maszyny wirtualnej.

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

Uruchom nieautoryzowane zadanie:

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}

Wyświetl błąd

Zamiast wyników zadania widzisz błąd (The given credential is rejected by the attribute condition).

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

5. Czyszczenie

Tutaj znajdziesz skrypt, którego możesz użyć do usunięcia zasobów utworzonych w ramach tego ćwiczenia z programowania. W ramach tego czyszczenia zostaną usunięte te zasoby:

Zasobnik wejściowy Primus ($PRIMUS_INPUT_STORAGE_BUCKET).
Konto usługi Primus ($PRIMUS_SERVICEACCOUNT).
Repozytorium artefaktów Primus ($PRIMUS_ARTIFACT_REPOSITORY).
Pula tożsamości zadań Primus ($PRIMUS_WORKLOAD_IDENTITY_POOL).
Konto usługi zadań Secundus ($WORKLOAD_SERVICEACCOUNT).
Zasobnik wejściowy Secundus ($SECUNDUS_INPUT_STORAGE_BUCKET).
Instancje obliczeniowe zbioru zadań.
Zasobnik wyników Secundus ($SECUNDUS_RESULT_STORAGE_BUCKET).

$ ./cleanup.sh

Jeśli skończysz eksplorowanie, rozważ usunięcie projektu.

Otwórz konsolę Cloud Platform.
Wybierz projekt, który chcesz wyłączyć, a następnie kliknij „Usuń” u góry. Spowoduje to zaplanowanie usunięcia projektu.

Co dalej?

Sprawdź te podobne ćwiczenia...