Usa Cloud Pub/Sub como extremo para tu app

Cuando creas una app para tu organización, es posible que esta use un firewall, lo que puede impedir que Google Chat envíe mensajes a la app. Para ayudar con esto, Google Chat cuenta con una integración con Cloud Pub/Sub. Esta integración permite que tu app establezca una conexión con Cloud Pub/Sub y reciba mensajes.

Configura Cloud Pub/Sub

En esta sección, se describe cómo configurar un tema de Cloud Pub/Sub y suscribir tu app a él.

Crea un proyecto de Google Cloud habilitado para Pub/Sub

Para usar Cloud Pub/Sub con tu app, debes crear un proyecto de Google Cloud Platform que tenga habilitada la API de Pub/Sub.

1. Crea un proyecto nuevo en la consola de Google Cloud.
2. En el panel izquierdo de la consola, selecciona Pub/Sub y, luego, Habilitar API.

Crea un tema de Pub/Sub

A continuación, crea un tema al que la API de Chat envíe mensajes. Consulta la guía de inicio rápido de la consola de Pub/Sub para ver cómo crear un tema.

Te recomendamos que uses un solo tema por app. Consulta los límites de Cloud Pub/Sub para conocer el límite en la cantidad de temas.

Habilita la API de Google Chat

Asegúrate de habilitar la API de Google Chat y configurarla en el tema creado en el paso anterior.

1. En el panel izquierdo de la consola, selecciona APIs y servicios y habilita la API de Google Chat.
2. Cuando configure la API, asegúrese de que la configuración de la conexión esté establecida en Cloud Pub/Sub y proporcione el mismo tema del paso anterior.
3. Completa los otros campos como se detalla en la guía de la app de ejemplo.

Cómo otorgar derechos de publicación en tu tema

Para que Google Chat publique mensajes en tu tema, debe tener derechos de publicación en el tema. Para otorgar estos permisos a Google Chat, asigna el rol Publicador de Pub/Sub a la siguiente cuenta de servicio:

[e-mail]

Esta acción permitirá que Google Chat publique en tu tema.

Crea una cuenta de servicio

Para que el código de tu app se autorice con Cloud Pub/Sub y Google Chat, debes usar una cuenta de servicio. Para configurar una cuenta de servicio, consulta Autoriza y autentica con la API de Chat mediante una cuenta de servicio.

Las apps usan cuentas de servicio para dos tareas: (a) usar la API de Pub/Sub como se describe aquí y (b) enviar mensajes a Google Chat. (Consulta la guía sobre cuentas de servicio para obtener más detalles). Puedes usar una sola cuenta de servicio para ambos o puedes usar dos cuentas de servicio separadas.

Cree una suscripción

Sigue la Guía para suscriptores de Cloud Pub/Sub a fin de configurar una suscripción al tema que creaste. Configura el tipo de suscripción para que sea una extracción de webhook. Agrega permisos a la suscripción para la cuenta de servicio que creaste en el último paso y asígnale la función de “Suscriptor de Pub/Sub”.

Publica la app de Cloud Pub/Sub

Consulta la guía Publicación de aplicaciones para obtener detalles sobre cómo publicar tu aplicación. Para aplicaciones de Cloud Pub/Sub, selecciona la opción de Cloud Pub/Sub y, luego, ingresa el nombre completamente calificado del tema creado. El nombre del tema debe tener el siguiente formato:

projects/PROJECT_ID/topics/TOPIC_ID

Por ejemplo, projects/pubsub-demo-2/topics/test-topic

Una vez que hayas publicado la app de esta manera, los usuarios podrán usarla, y la app recibirá mensajes en el tema de Pub/Sub que configuraste.

En el ejemplo de la siguiente sección, se muestra cómo crear y ejecutar una app simple que implemente estos objetos.

Ejemplo de implementación de app

El siguiente código de muestra muestra una aplicación simple que usa Cloud Pub/Sub para recibir mensajes entrantes. Para probar esta app, debes hacer lo siguiente:

• Edita los valores de ID del proyecto y de ID de suscripción en la clase principal

• Proporciona las credenciales de la cuenta de servicio como se describe en la guía Primeros pasos con la autenticación.

  export GOOGLE_APPLICATIONCREDENTIALS=<path_to_service_account_file>

Para ejecutar este código, necesitarás las siguientes dependencias en tu ruta de clase:

• Cliente de la API de Google
• Cliente de Cloud Pub/Sub
• Vinculación de datos de Jackson

package com.google.chat;

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 = "my-project-id";

  // Cloud Pub/Sub Subscription ID
  public static final String SUBSCRIPTION_ID = "my-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 "my-subscription-id" 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();
  }
}

Límites y consideraciones

Toma nota de los siguientes límites y consideraciones de Pub/Sub:

• Abrir, enviar o cancelar un diálogo requiere una respuesta síncrona de una app de Chat con un DialogEventType. En consecuencia, los diálogos no son compatibles con las apps de Chat compiladas con una arquitectura asíncrona, como Cloud Pub/Sub. Como solución alternativa, considera usar un mensaje de tarjeta en lugar de un diálogo.
• Las apps de chat compiladas con Cloud Pub/Sub no pueden actualizar tarjetas individuales con una respuesta síncrona. Para actualizar una tarjeta, actualiza todo el mensaje mediante una llamada al método de la API de Patch Message.

Solución de problemas

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

Aunque 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 apps de chat. Si necesitas ayuda para ver, depurar y corregir errores, consulta Cómo solucionar problemas de Google Chat.