Ein Confidential Space-Image ist ein minimales Betriebssystem für einen einzigen Zweck, das auf einer Confidential VM-Instanz ausgeführt wird. Er ist so konzipiert, dass er eine einzelne Arbeitslast nur einmal ohne nichtflüchtigen Speicher ausführt. Diese Arbeitslast wird mithilfe von Docker über das Confidential Space-Image gelegt.
Confidential Space-Images basieren auf den vorhandenen Sicherheitsverbesserungen von Container-Optimized OS und bieten die folgenden Vorteile:
Verschlüsselte Laufwerkpartitionen mit Integritätsschutz
Authentifizierte, verschlüsselte Netzwerkverbindungen
Verschiedene Boot-Messungen
Deaktivierter Remotezugriff und cloudspezifische Tools
Bildarten
Confidential Space-Images sind in zwei Varianten verfügbar:
Produktion: Das Produktions-Image wird für die Ausführung echter Produktionsarbeitslasten mit echten Produktionsdaten verwendet. Sie ist gesperrt, um zu verhindern, dass der Arbeitslastoperator auf die verarbeiteten Daten zugreift. Weitere Informationen finden Sie unter Confidential Space – Sicherheit.
Debug: Das Debug-Image wird zum Testen Ihrer Arbeitslast mit Nicht-Produktionsdaten verwendet. SSH ist im Debug-Image aktiviert und der Operator hat Root-Zugriff auf die VM, auf der die Arbeitslast ausgeführt wird. Die VM, auf der das Debugging-Image ausgeführt wird, wird nach Abschluss der Arbeitslast nicht beendet.
Sie können festlegen, welcher Image-Typ verwendet werden soll, wenn Sie die Arbeitslast bereitstellen.
Confidential Space-Images ansehen
Mit dem folgenden gcloud-Befehl können Sie die verfügbaren Confidential Space-Images aufrufen:
gcloud compute images list \
--project=confidential-space-images \
--no-standard-images
Mit den folgenden Flags können Sie die zurückgegebenen Bilder in den Ergebnissen ändern:
Fügen Sie das Flag
--filter="family~'confidential-space$'"hinzu, um Produktions-Images anzuzeigen.Fügen Sie das Flag
--filter="family~'confidential-space-debug$'"hinzu, um Debug-Images anzuzeigen.
Verworfene Images ansehen
Führen Sie den folgenden Befehl aus, um verworfene Images in die Ergebnisse aufzunehmen, zusammen mit zusätzlichen Feldern, die bei der Entscheidungsfindung helfen können:
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
)"
Eine erfolgreiche Antwort sieht in etwa so aus:
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
...
Lebenszyklus von Confidential Space-Images
Wenn Sie eine Confidential VM mit einer Confidential Space-Image-Familie erstellen, wird die neueste Version des Confidential Space-Images verwendet. Wenn Sie Ihre Confidential VM immer löschen, wenn die Arbeitslast fertig ist, und eine neue erstellen, wenn Sie die Arbeitslast ausführen, können Sie sicher sein, dass das Image auf dem neuesten Stand ist.
Bei lang andauernden Arbeitslasten oder bei der Ausführung einer Arbeitslast auf einer in der Vergangenheit erstellten VM besteht jedoch das Risiko, dass ein veraltetes Confidential Space-Image verwendet wird, was zu Sicherheitslücken führen kann.
Um dieses Problem zu beheben, kann ein Datenbearbeiter Support-Attribute verwenden, um zu prüfen, ob eine auf einer VM ausgeführte Confidential Space-Produktions-Image-Version aktuell ist, und den Zugriff auf seine Daten verweigern, wenn dies nicht der Fall ist. Für Confidential Space-Debug-Images ist kein Support-Attribut festgelegt.
In der folgenden Tabelle werden die Support-Attribute für Confidential Space-Produktions-Images beschrieben.
| Support-Attribut | Beschreibung |
|---|---|
|
|
Lebensdauer des Bildes: Ungefähr ein Monat. Danach wird das Support-Attribut Dies ist die neueste Version des Confidential Space-Images. Sie wird unterstützt und auf Sicherheitslücken überwacht.
Für Arbeitslasten mit langer Ausführungszeit empfehlen wir, |
|
|
Lebensdauer des Images: Ungefähr sechs Monate. Ab dem 1. April 2027 wird das Support-Attribut
Images mit dem Attribut
In seltenen Fällen kann das Attribut |
USABLE |
Images, die nur das Attribut
gcloud compute images describe confidential-space-240800 \ --format=json \ --project=confidential-space-images |
EXPERIMENTAL |
Images, die nur dieses Attribut haben, verwenden Funktionen in der Vorabversion.
Ein |
Wir empfehlen, Ihr Confidential Space-Image auf dem neuesten Stand zu halten. Informationen zum Aktualisieren Ihres Confidential Space-Images finden Sie unter Confidential Space-Images aktualisieren.
Auf verworfene Images überwachen
Wenn Sie VM-Instanzen überwachen möchten, auf denen veraltete oder bald veraltete Confidential Space-Images ausgeführt werden, können Sie eine Cloud Run-Funktion bereitstellen, die regelmäßig mit einem Cloud Scheduler-Job ausgeführt wird. Anschließend können Sie Cloud Logging-Benachrichtigungen einrichten, um sich benachrichtigen zu lassen, wenn Images verworfen wurden.
Cloud Run-Funktion bereitstellen, um nach verworfenen Images zu suchen
Führen Sie die folgenden Schritte aus, um die Cloud Run-Funktion einzurichten:
Rufen Sie in Cloud Run die Seite Dienste auf.
Klicken Sie auf Funktion schreiben.
Geben Sie im Feld Dienstname einen Namen für die Funktion ein.
Wählen Sie eine Region aus, in der die Funktion ausgeführt werden soll.
Legen Sie die Laufzeit auf eine aktuelle Version von Go fest.
Legen Sie für Authentifizierung die Option Authentifizierung erforderlich fest.
Legen Sie für Eingehender Traffic die Option Intern fest.
Maximieren Sie den Abschnitt Container, Netzwerk, Sicherheit.
Legen Sie auf dem Tab Container für Arbeitsspeicher den Wert 128 MiB fest.
Klicken Sie auf dem Tab Sicherheit auf das Feld Dienstkonto.
Klicken Sie auf Neues Dienstkonto erstellen.
Geben Sie im Feld Dienstkontoname einen Namen ein.
Klicken Sie auf Erstellen.
Fügen Sie die Rolle Compute-Betrachter hinzu und klicken Sie dann auf Fertig.
Klicken Sie auf Erstellen.
Nachdem die Funktion geladen wurde, legen Sie auf dem Tab Quelle den Funktionseinstiegspunkt auf
DeprecationCheckfest.Überschreiben Sie den Inhalt in
function.gomit dem folgenden Code:// 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) }Überschreiben Sie den Inhalt in
go.modmit dem folgenden Code: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 )Klicken Sie auf Speichern und wieder bereitstellen.
Notieren Sie sich nach der erfolgreichen Bereitstellung des Dienstes die URL, die Sie neben dem Namen der Funktion finden, zur späteren Verwendung.
Cloud Scheduler-Job einrichten
So richten Sie den Cloud Scheduler-Job ein, der die Cloud Run-Funktion ausführt:
Erstellen Sie zuerst ein Dienstkonto, um den geplanten Job auszuführen. Rufen Sie dazu die Seite Dienstkonto erstellen auf:
Geben Sie im Feld Dienstkontoname einen Dienstkontonamen ein.
Notieren Sie sich die Dienstkonto-ID für die spätere Verwendung.
Klicken Sie auf Erstellen und fortfahren.
Fügen Sie die Rolle Cloud Run-Aufrufer hinzu.
Klicken Sie auf Fertig.
Aktivieren Sie die Cloud Scheduler API, falls noch nicht geschehen.
Rufen Sie in Cloud Scheduler die Seite Jobs auf.
Klicken Sie auf Job erstellen.
Geben Sie im Feld Name einen Namen für den Job ein.
Wählen Sie eine Region aus, in der der geplante Job ausgeführt werden soll.
Fügen Sie dem Feld Häufigkeit einen Cron-Zeitplan hinzu. Beispiel:
0 9 1 * *führt den Job am ersten Tag jedes Monats um 9:00 Uhr aus.Legen Sie eine Zeitzone für den Zeitplan fest.
Klicken Sie auf Weiter.
Legen Sie den Zieltyp auf HTTP fest.
Legen Sie die URL auf die URL der von Ihnen erstellten Cloud Run-Funktion fest.
Wählen Sie im Feld Auth-Header die Option OIDC-Token hinzufügen aus.
Klicken Sie auf das Feld Dienstkonto und geben Sie die ID des Dienstkontos ein, das Sie zuvor erstellt haben.
Legen Sie die Zielgruppe auf die URL der von Ihnen erstellten Cloud Run-Funktion fest.
Klicken Sie auf Erstellen.
Klicken Sie zum Testen des Jobs auf Aktionen und dann auf Ausführung erzwingen.
Logbasierte Benachrichtigungen einrichten
So richten Sie logbasierte Benachrichtigungen zu verworfenen Images ein:
Zur Seite „Log-Explorer“
Aktivieren Sie Abfrage anzeigen.
Geben Sie im Abfragefeld eine der folgenden Logging-Abfragesprachen-Abfragen ein:
VMs mit bevorstehenden Einstellungen gefunden:
resource.type="cloud_run_revision" severity="WARNING" jsonPayload.message="Confidential Space Image Deprecation Alert"Fehler bei der Prüfung auf Einstellung:
resource.type="cloud_run_revision" severity="ERROR" jsonPayload.message="Confidential Space Image Deprecation Alert - Job Failed"In Ihrer VM-Flotte wurden keine verworfenen Images erkannt:
resource.type="cloud_run_revision" severity="INFO" jsonPayload.message="Confidential Space Image Deprecation Alert - No Issues Detected"
Klicken Sie auf Abfrage ausführen.
Klicken Sie neben den Ergebnissen auf Aktionen.
Klicken Sie auf Logbenachrichtigung erstellen und schließen Sie den Vorgang ab, um eine Benachrichtigungsrichtlinie basierend auf der eingegebenen Abfrage zu erstellen.
Confidential Space-Images aktualisieren
Damit Ihr Confidential Space-Image auf dem neuesten Stand bleibt und Unterbrechungen vermieden werden, empfehlen wir, jedes Mal, wenn Sie eine Confidential Space-Arbeitslast starten, eine neue Confidential VM-Instanz zu erstellen. Jedes Mal, wenn Sie eine neue Instanz auf Basis des Confidential Space-Image erstellen, wird das neueste Confidential Space-Image bereitgestellt.
Wenn Sie nicht für jede Ausführung einer Confidential Space-Arbeitslast eine neue Confidential VM-Instanz erstellen können, empfehlen wir, ein Wartungsfenster zu definieren, um die Confidential VM-Instanz basierend auf dem Support-Attribut neu zu erstellen, das die vertrauende Seite in ihrer Attestierungsrichtlinie festgelegt hat:
Wenn Sie eine Attestierungsrichtlinie festgelegt haben, die das Support-Attribut
LATESTerfordert, müssen Sie das Confidential Space-Image mindestens einmal im Monat aktualisieren.Wenn Sie eine Attestierungsrichtlinie festgelegt haben, die das Support-Attribut
STABLEerfordert, müssen Sie das Confidential Space-Image mindestens alle sechs Monate aktualisieren.
Sie können die Neuerstellung von VMs mit einer oder mehreren der folgenden Methoden vereinfachen:
Informationen zum Einrichten dieser Funktionen finden Sie unter Confidential Space-Arbeitslast mit MIGs mithilfe von Autoscaling, automatischer Reparatur und Image-Updates bereitstellen.
Arbeitslasten mit langer Ausführungszeit
Ein Confidential Space-Image kann während einer lang andauernden Arbeitslast eingestellt oder widerrufen werden. Wenn Sie eine Attestierungsrichtlinie festgelegt haben, die das Confidential Space-Support-Attribut STABLE erfordert, und das Confidential Space-Image, das Ihre Arbeitslast verwendet, veraltet ist oder widerrufen wurde, besteht die Confidential VM-Instanz, auf der die Arbeitslast ausgeführt wird, die Attestierung nicht. Um Unterbrechungen zu vermeiden, sollten lang andauernde Arbeitslasten so konzipiert sein, dass sie fortgesetzt werden können und ihr Status sicher verwaltet wird.