Övervaka Experience Platform-event i Slack

Lär dig hur du får Experience Platform-meddelanden i Slack genom att integrera med en Adobe App Builder webbkrock-proxy. Datatekniker och administratörer kan vilja få proaktiva meddelanden i Slack från Adobe Experience Platform för att övervaka statusen för plattformsimplementeringarna. I den här självstudiekursen beskrivs arkitektur och implementeringssteg för att ansluta Adobe I/O Events till Slack med Adobe App Builder.

Varför en webkrok-proxy?

Det går inte att ansluta Adobe I/O Events direkt till en inkommande Slack-webkrok på grund av ett protokollfel i verifieringsprocessen.

Arkitektur - översikt

Vad är Adobe Developer Console?

Adobe Developer Console är den centrala portalen för hantering av Adobe-projekt, API:er och autentiseringsuppgifter. Det är där du skapar ditt projekt, konfigurerar autentisering och registrerar dina webbböcker.

Vad är App Builder?

Adobe App Builder är ett komplett ramverk med vilket företagsutvecklare kan skapa molnbaserade program.

Vad är Adobe I/O Runtime?

Adobe I/O Runtime är den serverlösa plattform som driver App Builder. Det gör att utvecklare kan distribuera kod (Functions-as-a-Service) som körs som svar på HTTP-begäranden utan att hantera serverinfrastrukturen.

I den här implementeringen använder vi en åtgärd. En åtgärd är en tillståndslös funktion (skriven i Node.js) som körs på Adobe I/O Runtime. Vår åtgärd fungerar som den offentliga HTTP-slutpunkten som Adobe I/O Events pratar med.

Mer information finns i Adobe I/O Runtime-dokumentationen.

Implementeringsguide

Förutsättningar

Innan du börjar bör du kontrollera följande:

Steg 1: Skapa ett projekt i Adobe Developer Console

Skapa först ett projekt med App Builder-mallen i Adobe Developer Console:

Initiera körningsmiljön

Kör följande kommandon i terminalen för att skapa projektstrukturen:

Logga in på aio

aio login

Steg 2: Initiera ett nytt App Builder-projekt

aio app init slack-webhook-proxy

Initieringen av appen bör slutföras.

Navigera till projektkatalogen

cd slack-webhook-proxy

Lägg till webbåtgärden

aio app add action

Steg 3: Uppdatera proxyåtgärdskoden

Skapa/ändra filen actions/webhook-proxy/index.js med följande kod i en IDE- eller textredigerare. Den här implementeringen vidarebefordrar händelser till Slack. Signaturverifiering och utmaningshantering sker automatiskt när körningsåtgärdsregistrering används.

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;

Steg 4: Konfigurera åtgärden

Åtgärdskonfigurationen i app.config.yaml är viktig. Använd webb: nej för att skapa en icke-webbåtgärd som kan registreras som en körningsåtgärd i 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

Varför web: no?

När du använder en åtgärd som inte är en webbåtgärd och registrerar den via alternativet"Runtime Action" i Developer Console, gör Adobe I/O Events automatiskt följande:

Det innebär att koden bara behöver hantera affärslogiken (vidarebefordra till Slack).

Steg 4: Uppdatera miljövariablerna

För att hantera inloggningsuppgifter på ett säkert sätt använder vi miljövariabler. Skapa/ändra filen .env i roten för ditt projekt för att lägga till din webkrok-URL för Slack. Se till att du visar dolda filer på datorn om du inte ser filen .env:

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

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

Steg 5: Distribuera åtgärden

Distribuera åtgärden när systemvariablerna har angetts. Se till att vara i projektets rot, det vill säga slack-webhook-proxy, när du kör det här kommandot i terminalen.

aio app deploy

Din åtgärd distribueras till Adobe I/O Runtime och är tillgänglig i Developer Console för registrering.

Steg 6: Registrera åtgärden i Adobe Developer Console

Nu när du distribuerat funktionsmakrot kan du registrera det som mål för Adobe Events.

Steg 7: Validera med en exempelhändelse

Du kan testa hela flödet från början till slut genom att klicka på ikonen Skicka exempelhändelse bredvid en konfigurerad händelse.

Exempelhändelsen skickas till den kanal som du har konfigurerat när du skapar din Slack-app och skapar webkroken. Du bör se något som liknar följande:

Grattis! Du har nu integrerat Slack med Experience Platform event!

Vanliga problem

Här är några problem som du kan stöta på när du konfigurerar proxyn och några möjliga sätt att åtgärda dem.