Compila una app de Google Chat que use Pub/Sub

Versión preliminar para desarrolladores: Disponible como parte del Programa de versión preliminar para desarrolladores de Google Workspace, que otorga acceso anticipado a ciertas funciones.

En esta página, se explica cómo crear una app de Chat que recibe eventos de Chat con Cloud Pub/Sub. Esta arquitectura es útil si tu app de Chat está detrás de un firewall o si deseas enviar o recibir eventos sobre un espacio o usuario de Chat con la API de Google Workspace Events.

En el siguiente diagrama, se muestra la arquitectura de una app de chat compilada con Pub/Sub:

En el diagrama anterior, un usuario que interactúa con una app de chat de Pub/Sub tiene el siguiente flujo de información:

1. Un usuario interactúa con la app de Chat, por ejemplo, enviándole un mensaje, emitiendo un comando o agregándola o quitándola de un espacio de Chat.

2. Chat envía el mensaje a un tema de Pub/Sub.

3. Un servidor de aplicaciones, es decir, un sistema en la nube o local que contiene la lógica de la app de Chat, se suscribe al tema de Pub/Sub para recibir el mensaje a través del firewall.

4. De manera opcional, la app de Chat puede llamar a la API de Chat para publicar mensajes de forma asíncrona o realizar otras operaciones.

Requisitos previos

Node.js

• Una cuenta de Google Workspace para empresas o Enterprise con acceso a Google Chat
• Un proyecto de Google Cloud con facturación habilitada. Para verificar que un proyecto existente tenga habilitada la facturación, consulta Verifica el estado de facturación de tus proyectos. Para crear un proyecto y configurar la facturación, consulta Crea un proyecto de Google Cloud.
• Node.js 14 o una versión posterior
• La herramienta de administración de paquetes npm
• Un proyecto de Node.js inicializado Para inicializar un proyecto nuevo, crea una carpeta nueva y cambia a ella. Luego, ejecuta el siguiente comando en tu interfaz de línea de comandos:

  npm init

Python

• Una cuenta de Google Workspace para empresas o Enterprise con acceso a Google Chat
• Un proyecto de Google Cloud con facturación habilitada. Para verificar que un proyecto existente tenga habilitada la facturación, consulta Verifica el estado de facturación de tus proyectos. Para crear un proyecto y configurar la facturación, consulta Crea un proyecto de Google Cloud.
• Python 3.6 o una versión posterior
• La herramienta de administración de paquetes pip

Java

• Una cuenta de Google Workspace para empresas o Enterprise con acceso a Google Chat
• Un proyecto de Google Cloud con facturación habilitada. Para verificar que un proyecto existente tenga habilitada la facturación, consulta Verifica el estado de facturación de tus proyectos. Para crear un proyecto y configurar la facturación, consulta Crea un proyecto de Google Cloud.
• Java 11 o una versión posterior
• La herramienta de administración de paquetes Maven

Habilita las APIs

Antes de usar las APIs de Google, debes activarlas en un proyecto de Google Cloud. Puedes activar una o más APIs en un solo proyecto de Google Cloud.

• En la consola de Google Cloud, habilita la API de Google Chat y la API de Pub/Sub.

  Habilitar las API

Configura Pub/Sub

1. Crea un tema de Pub/Sub al que la API de Chat pueda enviar mensajes. Te recomendamos que uses un solo tema por app de Chat.

2. Crea una cuenta de servicio para que la app de Chat se autorice con Pub/Sub y Chat, y guarda el archivo de claves privadas en tu directorio de trabajo.

3. Crea una suscripción de extracción al tema.

4. Asigna el rol de suscriptor de Pub/Sub en la suscripción para la cuenta de servicio que creaste anteriormente.

Escribe el guion

En esta sección, definirás la lógica de la aplicación de tu app de Chat. Escribirás un script que se autentique con Google Cloud y se suscriba al tema de Pub/Sub para recibir eventos de Chat, por ejemplo, cuando un usuario envíe un mensaje a tu app de Chat.

Cuando la secuencia de comandos recibe un mensaje, procesa los datos del evento y usa la API de Google Chat para publicar una respuesta al usuario o espacio. Esta configuración permite que tu app de Chat funcione detrás de un firewall y, al mismo tiempo, interactúe con los usuarios de Chat.

Node.js

1. En una CLI, proporciona las credenciales de la cuenta de servicio:

   export GOOGLE_APPLICATION_CREDENTIALS=SERVICE_ACCOUNT_FILE_PATH
   

2. En una CLI, proporciona el ID del proyecto de Google Cloud:

   export PROJECT_ID=PROJECT_ID
   

3. En una CLI, proporciona el ID de la suscripción a Pub/Sub que creaste anteriormente:

   export SUBSCRIPTION_ID=SUBSCRIPTION_ID
   

4. En tu directorio de trabajo, crea un archivo llamado package.json.

5. En el archivo package.json, pega el siguiente código:

   {
     "name": "pub-sub-app",
     "version": "1.0.0",
     "description": "Google Chat App that listens for messages via Cloud Pub/Sub",
     "main": "index.js",
     "scripts": {
       "start": "node index.js",
       "test": "echo \"Error: no test specified\" && exit 1"
     },
     "dependencies": {
       "@google-apps/chat": "^0.4.0",
       "@google-cloud/pubsub": "^4.5.0"
     },
     "license": "Apache-2.0"
   }
   

6. En tu directorio de trabajo, crea un archivo llamado index.js.

7. En index.js, pega el siguiente código:

   const {ChatServiceClient} = require('@google-apps/chat');
   const {MessageReplyOption} = require('@google-apps/chat').protos.google.chat.v1.CreateMessageRequest;
   const {PubSub} = require('@google-cloud/pubsub');
   const {SubscriberClient} = require('@google-cloud/pubsub/build/src/v1');
   
   // Receives messages from a pull subscription.
   function receiveMessages() {
     const chat = new ChatServiceClient({
       keyFile: process.env.GOOGLE_APPLICATION_CREDENTIALS,
       scopes: ['https://www.googleapis.com/auth/chat.bot'],
     });
   
     const subscriptionPath = new SubscriberClient()
       .subscriptionPath(process.env.PROJECT_ID, process.env.SUBSCRIPTION_ID)
     const subscription = new PubSub()
       .subscription(subscriptionPath);
   
     // Handle incoming message, then acknowledge the received message
     const messageHandler = message => {
       console.log(`Id : ${message.id}`);
       const event = JSON.parse(message.data);
       console.log(`Data : ${JSON.stringify(event)}`);
   
       // Post the response to Google Chat.
       const request = formatRequest(event);
       if (request != null) {
         chat.createMessage(request);
       }
   
       // Acknowledge the message.
       message.ack();
     }
   
     subscription.on('message', messageHandler);
     console.log(`Listening for messages on ${subscriptionPath}`);
   
     // Keep main thread from exiting while waiting for messages
     setTimeout(() => {
       subscription.removeListener('message', messageHandler);
       console.log(`Stopped listening for messages.`);
     }, 60 * 1000);
   }
   
   // Send message to Google Chat based on the type of event
   function formatRequest(event) {
     const chatEvent = event.chat || {};
   
     // If the app was removed, we don't respond.
     if (chatEvent.removedFromSpacePayload) {
       console.log(`App removed from space.`);
       return null;
     }
   
     const payload = chatEvent.messagePayload || chatEvent.addedToSpacePayload;
     const spaceName = payload?.space?.name;
   
     if (!spaceName) {
       console.log('No space name in event.');
       return null;
     }
   
     if (chatEvent.addedToSpacePayload) {
       // 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.
       return {
         parent: spaceName,
         message: { text: 'Thank you for adding me!' },
       };
     } else if (chatEvent.messagePayload) {
       // In case of message, post the response in the same thread.
       const message = chatEvent.messagePayload.message;
       return {
         parent: spaceName,
         messageReplyOption: MessageReplyOption.REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD,
         message: {
           text: 'You said: `' + message.text + '`',
           thread: { name: message.thread.name },
         },
       };
     }
   }
   
   if (!process.env.PROJECT_ID) {
     console.log('Missing PROJECT_ID env var.');
     process.exit(1);
   }
   if (!process.env.SUBSCRIPTION_ID) {
     console.log('Missing SUBSCRIPTION_ID env var.');
     process.exit(1);
   }
   if (!process.env.GOOGLE_APPLICATION_CREDENTIALS) {
     console.log('Missing GOOGLE_APPLICATION_CREDENTIALS env var.');
     process.exit(1);
   }
   
   receiveMessages();
   

Python

1. En una CLI, proporciona las credenciales de la cuenta de servicio:

   export GOOGLE_APPLICATION_CREDENTIALS=SERVICE_ACCOUNT_FILE_PATH
   

2. En una CLI, proporciona el ID del proyecto de Google Cloud:

   export PROJECT_ID=PROJECT_ID
   

3. En una CLI, proporciona el ID de la suscripción a Pub/Sub que creaste anteriormente:

   export SUBSCRIPTION_ID=SUBSCRIPTION_ID
   

4. En tu directorio de trabajo, crea un archivo llamado requirements.txt.

5. En el archivo requirements.txt, pega el siguiente código:

   google-cloud-pubsub>=2.23.0
   google-apps-chat==0.1.9
   

6. En tu directorio de trabajo, crea un archivo llamado app.py.

7. En app.py, pega el siguiente código:

   import json
   import logging
   import os
   import sys
   import time
   from google.apps import chat_v1 as google_chat
   from google.cloud import pubsub_v1
   from google.oauth2.service_account import Credentials
   
   def receive_messages():
     """Receives messages from a pull subscription."""
   
     scopes = ['https://www.googleapis.com/auth/chat.bot']
     service_account_key_path = os.environ.get('GOOGLE_APPLICATION_CREDENTIALS')
     creds = Credentials.from_service_account_file(service_account_key_path)
     chat = google_chat.ChatServiceClient(
         credentials=creds, client_options={'scopes': scopes}
     )
   
     project_id = os.environ.get('PROJECT_ID')
     subscription_id = os.environ.get('SUBSCRIPTION_ID')
     subscriber = pubsub_v1.SubscriberClient()
     subscription_path = subscriber.subscription_path(project_id, subscription_id)
   
     # Handle incoming message, then acknowledge the received message
     def callback(message):
       event = json.loads(message.data)
       logging.info('Data : %s', event)
   
       # Post the response to Google Chat.
       request = format_request(event)
       if request is not None:
         chat.create_message(request)
   
       # Acknowledge the message.
       message.ack()
   
     subscriber.subscribe(subscription_path, callback = callback)
     logging.info('Listening for messages on %s', subscription_path)
   
     # Keep main thread from exiting while waiting for messages
     while True:
       time.sleep(60)
   
   def format_request(event):
     """Send message to Google Chat based on the type of event.
     Args:
       event: A dictionary with the event data.
     """
     chat_event = event.get('chat', {})
   
     # If the app was removed, we don't respond.
     if 'removedFromSpacePayload' in chat_event:
       logging.info('App removed from space.')
       return
   
     payload = chat_event.get('messagePayload') or chat_event.get(
         'addedToSpacePayload'
     )
     space_name = payload.get('space', {}).get('name') if payload else None
   
     if not space_name:
       logging.warning('No space name in event.')
       return
   
     if 'addedToSpacePayload' in chat_event:
       # 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.
       return google_chat.CreateMessageRequest(
           parent = space_name,
           message = {
             'text': 'Thank you for adding me!'
           }
       )
     elif 'messagePayload' in chat_event:
       # In case of message, post the response in the same thread.
       message = chat_event['messagePayload']['message']
       return google_chat.CreateMessageRequest(
           parent = space_name,
           message_reply_option = google_chat.CreateMessageRequest.MessageReplyOption.REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD,
           message = {
             'text': 'You said: `' + message['text'] + '`',
             'thread': {
               'name': message['thread']['name']
             }
           }
       )
   
   if __name__ == '__main__':
     if 'PROJECT_ID' not in os.environ:
       logging.error('Missing PROJECT_ID env var.')
       sys.exit(1)
   
     if 'SUBSCRIPTION_ID' not in os.environ:
       logging.error('Missing SUBSCRIPTION_ID env var.')
       sys.exit(1)
   
     if 'GOOGLE_APPLICATION_CREDENTIALS' not in os.environ:
       logging.error('Missing GOOGLE_APPLICATION_CREDENTIALS env var.')
       sys.exit(1)
   
     logging.basicConfig(
         level=logging.INFO,
         style='{',
         format='{levelname:.1}{asctime} {filename}:{lineno}] {message}')
     receive_messages()
   

Java

1. En una CLI, proporciona las credenciales de la cuenta de servicio:

   export GOOGLE_APPLICATION_CREDENTIALS=SERVICE_ACCOUNT_FILE_PATH
   

2. En una CLI, proporciona el ID del proyecto de Google Cloud:

   export PROJECT_ID=PROJECT_ID
   

3. En una CLI, proporciona el ID de la suscripción a Pub/Sub que creaste anteriormente:

   export SUBSCRIPTION_ID=SUBSCRIPTION_ID
   

4. En tu directorio de trabajo, crea un archivo llamado pom.xml.

5. En el archivo pom.xml, pega el siguiente código:

   <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.addon</groupId>
    <artifactId>pubsub-addon-chat-app</artifactId>
    <version>0.1.0</version>
   
    <name>pubsub-addon-chat-app-java</name>
   
    <properties>
      <maven.compiler.release>11</maven.compiler.release>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
   
    <dependencyManagement>
      <dependencies>
        <dependency>
          <groupId>com.google.cloud</groupId>
          <artifactId>libraries-bom</artifactId>
          <version>26.41.0</version> <!-- Use a recent BOM version -->
          <type>pom</type>
          <scope>import</scope>
        </dependency>
      </dependencies>
    </dependencyManagement>
   
    <dependencies>
      <!-- Google Chat GAPIC library -->
      <dependency>
        <groupId>com.google.cloud</groupId>
        <artifactId>google-cloud-chat</artifactId>
      </dependency>
      <!-- Google Cloud Pub/Sub library -->
      <dependency>
        <groupId>com.google.cloud</groupId>
        <artifactId>google-cloud-pubsub</artifactId>
      </dependency>
      <!-- Google Apps Add-ons Event Object -->
      <dependency>
        <groupId>com.google.apps.addons.v1</groupId>
        <artifactId>google-apps-addons-v1-java</artifactId>
        <version>0.2.0</version> <!-- Check for latest version -->
      </dependency>
      <!-- Protobuf JSON utility -->
      <dependency>
        <groupId>com.google.protobuf</groupId>
        <artifactId>protobuf-java-util</artifactId>
      </dependency>
      <!-- Google Auth Library -->
      <dependency>
        <groupId>com.google.auth</groupId>
        <artifactId>google-auth-library-oauth2-http</artifactId>
      </dependency>
      <dependency>
        <groupId>com.google.api</groupId>
        <artifactId>gax</artifactId>
      </dependency>
      <!-- JSON utilities for PubSub message (if needed, though protobuf-java-util is primary for EventObject) -->
      <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.14.2</version>
      </dependency>
      <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-jdk14</artifactId>
        <version>1.7.36</version>
        <scope>runtime</scope>
      </dependency>
    </dependencies>
   
    <build>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.13.0</version>
          <configuration>
            <source>11</source>
            <target>11</target>
          </configuration>
        </plugin>
        <plugin>
          <groupId>org.codehaus.mojo</groupId>
          <artifactId>exec-maven-plugin</artifactId>
          <version>3.3.0</version>
          <configuration>
            <mainClass>Main</mainClass>
          </configuration>
        </plugin>
      </plugins>
    </build>
   </project>
   

6. En tu directorio de trabajo, crea la estructura de directorios src/main/java.

7. En el directorio src/main/java, crea un archivo llamado Main.java.

8. En Main.java, pega el siguiente código:

   import com.fasterxml.jackson.databind.JsonNode;
   import com.fasterxml.jackson.databind.ObjectMapper;
   import com.google.api.gax.core.FixedCredentialsProvider;
   import com.google.auth.oauth2.GoogleCredentials;
   import com.google.chat.v1.ChatServiceClient;
   import com.google.chat.v1.ChatServiceSettings;
   import com.google.chat.v1.CreateMessageRequest;
   import com.google.chat.v1.CreateMessageRequest.MessageReplyOption;
   import com.google.chat.v1.Message;
   import com.google.chat.v1.Thread;
   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.ProjectSubscriptionName;
   import com.google.pubsub.v1.PubsubMessage;
   import java.io.FileInputStream;
   import java.util.Collections;
   
   public class Main {
   
     public static final String PROJECT_ID_ENV_PROPERTY = "PROJECT_ID";
     public static final String SUBSCRIPTION_ID_ENV_PROPERTY = "SUBSCRIPTION_ID";
     public static final String CREDENTIALS_PATH_ENV_PROPERTY = "GOOGLE_APPLICATION_CREDENTIALS";
   
     public static void main(String[] args) throws Exception {
       ProjectSubscriptionName subscriptionName =
           ProjectSubscriptionName.of(
               System.getenv(Main.PROJECT_ID_ENV_PROPERTY),
               System.getenv(Main.SUBSCRIPTION_ID_ENV_PROPERTY));
   
       // 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("Subscriber is listening to events...");
       subscriber.startAsync();
   
       // Wait for termination
       subscriber.awaitTerminated();
     }
   }
   
   /**
    * A demo app which implements {@link MessageReceiver} to receive messages.
    * It echoes 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, 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";
   
     private static final String ADDED_RESPONSE = "Thank you for adding me!";
   
     ChatServiceClient chatServiceClient;
   
     EchoApp() throws Exception {
       GoogleCredentials credential =
           GoogleCredentials.fromStream(new FileInputStream(SERVICE_ACCOUNT_KEY_PATH))
               .createScoped(Collections.singleton(GOOGLE_CHAT_API_SCOPE));
   
       // Create the ChatServiceSettings with the app credentials
       ChatServiceSettings chatServiceSettings =
           ChatServiceSettings.newBuilder()
               .setCredentialsProvider(FixedCredentialsProvider.create(credential))
               .build();
   
       // Set the Chat service client
       chatServiceClient = ChatServiceClient.create(chatServiceSettings);
     }
   
     // 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 acknowledge 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);
         // Negative acknowledgement makes Pub/Sub redeliver the message.
         consumer.nack();
       }
     }
   
     // Send message to Google Chat based on the type of event.
     public void handle(JsonNode eventJson) throws Exception {
       // Google Chat events for add-ons are wrapped in a 'chat' object.
       if (!eventJson.has("chat")) {
         System.out.println("Ignored: Not a Chat event (missing 'chat' field).");
         return;
       }
   
       JsonNode chatNode = eventJson.get("chat");
       CreateMessageRequest createMessageRequest = null;
   
       if (chatNode.has("messagePayload")) {
         // HANDLE MESSAGE
         JsonNode messagePayload = chatNode.get("messagePayload");
         JsonNode message = messagePayload.get("message");
         JsonNode space = messagePayload.get("space");
   
         String spaceName = space.get("name").asText();
         String userText = message.has("text") ? message.get("text").asText() : "";
         String threadName = message.has("thread") ? message.get("thread").get("name").asText() : "";
   
         System.out.println("Received message in " + spaceName + ": " + userText);
   
         createMessageRequest =
             CreateMessageRequest.newBuilder()
                 .setParent(spaceName)
                 .setMessageReplyOption(MessageReplyOption.REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD)
                 .setMessage(
                     Message.newBuilder()
                         .setText("You said: `" + userText + "`")
                         .setThread(Thread.newBuilder().setName(threadName).build())
                         .build())
                 .build();
   
       } else if (chatNode.has("addedToSpacePayload")) {
         // HANDLE ADDED TO SPACE
         JsonNode addedPayload = chatNode.get("addedToSpacePayload");
         JsonNode space = addedPayload.get("space");
         String spaceName = space.get("name").asText();
   
         System.out.println("Added to space: " + spaceName);
   
         createMessageRequest =
             CreateMessageRequest.newBuilder()
                 .setParent(spaceName)
                 .setMessage(Message.newBuilder().setText(ADDED_RESPONSE).build())
                 .build();
   
       } else if (chatNode.has("removedFromSpacePayload")) {
         System.out.println("Removed from space.");
         return;
       } else {
         System.out.println("Ignored: Unhandled Chat event type.");
         return;
       }
   
       if (createMessageRequest != null) {
         // Post the response to Google Chat.
         chatServiceClient.createMessage(createMessageRequest);
         System.out.println("Sent reply.");
       }
     }
   }
   

Configura la app de Chat

Configura la app de Chat en la consola de Google Cloud para proporcionar detalles como su nombre y avatar, y para configurar la conexión al tema de Pub/Sub.

Cuando te conectas al tema de Pub/Sub, habilitas Chat para que envíe eventos a tu app. Luego, tu secuencia de comandos, que se suscribe al tema, puede recibir estos eventos y responder a los usuarios.

1. En la consola de Google Cloud, ve a Menú > APIs y servicios > APIs y servicios habilitados > API de Google Chat > Configuración.

   Ir a la configuración de la API de Chat

2. Configura la app de chat para Pub/Sub:

   1. En Nombre de la app, ingresa Add-on Chat App.
   2. En URL del avatar, escribe https://developers.google.com/workspace/add-ons/images/quickstart-app-avatar.png.
   3. En Descripción, ingresa Quickstart app.
   4. En Funcionalidad, selecciona Unirse a espacios y conversaciones grupales.
   5. En Configuración de conexión, selecciona Cloud Pub/Sub y pega el nombre del tema de Pub/Sub que creaste anteriormente.
   6. En Visibilidad, selecciona Hacer que esta app de Google Chat esté disponible para personas y grupos específicos en tu dominio y escribe tu dirección de correo electrónico.
   7. En Registros, selecciona Registrar errores en Logging.

3. Haz clic en Guardar.

Ahora que configuraste la app de Chat, debes actualizar una configuración de Pub/Sub.

1. En la página de configuración de la API de Chat, en Configuración de conexión, copia el correo electrónico de la cuenta de servicio, que es un correo electrónico único generado para tu proyecto de Google Cloud.
2. Otorga permiso de publicación a Chat en el tema asignando el rol de Publicador de Pub/Sub al correo electrónico de la cuenta de servicio que copiaste anteriormente.

La app está lista para recibir y responder mensajes en Chat.

Ejecuta la secuencia de comandos:

En una CLI, cambia a tu directorio de trabajo y ejecuta la secuencia de comandos:

Node.js

npm install
npm start

Python

python -m venv env
source env/bin/activate
pip install -r requirements.txt -U
python app.py

Java

mvn compile exec:java -Dexec.mainClass=Main

Cuando ejecutas el código, la aplicación comienza a escuchar los mensajes publicados en el tema de Pub/Sub.

Prueba tu app de Chat

Para probar tu app de Chat, abre un espacio de mensajes directos con la app de Chat y envía un mensaje:

1. Abre Google Chat con la cuenta de Google Workspace que proporcionaste cuando te agregaste como verificador de confianza.

   Ir a Google Chat

2. Haz clic en Nuevo chat.
3. En el campo Agrega 1 o más personas, escribe el nombre de tu app de Chat.

4. Selecciona tu app de Chat en los resultados. Se abrirá un mensaje directo.

   Nota: Si no ves tu app de Chat en la lista de resultados, asegúrate de haber incluido tu cuenta de Google Workspace en la configuración de Visibilidad de la página Configuración de la API de Chat en la consola de Google Cloud.
5. En el nuevo mensaje directo con la app, escribe Hello y presiona enter.

Para agregar verificadores de confianza y obtener más información sobre las pruebas de funciones interactivas, consulta Cómo probar funciones interactivas para apps de Google Chat.

Solucionar problemas

Cuando una app o una tarjeta de Google Chat muestra un error, la interfaz de Chat muestra un mensaje que dice "Se produjo un error". o "No se pudo procesar tu solicitud". A veces, la IU de Chat no muestra ningún mensaje de error, pero la app o la tarjeta de Chat producen un resultado inesperado. Por ejemplo, es posible que no aparezca un mensaje de la tarjeta.

Si bien es posible que no se muestre un mensaje de error en la IU de Chat, hay mensajes de error descriptivos y datos de registro disponibles para ayudarte a corregir errores cuando se activa el registro de errores para las apps de Chat. Para obtener ayuda para ver, depurar y corregir errores, consulta Soluciona y corrige errores de Google Chat.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en este instructivo, te recomendamos que borres el proyecto de Cloud.

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

• Se borra todo en el proyecto. Si utilizaste un proyecto existente para este instructivo, cuando lo borres, también borrarás cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URLs que utilizan el ID del proyecto, como una URL en appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de todo el proyecto.

Si planeas explorar varios instructivos y guías de inicio rápido, la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

1. En la consola de Google Cloud, ve a la página Administrar recursos. Haz clic en Menú > IAM y administración > Administrar recursos.

   Ir al administrador de recursos

2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrarlo.

Temas relacionados

• Para agregar más funciones a tu app de Chat, consulta los siguientes recursos:

  • Envía mensajes de Google Chat
  • Cómo responder a comandos

• Crea interfaces de Google Chat