Immagini di Confidential Space

Un'immagine Confidential Space è un sistema operativo minimo e monouso che viene eseguito su un'istanza Confidential VM. È progettato per eseguire un singolo workload una sola volta, senza archiviazione permanente. Questo workload viene sovrapposto all'immagine Confidential Space utilizzando Docker.

Le immagini di Confidential Space si basano sui miglioramenti della sicurezza esistenti di Container-Optimized OS e aggiungono i seguenti vantaggi:

  • Partizioni del disco crittografate con protezione dell'integrità

  • Connessioni di rete autenticate e criptate

  • Varie misurazioni di avvio

  • Accesso remoto e strumenti specifici per il cloud disabilitati

Tipi di immagini

Le immagini Confidential Space sono disponibili in due varianti:

  • Produzione: l'immagine di produzione viene utilizzata per eseguire workload di produzione reali con dati di produzione reali. È bloccato per impedire all'operatore del workload di accedere ai dati elaborati. Per saperne di più, consulta la Panoramica della sicurezza di Confidential Space.

  • Debug: l'immagine di debug viene utilizzata per testare il workload su dati non di produzione. SSH è abilitato sull'immagine di debug e l'operatore ha accesso root alla VM che esegue il workload. La VM che esegue l'immagine di debug non si arresta al termine del workload.

Puoi impostare il tipo di immagine da utilizzare quando esegui il deployment del workload.

Visualizza le immagini di Confidential Space

Puoi visualizzare le immagini di Confidential Space disponibili con il seguente comando gcloud:

gcloud compute images list \
    --project=confidential-space-images \
    --no-standard-images

I seguenti flag possono modificare le immagini restituite nei risultati:

  • Aggiungi il flag --filter="family~'confidential-space$'" per mostrare le immagini di produzione.

  • Aggiungi il flag --filter="family~'confidential-space-debug$'" per mostrare le immagini di debug.

Visualizza immagini deprecate

Esegui questo comando per includere le immagini deprecate nei risultati, insieme a campi aggiuntivi che possono aiutarti a prendere decisioni:

gcloud compute images list \
    --project=confidential-space-images \
    --no-standard-images \
    --show-deprecated \
    --filter="name ~ '^confidential-space-[0-9]{6}$'" \
    --format="table(
      name,
      creationTimestamp.date('%Y-%m-%d'):label=CREATION_DATE,
      status,
      description.sub('.*COS: ', '').sub(',.*', ''):label=COS_VERSION,
      deprecated.state:label=STATE,
      deprecated.deprecated:label=DEPRECATE_ON,
      deprecated.obsolete:label=OBSOLETE_ON,
      deprecated.replacement
    )"

Una risposta corretta è simile alla seguente:

NAME                       CREATION_DATE  STATUS  COS_VERSION               STATE       DEPRECATE_ON  OBSOLETE_ON  REPLACEMENT
confidential-space-230600  2023-06-09     READY   cos-dev-109-17637-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-230901
confidential-space-230900  2023-09-17     READY   cos-dev-109-17637-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-230600
confidential-space-230901  2023-10-02     READY   cos-dev-113-17877-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-231001
confidential-space-231001  2023-11-01     READY   cos-dev-113-17965-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-231100
confidential-space-231100  2023-11-17     READY   cos-dev-113-18026-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-231200
confidential-space-231200  2023-12-04     READY   cos-dev-113-18054-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-231201
confidential-space-231201  2023-12-15     READY   cos-dev-113-18059-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-240200
confidential-space-240200  2024-02-28     READY   cos-dev-113-18146-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-240402
confidential-space-240402  2024-04-22     READY   cos-dev-117-18342-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-240500
confidential-space-240500  2024-05-30     READY   cos-dev-117-18374-0-0     DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-240700
confidential-space-240700  2024-07-30     READY   cos-113-18244-85-54       DEPRECATED                             https://www.googleapis.com/compute/v1/projects/confidential-space-images/global/images/confidential-space-240800
confidential-space-240800  2024-09-03     READY   cos-113-18244-151-14
confidential-space-240900  2024-10-01     READY   cos-113-18244-151-80
confidential-space-241000  2024-10-18     READY   cos-113-18244-151-96
...

Ciclo di vita delle immagini Confidential Space

Quando crei una Confidential VM utilizzando una famiglia di immagini Confidential Space, viene utilizzata l'ultima versione dell'immagine Confidential Space. Se elimini sempre la Confidential VM al termine del workload e ne crei una nuova ogni volta che esegui il workload, puoi avere la certezza che l'immagine sia aggiornata.

Tuttavia, i workload a lunga esecuzione o l'esecuzione di un workload su una VM creata in passato ti espongono al rischio di utilizzare un'immagine Confidential Space obsoleta, che potrebbe introdurre vulnerabilità di sicurezza.

Per mitigare questo problema, un collaboratore ai dati può utilizzare gli attributi di supporto per verificare se una versione immagine di Confidential Space di produzione in esecuzione su una VM è recente e negare l'accesso ai propri dati se non supera il controllo. Esegui il debug Le immagini di Confidential Space non hanno un attributo di supporto impostato.

La tabella seguente descrive gli attributi di supporto presenti nelle immagini Confidential Space di produzione.

Attributo di supporto Descrizione

LATEST

Le immagini LATEST hanno anche i seguenti attributi di supporto:

  • STABLE
  • USABLE

Durata dell'immagine: circa un mese. In seguito, l'attributo di supporto LATEST viene rimosso.

Questa è l'ultima versione dell'immagine Confidential Space ed è supportata e monitorata per rilevare eventuali vulnerabilità.

Per i workload a lunga esecuzione, ti consigliamo di non specificare LATEST come parte della policy di attestazione. Questo perché l'immagine Confidential Space potrebbe essere aggiornata mentre il workload è in esecuzione, rendendo l'immagine Confidential Space che stai utilizzando non più LATEST e causando l'attestazione del workload al successivo aggiornamento del token predefinito di Confidential Space.

STABLE

Le immagini STABLE hanno anche i seguenti attributi di supporto:

  • USABLE

Durata dell'immagine: circa sei mesi. A partire dal 1° aprile 2027, l'attributo di supporto STABLE viene rimosso dopo la scadenza della durata dell'immagine.

Le immagini con l'attributo STABLE sono supportate e monitorate per rilevare eventuali vulnerabilità per un periodo di sei mesi. Ti consigliamo di scrivere una policy di attestazione basata sull'attributo STABLE.

In rari casi, l'attributo STABLE può essere rimosso durante il normale periodo di assistenza di sei mesi, ad esempio quando vengono scoperte vulnerabilità critiche.

USABLE

Le immagini con solo l'attributo USABLE sono ancora disponibili per l'utilizzo, ma sono considerate deprecate. Le immagini deprecate non sono supportate e hanno più di sei mesi. Utilizzale a tuo rischio.

Le immagini USABLE hanno una proprietà deprecated.deprecated. Il suo valore è il timestamp di quando è prevista la deprecazione dell'immagine. Le proprietà di un'immagine possono essere visualizzate con il comando gcloud compute images describe o con il metodo REST images.get. Ad esempio:

gcloud compute images describe confidential-space-240800 \
    --format=json \
    --project=confidential-space-images
EXPERIMENTAL

Le immagini con solo questo attributo utilizzano le funzionalità di anteprima. Le immagini EXPERIMENTAL sono solo a scopo di test e non devono mai essere utilizzate in produzione.

Un'immagine EXPERIMENTAL non ha mai gli attributi LATEST, STABLE o USABLE.

Ti consigliamo di mantenere aggiornata l'immagine di Confidential Space. Per scoprire come aggiornare l'immagine di Confidential Space, consulta Aggiorna le immagini di Confidential Space.

Monitora le immagini deprecate

Per monitorare le istanze VM che eseguono immagini Confidential Space ritirate o che verranno ritirate a breve, puoi eseguire il deployment di una funzione Cloud Run eseguita regolarmente con un job Cloud Scheduler. Puoi quindi configurare le notifiche di Cloud Logging per ricevere un avviso quando le immagini vengono ritirate.

Esegui il deployment di una funzione Cloud Run per verificare la presenza di immagini deprecate

Per configurare la funzione Cloud Run, completa le seguenti istruzioni:

  1. In Cloud Run, vai alla pagina Servizi.

    Vai a Servizi

  2. Fai clic su Scrivi una funzione.

  3. Nella casella Nome servizio, inserisci un nome per la funzione.

  4. Seleziona una regione in cui eseguire la funzione.

  5. Imposta Runtime su una versione recente di Go.

  6. Imposta Autenticazione su Richiedi autenticazione.

  7. Imposta Traffico in entrata su Interno.

  8. Espandi la sezione Container, networking, sicurezza.

  9. Nella scheda Container, imposta Memoria su 128 MiB.

  10. Nella scheda Sicurezza, fai clic sulla casella Service account.

  11. Fai clic su Crea nuovo service account.

  12. Inserisci un nome nella casella Nome service account.

  13. Fai clic su Crea.

  14. Aggiungi il ruolo Visualizzatore Compute e fai clic su Fine.

  15. Fai clic su Crea.

  16. Dopo il caricamento della funzione, nella scheda Origine imposta Entry point della funzione su DeprecationCheck.

  17. Sovrascrivi i contenuti di function.go con il seguente codice:

    // Package imagechecker provides a function to check for deprecated CS images.
    package imagechecker
    
    import (
    	"context"
    	"encoding/json"
    	"fmt"
    	"log"
    	"log/slog"
    	"net/http"
    	"regexp"
    	"strings"
    	"time"
    
    	"cloud.google.com/go/compute/metadata"
    	"google.golang.org/api/compute/v1"
    	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
    )
    
    const (
    	sourceImageProject  = "confidential-space-images"
    	deprecationValueFmt = "2006-01-02"
    )
    
    // CS Images have the format confidential-space-.*.
    var prodImageNameRegex = regexp.MustCompile(`^confidential-space-.*`)
    
    // VMInfo represents the information logged about an VM instance of note.
    type VMInfo struct {
    	Name            string `json:"instance_name"`
    	Zone            string `json:"instance_zone"`
    	ImageName       string `json:"image_name"`
    	DeprecationDate string `json:"image_deprecation_date,omitempty"`
    	ObsoleteDate    string `json:"image_obsolete_date,omitempty"`
    }
    
    // VMList represents a list of notable VMs and their relevance.
    type VMList struct {
    	Description string   `json:"description"`
    	Instances   []VMInfo `json:"instances"`
    }
    
    // LogPayload is the payload for Cloud Logs written by this job.
    type LogPayload struct {
    	Message            string  `json:"message"`
    	Obsolete           *VMList `json:"vms_obsolete"`
    	ObsoleteWarning    *VMList `json:"vms_obsolete_warning"`
    	Deprecated         *VMList `json:"vms_deprecated"`
    	DeprecationWarning *VMList `json:"vms_deprecation_warning"`
    }
    
    // LogEntry represents a Cloud Logging entry.
    type LogEntry struct {
    	Message   string      `json:"message"`
    	Severity  string      `json:"severity"` // Special field for Cloud Logging.
    	Payload   *LogPayload `json:"payload,omitempty"`
    	ProjectID string      `json:"projectId"`
    }
    
    func init() {
    	log.SetFlags(0)
    	functions.HTTP("DeprecationCheck", checkForDeprecations)
    }
    
    func checkForDeprecations(w http.ResponseWriter, r *http.Request) {
    	ctx := context.Background()
    
    	// Retrieve project ID.
    	projectID, err := metadata.ProjectIDWithContext(ctx)
    	if err != nil {
    		errMsg := fmt.Sprintf("Failed to get project ID from metadata server: %v", err)
    		logError(projectID, errMsg)
    		http.Error(w, errMsg, http.StatusInternalServerError)
    		return
    	}
    	slog.Info(fmt.Sprintf("Checking for project: %s", projectID))
    
    	// Configure compute service.
    	computeService, err := compute.NewService(ctx)
    	if err != nil {
    		msg := fmt.Sprintf("Failed to create compute service: %v", err)
    		logError(projectID, msg)
    		http.Error(w, msg, http.StatusInternalServerError)
    		return
    	}
    
    	var obsoleteVMs []VMInfo           // Will contain VMs whose images are obsolete.
    	var obsoleteWarningVMs []VMInfo    // Will contain VMs using an image that will be obsolete within a month.
    	var deprecatedVMs []VMInfo         // Will contain VMs whose images are deprecated.
    	var deprecationWarningVMs []VMInfo // Will contain VMs using an image that will be deprecated within a month.
    	now := time.Now()
    
    	pageFunc := instancesPageFunc(ctx, projectID, &obsoleteVMs, &obsoleteWarningVMs, &deprecatedVMs, &deprecationWarningVMs, now, computeService)
    	if err = computeService.Instances.AggregatedList(projectID).Pages(ctx, pageFunc); err != nil {
    		msg := fmt.Sprintf("Failed to list instances: %v", err)
    		logError(projectID, msg)
    		http.Error(w, msg, http.StatusInternalServerError)
    		return
    	}
    
    	if len(obsoleteVMs) == 0 && len(obsoleteWarningVMs) == 0 && len(deprecatedVMs) == 0 && len(deprecationWarningVMs) == 0 {
    		returnmsg := "No VMs using obsolete or deprecated images found."
    		logEntry := LogEntry{
    			Message:   "Confidential Space Image Deprecation Alert - No Issues Detected",
    			Severity:  "INFO",
    			ProjectID: projectID,
    			Payload:   &LogPayload{Message: returnmsg},
    		}
    		writeLog(logEntry)
    
    		w.WriteHeader(http.StatusOK)
    		_, err := w.Write([]byte(returnmsg))
    		if err != nil {
    			http.Error(w, fmt.Sprintf("Failed to write HTTP response: %v", err), http.StatusInternalServerError)
    		}
    		return
    	}
    
    	respPayload := &LogPayload{
    		Message: "The following instances are using Confidential Space images that are obsolete, deprecated, or will be obsolete/deprecated soon. Obsolete and deprecated images are no longer maintained and scanned for vulnerabilities. Please review these instances and update their boot images as needed.",
    	}
    
    	if len(obsoleteVMs) > 0 {
    		respPayload.Obsolete = &VMList{
    			Description: "Instances using CS images that are obsolete.",
    			Instances:   obsoleteVMs,
    		}
    	}
    	if len(obsoleteWarningVMs) > 0 {
    		respPayload.ObsoleteWarning = &VMList{
    			Description: "Instances using CS images that will be obsolete within a month.",
    			Instances:   obsoleteWarningVMs,
    		}
    	}
    	if len(deprecatedVMs) > 0 {
    		respPayload.Deprecated = &VMList{
    			Description: "Instances using CS images that are deprecated.",
    			Instances:   deprecatedVMs,
    		}
    	}
    	if len(deprecationWarningVMs) > 0 {
    		respPayload.DeprecationWarning = &VMList{
    			Description: "Instances using CS images that will be deprecated within a month.",
    			Instances:   deprecationWarningVMs,
    		}
    	}
    
    	entry := LogEntry{
    		Message:   "Confidential Space Image Deprecation Alert",
    		Severity:  "WARNING",
    		ProjectID: projectID,
    		Payload:   respPayload,
    	}
    
    	writeLog(entry)
    
    	w.Header().Set("Content-Type", "application/json")
    	w.WriteHeader(http.StatusOK)
    	err = json.NewEncoder(w).Encode(respPayload)
    	if err != nil {
    		http.Error(w, fmt.Sprintf("Failed to write HTTP response: %v", err), http.StatusInternalServerError)
    		return
    	}
    }
    
    func instancesPageFunc(ctx context.Context, projectID string, obsoleteVMs *[]VMInfo, obsoleteWarningVMs *[]VMInfo, deprecatedVMs *[]VMInfo, deprecationWarningVMs *[]VMInfo, now time.Time, computeService *compute.Service) func(list *compute.InstanceAggregatedList) error {
    	return func(list *compute.InstanceAggregatedList) error {
    		for _, instanceList := range list.Items {
    			for _, instances := range instanceList.Instances {
    				sourceImage, err := getSourceImage(ctx, projectID, instances, computeService)
    				if err != nil {
    					slog.Warn(fmt.Sprintf("Failed to get source image for instance %s: %v", instances.Name, err))
    					continue
    				}
    
    				// Skip instance if not using a CS prod image.
    				imageProject, imageName := parseImage(sourceImage)
    				if imageProject != sourceImageProject || !prodImageNameRegex.MatchString(imageName) {
    					continue
    				}
    
    				// Get deprecation status ("deprecate-on" / "obsolete-on" / state settings).
    				depStatus, err := getDeprecationStatus(ctx, imageProject, imageName, computeService)
    				if err != nil {
    					slog.Error(fmt.Sprintf("Failed to get deprecation status for image %s in project %s: %v", imageName, imageProject, err))
    					continue
    				}
    				if depStatus == nil {
    					continue
    				}
    
    				vm := VMInfo{
    					Name:      instances.Name,
    					Zone:      getResourceName(instances.Zone),
    					ImageName: imageName,
    				}
    
    				var depTime, obsTime time.Time
    				if depStatus.Deprecated != "" {
    					depTime, err = parseDeprecationDate(depStatus.Deprecated)
    					if err != nil {
    						slog.Error(fmt.Sprintf("Failed to parse deprecation date %s for image %s in project %s: %v", depStatus.Deprecated, imageName, imageProject, err))
    						continue
    					}
    					vm.DeprecationDate = depTime.Format(deprecationValueFmt)
    				}
    
    				if depStatus.Obsolete != "" {
    					obsTime, err = parseDeprecationDate(depStatus.Obsolete)
    					if err != nil {
    						slog.Error(fmt.Sprintf("Failed to parse obsolete date %s for image %s in project %s: %v", depStatus.Obsolete, imageName, imageProject, err))
    						continue
    					}
    					vm.ObsoleteDate = obsTime.Format(deprecationValueFmt)
    				}
    
    				// Determine whether instance image is obsolete, upcoming obsolete, deprecated, or upcoming deprecated.
    				if depStatus.State == "OBSOLETE" || (!obsTime.IsZero() && isPast(obsTime, now)) {
    					*obsoleteVMs = append(*obsoleteVMs, vm)
    				} else if !obsTime.IsZero() && isWarning(obsTime, now) {
    					*obsoleteWarningVMs = append(*obsoleteWarningVMs, vm)
    				} else if depStatus.State == "DEPRECATED" || (!depTime.IsZero() && isPast(depTime, now)) {
    					*deprecatedVMs = append(*deprecatedVMs, vm)
    				} else if !depTime.IsZero() && isWarning(depTime, now) {
    					*deprecationWarningVMs = append(*deprecationWarningVMs, vm)
    				}
    			}
    		}
    
    		return nil
    	}
    }
    
    func getSourceImage(ctx context.Context, projectID string, instance *compute.Instance, service *compute.Service) (string, error) {
    	for _, disk := range instance.Disks {
    		// Only check boot disk.
    		if disk.Boot {
    			// Retrieve source image for disk.
    			diskName := getResourceName(disk.Source)
    			zone := getResourceName(instance.Zone)
    
    			d, err := service.Disks.Get(projectID, zone, diskName).Context(ctx).Do()
    			if err != nil {
    				slog.Warn(fmt.Sprintf("Failed to get details for disk %s in zone %s: %v", diskName, zone, err))
    				continue
    			}
    
    			if d.SourceImage != "" {
    				return d.SourceImage, nil
    			}
    		}
    	}
    
    	return "", fmt.Errorf("no suitable source image name found for instance %s", instance.Name)
    }
    
    func getDeprecationStatus(ctx context.Context, imageProject, imageName string, service *compute.Service) (*compute.DeprecationStatus, error) {
    	image, err := service.Images.Get(imageProject, imageName).Context(ctx).Do()
    	if err != nil {
    		slog.Warn(fmt.Sprintf("Failed to get details for image %s in project %s: %v", imageName, imageProject, err))
    		return nil, err
    	}
    
    	if image.Deprecated == nil || (image.Deprecated.Deprecated == "" && image.Deprecated.Obsolete == "" && image.Deprecated.State == "") {
    		// Skip if no deprecation/obsolete setting.
    		slog.Warn(fmt.Sprintf("Image %s in project %s has no deprecate-on or obsolete-on setting", imageName, imageProject))
    		return nil, nil
    	}
    
    	return image.Deprecated, nil
    }
    
    func parseDeprecationDate(dateStr string) (time.Time, error) {
    	formats := []string{
    		time.RFC3339,
    		time.RFC3339Nano,
    		"2006-01-02T15:04:05",
    		"2006-01-02",
    		"2006-01",
    	}
    	for _, format := range formats {
    		if t, err := time.Parse(format, dateStr); err == nil {
    			return t, nil
    		}
    	}
    	return time.Time{}, fmt.Errorf("unable to parse %q as a valid deprecation date", dateStr)
    }
    
    func isPast(obsTime time.Time, now time.Time) bool {
    	return !obsTime.After(now)
    }
    
    func isWarning(targetTime time.Time, now time.Time) bool {
    	warningWindowEnd := now.AddDate(0, 1, 0)
    	return targetTime.After(now) && !targetTime.After(warningWindowEnd)
    }
    
    func parseImage(image string) (string, string) {
    	parts := strings.Split(image, "/")
    
    	var project, imageName string
    	for i, part := range parts {
    		if part == "projects" && i+1 < len(parts) {
    			project = parts[i+1]
    		} else if part == "images" && i+1 < len(parts) {
    			imageName = parts[i+1]
    		}
    	}
    
    	slog.Info(fmt.Sprintf("Source image project: %s, name: %s", project, imageName))
    
    	return project, imageName
    }
    
    // getResourceName extracts the last part of a GCP resource URL.
    func getResourceName(url string) string {
    	parts := strings.Split(url, "/")
    	return parts[len(parts)-1]
    }
    
    func writeLog(entry LogEntry) {
    	jsonData, err := json.Marshal(entry)
    	if err != nil {
    		slog.Warn(fmt.Sprintf("Error marshaling final log: %v", err))
    		slog.Warn(fmt.Sprintf("Log contents: %v", entry))
    		return
    	}
    
    	fmt.Println(string(jsonData))
    }
    
    func logError(projectID, errMsg string) {
    	entry := LogEntry{
    		Message:   "Confidential Space Image Deprecation Alert - Job Failed",
    		Severity:  "ERROR",
    		ProjectID: projectID,
    		Payload: &LogPayload{
    			Message: errMsg,
    		},
    	}
    
    	writeLog(entry)
    }
    
    
  18. Sovrascrivi i contenuti di go.mod con il seguente codice:

    module example.com/imagechecker
    
    require (
        cloud.google.com/go/compute/metadata v0.5.0
        github.com/GoogleCloudPlatform/functions-framework-go v1.9.0
        google.golang.org/api v0.264.0
    )
    
    
  19. Fai clic su Salva e riesegui il deployment.

  20. Una volta eseguito il deployment del servizio, prendi nota del suo URL, che si trova accanto al nome della funzione, per utilizzarlo in un secondo momento.

Configura un job Cloud Scheduler

Per configurare il job Cloud Scheduler che esegue la funzione Cloud Run, completa le seguenti istruzioni:

  1. Innanzitutto, crea un account di servizio per eseguire il job pianificato. Per farlo, vai alla pagina Crea un service account:

    Vai a Crea un service account

  2. Nella casella Nome service account, aggiungi un nome per account di servizio.

  3. Prendi nota dell'ID account di servizio per utilizzarlo in un secondo momento.

  4. Fai clic su Crea e continua.

  5. Aggiungi il ruolo Cloud Run Invoker.

  6. Fai clic su Fine.

  7. Se non l'hai ancora fatto, abilita l'API Cloud Scheduler.

  8. In Cloud Scheduler, vai alla pagina Job.

    Vai a Job

  9. Fai clic su Crea job.

  10. Nel campo Nome, inserisci un nome per il job.

  11. Seleziona una regione in cui eseguire il job pianificato.

  12. Aggiungi una pianificazione cron al campo Frequenza. Ad esempio, 0 9 1 * * esegue il job alle 09:00 del primo giorno di ogni mese.

  13. Imposta un fuso orario per la pianificazione.

  14. Fai clic su Continua.

  15. Imposta Tipo di destinazione su HTTP.

  16. Imposta l'URL sull'URL della funzione Cloud Run che hai creato.

  17. Nella casella Intestazione autenticazione, seleziona Aggiungi token OIDC.

  18. Fai clic sulla casella Service account e inserisci l'ID del account di servizio che hai creato in precedenza.

  19. Imposta il pubblico sull'URL della funzione Cloud Run che hai creato

  20. Fai clic su Crea.

  21. Per testare il job, fai clic su Azioni, quindi su Forza esecuzione.

Configura gli avvisi basati su log

Per configurare gli avvisi basati su log per le immagini deprecate, completa le seguenti istruzioni:

  1. Vai alla pagina Esplora log:

    Vai a Esplora log

  2. Attiva Mostra query.

  3. Nella casella della query, inserisci una delle seguenti query in Logging Query Language:

    • VM trovate con deprecazioni imminenti:

      resource.type="cloud_run_revision"
      severity="WARNING"
      jsonPayload.message="Confidential Space Image Deprecation Alert"
      
    • Errori di controllo del ritiro:

      resource.type="cloud_run_revision"
      severity="ERROR"
      jsonPayload.message="Confidential Space Image Deprecation Alert - Job Failed"
      
    • Nessuna immagine deprecata rilevata nel tuo parco risorse VM:

      resource.type="cloud_run_revision"
      severity="INFO"
      jsonPayload.message="Confidential Space Image Deprecation Alert - No Issues Detected"
      
  4. Fai clic su Esegui query.

  5. Accanto ai risultati, fai clic su Azioni.

  6. Fai clic su Crea avviso log, quindi completa la procedura per creare una policy di avviso basata sulla query inserita.

Aggiorna le immagini di Confidential Space

Per mantenere aggiornata l'immagine di Confidential Space ed evitare interruzioni, ti consigliamo di creare una nuova istanza Confidential VM ogni volta che avvii un workload di Confidential Space. Ogni volta che crei una nuova istanza basata sull'immagine Confidential Space, viene eseguito il provisioning dell'immagine Confidential Space più recente.

Se non riesci a creare una nuova istanza Confidential VM per ogni esecuzione del workload di Confidential Space, ti consigliamo di definire un periodo di manutenzione per ricreare l'istanza Confidential VM in base all'attributo di supporto impostato dalla relying party nella policy di attestazione:

  • Se hai impostato una policy di attestazione che richiede l'attributo di supporto LATEST, devi aggiornare l'immagine di Confidential Space almeno una volta al mese.

  • Se hai impostato una policy di attestazione che richiede l'attributo di supporto STABLE, devi aggiornare l'immagine di Confidential Space almeno ogni sei mesi.

Puoi semplificare la ricreazione delle VM utilizzando uno o più dei seguenti elementi:

Per scoprire come configurare queste funzionalità, consulta Deployment di un workload Confidential Space con MIG utilizzando la scalabilità automatica, il ripristino automatico e gli aggiornamenti delle immagini.

Workload a lunga esecuzione

Un'immagine Confidential Space potrebbe essere deprecata o revocata durante un workload a lunga esecuzione. Se hai impostato una policy di attestazione che richiede l'attributo di supporto di Confidential Space STABLE e l'immagine di Confidential Space utilizzata dal tuo workload è deprecata o revocata, l'istanza Confidential VM che esegue il workload non supererà l'attestazione. Per evitare interruzioni, i workload a lunga esecuzione devono essere progettati tenendo conto della ripresa, con lo stato gestito in modo sicuro.