Google Chat-App mit Pub/Sub hinter einer Firewall erstellen

Auf dieser Seite wird erläutert, wie Sie eine Chat-App mit Pub/Sub erstellen. Diese Art von Architektur für eine Chat-Anwendung ist nützlich, wenn Ihre Organisation eine Firewall hat, die verhindern kann, dass Chat Nachrichten an Ihre Chat-App sendet, oder wenn die Chat-App die Google Workspace Events API verwendet. Für diese Architektur gelten jedoch die folgenden Einschränkungen, da diese Chat-Anwendungen nur asynchrone Nachrichten senden und empfangen können:

  • Dialogfelder können in Nachrichten nicht verwendet werden. Verwende stattdessen eine Kartennachricht.
  • Einzelne Karten können nicht mit einer synchronen Antwort aktualisiert werden. Aktualisieren Sie stattdessen die gesamte Nachricht durch Aufrufen der Methode patch.

Das folgende Diagramm zeigt die Architektur einer Chat-App, die mit Pub/Sub erstellt wurde:

Architektur einer mit Pub/Sub implementierten Chat-App.

Im obigen Diagramm hat ein Nutzer, der mit einer Pub/Sub Chat-Anwendung interagiert, den folgenden Informationsfluss:

  1. Ein Nutzer sendet in Google Chat eine Nachricht an eine Chat-App, entweder in einer Direktnachricht oder in einem Chatbereich, oder ein Ereignis findet in einem Chatbereich statt, für den die Chat-App ein aktives Abo hat.

  2. Chat sendet die Nachricht an ein Pub/Sub-Thema.

  3. Ein Anwendungsserver, bei dem es sich entweder um eine Cloud oder ein lokales System handelt, das die Logik der Chat-Anwendung enthält, abonniert das Pub/Sub-Thema, um die Nachricht über die Firewall zu empfangen.

  4. Optional kann die Chat-Anwendung die Chat API aufrufen, um asynchron Nachrichten zu senden oder andere Vorgänge auszuführen.

Voraussetzungen

Java

Umgebung einrichten

Bevor Sie Google APIs verwenden können, müssen Sie sie in einem Google Cloud-Projekt aktivieren. Sie können eine oder mehrere APIs in einem einzelnen Google Cloud-Projekt aktivieren.
  • Aktivieren Sie in der Google Cloud Console die Google Chat API und die Pub/Sub API.

    APIs aktivieren

Pub/Sub einrichten

  1. Erstellen Sie ein Pub/Sub-Thema, an das die Chat API Nachrichten senden kann. Wir empfehlen, nur ein Thema pro Chat-App zu verwenden.

  2. Erteilen Sie Chat die Berechtigung zum Veröffentlichen des Themas, indem Sie dem folgenden Dienstkonto die Rolle Pub/Sub Publisher zuweisen:

    chat-api-push@system.gserviceaccount.com
    
  3. Erstellen Sie ein Dienstkonto für die Chat-Anwendung zur Autorisierung mit Pub/Sub und Chat und speichern Sie die Datei mit dem privaten Schlüssel in Ihrem Arbeitsverzeichnis.

  4. Erstellen Sie ein Pull-Abo für das Thema.

  5. Weisen Sie dem zuvor erstellten Dienstkonto die Pub/Sub-Abonnentenrolle für das Abo zu.

Skript schreiben

Java

  1. Geben Sie in einer Befehlszeile Anmeldedaten für das Dienstkonto an:

    export GOOGLE_APPLICATION_CREDENTIALS=SERVICE_ACCOUNT_FILE_PATH
    
  2. Erstellen Sie in Ihrem Arbeitsverzeichnis eine Datei mit dem Namen pom.xml.

  3. Fügen Sie den folgenden Code in die Datei pom.xml ein:

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.google.chat.pubsub</groupId>
    <artifactId>java-pubsub-app</artifactId>
    <version>0.1.0</version>
    
    <name>java-pubsub-app</name>
    
    <properties>
      <maven.compiler.target>11</maven.compiler.target>
      <maven.compiler.source>11</maven.compiler.source>
    </properties>
    
    <dependencyManagement>
      <dependencies>
        <dependency>
          <groupId>com.google.cloud</groupId>
          <artifactId>libraries-bom</artifactId>
          <version>26.26.0</version>
          <type>pom</type>
          <scope>import</scope>
        </dependency>
      </dependencies>
    </dependencyManagement>
    
    <dependencies>
      <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.9.1</version>
      </dependency>
      <dependency>
        <groupId>com.google.api-client</groupId>
        <artifactId>google-api-client</artifactId>
        <version>1.32.1</version>
      </dependency>
      <dependency>
        <groupId>com.google.cloud</groupId>
        <artifactId>google-cloud-pubsub</artifactId>
      </dependency>
      <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.14.2</version>
      </dependency>
    </dependencies>
    
    <build>
      <pluginManagement>
        <plugins>
          <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.0</version>
          </plugin>
        </plugins>
      </pluginManagement>
    </build>
    </project>
    
  4. Erstellen Sie in Ihrem Arbeitsverzeichnis die Verzeichnisstruktur src/main/java.

  5. Erstellen Sie im Verzeichnis src/main/java eine Datei mit dem Namen Main.java.

  6. Fügen Sie den folgenden Code in Main.java ein:

    import com.fasterxml.jackson.databind.JsonNode;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.node.JsonNodeFactory;
    import com.fasterxml.jackson.databind.node.ObjectNode;
    import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
    import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
    import com.google.api.client.http.ByteArrayContent;
    import com.google.api.client.http.GenericUrl;
    import com.google.api.client.http.HttpContent;
    import com.google.api.client.http.HttpRequest;
    import com.google.api.client.http.HttpRequestFactory;
    import com.google.api.client.http.HttpTransport;
    import com.google.cloud.pubsub.v1.AckReplyConsumer;
    import com.google.cloud.pubsub.v1.MessageReceiver;
    import com.google.cloud.pubsub.v1.Subscriber;
    import com.google.pubsub.v1.PubsubMessage;
    import com.google.pubsub.v1.ProjectSubscriptionName;
    import java.io.FileInputStream;
    import java.util.Collections;
    
    public class Main {
    
      public static final String CREDENTIALS_PATH_ENV_PROPERTY = "GOOGLE_APPLICATION_CREDENTIALS";
    
      // Google Cloud Project ID
      public static final String PROJECT_ID = PROJECT_ID;
    
      // Cloud Pub/Sub Subscription ID
      public static final String SUBSCRIPTION_ID = SUBSCRIPTION_ID
    
      public static void main(String[] args) throws Exception {
        ProjectSubscriptionName subscriptionName =
            ProjectSubscriptionName.of(PROJECT_ID, SUBSCRIPTION_ID);
    
        // Instantiate app, which implements an asynchronous message receiver.
        EchoApp echoApp = new EchoApp();
    
        // Create a subscriber for <var>SUBSCRIPTION_ID</var> bound to the message receiver
        final Subscriber subscriber =
            Subscriber.newBuilder(subscriptionName, echoApp).build();
        System.out.println("Starting subscriber...");
        subscriber.startAsync();
    
        // Wait for termination
        subscriber.awaitTerminated();
      }
    }
    
    / **
    * A demo app which implements {@link MessageReceiver} to receive messages. It simply echoes the
    * incoming messages.
    */
    class EchoApp implements MessageReceiver {
    
      // Path to the private key JSON file of the service account to be used for posting response
      // messages to Google Chat.
      // In this demo, we are using the same service account for authorizing with Cloud Pub/Sub to
      // receive messages and authorizing with Google Chat to post messages. If you are using
      // different service accounts, please set the path to the private key JSON file of the service
      // account used to post messages to Google Chat here.
      private static final String SERVICE_ACCOUNT_KEY_PATH =
          System.getenv(Main.CREDENTIALS_PATH_ENV_PROPERTY);
    
      // Developer code for Google Chat API scope.
      private static final String GOOGLE_CHAT_API_SCOPE = "https://www.googleapis.com/auth/chat.bot";
    
      // Response URL Template with placeholders for space id.
      private static final String RESPONSE_URL_TEMPLATE =
          "https://chat.googleapis.com/v1/__SPACE_ID__/messages";
    
      // Response echo message template.
      private static final String RESPONSE_TEMPLATE = "You said: `__MESSAGE__`";
    
      private static final String ADDED_RESPONSE = "Thank you for adding me!";
    
      GoogleCredential credential;
      HttpTransport httpTransport;
      HttpRequestFactory requestFactory;
    
      EchoApp() throws Exception {
        credential =
            GoogleCredential.fromStream(new FileInputStream(SERVICE_ACCOUNT_KEY_PATH))
                .createScoped(Collections.singleton(GOOGLE_CHAT_API_SCOPE));
        httpTransport = GoogleNetHttpTransport.newTrustedTransport();
        requestFactory = httpTransport.createRequestFactory(credential);
      }
    
      // Called when a message is received by the subscriber.
      @Override
      public void receiveMessage(PubsubMessage pubsubMessage, AckReplyConsumer consumer) {
        System.out.println("Id : " + pubsubMessage.getMessageId());
        // handle incoming message, then ack/nack the received message
        try {
          ObjectMapper mapper = new ObjectMapper();
          JsonNode dataJson = mapper.readTree(pubsubMessage.getData().toStringUtf8());
          System.out.println("Data : " + dataJson.toString());
          handle(dataJson);
          consumer.ack();
        } catch (Exception e) {
          System.out.println(e);
          consumer.nack();
        }
      }
    
      public void handle(JsonNode eventJson) throws Exception {
        JsonNodeFactory jsonNodeFactory = new JsonNodeFactory(false);
        ObjectNode responseNode = jsonNodeFactory.objectNode();
    
        // Construct the response depending on the event received.
    
        String eventType = eventJson.get("type").asText();
        switch (eventType) {
          case "ADDED_TO_SPACE":
            responseNode.put("text", ADDED_RESPONSE);
            // An app can also be added to a space by @mentioning it in a message. In that case, we fall
            // through to the MESSAGE case and let the app respond. If the app was added using the
            // invite flow, we just post a thank you message in the space.
            if(!eventJson.has("message")) {
              break;
            }
          case "MESSAGE":
            responseNode.put("text",
                RESPONSE_TEMPLATE.replaceFirst(
                    "__MESSAGE__", eventJson.get("message").get("text").asText()));
            // In case of message, post the response in the same thread.
            ObjectNode threadNode = jsonNodeFactory.objectNode();
            threadNode.put("name", eventJson.get("message").get("thread").get("name").asText());
            responseNode.put("thread", threadNode);
            break;
          case "REMOVED_FROM_SPACE":
          default:
            // Do nothing
            return;
        }
    
        // Post the response to Google Chat.
    
        String URI =
            RESPONSE_URL_TEMPLATE.replaceFirst(
                "__SPACE_ID__", eventJson.get("space").get("name").asText());
        GenericUrl url = new GenericUrl(URI);
    
        HttpContent content =
            new ByteArrayContent("application/json", responseNode.toString().getBytes("UTF-8"));
        HttpRequest request = requestFactory.buildPostRequest(url, content);
        com.google.api.client.http.HttpResponse response = request.execute();
      }
    }
    

    Ersetzen Sie Folgendes:

    • PROJECT_ID: die Google Cloud-Projekt-ID.
    • SUBSCRIPTION_ID: die Abo-ID für das zuvor erstellte Pub/Sub-Abo.

App in Google Chat veröffentlichen

  1. Gehen Sie in der Google Cloud Console zu Menü > APIs und Dienste > Aktivierte APIs und Dienste > Google Chat API > Konfiguration.

    Zu „Konfiguration“

  2. Konfigurieren Sie die Chat-App für Pub/Sub:

    1. Geben Sie unter App-Name Quickstart App ein.
    2. Geben Sie im Feld Avatar-URL den Wert https://developers.google.com/chat/images/quickstart-app-avatar.png ein.
    3. Geben Sie unter Beschreibung den Text Quickstart app ein.
    4. Wählen Sie unter Funktionen die Option 1:1-Nachrichten erhalten und Gruppenbereichen und Gruppenunterhaltungen beitreten aus.
    5. Wählen Sie unter Verbindungseinstellungen Cloud Pub/Sub aus und fügen Sie den Namen des zuvor erstellten Pub/Sub-Themas ein.
    6. Wählen Sie unter Sichtbarkeit die Option Diese Google Chat-App für bestimmte Personen und Gruppen in Ihrer Domain verfügbar machen aus und geben Sie Ihre E-Mail-Adresse ein.
    7. Wählen Sie unter Logs die Option Fehler in Logging protokollieren aus.
  3. Klicken Sie auf Speichern.

Über die App können jetzt Nachrichten in Google Chat empfangen und beantwortet werden.

Skript ausführen

Wechseln Sie in einer Befehlszeile zu Ihrem Arbeitsverzeichnis und führen Sie das Skript aus:

Java

mvn compile exec:java -Dexec.mainClass=Main

Wenn Sie den Code ausführen, überwacht die Anwendung im Pub/Sub-Thema veröffentlichte Nachrichten.

Chat-App testen

Wenn Sie die Chat-App testen möchten, senden Sie eine Direktnachricht an die App:

  1. Öffnen Sie Google Chat.
  2. Klicken Sie zum Senden einer Direktnachricht an die Anwendung auf „Chat starten“ und dann im eingeblendeten Fenster auf Apps suchen.
  3. Suchen Sie im Dialogfeld Apps suchen nach „Schnellstart-App“.
  4. Zum Öffnen einer Direktnachricht an die App klicken Sie in der Kurzanleitung auf Hinzufügen > Chat.
  5. Geben Sie in der Direktnachricht Hello ein und drücken Sie enter. Die Chat-App gibt die Nachricht an Sie wieder.

Unter Interaktive Funktionen für Google Chat-Apps testen erfahren Sie, wie Sie Trusted Tester hinzufügen und mehr über das Testen interaktiver Funktionen erfahren.

Fehlerbehebung

Wenn eine Google Chat-App oder Google Chat-Karte einen Fehler zurückgibt, wird in der Chat-Oberfläche die Meldung „Ein Fehler ist aufgetreten“ oder „Ihre Anfrage kann nicht verarbeitet werden“ angezeigt. Manchmal wird in der Chat-Benutzeroberfläche keine Fehlermeldung angezeigt, aber die Chat-App oder -Karte führt zu einem unerwarteten Ergebnis, z. B. dass keine Kartennachricht angezeigt wird.

Obwohl eine Fehlermeldung möglicherweise nicht in der Chat-Benutzeroberfläche angezeigt wird, sind beschreibende Fehlermeldungen und Protokolldaten verfügbar, mit denen Sie Fehler beheben können, wenn die Fehlerprotokollierung für Chat-Apps aktiviert ist. Informationen zum Aufrufen, Debuggen und Beheben von Fehlern finden Sie im Hilfeartikel Google Chat-Fehler beheben.