Monitorización de eventos de Experience Platform en Slack

Obtenga información sobre cómo recibir notificaciones de Experience Platform en Slack mediante la integración con un proxy de gancho web de Adobe App Builder. Es posible que los ingenieros y administradores de datos deseen recibir notificaciones proactivas en Slack desde Adobe Experience Platform para monitorizar el estado de sus implementaciones de Platform. Este tutorial describe la arquitectura y los pasos de implementación para conectar Adobe I/O Events a Slack mediante Adobe App Builder.

¿Por qué un proxy webhook?

La conexión directa de Adobe I/O Events a un webhook entrante de Slack no es posible debido a una discrepancia de protocolos en el proceso de verificación.

Descripción general de arquitectura

¿Qué es Adobe Developer Console?

Adobe Developer Console es el portal central para administrar sus proyectos, API y credenciales de Adobe. Es donde crea el proyecto, configura la autenticación y registra los webhooks.

¿Qué es App Builder?

Adobe App Builder es un marco de trabajo completo que permite a los desarrolladores empresariales crear aplicaciones nativas de la nube.

¿Qué es Adobe I/O Runtime?

Adobe I/O Runtime es la plataforma sin servidor que alimenta App Builder. Permite a los desarrolladores implementar código (Funciones como servicio) que se ejecuta en respuesta a solicitudes HTTP sin administrar la infraestructura del servidor.

En esta implementación, utilizamos una Acción. Una acción es una función sin estado (escrita en Node.js) que se ejecuta en Adobe I/O Runtime. Nuestra acción sirve como punto final HTTP público con el que Adobe I/O Events habla.

Para obtener más información, consulte la documentación de Adobe I/O Runtime.

Guía de implementación

Requisitos previos

Antes de empezar, asegúrese de que dispone de lo siguiente:

Paso 1: Crear un proyecto en Adobe Developer Console

En primer lugar, cree un proyecto con la plantilla App Builder en Adobe Developer Console:

Inicializar el entorno de tiempo de ejecución

Ejecute los siguientes comandos en el terminal para crear la estructura del proyecto:

Iniciar sesión en aio

aio login

Paso 2: Inicializar un nuevo proyecto de App Builder

aio app init slack-webhook-proxy

Se debe completar la inicialización de la aplicación.

Vaya al directorio del proyecto

cd slack-webhook-proxy

Añadir la acción web

aio app add action

Paso 3: Actualizar el código de acción de proxy

En un IDE o editor de texto, cree o modifique el archivo actions/webhook-proxy/index.js con el siguiente código. Esta implementación reenvía eventos a Slack. La verificación de firma y la gestión de desafíos son automáticas al utilizar el registro de acciones en tiempo de ejecución.

const fetch = require("node-fetch");
const { Core } = require("@adobe/aio-sdk");

/**
 * Adobe I/O Events to Slack Runtime Proxy
 *
 * Receives events from Adobe I/O Events and forwards them to Slack.
 * Signature verification and challenge handling are automatic when
 * using Runtime Action registration (non-web action).
 */
async function main(params) {
  const logger = Core.Logger("webhook-proxy", { level: params.LOG_LEVEL || "info" });

  try {
    logger.info(`Event received: ${JSON.stringify(params)}`);

    // Forward to Slack
    return forwardToSlack(params, params.SLACK_WEBHOOK_URL, logger);

  } catch (error) {
    logger.error(`Error: ${error.message}`);
    return { statusCode: 500, body: { error: "Internal server error" } };
  }
}

/**
 * Forwards the event payload to Slack
 */
async function forwardToSlack(payload, webhookUrl, logger) {
  if (!webhookUrl) {
    logger.error("SLACK_WEBHOOK_URL not configured");
    return { statusCode: 500, body: { error: "Server configuration error" } };
  }

  // Extract Adobe headers passed to runtime action
  const headers = {
    "x-adobe-event-code": payload["x-adobe-event-code"],
    "x-adobe-event-id": payload["x-adobe-event-id"],
    "x-adobe-provider": payload["x-adobe-provider"]
  };

  const slackMessage = buildSlackMessage(payload, headers);

  const response = await fetch(webhookUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(slackMessage)
  });

  if (!response.ok) {
    const errorText = await response.text();
    logger.error(`Slack API error: ${response.status} - ${errorText}`);
    return { statusCode: response.status, body: { error: errorText } };
  }

  logger.info("Event forwarded to Slack");
  return { statusCode: 200, body: { success: true } };
}

/**
 * Builds a Slack Block Kit message from the event payload
 */
function buildSlackMessage(payload, headers) {
  // Adobe passes event code as x-adobe-event-code header (available in params for runtime actions)
  const eventType = headers["x-adobe-event-code"] ||
                    payload["x-adobe-event-code"] ||
                    payload.event_code ||
                    payload.type ||
                    payload.event_type ||
                    "Adobe Event";
  const eventId = headers["x-adobe-event-id"] || payload["x-adobe-event-id"] || payload.event_id || payload.id || "N/A";
  const eventData = payload.data || payload.event || payload;

  return {
    blocks: [
      {
        type: "header",
        text: { type: "plain_text", text: `Event: ${eventType}`, emoji: true }
      },
      {
        type: "section",
        fields: formatDataFields(eventData)
      },
      { type: "divider" },
      {
        type: "context",
        elements: [{
          type: "mrkdwn",
          text: `*Event ID:* ${eventId}  |  *Time:* ${new Date().toISOString()}`
        }]
      }
    ]
  };
}

/**
 * Formats event data as Slack mrkdwn fields
 */
function formatDataFields(data, maxFields = 10) {
  if (typeof data !== "object" || data === null) {
    return [{ type: "mrkdwn", text: `*Payload:*\n${String(data)}` }];
  }

  const entries = Object.entries(data);
  if (entries.length === 0) {
    return [{ type: "mrkdwn", text: "_No data provided_" }];
  }

  return entries.slice(0, maxFields).map(([key, value]) => ({
    type: "mrkdwn",
    text: `*${key}:*\n${typeof value === "object" ? `\`\`\`${JSON.stringify(value)}\`\`\`` : value}`
  }));
}

exports.main = main;

Paso 4: Configurar la acción

La configuración de la acción en app.config.yaml es crítica. Utilice web: no para crear una acción no web que se pueda registrar como Acción de tiempo de ejecución en Developer Console.

application:
  runtimeManifest:
    packages:
      slack-webhook-proxy:
        license: Apache-2.0
        actions:
          webhook-proxy:
            function: actions/webhook-proxy/index.js
            web: no
            runtime: nodejs:22
            inputs:
              LOG_LEVEL: info
              SLACK_WEBHOOK_URL: $SLACK_WEBHOOK_URL
            annotations:
              require-adobe-auth: false
              final: true

Por qué web: no?

Cuando se utiliza una acción que no es de web y se registra mediante la opción "Acción de tiempo de ejecución" en Developer Console, Adobe I/O Events hace lo siguiente automáticamente:

Esto significa que el código solo necesita gestionar la lógica empresarial (reenvío a Slack).

Paso 4: Actualizar las variables de entorno

Para administrar credenciales de forma segura, utilizamos variables de entorno. Cree o modifique el archivo .env en la raíz del proyecto para agregar la URL del webhook de Slack. Asegúrese de mostrar los archivos ocultos en el sistema si no ve el archivo .env:

# ... other .env file content ...

SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL

Paso 5: Implementar la acción

Una vez configuradas las variables de entorno, implemente la acción. Asegúrese de estar en la raíz del proyecto, concretamente slack-webhook-proxy, al ejecutar este comando en el terminal.

aio app deploy

La acción se implementará en Adobe I/O Runtime y estará disponible en Developer Console para registrarse.

Paso 6: Registrar la acción en Adobe Developer Console

Ahora que la acción está implementada, regístrela como destino para los eventos de Adobe.

Paso 7: Validar con un evento de ejemplo

Puede probar todo el flujo de extremo a extremo haciendo clic en el icono "Enviar evento de muestra" junto a cualquier evento configurado.

El evento de muestra se envía en el canal que ha configurado al crear la aplicación de Slack y el webhook; debería ver algo similar a esto:

¡Felicidades, ha integrado correctamente Slack con los eventos de Experience Platform!

Problemas comunes

Estos son algunos problemas que puede encontrar al configurar el proxy y algunas formas potenciales de solucionarlos.