Diese Seite wurde von der Cloud Translation API übersetzt.

Logs abfragen und aufrufen

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

Nachdem Sie Logs von Ihren bereitgestellten Arbeitslasten und Diensten in Google Distributed Cloud (GDC) Air-Gapped erfasst haben, können Sie mit der Analyse beginnen. Um Logs zu analysieren, können Sie sie in informativen Grafana-Panels visualisieren und filtern oder direkt über die Log Query API auf sie zugreifen. Für den programmatischen Zugriff sind HTTP- oder gRPC-Aufrufe möglich.

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

Grafana-Panels: Im Log-Panel Ihrer Grafana-Instanz können Sie sich einen Überblick über den Aktivitätsverlauf Ihres Projekts verschaffen. In diesem Bereich können Sie bestimmte Logs abfragen und eingrenzen. So erhalten Sie detaillierte Daten, die auf Ihre Anforderungen zugeschnitten sind. Grafana bietet eine benutzerfreundliche Oberfläche zum Filtern und Analysieren Ihrer Arbeitslastdaten sowie zum Erstellen benutzerdefinierter Dashboards und Steuerfelder 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. Folgen Sie dazu den Standardmethoden für den API-Zugriff.

Hinweise

Bitten Sie Ihren IAM-Administrator der Organisation oder des Projekts, Ihnen eine der vordefinierten Rollen „Grafana Viewer“ für die Organisation oder das Projekt zuzuweisen, damit Sie die Berechtigungen erhalten, die Sie zum Abfragen und Visualisieren von Logs in 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 Projekt-Namespace 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 den Arbeitslasten Ihres Projekts zu filtern:

Grafana-Logbereich

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

Grafana-Endpunkt identifizieren

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 Projekt-Namespace.

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

Logs in der Grafana-Benutzeroberfläche ansehen

Logs in der Grafana-Benutzeroberfläche abfragen:

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.

Eine neue Seite mit Ihrem Grafana-Endpunkt wird geöffnet und die Benutzeroberfläche wird angezeigt.
Klicken Sie in der Benutzeroberfläche im Navigationsmenü auf Explore Explore, um die Seite Explore zu öffnen.
Wählen Sie im Menü in der Leiste Untersuchen eine Datenquelle aus, um Protokolle abzurufen. Das hängt von Ihrem Universumstyp ab:
- Universen mit einer Zone: Wählen Sie eine der folgenden Datenquellen aus, um Protokolldaten aus der einzelnen Zone Ihres Universums aufzurufen:
  - 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 Protokolldaten aus einer beliebigen Zone Ihres Universums aufzurufen, unabhängig davon, in welcher Zone Sie angemeldet sind:
  - Betriebslogs ZONE_NAME: Hier werden Betriebslogs aus einer bestimmten Zone angezeigt.
  - Audit-Logs ZONE_NAME: Audit-Logs aus einer bestimmten Zone anzeigen.
  Wenn Sie außerdem zonenübergreifende Datenvisualisierungen in einem einzigen Dashboard erstellen und Ihrer Abfrage mehrere Zonen hinzufügen möchten, wählen Sie Gemischt als Datenquelle aus.
  
  Hinweis :Audit-Logs sind nur für Plattformadministratoren verfügbar, auch wenn sie keine Audit-Logging-Ziele erstellen oder konfigurieren können. Anwendungsbediener können nur auf Betriebslogs zugreifen.
Geben Sie eine Abfrage ein, um im Logbereich mit LogQL-Ausdrücken (Log Query Language) nach Logs zu suchen. Sie können diesen Schritt auf eine der beiden folgenden Arten ausführen:
- 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 Umschalt + Eingabetaste, 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 Protokolle im Nur-Text- oder CSV-Format herunterzuladen. Sie können auch einen Zeitraum für Ihre Protokolle 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, auf 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ü Zeitachse.
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.
- Sie können auch benutzerdefinierte absolute Zeiträume festlegen, indem Sie bestimmte Datumsangaben 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 Zeitbereichssteuerelemente zu ändern.

Zeiteinstellungen werden für jedes Dashboard einzeln 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 mit der Log Query API auf Ihre Logs zugreifen.

Log Query API-Endpunkt ermitteln

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

Audit-Log-Endpunkt:
```
audit-log-query-api.ORG_DOMAIN
```
Hinweis :Audit-Logs sind nur für Plattformadministratoren verfügbar, auch wenn sie keine Audit-Logging-Ziele erstellen oder konfigurieren können. Anwendung Bediener 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 dieses Attribut 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 Zone zone1 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: Listet alle Labels für ein Projekt auf.
labels/labels/LABEL/values: Listet bestimmte Labelwerte für ein Projekt auf.
logs: Listet Logs für ein bestimmtes Projekt auf.

Weitere Informationen finden Sie in der API-Dokumentation.

Abfrage senden

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

HTTP

Folgen Sie der Anleitung zum direkten Zugriff auf die API mit einem HTTP-Client. Sie können die Authentifizierung von kubectl verwalten lassen oder sie selbst verarbeiten.

Fragen Sie die Log Query API mit HTTP-Clients wie curl, wget oder einem HTTP-Client ab, den Sie erstellen und verwalten. 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 gcloud CLI herunter und installieren Sie sie.
2. Legen Sie das core/organization_console_url-Attribut von gcloud fest:
```
gdcloud config set core/organization_console_url https://GDC_URL
```
  Ersetzen Sie GDC_URL durch die URL einer Organisation in GDC.
3. Mit dem konfigurierten Identitätsanbieter anmelden:
```
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 Log Query API-Endpunkt, von dem aus Sie Logs abfragen möchten, und die Domain, mit der Sie eine Verbindung herstellen möchten. Der Wert für das audiences-Flag kann beispielsweise https://operational-log-query-api.org-1.zone1.google.gdch.test sein.
  
  Wenn die Anmeldung erfolgreich ist, können Sie den Autorisierungsheader in Ihrer cURL-Anfrage über den Befehl gdcloud auth print-identity-token verwenden. Weitere Informationen finden Sie unter gcloud auth print-identity-token.
Wenn Sie alle Labels für ein Projekt auflisten möchten, senden Sie die folgende Anfrage:
```
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 Log Query API-Endpunkt, von dem aus Sie Logs abfragen möchten.
- PROJECT_NAMESPACE: Ihr Projekt-Namespace.
Wenn Sie bestimmte Labelwerte für ein Projekt auflisten möchten, senden Sie die folgende Anfrage:
```
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 Log Query API-Endpunkt, von dem aus Sie Logs abfragen möchten.
- PROJECT_NAMESPACE: Ihr Projekt-Namespace.
- 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 Anfragetext 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 Log Query API-Endpunkt, von dem aus Sie Logs abfragen möchten.
- PROJECT_NAMESPACE: Ihr Projekt-Namespace.
- LABEL: Das spezifische Label, für das Sie Logs abfragen möchten.
- LABEL_VALUE: Der Labelwert, für den Sie Logs abfragen möchten.
Alle Optionen zum Erstellen einer logs_filter-Abfrage finden Sie in der API-Dokumentation.

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 auf Grundlage der von Google bereitgestellten Protokollzwischenspeicher.
Implementieren Sie die Authentifizierung im Client.
Wiederholungsversuche implementieren

Informationen zu den Protocol Buffers finden Sie in der API-Dokumentation.

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

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 Log Query API-Endpunkt, von dem aus Sie Logs abfragen möchten.
Wenn das Serverflag 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 ist der Name des Clusters.
namespace: Ihr Projekt-Namespace.
node: der Knotenname.
pod: der Pod-Name.
container: Der Containername.

In den folgenden Codebeispielen sehen Sie, wie Sie mit Labels und Werten verschiedene Logs abfragen:

Wählen Sie Serverprotokolle aus:

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

Wählen Sie Cluster-Audit-Logs aus:

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