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 |
|---|---|
|
Le immagini
|
Durata dell'immagine: circa un mese. In seguito, l'attributo di supporto 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 |
|
Le immagini
|
Durata dell'immagine: circa sei mesi. A partire dal 1° aprile 2027, l'attributo di supporto
Le immagini con l'attributo
In rari casi, l'attributo |
USABLE |
Le immagini con solo l'attributo
Le immagini 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
Un'immagine |
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:
In Cloud Run, vai alla pagina Servizi.
Fai clic su Scrivi una funzione.
Nella casella Nome servizio, inserisci un nome per la funzione.
Seleziona una regione in cui eseguire la funzione.
Imposta Runtime su una versione recente di Go.
Imposta Autenticazione su Richiedi autenticazione.
Imposta Traffico in entrata su Interno.
Espandi la sezione Container, networking, sicurezza.
Nella scheda Container, imposta Memoria su 128 MiB.
Nella scheda Sicurezza, fai clic sulla casella Service account.
Fai clic su Crea nuovo service account.
Inserisci un nome nella casella Nome service account.
Fai clic su Crea.
Aggiungi il ruolo Visualizzatore Compute e fai clic su Fine.
Fai clic su Crea.
Dopo il caricamento della funzione, nella scheda Origine imposta Entry point della funzione su
DeprecationCheck.Sovrascrivi i contenuti di
function.gocon 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) }Sovrascrivi i contenuti di
go.modcon 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 )Fai clic su Salva e riesegui il deployment.
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:
Innanzitutto, crea un account di servizio per eseguire il job pianificato. Per farlo, vai alla pagina Crea un service account:
Nella casella Nome service account, aggiungi un nome per account di servizio.
Prendi nota dell'ID account di servizio per utilizzarlo in un secondo momento.
Fai clic su Crea e continua.
Aggiungi il ruolo Cloud Run Invoker.
Fai clic su Fine.
Se non l'hai ancora fatto, abilita l'API Cloud Scheduler.
In Cloud Scheduler, vai alla pagina Job.
Fai clic su Crea job.
Nel campo Nome, inserisci un nome per il job.
Seleziona una regione in cui eseguire il job pianificato.
Aggiungi una pianificazione cron al campo Frequenza. Ad esempio,
0 9 1 * *esegue il job alle 09:00 del primo giorno di ogni mese.Imposta un fuso orario per la pianificazione.
Fai clic su Continua.
Imposta Tipo di destinazione su HTTP.
Imposta l'URL sull'URL della funzione Cloud Run che hai creato.
Nella casella Intestazione autenticazione, seleziona Aggiungi token OIDC.
Fai clic sulla casella Service account e inserisci l'ID del account di servizio che hai creato in precedenza.
Imposta il pubblico sull'URL della funzione Cloud Run che hai creato
Fai clic su Crea.
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:
Vai alla pagina Esplora log:
Attiva Mostra query.
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"
Fai clic su Esegui query.
Accanto ai risultati, fai clic su Azioni.
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.