Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Betriebssystempakete automatisch scannen

In diesem Dokument erfahren Sie, wie Sie die Container Scanning API aktivieren, ein Image in Artifact Registry hochladen und die Liste der im Image gefundenen Sicherheitslücken aufrufen.

Die Artefaktanalyse liefert Informationen zu Sicherheitslücken für die Container-Images in Artifact Registry. Die Metadaten werden als Notizen gespeichert. Für jede Instanz einer Notiz, die mit einem Bild verknüpft ist, wird ein Vorkommen erstellt. Weitere Informationen finden Sie in der Übersicht und in den Preisdokumenten.

Hinweis

Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry and Container Scanning APIs, if any are not already enabled.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the APIs

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry and Container Scanning APIs, if any are not already enabled.

Roles required to enable APIs

Enable the APIs

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

Erstellen Sie ein Docker-Repository in Artifact Registry und übertragen Sie ein Container-Image per Push in das Repository. Wenn Sie mit Artifact Registry nicht vertraut sind, lesen Sie die Docker-Kurzanleitung.

Wenn Sie diese API aktivieren, wird auch das Scannen von Sprachpaketen in Artifact Registry aktiviert. Unterstützte Pakettypen

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, damit Sie die nötigen Berechtigungen zum Aufrufen der Ergebnisse von Paketscans haben:

Container Scanner-Dienst-Agent (roles/containerscanning.ServiceAgent)
Container Analysis Occurrences Viewer (roles/containeranalysis.occurrences.viewer)
Betrachter von Container Analysis-Hinweisen (roles/containeranalysis.notes.viewer)
Artifact Registry-Leser (roles/artifactregistry.reader)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Image-Sicherheitslücken ansehen

Artefaktanalyse scannt neue Images, sobald sie in Artifact Registry hochgeladen werden. Bei diesem Scan werden Informationen zu den Systempaketen im Container extrahiert.

Sie können Sicherheitslücken für Ihre Images in der Registry mit der Google Cloud Console, der Google Cloud CLI oder der Container Analysis API aufrufen. Wenn ein Bild Sicherheitslücken aufweist, können Sie die Details abrufen.

Artefaktanalyse scannt Images und Pakete weiterhin, solange sie in den letzten 30 Tagen abgerufen wurden. Nach 30 Tagen werden die Metadaten für gescannte Bilder und Pakete nicht mehr aktualisiert und die Ergebnisse sind veraltet.

Die Artefaktanalyse archiviert Metadaten, die seit mehr als 90 Tagen inaktiv sind. Diese archivierten Metadaten können nur über die API ausgewertet werden. Sie können ein Image mit veralteten oder archivierten Metadaten noch einmal scannen, indem Sie es per Pull abrufen. Das Aktualisieren der Metadaten kann bis zu 24 Stunden dauern. Pakete mit veralteten oder archivierten Metadaten können nicht neu gescannt werden.

Vorkommen in der Google Cloud Console ansehen

So rufen Sie die Sicherheitslücken in einem Image auf:

Rufen Sie die Liste der Repositories ab.

Zur Seite „Repositories“
Klicken Sie in der Repository-Liste auf ein Repository.
Klicken Sie in der Liste der Images auf einen Image-Namen.

Die Gesamtzahl der Sicherheitslücken für jeden Image-Digest wird in der Spalte Sicherheitslücken angezeigt.
Wenn Sie die Liste der Sicherheitslücken für ein Image aufrufen möchten, klicken Sie auf den Link in der Spalte Vulnerabilities (Sicherheitslücken).

Im Bereich Scanergebnisse wird eine Zusammenfassung der gescannten Pakettypen, der Gesamtzahl der Sicherheitslücken, der Sicherheitslücken mit verfügbaren Korrekturen, der Sicherheitslücken ohne Korrekturen und des effektiven Schweregrads angezeigt.

In der Tabelle der Sicherheitslücken sind für jede gefundene Sicherheitslücke der Name der Common Vulnerabilities and Exposures (CVE), der effektive Schweregrad, der CVSS-Wert (Common Vulnerability Scoring System), Korrekturen (falls verfügbar), der Name des Pakets, das die Sicherheitslücke enthält, und der Pakettyp aufgeführt.

In derGoogle Cloud Console werden in dieser Tabelle bis zu 1.200 Sicherheitslücken pro Seite angezeigt. Sie können diese Dateien filtern und sortieren, um eine bestimmte Datei, ein bestimmtes Verzeichnis, eine bestimmte Ebene oder einen bestimmten Dateityp nach Dateiendung zu prüfen.
Klicken Sie auf den Namen der CVE, um Details zu einer bestimmten CVE aufzurufen.
Wenn Sie Details zum Auftreten von Sicherheitslücken wie Versionsnummer und betroffene Stelle aufrufen möchten, klicken Sie in der Zeile mit dem Namen der Sicherheitslücke auf Ansehen oder Behobene ansehen. Der Linktext lautet Ansehen für Sicherheitslücken ohne Korrektur und Behobene ansehen für Sicherheitslücken, bei denen eine Korrektur angewendet wurde.

Sicherheitslücken in einer bestimmten Ebene ansehen

Die Artefaktanalyse bietet schichtspezifische Metadaten, mit denen Sie ermitteln können, welches Paket Sicherheitslücken enthält und mit welchem Docker-Build-Befehl diese Schicht eingeführt wurde.

So rufen Sie ebenenbasierte Metadaten zu Sicherheitslücken in der Google Cloud Console auf:

Öffnen Sie in Artifact Registry die Liste Ihrer Repositories.

Zur Seite „Repositories“
Klicken Sie auf der Seite Repositories auf ein Repository.
Klicken Sie auf der Seite Repository-Details auf ein Image.
Klicken Sie in der Liste der Bildversionen auf einen Bild-Digest.
Klicken Sie auf der Seite mit den Details zum Image-Digest auf den Tab Sicherheitslücken.

Wenn ebenenbasierte Metadaten verfügbar sind, zeigt die Artefaktanalyse in der Leiste Ebene eine auswählbare Liste von Ebenen an:
Klicken Sie auf das Drop-down-Menü für Ebenen, um die Liste der Ebenen aufzurufen.

Eine Drop-down-Liste mit einer nummerierten Liste von Ebenen wird geöffnet. Ebene 0 stellt die unterste Ebene dar, wobei jede folgende Ebene auf der vorherigen aufbaut. Es werden nur Ebenen angezeigt, in denen Sicherheitslücken gefunden wurden.

Für jede Ebene zeigt die Artefaktanalyse den Docker-Befehl, der zum Erstellen der Ebene verwendet wurde, und die Anzahl der in dieser Ebene gefundenen Sicherheitslücken an.
Wenn Sie mehr über die Sicherheitslücken in einer bestimmten Ebene erfahren möchten, wählen Sie eine Ebene aus der Ebenenliste aus.

Die Tabelle mit den Sicherheitslücken wird aktualisiert und enthält nur die Sicherheitslücken, die in der ausgewählten Ebene gefunden wurden. Sie können weitere Filter anwenden oder bestimmte Sicherheitslücken untersuchen.
Klicken Sie neben einer Sicherheitslücke auf ANSEHEN oder KORREKTUR ANSEHEN, um weitere Informationen zur Sicherheitslücke aufzurufen.

In der Seitenleiste Details zur Sicherheitslücke werden Dateispeicherorte angezeigt, an denen Pakete Sicherheitslücken aufweisen.
Bewegen Sie den Mauszeiger in der Tabelle Dateispeicherort(e) auf das Fragezeichen, um zusätzliche Layer-Metadaten zu öffnen.

In einem Dialogfeld werden der Schichtindex, der Schicht-Build-Befehl, der Schicht-Digest und das Basis-Image angezeigt, in dem Sie die Sicherheitslücke beheben können.

Vorkommen mit gcloud ansehen

Führen Sie den Befehl gcloud artifacts docker images list aus, um Vorkommen für Images in Artifact Registry aufzurufen:

  gcloud artifacts docker images list --show-occurrences \
      LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

Wobei:

LOCATION ist der regionale oder multiregionale Speicherort des Repositorys.
PROJECT_ID ist die Projekt-ID Ihrer Google Cloud Console.
REPOSITORY ist der Name des Repositorys, in dem das Image gespeichert ist.
IMAGE_ID ist der Name des Images im Repository. Mit diesem Befehl können Sie kein Image-Tag angeben.

Standardmäßig werden mit dem Befehl die zehn letzten Ergebnisse zurückgegeben. Verwenden Sie das Flag --show-occurrences-from, um eine andere Anzahl von Ergebnissen anzuzeigen. Mit dem folgenden Befehl werden beispielsweise die 25 neuesten Ergebnisse zurückgegeben:

gcloud artifacts docker images list --show-occurrences-from=25 \
    us-central1-docker.pkg.dev/my-project/my-repo/my-image

Die Ausgabe sieht dann ungefähr so aus:

Beispiel für eine Bildausgabe

  {
      "name": "projects/my-project/locations/us-central1/occurrences/22d3edfb-34f2-4d3f-be08-fd90c549f010",
      "resource": {
        "uri": "https://us-central1-docker.pkg.dev/my-project/my-repo/golang-nginx@sha256:5b54ef20748417ccdb0b87afedf98c44e699e2f59bd6cv48cbdc1ca2e72c80e3"
      },
      "noteName": "projects/my-project/locations/us-central1/notes/CVE-2005-2541",
      "kind": "VULNERABILITY",
      "createTime": "2025-01-21T15:57:01.238832Z",
      "updateTime": "2025-01-21T15:57:01.238832Z",
      "vulnerability": {
        "severity": "CRITICAL",
        "cvssScore": 10,
        "packageIssue": [
          {
            "affectedLocation": {
              "cpeUri": "cpe:/o:debian:debian_linux:12",
              "package": "tar",
              "version": {
                "name": "1.34+dfsg",
                "revision": "1.2+deb12u1",
                "kind": "NORMAL"
              }
            },
            "fixedLocation": {
              "cpeUri": "cpe:/o:debian:debian_linux:12",
              "package": "tar",
              "version": {
                "kind": "MAXIMUM"
              }
            },
            "packageType": "OS",
            "effectiveSeverity": "LOW",
            "file_location": [
                {
                "file_path": "/var/lib/dpkg/status",
                "layerDetails": {
                  "index": 0,
                  "diffID": "sha256:123",
                  "buildCommand": "FROM golang:example_sha256",
                  "BaseImages": [
                    {
                      "name": "library/golang",
                    },
                  ],
                },
              },
            ],
          }
        ],
        "shortDescription": "CVE-2005-2541",
        "longDescription": "NIST vectors: AV:N/AC:L/Au:N/C:C/I:C/A:C",
        "relatedUrls": [
          {
            "url": "https://security-tracker.debian.org/tracker/CVE-2005-2541",
            "label": "More Info"
          }
        ],
        "effectiveSeverity": "LOW",
        "cvssVersion": "CVSS_VERSION_2",
        "cvssV2": {
          "baseScore": 10,
          "attackVector": "ATTACK_VECTOR_NETWORK",
          "attackComplexity": "ATTACK_COMPLEXITY_LOW",
          "authentication": "AUTHENTICATION_NONE",
          "confidentialityImpact": "IMPACT_COMPLETE",
          "integrityImpact": "IMPACT_COMPLETE",
          "availabilityImpact": "IMPACT_COMPLETE"
        }
      }
    }

Sicherheitslückenvorkommen filtern

Verwenden Sie den Parameter --occurrence-filter, um das Auftreten von Sicherheitslücken zu filtern:

gcloud artifacts docker images list --show-occurrences \
    LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID \
    --occurrence-filter=FILTER_EXPRESSION

Wobei:

LOCATION ist der regionale oder multiregionale Speicherort für das Repository.
PROJECT_ID ist Ihre Projekt-ID in der Console von Google Cloud .
REPOSITORY ist der Name des Repositorys, in dem das Image gespeichert ist.
IMAGE_ID ist der Name des Images im Repository.
FILTER_EXPRESSION ist ein Beispiel für einen Filterausdruck im Format, das unter Vulnerability-Vorkommen filtern beschrieben wird.

Sicherheitslücken für eine bestimmte Ebene ansehen

Mit dem Feld layerDetails können Sie ermitteln, in welcher Ebene ein anfälliges Paket eingeführt wurde, und zusätzliche Informationen zu dieser Ebene aufrufen. Betrachten Sie beispielsweise die folgende layerDetails-Ausgabe für ein Image:

  "layerDetails": {
    "index": 0,
    "diffID": "sha256:123",
    "buildCommand": "FROM golang:example_sha256",
    "BaseImages": [
      {
        "name": "library/golang",
      },
    ],
  }

Die Ausgabe zeigt, dass der Layer-Index im Bild 0 ist und der Layer-Hash sha256:123 lautet. Der Docker-Build-Befehl zum Erstellen dieser Ebene ist FROM golang:example_sha256. Die Ebene ist auch im Basis-Image library/golang enthalten.

Vorkommen mit der API oder mit Code ansehen

Wenn Sie Vorkommen für ein Bild aufrufen möchten, geben Sie Bilder mit einer URL im folgenden Format an:

LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

API

cURL verwenden

So rufen Sie eine Liste der Vorkommen in Ihrem Projekt ab:

 curl -X GET -H "Content-Type: application/json" -H \
    "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences

So erhalten Sie eine Zusammenfassung der Sicherheitslücken in Ihrem Projekt:

 curl -X GET -H "Content-Type: application/json" -H \
    "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences:vulnerabilitySummary

So rufen Sie Details zu einem bestimmten Vorkommen ab:

 curl -X GET -H "Content-Type: application/json" -H \
    "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences/OCCURRENCE_ID

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Artefaktanalyse finden Sie unter Artefaktanalyse-Clientbibliotheken. Weitere Informationen finden Sie in der Artefaktanalyse-Referenzdokumentation zur Java API.

Richten Sie zur Authentifizierung bei Artefaktanalyse Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import com.google.cloud.devtools.containeranalysis.v1.ContainerAnalysisClient;
import io.grafeas.v1.GrafeasClient;
import io.grafeas.v1.Occurrence;
import io.grafeas.v1.ProjectName;
import java.io.IOException;
import java.lang.InterruptedException;

public class OccurrencesForImage {
  // Retrieves all the Occurrences associated with a specified image
  // Here, all Occurrences are simply printed and counted
  public static int getOccurrencesForImage(String resourceUrl, String projectId)
      throws IOException, InterruptedException {
    // String resourceUrl = "https://gcr.io/project/image@sha256:123";
    // String projectId = "my-project-id";
    final String projectName = ProjectName.format(projectId);
    final String filterStr = String.format("resourceUrl=\"%s\"", resourceUrl);

    // Initialize client that will be used to send requests. After completing all of your requests, 
    // call the "close" method on the client to safely clean up any remaining background resources.
    GrafeasClient client = ContainerAnalysisClient.create().getGrafeasClient();
    int i = 0;
    for (Occurrence o : client.listOccurrences(projectName, filterStr).iterateAll()) {
      // Write custom code to process each Occurrence here
      System.out.println(o.getName());
      i = i + 1;
    }
    return i;
  }
}

Go


import (
	"context"
	"fmt"
	"io"

	containeranalysis "cloud.google.com/go/containeranalysis/apiv1"
	"google.golang.org/api/iterator"
	grafeaspb "google.golang.org/genproto/googleapis/grafeas/v1"
)

// getOccurrencesForImage retrieves all the Occurrences associated with a specified image.
// Here, all Occurrences are simply printed and counted.
func getOccurrencesForImage(w io.Writer, resourceURL, projectID string) (int, error) {
	// Use this style of URL when you use Google Container Registry.
	// resourceURL := "https://gcr.io/my-project/my-repo/my-image"
	// Use this style of URL when you use Google Artifact Registry.
	// resourceURL := "https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image"
	ctx := context.Background()
	client, err := containeranalysis.NewClient(ctx)
	if err != nil {
		return -1, fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	req := &grafeaspb.ListOccurrencesRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Filter: fmt.Sprintf("resourceUrl=%q", resourceURL),
	}
	it := client.GetGrafeasClient().ListOccurrences(ctx, req)
	count := 0
	for {
		occ, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return -1, fmt.Errorf("occurrence iteration error: %w", err)
		}
		// Write custom code to process each Occurrence here.
		fmt.Fprintln(w, occ)
		count = count + 1
	}
	return count, nil
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Artefaktanalyse finden Sie unter Artifact Analysis-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Artefaktanalyse Node.js API.

/**
 * TODO(developer): Uncomment these variables before running the sample
 */
// const projectId = 'your-project-id', // Your GCP Project ID
// If you are using Google Container Registry
// const imageUrl = 'https://gcr.io/my-project/my-repo/my-image@sha256:123' // Image to attach metadata to
// If you are using Google Artifact Registry
// const imageUrl = 'https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image@sha256:123' // Image to attach metadata to

// Import the library and create a client
const {ContainerAnalysisClient} = require('@google-cloud/containeranalysis');
const client = new ContainerAnalysisClient();

const formattedParent = client.getGrafeasClient().projectPath(projectId);

// Retrieves all the Occurrences associated with a specified image
const [occurrences] = await client.getGrafeasClient().listOccurrences({
  parent: formattedParent,
  filter: `resourceUrl = "${imageUrl}"`,
});

if (occurrences.length) {
  console.log(`Occurrences for ${imageUrl}`);
  occurrences.forEach(occurrence => {
    console.log(`${occurrence.name}:`);
  });
} else {
  console.log('No occurrences found.');
}

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Artefaktanalyse finden Sie unter Artefaktanalyse-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Artefaktanalyse Ruby API.

# resource_url = "The URL of the resource associated with the occurrence."
#                # e.g. https://gcr.io/project/image@sha256:123"
# project_id   = "The Google Cloud project ID of the occurrences to retrieve"

require "google/cloud/container_analysis"

# Initialize the client
client = Google::Cloud::ContainerAnalysis.container_analysis.grafeas_client

parent = client.project_path project: project_id
filter = "resourceUrl = \"#{resource_url}\""
count = 0
client.list_occurrences(parent: parent, filter: filter).each do |occurrence|
  # Process occurrence here
  puts occurrence
  count += 1
end
puts "Found #{count} occurrences"

Python

from google.cloud.devtools import containeranalysis_v1


def get_occurrences_for_image(resource_url: str, project_id: str) -> int:
    """Retrieves all the occurrences associated with a specified image.
    Here, all occurrences are simply printed and counted."""
    # resource_url = 'https://gcr.io/my-project/my-image@sha256:123'
    # project_id = 'my-gcp-project'

    filter_str = f'resourceUrl="{resource_url}"'
    client = containeranalysis_v1.ContainerAnalysisClient()
    grafeas_client = client.get_grafeas_client()
    project_name = f"projects/{project_id}"

    response = grafeas_client.list_occurrences(parent=project_name, filter=filter_str)
    count = 0
    for o in response:
        # do something with the retrieved occurrence
        # in this sample, we will simply count each one
        count += 1
    return count

Vorkommen in Cloud Build ansehen

Wenn Sie Cloud Build verwenden, können Sie sich auch im Seitenbereich Sicherheitsinformationen in der Google Cloud Console Bildschwachstellen ansehen.

Die Seitenleiste Sicherheitsinformationen bietet einen allgemeinen Überblick über die Build-Sicherheitsinformationen für Artefakte, die in Artifact Registry gespeichert sind. Weitere Informationen zur Seitenleiste und dazu, wie Sie Cloud Build zum Schutz Ihrer Softwarelieferkette verwenden können, finden Sie unter Build-Sicherheitserkenntnisse ansehen.

Vorkommen filtern

Sie können Filterstrings in den gcloud-Befehlen und der Artifact Analysis API verwenden, um Vorkommen zu filtern, bevor Sie sie ansehen. In den folgenden Abschnitten werden die unterstützten Suchfilter beschrieben.

Erkennungsvorkommen ansehen

Wenn ein Image zum ersten Mal per Push an Artifact Registry übertragen wird, erstellt Artifact Registry ein Discovery-Vorkommen, das Informationen zum ersten Scan des Container-Images enthält.

Mit diesem Filterausdruck rufen Sie das Erkennungsvorkommen für ein Image ab:

kind="DISCOVERY" AND resourceUrl="RESOURCE_URL"

Dabei hat RESOURCE_URL das folgende Format:

LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

gcloud

Erkennungsvorkommen für ein Image ansehen:

In diesem Fall wird der Ausdruck nicht direkt im Befehl verwendet, aber dieselben Informationen werden als Argumente übergeben:

Artifact Registry:

gcloud artifacts docker images list --show-occurrences \
--occurrence-filter='kind="DISCOVERY"' --format=json \
LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

API

Zum Abrufen des Discovery-Vorkommens muss Ihr Filterausdruck URL-codiert und so in eine GET-Anfrage eingebettet sein:

GET https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences?filter=kind%3D%22DISCOVERY%22%20AND%20resourceUrl%3D%22ENCODED_RESOURCE_URL%22

Weitere Informationen finden Sie unter dem API-Endpunkt projects.occurrences.get.

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Artefaktanalyse finden Sie unter Artefaktanalyse-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Artefaktanalyse Java API.

import com.google.cloud.devtools.containeranalysis.v1.ContainerAnalysisClient;
import io.grafeas.v1.GrafeasClient;
import io.grafeas.v1.Occurrence;
import io.grafeas.v1.ProjectName;
import java.io.IOException;
import java.lang.InterruptedException;

public class GetDiscoveryInfo {
  // Retrieves and prints the Discovery Occurrence created for a specified image
  // The Discovery Occurrence contains information about the initial scan on the image
  public static void getDiscoveryInfo(String resourceUrl, String projectId) 
      throws IOException, InterruptedException {
    // String resourceUrl = "https://gcr.io/project/image@sha256:123";
    // String projectId = "my-project-id";
    String filterStr = "kind=\"DISCOVERY\" AND resourceUrl=\"" + resourceUrl + "\"";
    final String projectName = ProjectName.format(projectId);

    // Initialize client that will be used to send requests. After completing all of your requests, 
    // call the "close" method on the client to safely clean up any remaining background resources.
    GrafeasClient client = ContainerAnalysisClient.create().getGrafeasClient();
    for (Occurrence o : client.listOccurrences(projectName, filterStr).iterateAll()) {
      System.out.println(o);
    }
  }
}

Go


import (
	"context"
	"fmt"
	"io"

	containeranalysis "cloud.google.com/go/containeranalysis/apiv1"
	"google.golang.org/api/iterator"
	grafeaspb "google.golang.org/genproto/googleapis/grafeas/v1"
)

// getDiscoveryInfo retrieves and prints the Discovery Occurrence created for a specified image.
// The Discovery Occurrence contains information about the initial scan on the image.
func getDiscoveryInfo(w io.Writer, resourceURL, projectID string) error {
	// Use this style of URL when you use Google Container Registry.
	// resourceURL := "https://gcr.io/my-project/my-repo/my-image"
	// Use this style of URL when you use Google Artifact Registry.
	// resourceURL := "https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image"
	ctx := context.Background()
	client, err := containeranalysis.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	req := &grafeaspb.ListOccurrencesRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Filter: fmt.Sprintf(`kind="DISCOVERY" AND resourceUrl=%q`, resourceURL),
	}
	it := client.GetGrafeasClient().ListOccurrences(ctx, req)
	for {
		occ, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("occurrence iteration error: %w", err)
		}
		fmt.Fprintln(w, occ)
	}
	return nil
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für die Artefaktanalyse finden Sie unter Artefaktanalyse-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Artefaktanalyse Node.js API.

/**
 * TODO(developer): Uncomment these variables before running the sample
 */
// const projectId = 'your-project-id', // Your GCP Project ID
// If you are using Google Container Registry
// const imageUrl = 'https://gcr.io/my-project/my-repo/my-image:123' // Image to attach metadata to
// If you are using Google Artifact Registry
// const imageUrl = 'https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image:123' // Image to attach metadata to

// Import the library and create a client
const {ContainerAnalysisClient} = require('@google-cloud/containeranalysis');
const client = new ContainerAnalysisClient();

const formattedParent = client.getGrafeasClient().projectPath(projectId);
// Retrieves and prints the Discovery Occurrence created for a specified image
// The Discovery Occurrence contains information about the initial scan on the image
const [occurrences] = await client.getGrafeasClient().listOccurrences({
  parent: formattedParent,
  filter: `kind = "DISCOVERY" AND resourceUrl = "${imageUrl}"`,
});

if (occurrences.length > 0) {
  console.log(`Discovery Occurrences for ${imageUrl}`);
  occurrences.forEach(occurrence => {
    console.log(`${occurrence.name}:`);
  });
} else {
  console.log('No occurrences found.');
}

Ruby

# resource_url = "The URL of the resource associated with the occurrence."
#                # e.g. https://gcr.io/project/image@sha256:123
# project_id   = "The Google Cloud project ID of the occurrences to retrieve"

require "google/cloud/container_analysis"

# Initialize the client
client = Google::Cloud::ContainerAnalysis.container_analysis.grafeas_client

parent = client.project_path project: project_id
filter = "kind = \"DISCOVERY\" AND resourceUrl = \"#{resource_url}\""
client.list_occurrences(parent: parent, filter: filter).each do |occurrence|
  # Process discovery occurrence here
  puts occurrence
end

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Artefaktanalyse finden Sie unter Artefaktanalyse-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Artefaktanalyse Python API.

from google.cloud.devtools import containeranalysis_v1


def get_discovery_info(resource_url: str, project_id: str) -> None:
    """Retrieves and prints the discovery occurrence created for a specified
    image. The discovery occurrence contains information about the initial
    scan on the image."""
    # resource_url = 'https://gcr.io/my-project/my-image@sha256:123'
    # project_id = 'my-gcp-project'

    filter_str = f'kind="DISCOVERY" AND resourceUrl="{resource_url}"'
    client = containeranalysis_v1.ContainerAnalysisClient()
    grafeas_client = client.get_grafeas_client()
    project_name = f"projects/{project_id}"
    response = grafeas_client.list_occurrences(parent=project_name, filter_=filter_str)
    for occ in response:
        print(occ)

Vorkommen von Sicherheitslücken ansehen

Erstellen Sie eine Abfrage mit einem Filterausdruck, um Sicherheitslücken für ein bestimmtes Image aufzurufen:

kind="VULNERABILITY" AND resourceUrl="RESOURCE_URL"

Dabei hat RESOURCE_URL das folgende Format:

LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

gcloud

In diesem Fall wird der Ausdruck nicht direkt im Befehl verwendet, aber dieselben Informationen werden als Argumente übergeben:

Artifact Registry

gcloud artifacts docker images list --show-occurrences \
--occurrence-filter='kind="VULNERABILITY"' --format=json \
LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

API

Die Ressourcen-URL muss URL-codiert und so in eine GET-Anfrage eingebettet sein:

GET https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences?filter=kind%3D%22VULNERABILITY%22%20AND%20resourceUrl%3D%22ENCODED_RESOURCE_URL%22

Weitere Informationen finden Sie unter dem API-Endpunkt projects.occurrences.get.

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Artefaktanalyse finden Sie unter Artifact Analysis-Clientbibliotheken. Weitere Informationen finden Sie in der Artefaktanalyse-Referenzdokumentation zur Java API.

import com.google.cloud.devtools.containeranalysis.v1.ContainerAnalysisClient;
import io.grafeas.v1.GrafeasClient;
import io.grafeas.v1.Occurrence;
import io.grafeas.v1.ProjectName;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

public class VulnerabilityOccurrencesForImage {
  // Retrieve a list of vulnerability occurrences assoviated with a resource
  public static List<Occurrence> findVulnerabilityOccurrencesForImage(String resourceUrl, 
      String projectId) throws IOException {
    // String resourceUrl = "https://gcr.io/project/image@sha256:123";
    // String projectId = "my-project-id";
    final String projectName = ProjectName.format(projectId);
    String filterStr = String.format("kind=\"VULNERABILITY\" AND resourceUrl=\"%s\"", resourceUrl);

    // Initialize client that will be used to send requests. After completing all of your requests, 
    // call the "close" method on the client to safely clean up any remaining background resources.
    GrafeasClient client = ContainerAnalysisClient.create().getGrafeasClient();
    LinkedList<Occurrence> vulnerabilitylist = new LinkedList<Occurrence>();
    for (Occurrence o : client.listOccurrences(projectName, filterStr).iterateAll()) {
      vulnerabilitylist.add(o);
    }
    return vulnerabilitylist;
  }
}

Go


import (
	"context"
	"fmt"

	containeranalysis "cloud.google.com/go/containeranalysis/apiv1"
	"google.golang.org/api/iterator"
	grafeaspb "google.golang.org/genproto/googleapis/grafeas/v1"
)

// findVulnerabilityOccurrencesForImage retrieves all vulnerability Occurrences associated with a resource.
func findVulnerabilityOccurrencesForImage(resourceURL, projectID string) ([]*grafeaspb.Occurrence, error) {
	// Use this style of URL when you use Google Container Registry.
	// resourceURL := "https://gcr.io/my-project/my-repo/my-image"
	// Use this style of URL when you use Google Artifact Registry.
	// resourceURL := "https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image"
	ctx := context.Background()
	client, err := containeranalysis.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	req := &grafeaspb.ListOccurrencesRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Filter: fmt.Sprintf("resourceUrl = %q kind = %q", resourceURL, "VULNERABILITY"),
	}

	var occurrenceList []*grafeaspb.Occurrence
	it := client.GetGrafeasClient().ListOccurrences(ctx, req)
	for {
		occ, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return nil, fmt.Errorf("occurrence iteration error: %w", err)
		}
		occurrenceList = append(occurrenceList, occ)
	}

	return occurrenceList, nil
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Artefaktanalyse finden Sie unter Artifact Analysis-Clientbibliotheken. Weitere Informationen finden Sie in der Artefaktanalyse-Referenzdokumentation zur Node.js API.

/**
 * TODO(developer): Uncomment these variables before running the sample
 */
// const projectId = 'your-project-id', // Your GCP Project ID
// If you are using Google Container Registry
// const imageUrl = 'https://gcr.io/my-project/my-repo/my-image:123' // Image to attach metadata to
// If you are using Google Artifact Registry
// const imageUrl = 'https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image:123' // Image to attach metadata to

// Import the library and create a client
const {ContainerAnalysisClient} = require('@google-cloud/containeranalysis');
const client = new ContainerAnalysisClient();

const formattedParent = client.getGrafeasClient().projectPath(projectId);

// Retrieve a list of vulnerability occurrences assoviated with a resource
const [occurrences] = await client.getGrafeasClient().listOccurrences({
  parent: formattedParent,
  filter: `kind = "VULNERABILITY" AND resourceUrl = "${imageUrl}"`,
});

if (occurrences.length) {
  console.log(`All Vulnerabilities for ${imageUrl}`);
  occurrences.forEach(occurrence => {
    console.log(`${occurrence.name}:`);
  });
} else {
  console.log('No occurrences found.');
}

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Artefaktanalyse finden Sie unter Artefaktanalyse-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Artefaktanalyse Ruby API.

# resource_url = "The URL of the resource associated with the occurrence
#                e.g. https://gcr.io/project/image@sha256:123"
# project_id   = "The Google Cloud project ID of the vulnerabilities to find"

require "google/cloud/container_analysis"

# Initialize the client
client = Google::Cloud::ContainerAnalysis.container_analysis.grafeas_client

parent = client.project_path project: project_id
filter = "resourceUrl = \"#{resource_url}\" AND kind = \"VULNERABILITY\""
client.list_occurrences parent: parent, filter: filter

Python

Richten Sie zur Authentifizierung bei Artefaktanalyse die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

from typing import List

from google.cloud.devtools import containeranalysis_v1
from grafeas.grafeas_v1 import types


def find_vulnerabilities_for_image(
    resource_url: str, project_id: str
) -> List[types.grafeas.Occurrence]:
    """ "Retrieves all vulnerability occurrences associated with a resource."""
    # resource_url = 'https://gcr.io/my-project/my-image@sha256:123'
    # project_id = 'my-gcp-project'

    client = containeranalysis_v1.ContainerAnalysisClient()
    grafeas_client = client.get_grafeas_client()
    project_name = f"projects/{project_id}"

    filter_str = 'kind="VULNERABILITY" AND resourceUrl="{}"'.format(resource_url)
    return list(grafeas_client.list_occurrences(parent=project_name, filter=filter_str))

Vorkommen eines bestimmten Typs ansehen

In den beiden vorherigen Beispielen besteht der einzige Unterschied zwischen den Filterausdrücken im Wert von kind, der den Typ des Ereignisses angibt. Mit diesem Feld können Sie die Liste der Vorkommen auf eine bestimmte Art beschränken, z. B. eine Sicherheitslücke oder Bereitstellung.

Verwenden Sie folgenden Filterausdruck, um Vorkommen für ein bestimmtes Image abzurufen:

kind="NOTE_KIND" AND resourceUrl="RESOURCE_URL"

Wobei:

NOTE_KIND ist die Art des Hinweises.
- Verwenden Sie beispielsweise DISCOVERY zum Auflisten der Erkennungsvorkommen. Discovery-Vorkommen werden für Images erstellt, wenn sie zum ersten Mal per Push in Artifact Registry übertragen werden.
- Verwenden Sie zum Auflisten der Vorkommen von Sicherheitslücken die Art VULNERABILITY.
RESOURCE_URL ist die vollständige URL des Images https://HOSTNAME/PROJECT_ID/IMAGE_ID@sha256:HASH.

Der Filterausdruck zum Abrufen von Vorkommen einer bestimmten Art für mehrere Images lautet:

kind="NOTE_KIND" AND has_prefix(resourceUrl, "RESOURCE_URL_PREFIX")

Wobei:

RESOURCE_URL_PREFIX ist das URL-Präfix für einige Images.
- Zum Auflisten aller Versionen eines Images: https://HOSTNAME/PROJECT_ID/IMAGE_ID@
- Zum Auflisten aller Images in einem Projekt: https://HOSTNAME/PROJECT_ID/

Bilder ansehen, die mit einer bestimmten Notiz verknüpft sind

Sie können eine Liste von Ressourcen abrufen, die einer bestimmten Hinweis-ID zugeordnet sind. So können Sie beispielsweise Images mit einer bestimmten CVE-Sicherheitslücke auflisten.

Verwenden Sie den folgenden Filterausdruck, um alle Images in einem Projekt aufzulisten, die einem bestimmten Hinweis zugeordnet sind:

noteProjectId="PROVIDER_PROJECT_ID" AND noteId="NOTE_ID"

Mit dem folgenden Filterausdruck können Sie ein bestimmtes Image auf einen konkreten Hinweis prüfen:

resourceUrl="RESOURCE_URL" AND noteProjectId="PROVIDER_PROJECT_ID" \
    AND noteId="NOTE_ID"

Wobei:

PROVIDER_PROJECT_ID ist die ID eines Provider-Projekts. Beispielsweise stellt goog-vulnz die Standardanalyse für Sicherheitslücken bereit.
NOTE_ID ist die ID des Hinweises. Sicherheitsbezogene Hinweise sind oft als CVE-2019-12345 formatiert.
RESOURCE_URL ist die vollständige URL des Images https://HOSTNAME/PROJECT_ID/IMAGE_ID@sha256:HASH.

Mit dem folgenden Filterausdruck können Sie beispielsweise prüfen, ob alle Images gemäß der Google-Analyse CVE-2017-16231 enthalten:

noteProjectId="goog-vulnz" AND noteId="CVE-2017-16231"

Nächste Schritte

Pub/Sub-Benachrichtigungen verwenden, um Benachrichtigungen zu Sicherheitslücken und anderen Metadaten zu erhalten.
Mit Kritis Signer können Sie Attestierungen für die Binärautorisierung als Teil Ihrer Build-Pipeline erstellen. Mit diesem Tool können Binärautorisierungs-Attestierungen auf Grundlage von Ergebnissen von Scans auf Sicherheitslücken erstellt werden. Weitere Informationen finden Sie unter Atteste mit Kritis Signer erstellen.

Betriebssystempakete automatisch scannen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hinweis

Erforderliche Rollen

Image-Sicherheitslücken ansehen

Vorkommen in der Google Cloud Console ansehen

Sicherheitslücken in einer bestimmten Ebene ansehen

Vorkommen mit gcloud ansehen

Beispiel für eine Bildausgabe

Sicherheitslückenvorkommen filtern

Sicherheitslücken für eine bestimmte Ebene ansehen

Vorkommen mit der API oder mit Code ansehen

API

Java

Go

Node.js

Ruby

Python

Vorkommen in Cloud Build ansehen

Vorkommen filtern

Erkennungsvorkommen ansehen

gcloud

API

Java

Go

Node.js

Ruby

Python

Vorkommen von Sicherheitslücken ansehen

gcloud

API

Java

Go

Node.js

Ruby

Python

Vorkommen eines bestimmten Typs ansehen

Bilder ansehen, die mit einer bestimmten Notiz verknüpft sind

Nächste Schritte

Betriebssystempakete automatisch scannen