Intégration d’Actions avec plusieurs domaines personnalisés

Découvrez comment utiliser plusieurs domaines personnalisés avec Actions d’Auth0 pour mettre en place une logique d’authentification propre à chaque domaine.

Les Actions Auth0 vous permettent de personnaliser l’authentification à l’aide de code personnalisé. Lorsque vous utilisez plusieurs domaines personnalisés, vous pouvez accéder aux informations sur le domaine personnalisé dans vos Actions afin d’implémenter une logique propre au domaine, de diriger les utilisateurs vers des organisations, d’appliquer des politiques d’accès et de personnaliser les notifications.

​

Accès aux informations du domaine personnalisé

Les Actions permettent d’accéder aux informations du domaine personnalisé au moyen de l’objet event.custom_domain. Cet objet contient le nom de domaine ainsi que toutes les métadonnées configurées pour ce domaine.

​

Déclencheurs disponibles

L’objet event.custom_domain est disponible dans les déclencheurs d’Action suivants :

Déclencheur	Référence de l’objet d’événement
Échange d’identifiants	Objet d’événement
Fournisseur de courriel personnalisé	Objet d’événement
Fournisseur de téléphonie personnalisé	Objet d’événement
Après la connexion	Objet d’événement
Après l’inscription de l’utilisateur	Objet d’événement
Après le changement de mot de passe	Objet d’événement
Avant l’inscription de l’utilisateur	Objet d’événement
Après le défi de réinitialisation du mot de passe	Objet d’événement

L’objet event.custom_domain est uniquement disponible dans les déclencheurs où la requête provient d’un contexte de domaine personnalisé. Si aucun domaine personnalisé n’est utilisé, cette propriété aura la valeur undefined.

​

Structure de l’objet d’événement

Avec le domaine login.example.com configuré avec les métadonnées du domaine :

Clé	Valeur
allow_list	example1.com,example2.com

exports.onExecutePostLogin = async (event, api) => {
  console.log(event.custom_domain);
};

Afficherait dans la console :

{
  "domain": "login.example.com",
  "domain_metadata": {
    "allow_list": "example1.com,example2.com"
  }
}

​

Cas d’usage courants

​

Logique conditionnelle selon le domaine

Appliquez différentes règles selon qu’un domaine personnalisé ou un domaine canonique est utilisé :

exports.onExecutePostLogin = async (event, api) => {
  const domain = event.custom_domain?.domain;

  if (
    domain === undefined ||
    domain.includes('.auth0.com') || // Nuage public
    domain.includes('.auth0app.com') // Nuage privé
  ) {
    return api.access.deny('Please use the custom domain to log in.');
  }
};

​

Contrôle d’accès basé sur le domaine du courriel

Appliquez des politiques d’accès propres à chaque domaine de courriel à l’aide de métadonnées de domaine personnalisées :

const getEmailDomain = (email) => {
  if (!email || typeof email !== 'string') {
    return null;
  }

  const parts = email.split('@');
  
  // S'assurer qu'il y a exactement un '@' (ou du moins qu'un domaine existe)
  // gère les cas comme "invalid-email" ou "user@"
  if (parts.length < 2 || !parts[1]) {
    return null;
  }

  return parts[1].toLowerCase().trim();
}

exports.onExecutePreUserRegistration = async (event, api) => {
  const domain = event.custom_domain?.domain;

  if (domain === undefined) {
    return api.access.deny(
      'access_denied',
      `Access denied - Users cannot access without custom domain.`
    );
  }

  const email = event.user.email;
  
  if (email === undefined) {
    return api.access.deny(
      'access_denied',
      `Access denied - Users cannot access without email.`
    );
  }

  const domainAllowList = event.custom_domain?.domain_metadata?.allow_list?.split(',') || [];
  const emailDomain = getEmailDomain(email);

  if (domainAllowList.includes(emailDomain) === false) {
    return api.access.deny(
      'access_denied',
      `Access denied - Users from ${emailDomain} cannot access ${domain}.`
    );
  }
};

​

Contrôle d’accès fondé sur les métadonnées de l’application

Appliquez des politiques d’accès pour les groupes d’applications et de domaines à l’aide des métadonnées d’application et de domaine :

exports.onExecuteCredentialsExchange = async (event, api) => {
  const domain = event.custom_domain?.domain;
  
  if (
    domain === undefined ||
    domain.includes(event.tenant.id)
  ) {
    return; // Ignorer pour le domaine canonique
  }

  const applicationGroup = new Set(event.client.metadata?.domain_group?.split(',') || []);
  const domainGroup = event.custom_domain?.domain_metadata?.domain_group?.split(',') || [];
  const intersection = domainGroup.filter(x => applicationGroup.has(x));

  if (intersection.length === 0) {
    return api.access.deny(
      'invalid_request',
      `Access denied - Cannot get access from application ${event.client.name} and ${domain}.`
    );
  }
};

​

Contrôle d’accès basé sur les métadonnées de la connexion

Appliquez des politiques d’accès aux groupes de connexions et de domaines à l’aide des métadonnées de connexion et de domaine :

exports.onExecutePostLogin = async (event, api) => {
  const domain = event.custom_domain?.domain;

  if (domain === undefined) {
    return api.access.deny(
      `Access denied - Users cannot access without custom domain.`
    );
  }

  const connectionGroup = new Set(event.connection.metadata?.domain_group?.split(',') || []);
  const domainGroup = event.custom_domain?.domain_metadata?.domain_group?.split(',') || [];
  const intersection = domainGroup.filter(x => connectionGroup.has(x));

  if (intersection.length === 0) {
    return api.access.deny(
      `Access denied - Users cannot access connection ${event.connection.name} from ${domain}.`
    );
  }
};

​

Contrôle d’accès basé sur les métadonnées de l’organisation

Appliquez des politiques d’accès aux groupes d’organisation et de domaine à l’aide des métadonnées de l’organisation et du domaine :

exports.onExecutePostLogin = async (event, api) => {
  const organization = event.organization;

  if (organization === undefined) {
    return; // Ignorer pour l'authentification hors organisation
  }

  const domain = event.custom_domain?.domain;

  if (domain === undefined) {
    return api.access.deny(
      `Access denied - Users cannot access without custom domain.`
    );
  }

  const organizationGroup = new Set(organization.metadata?.domain_group?.split(',') || []);
  const domainGroup = event.custom_domain?.domain_metadata?.domain_group?.split(',') || [];  
  const intersection = domainGroup.filter(x => organizationGroup.has(x));

  if (intersection.length === 0) {
    return api.access.deny(
      `Access denied - Users cannot access organization ${organization.name} from ${domain}.`
    );
  }
};

​

Requêtes selon la région

Faites des requêtes à des services externes propres à une région en fonction des métadonnées du domaine personnalisé :

exports.onExecuteCustomEmailProvider = async (event, api) => {
  const regionServiceEndpoint = event.custom_domain?.domain_metadata?.region_service_endpoint;

  if (regionServiceEndpoint === undefined) {
    return api.notification.drop(`Missing regional service endpoint configuration at custom domain.`);
  }

  const notification = event.notification;
  const messageBody = {
    body: notification.html
  };

  try {
    await fetch(regionServiceEndpoint, {
      method: 'POST',
      headers: {
        'X-API-Key': event.secrets.API_KEY,
      },
      body: JSON.stringify(messageBody),
    });
  } catch (err) {
    api.notification.drop('External service failure');
  }
};

​

En savoir plus

​

Documentation des Actions

• Présentation des Actions Auth0
• Explorer les déclencheurs d’Action
• Limites des Actions

​

Références des objets d’événement

• Objet d’événement Post-Login
• Objet d’événement Pre-User Registration
• Objet d’événement du fournisseur de courriel personnalisé
• Objet d’événement du fournisseur de téléphonie personnalisé

​

Sujets connexes

• Domaines personnalisés multiples
• Organisations
• Fournisseurs de courriel personnalisés