Logs schreiben und aufrufen

Auf dieser Seite werden die Logs, die bei der Verwendung von Cloud Run for Anthos verfügbar sind, und das Aufrufen und Schreiben der Logs erläutert.

Cloud Run for Anthos bietet zwei Arten von Logs:

  • Anfragelogs: Logs von Anfragen, die an Dienste von Cloud Run for Anthos gesendet werden. Diese Logs werden automatisch erstellt.
  • Containerlogs: Logs, die von den Containerinstanzen ausgegeben werden, üblicherweise aus Ihrem eigenen Code, und in unterstützte Speicherorte geschrieben werden, wie unter Containerlogs schreiben erläutert.

Logs aktivieren

Für Google Cloud-Logs werden automatisch an Cloud Logging gesendet. Für GKE on VMware müssen Sie zuerst Logs aktivieren.

Logs ansehen

Sie können Logs für Ihren Dienst auf verschiedene Weise aufrufen:

  • Verwenden Sie die Seite „Cloud Run for Anthos“ in der Google Cloud Console
  • Verwenden Sie den Cloud Logging-Log-Explorer in der Google Cloud Console.

Beide Anzeigemethoden untersuchen dieselben Logs, die in Cloud Logging gespeichert sind. Der Log-Explorer von Cloud Logging bietet jedoch weitere Details und Filterfunktionen.

Logs in Cloud Run for Anthos ansehen

So rufen Sie Logs auf der Seite „Cloud Run for Anthos“ auf:

  1. Zu Cloud Run for Anthos

  2. Klicken Sie in der angezeigten Liste auf den gewünschten Dienst.

  3. Klicken Sie auf den Tab LOGS, um die Anfrage- und Containerlogs für alle Überarbeitungen des Dienstes abzurufen. Sie können nach Logschweregrad filtern.

Logs in Cloud Logging ansehen

So zeigen Sie Ihre Cloud Run for Anthos-Logs im Log-Explorer von Cloud Logging an:

  1. Rufen Sie in der Google Cloud Console den Log-Explorer auf.

  2. Wählen Sie oben auf der Seite ein vorhandenes Google Cloud-Projekt aus oder erstellen Sie ein neues Projekt.

  3. Wählen Sie in den Drop-down-Menüs die Ressource Kubernetes-Container aus.

Weitere Informationen finden Sie unter Log-Explorer verwenden.

Logs in Cloud Code ansehen

Informationen zum Aufrufen Ihrer Logs in Cloud Code finden Sie in den Leitfäden zu IntelliJ und Visual Studio Code.

Logs programmatisch lesen

Wenn Sie die Logs programmatisch lesen möchten, können Sie eine der folgenden Methoden verwenden:

Containerlogs schreiben

Wenn Sie Logs von Ihrem Dienst aus schreiben, werden sie von Cloud Logging automatisch erfasst, sofern die Logs an einen der folgenden Speicherorte geschrieben werden:

Die meisten Entwickler schreiben Logs über Standardausgabe und Standardfehler.

Die Containerlogs, die in diese unterstützten Speicherorte geschrieben werden, werden automatisch dem Cloud Run for Anthos-Dienst, der Cloud Run-Überarbeitung und dem Cloud Run-Speicherort zugeordnet.

Einfachen Text im Vergleich zu strukturiertem JSON in Logs verwenden

Wenn Sie Logs schreiben, können Sie einen einfachen Textstring oder eine einzelne Zeile mit serialisiertem JSON (auch als "strukturierte" Daten bezeichnet) senden. Diese wird von Cloud Logging erfasst und geparst und in jsonPayload eingefügt. Die einfache Textnachricht wird dagegen in textPayload eingefügt.

Strukturierte Logs schreiben

Das folgende Snippet zeigt, wie strukturierte Logeinträge geschrieben werden. Außerdem wird gezeigt, wie Lognachrichten mit dem entsprechenden Anfragelog in Beziehung gesetzt werden.

Node.js

run/logging-manual/app.js 

// Uncomment and populate this variable in your code:
// const project = 'The project ID of your function or Cloud Run service';

// Build structured log messages as an object.
const globalLogFields = {};

// Add log correlation to nest all log messages beneath request log in Log Viewer.
// (This only works for HTTP-based invocations where `req` is defined.)
if (typeof req !== 'undefined') {
  const traceHeader = req.header('X-Cloud-Trace-Context');
  if (traceHeader && project) {
    const [trace] = traceHeader.split('/');
    globalLogFields['logging.googleapis.com/trace'] =
      `projects/${project}/traces/${trace}`;
  }
}

// Complete a structured log entry.
const entry = Object.assign(
  {
    severity: 'NOTICE',
    message: 'This is the default display field.',
    // Log viewer accesses 'component' as 'jsonPayload.component'.
    component: 'arbitrary-property',
  },
  globalLogFields
);

// Serialize to a JSON string and output.
console.log(JSON.stringify(entry));

Python

run/logging-manual/main.py 
# Uncomment and populate this variable in your code:
# PROJECT = 'The project ID of your Cloud Run service';

# Build structured log messages as an object.
global_log_fields = {}

# Add log correlation to nest all log messages.
# This is only relevant in HTTP-based contexts, and is ignored elsewhere.
# (In particular, non-HTTP-based Cloud Functions.)
request_is_defined = "request" in globals() or "request" in locals()
if request_is_defined and request:
    trace_header = request.headers.get("X-Cloud-Trace-Context")

    if trace_header and PROJECT:
        trace = trace_header.split("/")
        global_log_fields[
            "logging.googleapis.com/trace"
        ] = f"projects/{PROJECT}/traces/{trace[0]}"

# Complete a structured log entry.
entry = dict(
    severity="NOTICE",
    message="This is the default display field.",
    # Log viewer accesses 'component' as jsonPayload.component'.
    component="arbitrary-property",
    **global_log_fields,
)

print(json.dumps(entry))

Einfach loslegen (Go)

Die Struktur für jeden Logeintrag wird vom Typ Entry bereitgestellt:

run/logging-manual/main.go 

// Entry defines a log entry.
type Entry struct {
	Message  string `json:"message"`
	Severity string `json:"severity,omitempty"`
	Trace    string `json:"logging.googleapis.com/trace,omitempty"`

	// Logs Explorer allows filtering and display of this as `jsonPayload.component`.
	Component string `json:"component,omitempty"`
}

// String renders an entry structure to the JSON format expected by Cloud Logging.
func (e Entry) String() string {
	if e.Severity == "" {
		e.Severity = "INFO"
	}
	out, err := json.Marshal(e)
	if err != nil {
		log.Printf("json.Marshal: %v", err)
	}
	return string(out)
}

Wenn eine Eintragsstruktur in Logs erfasst wird, wird die Methode String aufgerufen, um sie in das von Cloud Logging erwartete JSON-Format umzuwandeln:

run/logging-manual/main.go 

func init() {
	// Disable log prefixes such as the default timestamp.
	// Prefix text prevents the message from being parsed as JSON.
	// A timestamp is added when shipping logs to Cloud Logging.
	log.SetFlags(0)
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
	// Uncomment and populate this variable in your code:
	// projectID = "The project ID of your Cloud Run service"

	// Derive the traceID associated with the current request.
	var trace string
	if projectID != "" {
		traceHeader := r.Header.Get("X-Cloud-Trace-Context")
		traceParts := strings.Split(traceHeader, "/")
		if len(traceParts) > 0 && len(traceParts[0]) > 0 {
			trace = fmt.Sprintf("projects/%s/traces/%s", projectID, traceParts[0])
		}
	}

	log.Println(Entry{
		Severity:  "NOTICE",
		Message:   "This is the default display field.",
		Component: "arbitrary-property",
		Trace:     trace,
	})

	fmt.Fprintln(w, "Hello Logger!")
}

Java

Aktivieren Sie das JSON-Logging mit Logback und SLF4J, indem Sie den Logstash-JSON-Encoder in Ihrer logback.xml-Konfiguration aktivieren.

run/logging-manual/src/main/java/com/example/cloudrun/App.java 
// Build structured log messages as an object.
Object globalLogFields = null;

// Add log correlation to nest all log messages beneath request log in Log Viewer.
// TODO(developer): delete this code if you're creating a Cloud
//                  Function and it is *NOT* triggered by HTTP.
String traceHeader = req.headers("x-cloud-trace-context");
if (traceHeader != null && project != null) {
  String trace = traceHeader.split("/")[0];
  globalLogFields =
      kv(
          "logging.googleapis.com/trace",
          String.format("projects/%s/traces/%s", project, trace));
}
// -- End log correlation code --

// Create a structured log entry using key value pairs.
logger.error(
    "This is the default display field.",
    kv("component", "arbitrary-property"),
    kv("severity", "NOTICE"),
    globalLogFields);
run/logging-manual/src/main/resources/logback.xml 
<configuration>
  <appender name="jsonConsoleAppender" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
      <!-- Ignore default logging fields -->
      <fieldNames>
        <timestamp>[ignore]</timestamp>
        <version>[ignore]</version>
        <logger>[ignore]</logger>
        <thread>[ignore]</thread>
        <level>[ignore]</level>
        <levelValue>[ignore]</levelValue>
      </fieldNames>
    </encoder>
  </appender>
  <root level="INFO">
    <appender-ref ref="jsonConsoleAppender"/>
  </root>
</configuration>

Spezielle JSON-Felder in Nachrichten

Wenn Sie ein strukturiertes Log als JSON-Wörterbuch erstellen, werden bestimmte Felder aus jsonPayload entfernt und in das entsprechende Feld im erstellten LogEntry geschrieben, wie in der Dokumentation für spezielle Felder erläutert.

Wenn Ihre JSON-Datei beispielsweise das Attribut severity enthält, wird es aus jsonPayload entfernt und stattdessen als severity des Logeintrags angezeigt. Das Attribut message wird als Hauptanzeigentext des Logeintrags verwendet, sofern vorhanden. Weitere Informationen zu speziellen Attributen erhalten Sie unten im Abschnitt Logging-Ressource.

Containerlogs mit einem Anfragelog korrelieren

Im Log-Explorer werden Logs, die mit demselben trace verknüpft sind, im hierarchischen Format angezeigt. Wenn Sie auf das Dreiecksymbol links neben dem Anfragelogeintrag klicken, werden die mit dieser Anfrage verbundenen Containerlogs unter dem Anfragelog verschachtelt angezeigt.

Containerlogs werden nicht automatisch mit Anfragelogs korreliert, es sei denn, Sie verwenden eine Cloud Logging-Clientbibliothek. Um Containerlogs mit Anforderungslogs zu korrelieren, ohne eine Clientbibliothek zu verwenden, können Sie eine strukturierte JSON-Logzeile verwenden, die ein logging.googleapis.com/trace-Feld mit der aus dem X-Cloud-Trace-Context-Header extrahierten Trace-ID enthält, wie im obigen Beispiel für strukturiertes Logging gezeigt.

Nutzung der Anfragelogressource steuern

Anfragelogs werden automatisch erstellt. Auch wenn Sie die Menge der Anforderungslogs nicht direkt über Cloud Run for Anthos steuern können, können Sie das Feature Logausschlüsse von Cloud Logging verwenden.

Ein Hinweis zu Logging-Agents

Wenn Sie Cloud Logging mit bestimmten Google Cloud-Produkten wie Compute Engine verwendet haben, haben Sie möglicherweise Logging-Agents von Cloud Logging verwendet. Cloud Run for Anthos verwendet keine Logging-Agents, da es integrierte Unterstützung für die Logerfassung bietet.

Logging-Ressource

Wenn Sie im Log-Explorer auf einen Logeintrag klicken, wird ein Logeintrag im JSON-Format geöffnet, in dem Sie die gewünschten Details aufrufen können.

Alle Felder in einem Logeintrag, wie Zeitstempel, Schweregrad und httpRequest, sind Standardfelder und werden in der Dokumentation für einen Logeintrag beschrieben.

Es gibt jedoch einige spezifische Labels oder Ressourcenlabels für Cloud Run for Anthos. Diese sind hier mit Beispielinhalten aufgeführt:

{
 httpRequest: {…}
 insertId:  "5c82b3d1000ece0000000000"
 labels: {
  instanceId:  "00bf4bf00000fb59c906a00000c9e29c2c4e06dce91500000000056008d2b6460f163c0057b97b2345f2725fb2423ee5f0bafd36df887fdb1122371563cf1ff453717282afe000001"
 }
 logName:  "projects/my-project/logs/anthos/run/.googleapis.com%2Frequests"
 receiveTimestamp:  "2019-03-08T18:26:25.981686167Z"
 resource: {
  labels: {
   configuration_name:  "myservice"
   location:  "us-central1"
   project_id:  "my-project"
   revision_name:  "myservice-00002"
   service_name:  "myservice"
  }
  type:  "cloud_run_revision"
 }
 severity:  "INFO"
 timestamp:  "2019-03-08T18:26:25.970397Z"
}
Feld Werte und Hinweise
instanceId Die Containerinstanz, die die Anfrage verarbeitet hat.
logName Gibt das Log an, z. B. Anfragelog, Standardfehler, Standardausgabe usw.
configuration_name Die Konfigurationsressource, die die Überarbeitung erstellt hat, mit der die Anfrage bereitgestellt wurde.
location Der GCP-Speicherort des Dienstes.
project_id Das Projekt, in dem der Dienst bereitgestellt wird.
revision_name Die Überarbeitung, die die Anfrage bereitgestellt hat.
service_name Der Dienst, der die Anfrage bereitgestellt hat.
type cloud_run_revision. Der Ressourcentyp von Cloud Run for Anthos.