Comment Envoyer des Emails dans Laravel : Guide Complet SMTP & API

On août 05, 2024
21min read
Aleksandr Varnin Full Stack Developer @ Railsware
Ivan Djuric, an author at Mailtrap
Ivan Djuric Technical Content Writer @Mailtrap
Sending emails in laravel
Table of Contents

Dans cet article, je vais vous montrer comment envoyer des emails dans Laravel étape par étape en utilisant Mailtrap et en mettant l’accent sur la délivrabilité.

En tant que développeur Laravel, vous avez peut-être entendu parler de Mailtrap comme étant exclusivement une solution de test d’emails dans la documentation officielle de Laravel. Cependant, cette plateforme offre également l’Email API/SMTP.

Les processus et extraits de code que je vais vous montrer dans cet article sont compatibles avec Laravel 9.x et versions supérieures.

Configuration du service de messagerie Laravel avant l’envoi d’emails

Laravel dispose de ses propres services de messagerie, qui permettent l’envoi d’emails via des services locaux ou basés sur le cloud.

Par exemple, la combinaison de Laravel et Symfony Mailer offre aux utilisateurs une gamme de pilotes pour envoyer des emails via SMTP, des services de messagerie tiers, et le MTA de Sendmail.

Bien que vous puissiez techniquement utiliser sendmail pour envoyer des emails depuis votre application web, vos emails risquent d’être catégorisés comme du spam.

Vous pouvez également envoyer des emails dans Laravel sans utiliser de service SMTP ou API externe en utilisant le pilote de log, mais cela n’enverra pas vos emails. Au lieu de cela, il écrira tous les emails dans les fichiers de votre application.

Les autres fonctionnalités notables des services de messagerie de Laravel incluent :

  • Mise en file d’attente des emails.
  • Création d’email en texte brut et HTML.
  • Ajout de pièces jointes dans différents formats et types MIME, ainsi que de données raw.
  • Inclusion de pièces jointes en ligne et intégration de données raw dans les modèles d’email.
  • Prévisualisation des messages dans le navigateur.
  • Supporte Markdown (dans plusieurs frameworks) – création de beaux modèles en incluant facilement des boutons, tableaux ou panneaux.
  • Système de modèles – utilisation de divers modèles et configuration des vues.
  • Méthodes de localisation – définition de la langue souhaitée pour un utilisateur spécifique.
  • Envoi d’emails en développement local – évite l’envoi de tests d’emails vers de vraies boîtes de réception.

Génération et écriture des emails

Dans Laravel, le fichier config.mail.php sera l’outil principal que nous utiliserons pour configurer les services de messagerie. Il contient une section mailers, qui a une entrée de configuration type pour chaque grand transporteur/pilote d’email pris en charge par Laravel.

Par défaut, Laravel choisit le service à utiliser en fonction de la configuration de ce fichier. La configuration nous permet de choisir différents services de messagerie pour différents types d’emails.

De plus, Laravel utilise une classe “mailable” pour représenter différents types d’emails. Ces classes sont stockées dans le répertoire app/Mail, mais vous ne les verrez pas directement dans votre projet. Elles seront générées lorsque vous créerez votre première classe mailable.

Pour créer une classe mailable, j’ai utilisé cette commande Artisan (incluse dans Laravel) :

php artisan make:mail MailableName

Après avoir créé une classe mailable, j’ai pu voir son contenu et configurer la classe elle-même. Pour cela, j’ai utilisé les méthodes du tableau suivant :

MéthodeExplication
EnvelopeRenvoie l’objet Illuminate\Mail\Mailables\Envelope, qui définit le sujet et les destinataires.
ContentRenvoie l’objet Illuminate\Mail\Mailables\Content, qui définit le modèle Blade utilisé pour générer le contenu du message.
AttachmentsRenvoie un tableau de pièces jointes.

Configuration de l’expéditeur

Maintenant, nous devons spécifier l’adresse email et le nom de l’expéditeur ou du from. Pour cela, nous pouvons soit :

  • Spécifier l’expéditeur dans l’objet Enveloppe du message, comme ceci :
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Envelope;
 
/**
* Obtenir l'enveloppe du message.
*
* @return \Illuminate\Mail\Mailables\Envelope
*/
public function envelope()
{
   return new Envelope(
       from: new Address('exemple@exemple.com', 'Expéditeur de test'),
       subject: 'Email de test',
   );
}
  • Spécifier l’expéditeur dans config/mail.php avec une adresse from globale, comme ceci :
'from' => ['address' => 'exemple@exemple.com', 'name' => 'Nom de l\'App']

Astuce Pro : Vous devriez utiliser l’adresse from globale si vous prévoyez de l’utiliser dans tous les emails envoyés par votre application. J’ai trouvé cela très pratique car cela m’a évité d’avoir à appeler la méthode from dans chacune de mes classes mailable. De plus, cela m’a servi d’adresse from par défaut, car je n’ai pas spécifié d’autre adresse.

Envoyer un email dans Laravel en utilisant SMTP

Maintenant que vous avez configuré le service de messagerie Laravel, je vais vous montrer comment configurer l’Email API/SMTP de Mailtrap comme fournisseur de service SMTP dans votre application/projet, puis je vous montrerai comment j’ai créé des classes mailable et effectué des tests.

Étape 1. Utiliser les informations d’identification SMTP de Mailtrap pour l’intégration avec votre application

La première chose que j’ai faite a été d’utiliser les informations d’identification de serveur SMTP fournies par l’Email API/SMTP de Mailtrap dans le fichier .env de mon application web.

Pour ce faire, il vous suffit de créer un compte Mailtrap, de vous connecter et de naviguer jusqu’à Sending Domains. Là, vous devez ajouter et vérifier votre domaine, ce qui ne prend que quelques secondes.

Si vous avez une mémoire visuelle, Mailtrap vous propose une vidéo facile à suivre.

Une fois votre domaine vérifié, Mailtrap vous redirigera vers la page où vous pourrez copier les informations d’identification SMTP et les coller facilement dans votre projet, application ou service de messagerie.

Note : Nous utiliserons le Stream Transactionnel pour ce chapitre, et je vous montrerai comment vous pouvez utiliser le Bulk Stream plus tard dans l’article.

Et voici à quoi devraient ressembler vos informations d’identification SMTP une fois que vous les avez intégrées dans votre code Laravel :

// .env file

MAIL_MAILER=smtp
MAIL_HOST=live.smtp.mailtrap.io
MAIL_PORT=587
MAIL_USERNAME=//votre nom d'utilisateur
MAIL_PASSWORD=//votre mot de passe
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=de@exemple.com
MAIL_FROM_NAME=//nom de votre application

Étape 2. Vérifier votre configuration SMTP

Une fois les informations d’identification ajoutées et un email de test envoyé depuis mon projet Laravel, Mailtrap vérifie ma configuration SMTP.

Voici ce que vous devriez recevoir comme réponse si votre email de test a été envoyé avec succès :

  • “250 2.0.0 Ok: queued as …”

Ensuite, cliquez simplement sur « Verify Setup », ce qui lancera le processus de vérification.

Étape 3. Activer les paramètres de suivi de Mailtrap (optionnel)

Cette étape est optionnelle, mais je la recommande vivement car elle me permet de surveiller la performance de mes emails.

En effet, Mailtrap vous fournit des analyses détaillées grâce auxquelles vous pouvez surveiller vos ouvertures, clics, rebonds, et plus encore.

Voici ce que je vois lorsque j’ouvre mes statistiques :

Et voici un aperçu des statistiques :

Étape 4. Créer des classes mailables

Vous vous souvenez de ces classes mailables dont je vous ai parlé précédemment ? Il est temps de les créer avec la commande suivante :

php artisan make:mail MyTestEmail

Après avoir exécuté cette commande, vous devriez voir la classe MyTestEmail sous “app/mailMyTestEmail.php“.

Mytestemail class under app/mailMyTestEmail.php

Voici le code de la classe pour plus de facilité :

<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;

class MyTestEmail extends Mailable
{
    use Queueable, SerializesModels;

    /**
     * Créer une nouvelle instance de message.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }

    /**
     * Obtenir l'enveloppe du message.
     *
     * @return \Illuminate\Mail\Mailables\Envelope
     */

    public function envelope()
    {
        return new Envelope(
            subject: 'Mon Email de Test',
        );
    }
 /**
     * Obtenir la définition du contenu du message.
     *
     * @return \Illuminate\Mail\Mailables\Content
     */

    public function content()
    {
        return new Content(
            view: 'view.name',
        );
    }

    /**
     * Obtenir les pièces jointes du message.
     *
     * @return array
     */
    public function attachments()
    {
        return [];
    }
}

Remarquez-vous quelque chose d’intéressant ? C’est exact, la méthode content() renvoie une vue. Allons donc dans le répertoire resources/views et créons un nouveau dossier avec un fichier blade.php dedans.

Prêt à enfin écrire du texte ? Vous pouvez le faire dans le fichier blade.php, de cette manière :

Maintenant, revenons à la méthode content() et remplaçons le nom de la vue qu’elle renvoie par le nom de celle que nous venons de créer.

Vous pouvez également rendre les choses un peu plus dynamiques en faisant en sorte que votre fichier template/blade.php d’email inclue le nom du destinataire en utilisant l’attribut with pour passer le nom.

Regardez.

<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;

class MyTestEmail extends Mailable
{
    use Queueable, SerializesModels;

    /**
     * Créer une nouvelle instance de message.
     *
     * @return void
     */
    public function __construct(private $name)
    {
        //
    }

    /**
     * Obtenir l'enveloppe du message.
     *
     * @return \Illuminate\Mail\Mailables\Envelope
     */
    public function envelope()
    {
        return new Envelope(
            subject: 'Mon Email de Test',
        );
    }

    /**
     * Obtenir la définition du contenu du message.
     *
     * @return \Illuminate\Mail\Mailables\Content
     */
    public function content()
    {
        return new Content(
            view: 'mail.test-email',
            with: ['name' => $this->name],
        );
    }
}

Pour que cela fonctionne, j’ai dû apporter un petit changement dans le fichier de vue test-email.blade.php. Cela lui permet d’accepter la variable $name.

// resources/views/mail/test-email.blade.php

Salut {{$name}}, 
Votre application Laravel peut-elle envoyer des emails ? 😉 
Mailtrap

Et enfin, créons une route dans le fichier routes/web.php avec ce code :

<?php

use Illuminate\Support\Facades\Route;
use App\Mail\MyTestEmail;
use Illuminate\Support\Facades\Mail;

Route::get('/testroute', function() {
    $name = "Drôle de Développeur";

    // L'envoi de l'email est effectué en utilisant la méthode “to” sur la façade Mail
    Mail::to('destinatairedetest@gmail.com'')->send(new MyTestEmail($name));
});

Voici à quoi le fichier devrait ressembler:

Le moment de vérité est arrivé. J’ai testé le tout en exécutant la commande php artisan serve et en allant sur mon navigateur, où j’ai collé la route que j’ai créée. Dans mon cas, il s’agissait de localhost:8000/testroute.

Si tout fonctionne, votre email devrait atterrir dans la boîte de réception de l’adresse “to” que vous avez spécifiée.

Envoi d’email HTML

Pour des paramètres de personnalisation avancés des emails HTML dans Laravel, consultez notre article dédié.

Envoyer des emails accrocheurs dans Laravel est assez simple. Il vous suffit d’ajouter du code HTML à votre fichier de vue Blade. Si vous vous souvenez, nous avons utilisé test-email.blade.php dans ce guide.

Voici un extrait de code que vous pouvez utiliser pour envoyer un message HTML basique :

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">

    <style>
        p {
            font-size: 12px;
        }

        .signature {
            font-style: italic;
        }
    </style>
</head>
<body>
<div>
    <p>Salut {{ $name }},</p>
    <p>Votre application Laravel peut-elle envoyer des emails ? 😉 </p>
    <p class="signature">Mailtrap</p>
</div>
</body>
</html>
Envoyer des Emails avec Mailtrap Gratuitement

Envoi d’emails à plusieurs destinataires

Pour envoyer des emails à plusieurs personnes dans Laravel, j’ai utilisé le code suivant :

foreach (['Premier Développeur' => 'premier-destinataire@gmail.com', 'Deuxième Développeur' => 'deuxieme-destinataire@gmail.com'] as $name => $recipient) {
    Mail::to($recipient)->send(new MyTestEmail($name));
}

Ce code itère sur un tableau de destinataires. Il recrée également l’instance mailable à chaque fois, ce qui est super utile car cela empêche l’envoi d’un nouvel email à chaque destinataire précédent à chaque itération de la boucle. Imaginez le casse-tête. 🤕

« Mais comment envoyer des emails à un seul destinataire tout en mettant certains en cc et d’autres en bcc ? », vous vous demandez peut-être. Suivez simplement cet exemple dans la classe MyTestEmail :

return new Envelope(
    subject: 'Mon Email de Test',
    cc: ['destinatairedetest-cc@gmail.com'],
    bcc: ['destinatairedetest-bcc@gmail.com']
);

Envoyer un email avec des pièces jointes

Pour ajouter des pièces jointes à mes emails dans Laravel, j’ai simplement modifié la méthode attachments dans l’exemple de code pour envoyer des emails que je vous ai montré plus tôt.

Je les ai d’abord créés dans la classe MyTestEmail :

<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Queue\SerializesModels;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Attachment;
use Illuminate\Contracts\Queue\ShouldQueue;

class MyTestEmail extends Mailable
{
    use Queueable, SerializesModels;

    /**
     * Créer une nouvelle instance de message.
     *
     * @return void
     */
    public function __construct(private $name, public $attachedFile){ }

    /**
     * Obtenir l'enveloppe du message.
     *
     * @return \Illuminate\Mail\Mailables\Envelope
     */
    public function envelope()
    {
        return new Envelope(
            subject: 'Mon Email de Test',
        );
    }

    /**
     * Obtenir la définition du contenu du message.
     *
     * @return \Illuminate\Mail\Mailables\Content
     */
    public function content()
    {
        return new Content(
            view: 'mail.test-email',
            with: ['name' => $this->name],
        );
    }

    /**
     * Obtenir les pièces jointes du message.
     *
     * @return array
     */
    public function attachments()
    {
        return [
            Attachment::fromPath($this->attachedFile),
        ];

    }
}

Ensuite, j’ai apporté quelques modifications dans le code testroute sous routes/web.php :

<?php

use Illuminate\Support\Facades\Route;
use App\Mail\MyTestEmail;

Route::get('/testroute', function () {

    $filePath = public_path('favicon.ico');

    $name = "Drôle de Développeur";

    Mail::to('destinatairedetest@gmail.com'')->send(new MyTestEmail($name, $filePath));
});

Et c’est à peu près tout. Si vous avez utilisé ce code, votre email devrait maintenant contenir une pièce jointe ICO nommée favicon.ico, comme vous pouvez le voir dans l’extrait ci-dessus.

Envoi d’emails avec des images intégrées

Pour envoyer un email avec une image intégrée dans Laravel, j’ai utilisé la méthode embed dans le modèle Blade. La méthode embed vous permet de joindre des images directement au contenu de votre email, qui seront affichées en ligne.

Tout d’abord, assurez-vous que votre classe mailable (MyTestEmail dans cet exemple) transmette les données nécessaires à la vue. Il n’y a rien de spécifique à changer dans la classe pour l’image.

Dans votre modèle d’email Blade, utilisez la méthode embed pour inclure l’image. Supposons que vous ayez une image située dans public/images/logo.png.

// resources/views/mail/test-email.blade.php

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <div>
        <p>Salut {{$name}},</p>
        <p>Votre application Laravel peut-elle envoyer des emails ? 😉</p>
        <img src="{{ $message->embed(public_path('images/logo.png')) }}" alt="Logo">
    </div>
</body>
</html>

Comme vous pouvez le voir, j’ai essentiellement ajouté cette ligne de code :

<img src="{{ $message->embed(public_path('images/logo.png')) }}" alt="Logo">

Elle intègre l’image située dans public/images/logo.png dans l’email, et la méthode embed renvoie une URL qui pointe vers l’image intégrée. L’image renvoyée est ensuite utilisée comme attribut src de la balise \, affichant l’image en ligne dans l’email.

Mise en file d’attente des emails pour l’envoi asynchrone

Pour l’envoi asynchrone des emails, j’ai utilisé le système de file d’attente ShouldQueue de Laravel.

Donc, assurez-vous d’abord que votre classe mailable implémente l’interface ShouldQueue et utilise le trait Queueable :

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;

class MyTestEmail extends Mailable implements ShouldQueue
{
    use Queueable, SerializesModels;
    // Le reste de votre classe...
}

Ensuite, configurez votre pilote de file d’attente dans le fichier .env en définissant QUEUE_CONNECTION à un pilote de file d’attente (par exemple, database, redis, sqs, etc.).

Enfin, lorsque vous envoyez un email avec la commande suivante, Laravel le mettra automatiquement en file d’attente si la classe mailable implémente ShouldQueue :

Mail::to('destinatairedetest@exemple.com')->send(new MyTestEmail($name));

Note : Pour démarrer le traitement des jobs en file d’attente, vous pouvez exécuter la commande php artisan queue:work dans votre terminal.

Envoi d’emails en masse dans Laravel

Vous vous souvenez des informations d’identification SMTP du Bulk Stream de Mailtrap que j’ai mentionnées plus tôt ? Eh bien, nous allons les utiliser pour envoyer, comme vous l’avez peut-être deviné, des emails en masse.

Tout d’abord, connectez-vous à votre compte Mailtrap et naviguez vers l’onglet SMTP/API Settings. Là, vous trouverez les informations d’identification du Bulk Stream sur votre droite.

Ensuite, ouvrez votre fichier .env et ajoutez ces informations d’identification. Le fichier de configuration devrait ressembler à ceci :

MAIL_MAILER=smtp
MAIL_HOST=bulk.smtp.mailtrap.io
MAIL_PORT=587
MAIL_USERNAME=votre_nom_d_utilisateur_mailtrap_bulk
MAIL_PASSWORD=votre_mot_de_passe_mailtrap_bulk
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=de@exemple.com
MAIL_FROM_NAME="Nom de Votre Application"
Remplacez votre_nom_d_utilisateur_mailtrap_bulk et votre_mot_de_passe_mailtrap_bulk par vos informations d'identification SMTP Mailtrap pour le Bulk Stream.

Maintenant, si vous ne l’avez pas déjà fait, vous devez générer une classe Mailable que vous utiliserez pour envoyer des emails. Vous pouvez la personnaliser pour qu’elle corresponde aux emails que vous prévoyez d’envoyer en masse, et voici à quoi elle devrait ressembler :

php artisan make:mail BulkEmail

Une fois que vous avez généré votre classe mailable BulkEmail, définissez les propriétés et méthodes qui configurent le contenu de l’email.

Vous pouvez transférer des données à votre classe mailable via son constructeur et utiliser ces données dans les vues de vos email.

Enfin, j’ai parcouru mes destinataires et envoyé des emails individuellement avec la connexion SMTP configurée pour une utilisation en masse.

Voici un exemple :

use App\Mail\BulkEmail;
use Illuminate\Support\Facades\Mail;

$users = User::all(); // Exemple : Sélectionner tous les utilisateurs auxquels vous voulez envoyer un email

foreach ($users as $user) {
    Mail::to($user->email)->send(new BulkEmail($data));
}

Cependant, il y a quelques points à garder en tête pour améliorer votre évolutivité et vos performances :

  • Limitation de débit et délais – Envisagez de limiter les taux ou d’implémenter des délais entre les emails si vous envoyez à un grand nombre de destinataires.
  • Chunking – Pour les listes très larges, la méthode chunk de Laravel peut vous aider à traiter les utilisateurs par petits groupes.
    • Par exemple :
User::chunk(200, function ($users) use ($data) {
    foreach ($users as $user) {
        Mail::to($user->email)->queue(new BulkEmail($data));
    }
});
  • Jobs en file d’attente – En dispatchant un job pour chaque email, Laravel peut mettre en file d’attente les emails et les envoyer en arrière-plan, libérant ainsi votre application pour traiter d’autres requêtes.
    • Par exemple :
class SendBulkEmailJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $user;
    protected $data;

    public function __construct($user, $data)
    {
        $this->user = $user;
        $this->data = $data;
    }

    public function handle()
    {
        Mail::to($this->user->email)->send(new BulkEmail($this->data));
    }
}

// Dispatching the job for each user
foreach ($users as $user) {
    SendBulkEmailJob::dispatch($user, $data)->onQueue('emails');
}

Enfin, gardez un œil sur les logs de votre application et les tableaux de bord de Mailtrap pour vous assurer que vos emails soient traités et envoyés comme prévu.

Envoyer un email dans Laravel en utilisant l’API

Si vous voulez automatiser votre processus d’envoi, l’Email API/SMTP de Mailtrap API est la solution que vous recherchez.

L’intégration de l’Email API de Mailtrap dans votre application Laravel est super facile car vous pouvez utiliser le SDK PHP officiel et la documentation pour le bridge framework Laravel. Avec ceux-ci, vous n’aurez pas à écrire manuellement le code d’intégration pour votre projet, rendant l’intégration beaucoup plus facile et efficace. De plus, la bibliothèque Mailtrap est entièrement compatible avec Laravel 9.x et versions supérieures.

Pour commencer, suivez simplement ces étapes :

  • Créez un compte Mailtrap et connectez-vous.
  • Ajoutez et vérifiez votre domaine.
  • Installez le client PHP Mailtrap et les dépendances à l’aide de Composer.
composer require railsware/mailtrap-php symfony/http-client nyholm/psr7
  • Ajoutez le transport Mailtrap dans votre fichier config.mail.php.
<?php

return [
    /*
    |--------------------------------------------------------------------------
    | Configurations des Mailers
    |--------------------------------------------------------------------------
    */
    'mailers' => [
    
            // début du transport mailtrap
            'mailtrap' => [
                'transport' => 'mailtrap'
            ],
            // fin du transport mailtrap
    
    ]
];
  • Ajoutez vos informations d’identification Mailtrap à votre fichier .env de Laravel (assurez-vous de sélectionner le Stream Transactionnel ; nous utiliserons le Bulk Stream plus tard).
MAIL_MAILER="mailtrap"
MAILTRAP_HOST="send.api.mailtrap.io"
MAILTRAP_API_KEY="VOTRE_CLE_API_ICI"
MAIL_FROM_ADDRESS=”nom@domaine_enregistré.com”
  • Créez une classe mailable pour envoyer un email.
php artisan make:mail WelcomeMail
  • Configurez la classe app/Mail/WelcomeMail.php en suivant cet exemple.
<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Mail\Attachment;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Headers;
use Illuminate\Queue\SerializesModels;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;

class WelcomeMail extends Mailable
{
    use Queueable, SerializesModels;

    private string $name;

    /**
     * Créer une nouvelle instance de message.
     */
    public function __construct(string $name)
    {
        $this->name = $name;
    }

    /**
     * Obtenir l'enveloppe du message.
     */
    public function envelope(): Envelope
    {
        return new Envelope(
            from: new Address('jeffrey@exemple.com', 'Jeffrey Way'),
            replyTo: [
                      new Address('taylor@exemple.com', 'Taylor Otwell'),
                  ],
            subject: 'Email de Bienvenue',
            using: [
                      function (Email $email) {
                          // En-têtes
                          $email->getHeaders()
                              ->addTextHeader('X-Message-Source', 'exemple.com')
                              ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client'))
                          ;

                          // Variables personnalisées
                          $email->getHeaders()
                              ->add(new CustomVariableHeader('user_id', '45982'))
                              ->add(new CustomVariableHeader('batch_id', 'PSJ-12'))
                          ;

                          // Catégorie (doit être unique)
                          $email->getHeaders()
                              ->add(new CategoryHeader('Test d\'intégration'))
                          ;
                      },
                  ]
        );
    }

    /**
     * Obtenir la définition du contenu du message.
     */
    public function content(): Content
    {
        return new Content(
            view: 'mail.welcome-email',
            with: ['name' => $this->name],
        );
    }

    /**
     * Obtenir les pièces jointes du message.
     *
     * @return array<int, \Illuminate\Mail\Mailables\Attachment>
     */
    public function attachments(): array
    {
        return [
           Attachment::fromPath('https://mailtrap.io/wp-content/uploads/2021/04/mailtrap-new-logo.svg')
                ->as('logo.svg')
                ->withMime('image/svg+xml'),
        ];
    }

    /**
     * Obtenir les en-têtes du message.
     */
    public function headers(): Headers
    {
        return new Headers(
            'id-du-message-personnalisé@exemple.com',
            ['message-précédent@exemple.com'],
            [
                'X-Custom-Header' => 'Valeur Personnalisée',
            ],
        );
    }
}
  • Créez un modèle d’email sous resources/views/mail/welcome-email.blade.php.
Salut, {{$name}} et bienvenue 😉

<br>
Drôle de Développeur
  • Ajoutez le routeur CLI au fichier app/routes/console.php.
<?php

use App\Mail\WelcomeMail;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\Mail;

/*
|--------------------------------------------------------------------------
| Routes Console
|--------------------------------------------------------------------------
|
*/

Artisan::command('send-welcome-mail', function () {
    Mail::to('destinatairedetest@gmail.com')->send(new WelcomeMail("Jon"));
    // Vous pouvez également utiliser un mailer spécifique si votre mailer par défaut n'est pas "mailtrap" mais que vous souhaitez l'utiliser pour les mails de bienvenue
    // Mail::mailer('mailtrap')->to('destinatairedetest@gmail.com')->send(new WelcomeMail("Jon"));
})->purpose('Envoyer un email de bienvenue');
  • Appelez la commande CLI pour envoyer votre email.
php artisan send-welcome-mail

Une fois ces étapes terminées, vous devriez pouvoir utiliser l’Email API de Mailtrap pour envoyer des emails transactionnels sans obtenir d’erreurs.

De plus, vous vous souvenez des paramètres de suivi que j’ai mentionnés plus tôt ? Vous pouvez les activer si vous utilisez également l’Email APIl.

Envoi d’un email HTML

Pour envoyer un email HTML dans Laravel, il vous suffit d’ajouter du code HTML à votre fichier de vue Blade, qui se trouve être test-email.blade.phpdans le cas de ce tutoriel.

Et voici à quoi ressemble l’email en texte brut sous forme HTML :

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">

    <style>
        p {
            font-size: 12px;
        }

        .signature {
            font-style: italic;
        }
    </style>
</head>
<body>
<div>
    <p>Salut {{ $name }},</p>
    <p>Votre application Laravel peut-elle envoyer des emails ? 😉 </p>
    <p class="signature">Mailtrap</p>
</div>
</body>
</html>
Envoyer des Emails avec Mailtrap Gratuitement

Envoi d’emails à plusieurs destinataires

Selon la documentation de Laravel, vous pouvez envoyer un email à plusieurs destinataires avec le code suivant :

foreach (['Premier Développeur' => 'premier-destinataire@gmail.com', 'Deuxième Développeur' => ‘deuxieme-destinataire@gmail.com'] as $name => $recipient) {
    Mail::to($recipient)->send(new MyTestEmail($name));
}

Vous pouvez également envoyer votre email à un seul destinataire et ajouter “cc” et “bcc” avec le code suivant dans la classe MyTestEmail :

return new Envelope(
    subject: 'Mon Email de Test',
    cc: ['destinatairedetest-cc@gmail.com'],
    bcc: ['destinatairedetest-bcc@gmail.com']
);

Envoyer un email avec des pièces jointes

De même qu’avec SMTP, j’ai modifié la méthode attachments pour ajouter des pièces jointes à mes emails.

Tout d’abord, je les ai créées dans la classe MyTestEmail :

<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Queue\SerializesModels;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Attachment;
use Illuminate\Contracts\Queue\ShouldQueue;

class MyTestEmail extends Mailable
{
    use Queueable, SerializesModels;

    /**
     * Créer une nouvelle instance de message.
     *
     * @return void
     */
    public function __construct(private $name, public $attachedFile){ }

    /**
     * Obtenir l'enveloppe du message.
     *
     * @return \Illuminate\Mail\Mailables\Envelope
     */
    public function envelope()
    {
        return new Envelope(
            subject: 'Mon Email de Test',
        );
    }

    /**
     * Obtenir la définition du contenu du message.
     *
     * @return \Illuminate\Mail\Mailables\Content
     */
    public function content()
    {
        return new Content(
            view: 'mail.test-email',
            with: ['name' => $this->name],
        );
    }

    /**
     * Obtenir les pièces jointes du message.
     *
     * @return array
     */
    public function attachments()
    {
        return [
            Attachment::fromPath($this->attachedFile),
        ];

    }
}

Ensuite, j’ai modifié le code testroute sous routes/web.php :

<?php

use Illuminate\Support\Facades\Route;
use App\Mail\MyTestEmail;

Route::get('/testroute', function () {

    $filePath = public_path('favicon.ico');

    $name = "Drôle de Développeur";

    Mail::to('destinatairedetest@gmail.com'')->send(new MyTestEmail($name, $filePath));
});

Et comme avec SMTP, votre email devrait maintenant contenir une pièce jointe ICO nommée favicon.ico.

Envoi d’emails avec des images intégrées

Pour envoyer un email avec une image intégrée, utilisez la méthode embed dans le modèle Blade pour inclure l’image. Par exemple, imaginons que vous ayez une image public/images/logo.php.

Voici à quoi ressemblerait alors votre code :

// resources/views/mail/test-email.blade.php

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <div>
        <p>Salut {{$name}},</p>
        <p>Votre application Laravel peut-elle envoyer des emails ? 😉</p>
        <img src="{{ $message->embed(public_path('images/logo.png')) }}" alt="Logo">
    </div>
</body>
</html>

Mise en file d’attente des emails pour l’envoi asynchrone

Comme avec SMTP, vous pouvez utiliser ShouldQueue de Laravel pour l’envoi asynchrone.

Pour que cela fonctionne, votre classe mailable doit implémenter l’interface ShouldQueue et utiliser le trait Queueable :

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;

class MyTestEmail extends Mailable implements ShouldQueue
{
    use Queueable, SerializesModels;
    // Le reste de votre classe...
}

Vous pouvez configurer votre pilote de file d’attente dans le fichier .env en définissant QUEUE_CONNECTION à un pilote de file d’attente comme database, redis, sqs, etc.

Et pour envoyer un email, vous pouvez utiliser la commande suivante :

Mail::to('destinatairedetest@exemple.com')->send(new MyTestEmail($name));

N’oubliez pas que vous pouvez exécuter la commande php artisan queue:work dans votre terminal pour démarrer le traitement des jobs mis en file d’attente.

Envoi d’emails en masse

Pour commencer à envoyer des emails en masse, vous devez d’abord ajouter les informations d’identification du Bulk Stream, que vous pouvez trouver dans l’onglet SMTP/API Settings lorsque vous vous connectez à votre compte Mailtrap.

Une fois que vous avez trouvé les informations d’identification, ajoutez-les à votre fichier .env de Laravel (assurez-vous de sélectionner le Bulk Stream).

Voici à quoi devrait ressembler votre fichier .env lorsque vous entrez vos informations d’identification du Bulk Stream :

MAIL_MAILER="mailtrap"
MAILTRAP_HOST="bulk.smtp.mailtrap.io"
MAILTRAP_API_KEY="VOTRE_CLE_API_BULK_STREAM_ICI"

Une fois vos informations d’identification remplacées, vous devez générer une classe Mailable pour envoyer des emails :

php artisan make:mail BulkEmail

À partir de là, vous avez trois options pour envoyer des emails en masse, à savoir :

  • Boucle

Si vous envoyez une petite quantité d’emails en masse, vous pouvez créer une boucle dans vos destinataires et envoyer des emails individuellement. Comme ceci :

use App\Mail\BulkEmail;
use Illuminate\Support\Facades\Mail;

$users = User::all(); // Exemple : Sélectionner tous les utilisateurs auxquels vous voulez envoyer un email

foreach ($users as $user) {
    Mail::to($user->email)->send(new BulkEmail($data));
}
  • Chunking

Si vous prévoyez d’envoyer une grande quantité d’emails en masse, la méthode Chunking peut vous aider à traiter les utilisateurs en petits groupes.

Regardez:

User::chunk(200, function ($users) use ($data) {
    foreach ($users as $user) {
        Mail::to($user->email)->queue(new BulkEmail($data));
    }
});
  • Jobs en file d’attente

Si vous prévoyez d’envoyer une grande quantité d’emails en masse et de libérer votre application pour traiter d’autres requêtes, vous pouvez attribuer un job pour chaque email :

class SendBulkEmailJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $user;
    protected $data;

    public function __construct($user, $data)
    {
        $this->user = $user;
        $this->data = $data;
    }

    public function handle()
    {
        Mail::to($this->user->email)->send(new BulkEmail($this->data));
    }
}

// Attribue un job pour chaque utilisateur
foreach ($users as $user) {
    SendBulkEmailJob::dispatch($user, $data)->onQueue('emails');
}

Quelle que soit la méthode de l’envoi en masse que vous choisissez, vous devez toujours surveiller les logs de votre application et le tableau de bord de Mailtrap pour vous assurer que vos emails soient traités et envoyés.

De plus, envisagez de limiter les taux ou d’instaurer des délais entre les emails si vous envoyez à un grand nombre de destinataires.

Test des emails et envoi d’emails : pourquoi et comment

Avec tout ce code écrit, vous ne voudriez pas que vos emails soient envoyés depuis un domaine blacklisté, catégorisés comme spam, ou que leur modèle HTML soit mal rendu par certains navigateurs web. C’est pourquoi vous devriez tester vos emails dans Laravel avant de les envoyer.

Techniquement, vous pourriez le faire avec votre boîte de réception personnelle ou le pilote de log, mais pourquoi affecter la réputation de votre domaine et inonder votre boîte de réception d’emails indésirables, alors que vous pouvez utiliser l’Email Testing de Mailtrap ?

Mailtrap est également supporté par Laravel dans la documentation officielle.

Cette plateforme d’envoi d’emails offre également de nombreuses fonctionnalités qui peuvent vous aider à résoudre de nombreux problèmes de test tout en gardant votre processus de test d’emails sécurisé.

Avec l’Email Testing de Mailtrap, vous pouvez capturer des emails de test et les prévisualiser dans un environnement sandbox sécurisé. Vous pouvez également vérifier le score de spam de vos emails, analyser leur HTML/CSS, et plus encore, tout cela avant de les envoyer.

En gros, la fonction de l’Email Testing de Mailtrap est de s’assurer que vos emails arrivent là où ils sont censés arriver, au lieu de finir dans les dossiers de spam.

L’Email Testing de Mailtrap vous permet également de partager facilement le processus de test avec vos collègues, de créer de nouveaux projets, et d’ajouter plusieurs objets au sein de ceux-ci.

Vous pouvez également transférer les emails aux bonnes adresses manuellement ou automatiquement une fois que vous êtes satisfait des résultats obtenus.

Plus important encore, tester des emails avec Mailtrap est assez facile.

SMTP

Pour tester vos emails avec Mailtrap, il vous suffit de créer un compte Mailtrap gratuit, ce qui vous donnera accès à l’ensemble de la plateforme d’Email Delivery de Mailtrap. Cela signifie que vous pourrez utiliser à la fois l’Email Testing et l’Email API/SMTP.

Une fois que vous avez créé votre compte et que vous vous êtes connecté, suivez simplement ces étapes :

  • Naviguez vers Email Testing → Inboxes → SMTP Settings
  • Sélectionnez la version Laravel souhaitée dans la liste des intégrations (je recommande la version 9+)
  • Copiez l’extrait de code généré dans le fichier .env situé dans le répertoire racine de votre projet. Cela devrait ressembler à ceci :
MAIL_MAILER=smtp
MAIL_HOST=sandbox.smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=07f4dbf61b8122
MAIL_PASSWORD=d7fc5d57bc6eac
MAIL_ENCRYPTION=tls

Une fois terminé, vous pourrez envoyer le premier email de test avec le code suivant :

<?php
use App\Mail\JustTesting;
use Illuminate\Support\Facades\Mail;
Route::get('/send-mail', function () {
    Mail::to('nouvelutilisateur@exemple.com')->send(new JustTesting());
    return 'Un message a été envoyé à Mailtrap!';
});

Astuce Pro : Assurez-vous d’utiliser Laravel 5.8 ou une version plus récente et que vous avez spécifié la route dans le fichier routes/web.php.

Pour envoyer l’email de test, démarrez l’application et accédez au chemin /send-mail dans votre navigateur. Vous verrez alors l’email dans Email Testing → Inboxes.

Testez les Emails avec Mailtrap Gratuitement

API

Alternativement, vous pouvez intégrer l’Email Testing dans votre application et utiliser le Testing API pour les tests, l’automatisation et les séquences de tests automatisées.

Selon le client HTTP que vous utilisez, exécutez l’une des commandes suivantes :

# Avec le client symfony http (recommandé)
composer require railsware/mailtrap-php symfony/http-client nyholm/psr7

# Ou avec le client guzzle http
composer require railsware/mailtrap-php guzzlehttp/guzzle php-http/guzzle7-adapter

Ajoutez le transport Mailtrap dans votre fichier config.mail.php :

<?php

return [
    /*
    |--------------------------------------------------------------------------
    | Configurations des Mailers
    |--------------------------------------------------------------------------
    */
    'mailers' => [
    
            // début du transport mailtrap
            'mailtrap' => [
                'transport' => 'mailtrap'
            ],
            // fin du transport mailtrap
    
    ]
]

Ensuite, vous devez définir la clé API sur la variable MAILTRAP_API_KEY et définir l’ID de votre boîte de réception sur MAILTRAP_INBOX_ID, comme ceci :

MAIL_MAILER="mailtrap"

MAILTRAP_HOST="sandbox.api.mailtrap.io"
MAILTRAP_API_KEY="VOTRE_CLE_API_ICI"
MAILTRAP_INBOX_ID=1000001

Notes: 

  • Vous pouvez trouver votre clé/jeton API en accédant à votre compte Mailtrap et en naviguant vers Sending Domains → SMTP/API Settings
  • Assurez-vous d’exécuter la commande de nettoyage du cache pour configurer de nouvelles variables avec :
php artisan config:clear

Et pour tester votre premier email, vous devez générer une classe Mailable, comme avec l’envoi :

php artisan make:mail WelcomeMail

Une fois que vous avez créé votre classe Mailable, vous pouvez configurer votre email. Voici un exemple :

# app/Mail/WelcomeMail.php
<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Mail\Attachment;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Headers;
use Illuminate\Queue\SerializesModels;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;

class WelcomeMail extends Mailable
{
    use Queueable, SerializesModels;

    private string $name;

    /**
     * Créer une nouvelle instance de message.
     */
    public function __construct(string $name)
    {
        $this->name = $name;
    }

    /**
     * Obtenir l'enveloppe du message.
     */
    public function envelope(): Envelope
    {
        return new Envelope(
            from: new Address('jeffrey@exemple.com', 'Jeffrey Way'),
            replyTo: [
                      new Address('taylor@exemple.com', 'Taylor Otwell'),
                  ],
            subject: 'Email de Bienvenue',
            using: [
                      function (Email $email) {
                          // En-têtes
                          $email->getHeaders()
                              ->addTextHeader('X-Message-Source', 'example.com')
                              ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client'))
                          ;

                          // Variables personnalisées
                          $email->getHeaders()
                              ->add(new CustomVariableHeader('user_id', '45982'))
                              ->add(new CustomVariableHeader('batch_id', 'PSJ-12'))
                          ;

                          // Catégorie (doit être unique)
                          $email->getHeaders()
                              ->add(new CategoryHeader('Integration Test'))
                          ;
                      },
                  ]
        );
    }

    /**
     * Obtenir la définition du contenu du message.
     */
    public function content(): Content
    {
        return new Content(
            view: 'mail.welcome-email',
            with: ['name' => $this->name],
        );
    }

    /**
     * Obtenir les pièces jointes du message.
     *
     * @return array<int, \Illuminate\Mail\Mailables\Attachment>
     */
    public function attachments(): array
    {
        return [
            Attachment::fromPath('https://mailtrap.io/wp-content/uploads/2021/04/mailtrap-new-logo.svg')
                ->as('logo.svg')
                ->withMime('image/svg+xml'),
        ];
    }

    /**
     * Obtenir les en-têtes du message.
     */
    public function headers(): Headers
    {
        return new Headers(
            'id-du-message-personnalisé@exemple.com',
            ['message-précédent@exemple.com'],
            [
                'X-Custom-Header' => 'Valeur Personnalisée',
            ],
        );
    }
}

De plus, vous pouvez utiliser un modèle d’email :

# resources/views/mail/welcome-email.blade.php

Salut, {{$name}} et bienvenue 😉

<br>
Drôle de Développeur

Et ajoutez le routeur CLI :

# app/routes/console.php
<?php

use App\Mail\WelcomeMail;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\Mail;

/*
|--------------------------------------------------------------------------
| Routes Console
|--------------------------------------------------------------------------
|
*/

Artisan::command('send-welcome-mail', function () {
    Mail::to('destinatairedetest@gmail.com')->send(new WelcomeMail("Jon"));
    // Vous pouvez également utiliser un mailer spécifique si votre mailer par défaut n'est pas "mailtrap" mais que vous souhaitez l'utiliser pour les mails de bienvenue
    // Mail::mailer('mailtrap')->to('destinatairedetest@gmail.com')->send(new WelcomeMail("Jon"));
})->purpose('Envoyer un email de bienvenue');

Et pour envoyer votre email, appelez simplement cette commande CLI :

php artisan send-welcome-mail

Pour plus d’informations, consultez la documentation officielle de l’API Mailtrap.

Conclusion

Et voilà, nous avons terminé notre guide « Envoi d’email dans Laravel ».

Nous avons couvert beaucoup de choses, de la configuration de Laravel à l’envoi d’emails avec SMTP en passant par l’envoi d’emails via API. Quelle que soit l’option que vous choisissez, vous pouvez toujours vous référer à cet article pour suivre les étapes.

Pour en savoir plus sur Laravel, consultez la documentation officielle. Et si vous recherchez plus de contenu sur l’envoi d’emails avec Laravel, assurez-vous de visiter le blog de Mailtrap où vous pouvez trouver d’autres articles utiles tels que :

Article by Aleksandr Varnin Full Stack Developer @ Railsware
Ivan Djuric, an author at Mailtrap
Article by Ivan Djuric Technical Content Writer @Mailtrap

I’m a Technical Content Writer with 5 years of background covering email-related topics in tight collaboration with software engineers and email marketers. I just love to research and share actionable insights with you about email sending, testing, deliverability improvements, and more. Happy to be your guide in the world of emails!