Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Génération de liens d'action par e-mail

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Les applications mobiles doivent parfois interagir avec les utilisateurs et les inviter à effectuer certaines actions en envoyant des e-mails.

Les SDK Firebase Client permettent d'envoyer aux utilisateurs des e-mails contenant des liens qu'ils peuvent utiliser pour la réinitialisation des mots de passe, la vérification de l'adresse e-mail et la connexion par e-mail. Ces e-mails basés sur des modèles sont envoyés par Google et ont une personnalisation limitée.

Si vous souhaitez plutôt utiliser vos propres modèles d'e-mail et votre propre service d'envoi d'e-mails, cette page explique comment utiliser le SDK d'administration Firebase pour générer par programmation les liens d'action pour les flux ci-dessus, que vous pouvez inclure dans les e-mails destinés à vos utilisateurs.

Cela vient avec les avantages suivants :

  • Personnalisez les modèles d'e-mails. Cela inclut la possibilité d'ajouter de nouveaux styles et une image de marque personnalisée, de modifier le libellé et les logos, de s'adresser aux utilisateurs par leur prénom au lieu de leur nom complet, etc.
  • Appliquez différents modèles en fonction du contexte. Par exemple, si l'utilisateur vérifie son adresse e-mail pour s'abonner à une newsletter, le contexte peut devoir être fourni dans le contenu de l'e-mail. Un autre exemple est la connexion par lien par e-mail : dans un scénario, cela peut être déclenché par le même utilisateur ou sous la forme d'une invitation par un autre utilisateur. Le contexte devrait être inclus dans l'e-mail.
  • Localisez des modèles d'e-mails personnalisés.
  • Possibilité de générer le lien à partir d'un environnement de serveur sécurisé.
  • Possibilité de personnaliser la façon dont le lien doit être ouvert, via une application mobile ou un navigateur, et comment transmettre des informations d'état supplémentaires, etc.
  • Possibilité de personnaliser le domaine de lien dynamique utilisé pour les flux d'applications mobiles lors de la construction du lien d'action d'e-mail, et même de spécifier un domaine de lien dynamique différent en fonction du contexte ou de l'application mobile.

Initialiser ActionCodeSettings

Avant de pouvoir générer un lien d'action par e-mail, vous devrez peut-être initialiser une instance ActionCodeSettings .

ActionCodeSettings vous permet de transmettre un état supplémentaire via une URL de poursuite accessible après que l'utilisateur a cliqué sur le lien de l'e-mail. Cela permet également à l'utilisateur de revenir à l'application une fois l'action terminée. De plus, vous pouvez spécifier si vous souhaitez gérer le lien d'action de l'e-mail directement depuis une application mobile lors de son installation ou depuis un navigateur.

Pour les liens destinés à être ouverts via une application mobile, vous devez activer Firebase Dynamic Links et effectuer certaines tâches pour détecter ces liens à partir de votre application mobile. Reportez-vous aux instructions de configuration des liens dynamiques Firebase pour les actions par e-mail.

Pour initialiser une instance ActionCodeSettings , fournissez les données suivantes :

Paramètre Taper La description
url chaîne de caractères

Définit le lien (état/continuer l'URL) qui a différentes significations dans différents contextes :

  • Lorsque le lien est géré dans les widgets d'action Web, il s'agit du lien profond dans le paramètre de requête continueUrl .
  • Lorsque le lien est géré directement dans l'application, il s'agit du paramètre de requête continueUrl dans le lien profond du lien dynamique.
iOS ({bundleId : chaîne}|non défini) Définit l'ID de groupe. Cela essaiera d'ouvrir le lien dans une application Apple si elle est installée. L'application doit être enregistrée dans la console.
android ({packageName : string, installApp:boolean|undefined, minimumVersion : string|undefined}|undefined) Définit le nom du package Android. Cela essaiera d'ouvrir le lien dans une application Android si elle est installée. Si installApp est passé, il spécifie s'il faut installer l'application Android si l'appareil la prend en charge et si l'application n'est pas déjà installée. Si ce champ est fourni sans packageName , une erreur est renvoyée expliquant que le packageName doit être fourni conjointement avec ce champ. Si minimumVersion est spécifié et qu'une ancienne version de l'application est installée, l'utilisateur est redirigé vers le Play Store pour mettre à niveau l'application. L'application Android doit être enregistrée dans la console.
handleCodeInApp (booléen|non défini) Indique si le lien d'action par e-mail sera d'abord ouvert dans une application mobile ou un lien Web. Le défaut est faux. Lorsqu'il est défini sur true, le lien du code d'action sera envoyé sous forme de lien universel ou de lien d'application Android et sera ouvert par l'application si elle est installée. Dans le cas faux, le code sera d'abord envoyé au widget Web, puis sur continuer redirigera vers l'application si elle est installée.
dynamicLinkDomain (chaîne|indéfini) Définit le domaine (ou sous-domaine) de lien dynamique à utiliser pour le lien actuel s'il doit être ouvert à l'aide de Firebase Dynamic Links. Comme plusieurs domaines de liens dynamiques peuvent être configurés par projet, ce champ permet d'en choisir explicitement un. Si aucun n'est fourni, le domaine le plus ancien est utilisé par défaut.

L'exemple suivant illustre comment envoyer un lien de vérification d'e-mail qui s'ouvrira d'abord dans une application mobile en tant que lien dynamique Firebase (application Apple com.example.ios ou application Android com.example.android où l'application sera installée si elle n'est pas déjà installée et la version minimale est 12). Le lien profond contiendra la charge utile de l'URL de continuation https://www.example.com/checkout?cartId=1234 . Le domaine de lien dynamique utilisé est coolapp.page.link , qui doit être configuré pour être utilisé avec Firebase Dynamic Links.

Node.js

const actionCodeSettings = {
  // URL you want to redirect back to. The domain (www.example.com) for
  // this URL must be whitelisted in the Firebase Console.
  url: 'https://www.example.com/checkout?cartId=1234',
  // This must be true for email link sign-in.
  handleCodeInApp: true,
  iOS: {
    bundleId: 'com.example.ios',
  },
  android: {
    packageName: 'com.example.android',
    installApp: true,
    minimumVersion: '12',
  },
  // FDL custom domain.
  dynamicLinkDomain: 'coolapp.page.link',
};

Java

ActionCodeSettings actionCodeSettings = ActionCodeSettings.builder()
    .setUrl("https://www.example.com/checkout?cartId=1234")
    .setHandleCodeInApp(true)
    .setIosBundleId("com.example.ios")
    .setAndroidPackageName("com.example.android")
    .setAndroidInstallApp(true)
    .setAndroidMinimumVersion("12")
    .setDynamicLinkDomain("coolapp.page.link")
    .build();

Python

action_code_settings = auth.ActionCodeSettings(
    url='https://www.example.com/checkout?cartId=1234',
    handle_code_in_app=True,
    ios_bundle_id='com.example.ios',
    android_package_name='com.example.android',
    android_install_app=True,
    android_minimum_version='12',
    dynamic_link_domain='coolapp.page.link',
)

Aller

actionCodeSettings := &auth.ActionCodeSettings{
	URL:                   "https://www.example.com/checkout?cartId=1234",
	HandleCodeInApp:       true,
	IOSBundleID:           "com.example.ios",
	AndroidPackageName:    "com.example.android",
	AndroidInstallApp:     true,
	AndroidMinimumVersion: "12",
	DynamicLinkDomain:     "coolapp.page.link",
}

C#

var actionCodeSettings = new ActionCodeSettings()
{
    Url = "https://www.example.com/checkout?cartId=1234",
    HandleCodeInApp = true,
    IosBundleId = "com.example.ios",
    AndroidPackageName = "com.example.android",
    AndroidInstallApp = true,
    AndroidMinimumVersion = "12",
    DynamicLinkDomain = "coolapp.page.link",
};

Pour en savoir plus, consultez Passing State in Email Actions .

Pour générer un lien de réinitialisation de mot de passe, fournissez l'e-mail de l'utilisateur existant et un objet ActionCodeSettings facultatif. L'opération sera résolue avec le lien d'action par e-mail. L'email utilisé doit appartenir à un utilisateur existant.

Node.js

// Admin SDK API to generate the password reset link.
const userEmail = 'user@example.com';
getAuth()
  .generatePasswordResetLink(userEmail, actionCodeSettings)
  .then((link) => {
    // Construct password reset email template, embed the link and send
    // using custom SMTP server.
    return sendCustomPasswordResetEmail(userEmail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

Java

String email = "user@example.com";
try {
  String link = FirebaseAuth.getInstance().generatePasswordResetLink(
      email, actionCodeSettings);
  // Construct email verification template, embed the link and send
  // using custom SMTP server.
  sendCustomEmail(email, displayName, link);
} catch (FirebaseAuthException e) {
  System.out.println("Error generating email link: " + e.getMessage());
}

Python

email = 'user@example.com'
link = auth.generate_password_reset_link(email, action_code_settings)
# Construct password reset email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)

Aller

email := "user@example.com"
link, err := client.PasswordResetLinkWithSettings(ctx, email, actionCodeSettings)
if err != nil {
	log.Fatalf("error generating email link: %v\n", err)
}

// Construct password reset template, embed the link and send
// using custom SMTP server.
sendCustomEmail(email, displayName, link)

C#

var email = "user@example.com";
var link = await FirebaseAuth.DefaultInstance.GeneratePasswordResetLinkAsync(
    email, actionCodeSettings);
// Construct email verification template, embed the link and send
// using custom SMTP server.
SendCustomEmail(email, displayName, link);

Une fois le lien généré, il peut être inséré dans l'e-mail de réinitialisation du mot de passe personnalisé, puis envoyé par e-mail à l'utilisateur correspondant à l'aide d'un serveur SMTP personnalisé.

Si vous n'utilisez pas la page d'accueil de réinitialisation du mot de passe par défaut et que vous créez votre propre gestionnaire personnalisé, consultez Création de gestionnaires d'action de messagerie personnalisés .

Pour générer un lien de vérification d'e-mail, fournissez l'e-mail non vérifié de l'utilisateur existant et un objet ActionCodeSettings facultatif. L'opération sera résolue avec le lien d'action par e-mail. L'email utilisé doit appartenir à un utilisateur existant.

Node.js

// Admin SDK API to generate the email verification link.
const useremail = 'user@example.com';
getAuth()
  .generateEmailVerificationLink(useremail, actionCodeSettings)
  .then((link) => {
    // Construct email verification template, embed the link and send
    // using custom SMTP server.
    return sendCustomVerificationEmail(useremail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

Java

String email = "user@example.com";
try {
  String link = FirebaseAuth.getInstance().generateEmailVerificationLink(
      email, actionCodeSettings);
  // Construct email verification template, embed the link and send
  // using custom SMTP server.
  sendCustomEmail(email, displayName, link);
} catch (FirebaseAuthException e) {
  System.out.println("Error generating email link: " + e.getMessage());
}

Python

email = 'user@example.com'
link = auth.generate_email_verification_link(email, action_code_settings)
# Construct email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)

Aller

email := "user@example.com"
link, err := client.EmailVerificationLinkWithSettings(ctx, email, actionCodeSettings)
if err != nil {
	log.Fatalf("error generating email link: %v\n", err)
}

// Construct email verification template, embed the link and send
// using custom SMTP server.
sendCustomEmail(email, displayName, link)

C#

var email = "user@example.com";
var link = await FirebaseAuth.DefaultInstance.GenerateEmailVerificationLinkAsync(
    email, actionCodeSettings);
// Construct email verification template, embed the link and send
// using custom SMTP server.
SendCustomEmail(email, displayName, link);

Une fois le lien généré, il peut être inséré dans l'e-mail de vérification personnalisé, puis envoyé par e-mail à l'utilisateur correspondant à l'aide d'un serveur SMTP personnalisé.

Si vous n'utilisez pas la page d'accueil de vérification des e-mails par défaut et que vous créez votre propre gestionnaire personnalisé, consultez la section création de gestionnaires d'actions d'e-mail personnalisés .

Avant de pouvoir authentifier les utilisateurs avec la connexion par lien de messagerie, vous devez activer la connexion par lien de messagerie pour votre projet Firebase.

Pour générer un lien de connexion, fournissez l'e-mail de l'utilisateur et un objet ActionCodeSettings . L'objet ActionCodeSettings est requis dans ce cas pour fournir des informations sur l'endroit où renvoyer l'utilisateur après avoir cliqué sur le lien pour terminer la connexion. L'opération sera résolue avec le lien d'action par e-mail.

Contrairement à la réinitialisation du mot de passe et à la vérification des e-mails, l'e-mail utilisé ne doit pas nécessairement appartenir à un utilisateur existant, car cette opération peut être utilisée pour inscrire de nouveaux utilisateurs dans votre application via un lien e-mail.

Node.js

// Admin SDK API to generate the sign in with email link.
const useremail = 'user@example.com';
getAuth()
  .generateSignInWithEmailLink(useremail, actionCodeSettings)
  .then((link) => {
    // Construct sign-in with email link template, embed the link and
    // send using custom SMTP server.
    return sendSignInEmail(useremail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

Java

String email = "user@example.com";
try {
  String link = FirebaseAuth.getInstance().generateSignInWithEmailLink(
      email, actionCodeSettings);
  // Construct email verification template, embed the link and send
  // using custom SMTP server.
  sendCustomEmail(email, displayName, link);
} catch (FirebaseAuthException e) {
  System.out.println("Error generating email link: " + e.getMessage());
}

Python

email = 'user@example.com'
link = auth.generate_sign_in_with_email_link(email, action_code_settings)
# Construct email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)

Aller

email := "user@example.com"
link, err := client.EmailSignInLink(ctx, email, actionCodeSettings)
if err != nil {
	log.Fatalf("error generating email link: %v\n", err)
}

// Construct sign-in with email link template, embed the link and send
// using custom SMTP server.
sendCustomEmail(email, displayName, link)

C#

var email = "user@example.com";
var link = await FirebaseAuth.DefaultInstance.GenerateSignInWithEmailLinkAsync(
    email, actionCodeSettings);
// Construct email verification template, embed the link and send
// using custom SMTP server.
SendCustomEmail(email, displayName, link);

Une fois le lien généré, il peut être inséré dans l'e-mail de connexion personnalisé, puis envoyé par e-mail à l'utilisateur correspondant à l'aide d'un serveur SMTP personnalisé.

En savoir plus sur l'authentification des utilisateurs auprès de Firebase à l'aide de liens de messagerie . Cela aidera à fournir des informations sur la façon de terminer la connexion après que l'utilisateur a cliqué sur le lien et est redirigé vers l'application.