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

Découvrez comment utiliser plusieurs domaines personnalisés avec Auth0 Actions pour créer une logique d’authentification adaptée à chaque domaine.

Les Auth0 Actions vous permettent de personnaliser l’authentification à l’aide de code personnalisé. Lorsque vous utilisez plusieurs domaines personnalisés, vous pouvez accéder aux renseignements sur le domaine personnalisé dans vos Actions afin de mettre en œuvre 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 renseignements sur le domaine personnalisé

Actions permettent d’accéder aux renseignements sur le domaine personnalisé par l’intermédiaire 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 des Actions suivants :

Déclencheur	Référence de l’objet Event
Credentials Exchange	Objet Event
Custom Email Provider	Objet Event
Custom Phone Provider	Objet Event
Post Login	Objet Event
Post User Registration	Objet Event
Post Password Change	Objet Event
Pre User Registration	Objet Event
Reset Password Post Challenge	Objet Event

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

​

Structure de l’objet Event

En utilisant 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’utilisation courants

​

Logique conditionnelle par domaine

Appliquez différentes règles selon que vous utilisez un domaine personnalisé ou un domaine canonique :

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 selon le domaine du courriel

Appliquez des politiques d’accès selon le domaine du courriel à l’aide des métadonnées du domaine personnalisé :

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 basé sur les métadonnées de l’application

Appliquez les politiques d’accès des 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 connexion

Appliquez les politiques d’accès pour les 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 fondé sur les métadonnées de l’organisation

Faites appliquer les politiques d’accès des 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 par région

Envoyez 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');
  }
};

​

Pour en savoir plus

​

Documentation des Actions

• Aperçu des Auth0 Actions
• Explorer les déclencheurs des Actions
• Limitations des Actions

​

Références des objets Event

• Objet Event Post-Login
• Objet Event Pre-User Registration
• Objet Event Custom Email Provider
• Objet Event Custom Phone Provider

​

Sujets connexes

• Multiple Custom Domains
• Organizations
• Fournisseurs de courriels personnalisés