Protezione dei modelli ML e della proprietà intellettuale utilizzando Confidential Space

1. Panoramica

Confidential Space offre un ambiente sicuro per la collaborazione tra più parti. Questo codelab mostra come Confidential Space può essere utilizzato per proteggere la proprietà intellettuale sensibile, come i modelli di machine learning.

In questo codelab utilizzerai Spazio riservato per consentire a un'azienda di condividere in modo sicuro il proprio modello di machine learning proprietario con un'altra azienda che vuole utilizzarlo. Nello specifico, la società Primus ha un modello di machine learning che verrà rilasciato solo a un carico di lavoro in esecuzione in uno spazio riservato, consentendo a Primus di mantenere il controllo completo sulla sua proprietà intellettuale. La società Secundus sarà l'operatore del carico di lavoro ed eseguirà il carico di lavoro di machine learning in uno spazio riservato. Secundus caricherà questo modello ed eseguirà un'inferenza utilizzando i dati di esempio di sua proprietà.

In questo caso, Primus è l'autore del codice del carico di lavoro e un collaboratore che vuole proteggere la propria proprietà intellettuale dall'operatore del carico di lavoro non attendibile, Secundus. Secundus è l'operatore del carico di lavoro di machine learning.

Cosa imparerai a fare

• Come configurare un ambiente in cui una parte può condividere il proprio modello ML proprietario con un'altra parte senza perdere il controllo sulla propria proprietà intellettuale.

Che cosa ti serve

• Un progetto Google Cloud
• Conoscenze di base di Google Compute Engine ( codelab), Confidential VM, container e repository remoti
• Conoscenze di base su account di servizio, Federazione delle identità per i carichi di lavoro e condizioni degli attributi.

Ruoli coinvolti nella configurazione di uno spazio riservato

In questo codelab, la società Primus sarà il proprietario della risorsa e l'autore del carico di lavoro, responsabile di quanto segue:

1. Configurazione delle risorse cloud richieste con un modello di machine learning
2. Scrittura del codice del carico di lavoro
3. Pubblicazione dell'immagine del workload
4. Configurazione del criterio del pool di identità del workload per proteggere il modello ML da un operatore non attendibile

La Società Secundus sarà l'operatore e responsabile di:

1. Configurazione delle risorse cloud necessarie per archiviare le immagini di esempio utilizzate dal carico di lavoro e i risultati
2. Eseguire il carico di lavoro ML in Confidential Space utilizzando il modello fornito da Primus

Come funziona Spazio riservato

Quando esegui il carico di lavoro in Confidential Space, viene eseguita la seguente procedura utilizzando le risorse configurate:

1. Il carico di lavoro richiede un token di accesso a Google generale per $PRIMUS_SERVICEACCOUNT dal pool Workload Identity. Offre un token di servizio Attestation Verifier con claim relativi a workload e ambiente.
2. Se le rivendicazioni di misurazione del carico di lavoro nel token del servizio di verifica dell'attestazione corrispondono alla condizione dell'attributo nel WIP, viene restituito il token di accesso per $PRIMUS_SERVICEACCOUNT.
3. Il carico di lavoro utilizza il token di accesso all'account di servizio associato a $PRIMUS_SERVICEACCOUNT per accedere al modello di machine learning archiviato nel bucket $PRIMUS_INPUT_STORAGE_BUCKET.
4. Il carico di lavoro esegue un'operazione sui dati di proprietà di Secundus e viene gestito ed eseguito da Secundus nel suo progetto.
5. Il carico di lavoro utilizza l'account di servizio $WORKLOAD_SERVICEACCOUNT per scrivere i risultati dell'operazione nel bucket $SECUNDUS_RESULT_STORAGE_BUCKET.

2. Configurare le risorse cloud

Prima di iniziare

• Clona questo repository utilizzando il comando riportato di seguito per ottenere gli script richiesti utilizzati nell'ambito di questo codelab.

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

• Modifica la directory per questo codelab.

cd confidential-space/codelabs/ml_model_protection/scripts

• Assicurati di aver impostato le variabili di ambiente del progetto richieste come mostrato di seguito. Per ulteriori informazioni sulla configurazione di un progetto Google Cloud, consulta questo codelab. Puoi fare riferimento a questa pagina per informazioni dettagliate su come recuperare l'ID progetto e su come si differenzia dal nome e dal numero di progetto.

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

• Attiva la fatturazione per i tuoi progetti.
• Abilita l'API Confidential Computing e le API seguenti per entrambi i progetti.

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

• Assegna i valori alle variabili per i nomi delle risorse specificati sopra utilizzando il seguente comando. Queste variabili ti consentono di personalizzare i nomi delle risorse in base alle esigenze e di utilizzare anche le risorse esistenti, se sono già state create. (ad es.export PRIMUS_INPUT_STORAGE_BUCKET='my-input-bucket')

1. Puoi impostare le seguenti variabili con i nomi delle risorse cloud esistenti nel progetto Primus. Se la variabile è impostata, verrà utilizzata la risorsa cloud esistente corrispondente del progetto Primus. Se la variabile non è impostata, il nome della risorsa cloud viene generato da project-name e la nuova risorsa cloud viene creata con questo nome. Di seguito sono riportate le variabili supportate per i nomi delle risorse:

$PRIMUS_INPUT_STORAGE_BUCKET	Il bucket che memorizza il modello di machine learning di Primus.
$PRIMUS_WORKLOAD_IDENTITY_POOL	Il pool di identità del workload (WIP) di Primus che convalida le rivendicazioni.
$PRIMUS_WIP_PROVIDER	Il fornitore del pool di identità del workload di Primus che include la condizione di autorizzazione da utilizzare per i token firmati dal servizio di verifica dell'attestazione.
$PRIMUS_SERVICE_ACCOUNT	Account di servizio Primus utilizzato da $PRIMUS_WORKLOAD_IDENTITY_POOL per accedere alle risorse protette (modello ML in questo codelab). In questo passaggio ha l'autorizzazione a leggere il modello di machine learning archiviato nel bucket $PRIMUS_INPUT_STORAGE_BUCKET.
$PRIMUS_ARTIFACT_REPOSITORY	Il repository di artefatti in cui verrà inviata l'immagine Docker del carico di lavoro.

2. Puoi impostare le seguenti variabili con i nomi delle risorse cloud esistenti nel progetto Secundus. Se la variabile è impostata, verrà utilizzata la risorsa cloud esistente corrispondente del progetto Secundus. Se la variabile non è impostata, il nome della risorsa cloud viene generato dal nome del progetto e viene creata una nuova risorsa cloud con quel nome. Di seguito sono riportate le variabili supportate per i nomi delle risorse:

$SECUNDUS_INPUT_STORAGE_BUCKET	Il bucket che memorizza le immagini di esempio che Secundus vuole classificare utilizzando il modello fornito da Primus.
$SECUNDUS_RESULT_STORAGE_BUCKET	Il bucket in cui vengono archiviati i risultati del carico di lavoro.
$WORKLOAD_IMAGE_NAME	Il nome dell'immagine del contenitore del carico di lavoro.
$WORKLOAD_IMAGE_TAG	Il tag dell'immagine container del carico di lavoro.
$WORKLOAD_SERVICE_ACCOUNT	L'account di servizio che ha l'autorizzazione per accedere alla VM con accesso riservato che esegue il workload.

• Per questi due progetti sono necessarie autorizzazioni specifiche. Puoi consultare questa guida su come concedere i ruoli IAM utilizzando la console Google Cloud:
• Per $PRIMUS_PROJECT_ID, avrai bisogno di Storage Admin, Artifact Registry Administrator, Service Account Admin, IAM Workload Identity Pool Admin.
• Per $SECUNDUS_PROJECT_ID, avrai bisogno di Amministratore Compute, Amministratore archiviazione, Amministratore account di servizio, Amministratore pool Workload Identity IAM, Amministratore sicurezza (facoltativo).
• Esegui il seguente script per impostare i nomi delle variabili rimanenti su valori basati sull'ID progetto per i nomi delle risorse.

source config_env.sh

Configurare le risorse della società Primus

In questo passaggio, configurerai le risorse cloud necessarie per Primus. Esegui il seguente script per configurare le risorse per Primus. Nell'ambito dell'esecuzione dello script verranno create le seguenti risorse:

• Bucket Cloud Storage ($PRIMUS_INPUT_STORAGE_BUCKET) per archiviare il modello di machine learning di Primus.
• Pool di identità del workload ($PRIMUS_WORKLOAD_IDENTITY_POOL) per convalidare i claim in base alle condizioni degli attributi configurate nel relativo provider.
• Account di servizio ($PRIMUS_SERVICEACCOUNT) associato al pool di identità di carico di lavoro ($PRIMUS_WORKLOAD_IDENTITY_POOL) sopra indicato con accesso IAM per leggere i dati dal bucket di archiviazione sul cloud (utilizzando il ruolo objectViewer) e per connettere questo account di servizio al pool di identità di carico di lavoro (utilizzando il ruolo roles/iam.workloadIdentityUser).

Nell'ambito di questa configurazione delle risorse cloud, utilizzeremo un modello TensorFlow. Possiamo salvare l'intero modello, che include l'architettura, i pesi e la configurazione dell'addestramento, in un archivio ZIP. Ai fini di questo codelab, utilizzeremo il modello MobileNet V1 addestrato sul set di dati ImageNet disponibile qui.

./setup_primus_company_resources.sh

Lo script sopra indicato configurerà la risorsa cloud. Ora scaricheremo e pubblicheremo il modello nel bucket Cloud Storage creato dallo script.

1. Scarica il modello preaddestrato da qui.
2. Una volta scaricato, rinomina il file tar scaricato in model.tar.gz.
3. Pubblica il file model.tar.gz nel bucket Cloud Storage utilizzando il seguente comando dalla directory contenente il file model.tar.gz.

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

Configura le risorse della società Secundus

In questo passaggio, configurerai le risorse cloud necessarie per Secundus. Esegui il seguente script per configurare le risorse per Secundus. Nell'ambito di questi passaggi verranno create le seguenti risorse:

• Bucket Cloud Storage ($SECUNDUS_INPUT_STORAGE_BUCKET) per archiviare le immagini di esempio per l'esecuzione di inferenze da parte di Secundus.
• Bucket Cloud Storage ($SECUNDUS_RESULT_STORAGE_BUCKET) per archiviare il risultato dell'esecuzione del carico di lavoro ML da parte di Secundus.

Alcune immagini di esempio sono disponibili qui per questo codelab.

./setup_secundus_company_resources.sh

3. Crea workload

Crea un account di servizio per il workload

Ora crea un account di servizio per il carico di lavoro con i ruoli e le autorizzazioni richiesti. Esegui il seguente script per creare un account di servizio per il carico di lavoro nel progetto Secundus. Questo account di servizio verrà utilizzato dalla VM che esegue il carico di lavoro ML.

Questo account di servizio del carico di lavoro ($WORKLOAD_SERVICEACCOUNT) avrà i seguenti ruoli:

• confidentialcomputing.workloadUser per ottenere un token di attestazione
• logging.logWriter per scrivere i log in Cloud Logging.
• objectViewer per leggere i dati dal bucket Cloud Storage $SECUNDUS_INPUT_STORAGE_BUCKET.
• objectUser per scrivere il risultato del carico di lavoro nel bucket Cloud Storage $SECUNDUS_RESULT_STORAGE_BUCKET.

./create_workload_service_account.sh

Crea workload

In questo passaggio, creerai un'immagine Docker del tuo workload. Il workload sarebbe creato da Primus. Il carico di lavoro utilizzato in questo codelab è un codice Python di machine learning che accede al modello ML archiviato nel bucket di archiviazione di Primus ed esegue inferenze con le immagini di esempio archiviate in un bucket di archiviazione.

Il modello di machine learning archiviato nel bucket di archiviazione di Primus sarebbe accessibile solo ai carichi di lavoro che soddisfano le condizioni degli attributi richiesti. Queste condizioni degli attributi sono descritte in maggiore dettaglio nella sezione successiva sull'autorizzazione del carico di lavoro.

Ecco il metodo run_inference() del carico di lavoro che verrà creato e utilizzato in questo codelab. Puoi trovare l'intero codice del carico di lavoro qui.

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

Esegui il seguente script per creare un carico di lavoro in cui vengono eseguiti i seguenti passaggi:

• Crea Artifact Registry($PRIMUS_ARTIFACT_REGISTRY) di proprietà di Primus.
• Aggiorna il codice del carico di lavoro con i nomi delle risorse richieste.
• Crea il carico di lavoro ML e il Dockerfile per creare un'immagine Docker del codice del carico di lavoro. Qui puoi trovare il Dockerfile utilizzato per questo codelab.
• Crea e pubblica l'immagine Docker in Artifact Registry ($PRIMUS_ARTIFACT_REGISTRY) di proprietà di Primus.
• Concedi a $WORKLOAD_SERVICEACCOUNT l'autorizzazione di lettura per $PRIMUS_ARTIFACT_REGISTRY. Questo è necessario per consentire al container del workload di estrarre l'immagine Docker del workload da Artifact Registry.

./create_workload.sh

Inoltre, i carichi di lavoro possono essere codificati per garantire il caricamento della versione prevista del modello di machine learning controllando l'hash o la firma del modello prima di utilizzarlo. Il vantaggio di questi controlli aggiuntivi è che garantiscono l'integrità del modello di machine learning. In questo modo, l'operatore del carico di lavoro dovrà anche aggiornare l'immagine del carico di lavoro o i relativi parametri quando si prevede che il carico di lavoro utilizzi versioni diverse del modello di ML.

4. Autorizza ed esegui il carico di lavoro

Autorizza il workload

Primus vuole autorizzare i carichi di lavoro ad accedere al proprio modello di machine learning in base agli attributi delle seguenti risorse:

• Che cosa: codice verificato
• Dove: un ambiente sicuro
• Chi: un operatore attendibile

Primus utilizza la federazione delle identità per i carichi di lavoro per applicare un criterio di accesso in base a questi requisiti. La federazione delle identità per i carichi di lavoro ti consente di specificare le condizioni degli attributi. Queste condizioni limitano le identità che possono autenticarsi con il pool di identità del workload (WIP). Puoi aggiungere il servizio di verifica dell'attestazione al WIP come provider del pool di identità del workload per presentare le misurazioni e applicare il criterio.

Il pool di identità del workload è già stato creato in precedenza durante il passaggio di configurazione delle risorse cloud. Ora Primus creerà un nuovo provider del pool di identità del workload OIDC. Il --attribute-condition specificato autorizza l'accesso al contenitore del carico di lavoro. Richiede:

• Che cosa: $WORKLOAD_IMAGE_NAME più recente caricato nel repository $PRIMUS_ARTIFACT_REPOSITORY.
• Dove: l'ambiente di esecuzione attendibile Confidential Space è in esecuzione sull'immagine VM Confidential Space completamente supportata.
• Chi: account di servizio 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"

Esegui workload

In questo passaggio, eseguiremo il carico di lavoro nella VM Confidential Space. Gli argomenti TEE obbligatori vengono passati utilizzando il flag dei metadati. Gli argomenti per il contenitore del workload vengono passati utilizzando la parte "tee-cmd" del flag. Il risultato dell'esecuzione del workload verrà pubblicato in $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}

Nota:puoi utilizzare due famiglie di immagini per l'istanza: confidential-space-debug e confidential-space. Puoi utilizzare uno dei due. La differenza principale è che confidential-space ha i servizi disattivati, il che non consente all'operatore di interferire con il carico di lavoro, mentre confidential-space-debug avrà SSH abilitato e l'operatore potrà connettersi tramite SSH alla VM. In questo modo, l'operatore potrà eseguire il debug (ma il servizio di attestazione annoterà nel token di attestazione che lo stato di debug è attivo). Tuttavia, dovrai arrestare manualmente la VM in un secondo momento.

Visualizza risultati

Una volta completato il carico di lavoro, il risultato del carico di lavoro ML verrà pubblicato in $SECUNDUS_RESULT_STORAGE_BUCKET.

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

Ecco alcuni esempi di come potrebbero apparire i risultati dell'inferenza sulle immagini di esempio:

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

Per ogni immagine di esempio in un bucket di archiviazione Secundus, vedrai una voce nei risultati. Questa voce includerà due informazioni chiave:

• Indice di predicted_class: si tratta di un indice numerico che rappresenta la classe a cui il modello prevede che appartenga l'immagine.
• Top_k_predictions: fornisce fino a k previsioni per l'immagine, classificate dalla più alla meno probabile. Il valore di k è impostato su 5 in questo codelab, ma puoi modificarlo nel codice del carico di lavoro per ottenere più o meno previsioni.

Per tradurre l'indice di classe in un nome di classe leggibile, consulta l'elenco delle etichette disponibili qui. Ad esempio, se vedi un indice di classe pari a 2, corrisponde all'etichetta della classe "trota" nell'elenco delle etichette.

In questo codelab abbiamo dimostrato che un modello di proprietà di Primus viene rilasciato solo al carico di lavoro in esecuzione in un TEE. Secundus esegue il carico di lavoro ML in un TEE e questo carico di lavoro è in grado di utilizzare il modello di proprietà di Primus, che mantiene il pieno controllo sul modello.

Esegui carico di lavoro non autorizzato

Secundus modifica l'immagine del workload estraendo un'immagine del workload diversa dal proprio repository di elementi non autorizzato da Primus. Il pool di identità per i carichi di lavoro di Primus ha autorizzato solo l'immagine del carico di lavoro ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG.

Esegui nuovamente il carico di lavoro

Quando Secundus tenta di eseguire il carico di lavoro originale con questa nuova immagine, l'operazione non va a buon fine. Per visualizzare l'errore, elimina il file dei risultati originale e l'istanza VM, quindi riprova a eseguire il carico di lavoro.

Assicurati che sia presente una nuova immagine Docker pubblicata nell'Artifact Registry di Secundus (come us-docker.pkg.dev/${SECUNDUS_PROJECT_ID}/custom-image/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}) e che l'account di servizio del carico di lavoro ($WORKLOAD_SERVICEACCOUNT) abbia concesso all'account Lettore di Artifact Registry l'autorizzazione a leggere questa nuova immagine del carico di lavoro. Questo serve ad assicurarsi che il carico di lavoro non esista prima che il criterio WIP di Primus rifiuti il token presentato dal carico di lavoro.

Elimina il file dei risultati esistente e l'istanza VM

1. Imposta il progetto sul progetto $SECUNDUS_PROJECT_ID.

gcloud config set project $SECUNDUS_PROJECT_ID

2. Elimina il file del risultato.

gsutil rm gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

3. Elimina l'istanza Confidential VM.

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

Esegui il carico di lavoro non autorizzato:

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}

Visualizza errore

Invece dei risultati del carico di lavoro, viene visualizzato un errore (The given credential is rejected by the attribute condition).

gsutil cat gs://$SECUNDUS_RESULT_STORAGE_BUCKET/result

5. Esegui la pulizia

Qui è riportato lo script che può essere utilizzato per ripulire le risorse che abbiamo creato nell'ambito di questo codelab. Nell'ambito di questa operazione di pulizia, verranno eliminate le seguenti risorse:

• Bucket di archiviazione di input di Primus ($PRIMUS_INPUT_STORAGE_BUCKET).
• Account di servizio Primus ($PRIMUS_SERVICEACCOUNT).
• Repository di elementi di Primus ($PRIMUS_ARTIFACT_REPOSITORY).
• Pool di identità del workload Primus ($PRIMUS_WORKLOAD_IDENTITY_POOL).
• Service account del workload di Secundus ($WORKLOAD_SERVICEACCOUNT).
• Inserisci il bucket di archiviazione di Secundus ($SECUNDUS_INPUT_STORAGE_BUCKET).
• Istanze di calcolo del workload.
• Bucket di archiviazione dei risultati di Secundus ($SECUNDUS_RESULT_STORAGE_BUCKET).

$ ./cleanup.sh

Se hai finito di esplorare, valuta la possibilità di eliminare il progetto.

• Vai alla console della piattaforma Cloud.
• Seleziona il progetto che vuoi arrestare e fai clic su "Elimina" in alto per pianificarne l'eliminazione.

Passaggi successivi

Dai un'occhiata ad alcuni di questi codelab simili…

• Proteggere i dati condivisi in uso con Confidential Space
• Come eseguire transazioni di asset digitali con il calcolo a parti multiple e gli spazi riservati
• Analizzare i dati riservati con Confidential Space