Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Logs abfragen und aufrufen

Auf dieser Seite finden Sie eine detaillierte Anleitung zum Abfragen und Visualisieren Ihrer Logs mit der Grafana-Benutzeroberfläche und der Log Query API, um Einblicke in Ihre Dienstereignisse und -aktivitäten zu erhalten.

Nachdem Sie Logs erfasst haben von Ihren bereitgestellten Arbeitslasten und Diensten in Google Distributed Cloud (GDC) air-gapped, können Sie mit der Analyse beginnen. Dazu können Sie die Logs in informativen Grafana-Panels visualisieren und filtern oder direkt über die Log Query API mit HTTP- oder gRPC-Aufrufen für den programmatischen Zugriff aufrufen.

Sie haben zwei Möglichkeiten, auf Ihre Logs zuzugreifen:

Grafana-Panels: Über das Log-Panel Ihrer Grafana-Instanz erhalten Sie Einblicke in den Aktivitätsverlauf Ihres Projekts. Mit diesem Panel können Sie bestimmte Logs abfragen und genau bestimmen, um eine detaillierte Datenbeobachtbarkeit zu erhalten, die auf Ihre Bedürfnisse zugeschnitten ist. Grafana bietet eine nutzerfreundliche Oberfläche zum Filtern und Analysieren Ihrer Arbeitslastdaten sowie zum Erstellen benutzerdefinierter Dashboards und Panels für eine umfassende Visualisierung.
Log Query API: Für den programmatischen Zugriff können Sie Logs direkt über die Log Query API Ihres Projekts abfragen. Die Log Query API ist eine Nicht-Kubernetes-API, die HTTP und gRPC unterstützt und eigene Endpunkte für Sie bereitstellt. Greifen Sie nur innerhalb einer bestimmten Organisation in Distributed Cloud auf diese API zu, indem Sie die Standardmethoden für den API-Zugriff verwenden.

Hinweis

Bitten Sie Ihren IAM-Administrator der Organisation oder Projekt-IAM-Administrator, Ihnen eine der vordefinierten Rollen „Grafana-Viewer der Organisation“ oder „Grafana-Viewer des Projekts“ zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Abfragen und Visualisieren von Logs auf der Grafana-Benutzeroberfläche benötigen. Je nach erforderlichem Zugriff und den erforderlichen Berechtigungen können Sie Grafana-Rollen in einer Organisation oder einem Projekt erhalten.

Alternativ können Sie Ihren Projekt-IAM-Administrator bitten, Ihnen die Rolle „Log Query API Querier“ in Ihrem Projektnamespace zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Abfragen von Logs über die Log Query API benötigen.

Weitere Informationen zu diesen Rollen finden Sie unter IAM-Berechtigungen vorbereiten.

Logs abfragen und filtern

Wählen Sie eine der folgenden Methoden aus, um Abfragen zu erstellen und Logs aus Ihren Projektarbeitslasten zu filtern:

Grafana-Log-Panel

In diesem Abschnitt wird beschrieben, wie Sie in Grafana über das Log-Panel auf Ihre Logs zugreifen.

Grafana-Endpunkt ermitteln

Die folgende URL ist der Endpunkt der Grafana-Instanz Ihres Projekts:

  https://GDC_URL/PROJECT_NAMESPACE/grafana

Ersetzen Sie Folgendes:

GDC_URL: die URL Ihrer Organisation in GDC.
PROJECT_NAMESPACE: Ihr Projektnamespace.

Der Grafana-Endpunkt für das platform-obs Projekt in der org-1 Organisation ist https://org-1/platform-obs/grafana.

Logs auf der Grafana-Benutzeroberfläche ansehen

So fragen Sie Logs auf der Grafana-Benutzeroberfläche ab:

Wählen Sie in der GDC Console Ihr Projekt aus.
Wählen Sie im Navigationsmenü Vorgänge > Logging aus.
Klicken Sie auf Alle in Grafana Loki ansehen.

Auf einer neuen Seite wird Ihr Grafana-Endpunkt geöffnet und die Benutzeroberfläche angezeigt.
Klicken Sie auf der Benutzeroberfläche im Navigationsmenü auf explore Explore , um die Seite Explore zu öffnen.
Wählen Sie in der Leiste Explore (Erkunden) eine Datenquelle aus, um Logs abzurufen. Das hängt von Ihrem Universumstyp ab:
- Universen mit einer Zone: Wählen Sie eine der folgenden Daten quellen aus, um Logging-Daten aus der einzelnen Zone Ihres Universums anzuzeigen:
  - Betriebslogs: Betriebslogs anzeigen.
  - Audit-Logs: Audit-Logs anzeigen.
- Universen mit mehreren Zonen: Grafana kann eine Verbindung zu verschiedenen Zonen herstellen und zonenübergreifende Daten anzeigen. Wählen Sie eine der folgenden Datenquellen aus, um Logging-Daten aus einer beliebigen Zone Ihres Universums anzuzeigen, unabhängig davon, in welcher Zone Sie angemeldet sind:
  - Betriebslogs ZONE_NAME: Betriebslogs aus einer bestimmten Zone anzeigen.
  - Audit-Logs ZONE_NAME: Audit-Logs aus einer bestimmten Zone anzeigen.
  Wenn Sie außerdem zonenübergreifende Datenvisualisierungen in einem einzigen Dashboard haben und Ihrer Abfrage mehrere Zonen hinzufügen möchten, wählen Sie Mixed (Gemischt) als Datenquelle aus.
  
  Hinweis: Audit-Logs sind nur für Plattformadministratoren verfügbar, auch wenn sie keine Ziele für die Audit-Protokollierung erstellen oder konfigurieren können. Anwendungsoperatoren können nur auf Betriebslogs zugreifen.
Geben Sie eine Abfrage ein, um im Log-Panel mit LogQL (Log Query Language) Ausdrücken nach Logs zu suchen. Sie haben zwei Möglichkeiten:
- Verwenden Sie die interaktive Query Builder-Oberfläche. Klicken Sie dann auf Abfrage ausführen.
- Geben Sie die Abfrage direkt in das Textfeld ein und drücken Sie Shift+Enter, um die Abfrage auszuführen.
Auf der Seite werden die Logs angezeigt, die Ihrer Abfrage entsprechen. Nachdem Sie Logs abgefragt haben, können Sie sie exportieren. Klicken Sie auf Exportieren , um Logs im Nur-Text- oder CSV-Format herunterzuladen. Sie können auch einen Zeitraum für Ihre Logs auswählen.

Abbildung 1. Menüoption zum Abfragen von Audit-Logs über die Grafana-Benutzeroberfläche.

In Abbildung 1 wird mit der Option Audit-Logs die Oberfläche angezeigt, mit der Sie Abfragen aus Grafana erstellen können, um Audit-Logs abzurufen.

Beispiele für Labels und Werte zum Abfragen verschiedener Logs finden Sie unter Beispielabfragen und -labels.

Zeitraum für Logs auswählen

So fragen Sie Logs in einem bestimmten Zeitraum ab:

Klicken Sie in Grafana auf das Menü Time Picker (Zeitauswahl).
Führen Sie im Menü eine der folgenden Aktionen aus:
- Wählen Sie Optionen für relative Zeiträume aus, z. B. die letzten 30 Minuten.
- Legen Sie benutzerdefinierte absolute Zeiträume fest, indem Sie bestimmte Daten und Uhrzeiten im Kalender auswählen und auf Zeitraum anwenden klicken.
Optional können Sie auf Zeiteinstellungen ändern klicken, um die Einstellungen für Zeitzone und Geschäftsjahr über die Steuerelemente für den Zeitraum zu ändern.

Die Zeiteinstellungen werden pro Dashboard gespeichert. Weitere Informationen zu Abfragen über einen Zeitraum finden Sie unter https://grafana.com/docs/loki/latest/reference/api/#query-loki-over-a-range-of-time.

Log Query API

In diesem Abschnitt wird beschrieben, wie Sie über die Log Query API auf Ihre Logs zugreifen.

API-Endpunkt der Log Query API ermitteln

Die Log Query API stellt die folgenden beiden Endpunkte zum Abfragen von Audit- und Betriebslogs bereit:

Endpunkt für Audit-Logs :
```
audit-log-query-api.ORG_DOMAIN
```
Hinweis: Audit-Logs sind nur für Plattformadministratoren verfügbar, auch wenn sie keine Ziele für die Audit-Protokollierung erstellen oder konfigurieren können. Anwendungsoperatoren können nur auf Betriebslogs zugreifen.
Endpunkt für Betriebslogs :
```
operational-log-query-api.ORG_DOMAIN
```

Ersetzen Sie ORG_DOMAIN durch den Domainnamen der Organisation. Sie können diese Property mit dem Befehl gdcloud config list aufrufen. Der Domainname muss der Syntax org-name.zone.google.gdch.com entsprechen. Eine Organisation mit dem Namen org-1, in der zone1 Zone und in einer Testumgebung hat beispielsweise eine Domain wie org-1.zone1.google.gdch.test.

Die Log Query API bietet die folgenden drei Endpunktoptionen:

labels: Alle Labels für ein Projekt auflisten.
labels/labels/LABEL/values: Bestimmte Labelwerte für ein Projekt auflisten.
logs: Logs für ein bestimmtes Projekt auflisten.

Weitere Informationen finden Sie in der API-Dokumentation.

Abfrage senden

Senden Sie eine Abfrage an den API-Endpunkt der Log Query API mit HTTP- oder gRPC-Clients.

HTTP

Folgen Sie der Anleitung, um direkt mit einem HTTP-Client auf die API zuzugreifen. Sie können kubectl verwenden, um die Authentifizierung zu verwalten, oder die Authentifizierung selbst vornehmen.

Fragen Sie die Log Query API mit HTTP-Clients wie curl, wget oder einem von Ihnen erstellten und verwalteten HTTP-Client ab. Im folgenden Beispiel wird das Tool curl verwendet, um die API abzufragen. Sie können ein ähnliches Format für wget-Befehle verwenden:

Authentifizieren Sie die cURL-Anfrage:
1. Laden Sie die gdcloud CLI herunter und installieren Sie sie.
2. Legen Sie die gdcloud core/organization_console_url Property fest:
```
gdcloud config set core/organization_console_url https://GDC_URL
```
  Ersetzen Sie GDC_URL durch die URL einer Organisation in GDC.
3. Melden Sie sich mit dem konfigurierten Identitätsanbieter an:
```
gdcloud auth login
```
4. Authentifizieren Sie sich mit Ihrem Nutzernamen und Passwort und melden Sie sich an.
5. Exportieren Sie das Identitätstoken für das angegebene Konto in eine Umgebungsvariable:
```
export TOKEN="$($HOME/gdcloud auth print-identity-token --audiences=https://LOG_QUERY_API_ENDPOINT)"
```
  Ersetzen Sie LOG_QUERY_API_ENDPOINT durch den API-Endpunkt der Log Query API, von dem aus Sie Logs abfragen möchten, und die Domain, mit der Sie eine Verbindung herstellen möchten. Der Wert für das Flag audiences kann beispielsweise https://operational-log-query-api.org-1.zone1.google.gdch.test sein.
  
  Wenn die Anmeldung erfolgreich war, können Sie den Autorisierungsheader in Ihrer cURL-Anfrage über den Befehl gdcloud auth print-identity-token verwenden. Weitere Informationen finden Sie unter gdcloud auth print-identity-token.
Wenn Sie alle Labels für ein Projekt auflisten möchten, senden Sie die folgende Abfrage:
```
curl -H "Authorization: Bearer ${TOKEN}" \
https://LOG_QUERY_API_ENDPOINT/v1/projects/PROJECT_NAMESPACE/labels \
-H "Content-Type: application/json" -v
```
Ersetzen Sie Folgendes:
- LOG_QUERY_API_ENDPOINT: der API-Endpunkt der Log Query API, von dem aus Sie Logs abfragen möchten.
- PROJECT_NAMESPACE: Ihr Projektnamespace.
Wenn Sie bestimmte Labelwerte für ein Projekt auflisten möchten, senden Sie die folgende Abfrage:
```
curl -H "Authorization: Bearer ${TOKEN}" \
https://LOG_QUERY_API_ENDPOINT/v1/projects/PROJECT_NAMESPACE/labels/labels/LABEL/values \
-H "Content-Type: application/json" -v
```
Ersetzen Sie Folgendes:
- LOG_QUERY_API_ENDPOINT: der API-Endpunkt der Log Query API, von dem aus Sie Logs abfragen möchten.
- PROJECT_NAMESPACE: Ihr Projektnamespace.
- LABEL: das spezifische Label, dessen Wert Sie abfragen möchten.
Wenn Sie Logs für ein bestimmtes Projekt abfragen möchten, erstellen Sie eine logs_filter-Abfrage und fügen Sie sie in den Text der Anfrage ein:
```
curl -X GET -H "Authorization: Bearer ${TOKEN}" \
https://LOG_QUERY_API_ENDPOINT/v1/projects/PROJECT_NAMESPACE/logs \
-H "Content-Type: application/json" -d \
'{"logs_filter": {"labels_equal": {"LABEL": "LABEL_VALUE"}}}' -v
```
Ersetzen Sie Folgendes:
- LOG_QUERY_API_ENDPOINT: der API-Endpunkt der Log Query API, von dem aus Sie Logs abfragen möchten.
- PROJECT_NAMESPACE: Ihr Projektnamespace.
- LABEL: das spezifische Label, für das Sie Logs abfragen möchten.
- LABEL_VALUE: der Labelwert, für den Sie Logs abfragen möchten.
In der API-Dokumentation finden Sie alle Optionen zum Erstellen einer logs_filter-Abfrage.

gRPC

gRPC wird von vielen Programmiersprachen unterstützt und bietet eine effizientere Kommunikationsmethode als HTTP-Clients.

Wenn Sie Logs mit gRPC abfragen möchten, müssen die folgenden Voraussetzungen erfüllt sein:

Erstellen Sie Ihre eigene Clientbibliothek basierend auf den von Google bereitgestellten Protokollzwischenspeichern.
Implementieren Sie die Authentifizierung im Client.
Implementieren Sie Wiederholungen.

Informationen zu den Protokollzwischenspeichern finden Sie in der API-Dokumentation.

Im folgenden Beispiel wird gezeigt, wie Sie Logs über ein Go-Programm mit einem nicht authentifizierten gRPC-Client abfragen. Im Beispiel wird davon ausgegangen, dass Sie ein Go-Paket erstellt haben, das eine Bazel-Build-Datei zum Importieren von Codeabhängigkeiten enthält:

Speichern Sie den folgenden Code in einem Go-Programm mit dem Namen client.go:

package main
import (
        "context"
        "crypto/tls"
        "flag"
        "fmt"
        "google.golang.org/grpc/credentials"
        "google.golang.org/grpc/metadata"
        pb "<import path to generated log query api protos>/pkg/apis/public/logging/v1/proto"
        "google.golang.org/grpc"
)

var serverAddr = flag.String("server", "localhost:8080", "server address")

func main() {
        flag.Parse()
        tc := credentials.NewTLS(&tls.Config{InsecureSkipVerify: true})
        conn, err := grpc.Dial(*serverAddr, grpc.WithTransportCredentials(tc))

        if err != nil {
                panic(error.Error(fmt.Errorf("create client connection failed: %v", err)))
        }
        defer conn.Close()

        c := pb.NewLogsClient(conn)
        md := metadata.Pairs("clienttest", "test")
        ctx := metadata.NewOutgoingContext(context.Background(), md)

        err = listLabels(ctx, c, "project-foo")
        if err != nil {
                panic(error.Error(err))
        }

        if err := listLabelValues(ctx, c, "project-foo", "resource-bar"); err != nil {
                panic(error.Error(err))
        }

        if err := listLogs(ctx, c, "project-foo", &pb.ListLogsFilter{
                LabelsEqual:    map[string]string{"resource-bar": "resource-bar-value"},
                OrderAscending: true,
        }); err != nil {
                panic(error.Error(err))
        }
}

// List all labels for a project.

func listLabels(ctx context.Context, c pb.LogsClient, project string) error {
        lbr := &pb.ListLabelsRequest{
                Parent:   project,
                PageSize: 1000, // PageSize can be configured to limit the number of responses per page.
        }
        resp, err := c.ListLabels(ctx, lbr)
        if err != nil {
                return fmt.Errorf("list labels: %v", err)
        }
        fmt.Printf("%v", resp)
        return nil
}

// List specific label values for a project.

func listLabelValues(ctx context.Context, c pb.LogsClient, project string, label string) error {
        lbr := &pb.ListLabelValuesRequest{
                Parent:   project,
                Label:    label,
                PageSize: 1000, // PageSize can be configured to limit the number of responses per page.
        }
        resp, err := c.ListLabelValues(ctx, lbr)
        if err != nil {
                return fmt.Errorf("list label values: %v", err)
        }
        fmt.Printf("%v", resp)
        return nil
}

// List logs for a specific project.

func listLogs(ctx context.Context, c pb.LogsClient, project string, lf *pb.ListLogsFilter) error {
        lbr := &pb.ListLogsRequest{
                Parent:     project,
                LogsFilter: lf,
                PageSize:   5, // PageSize can be configured to limit the number of responses per page.
        }
        resp, err := c.ListLogs(ctx, lbr)
        if err != nil {
                return fmt.Errorf("list logs: %v", err)
        }
        fmt.Printf("logs: %v", resp)
        return nil
}

Führen Sie das Go-Programm aus:
```
go run PATH_TO_API/client.go -server=LOG_QUERY_API_ENDPOINT:443
```
Ersetzen Sie Folgendes:
- PATH_TO_API: der Pfad zur API-Datei.
- LOG_QUERY_API_ENDPOINT: der API-Endpunkt der Log Query API, von dem aus Sie Logs abfragen möchten.
Wenn das Server-Flag nicht angegeben ist, wird die Standardanfrage an localhost gesendet.

Beispielabfragen und -labels

Im Folgenden finden Sie einige der Standardlabels, mit denen Sie Logs abfragen können:

cluster: der Name des Clusters.
namespace: Ihr Projektnamespace.
node: der Knotenname.
pod: der Pod-Name.
container: der Containername.

In den folgenden Codebeispielen wird die Verwendung von Labels und Werten zum Abfragen verschiedener Logs veranschaulicht:

Serverlogs auswählen:

{cluster="admin", namespace="kube-system", resources="k8s_container", container="kube-apiserver"}

Cluster-Audit-Logs auswählen:

{cluster="admin", resources="k8s_audit"}

Logs abfragen und aufrufen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hinweis

Logs abfragen und filtern

Grafana-Log-Panel

Grafana-Endpunkt ermitteln

Logs auf der Grafana-Benutzeroberfläche ansehen

Zeitraum für Logs auswählen

Log Query API

API-Endpunkt der Log Query API ermitteln

Abfrage senden

HTTP

gRPC

Beispielabfragen und -labels

Logs abfragen und aufrufen