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:
Im obigen Diagramm hat ein Nutzer, der mit einer Pub/Sub Chat-Anwendung interagiert, den folgenden Informationsfluss:
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.
Chat sendet die Nachricht an ein Pub/Sub-Thema.
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.
Optional kann die Chat-Anwendung die Chat API aufrufen, um asynchron Nachrichten zu senden oder andere Vorgänge auszuführen.
Voraussetzungen
Java
- Ein Google Workspace-Konto mit Zugriff auf Google Chat.
- Ein Google Cloud-Projekt
- Die Abrechnung für Ihr Cloud-Projekt muss aktiviert sein. Weitere Informationen zur Überprüfung des Abrechnungsstatus Ihrer Projekte
- Java 11 oder höher.
- Apache Maven
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.
Pub/Sub einrichten
Erstellen Sie ein Pub/Sub-Thema, an das die Chat API Nachrichten senden kann. Wir empfehlen, nur ein Thema pro Chat-App zu verwenden.
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
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.
Erstellen Sie ein Pull-Abo für das Thema.
Weisen Sie dem zuvor erstellten Dienstkonto die Pub/Sub-Abonnentenrolle für das Abo zu.
Skript schreiben
Java
Geben Sie in einer Befehlszeile Anmeldedaten für das Dienstkonto an:
export GOOGLE_APPLICATION_CREDENTIALS=SERVICE_ACCOUNT_FILE_PATH
Erstellen Sie in Ihrem Arbeitsverzeichnis eine Datei mit dem Namen
pom.xml
.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>
Erstellen Sie in Ihrem Arbeitsverzeichnis die Verzeichnisstruktur
src/main/java
.Erstellen Sie im Verzeichnis
src/main/java
eine Datei mit dem NamenMain.java
.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
Gehen Sie in der Google Cloud Console zu Menü > APIs und Dienste > Aktivierte APIs und Dienste > Google Chat API > Konfiguration.
Konfigurieren Sie die Chat-App für Pub/Sub:
- Geben Sie unter App-Name
Quickstart App
ein. - Geben Sie im Feld Avatar-URL den Wert
https://developers.google.com/chat/images/quickstart-app-avatar.png
ein. - Geben Sie unter Beschreibung den Text
Quickstart app
ein. - Wählen Sie unter Funktionen die Option 1:1-Nachrichten erhalten und Gruppenbereichen und Gruppenunterhaltungen beitreten aus.
- Wählen Sie unter Verbindungseinstellungen Cloud Pub/Sub aus und fügen Sie den Namen des zuvor erstellten Pub/Sub-Themas ein.
- 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.
- Wählen Sie unter Logs die Option Fehler in Logging protokollieren aus.
- Geben Sie unter App-Name
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
Öffnen Sie zum Testen der Chat-App einen Direktnachrichtbereich mit der Chat-App und senden Sie eine Nachricht:
Öffnen Sie Google Chat mit dem Google Workspace-Konto, das Sie bei der Registrierung als Trusted Tester angegeben haben.
- Klicken Sie auf Neuer Chat.
- Geben Sie im Feld Eine oder mehrere Personen hinzufügen den Namen Ihrer Chat-App ein.
Wählen Sie Ihre Chat-App aus den Ergebnissen aus. Eine Direktnachricht wird geöffnet.
- Geben Sie in der neuen Direktnachricht an die App
Hello
ein und drücken Sieenter
.
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 -Karte einen Fehler zurückgibt, wird in der Chat-Oberfläche die Meldung „Ein Fehler ist aufgetreten“ angezeigt. oder „Ihre Anfrage kann nicht verarbeitet werden“. Manchmal wird in der Chat-UI keine Fehlermeldung angezeigt, die Chat-App oder -Karte aber ein unerwartetes Ergebnis, z. B. wird keine Kartennachricht angezeigt.
Obwohl möglicherweise keine Fehlermeldung in der Chat-UI angezeigt wird, stehen beschreibende Fehlermeldungen und Protokolldaten zur Verfügung, mit denen Sie Fehler beheben können, wenn das Fehler-Logging für Chat-Anwendungen aktiviert ist. Informationen zum Ansehen, Debuggen und Beheben von Fehlern finden Sie unter Google Chat-Fehler beheben.
Bereinigen
Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, sollten Sie das Cloud-Projekt löschen.
- Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten. Klicken Sie auf Menü > IAM und Verwaltung > 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 Beenden, um das Projekt zu löschen.
Weitere Informationen
Wenn Sie Ihrer Chat-App weitere Funktionen hinzufügen möchten, lesen Sie die folgenden Informationen: