Compila una app de Google Chat como webhook

En esta página, se describe cómo configurar un webhook para enviar mensajes asíncronos a un espacio de Chat mediante activadores externos. Por ejemplo, puedes configurar una aplicación de supervisión para notificar al personal de guardia en Chat cuando un servidor falle. Si quieres enviar un mensaje síncrono con una app de Chat, consulta Cómo enviar un mensaje.

Con este tipo de diseño de arquitectura, los usuarios no pueden interactuar con el webhook o la aplicación externa conectada porque la comunicación es unidireccional. Los webhooks no son conversacionales. No pueden responder ni recibir mensajes de los usuarios ni los eventos de interacción de la app de Chat. Para responder mensajes, compila una app de Chat en lugar de un webhook.

Si bien, técnicamente, un webhook no es una app de chat (los webhooks conectan aplicaciones mediante solicitudes HTTP estándar), en esta página, se hace referencia a este como una app de chat para simplificar. Cada webhook solo funciona en el espacio de Chat en el que está registrado. Los webhooks entrantes funcionan en los mensajes directos, pero solo cuando todos los usuarios tienen habilitadas las apps de chat. No puedes publicar webhooks en Google Workspace Marketplace.

En el siguiente diagrama, se muestra la arquitectura de un webhook conectado a Chat:

Arquitectura de webhooks entrantes para enviar mensajes asíncronos a Chat.

En el diagrama anterior, una app de Chat tiene el siguiente flujo de información:

  1. La lógica de la app de Chat recibe información de servicios externos de terceros, como un sistema de administración de proyectos o una herramienta de tickets.
  2. La lógica de la app de Chat se aloja en un sistema local o en la nube que puede enviar mensajes mediante una URL de webhook a un espacio de Chat específico.
  3. Los usuarios pueden recibir mensajes de la app de Chat en ese espacio de Chat específico, pero no pueden interactuar con la app de Chat.

Requisitos previos

Python

Node.js

Java

Apps Script

Crea un webhook

Para crear un webhook, regístralo en el espacio de Chat en el que deseas recibir mensajes y, luego, escribe una secuencia de comandos que envíe mensajes.

Registra el webhook entrante

  1. En un navegador, abre Chat. Los webhooks no se pueden configurar desde la app de Chat para dispositivos móviles.
  2. Ve al espacio en el que deseas agregar un webhook.
  3. Junto al título del espacio, haz clic en la flecha para expandir más y, luego, en Integraciones y apps.
  4. Haz clic en Agregar webhooks.
  5. En el campo Name, ingresa Quickstart Webhook.
  6. En el campo URL del avatar, ingresa https://developers.google.com/chat/images/chat-product-icon.png.
  7. Haz clic en Guardar.
  8. Para copiar la URL de webhook, haz clic en Más y, luego, en Copiar vínculo.

Escribe la secuencia de comandos del webhook

La secuencia de comandos del webhook de ejemplo envía un mensaje al espacio en el que está registrado el webhook mediante el envío de una solicitud POST a la URL de webhook. La API de Chat responde con una instancia de Message.

Selecciona un lenguaje para aprender a crear una secuencia de comandos de webhook:

Python

  1. En el directorio de trabajo, crea un archivo llamado quickstart.py.

  2. En quickstart.py, pega el siguiente código:

    python/webhook/quickstart.py
    from json import dumps
from httplib2 import Http


def main():
    """Google Chat incoming webhook quickstart."""
    url = "https://chat.googleapis.com/v1/spaces/SPACE_ID/messages"
    app_message = {"text": "Hello from a Python script!"}
    message_headers = {"Content-Type": "application/json; charset=UTF-8"}
    http_obj = Http()
    response = http_obj.request(
        uri=url,
        method="POST",
        headers=message_headers,
        body=dumps(app_message),
    )
    print(response)


if __name__ == "__main__":
    main()

  3. Reemplaza el valor de la variable WEBHOOK_URL por la URL de webhook que copiaste cuando registraste el webhook.

Node.js

  1. En el directorio de trabajo, crea un archivo llamado index.js.

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

    node/webhook/index.js
    /**
 * Sends asynchronous message to Google Chat
 * @return {Object} response
 */
async function webhook() {
  const url = "https://chat.googleapis.com/v1/spaces/SPACE_ID/messages"
  const res = await fetch(url, {
    method: "POST",
    headers: {"Content-Type": "application/json; charset=UTF-8"},
    body: JSON.stringify({text: "Hello from a Node script!"})
  });
  return await res.json();
}

webhook().then(res => console.log(res));

  3. Reemplaza el valor de la variable webhookURL por la URL de webhook que copiaste cuando registraste el webhook.

Java

  1. En el directorio de trabajo, crea un archivo llamado pom.xml.

  2. En pom.xml, copia y pega lo siguiente:

    java/webhook/pom.xml
    <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.webhook</groupId>
  <artifactId>java-webhook-app</artifactId>
  <version>0.1.0</version>

  <name>java-webhook-app</name>
  <url>https://github.com/googleworkspace/google-chat-samples/tree/main/java/webhook</url>

  <properties>
    <maven.compiler.target>11</maven.compiler.target>
    <maven.compiler.source>11</maven.compiler.source>
  </properties>

  <dependencies>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.9.1</version>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

  3. En tu directorio de trabajo, crea la siguiente estructura de directorio src/main/java.

  4. En el directorio src/main/java, crea un archivo llamado App.java.

  5. En App.java, pega el siguiente código:

    java/webhook/src/main/java/com/google/chat/webhook/App.java
    import com.google.gson.Gson;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Map;
import java.net.URI;

public class App {
  private static final String URL = "https://chat.googleapis.com/v1/spaces/AAAAGCYeSRY/messages";
  private static final Gson gson = new Gson();
  private static final HttpClient client = HttpClient.newHttpClient();

  public static void main(String[] args) throws Exception {
    String message = gson.toJson(Map.of("text", "Hello from Java!"));

    HttpRequest request = HttpRequest.newBuilder(
        URI.create(URL))
        .header("accept", "application/json; charset=UTF-8")
        .POST(HttpRequest.BodyPublishers.ofString(message))
        .build();

    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

    System.out.println(response.body());
  }
}

  6. Reemplaza el valor de la variable URL por la URL de webhook que copiaste cuando registraste el webhook.

Apps Script

  1. En un navegador, ve a Apps Script.

  2. Haz clic en New Project.

  3. Pega el siguiente código:

    apps-script/webhook/webhook.gs
    function webhook() {
  const url = "https://chat.googleapis.com/v1/spaces/SPACE_ID/messages"
  const options = {
    "method": "post",
    "headers": {"Content-Type": "application/json; charset=UTF-8"},
    "payload": JSON.stringify({"text": "Hello from Apps Script!"})
  };
  const response = UrlFetchApp.fetch(url, options);
  console.log(response);
}

  4. Reemplaza el valor de la variable url por la URL de webhook que copiaste cuando registraste el webhook.

Ejecuta la secuencia de comandos del webhook

En una CLI, ejecuta la secuencia de comandos:

Python

  python3 quickstart.py

Node.js

  node index.js

Java

  mvn compile exec:java -Dexec.mainClass=App

Apps Script

  • Haz clic en Ejecutar.

Cuando ejecutas el código, el webhook envía un mensaje al espacio en el que lo registraste.

Iniciar o responder una conversación de mensajes

  1. Especifica spaces.messages.thread.threadKey como parte del cuerpo de la solicitud del mensaje. Según si inicias o respondes una conversación, usa los siguientes valores para threadKey:

    • Si inicias un subproceso, establece threadKey en una string arbitraria, pero toma nota de este valor para publicar una respuesta en la conversación.

    • Si respondes a un subproceso, especifica el threadKey que se configuró cuando se inició el subproceso. Por ejemplo, para publicar una respuesta en la conversación en la que el mensaje inicial usó MY-THREAD, configura MY-THREAD.

  2. Define el comportamiento del subproceso si no se encuentra el threadKey especificado:

    • Responder una conversación o iniciar una nueva Agrega el parámetro messageReplyOption=REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD a la URL de webhook. Pasar este parámetro de URL hace que Chat busque un subproceso existente con el threadKey especificado. Si se encuentra uno, el mensaje se publica como respuesta a esa conversación. Si no se encuentra ninguno, el mensaje inicia un subproceso nuevo correspondiente a ese threadKey.

    • Responder una conversación o no hacer nada Agrega el parámetro messageReplyOption=REPLY_MESSAGE_OR_FAIL a la URL de webhook. Pasar este parámetro de URL hace que Chat busque un subproceso existente con el threadKey especificado. Si se encuentra uno, el mensaje se publica como respuesta a esa conversación. Si no se encuentra ninguno, el mensaje no se envía.

    Para obtener más información, consulta messageReplyOption.

La siguiente muestra de código inicia o responde una conversación de mensajes:

Python

python/webhook/thread-reply.py
from json import dumps
from httplib2 import Http

# Copy the webhook URL from the Chat space where the webhook is registered.
# The values for SPACE_ID, KEY, and TOKEN are set by Chat, and are included
# when you copy the webhook URL.
#
# Then, append messageReplyOption=REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD to the
# webhook URL.


def main():
    """Google Chat incoming webhook that starts or replies to a message thread."""
    url = "https://chat.googleapis.com/v1/spaces/SPACE_ID/messages?key=KEY&token=TOKEN&messageReplyOption=REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD"
    app_message = {
        "text": "Hello from a Python script!",
        # To start a thread, set threadKey to an arbitratry string.
        # To reply to a thread, specify that thread's threadKey value.
        "thread": {"threadKey": "THREAD_KEY_VALUE"},
    }
    message_headers = {"Content-Type": "application/json; charset=UTF-8"}
    http_obj = Http()
    response = http_obj.request(
        uri=url,
        method="POST",
        headers=message_headers,
        body=dumps(app_message),
    )
    print(response)


if __name__ == "__main__":
    main()

Node.js

node/webhook/thread-reply.js
/**
 * Sends asynchronous message to Google Chat
 * @return {Object} response
 */
async function webhook() {
  const url = "https://chat.googleapis.com/v1/spaces/SPACE_ID/messages?key=KEY&token=TOKEN&messageReplyOption=REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD"
  const res = await fetch(url, {
    method: "POST",
    headers: {"Content-Type": "application/json; charset=UTF-8"},
    body: JSON.stringify({
      text: "Hello from a Node script!",
      thread: {threadKey: "THREAD_KEY_VALUE"}
    })
  });
  return await res.json();
}

webhook().then(res => console.log(res));

Apps Script

apps-script/webhook/thread-reply.gs
function webhook() {
  const url = "https://chat.googleapis.com/v1/spaces/SPACE_ID/messages?key=KEY&token=TOKEN&messageReplyOption=REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD"
  const options = {
    "method": "post",
    "headers": {"Content-Type": "application/json; charset=UTF-8"},
    "payload": JSON.stringify({
      "text": "Hello from Apps Script!",
      "thread": {"threadKey": "THREAD_KEY_VALUE"}
    })
  };
  const response = UrlFetchApp.fetch(url, options);
  console.log(response);
}