Confidential Space-Images

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

LATEST

LATEST-Images haben außerdem die folgenden Support-Attribute:

  • STABLE
  • USABLE

Lebensdauer des Bildes: Ungefähr ein Monat. Danach wird das Support-Attribut LATEST entfernt.

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, LATEST nicht als Teil Ihrer Attestierungsrichtlinie anzugeben. Das liegt daran, dass das Confidential Space-Image möglicherweise aktualisiert wird, während Ihre Arbeitslast ausgeführt wird. Dadurch ist das von Ihnen verwendete Confidential Space-Image nicht mehr LATEST und Ihre Arbeitslast schlägt bei der Attestierung fehl, wenn das Confidential Space-Standardtoken das nächste Mal aktualisiert wird.

STABLE

STABLE-Images haben außerdem die folgenden Support-Attribute:

  • USABLE

Lebensdauer des Images: Ungefähr sechs Monate. Ab dem 1. April 2027 wird das Support-Attribut STABLE nach Ablauf der Image-Lebensdauer entfernt.

Images mit dem Attribut STABLE werden sechs Monate lang unterstützt und auf Sicherheitslücken überwacht. Wir empfehlen, die Attestierungsrichtlinie auf Grundlage des Attributs STABLE zu schreiben.

In seltenen Fällen kann das Attribut STABLE während des normalen sechsmonatigen Supportzeitraums entfernt werden, z. B. wenn kritische Sicherheitslücken entdeckt werden.

USABLE

Images, die nur das Attribut USABLE haben, können weiterhin verwendet werden, gelten aber als veraltet. Verworfene Images werden nicht unterstützt und sind älter als sechs Monate. Die Nutzung erfolgt auf eigenes Risiko.

USABLE-Images haben das Attribut deprecated.deprecated. Der Wert ist der Zeitstempel, zu dem das Image voraussichtlich verworfen wird. Die Attribute eines Images können mit dem Befehl gcloud compute images describe oder der REST-Methode images.get angezeigt werden. Beispiel:

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. EXPERIMENTAL-Images sind nur für Testzwecke gedacht und sollten niemals in der Produktion verwendet werden.

Ein EXPERIMENTAL-Image hat nie die Attribute LATEST, STABLE oder USABLE.

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:

  1. Rufen Sie in Cloud Run die Seite Dienste auf.

    Zu Dienste

  2. Klicken Sie auf Funktion schreiben.

  3. Geben Sie im Feld Dienstname einen Namen für die Funktion ein.

  4. Wählen Sie eine Region aus, in der die Funktion ausgeführt werden soll.

  5. Legen Sie die Laufzeit auf eine aktuelle Version von Go fest.

  6. Legen Sie für Authentifizierung die Option Authentifizierung erforderlich fest.

  7. Legen Sie für Eingehender Traffic die Option Intern fest.

  8. Maximieren Sie den Abschnitt Container, Netzwerk, Sicherheit.

  9. Legen Sie auf dem Tab Container für Arbeitsspeicher den Wert 128 MiB fest.

  10. Klicken Sie auf dem Tab Sicherheit auf das Feld Dienstkonto.

  11. Klicken Sie auf Neues Dienstkonto erstellen.

  12. Geben Sie im Feld Dienstkontoname einen Namen ein.

  13. Klicken Sie auf Erstellen.

  14. Fügen Sie die Rolle Compute-Betrachter hinzu und klicken Sie dann auf Fertig.

  15. Klicken Sie auf Erstellen.

  16. Nachdem die Funktion geladen wurde, legen Sie auf dem Tab Quelle den Funktionseinstiegspunkt auf DeprecationCheck fest.

  17. Überschreiben Sie den Inhalt in function.go mit 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)
    }
    
    
  18. Überschreiben Sie den Inhalt in go.mod mit 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
    )
    
    
  19. Klicken Sie auf Speichern und wieder bereitstellen.

  20. 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:

  1. Erstellen Sie zuerst ein Dienstkonto, um den geplanten Job auszuführen. Rufen Sie dazu die Seite Dienstkonto erstellen auf:

    Zur Seite „Dienstkonto erstellen“

  2. Geben Sie im Feld Dienstkontoname einen Dienstkontonamen ein.

  3. Notieren Sie sich die Dienstkonto-ID für die spätere Verwendung.

  4. Klicken Sie auf Erstellen und fortfahren.

  5. Fügen Sie die Rolle Cloud Run-Aufrufer hinzu.

  6. Klicken Sie auf Fertig.

  7. Aktivieren Sie die Cloud Scheduler API, falls noch nicht geschehen.

  8. Rufen Sie in Cloud Scheduler die Seite Jobs auf.

    ZU JOBS

  9. Klicken Sie auf Job erstellen.

  10. Geben Sie im Feld Name einen Namen für den Job ein.

  11. Wählen Sie eine Region aus, in der der geplante Job ausgeführt werden soll.

  12. 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.

  13. Legen Sie eine Zeitzone für den Zeitplan fest.

  14. Klicken Sie auf Weiter.

  15. Legen Sie den Zieltyp auf HTTP fest.

  16. Legen Sie die URL auf die URL der von Ihnen erstellten Cloud Run-Funktion fest.

  17. Wählen Sie im Feld Auth-Header die Option OIDC-Token hinzufügen aus.

  18. Klicken Sie auf das Feld Dienstkonto und geben Sie die ID des Dienstkontos ein, das Sie zuvor erstellt haben.

  19. Legen Sie die Zielgruppe auf die URL der von Ihnen erstellten Cloud Run-Funktion fest.

  20. Klicken Sie auf Erstellen.

  21. 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:

  1. Zur Seite „Log-Explorer“

    Zum Log-Explorer

  2. Aktivieren Sie Abfrage anzeigen.

  3. 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"
      
  4. Klicken Sie auf Abfrage ausführen.

  5. Klicken Sie neben den Ergebnissen auf Aktionen.

  6. 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 LATEST erfordert, müssen Sie das Confidential Space-Image mindestens einmal im Monat aktualisieren.

  • Wenn Sie eine Attestierungsrichtlinie festgelegt haben, die das Support-Attribut STABLE erfordert, 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.