Ta strona została przetłumaczona przez Cloud Translation API.

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

1. Omówienie

Obszar poufny zapewnia bezpieczne środowisko do współpracy między wieloma osobami. To ćwiczenie w Codelabs pokazuje, jak wykorzystać Poufne przestrzenie do ochrony poufnej własności intelektualnej, np. modeli systemów uczących się.

W ramach tego ćwiczenia w Codelabs wykorzystasz Poufne przestrzenie, aby jedna firma mogła bezpiecznie udostępniać jej własny model systemów uczących się innej firmie, która zechce z niego korzystać. Przede wszystkim firma Primus ma model systemów uczących się, który zostałby zwolniony wyłącznie dla zadań działających w przestrzeni poufnej. Dzięki temu firma Primus może zachować pełną kontrolę nad swoją własnością intelektualną. Operatorem zadań będzie firma Secundus, która uruchomi zadanie systemów uczących się w obszarze poufnym. Secundus wczyta ten model i uruchomi wnioskowanie z użyciem przykładowych danych należących do tej firmy.

W tym przypadku Primus to autor zadania, który jest autorem kodu zbioru zadań, oraz współpracownik, który chce chronić swoją własność intelektualną przed niezaufanym operatorem zbioru zadań – Secundusem. Secundus to operator zbioru zadań zbioru zadań systemów uczących się.

Czego się nauczysz

Jak skonfigurować środowisko, w którym jedna ze stron może udostępniać swój zastrzeżony model ML innej stronie bez utraty kontroli nad swoją własnością intelektualną.

Czego potrzebujesz

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

Role powiązane w konfiguracji Pokoju poufnego

W tym ćwiczeniu w Codelabs firma Primus będzie właścicielem zasobu i autorem zadania, która będzie odpowiadać za:

Konfigurowanie wymaganych zasobów w chmurze za pomocą modelu systemów uczących się
Pisanie kodu zadania
Publikuję obraz zadania
Konfigurowanie zasady puli Workload Identity w celu ochrony modelu ML przed niezaufanym operatorem

Operatorem sieci będzie Secundus Company. Jego obowiązki to:

Konfiguruję zasoby w chmurze do przechowywania przykładowych obrazów używanych przez zadanie i wyniki
Uruchamianie zadania ML w przestrzeni poufnej z użyciem modelu dostarczonego przez Primus

Jak działa Obszar poufny

Gdy uruchomisz zadanie w obszarze poufnym, zachodzi poniższy proces z użyciem skonfigurowanych zasobów:

Zadanie wysyła do puli tożsamości Workspace ogólny token dostępu Google dla platformy $PRIMUS_SERVICEACCOUNT. Oferuje token usługi weryfikatora atestów z deklaracjami zadań i środowiska.
Jeśli deklaracje pomiaru zbiorów zadań w tokenie usługi weryfikatora atestów pasują do warunku atrybutu w trakcie opracowywania, zwraca token dostępu dla $PRIMUS_SERVICEACCOUNT.
Zadanie używa tokena dostępu konta usługi powiązanego z zasadą $PRIMUS_SERVICEACCOUNT, aby uzyskać dostęp do modelu systemów uczących się zapisanego w zasobniku $PRIMUS_INPUT_STORAGE_BUCKET.
Zbiór zadań wykonuje operację na danych należących do firmy Secundus, która jest obsługiwana i uruchamiana przez tę firmę w jej projekcie.
Zbiór zadań używa konta usługi $WORKLOAD_SERVICEACCOUNT do zapisywania wyników tej operacji w zasobniku $SECUNDUS_RESULT_STORAGE_BUCKET.

2. Konfigurowanie zasobów Cloud

Zanim zaczniesz

Skopiuj to repozytorium za pomocą poniższego polecenia, aby uzyskać wymagane skrypty używane w ramach tego ćwiczenia z programowania.

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

Zmień katalog przeznaczony do ćwiczenia w Codelabs.

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 ćwiczeniu z programowania. Tutaj znajdziesz szczegółowe informacje o tym, jak pobrać identyfikator projektu oraz czym różni się on od nazwy i numeru projektu.

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 w obu projektach interfejs Confidential Computing API i poniższe interfejsy API.

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 nazw zasobów podanych powyżej, korzystając z następującego polecenia. Dzięki tym zmiennym możesz dostosowywać nazwy zasobów do swoich potrzeb i korzystać 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ć następujące zmienne z istniejącymi nazwami zasobów w chmurze. Jeśli zmienna jest ustawiona, używany jest odpowiedni istniejący zasób w chmurze z projektu Primus. Jeśli zmienna nie zostanie ustawiona, nazwa zasobu w chmurze będzie generowana na podstawie nazwy projektu, a nowy zasób w chmurze zostanie utworzony o tej nazwie. Oto obsługiwane zmienne nazw zasobów:

`$PRIMUS_INPUT_STORAGE_BUCKET`	Zasobnik, w którym jest przechowywany model systemów uczących się Primus.
`$PRIMUS_WORKLOAD_IDENTITY_POOL`	Pula tożsamości zadań (WIP) Primus, która weryfikuje deklaracje.
`$PRIMUS_WIP_PROVIDER`	Dostawca puli tożsamości zadań Primus, który zawiera warunek autoryzacji używany w przypadku tokenów podpisanych przez usługę Weryfikator atestu.
`$PRIMUS_SERVICE_ACCOUNT`	Konto usługi Primus używane przez `$PRIMUS_WORKLOAD_IDENTITY_POOL` do uzyskiwania dostępu do zabezpieczonych zasobów (model ML w tym ćwiczeniu w Codelabs). Na tym etapie ma uprawnienia do odczytu modelu systemów uczących się zapisanego w zasobniku `$PRIMUS_INPUT_STORAGE_BUCKET`.
`$PRIMUS_ARTIFACT_REPOSITORY`	Repozytorium artefaktów, w którym zostanie wypchnięty obraz Dockera zadania.

W projekcie Secundus możesz ustawić poniższe zmienne z istniejącymi nazwami zasobów w chmurze. Jeśli zmienna jest ustawiona, zostanie użyty odpowiedni istniejący zasób w chmurze z projektu Secundus. Jeśli zmienna nie zostanie ustawiona, nazwa zasobu w chmurze zostanie wygenerowana na podstawie nazwy projektu i zostanie utworzony nowy zasób w chmurze o tej nazwie. Oto obsługiwane zmienne nazw zasobów:

`$SECUNDUS_INPUT_STORAGE_BUCKET`	Zasobnik, w którym przechowywane są przykładowe obrazy, które Secundus chce sklasyfikować za pomocą modelu dostarczonego przez Primus.
`$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 zadania.
`$WORKLOAD_SERVICE_ACCOUNT`	Konto usługi z uprawnieniami dostępu do poufnej maszyny wirtualnej, na której działa zadanie.

Musisz mieć określone uprawnienia do tych 2 projektów. Aby dowiedzieć się, jak przypisywać role uprawnień za pomocą konsoli GCP, zapoznaj się z tym przewodnikiem:
W przypadku $PRIMUS_PROJECT_ID potrzebujesz administratora miejsca na dane, administratora Artifact Registry, administratora kont usługi i administratora puli Workload Identity.
W przypadku $SECUNDUS_PROJECT_ID potrzebujesz administratora Compute, administratora miejsca na dane, administratora kont usługi, administratora puli Workload Identity i administratora zabezpieczeń (opcjonalnie).
Uruchom ten skrypt, aby ustawić pozostałe nazwy zmiennych zgodnie z identyfikatorem projektu dla nazw zasobów.

source config_env.sh

Konfigurowanie zasobów Primus Company

W tym kroku skonfigurujesz wymagane zasoby w chmurze na potrzeby Primus. Uruchom następujący skrypt, aby skonfigurować zasoby Primus. W ramach wykonywania skryptu zostaną utworzone te zasoby:

Zasobnik Cloud Storage ($PRIMUS_INPUT_STORAGE_BUCKET) do przechowywania modelu systemów uczących się Primus.
Pula tożsamości zadań ($PRIMUS_WORKLOAD_IDENTITY_POOL) do weryfikacji deklaracji na podstawie warunków atrybutów skonfigurowanych u jej dostawcy.
Konto usługi ($PRIMUS_SERVICEACCOUNT) połączone z wyżej wspomnianą pulą tożsamości zadań ($PRIMUS_WORKLOAD_IDENTITY_POOL) z uprawnieniami do odczytu danych z zasobnika Cloud Storage (z użyciem roli objectViewer) oraz do łączenia tego konta usługi z pulą tożsamości zadań (z użyciem roli roles/iam.workloadIdentityUser).

W ramach konfiguracji zasobów w chmurze użyjemy modelu TensorFlow. Cały model wraz z jego architekturą, wagami i konfiguracją trenowania możemy zapisać w archiwum ZIP. Na potrzeby tego ćwiczenia w Codelabs użyjemy modelu MobileNet V1 wytrenowanego na zbiorze danych ImageNet, który można znaleźć tutaj.

./setup_primus_company_resources.sh

Powyższy skrypt skonfiguruje zasób w chmurze. Teraz pobierzemy i opublikujemy model w zasobniku Cloud Storage utworzonym przez ten skrypt.

Pobierz już wytrenowany model stąd.
Po pobraniu zmień nazwę pobranego pliku tar na model.tar.gz.
Opublikuj plik model.tar.gz w zasobniku Cloud Storage za pomocą tego polecenia z katalogu zawierającego plik model.tar.gz.

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

Konfigurowanie zasobów Secundus Company

W tym kroku skonfigurujesz wymagane zasoby w chmurze na potrzeby Secundus. Uruchom następujący skrypt, aby skonfigurować zasoby Secundus. Część tych czynności utworzy te zasoby:

Zasobnik Cloud Storage ($SECUNDUS_INPUT_STORAGE_BUCKET) do przechowywania przykładowych obrazów na potrzeby uruchamiania wnioskowania według Secundusa.
Zasobnik Cloud Storage ($SECUNDUS_RESULT_STORAGE_BUCKET) do przechowywania wyniku wykonania zadania ML przez Secundus.

Kilka przykładowych obrazów do ćwiczeń z programowania znajdziesz tutaj.

./setup_secundus_company_resources.sh

3. Utwórz zadanie

Utwórz konto usługi zadań

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

To konto usługi zadań ($WORKLOAD_SERVICEACCOUNT) będzie miało przypisane te role:

confidentialcomputing.workloadUser, aby uzyskać token atestu
logging.logWriter, aby zapisać logi w Cloud Logging.
objectViewer, aby odczytać dane z zasobnika Cloud Storage $SECUNDUS_INPUT_STORAGE_BUCKET.
objectUser, aby zapisać wynik zadania w zasobniku Cloud Storage $SECUNDUS_RESULT_STORAGE_BUCKET.

./create_workload_service_account.sh

Utwórz zadanie

W tym kroku utworzysz obraz Dockera zadania. Zadanie zostanie utworzone przez Primusa. Zbiór zadań używany w tym ćwiczeniu z programowania to kod w języku Python systemów uczących się, który uzyskuje dostęp do modelu ML zapisanego w zasobniku na dane Primus i wykonuje wnioskowania z przykładowymi obrazami, które są przechowywane w zasobniku na dane.

Model systemów uczących się zapisany w zasobniku na dane Primus byłby dostępny tylko dla zbiorów zadań, które spełniają wymagane warunki atrybutów. Więcej informacji o tych warunkach atrybutów znajdziesz w następnej sekcji dotyczącej autoryzacji zadania.

Oto metoda run_inference() zadania, które zostanie utworzone i użyte w tym ćwiczeniu z programowania. Cały kod zadania 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 kroki:

Tworzenie Artifact Registry($PRIMUS_ARTIFACT_REGISTRY) należącego do Primus.
Zaktualizuj kod zadania o wymagane nazwy zasobów.
Skompiluj zadanie ML i utwórz plik Dockerfile, aby utworzyć obraz Dockera kodu zadania. Tutaj znajdziesz plik Dockerfile użyty w tym ćwiczeniu z programowania.
Skompiluj i opublikuj obraz Dockera w Artifact Registry ($PRIMUS_ARTIFACT_REGISTRY) należącym do firmy Primus.
Przyznaj maszynie wirtualnej $WORKLOAD_SERVICEACCOUNT uprawnienia do odczytu dla: $PRIMUS_ARTIFACT_REGISTRY. Jest to konieczne, aby kontener zbioru zadań mógł pobierać z Artifact Registry obraz Dockera zadania.

./create_workload.sh

Dodatkowo zadania można zaprogramować tak, aby mieć pewność, że wczytują oczekiwaną wersję modelu systemów uczących się, sprawdzając hasz lub podpis modelu przed jego użyciem. Zaletą takich dodatkowych kontroli jest to, że zapewniają one integralność modelu systemów uczących się. W takiej sytuacji operator zbioru zadań musiałby też zaktualizować obraz zadania lub jego parametry, gdy zadanie ma używać różnych wersji modelu ML.

4. Autoryzuj i uruchom zadanie

Autoryzuj zadanie

Primus chce autoryzować zadania dostępu do modelu systemów uczących się na podstawie atrybutów tych zasobów:

Co: zweryfikowany kod.
Gdzie: bezpieczne środowisko.
Kto: zaufany operator.

Primus używa federacji tożsamości zadań, aby egzekwować zasadę dostępu na podstawie tych wymagań. Federacja tożsamości zadań umożliwia określanie warunków atrybutów. Te warunki ograniczają to, które tożsamości mogą być uwierzytelniane za pomocą puli tożsamości zadań (WIP). Możesz dodać usługę weryfikatora atestu do raportu WIP jako dostawcę puli tożsamości zadań, aby prezentować pomiary i egzekwować zasadę.

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

Aktualizacja: plik $WORKLOAD_IMAGE_NAME ostatnio przesłany do repozytorium $PRIMUS_ARTIFACT_REPOSITORY.
Gdzie: zaufane środowisko wykonawcze Poufnego obszaru wykonawczego działa na w pełni obsługiwanym obrazie maszyny wirtualnej Confidential Przestrzeń.
Kto: konto usługi Secundus $WORKLOAD_SERVICE_ACCOUNT.

export WORKLOAD_IMAGE_DIGEST=$(docker images –digests ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_ARTIFACT_REPOSITORY}/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}| awk 'NR>1{ print $3 }')

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"

Uruchom zadanie

W ramach tego kroku uruchomimy zadanie w maszynie wirtualnej Poufnej przestrzeni. Wymagane argumenty TEE są przekazywane przy użyciu flagi metadanych. Argumenty kontenera zadania są przekazywane za pomocą funkcji „tee-cmd” tej części flagi. Wynik wykonania zadania zostanie opublikowany w usłudze $SECUNDUS_RESULT_STORAGE_BUCKET.

gcloud config set project $SECUNDUS_PROJECT_ID

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=TERMINATE \
 --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}

Wyświetl wyniki

Po zakończeniu zadania jego wynik zostanie opublikowany w usłudze $SECUNDUS_RESULT_STORAGE_BUCKET.

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

Oto kilka przykładów, jak mogą wyglądać wyniki 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 wynikach wyświetli się odpowiedni wpis dla każdego przykładowego obrazu w zasobniku na dane Secundus. Wpis będzie zawierał 2 kluczowe informacje:

Indeks klasy prognozy:jest to indeks liczbowy reprezentujący klasę, do której według prognoz model należy obraz.
Top_k_predictions::ta opcja zapewnia do tys. prognoz dla obrazu posortowanych w kolejności od najbardziej do najmniej prawdopodobnych. W tym ćwiczeniu z programowania 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 klas na czytelną dla człowieka nazwę klasy, zapoznaj się z listą etykiet dostępną tutaj. Jeśli na przykład indeks klas wynosi 2, odpowiada on etykiecie klasy „tench”. na liście etykiet.

W tym ćwiczeniu w Codelabs pokazaliśmy, że model należący do Primusa, który jest dostępny tylko dla zadania uruchomionego w TEE. Secundus uruchamia zbiór zadań ML w TEE i może pobierać model należący do Primus, podczas gdy Primus zachowuje pełną kontrolę nad modelem.

Uruchom nieautoryzowane zadanie

Secundus zmienia obraz zbioru zadań przez pobranie innego obrazu zbioru zadań z własnego repozytorium artefaktów, które nie jest autoryzowane przez Primus. 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 z tym nowym obrazem zbioru zadań, zakończy się niepowodzeniem. Aby wyświetlić błąd, usuń pierwotny plik wyników i instancję maszyny wirtualnej, a następnie spróbuj ponownie uruchomić zadanie.

Sprawdź, czy w rejestrze artefaktów Secundus (jako us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}) i koncie usługi zadań ($WORKLOAD_SERVICEACCOUNT) został opublikowany nowy obraz Dockera, który przyznał uprawnienia odczytującego artefakty rejestru do odczytu tego nowego obrazu zadania. Ma to na celu zapewnienie, że zadanie nie zostanie zakończone, zanim zasada WIP Primus odrzuci token przedstawiony przez zadanie.

Usuń istniejący plik wyników i instancję maszyny wirtualnej

Ustaw projekt na ten projekt: $SECUNDUS_PROJECT_ID.

gcloud config set project $SECUNDUS_PROJECT_ID

Usuń plik z wynikami.

gsutil rm gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

usunąć instancję poufnej maszyny wirtualnej,

gcloud compute instances delete ${WORKLOAD_VM}

Uruchom nieautoryzowane zadanie:

gcloud compute instances create ${WORKLOAD_VM} \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=TERMINATE \
 --scopes=cloud-platform --zone=${SECUNDUS_PROJECT_ZONE} \
 --image-project=confidential-space-images \
 --image-family=confidential-space \ 
--service-account=${WORKLOAD_SERVICE_ACCOUNT}@${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 zobaczysz 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 wyczyszczenia zasobów, które utworzyliśmy w ramach tego ćwiczenia. W ramach tego czyszczenia zostaną usunięte te zasoby:

Wejściowy zasobnik pamięci masowej 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).
Wejściowy zasobnik na dane usługi Secundus ($SECUNDUS_INPUT_STORAGE_BUCKET).
Instancje Compute zadań.
Zasobnik na dane wyników usługi Secundus ($SECUNDUS_RESULT_STORAGE_BUCKET).

$ ./cleanup.sh

Po zakończeniu analizy rozważ usunięcie projektu.

Otwórz konsolę Cloud Platform.
Wybierz projekt, który chcesz wyłączyć, i kliknij „Usuń”. u góry: powoduje zaplanowanie usunięcia projektu

Co dalej?

Zapoznaj się z podobnymi ćwiczeniami z programowania...