Diese Seite wurde von der Cloud Translation API übersetzt.

Hintergrundverarbeitung mit Go

Viele Anwendungen müssen eine Hintergrundverarbeitung außerhalb des Kontexts einer Webanfrage ausführen. In dieser Anleitung wird eine Webanwendung erstellt, mit der Nutzer Text eingeben können, der übersetzt werden soll. Anschließend wird eine Liste früherer Übersetzungen angezeigt. Die Übersetzung erfolgt in einem Hintergrundprozess, um die Anfrage des Nutzers nicht zu blockieren.

Das folgende Diagramm veranschaulicht den Übersetzungsanfrageprozess.

Wie die in dieser Anleitung verwendete Anwendung funktioniert, sehen Sie an der Abfolge der Ereignisse:

Die Webseite wird aufgerufen, um eine Liste früherer Übersetzungen anzuzeigen, die in Firestore gespeichert sind.
Die Übersetzung eines Textes wird angefordert. Dazu wird ein HTML-Formular ausgefüllt.
Die Übersetzungsanfrage wird in Pub/Sub veröffentlicht.
Eine Cloud Run-Funktion, die dieses Pub/Sub-Thema abonniert hat, wird ausgelöst.
Die Cloud Run-Funktion verwendet Cloud Translation zum Übersetzen des Textes.
Die Cloud Run-Funktion speichert das Ergebnis in Firestore.

Diese Anleitung richtet sich an alle, die mehr über die Hintergrundverarbeitung mit Google Cloud erfahren möchten. Keine Vorkenntnisse erforderlich für Pub/Sub, Firestore, App Engine oder Cloud Run-Funktionen. Etwas Erfahrung mit Go, JavaScript und HTML ist allerdings hilfreich, um den gesamten Code zu verstehen.

Lernziele

Cloud Run-Funktion verstehen und bereitstellen
App Engine-Anwendung verstehen und bereitstellen
Anwendung testen

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Firestore, Cloud Run functions, Pub/Sub, and Cloud Translation APIs.

Enable the APIs

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Firestore, Cloud Run functions, Pub/Sub, and Cloud Translation APIs.

Enable the APIs

Öffnen Sie die Anwendung in der Google Cloud Console über Cloud Shell.

Zu Cloud Shell

Cloud Shell bietet Ihnen direkt über den Browser Befehlszeilenzugriff auf Ihre Cloud-Ressourcen. Öffnen Sie Cloud Shell im Browser und klicken Sie auf Fortfahren, um den Beispielcode herunterzuladen und ins Anwendungsverzeichnis zu wechseln.
Konfigurieren Sie in Cloud Shell das gcloud-Tool, um Ihr Google Cloud-Projekt zu verwenden:
```
# Configure gcloud for your project
gcloud config set project YOUR_PROJECT_ID
```

Cloud Run-Funktion

Die Funktion beginnt mit dem Import mehrerer Abhängigkeiten wie Firestore und Translation. Sie bietet auch einige globale Variablen und Typen.


// Package background contains a Cloud Function to translate text.
// The function listens to Pub/Sub, does the translations, and stores the
// result in Firestore.
package background

import (
	"context"
	"crypto/sha512"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"os"
	"strings"

	"cloud.google.com/go/firestore"
	"cloud.google.com/go/translate"
	"golang.org/x/text/language"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// A Translation contains the original and translated text.
type Translation struct {
	Original         string `json:"original"`
	Translated       string `json:"translated"`
	OriginalLanguage string `json:"original_language"`
	Language         string `json:"language"`
}

// Clients reused between function invocations.
var (
	translateClient *translate.Client
	firestoreClient *firestore.Client
)

// PubSubMessage is the payload of a Pub/Sub event.
// See https://cloud.google.com/functions/docs/calling/pubsub.
type PubSubMessage struct {
	Data []byte `json:"data"`
}

Die globalen Firestore- und Translation-Clients werden initialisiert, damit sie zwischen Funktionsaufrufen wiederverwendet werden können. So müssen Sie nicht für jeden Funktionsaufruf neue Clients initialisieren, was die Ausführung verlangsamen würde.


// initializeClients creates translateClient and firestoreClient if they haven't
// been created yet.
func initializeClients() error {
	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	if projectID == "" {
		return fmt.Errorf("GOOGLE_CLOUD_PROJECT must be set")
	}

	if translateClient == nil {
		// Pre-declare err to avoid shadowing translateClient.
		var err error
		// Use context.Background() so the client can be reused.
		translateClient, err = translate.NewClient(context.Background())
		if err != nil {
			return fmt.Errorf("translate.NewClient: %w", err)
		}
	}
	if firestoreClient == nil {
		// Pre-declare err to avoid shadowing firestoreClient.
		var err error
		// Use context.Background() so the client can be reused.
		firestoreClient, err = firestore.NewClient(context.Background(), projectID)
		if err != nil {
			return fmt.Errorf("firestore.NewClient: %w", err)
		}
	}
	return nil
}

Die Translation API übersetzt den String in den Sprache ausgewählt haben.


// translateString translates text to lang, returning:
// * the translated text,
// * the automatically detected source language, and
// * an error.
func translateString(ctx context.Context, text string, lang string) (translated string, originalLang string, err error) {
	l, err := language.Parse(lang)
	if err != nil {
		return "", "", fmt.Errorf("language.Parse: %w", err)
	}

	outs, err := translateClient.Translate(ctx, []string{text}, l, nil)
	if err != nil {
		return "", "", fmt.Errorf("Translate: %w", err)
	}

	if len(outs) < 1 {
		return "", "", fmt.Errorf("Translate got %d translations, need at least 1", len(outs))
	}

	return outs[0].Text, outs[0].Source.String(), nil
}

Die Cloud Run-Funktion beginnt mit der Initialisierung der Firestore- und Pub/Sub-Clients. Anschließend parst sie die Pub/Sub-Nachricht, um den zu übersetzenden Text und die gewünschte Zielsprache abzurufen.

Die Anwendung erstellt dann einen eindeutigen Namen für die Übersetzungsanfrage, damit keine doppelten Übersetzungen gespeichert werden. Anschließend wird die Datei in eine Firestore-Transaktion übersetzt, damit bei gleichzeitiger Ausführung nicht versehentlich dieselbe Übersetzung zweimal ausgeführt wird.


// Translate translates the given message and stores the result in Firestore.
func Translate(ctx context.Context, m PubSubMessage) error {
	initializeClients()

	t := Translation{}
	if err := json.Unmarshal(m.Data, &t); err != nil {
		return fmt.Errorf("json.Unmarshal: %w", err)
	}

	// Use a unique document name to prevent duplicate translations.
	key := fmt.Sprintf("%s/%s", t.Language, t.Original)
	sum := sha512.Sum512([]byte(key))
	// Base64 encode the sum to make a nice string. The [:] converts the byte
	// array to a byte slice.
	docName := base64.StdEncoding.EncodeToString(sum[:])
	// The document name cannot contain "/".
	docName = strings.Replace(docName, "/", "-", -1)
	ref := firestoreClient.Collection("translations").Doc(docName)

	// Run in a transation to prevent concurrent duplicate translations.
	err := firestoreClient.RunTransaction(ctx, func(ctx context.Context, tx *firestore.Transaction) error {
		doc, err := tx.Get(ref)
		if err != nil && status.Code(err) != codes.NotFound {
			return fmt.Errorf("Get: %w", err)
		}
		// Do nothing if the document already exists.
		if doc.Exists() {
			return nil
		}

		translated, originalLang, err := translateString(ctx, t.Original, t.Language)
		if err != nil {
			return fmt.Errorf("translateString: %w", err)
		}
		t.Translated = translated
		t.OriginalLanguage = originalLang

		if err := tx.Set(ref, t); err != nil {
			return fmt.Errorf("Set: %w", err)
		}
		return nil
	})

	if err != nil {
		return fmt.Errorf("RunTransaction: %w", err)
	}
	return nil
}

Cloud Run-Funktion bereitstellen

Stellen Sie die Cloud Run-Funktion in Cloud Shell im selben Verzeichnis wie die Datei translate.go mit einem Pub/Sub-Trigger bereit:
```
gcloud functions deploy Translate --runtime go111 \
--trigger-topic=translate --set-env-vars GOOGLE_CLOUD_PROJECT=YOUR_GOOGLE_CLOUD_PROJECT
```
Dabei ist YOUR_GOOGLE_CLOUD_PROJECT Ihre Google Cloud-Projekt-ID.

Informationen zur Anwendung

Zur Webanwendung gehören zwei Hauptkomponenten:

Ein Go-HTTP-Server für Webanfragen Der Server hat die folgenden beiden Endpunkte:
- /: führt alle vorhandenen Übersetzungen auf und zeigt ein Formular an, das Nutzer senden können, um neue Übersetzungen anzufordern.
- /request-translation: Formulare werden an diesen Endpunkt gesendet, der die Anfrage zur asynchronen Übersetzung in Pub/Sub veröffentlicht.
Eine HTML-Vorlage, die vom Go-Server mit den vorhandenen Übersetzungen ausgefüllt wird.

HTTP-Server

Im Verzeichnis index beginnt main.go mit dem Einrichten der Anwendung und dem Registrieren von HTTP-Handlern:


// Command index is an HTTP app that displays all previous translations
// (stored in Firestore) and has a form to request new translations. On form
// submission, the request is sent to Pub/Sub to be processed in the background.
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"os"
	"path/filepath"

	"cloud.google.com/go/firestore"
	"cloud.google.com/go/pubsub"
	"github.com/GoogleCloudPlatform/golang-samples/getting-started/background"
)

// topicName is the Pub/Sub topic to publish requests to. The Cloud Function to
// process translation requests should be subscribed to this topic.
const topicName = "translate"

// An app holds the clients and parsed templates that can be reused between
// requests.
type app struct {
	pubsubClient    *pubsub.Client
	pubsubTopic     *pubsub.Topic
	firestoreClient *firestore.Client
	tmpl            *template.Template
}

func main() {
	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	if projectID == "" {
		log.Fatalf("GOOGLE_CLOUD_PROJECT must be set")
	}

	a, err := newApp(projectID, "index")
	if err != nil {
		log.Fatalf("newApp: %v", err)
	}

	http.HandleFunc("/", a.index)
	http.HandleFunc("/request-translation", a.requestTranslation)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	log.Printf("Listening on localhost:%v", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

// newApp creates a new app.
func newApp(projectID, templateDir string) (*app, error) {
	ctx := context.Background()

	pubsubClient, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return nil, fmt.Errorf("pubsub.NewClient: %w", err)
	}

	pubsubTopic := pubsubClient.Topic(topicName)

	firestoreClient, err := firestore.NewClient(ctx, projectID)
	if err != nil {
		return nil, fmt.Errorf("firestore.NewClient: %w", err)
	}

	// Template referenced relative to the module/app root.
	tmpl, err := template.ParseFiles(filepath.Join(templateDir, "index.html"))
	if err != nil {
		return nil, fmt.Errorf("template.New: %w", err)
	}

	return &app{
		pubsubClient: pubsubClient,
		pubsubTopic:  pubsubTopic,

		firestoreClient: firestoreClient,
		tmpl:            tmpl,
	}, nil
}

Der Index-Handler (/) ruft alle vorhandenen Übersetzungen aus Firestore ab und füllt eine HTML-Vorlage mit der Liste aus:


// index lists the current translations.
func (a *app) index(w http.ResponseWriter, r *http.Request) {
	docs, err := a.firestoreClient.Collection("translations").Documents(r.Context()).GetAll()
	if err != nil {
		log.Printf("GetAll: %v", err)
		http.Error(w, fmt.Sprintf("Error getting translations: %v", err), http.StatusInternalServerError)
		return
	}

	var translations []background.Translation
	for _, d := range docs {
		t := background.Translation{}
		if err := d.DataTo(&t); err != nil {
			log.Printf("DataTo: %v", err)
			http.Error(w, "Error reading translations", http.StatusInternalServerError)
			return
		}
		translations = append(translations, t)
	}

	if err := a.tmpl.Execute(w, translations); err != nil {
		log.Printf("tmpl.Execute: %v", err)
		http.Error(w, "Error writing response", http.StatusInternalServerError)
		return
	}
}

Neue Übersetzungen werden durch Senden eines HTML-Formulars angefordert. Der Handler für Übersetzungsanfragen, der unter /request-translation registriert ist, parst das gesendete Formular, validiert die Anfrage und veröffentlicht eine Nachricht in Pub/Sub:


// requestTranslation parses the request, validates it, and sends it to Pub/Sub.
func (a *app) requestTranslation(w http.ResponseWriter, r *http.Request) {
	if err := r.ParseForm(); err != nil {
		log.Printf("ParseForm: %v", err)
		http.Error(w, "Bad request", http.StatusBadRequest)
		return
	}
	v := r.PostFormValue("v")
	if v == "" {
		log.Printf("Empty value")
		http.Error(w, "Empty value", http.StatusBadRequest)
		return
	}
	acceptableLanguages := map[string]bool{
		"de": true,
		"en": true,
		"es": true,
		"fr": true,
		"ja": true,
		"sw": true,
	}
	lang := r.PostFormValue("lang")
	if !acceptableLanguages[lang] {
		log.Printf("Unsupported language: %v", lang)
		http.Error(w, fmt.Sprintf("Unsupported language: %v", lang), http.StatusBadRequest)
		return
	}

	log.Printf("Translation requested: %q -> %s", v, lang)

	t := background.Translation{
		Original: v,
		Language: lang,
	}
	msg, err := json.Marshal(t)
	if err != nil {
		log.Printf("json.Marshal: %v", err)
		http.Error(w, "Error requesting translation", http.StatusInternalServerError)
		return
	}

	res := a.pubsubTopic.Publish(r.Context(), &pubsub.Message{Data: msg})
	if _, err := res.Get(r.Context()); err != nil {
		log.Printf("Publish.Get: %v", err)
		http.Error(w, "Error requesting translation", http.StatusInternalServerError)
		return
	}
}

HTML-Vorlage

Die HTML-Vorlage ist die Grundlage für die HTML-Seite, die dem Nutzer angezeigt wird, damit er frühere Übersetzungen sehen und neue anfordern kann. Die Vorlage wird vom HTTP-Server mit der Liste der vorhandenen Übersetzungen ausgefüllt.

Das <head>-Element der HTML-Vorlage enthält Metadaten, Stylesheets und JavaScript für die Seite:

<html>

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Translations</title>

    <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons">
    <link rel="stylesheet" href="https://code.getmdl.io/1.3.0/material.indigo-pink.min.css">
    <script defer src="https://code.getmdl.io/1.3.0/material.min.js"></script>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
    <script>
        $(document).ready(function() {
            $("#translate-form").submit(function(e) {
                e.preventDefault();
                // Get value, make sure it's not empty.
                if ($("#v").val() == "") {
                    return;
                }
                $.ajax({
                    type: "POST",
                    url: "/request-translation",
                    data: $(this).serialize(),
                    success: function(data) {
                        // Show snackbar.
                        console.log(data);
                        var notification = document.querySelector('.mdl-js-snackbar');
                        $("#snackbar").removeClass("mdl-color--red-100");
                        $("#snackbar").addClass("mdl-color--green-100");
                        notification.MaterialSnackbar.showSnackbar({
                            message: 'Translation requested'
                        });
                    },
                    error: function(data) {
                        // Show snackbar.
                        console.log("Error requesting translation");
                        var notification = document.querySelector('.mdl-js-snackbar');
                        $("#snackbar").removeClass("mdl-color--green-100");
                        $("#snackbar").addClass("mdl-color--red-100");
                        notification.MaterialSnackbar.showSnackbar({
                            message: 'Translation request failed'
                        });
                    }
                });
            });
        });
    </script>
    <style>
        .lang {
            width: 50px;
        }
        .translate-form {
            display: inline;
        }
    </style>
</head>

Die Seite bindet CSS von Material Design Lite (MDL) und JavaScript-Assets ein. Mit MDL können Sie Ihren Websites einen Material Design-Look verleihen.

Mithilfe von JQuery wartet die Seite, bis das Dokument fertig geladen ist, und legt dann einen Handler für gesendete Formulare fest. Wenn das Formular zur Übersetzungsanfrage gesendet wird, bestätigt die Seite mithilfe einer minimalen Formularvalidierung, dass der Wert nicht leer ist, und sendet dann eine asynchrone Anfrage an den Endpunkt /request-translation.

Schließlich wird über eine MDL-Snackbar angegeben, ob die Anfrage erfolgreich war oder ob ein Fehler aufgetreten ist.

Der HTML-Text der Seite verwendet ein MDL-Layout und mehrere MDL-Komponenten, um eine Liste von Übersetzungen und ein Formular zum Anfordern weiterer Übersetzungen anzuzeigen:

<body>
    <div class="mdl-layout mdl-js-layout mdl-layout--fixed-header">
        <header class="mdl-layout__header">
            <div class="mdl-layout__header-row">
                <!-- Title -->
                <span class="mdl-layout-title">Translate with Background Processing</span>
            </div>
        </header>
        <main class="mdl-layout__content">
            <div class="page-content">
                <div class="mdl-grid">
                <div class="mdl-cell mdl-cell--1-col"></div>
                    <div class="mdl-cell mdl-cell--3-col">
                        <form id="translate-form" class="translate-form">
                            <div class="mdl-textfield mdl-js-textfield mdl-textfield--floating-label">
                                <input class="mdl-textfield__input" type="text" id="v" name="v">
                                <label class="mdl-textfield__label" for="v">Text to translate...</label>
                            </div>
                            <select class="mdl-textfield__input lang" name="lang">
                                <option value="de">de</option>
                                <option value="en">en</option>
                                <option value="es">es</option>
                                <option value="fr">fr</option>
                                <option value="ja">ja</option>
                                <option value="sw">sw</option>
                            </select>
                            <button class="mdl-button mdl-js-button mdl-button--raised mdl-button--accent" type="submit"
                                name="submit">Submit</button>
                        </form>
                    </div>
                    <div class="mdl-cell mdl-cell--8-col">
                        <table class="mdl-data-table mdl-js-data-table mdl-shadow--2dp">
                            <thead>
                                <tr>
                                    <th class="mdl-data-table__cell--non-numeric"><strong>Original</strong></th>
                                    <th class="mdl-data-table__cell--non-numeric"><strong>Translation</strong></th>
                                </tr>
                            </thead>
                            <tbody>
                                {{range .}}
                                <tr>
                                    <td class="mdl-data-table__cell--non-numeric">
                                        <span class="mdl-chip mdl-color--primary">
                                            <span class="mdl-chip__text mdl-color-text--white">{{ .OriginalLanguage }} </span>
                                        </span>
                                    {{ .Original }}
                                    </td>
                                    <td class="mdl-data-table__cell--non-numeric">
                                        <span class="mdl-chip mdl-color--accent">
                                            <span class="mdl-chip__text mdl-color-text--white">{{ .Language }} </span>
                                        </span>
                                        {{ .Translated }}
                                    </td>
                                </tr>
                                {{end}}
                            </tbody>
                        </table>
                        <br/>
                        <button class="mdl-button mdl-js-button mdl-button--raised" type="button" onClick="window.location.reload();">
                            Refresh
                        </button>
                    </div>
                </div>
            </div>
            <div aria-live="assertive" aria-atomic="true" aria-relevant="text" class="mdl-snackbar mdl-js-snackbar" id="snackbar">
                <div class="mdl-snackbar__text mdl-color-text--black"></div>
                <button type="button" class="mdl-snackbar__action"></button>
            </div>
        </main>
    </div>
</body>

</html>

App erstellen

Bevor Sie versuchen, die Webanwendung bereitzustellen, erstellen Sie die Anwendung, um sicherzustellen, dass sie kompiliert wird. und alle Abhängigkeiten funktionieren.
```
go build -o start ./index
```
Der Build war erfolgreich, wenn nichts ausgegeben und eine start-Datei erstellt wurde.

Webanwendung bereitstellen

Mit der App Engine-Standardumgebung können Sie eine Anwendung erstellen und bereitstellen, die zuverlässig unter hoher Last und mit großen Datenmengen ausgeführt wird.

In dieser Anleitung wird das HTTP-Front-End in der App Engine-Standardumgebung bereitgestellt.

Die Datei app.yaml konfiguriert die App Engine-Anwendung:

runtime: go111
main: index

Stellen Sie Ihre Anwendung aus demselben Verzeichnis wie die Datei app.yaml in der App Engine-Standardumgebung bereit:
```
gcloud app deploy
```

Anwendung testen

Fordern Sie nach dem Bereitstellen der Cloud Run-Funktion und der App Engine-Anwendung eine Übersetzung an.

Geben Sie die folgende URL ein, um die App in Ihrem Browser anzuzeigen:

https://PROJECT_ID.REGION_ID.r.appspot.com

Ersetzen Sie Folgendes:
- PROJECT_ID: Ihre Google Cloud-Projekt-ID
- REGION_ID: Code, der Ihrer Anwendung von App Engine zugewiesen wird
Sie sehen eine Seite mit einer leeren Liste von Übersetzungen und einem Formular zum Anfordern neuer Übersetzungen.
Geben Sie im Feld Text to translate (Zu übersetzender Text) einen Text ein, der übersetzt werden soll, z. B. Hello, World.
Wählen Sie in der Drop-down-Liste eine Sprache aus, in die Sie den Text übersetzen möchten.
Klicken Sie auf Submit (Senden).
Klicken Sie zum Aktualisieren der Seite auf Aktualisieren . Die Übersetzungsliste enthält jetzt eine neue Zeile. Wenn Sie keine Übersetzung sehen, warten Sie einige Sekunden und versuchen es dann noch einmal. Ist immer noch keine Übersetzung zu sehen, lesen Sie den nächsten Abschnitt zum Debugging der Anwendung.

Fehler in der Anwendung beheben

Wenn Sie keine Verbindung zur App Engine-Anwendung herstellen können oder keine neuen Übersetzungen sehen, gehen Sie so vor:

Prüfen Sie, ob die gcloud-Bereitstellungsbefehle erfolgreich ausgeführt wurden und keine Fehler ausgegeben haben. Wenn Fehler aufgetreten sind, beheben Sie sie, bevor Sie die Cloud Run-Funktion und die App Engine-Anwendung noch einmal bereitstellen.
Rufen Sie in der Google Cloud Console die Seite „Loganzeige“ auf.
Zur Seite "Loganzeige"
1. Klicken Sie in der Drop-down-Liste Kürzlich ausgewählte Ressourcen auf GAE-Anwendung und dann auf Alle Werte für module_id. Sie sehen eine Liste der Anfragen, die Sie beim Besuch Ihrer Anwendung gestellt haben. Wenn keine Anfragenliste angezeigt wird, bestätigen Sie, dass Sie Alle Werte für module_id aus der Drop-down-Liste ausgewählt haben. Wenn Fehlermeldungen in der Google Cloud Console angezeigt werden, prüfen Sie, der Code Ihrer App stimmt Code im Abschnitt über die App.
2. Klicken Sie in der Drop-down-Liste Kürzlich ausgewählte Ressourcen auf Cloud Functions-Funktion und dann auf Alle Funktionsnamen. Daraufhin wird für jede angeforderte Übersetzung eine Funktion angezeigt. Ist dies nicht der Fall, überprüfen Sie, Cloud Run-Funktion und App Engine-Anwendung verwenden dasselbe Pub/Sub-Thema:
  - Prüfen Sie in der Datei background/index/main.go, ob die topicName-Konstante "translate" lautet.
  - Wenn Sie die Cloud Run-Funktion bereitstellen, Achten Sie darauf, das Flag --trigger-topic=translate anzugeben.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Google Cloud-Projekt löschen

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

App Engine-Instanz löschen

In the Google Cloud console, go to the Versions page for App Engine.
Go to Versions
Select the checkbox for the non-default app version that you want to delete.
Hinweis: Die einzige Möglichkeit, die Standardversion Ihrer App Engine-Anwendung zu löschen, besteht im Löschen Ihres Projekts. Sie können jedoch die Standardversion in der Google Cloud Console anhalten. Diese Aktion fährt alle mit der Version verbundenen Instanzen herunter. Sie können diese Instanzen später neu starten.

In der Standardumgebung der App Engine können Sie die Standardversion nur dann anhalten, wenn Ihre Anwendung eine manuelle oder einfache Skalierung aufweist.
Klicken Sie zum Löschen der Anwendungsversion auf Löschen.

Cloud Run-Funktion löschen

Löschen Sie die Cloud Run-Funktion, die Sie in dieser Anleitung erstellt haben:
```
gcloud functions delete Translate
```

Nächste Schritte

Weitere Anleitungen zu Cloud Run-Funktionen testen
Mehr über App Engine erfahren
Cloud Run testen, um zustandslose Container in einer vollständig verwalteten Umgebung oder im eigenen Google Kubernetes Engine-Cluster auszuführen