Experience Platform-gebeurtenissen in Slack volgen

Leer hoe u Experience Platform-meldingen in Slack kunt ontvangen door te integreren met een Adobe App Builder-proxy voor webhaken. Gegevenstechnici en beheerders willen mogelijk proactieve meldingen in Slack van Adobe Experience Platform ontvangen om de status van hun platformimplementaties te controleren. In deze zelfstudie worden de architectuur- en implementatiestappen beschreven waarmee Adobe I/O Events via Adobe App Builder kan worden verbonden met Slack.

Waarom een webhaakproxy?

Rechtstreeks verbinding maken van Adobe I/O Events met een Slack Incoming Webhaak is niet mogelijk vanwege een protocolprobleem in het verificatieproces.

Overzicht van architectuur

Wat is Adobe Developer Console?

Adobe Developer Console is het centrale portaal voor het beheer van uw Adobe-projecten, API's en gegevens. Dit is de locatie waar u uw project maakt, verificatie configureert en uw websites registreert.

Wat is App Builder?

Adobe App Builder is een compleet raamwerk waarmee ontwikkelaars van ondernemingen cloudnative toepassingen kunnen ontwikkelen.

Wat is Adobe I/O Runtime?

Adobe I/O Runtime is het serverloze platform dat App Builder macht geeft. Het staat ontwikkelaars toe om code (Functions-as-a-Service) op te stellen die in antwoord op HTTP- verzoeken zonder het beheren van serverinfrastructuur loopt.

In deze implementatie, gebruiken wij een Actie. Een handeling is een stateless functie (geschreven in Node.js) die op de Adobe I/O Runtime wordt uitgevoerd. Onze actie fungeert als het openbare HTTP-eindpunt waar Adobe I/O Events het over heeft.

Voor meer informatie, zie de ​ documentatie van Adobe I/O Runtime ​.

Implementatiehandleiding

Vereisten

Zorg ervoor dat u het volgende hebt voordat u begint:

Stap 1: Een project maken in Adobe Developer Console

Maak eerst een project met de App Builder-sjabloon in Adobe Developer Console:

De runtimeomgeving initialiseren

Voer de volgende opdrachten in uw terminal uit om de projectstructuur te maken:

Aanmelden bij aio

aio login

Stap 2: Initialiseer een nieuw App Builder-project

aio app init slack-webhook-proxy

De initialisatie van uw app moet zijn voltooid.

Ga naar de projectmap

cd slack-webhook-proxy

De webactie toevoegen

aio app add action

Stap 3: Werk de code van de volmachtsactie bij

Maak/wijzig het bestand actions/webhook-proxy/index.js in een IDE of teksteditor met de volgende code. Deze implementatie stuurt gebeurtenissen door naar Slack. Handtekeningverificatie en probleemverwerking zijn automatisch wanneer u de registratie van runtimeacties gebruikt.

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;

Stap 4: Vorm de actie

De actieconfiguratie in app.config.yaml is essentieel. Gebruik Web: nee om een niet-Webactie tot stand te brengen die als Runtime Actie in Developer Console kan worden geregistreerd.

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

Waarom web: no?

Wanneer u een niet-webactie gebruikt en registreert via de optie "Runtime Action" in de Developer Console, wordt Adobe I/O Events automatisch:

Dit betekent dat uw code slechts de bedrijfslogica (door:sturen aan Slack) moet behandelen.

Stap 4: De omgevingsvariabelen bijwerken

Om geloofsbrieven veilig te beheren, gebruiken wij omgevingsvariabelen. Maak/wijzig het .env -bestand in de hoofdmap van uw project om de URL van de Slack-webhaak toe te voegen. Verborgen bestanden weergeven op uw systeem als het .env -bestand niet wordt weergegeven:

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

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

Stap 5: De handeling implementeren

Zodra de milieuvariabelen worden geplaatst, stel de actie op. Zorg ervoor dat u zich in de hoofdmap van uw project bevindt, namelijk slack-webhook-proxy, wanneer u deze opdracht uitvoert in de terminal.

aio app deploy

Je actie wordt uitgevoerd naar Adobe I/O Runtime en is beschikbaar in de Developer Console voor registratie.

Stap 6: De handeling registreren in Adobe Developer Console

Nu uw handeling is geïmplementeerd, registreert u deze als de bestemming voor Adobe Events.

Stap 7: Valideren met een voorbeeldgebeurtenis

U kunt de volledige stroom van begin tot eind testen door het "Send steekproefgebeurtenis"pictogram naast om het even welke gevormde gebeurtenis te klikken.

De voorbeeldgebeurtenis wordt verzonden naar het kanaal dat u hebt geconfigureerd bij het maken van uw Slack-app en het maken van de webhaak. Er wordt iets gelijkaardigs weergegeven als:

Gefeliciteerd, u hebt Slack geïntegreerd met Experience Platform-gebeurtenissen!

Vaak voorkomende problemen

Hier zijn sommige kwesties die u kunt lopen wanneer het vormen van de volmacht en sommige potentiële manieren om hen te richten.