Serverloses Monitoring der Webleistung mithilfe von Cloud Functions

In dieser Anleitung wird beschrieben, wie Sie mithilfe von serverlosen Google Cloud-Technologien eine Anwendung für das Monitoring der Webleistung erstellen können.

Die Leistung spielt eine wichtige Rolle für den Erfolg einer Webanwendung. Wenn Ihre Website eine schlechte Leistung aufweist, kann es zu weniger Anmeldungen und einer geringeren Nutzerbindung kommen, was sich wahrscheinlich auf Ihre Geschäftsziele auswirkt. Die Leistung sollte beim Entwerfen, Erstellen und Testen Ihrer Webanwendung ein wichtiges Erfolgskriterium sein.

Die Seitenleistung kann sich jedoch im Laufe der Zeit ändern, wenn sich Ihre Anwendung weiterentwickelt. Entwickler können Images und Skripte hinzufügen oder aktualisieren. Es kann sich aber auch die zugrunde liegende Infrastruktur der Anwendungsbereitstellung selbst ändern. Daher ist es wichtig, die Seitenleistung regelmäßig zu überwachen. In der Regel speichern Sie die Leistungsmesswerte, um die Verlaufsanalyse zu aktivieren. Es ist auch üblich, Warnmeldungen zu generieren, wenn die Seitenleistung unter einen bestimmten Grenzwert fällt.

Ziele

Erstellen Sie eine Cloud Functions-Funktion, die eine monitorlose Chrome-Version verwendet, um Leistungsmesswerte für Webseiten zu erfassen.
Speichern Sie die Messwerte im Cloud-Speicher.
Erstellen Sie eine weitere Cloud-Funktion, die durch das vorherige Erstellen in Cloud Storage ausgelöst wird, um die Seitenmesswerte zu analysieren.
Speichern Sie die Analyseergebnisse in Firestore.
Erstellen Sie eine weitere Cloud Functions-Funktion, die durch das Erstellen in Firestore ausgelöst wird, um bei einer schlechten Seitenleistung eine Warnung in Pub/Sub zu veröffentlichen.
Erstellen Sie einen Cloud Scheduler-Job, um regelmäßig die erste Cloud Functions-Funktion auszulösen.
Überprüfen Sie die Ausgaben auf Erfolg und auf Fehlerszenarien.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, darunter:

Cloud Functions
Cloud Scheduler
Cloud Storage
Firestore
Pub/Sub
Container Registry
Cloud Build

Sie können mithilfe des Preisrechners eine Kostenschätzung für Ihre voraussichtliche Nutzung erstellen.

Vorbereitung

Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie 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.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Cloud Functions, Cloud Scheduler, Pub/Sub, and Cloud Build APIs aktivieren.

Aktivieren Sie die APIs

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Cloud Functions, Cloud Scheduler, Pub/Sub, and Cloud Build APIs aktivieren.

Aktivieren Sie die APIs

Architektur

Überwachungsvorgänge der Webleistung sind in der Regel zustandslos und von kurzer Dauer. Sie sind auch häufig ereignisgesteuert und werden entweder nach einem Zeitplan ausgeführt oder werden als Teil eines anderen Prozesses ausgelöst, z. B. einer automatisierten Testpipeline. Diese Eigenschaften machen serverlose Architekturen zu einer attraktiven Wahl für die Implementierung von Webanalyseanwendungen.

In dieser Anleitung verwenden Sie verschiedene Teile des serverlosen Stacks von Google Cloud, einschließlich Cloud Functions, Firestore, Cloud Scheduler und Pub/Sub. Sie müssen für keinen dieser Dienste die Infrastruktur verwalten und bezahlen nur für das, was Sie nutzen. Der Kern der Anwendung wird mithilfe von Cloud Functions-Funktionen implementiert, die eine ereignisgesteuerte und skalierbare Umgebung für die Ausführung ohne Server bieten. Mithilfe von Cloud Functions-Funktionen können Sie Anwendungen mit unabhängigen, lose gekoppelten Logikelementen erstellen und verbinden.

Das folgende Diagramm zeigt die Architektur der serverlosen Lösung, die Sie in dieser Anleitung erstellen.

Architektur der serverlosen Webanalyselösung

Umgebung vorbereiten

Bevor Sie die serverlose Umgebung erstellen, rufen Sie den Code von GitHub ab, legen Variablen fest und bereiten Ressourcen vor, die Sie später zum Analysieren und Speichern benötigen.

Code abrufen und Umgebungsvariablen setzen

Öffnen Sie Cloud Shell in der Google Cloud Console.

Cloud Shell öffnen
Klonen Sie das Repository, das den Code für die in dieser Anleitung verwendeten Cloud Functions-Funktionen enthält:
```
git clone https://github.com/GoogleCloudPlatform/solutions-serverless-web-monitoring.git
```

Wechseln Sie in das Funktionsverzeichnis:

cd solutions-serverless-web-monitoring/functions

Legen Sie die aktuelle Projekt-ID und die Projektnummer als Shell-Variablen fest:

export PROJECT=$DEVSHELL_PROJECT_ID
export PROJECT_NUM=$(gcloud projects list \
    --filter="$PROJECT" \
    --format="value(PROJECT_NUMBER)")

Legen Sie die Standardbereitstellungsregion für Cloud Functions fest. Im folgenden Beispiel wird die Region auf us-east1 festgelegt. Sie können sie jedoch in jede beliebige Region ändern, in der Cloud Functions verfügbar ist.
```
export REGION=us-east1
gcloud config set functions/region $REGION
```

Cloud Storage-Buckets erstellen

In diesem Abschnitt erstellen Sie einen Cloud Storage-Bucket, um die gesammelten Seitenleistungsdaten zu speichern. Sie können einen beliebigen Speicherort oder eine beliebige Speicherklasse auswählen. Es empfiehlt sich jedoch, Buckets am selben Speicherort wie die Cloud Functions-Funktionen zu erstellen, die die Buckets verwenden.

Exportieren Sie in Cloud-Shell eine Shell-Variable für die Namen der Cloud Storage-Buckets, in denen die Messwerte gespeichert werden. Da Bucket-Namen global eindeutig sein müssen, verwendet der folgende Befehl Ihre Google Cloud-Projektnummer als Suffix für den Bucket-Namen.
```
export METRICS_BUCKET=page-metrics-$PROJECT_NUM
```
Verwenden Sie das gsutil-Tool, um die Buckets zu erstellen.
```
gsutil mb -l $REGION gs://$METRICS_BUCKET
```
Aktualisieren Sie die env-vars.yaml-Datei mit den Bucket-Namen. Diese Datei enthält Umgebungsvariablen, die Sie später an die Cloud Functions-Funktionen übergeben.
```
sed -i "s/\[YOUR_METRICS_BUCKET\]/$METRICS_BUCKET/" env-vars.yaml
```

Firestore-Sammlung erstellen

In einem späteren Abschnitt analysieren Sie die Messwerte zur Seitenleistung. In diesem Abschnitt erstellen Sie eine Firestore-Sammlung, um die Ergebnisse jeder Analyse zu speichern.

Rufen Sie in der Google Cloud Console die Seite Firestore auf.

Zur Seite "Firestore"
Führen Sie die folgenden Schritte aus, wenn Sie noch nie eine Firestore-Datenbank erstellt haben:
1. Klicken Sie auf Nativen Modus auswählen, um Firestore zu aktivieren.
2. Wählen Sie einen regionalen Standort in der Nähe der Region, in der Ihre Cloud Functions-Funktionen ausgeführt werden, aus.
3. Klicken Sie auf Datenbank erstellen.
Es dauert einige Augenblicke, bis die Konfiguration abgeschlossen ist.
Klicken Sie auf Sammlung starten und legen Sie die Sammlungs-ID auf page-metrics fest.
Klicken Sie auf Speichern.

Pub/Sub-Thema und -Abo erstellen

In der Regel möchten Sie interessierte Systeme und Parteien benachrichtigen, wenn bei der Analyse eine Seite eine schlechte Leistung erbringt. In diesem Abschnitt erstellen Sie Pub/Sub-Themen, die Benachrichtigungen enthalten, die eine schlechte Leistung beschreiben.

Erstellen Sie in Cloud Shell ein Pub/Sub-Thema mit dem Namen performance-alerts:
```
gcloud pubsub topics create performance-alerts
```
Erstellen Sie ein Abo für das Thema. Das Abo sorgt dafür, dass Warnmeldungen für das Thema veröffentlicht werden.
```
gcloud pubsub subscriptions create performance-alerts-sub \
    --topic performance-alerts
```

Seitenleistungsmesswerte erfassen

Viele Websites verwenden JavaScript, um Seiteninhalte dynamisch zu rendern. Dies erschwert die Leistungsanalyse, da der Client einen Browser emulieren muss, um die Website vollständig zu laden. Die Node.js -Laufzeit für Cloud Functions unterstützt die monitorlose Chrome-Version, um die Funktionalität eines vollständigen Webbrowsers in einer serverlosen Umgebung zu erhalten.

Puppeteer ist eine Node.js-Bibliothek, die vom Chrome DevTools-Team erstellt wurde und eine API auf übergeordneter Ebene zur Steuerung der monitorlosen Chrome-Version bietet. Standardmäßig installiert Puppeteer neben der Bibliothek eine aktuelle Version des Browsers. Sie können Puppeteer als Abhängigkeit zur Cloud Functions-Funktion hinzufügen, um so ganz einfach die monitorlose Chrome-Version in der Funktion zu verwenden.

Das Messen und Analysieren der Websiteleistung ist ein großer und komplexer Bereich. Der Einfachheit halber verwenden Sie in dieser Anleitung Puppeteer, um einige Messwerte zur Seitenleistung der obersten Ebene zu erfassen. Sie können jedoch auch Puppeteer und das Chrome DevTools Protocol (CDP) verwenden, um detailliertere Informationen zu erfassen, z. B. Zeitachsen-Traces. Sie können Ihre Endnutzererfahrungswerte auch besser darstellen, wenn Sie eine Netzwerküberlastung emulieren und eine CPU-Drosselung machen. Auf der Chrome-Website für Webentwickler finden Sie eine gute Einführung in die Analyse der Webseitenleistung.

Beachten Sie, dass viele Faktoren die Ladezeiten von Webseiten beeinflussen, dazu gehören auch die Leistungsanforderungen des Clients. Es ist wichtig, Baselines mithilfe der CPU- und RAM-Konfigurationen der Cloud Functions-Funktion zu erstellen.

Das folgende Snippet aus der Datei tracer/index.js zeigt, wie Sie mit Puppeteer die Webseite laden:

// launch Puppeteer and start a Chrome DevTools Protocol (CDP) session
// with performance tracking enabled.
browser = await puppeteer.launch({
  headless: true,
  args: ['--no-sandbox']
});
const page = await browser.newPage();
const client = await page.target().createCDPSession();
await client.send('Performance.enable');

// browse to the page, capture and write the performance metrics
console.log('Fetching url: '+url.href);
await page.goto(url.href, {
  'waitUntil' : 'networkidle0'
});
const performanceMetrics = await client.send('Performance.getMetrics');
options = createUploadOptions('application/json', page.url());
await writeToGcs(metricsBucket, filename, JSON.stringify(performanceMetrics), options);

Stellen Sie in Cloud Shell die Cloud Functions-Funktion trace bereit:
```
gcloud functions deploy trace \
    --trigger-http \
    --runtime nodejs10 \
    --memory 1GB \
    --source tracer \
    --env-vars-file env-vars.yaml \
    --quiet
```
Die Bereitstellung der Cloud Functions-Funktion kann einige Minuten dauern.

Die Bereitstellungsparameter geben an, dass die Funktion einen HTTP-Trigger haben und die Laufzeit von Node.js 10 verwenden sowie 1 GB Speicher haben soll. Diese Speicherkapazität ist erforderlich, um die monitorlose Chrome-Version ausführen zu können. Umgebungsvariablen werden mithilfe der Datei env-vars.yaml an die Funktion übergeben

Standardmäßig erlauben HTTP-ausgelöste Cloud Functions-Funktionen nicht authentifizierte Aufrufe. Daher müssen Sie die Trace-Funktion sichern.

Entfernen Sie die IAM-Rolle cloudfunctions.invoker für allUsers:

gcloud beta functions remove-iam-policy-binding trace \
    --member allUsers \
    --role roles/cloudfunctions.invoker

Messwerte analysieren

Übungen zur Überwachung der Webperformance dienen häufig dazu, die Leistung anhand einiger definierter Benchmarks zu prüfen. Wenn ein bestimmter Messwert einen erwarteten Grenzwert überschreitet, kann dies auf ein Problem mit einer neueren Softwareversion oder auf ein Problem mit der zugrunde liegenden Infrastruktur hinweisen.

In diesem Abschnitt erstellen Sie eine Cloud Functions-Funktion in Python, um die Seitenmesswerte zu parsen und die Ergebnisse in einer Firestore-Sammlung zu speichern. Die Funktion vergleicht den Messwert FirstMeaningfulPaint mit einem erwarteten Grenzwert und markiert das Analyseergebnis als problematisch, wenn der Grenzwert überschritten wird. FirstMeaningfulPaint ist ein nutzerbezogener Messwert, der ausführlich beschreibt, ab wann eine Seite nutzbar ist. Mithilfe eines Cloud Storage-Triggers wird die Analysefunktion immer dann ausgeführt, wenn eine neue Datei in den Bucket geschrieben wird, der die Messwerte enthält.

Das folgende Snippet aus der Datei analyzer/main.py zeigt die Funktionslogik:

def analyze(data, context):
  """Function entry point, triggered by creation of an object in a GCS bucket.

  The function reads the content of the triggering file, analyses its contents,
  and persists the results of the analysis to a new Firestore document.

  Args:
    data (dict): The trigger event payload.
    context (google.cloud.functions.Context): Metadata for the event.
  """
  page_metrics = get_gcs_file_contents(data)
  max_time_meaningful_paint = int(os.environ.get('MAX_TIME_MEANINGFUL_PAINT'))
  analysis_result = analyze_metrics(data, page_metrics,
                                    max_time_meaningful_paint)
  docref = persist(analysis_result, data['name'])
  logging.info('Created new Firestore document %s/%s describing analysis of %s',
               docref.parent.id, docref.id, analysis_result['input_file'])

Stellen Sie die Cloud Functions-Funktion analyze bereit:
```
gcloud functions deploy analyze \
    --trigger-resource gs://$METRICS_BUCKET \
    --trigger-event google.storage.object.finalize \
    --runtime python37 \
    --source analyzer \
    --env-vars-file env-vars.yaml
```
Die Funktion wird durch ein finalize-Ereignis im Messwert-Bucket ausgelöst, das jedes Mal gesendet wird, wenn ein Objekt im Bucket erstellt wird. Die Funktion verwendet die Python 3.7-Laufzeit.

Benachrichtigung bei Störungen

In der Regel möchten Sie Maßnahmen ergreifen, wenn die Messwertanalyse eine Seite mit schlechter Leistung meldet.

In diesem Abschnitt erstellen Sie eine Cloud Functions-Funktion zum Senden einer Nachricht an ein Pub/Sub-Thema, wenn die Seitenleistung nicht zufriedenstellend ist. Die Funktion wird jedes Mal ausgelöst, wenn in der Firestore-Sammlung ein Dokument erstellt wird. Interessenten können das Pub/Sub-Thema abonnieren und entsprechende Maßnahmen ergreifen. Eine Support-App könnte beispielsweise die Pub/Sub-Benachrichtigungen abonnieren und eine E-Mail senden, einen Support-Pager auslösen oder einen Bug melden.

Das folgende Snippet aus der Datei alerter/main.py zeigt die Funktionslogik:

def generate_alert(data, context):
  """Cloud Function entry point, triggered by a change to a Firestore document.

  If the triggering document indicates a Failed status, send the document to
  configured PubSub topic.

  Args:
    data (dict): The event payload.
    context (google.cloud.functions.Context): Metadata for the event.
  """
  doc_fields = data['value']['fields']
  status = doc_fields['status']['stringValue']
  if 'FAIL' in status:
    global publish_client
    if not publish_client:
      publish_client = pubsub.PublisherClient()

    logging.info('Sending alert in response to %s status in document %s',
                 status, context.resource)
    project = os.environ.get('GCP_PROJECT')
    topic = os.environ.get('ALERT_TOPIC')
    fqtn = 'projects/{}/topics/{}'.format(project, topic)
    msg = json.dumps(data['value']).encode('utf-8')
    publish_client.publish(fqtn, msg)

Achten Sie darauf, dass die Benachrichtigung nur gesendet wird, wenn das Statusfeld einen Fehler anzeigt.

Stellen Sie die Cloud Functions-Funktion alert bereit:

gcloud functions deploy alert \
    --trigger-event providers/cloud.firestore/eventTypes/document.create \
    --trigger-resource "projects/$PROJECT/databases/(default)/documents/page-metrics/{any}" \
    --runtime python37 \
    --source alerter \
    --env-vars-file env-vars.yaml \
    --entry-point generate_alert

Die Funktion wird durch ein document.create-Ereignis in der Firestore-Sammlung page-metrics ausgelöst. Das Suffix {any} ist ein Platzhalter, der angibt, dass die Funktion jedes Mal ausgelöst werden soll, wenn ein Dokument in der Sammlung erstellt wird.

Analyse planen

Es wird empfohlen, regelmäßig die Seitenleistung zu überwachen. Beispielsweise könnten Sie jede Stunde, jeden Tag oder jede Woche eine bestimmte Seite analysieren. In diesem Abschnitt erstellen Sie einen Cloud Scheduler-Job, um die Analysepipeline regelmäßig auszuführen, indem Sie die Funktion trace auslösen.

Der Cloud Scheduler-Job wird mit einem Dienstkonto ausgeführt, dem die erforderliche IAM-Rolle cloudfunctions.invoker für die Funktion trace zugewiesen wurde.

Manchmal reagieren Webseiten nicht richtig oder Anfragen verursachen eine Zeitüberschreitung. Daher sind Wiederholungsversuche bei Webanalyseanwendungen unvermeidbar. Daher ist es wichtig, in Ihrer App eine Wiederholungslogik zu haben. Cloud Functions unterstützt Wiederholungsversuche für Hintergrundfunktionen.

Wiederholungsversuche sind für HTTP-ausgelöste Cloud Functions-Funktionen nicht verfügbar. Daher können Sie Cloud Functions nicht verwenden, um die Funktion trace noch einmal auszuführen. Cloud Scheduler unterstützt jedoch Wiederholungsversuche. Weitere Informationen zum Konfigurieren von Wiederholungsparametern finden Sie in der RetryConfig-Dokumentation.

Es müssen drei Cloud Functions-Funktionen ordnungsgemäß bereitgestellt werden und den Status ACTIVE haben:
```
gcloud functions list
```
Erstellen Sie ein neues Dienstkonto, das bei der Ausführung des Cloud Scheduler-Jobs als Identität verwendet wird:
```
gcloud iam service-accounts create tracer-job-sa
```

Weisen Sie dem neuen Dienstkonto die IAM-Rolle cloudfunctions.invoker für die Funktion trace zu:

gcloud beta functions add-iam-policy-binding trace \
    --role roles/cloudfunctions.invoker \
    --member "serviceAccount:tracer-job-sa@$PROJECT.iam.gserviceaccount.com"

Erstellen Sie einen Cloud Scheduler-Job:
```
gcloud scheduler jobs create http traceWithRetry \
    --uri="https://$REGION-$PROJECT.cloudfunctions.net/trace" \
    --http-method=POST \
    --message-body="{\"url\":\"http://www.example.com\"}" \
    --headers="Content-Type=application/json" \
    --oidc-service-account-email="tracer-job-sa@$PROJECT.iam.gserviceaccount.com" \
    --schedule="0 3 * * *" \
    --time-zone="UTC" \
    --max-retry-attempts=3 \
    --min-backoff=30s
```
Da der Job die HTTP-ausgelöste trace-Funktion aufruft, gibt der Befehl den Jobtyp als http an und stellt die Funktionstrigger-URL als uri-Wert bereit. Die zu analysierende Seite, in diesem Fall www.example.com, wird im Flag message-body angegeben. Das Flag oidc-service-account-email definiert das Dienstkonto, das für die Authentifizierung verwendet werden soll. Der Befehl gibt die Anzahl der Wiederholungsversuche unter Verwendung des max-retry-attempts-Flags an, und der mit dem schedule-Flag übergebene Wert setzt den Ausführungszeitplan täglich auf 3:00 Uhr UTC.

Ergebnisse prüfen

In diesem Abschnitt prüfen Sie das erwartete Verhalten für Erfolgs- und Fehlerbedingungen.

Ergebnis prüfen

Der Cloud Scheduler-Job wird erst zum nächsten geplanten Termin ausgeführt, in diesem Fall 03:00 Uhr UTC. Sie können manuell einen Job auslösen, um die Ergebnisse sofort zu sehen.

Warten Sie 90 Sekunden, bis der Scheduler-Job die Initialisierung abgeschlossen hat.
Führen Sie den Cloud Scheduler-Job manuell aus:
```
gcloud scheduler jobs run traceWithRetry
```
Warten Sie ca. 30 Sekunden, bis die Funktionspipeline abgeschlossen ist.
Listen Sie den Inhalt des Messwert-Buckets auf, um zu sehen, ob Seitenmesswerte erfasst wurden:
```
gsutil ls -l gs://$METRICS_BUCKET
```
Öffnen Sie in der Google Cloud Console die Cloud Logging-Loganzeige:

Zur Seite "Logging"

Sie sehen Logeinträge von allen drei Cloud Functions-Funktionen: trace, analyze und alert. Der Durchlauf der Logs kann einen Moment dauern. Daher müssen Sie möglicherweise den Logbereich aktualisieren.
Notieren Sie sich die Firestore-Dokument-ID, die nach dem Text Created new Firestore document page-metrics/ aufgeführt ist.
Öffnen Sie in der Google Cloud Console die Seite „Firestore“:

Zur Seite "Firestore"
Prüfen Sie das Dokument, das die Ergebnisse der Analyse enthält. Die Dokumentwerte geben den Status PASS an und enthalten die neuesten Seitenleistungsmesswerte.
Prüfen Sie in Cloud Shell, ob keine Benachrichtigungen an das Pub/Sub-Thema gesendet wurden, indem Sie versuchen, eine Nachricht aus dem Abo abzurufen:
```
gcloud pubsub subscriptions pull \
    projects/$PROJECT/subscriptions/performance-alerts-sub \
    --auto-ack
```
Es werden keine Elemente aufgelistet.

Fehler prüfen

Lösen Sie die Trace-Funktion manuell aus. Diesmal stellen Sie die Seite mit den Google Cloud-Anleitungen als URL bereit. Diese Seite enthält einige dynamische Inhalte, die die Seitenladezeit über den erwarteten maximalen Schwellenwert hinaus erhöhen.
```
gcloud functions call trace \
    --data='{"url":"https://cloud.google.com/docs/tutorials"}'
```
Da Ihr Projekt die IAM-Rolle Owner oder Editor hat, verfügen Sie über ausreichende Berechtigungen zum Aufrufen der Funktion.
Warten Sie ca. 30 Sekunden, bis die Funktionspipeline abgeschlossen ist.
Listen Sie den Inhalt des Messwert-Buckets auf, um zu überprüfen, ob zusätzliche Messwerte erfasst wurden:
```
gsutil ls -l gs://$METRICS_BUCKET
```
Jeder Bucket enthält jetzt zwei Elemente.
Rufen Sie in der Google Cloud Console die Cloud Logging-Loganzeige auf und filtern Sie nach den Cloud Functions-Funktionslogs:

Zur Seite "Logging"

Die Funktion analyze gibt einen Fehler aus, der darauf hinweist, dass die Seite die maximal zulässige Ladezeit überschritten hat. Möglicherweise müssen Sie den Logbereich noch einmal aktualisieren, um die neuesten Benachrichtigungen anzuzeigen.
Notieren Sie sich die Firestore-Dokument-ID.
Öffnen Sie in der Google Cloud Console die Seite „Firestore“:

Zur Seite "Firestore"
Suchen Sie das Dokument, das die fehlgeschlagene Analyse enthält.

Das Statusfeld ist als FAIL markiert.
Prüfen Sie in Cloud Shell, ob eine Benachrichtigung an das Pub/Sub-Thema gesendet wurde, indem Sie eine Nachricht aus dem Abo abrufen.
```
gcloud pubsub subscriptions pull \
    projects/$PROJECT/subscriptions/performance-alerts-sub \
    --auto-ack
```
Dieses Mal sehen Sie den Inhalt der Benachrichtigung.

Bereinigen

Projekt löschen

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Nächste Schritte

Weitere Informationen zu serverlosen Google Cloud-Technologien.
Weitere Anleitungen zu Cloud Functions-Funktionen
Sehen Sie sich das Video der Google I/O '18 an, in dem weitere Verwendungszwecke von Puppeteer und der monitorlosen Chrome-Version beschrieben werden
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center