Comment envoyer un e-mail avec Django à l'aide du serveur SMTP

Avez-vous déjà eu du mal à configurer l'intégration des e-mails dans vos projets Django? Qu'il s'agisse de configurer les paramètres SMTP, de gérer les problèmes de sécurité ou d'automatiser les formulaires de contact, les fonctionnalités de messagerie sont cruciales pour l'engagement et la confiance des utilisateurs.

Dans ce tutoriel, nous allons expliquer comment envoyer des e-mails à l'aide de Django avec des instructions pratiques et étape par étape. Nous couvrirons comment configurer les connexions Django SMTP, comment configurer un mot de passe pour votre fournisseur de messagerie et comment envoyer des e-mails via le shell Django. Nous examinerons également comment configurer un formulaire de contact pour votre application Django, qui permettra à vos clients de vous contacter.

Les plats clés

• Configurer les paramètres SMTP: configurer le e-mail Django Envoyer en configurant le fichier Settings.py avec le backend, l'hôte, le port et les paramètres de sécurité appropriés (par exemple, TLS).
• Informations d'identification sécurisées avec Django Environ: Utilisez Django Environ pour gérer les informations d'identification sensibles comme Email_Host_User et Email_Host_Password en toute sécurité via des variables d'environnement, empêchant le codage rigide des informations d'identification dans le code source.
• Générer des mots de passe spécifiques à l'application: Lorsque vous utilisez Gmail, activez une vérification en 2 étapes et créez un mot de passe d'application pour authentifier en toute sécurité le courrier Django envoyant au lieu de compter sur votre mot de passe principal.
• Envoyer des e-mails avec Send_mail: Utilisez la fonction Send_mail intégrée de Django pour envoyer des e-mails avec Django à partir du shell Django, des vues ou des fonctions d'assistance réutilisables, en utilisant des paramètres pour la configuration rationalisée.
• Implémentez les formulaires de contact automatisés: créez un formulaire de contact automatisé à l'aide de formulaires Django et intégrez les fonctionnalités en fin de messagerie pour la gestion transparente des demandes d'utilisateurs.
• Test Fonctionnalité E-Email: Vérifiez la logique de fin de messagerie avec des tests unitaires et utilisez des outils tels que MailHog ou Backend de messagerie pour les tests de développement en toute sécurité.
• Suivez les meilleures pratiques: assurez-vous la livraison sécurisée et efficace des e-mails en utilisant le cryptage TLS, l'authentification appropriée et les fonctions de messagerie modulaire pour la réutilisabilité.

La plupart des applications Web utilisent le courrier électronique pour gérer les opérations cruciales, telles que la réinitialisation des mots de passe, l'activation du compte, la réception des commentaires des clients, l'envoi de newsletters et les campagnes de marketing. Alors que Gmail travaille pour les tests ou les petits projets, les sites Web de production doivent utiliser des services de messagerie dédiés tels que AWS SES, SendGrid ou Mailgun.

Cependant, si vous comparez le coût et l'effort d'utilisation d'un service de messagerie dédié, l'envoi d'e-mails avec votre e-mail personnel peut être plus raisonnable pour les petits ou des projets de test. Nous allons donc adopter cette approche ici pour garder les choses simples.

Remarque : Ce n'est pas une bonne idée d'utiliser votre service de messagerie personnel pour votre site Web de production. Vous pouvez en savoir plus sur Gmail Envoi des restrictions , ou se référer aux limites de votre fournisseur de messagerie.

Remarque: le code complet de ce tutoriel est disponible sur github.

Comprendre le serveur SMTP et le protocole de transfert de courrier simple

SMTP (ou le protocole de transfert de courrier simple) est un ensemble de règles pour déterminer comment les e-mails sont transférés des expéditeurs aux destinataires. Les serveurs SMTP utilisent ce protocole pour envoyer et relayer les e-mails sortants. (Notez que d'autres protocoles régissent la façon dont les e-mails sont reçus .)

Un serveur SMTP a toujours une adresse unique et un port spécifique pour l'envoi de messages, qui dans la plupart des cas est 587. Nous verrons comment le port est pertinent dans Django Email Send.

Pour cet exemple, nous utiliserons le serveur SMTP de Gmail, où:

• Adresse: smtp.gmail.com
• Port: 587

Maintenant, voyons comment nous pouvons envoyer des e-mails avec Django.

Création d'un projet Django

Chaque projet Django devrait avoir un environnement virtuel, car nous ne voulons pas gâcher les dépendances du projet. Pour en créer un, exécutez ce qui suit:

python <span>-m venv .venv</span>

Remarque: Si vous n'êtes pas familier avec les environnements virtuels, assurez-vous de vérifier notre guide des environnements virtuels Python .

La commande ci-dessus crée un environnement virtuel avec le nom .venv. Pour activer cet environnement virtuel, vous pouvez utiliser ce qui suit:

<span># CMD
</span>.venv<span>\Scripts\activate
</span>
<span># Power Shell
</span>.venv<span>\Scripts\Activate.ps1
</span>
<span># WSL
</span><span>source .venv/bin/activate</span>

Étant donné que Django est un package tiers, vous devez l'installer avec pip:

pip <span>install django</span>

Cela installera la dernière version de Django, que vous pouvez vérifier avec PIP Freeze.

Pour créer un projet Django, vous appelez l'utilitaire de commande django-admin:

django-admin startproject EmailProject

Avec la commande ci-dessus, vous créez un projet Django avec le nom EmailProject, mais vous pouvez créer le projet avec le nom que vous voulez. Maintenant, entrez dans le répertoire du projet et exécutez le serveur:

<span>cd EmailProject
</span>python manage.py runserver

Après avoir exécuté le serveur Django, visitez http: // localhost: 8000 dans votre navigateur. Vous verrez une page générée automatiquement avec les dernières notes de sortie de Django.

Configuration du backend de messagerie Django pour SMTP

Le backend des e-mails est le mécanisme pour envoyer des e-mails avec Django. Par défaut, Django utilise django.core.mail.backends.smtp.emailbackend, qui lui permet de se connecter à un serveur SMTP et d'envoyer des e-mails. Selon l'environnement (développement ou production), vous pouvez choisir un autre backend par e-mail pour répondre à vos besoins.

Vous devrez modifier le fichier de paramètres avant d'envoyer des e-mails, alors localisons ce fichier avec la commande ci-dessous:

Remarque: Pour la simplicité, nous n'utiliserons que les commandes système UNIX (macOS ou Linux).

python <span>-m venv .venv</span>

La commande d'arborescence sortira la structure de fichiers d'un répertoire. Dans ce cas, comme nous ne lui donnons pas un chemin de répertoire spécifique, nous obtiendrons quelque chose de similaire à ce qui suit si nous sommes dans le dossier racine du projet:

<span># CMD
</span>.venv<span>\Scripts\activate
</span>
<span># Power Shell
</span>.venv<span>\Scripts\Activate.ps1
</span>
<span># WSL
</span><span>source .venv/bin/activate</span>

Le fichier que nous modifierons constamment via ce tutoriel est le paramètres.py dans le dossier e-mail. Il contient toute la configuration du projet dont vous aurez besoin et vous permet de définir des variables personnalisées. Comme le disent les documents Django, «un fichier de paramètres n'est qu'un module Python avec des variables au niveau du module».

Examinons les paramètres requis pour l'envoi d'un e-mail avec Django. Ouvrez le fichier e-mail / settings.py.py et collez les paramètres suivants en bas du fichier:

pip <span>install django</span>

Décomposons le code ci-dessus en analysant chacun de ces paramètres.

Backend par e-mail

Le paramètre e-mail_backend déclare que le backend que notre projet Django utilisera pour se connecter avec le serveur SMTP.

Cette variable pointe vers la classe smtp.emailbackend qui reçoit tous les paramètres nécessaires pour envoyer un e-mail. Je vous suggère fortement de jeter un œil au constructeur de classe directement sur le code source de Django. Vous serez surpris par la lisible de ce code.

Remarque: Bien que cette classe soit le e-mail par défaut_backend, il est considéré comme une bonne pratique explicite dans les paramètres de Django.

Tous les autres paramètres de messagerie seront basés sur le constructeur de cette classe EmailBackend.

Hôte par e-mail

Le paramètre e-mail_host fait référence au domaine du serveur SMTP que vous utiliserez. Cela dépend de votre fournisseur de messagerie. Vous trouverez ci-dessous un tableau avec l'hôte du serveur SMTP correspondant à trois fournisseurs communs:

Fournisseur de messagerie SMTP Server Host gmailsmtp.gmail.comoutlook / hotmailsmtp-chail.outlook.comyahoosmtp.mail.yahoo.com

Nous laissons ce paramètre vide pour l'instant car nous utiliserons un fichier .env plus tard pour éviter les clés sensibles à code dur ou les configurations par site. Vous ne devez jamais définir des informations d'identification directement dans le code. Nous utiliserons Django Environ pour résoudre ce problème.

Port de messagerie

Le paramètre email_port doit être défini sur 587 car c'est le port par défaut pour la plupart des serveurs SMTP. Cela reste vrai pour les fournisseurs de courriels personnels. Ce port est utilisé avec le cryptage TLS pour assurer la sécurité de l'envoi des e-mails.

e-mail Utilisez TLS

Transport Layer Security (TLS) est un protocole de sécurité utilisé sur le Web pour crypter la communication entre les applications Web (Django) et les serveurs (serveur SMTP).

À l'origine, nous définissons la variable EMAIL_USE_TLS sur true. Cela signifie que Django utilisera la sécurité de la couche de transport pour se connecter au serveur SMTP et envoyer des e-mails. (C'est obligatoire pour les fournisseurs de courriels personnels.)

utilisateur de l'hôte de messagerie

Le paramètre EMAIL_HOST_USER est votre adresse e-mail personnelle. Laissez-le vide pour le moment, car nous utiliserons Django-Environ pour configurer toutes ces informations d'identification.

Mot de passe de l'hôte e-mail

Le paramètre e-mail_host_password est le mot de passe de l'application que vous obtiendrez de votre compte de messagerie - le processus que nous ferons juste après cette section. Même histoire: laissez ce paramètre vide, car nous utiliserons les variables environnementales plus tard.

Pour les autres fournisseurs, vous pouvez ajuster les paramètres en conséquence. Par exemple:

Configuration Outlook:

python <span>-m venv .venv</span>

Configuration de Yahoo:

<span># CMD
</span>.venv<span>\Scripts\activate
</span>
<span># Power Shell
</span>.venv<span>\Scripts\Activate.ps1
</span>
<span># WSL
</span><span>source .venv/bin/activate</span>

Configuration du serveur SMTP Gmail avec le mot de passe de l'application

Étant donné que les «applications moins sécurisées» sont obsolètes par Google, la manière appropriée et sécurisée de se connecter au compte Gmail pour l'envoi de courriels est d'utiliser les mots de passe de l'application. Les mots de passe de l'application ne sont disponibles que si vous activez une vérification en 2 étapes pour votre compte Google.

Pourquoi utiliser les mots de passe de l'application?

1. Alternative sécurisée: Au lieu de partager votre mot de passe principal, les mots de passe de l'application fournissent un accès limité pour des applications spécifiques.
2. Fonctionne avec SMTP: les mots de passe de l'application sont conformes aux exigences de sécurité de Gmail pour l'accès SMTP.
3. obligatoire pour la vérification en 2 étapes: Une fois la vérification en 2 étapes activée, les mots de passe de l'application sont le seul moyen de permettre aux applications externes de se connecter.

Étape 1: Activer la vérification en 2 étapes

1. Accédez à votre compte Google: https://myaccount.google.com/.
2. Accédez à la sécurité dans le menu de gauche.
3. Faites défiler vers la section "Comment vous vous connectez à Google".
4. Cliquez sur «Vérification en 2 étapes» et suivez les instructions à l'écran:
   • Utilisez votre numéro de téléphone ou une application Authenticator pour configurer une vérification en 2 étapes.
   • Vérifiez votre configuration avec le code envoyé à votre appareil.

Étape 2: générer un mot de passe d'application

1. Une fois la vérification en 2 étapes activée, recherchez les «mots de passe de l'application» dans la barre de recherche.
2. Là, entrez le nom du mot de passe de l'application et cliquez sur Créer.

3. Ensuite, il donnera un modal pop-up avec un mot de passe d'application de 16 caractères. Assurez-vous de le sauver quelque part car il ne sera affiché qu'une seule fois.

Si vous utilisez d'autres fournisseurs de messagerie, assurez-vous de lire les guides suivants:

• yahoo application mot de passe
• Mot de passe Outlook ou Hotmail App

Utilisation de Django Environ pour sécuriser les informations d'identification de backend e-mail

Même si vous envoyez simplement des e-mails en développement, vous ne devez pas écrire de mots de passe directement dans le code source. Cela devient encore plus important lors de l'utilisation d'un système de contrôle de version avec GitHub pour héberger votre projet. Vous ne voulez pas que les gens accédaient à vos données.

Voyons comment nous pouvons empêcher cela en utilisant le django-environ.

Créez un fichier .env dans le répertoire EmailProject (où se trouve le fichier Settings.py) avec la commande ci-dessous:

python <span>-m venv .venv</span>

Maintenant, ouvrez ce fichier .env et entrez les paires de clés-valeur suivantes:

<span># CMD
</span>.venv<span>\Scripts\activate
</span>
<span># Power Shell
</span>.venv<span>\Scripts\Activate.ps1
</span>
<span># WSL
</span><span>source .venv/bin/activate</span>

décomposer le contenu de ce fichier:

• email_host: l'adresse du serveur SMTP de votre fournisseur de messagerie. Voir le tableau des hôtes de messagerie ci-dessus pour des conseils rapides. Dans ce cas, j'utilise smtp.gmail.com, l'adresse Gmail SMTP.
• email_host_user: votre adresse e-mail.
• email_host_password: le mot de passe de l'application que vous venez de générer. Ont à l'esprit qu'il n'inclut aucun espace.
• destinataire_address: l'adresse e-mail dans laquelle vous recevrez les messages. Il s'agit d'un paramètre personnalisé que nous créerons plus tard pour envoyer tous les e-mails au même destinataire.

Pour utiliser ces variables environnementales, nous devrons installer django-environ:

pip <span>install django</span>

Remarque: assurez-vous que votre environnement virtuel est activé.

Maintenant, ouvrez les paramètres.py situés dans le répertoire EmailProject et utilisez le code ci-dessous:

django-admin startproject EmailProject

Tout d'abord, nous importons le package environnement en haut du fichier de paramètres. N'oubliez pas que toutes les importations doivent être au début. Ensuite, nous créons une variable Env qui contiendra toutes les paires de valeurs clés disponibles sur le .env.

L'énoncé env («clé») signifie que nous recherchons la valeur de cette clé. Avant de continuer, assurez-vous d'avoir configuré votre fichier .env. Sinon, si une variable environnementale n'est pas définie, vous obtiendrez une erreur Django malfigurée.

Remarque: le destinataire_address est un paramètre personnalisé que nous utiliserons pour envoyer des e-mails à une adresse à laquelle nous pouvons accéder.

N'oubliez pas d'inclure le fichier .env dans votre .gitignore si vous utilisez git et github. Vous pouvez le faire simplement en l'ouvrant et en ajoutant la ligne suivante:

<span>cd EmailProject
</span>python manage.py runserver

1. Envoi de courriels avec le shell Django

Enfin, nous arrivons à la partie juteuse de l'article! Il est temps d'envoyer votre premier e-mail à Django.

Ouvrez un terminal, activez l'environnement virtuel et exécutez:

tree

Cela créera un shell avec tous les paramètres django déjà configurés pour nous. À l'intérieur de ce tout nouveau shell, collez le code suivant:

├── EmailProject
│   ├── asgi.py
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

1 directory, 6 files

Nous pouvons également faire une seule ligne sans spécifier les arguments:

python <span>-m venv .venv</span>

Décomposons le code ci-dessus:

• Nous importons la fonction Django Send_mail.
• Ensuite, nous importons l'objet Paramètres, qui contient tous les paramètres globaux et les paramètres par site (ceux à l'intérieur du fichier Settings.py).
• Enfin, nous transmettons tous les arguments nécessaires à la fonction Send_mail. Cette fonction renvoie le nombre d'e-mails envoyés, dans ce cas, 1.

Notez comment nous utilisons l'objet Paramètres pour obtenir le from_email (l'e-mail avec lequel vous envoyez des e-mails) et le destinataire_list (le paramètre personnalisé du destinataire que nous avons défini dans le .env).

Maintenant, si je coche ma boîte de réception - car je définis la variable environnementale du destinataire_address dans mon adresse e-mail - je recevrai le message e-mail envoyé par Django.

e-mail asynchrone Envoi

Dans Django 4.x, l'envoi de courriels asynchrones est pris en charge pour améliorer les performances. Ceci est utile pour les sites Web très trafiques ou lors de l'envoi de courriels en vrac.

Voici comment envoyer un e-mail de manière asynchrone:

<span># CMD
</span>.venv<span>\Scripts\activate
</span>
<span># Power Shell
</span>.venv<span>\Scripts\Activate.ps1
</span>
<span># WSL
</span><span>source .venv/bin/activate</span>

L'envoi des e-mails asynchrones est utile dans des scénarios comme:

• Opérations non bloquantes où l'envoi d'un e-mail ne doit pas retarder les demandes des utilisateurs.
• Envoi des e-mails en vrac (utilisez une file d'attente de tâches comme le céleri pour les tâches à échelle de production).

Remarque: Bien que Django prenne en charge les e-mails asynchrones, pour les e-mails en vrac à l'échelle de la production, utilisez une file d'attente de tâches d'arrière-plan comme le céleri ou le django-Q pour de vraies opérations non bloquantes.

2. Créez un formulaire de contact automatisé avec Django

Dans cette section, nous créerons un formulaire de contact automatisé avec les formulaires Django et la fonction Send_mail intégrée. Nous allons également créer une fonction personnalisée, envoyer (), à l'intérieur du formulaire de contact, il est donc plus facile de l'implémenter dans les vues.

Commençons par créer l'application de contact. Entrez dans le répertoire racine du projet - où se trouve Manage.py - et exécutez:

pip <span>install django</span>

Ensuite, installez-le dans votre variable installée_apps dans le fichier e-mail / settings.py.py:

django-admin startproject EmailProject

Avant de progresser avec l'application de contact, configurons les UrlPatterns à l'intérieur du fichier e-mail / url.py. Pour ce faire, importez la fonction django.urls.include et incluez les URL de contact dans le projet global. Ne t'inquiète pas; Nous allons configurer les URL de contact plus tard:

<span>cd EmailProject
</span>python manage.py runserver

Formulaire de contact

Entrez le dossier de l'application Contact et créez un fichier Forms.py. C'est une bonne pratique de définir toutes vos formes à l'intérieur d'un fichier Forms.py, mais ce n'est pas obligatoire. C'est pourquoi Django n'inclut pas ce fichier par défaut. Vous pouvez créer le fichier de formulaires avec les commandes suivantes:

tree

Ouvrez le fichier que vous venez de créer et faites les importations suivantes:

python <span>-m venv .venv</span>

Le module Django Form nous donne toutes les classes et champs nécessaires pour créer notre formulaire de contact. Encore une fois, nous importons l'objet Paramètres et la fonction Send_mail pour envoyer les e-mails.

Notre formulaire de contact contiendra plusieurs champs et utilisera deux méthodes personnalisées: get_info (), qui formate les informations fournies par l'utilisateur, et Send (), qui enverra l'e-mail. Voyons cela implémenté dans le code:

<span># CMD
</span>.venv<span>\Scripts\activate
</span>
<span># Power Shell
</span>.venv<span>\Scripts\Activate.ps1
</span>
<span># WSL
</span><span>source .venv/bin/activate</span>

Cette classe est énorme, alors décomposons ce que nous faisons dans chaque partie. Premièrement, nous définissons quatre champs qui seront nécessaires pour envoyer l'e-mail:

• Le nom et la demande sont des charfiers, qui représentent le nom et la raison du message de contact.
• Email est un champ de messagerie qui représente l'adresse e-mail de la personne qui essaie de vous contacter. Notez que l'e-mail ne sera pas envoyé par l'adresse e-mail de l'utilisateur, mais par l'adresse e-mail, vous avez défini pour envoyer des e-mails dans le projet Django.
• Le message est un autre Charfield, sauf que nous utilisons le widget TextArea. Cela signifie que, lors de l'affichage du formulaire, il rendra une balise au lieu d'une simple <poue>. </poue>

En direction des méthodes personnalisées, nous utilisons uniquement la méthode get_info pour formater les informations de l'utilisateur et retourner deux variables: Sujet, qui n'est rien d'autre que le champ de demande et le message, qui sera le message électronique réel envoyé par Django .

En revanche, la méthode Send () obtient uniquement les informations formatées de get_info et envoie le message avec la fonction Send_mail. Bien que cette section soit assez grande, vous verrez comment nous avons simplifié les vues de contact en implémentant toute la logique d'envoi à la forme de contact elle-même.

Contact Views

Ouvrez le fichier Contact / Views.py et ajoutez les importations suivantes:

pip <span>install django</span>

Comme vous pouvez le voir, nous allons utiliser des vues génériques de Django, ce qui nous fait gagner une tonne de temps lorsque vous effectuez des tâches simples - par exemple, lorsque vous configurez un formulaire avec FormView ou créant une vue qui ne fait que rendre un modèle avec TemplateView.

De plus, nous importons la forme de contact que nous avons construite dans la section précédente et la fonction reversé_lazy utilisée lorsque vous travaillons avec Vues basées sur les classes . Poursuivant avec les vues, écrivons le ContactView:

django-admin startproject EmailProject

Comme vous pouvez le voir, nous construisons une vue simple en utilisant la forme de contact que nous avons créée. Nous configurons également le Template_name et le Success_Url. Nous allons écrire le modèle HTML et configurer les URL plus tard.

La méthode valide du formulaire nous envoyons l'e-mail à l'aide de la méthode ContactForm.Send () uniquement si tous les champs du formulaire sont valides. Cela implique que si l'utilisateur entre dans une entrée non valide - comme une adresse e-mail non formatée - le message ne sera pas envoyé.

L'implémentation de méthode Form_Valid ci-dessus serait équivalente à ce qui suit dans une vue basée sur la fonction:

python <span>-m venv .venv</span>

terminant cette section, nous allons écrire un ContacteSussView, qui affichera un message de réussite à l'utilisateur. Puisque nous avons déjà importé la classe TemplateView, nous n'avons qu'à en hériter et à définir l'attribut template_name:

<span># CMD
</span>.venv<span>\Scripts\activate
</span>
<span># Power Shell
</span>.venv<span>\Scripts\Activate.ps1
</span>
<span># WSL
</span><span>source .venv/bin/activate</span>

Vous pouvez consulter le fichier Views.py sur le référentiel GitHub si vous avez des préoccupations.

Contacter les URL

Il est temps de créer les modèles URL de l'application de contact. Étant donné que Django ne nous donne pas le fichier url.py par défaut, nous devons le créer avec la commande suivante (assurez-vous d'être dans le dossier de l'application de contact):

pip <span>install django</span>

Ouvrez ce fichier et configurez les variables APP_NAME et URLPatterns:

django-admin startproject EmailProject

Nous utilisons le chemin d'accès pour inclure l'itinéraire et sa vue correspondante vers la configuration de l'URL de l'application. Lorsque nous définissons la variable APP_NAME sur «Contacter», cela signifie que l'URL ESPACACE DE NOMS de l'application ressemblera à ceci:

<span>cd EmailProject
</span>python manage.py runserver

Remarque: Un espace de noms est ce que nous appelons les URL dynamiquement dans les modèles et les vues django.

Vous pouvez en savoir plus sur le répartiteur de l'URL Django dans la documentation officielle.

Modèles d'écriture

Les modèles Django sont le moyen préféré d'afficher les données dynamiquement, en utilisant HTML et des balises spéciales fournies par le langage du modèle Django.

Pour cette application spécifique, nous utiliserons trois modèles:

• base.html: Tous les autres modèles en hériteront. Il contiendra le squelette HTML que tous les modèles doivent avoir, ainsi que des liens vers Bootstrap.
• contact.html: affiche le formulaire de contact.
• Success.html: affiche un message de réussite.

Commençons par créer la structure du modèle d'application du contact (assurez-vous que vous êtes dans le dossier de l'application de contact):

tree

Les commandes ci-dessus créent la structure de modèle typique d'une application Django réutilisable - Appname / Templates / AppName - et les fichiers de modèle d'arborescence que j'ai mentionnés précédemment. Voici à quoi devrait ressembler la structure des fichiers d'application:

├── EmailProject
│   ├── asgi.py
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

1 directory, 6 files

Saisons dans le contenu du modèle de base.html:

<span># EmailProject/settings.py
</span>
<span># Bottom of the file
</span>EMAIL_BACKEND <span>= 'django.core.mail.backends.smtp.EmailBackend'
</span>EMAIL_HOST <span>= ''
</span>EMAIL_PORT <span>= 587
</span>EMAIL_USE_TLS <span>= True
</span>EMAIL_HOST_USER <span>= ''
</span>EMAIL_HOST_PASSWORD <span>= ''
</span>

Comme vous pouvez le voir, c'est le squelette simple d'un fichier HTML qui comprend des liens vers Bootstrap 5. Cela nous permet de styliser notre application de contact sans utiliser de fichiers CSS. La balise {% Block Name-of-Block%} nous permet de configurer un espace réservé que les «modèles enfants» utiliseront. L'utilisation de cette balise fait de l'héritage du modèle une tâche facile.

Avant de vous diriger vers les formulaires, vous devrez installer le package Django Crispy Forms, qui nous permet de les styliser facilement:

EMAIL_HOST <span>= 'smtp-mail.outlook.com'
</span>EMAIL_PORT <span>= 587
</span>EMAIL_USE_TLS <span>= True
</span>EMAIL_HOST_USER <span>= 'your-email@outlook.com'
</span>EMAIL_HOST_PASSWORD <span>= 'your-app-password'</span>

Encore une fois, Crispy_Forms est une application Django, et nous devons l'inclure sur la liste installée_apps:

EMAIL_HOST <span>= 'smtp.mail.yahoo.com'
</span>EMAIL_PORT <span>= 587
</span>EMAIL_USE_TLS <span>= True
</span>EMAIL_HOST_USER <span>= 'your-email@yahoo.com'
</span>EMAIL_HOST_PASSWORD <span>= 'your-app-password'</span>

Nous utilisons le pack de modèles de bootstrap 4, car les classes de formulaire bootstrap sont compatibles entre la 4e et la 5e version (au moment de la rédaction).

Maintenant, travaillons sur le modèle de contact.html:

python <span>-m venv .venv</span>

Notez comment nous avons prolongé le modèle de base et utiliser l'espace réservé du bloc. C'est ce qui rend la langue du modèle django si efficace, car elle nous permet d'économiser beaucoup de copie et de collage HTML.

En parlant du formulaire, nous utilisons la méthode «Post», ce qui signifie que notre ContactView traitera les données fournies par l'utilisateur et enverra l'e-mail si le formulaire est valide. Le {% csrf_token%} est obligatoire sous chaque forme pour des raisons de sécurité. La documentation de Django a une page dédiée sur les jetons CSRF et les raisons de les utiliser lorsque vous travaillez avec des formulaires.

Nous rendrons le formulaire avec la balise de modèle croustillant, c'est pourquoi nous avons chargé les balises croustillantes avec {% de chargement Crispy_Forms_Tags%}.

Enfin, écrivons le modèle Success.html:

<span># CMD
</span>.venv<span>\Scripts\activate
</span>
<span># Power Shell
</span>.venv<span>\Scripts\Activate.ps1
</span>
<span># WSL
</span><span>source .venv/bin/activate</span>

Comme vous pouvez le voir, c'est une annonce de succès simple avec un lien vers le formulaire de contact au cas où l'utilisateur souhaite envoyer un autre message.

Exécutez à nouveau le serveur et visitons http: // localhost: 8000 (assurez-vous que le .venv activé et vous êtes dans le dossier racine du projet):

pip <span>install django</span>

L'image ci-dessous montre à quoi ressemble le formulaire de contact final.

Et c'est une image du message de réussite.

Et voici une image de l'e-mail dans la boîte de réception.

meilleures pratiques à suivre

1. Fonction d'envoi d'e-mail réutilisable

Pour rendre votre logique de messagerie par courrier électronique modulaire et réutilisable, vous pouvez déplacer la fonction d'envoi d'e-mail à une fonction d'assistance:

django-admin startproject EmailProject

Vous pouvez maintenant appeler cette fonction partout où vous avez besoin d'envoyer des e-mails, y compris votre formulaire de contact.

2. Test unitaire

Vous pouvez utiliser django.test pour tester les fonctionnalités de Django envoyées par e-mail.

<span>cd EmailProject
</span>python manage.py runserver

3. Envoi Rich Html Emails

Les e-mails HTML offrent une meilleure conception et présentation. Utilisez le moteur de modèle de Django pour créer un riche contenu par e-mail:

tree

4. Intégration des services de messagerie tiers

Pour les applications prêtes pour la production, envisagez d'utiliser des services tiers tels que SendGrid, Mailgun ou AWS SES. Ces services offrent des fonctionnalités avancées comme l'analyse des e-mails, le suivi de livraison et le filtrage des spams.

├── EmailProject
│   ├── asgi.py
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

1 directory, 6 files

5. Vérification des e-mails dans l'enregistrement des utilisateurs

Envoyez des liens de vérification par e-mail pendant l'enregistrement des utilisateurs pour éviter les comptes de spam.

<span># EmailProject/settings.py
</span>
<span># Bottom of the file
</span>EMAIL_BACKEND <span>= 'django.core.mail.backends.smtp.EmailBackend'
</span>EMAIL_HOST <span>= ''
</span>EMAIL_PORT <span>= 587
</span>EMAIL_USE_TLS <span>= True
</span>EMAIL_HOST_USER <span>= ''
</span>EMAIL_HOST_PASSWORD <span>= ''
</span>

Envelopper

Félicitations! Vous avez appris à envoyer des e-mails avec Django et à créer également un formulaire de contact Django.

Il existe de nombreuses façons d'envoyer des e-mails avec Django. Dans ce tutoriel, vous avez réussi votre adresse e-mail personnelle, mais je voudrais que vous exploriez d'autres outils et les intégrer dans vos projets.

Dans ce tutoriel, nous avons couvert ce qui suit:

• Comment configurer les paramètres de Django pour servir les e-mails
• Comment utiliser un compte de messagerie personnel pour envoyer des e-mails dans un petit projet
• Comment utiliser des fichiers .env pour utiliser des données sensibles dans un projet Django
• Comment construire un formulaire de contact automatisé

Pour en savoir plus sur Django, consultez «Créer une application de partage de photos avec Django».

FAQ sur Django Envoyer un e-mail avec SMTP Server

Puis-je envoyer un e-mail de Django?

Oui, Django fournit un framework en fin de messagerie intégré qui facilite l'envoi de courriels. En configurant les paramètres SMTP dans votre fichier SetfitS.py, vous pouvez envoyer des e-mails à l'aide de la fonction Send_Mail ou du CourmandMessage.

Comment envoyer des e-mails dans Django?

pour configurer Django pour envoyer des e-mails:

• Définissez les détails SMTP dans votre fichier SetfitS.py: email_backend = 'django.core.mail.backends.smtp.emailbackend' email_host = 'smtp.gmail.com' email_port = 587 e-mail_use_tls = True_Host_User = 'your_email @ exemple .com 'email_host_password =' ​​your_app_password '
• Utilisez un mot de passe sécurisé au lieu de votre mot de passe d'e-mail principal si vous utilisez des fournisseurs Gmail ou similaires.
• Pour la production, envisagez d'utiliser des services tiers comme SendGrid, Mailgun ou Amazon SES pour une meilleure évolutivité.

Comment envoyer Outlook Mail dans Django?

Pour envoyer Outlook Mail dans Django, vous pouvez utiliser les fonctionnalités d'envoi d'e-mails de Django avec les paramètres SMTP pour Outlook. Dans le fichier SetfitS.py de votre projet Django, configurez les paramètres SMTP pour Outlook. Ces paramètres permettront à Django de se connecter au serveur SMTP Outlook pour envoyer des e-mails.

Comment recevoir des e-mails dans Django?

Dans les paramètres de votre projet Django.py, configurez vos paramètres de serveur de messagerie entrant. Vous avez généralement besoin des détails du serveur IMAP (Internet Message Access Protocol) pour votre fournisseur de messagerie, ainsi que des informations d'authentification. Ensuite, utilisez la bibliothèque IMAPLIB pour vous connecter à votre serveur de messagerie et récupérer les e-mails. Vous pouvez le faire dans vos vues Django ou vos commandes de gestion personnalisées. Une fois que vous avez récupéré un e-mail, vous pouvez les traiter, extraire des informations et effectuer toutes les actions nécessaires dans votre application Django. Cela pourrait impliquer l'analyse du contenu de l'e-mail, le stockage des données pertinentes dans votre base de données ou déclencher des actions spécifiques en fonction du contenu ou de l'expéditeur de l'e-mail.

Comment tester les e-mails envoyant Django sans envoyer de vrais e-mails?

Pendant le développement, vous pouvez utiliser un backend de messagerie en option pour tester les e-mails sans vous connecter à un vrai serveur SMTP. Par exemple: backend e-mail de la console: imprime les e-mails au terminal au lieu de les envoyer.

python <span>-m venv .venv</span>

Pour des tests plus avancés, utilisez des outils comme MailHog ou MailTrap, qui agissent comme de faux serveurs SMTP pour capturer et afficher les e-mails de test.

Comment gérer les informations d'identification des e-mails sensibles en toute sécurité?

Utilisez Django Environ pour charger des informations d'identification sensibles (comme l'hôte de messagerie, le nom d'utilisateur et le mot de passe) à partir d'un fichier .env:

1. Installer Django Environ: PIP Installer Django-Environ
2. Créer un fichier .env: email_host = smtp.gmail.com email_host_user=your_email@example.com email_host_password = your_app_password
3. Chargez le fichier .env dans settings.py:Import Environ Env = Environ.env () Environ.env.Read_env () email_host = env ('eMand_host') email_host_user = env ('email_host_user') email_host_password = env (' Email_host_password ')

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!