Orchestrer les flux de travail opérationnels

Déclenchez des flux de travail opérationnels en aval dans plusieurs systèmes, comme une plateforme CRM et un canal de notification, lorsque des changements d’identité surviennent dans Auth0.

Avec Event Streams et Auth0 Actions, vous pouvez transformer les changements du cycle de vie des identités en flux de travail opérationnels automatisés qui s’exécutent dans plusieurs systèmes. Lorsqu’un utilisateur est créé, mis à jour ou supprimé dans Auth0, une Action exécute du code côté serveur qui appelle des API externes en parallèle, ce qui vous permet de créer des pipelines complets sans déployer votre propre middleware.

Ce guide présente un exemple de bout en bout : provisionner des utilisateurs à partir d’un fournisseur d’identité d’entreprise (IdP) au moyen d’Auth0 Inbound SCIM, puis diffuser ces changements dans une plateforme CRM et un canal de notification d’équipe à l’aide d’une seule Action Event Stream.

​

Pourquoi automatiser les flux de travail liés à l’identité

L’automatisation des flux de travail axés sur l’identité est utile lorsque vous devez :

• Intégrer de nouveaux employés à plusieurs applications d’entreprise dès qu’ils sont provisionnés dans votre IdP.
• Répercuter les changements d’identité vers plusieurs systèmes en aval en une seule étape.
• Retirer l’accès dans l’ensemble des systèmes en aval lorsqu’un utilisateur est supprimé.
• Éliminer les étapes manuelles des processus qui dépendent d’événements du cycle de vie de l’identité.

​

Aperçu de l’architecture

Le pipeline de ce guide utilise quatre composants :

1. IdP d’entreprise (par exemple, Okta) — la source de référence pour les identités des employés.
2. Auth0 Inbound SCIM — reçoit les événements de Provisioning de l’IdP et crée ou met à jour des utilisateurs dans Auth0.
3. Event Stream avec une Auth0 Action — écoute les événements du cycle de vie des utilisateurs et exécute du code côté serveur.
4. Plusieurs systèmes externes — les destinations qui reçoivent les données transformées. Cet exemple cible un CRM (HubSpot) et un canal de notification d’équipe (Slack).

Le fonctionnement est le suivant :

1. Un administrateur attribue un utilisateur à une application dans l’IdP d’entreprise.
2. L’IdP transmet la modification à Auth0 au moyen de SCIM.
3. Auth0 crée ou met à jour le profil utilisateur et publie un événement.
4. L’Event Stream déclenche une Action qui effectue des requêtes vers plusieurs API externes.

La différence entre l’orchestration et la corrélation tient au nombre de systèmes en aval. La corrélation mappe un événement à un seul enregistrement externe. L’orchestration diffuse un même événement vers plusieurs systèmes dans le cadre d’un flux de travail plus large.

​

Prérequis

Avant de commencer, assurez-vous d’avoir :

• Un tenant Auth0 avec Events activé. Pour en savoir plus sur la disponibilité selon le plan, consultez Créer un Event Stream.
• Un IdP d’entreprise qui prend en charge le provisionnement SCIM (par exemple, Okta ou Microsoft Entra ID).
• Auth0 Inbound SCIM configuré pour la connexion pertinente. Pour en savoir plus, consultez Inbound SCIM.
• Des identifiants API pour chaque système externe. Cet exemple nécessite :
  • Un access token d’application privée HubSpot avec le scope d’écriture Contacts.
  • Une Slack Incoming Webhook URL pour le canal cible.

​

Configurer le provisionnement SCIM

Si vous n’avez pas encore configuré Inbound SCIM, suivez les étapes ci-dessous pour connecter votre IdP à Auth0.

Okta

1. Dans l’Auth0 Dashboard, accédez à Authentication > Enterprise et sélectionnez votre connexion d’entreprise SAML ou OIDC.
2. Sélectionnez l’onglet Provisioning et activez Inbound SCIM.
3. Générez un SCIM token et copiez-le.
4. Dans Okta, ouvrez l’application que vous utilisez pour fédérer avec Auth0.
5. Sélectionnez l’onglet Provisioning, puis Configure API Integration.
6. Activez l’intégration, collez l’URL du point de terminaison SCIM et le jeton Auth0, puis sélectionnez Save.
7. Sous To App, activez Create Users, Update User Attributes et Deactivate Users.

Other IdPs

Consultez la documentation de votre IdP pour configurer le provisionnement SCIM sortant. Vous aurez besoin de :

• L’URL du point de terminaison SCIM Auth0 dans l’onglet Provisioning de votre connexion d’entreprise.
• D’un SCIM token généré dans l’Auth0 Dashboard.

Après avoir enregistré la configuration, attribuez un utilisateur de test à l’application dans votre IdP. Vérifiez que l’utilisateur apparaît dans Auth0 sous User Management > Users.

​

Créer l’Action Event Stream

Avec le provisionnement SCIM activé, Auth0 publie les événements user.created, user.updated et user.deleted. Ensuite, créez un Event Stream doté d’une Auth0 Action qui diffuse ces événements vers plusieurs systèmes en aval.

​

Créer l’Event Stream

1. Accédez à Auth0 Dashboard > Event Streams.
2. Sélectionnez Create Event Stream.
3. Sélectionnez Auth0 Actions comme type de flux.
4. Entrez un nom descriptif (par exemple, Onboarding Workflow).
5. Abonnez-vous à user.created, user.updated et user.deleted.

​

Écrire le gestionnaire d’Action

Dans l’éditeur d’Action, écrivez un gestionnaire qui associe chaque type d’événement à des appels d’API vers vos systèmes externes. L’exemple ci-dessous crée un contact HubSpot CRM et publie une notification dans Slack lorsqu’un nouvel utilisateur est provisionné.

exports.onExecuteEventStream = async (event, api) => {
    const eventType = event.message.type;
    const userData = event.message.data.object;

    const HUBSPOT_TOKEN = event.secrets.HUBSPOT_TOKEN;
    const SLACK_WEBHOOK_URL = event.secrets.SLACK_WEBHOOK_URL;

    switch (eventType) {
        case "user.created":
            await onboardUser(userData, HUBSPOT_TOKEN, SLACK_WEBHOOK_URL);
            break;
        case "user.updated":
            await updateCrmContact(userData, HUBSPOT_TOKEN);
            break;
        case "user.deleted":
            await offboardUser(userData, HUBSPOT_TOKEN, SLACK_WEBHOOK_URL);
            break;
        default:
            console.log(`Unhandled event type: ${eventType}`);
    }
};

async function onboardUser(userData, hubspotToken, slackWebhookUrl) {
    const crmResult = await createCrmContact(userData, hubspotToken);
    await notifySlack(slackWebhookUrl, {
        text: `New user onboarded: ${userData.email} (CRM contact ${crmResult.id})`
    });
}

async function offboardUser(userData, hubspotToken, slackWebhookUrl) {
    await deleteCrmContact(userData, hubspotToken);
    await notifySlack(slackWebhookUrl, {
        text: `User offboarded: ${userData.email}`
    });
}

// --- Fonctions utilitaires CRM ---

async function createCrmContact(userData, token) {
    const response = await fetch("https://api.hubapi.com/crm/v3/objects/contacts", {
        method: "POST",
        headers: {
            "Authorization": `Bearer ${token}`,
            "Content-Type": "application/json"
        },
        body: JSON.stringify({
            properties: {
                email: userData.email,
                firstname: userData.given_name,
                lastname: userData.family_name
            }
        })
    });

    if (!response.ok) {
        throw new Error(`HubSpot create failed: ${response.status}`);
    }
    return response.json();
}

async function updateCrmContact(userData, token) {
    const BASE_URL = "https://api.hubapi.com/crm/v3/objects/contacts";
    const headers = {
        "Authorization": `Bearer ${token}`,
        "Content-Type": "application/json"
    };

    const searchResponse = await fetch(`${BASE_URL}/search`, {
        method: "POST",
        headers,
        body: JSON.stringify({
            filterGroups: [{
                filters: [{
                    propertyName: "email",
                    operator: "EQ",
                    value: userData.email
                }]
            }]
        })
    });

    const searchResult = await searchResponse.json();

    if (searchResult.total > 0) {
        const contactId = searchResult.results[0].id;
        await fetch(`${BASE_URL}/${contactId}`, {
            method: "PATCH",
            headers,
            body: JSON.stringify({
                properties: {
                    firstname: userData.given_name,
                    lastname: userData.family_name
                }
            })
        });
    }
}

async function deleteCrmContact(userData, token) {
    const BASE_URL = "https://api.hubapi.com/crm/v3/objects/contacts";
    const headers = {
        "Authorization": `Bearer ${token}`,
        "Content-Type": "application/json"
    };

    const searchResponse = await fetch(`${BASE_URL}/search`, {
        method: "POST",
        headers,
        body: JSON.stringify({
            filterGroups: [{
                filters: [{
                    propertyName: "email",
                    operator: "EQ",
                    value: userData.email
                }]
            }]
        })
    });

    const searchResult = await searchResponse.json();

    if (searchResult.total > 0) {
        const contactId = searchResult.results[0].id;
        await fetch(`${BASE_URL}/${contactId}`, {
            method: "DELETE",
            headers
        });
    }
}

// --- Fonction utilitaire Slack ---

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

    if (!response.ok) {
        console.error(`Slack notification failed: ${response.status}`);
    }
}

​

Gérer les échecs partiels

Lorsque votre Action fait appel à plusieurs systèmes externes, un appel peut réussir alors qu’un autre échoue. Envisagez les stratégies suivantes :

• Consigner et poursuivre. Encapsulez chaque appel externe dans un bloc try-catch afin qu’un échec dans un système n’empêche pas les autres de s’exécuter. Consignez l’erreur pour en assurer le suivi manuel.
• Réessayer avec des opérations idempotentes. Si l’Action génère une erreur, Auth0 réessaie l’événement. Assurez-vous que chaque appel externe est idempotent afin que les nouvelles tentatives ne créent pas d’enregistrements en double.
• Utiliser des coupe-circuits. Si un système externe échoue de façon répétée, envisagez d’interrompre les appels à ce système afin d’éviter des délais en cascade.

​

Stocker des clés API dans des secrets

1. Dans l’éditeur d’Action, sélectionnez Secrets (l’icône en forme de clé).
2. Ajoutez un secret nommé HUBSPOT_TOKEN avec comme valeur le jeton d’accès de votre application privée HubSpot.
3. Ajoutez un secret nommé SLACK_WEBHOOK_URL avec comme valeur votre Slack Incoming Webhook URL.

L’utilisation de secrets permet de garder les identifiants hors du code source de votre Action. Pour en savoir plus, consultez Action Secrets.

​

Enregistrer et déployer

Sélectionnez Save Draft, puis Deploy. L’Action est maintenant associée à votre Event Stream et s’exécute chaque fois qu’un événement auquel vous êtes abonné est déclenché.

​

Vérifier le pipeline

1. Dans votre IdP d’entreprise, assignez un utilisateur test à l’application connectée à Auth0.
2. Confirmez que l’utilisateur apparaît dans Auth0 sous User Management > Users.
3. Confirmez qu’un contact correspondant est créé dans HubSpot et qu’une notification est publiée dans Slack.
4. Mettez à jour le nom de l’utilisateur dans l’IdP et vérifiez que la modification se propage à la fois à Auth0 et à HubSpot.
5. Retirez l’utilisateur de l’application dans l’IdP. Confirmez que l’utilisateur est déprovisionné dans Auth0, que le contact dans HubSpot est supprimé et qu’une notification est publiée dans Slack.

Si les événements ne sont pas reçus, consultez les logs de livraison de l’Event Stream dans l’Auth0 Dashboard. Pour en savoir plus, consultez Event Testing, Observability, and Failure Recovery.

​

Étendre le modèle

L’architecture présentée dans ce guide n’est pas propre à HubSpot et à Slack. Vous pouvez appliquer le même modèle de diffusion à n’importe quelle combinaison de systèmes dotés d’API REST :

• CRM + gestion de tickets — créez un contact Salesforce et ouvrez un ticket Jira d’intégration.
• CRM + analytique — mettez à jour un contact HubSpot et envoyez une requête identify à Segment.
• Provisioning + notifications — envoyez une requête à un service interne de provisionnement et publiez un message dans Microsoft Teams.

Pour cibler différents systèmes, mettez à jour le gestionnaire d’Action avec les endpoints d’API et les méthodes d’authentification appropriés.

​

En savoir plus

• Corréler les changements d’identité avec des systèmes externes
• Catalogue d’événements
• Créer un Event Stream
• Pratiques exemplaires pour Events