Como Enviar E-mail com Django

Neste tutorial, vamos mostrar como enviar e-mails usando Django. Vamos cobrir como configurar conexões SMTP no Django, como configurar uma senha de aplicativo para seu provedor de e-mail e como enviar e-mails através do shell do Django. Também veremos como configurar um formulário de contato para seu aplicativo Django, o que permitirá que seus clientes entre em contato com você.

A maioria dos aplicativos web utiliza e-mail para gerenciar operações cruciais, como redefinição de senhas, ativação de conta, recebimento de feedback do cliente, envio de newsletters e campanhas de marketing. A maioria dessas tarefas requer um serviço dedicado como SendGrid ou Mailgun. Mas se você não espera que seu site receba uma quantidade massiva de visitantes, pode realmente fazer muito usando seu provedor de e-mail pessoal.

Enviar e-mails com seu e-mail pessoal é uma opção razoável para projetos pequenos ou de teste, então vamos adotar essa abordagem aqui para manter as coisas simples. No entanto, não é uma boa ideia usar seu serviço de e-mail pessoal para seu site de produção. Você pode aprender mais sobre restrições de envio do Gmail, ou consultar as limitações de seu provedor de e-mail.

Nota: o código completo deste tutorial está disponível no GitHub.

Compreendendo o SMTP

SMTP (ou o Simple Mail Transfer Protocol) é um conjunto de regras para determinar como os emails são transferidos de remetentes para destinatários. Os servidores SMTP utilizam este protocolo para enviar e encaminhar emails de saída. (Note que outros protocolos regulam como os emails são recebidos.)

Um servidor SMTP sempre possui um endereço único e uma porta específica para enviar mensagens, que na maioria dos casos é 587. Veremos como a porta é relevante ao enviar emails com Django.

Como usaremos o Gmail, o endereço com o qual trabalharemos é smtp.gmail.com, e a porta será 587.

Agora, vejamos como podemos enviar emails com Django.

Criando um Projeto Django

Todo projeto Django deve ter um ambiente virtual, pois não queremos bagunçar as dependências do projeto. Para criar um, execute o seguinte:

python -m venv .venv

Nota: se você não está familiarizado com ambientes virtuais, certifique-se de consultar nosso guia de ambientes virtuais do Python.

O comando acima cria um ambiente virtual com o nome .venv. Para ativar este ambiente virtual, você pode usar o seguinte:

source .venv/bin/activate

Como Django é um pacote de terceiros, você deve instalá-lo com pip:

pip install django

Isso instalará a versão mais recente do Django, que você pode verificar com pip freeze.

Para criar um projeto Django, você chama o utilitário de linha de comando django-admin:

django-admin startproject EmailProject

Com o comando acima, você está criando um projeto Django com o nome EmailProject, mas você pode criar o projeto com qualquer nome que desejar.

Agora, entre na pasta do projeto e inicie o servidor:

cd EmailProject
python manage.py runserver

Após iniciar o servidor Django, visite http://localhost:8000 em seu navegador. Você verá uma página gerada automaticamente com as notas de lançamento da versão mais recente do Django.

Modificando Configurações

Você precisará modificar o arquivo de configurações antes de enviar emails, então vamos localizar esse arquivo com o comando tree:

Nota: por simplicidade, estaremos usando apenas comandos de sistema UNIX (macOS ou Linux).

tree

O comando tree exibe a estrutura de arquivos de um diretório. Neste caso, como não estamos fornecendo um caminho de diretório específico, obteremos algo semelhante ao seguinte se estivermos na pasta raiz do projeto:

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

1 directory, 6 files

O arquivo que constantemente estaremos modificando ao longo deste tutorial é o settings.py dentro da pasta EmailProject.

settings.py contém todas as configurações do projeto que você precisará e permite que você defina variáveis personalizadas. Como dizem as documentações do Django, “Um arquivo de configurações é apenas um módulo Python com variáveis de nível de módulo”.

Vamos analisar as configurações necessárias para enviar um email com Django. Abra o arquivo EmailProject/settings.py e cole as seguintes configurações no final do arquivo:

# EmailProject/settings.py

# Bottom of the file
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = ''
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = ''
EMAIL_HOST_PASSWORD = ''

Vamos detalhar o código acima analisando cada uma dessas configurações.

Backend de Email

A configuração EMAIL_BACKEND declara o backend que nosso projeto Django usará para se conectar ao servidor SMTP.

Essa variável está apontando para a classe smtp.EmailBackend que recebe todos os parâmetros necessários para enviar um email. Recomendo fortemente que você dê uma olhada no construtor da classe diretamente no código-fonte do Django. Você ficará surpreso com a legibilidade desse código.

Nota: embora essa classe seja o EMAIL_BACKEND padrão, é considerado uma boa prática ser explícito nas configurações do Django.

Todas as outras configurações de email serão baseadas no construtor desta classe EmailBackend.

Host de Email

A configuração EMAIL_HOST refere-se ao domínio do servidor SMTP que você usará. Isso depende do seu provedor de email. Abaixo está uma tabela com o host do servidor SMTP correspondente a três provedores comuns:

Email provider	SMTP server host
Gmail	smtp.gmail.com
Outlook/Hotmail	smtp-mail.outlook.com
Yahoo	smtp.mail.yahoo.com

Estamos deixando essa configuração em branco por enquanto, pois usaremos um arquivo .env mais tarde para evitar chaves sensíveis codificadas de forma rígida ou configurações específicas do site. Você nunca deve definir credenciais diretamente no código.

Vamos usar Django Environ para resolver esse problema.

Porta de Email

A configuração EMAIL_PORT deve ser definida como 587 porque é a porta padrão para a maioria dos servidores SMTP. Isso continua verdadeiro para provedores de email pessoais.

Esta porta é usada junto com a criptografia TLS para garantir a segurança da entrega de emails.

Email Use TLS

Transport Layer Security (TLS) é um protocolo de segurança usado na Web para criptografar a comunicação entre aplicativos web (Django) e servidores (servidor SMTP).

Inicialmente, definimos a variável EMAIL_USE_TLS como True. Isso significa que o Django usará a Transport Layer Security para se conectar ao servidor SMTP e enviar emails. (É obrigatório para provedores de email pessoais.)

Usuário do Host de Email

A configuração EMAIL_HOST_USER é seu endereço de email pessoal. Deixe-o em branco por enquanto, pois usaremos django-environ para configurar todas essas credenciais.

Senha do Host de Email

A configuração EMAIL_HOST_PASSWORD é a senha de aplicativo que você obterá de sua conta de email — um processo que faremos logo após esta seção.

Mesma história: deixe esta configuração em branco, pois usaremos variáveis de ambiente mais tarde.

Configurar uma Senha de Aplicativo no Gmail

Para usar a configuração EMAIL_HOST_PASSWORD, você precisará ativar o acesso a aplicativos menos seguros e ter uma senha de aplicativo de seu endereço de email pessoal.

Se você não ativar o acesso a aplicativos menos seguros, provavelmente receberá um SMTPAuthenticationError, pois o Django não tem como cumprir os protocolos de segurança do Google.

Você pode optar por usar sua senha normal, mas seria ainda mais arriscado do que usar uma senha de aplicativo. Minha recomendação é criar uma nova conta do Gmail ou usar um endereço de email “de teste”.

Levando isso em consideração, você pode obter uma senha de aplicativo do Gmail com os passos abaixo. Observe que, se estiver usando uma conta existente e habilitou a verificação em duas etapas, poderá pular os passos 2 e 3:

1. Crie ou faça login em uma conta do Gmail
2. Vá para myaccount.google.com/lesssecureapps e ative a opção de aplicativos menos seguros.
   
3. Habilite a autenticação de dois fatores, pois é necessária para obter uma senha de aplicativo.
   
4. Agora que você habilitou a autenticação de dois fatores, é hora de obter uma senha de aplicativo. Você pode fazer isso indo até a seção de segurança de sua conta do Google, rolando até a seção de Entrar no Google e clicando em Senhas de aplicativo.
   

Você precisará reintroduzir sua senha (senha da conta) antes de ser redirecionado para a página de Senhas de aplicativo.

Uma vez dentro, clique em selecionar aplicativo, onde você escolherá um nome personalizado para essa senha de aplicativo — como “Enviar Email Django” — e depois clique em GERAR.

A new window will show up with a sixteen-character password. Copy it, because we’ll need it to configure our Django project.

Se você estiver usando outros provedores de email, certifique-se de ler os seguintes guias:

• Senha de aplicativo do Yahoo
• Senha de aplicativo do Outlook ou Hotmail

Usando Django Environ para Esconder Chaves Sensíveis

Mesmo que você esteja apenas enviando emails no desenvolvimento, não deve escrever senhas diretamente no código-fonte. Isso se torna ainda mais importante ao usar um sistema de controle de versão junto com o GitHub para hospedar seu projeto. Você não quer que as pessoas acessem seus dados.

Vejamos como podemos evitar isso usando Django-environ.

Crie um arquivo .env dentro do diretório EmailProject (onde o arquivo settings.py está localizado) com o comando abaixo:

cd EmailProject/
ls

settings.py # O arquivo de configurações deve estar aqui

touch .env

Agora, abra esse arquivo .env e insira os seguintes pares chave-valor:

EMAIL_HOST=smtp.gmail.com
EMAIL_HOST_USER=YourEmail@address
EMAIL_HOST_PASSWORD=YourAppPassword
RECIPIENT_ADDRESS=TheRecieverOfTheMails

Analisando o conteúdo deste arquivo:

• EMAIL_HOST: o endereço do servidor SMTP do seu provedor de email. Consulte a tabela de provedores de email acima para orientação rápida. Neste caso, estou usando smtp.gmail.com, o endereço SMTP do Gmail.
• EMAIL_HOST_USER: seu endereço de email.
• EMAIL_HOST_PASSWORD: a senha de aplicativo que você acabou de gerar. Tenha em mente que não inclui nenhum espaço.
• RECIPIENT_ADDRESS: o endereço de email no qual você receberá as mensagens. Esta é uma configuração personalizada que criaremos posteriormente para enviar todos os emails para o mesmo destinatário.

Para fazer uso dessas variáveis ambientais, precisaremos instalar Django-environ:

pip install django-environ

Observação: certifique-se de que seu ambiente virtual esteja ativado.

Agora, abra o settings.py localizado na pasta EmailProject e use o código abaixo:

# EmailProject/settings.py
# Isso deve estar no início do arquivo
import environ

env = environ.Env()
environ.Env.read_env()

# Configurações anteriores...
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = env('EMAIL_HOST')
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = env('EMAIL_HOST_USER')
EMAIL_HOST_PASSWORD = env('EMAIL_HOST_PASSWORD')

# Configuração personalizada. Para email
RECIPIENT_ADDRESS = env('RECIPIENT_ADDRESS')

Primeiro, estamos importando o pacote environ no topo do arquivo de configurações. Lembre-se de que todas as importações devem estar no início.

Em seguida, criamos uma variável env que conterá todos os pares chave-valor disponíveis no .env.

A instrução env('KEY') significa que estamos procurando o valor dessa chave. Certifique-se de ter configurado seu arquivo .env antes de prosseguir, pois você receberá um erro ImproperlyConfigured do Django caso alguma variável ambiental não tenha sido definida.

Note que RECIPIENT_ADDRESS é uma configuração personalizada que usaremos para enviar emails para um endereço que podemos acessar.

Não esqueça de incluir o arquivo .env em seu .gitignore caso esteja usando o Git e o GitHub. Você pode fazer isso abrindo-o e adicionando a seguinte linha:

.env

1. Enviando Emails com o Shell do Django

Finalmente, chegamos à parte interessante do artigo! É hora de enviar seu primeiro email para o Django.

Abra um terminal, ative o ambiente virtual e execute:

python manage.py shell

Isso criará um shell com todas as configurações do Django já pré-configuradas para nós. Dentro desse novo shell, cole o seguinte código:

>>> from django.core.mail import send_mail
>>> from django.conf import settings
>>> send_mail(
...     subject='A cool subject',
...     message='A stunning message',
...     from_email=settings.EMAIL_HOST_USER,
...     recipient_list=[settings.RECIPIENT_ADDRESS])
1

Também podemos fazer uma linha única sem especificar os argumentos:

>>> send_mail('A cool subject', 'A stunning message', settings.EMAIL_HOST_USER, [settings.RECIPIENT_ADDRESS])
1

Vamos analisar o código acima:

• Importamos a função do Django send_mail.
• Em seguida, importamos o objeto settings que contém todas as configurações globais e as configurações por site (aquelas dentro do arquivo settings.py).
• Por fim, passamos todos os argumentos necessários para a função send_mail. Essa função retorna o número de emails enviados, neste caso, 1.

Observe como estamos usando o objeto settings para obter o from_email (o email com o qual você está enviando emails) e a recipient_list (a configuração personalizada RECIPIENT_ADDRESS que definimos no arquivo .env).

Agora, se eu verificar minha caixa de entrada — como defini a variável ambiental RECIPIENT_ADDRESS como meu endereço de email — receberei a mensagem enviada pelo Django.

2. Criar um Formulário de Contato Automatizado com Django

Nesta seção, construiremos um formulário de contato automatizado com formulários Django e a função interna send_mail. Além disso, criaremos uma função personalizada, send(), dentro do formulário de contato para facilitar sua implementação nas views.

Vamos começar criando o aplicativo de contato. Entre na pasta raiz do projeto — onde manage.py está localizado — e execute:

python manage.py startapp contact

Em seguida, instale-o na variável INSTALLED_APPS dentro do arquivo EmailProject/settings.py:

# EmailProject/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    ...

    # Custom
    'contact',
]

Antes de avançar com o aplicativo contact, vamos configurar os urlpatterns dentro do arquivo EmailProject/urls.py. Para isso, importe a função django.urls.include e inclua os URLs de contato no projeto global. Não se preocupe; configuraremos os URLs de contato mais tarde:

# EmailProject/urls.py

from django.contrib import admin
from django.urls import path, include # Nova importação

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('contact.urls')) # Incluir URLs de Contato
]

Formulário de Contato

Entre na pasta do aplicativo contact e crie um arquivo forms.py. É uma boa prática definir todos os seus formulários dentro de um arquivo forms.py, mas não é obrigatório. É por isso que o Django não inclui este arquivo por padrão.

Você pode criar o arquivo de formulários com os seguintes comandos:

cd ../contact/
# Você estava dentro da pasta EmailProject
touch forms.py

Abra o arquivo que acabou de criar e faça as seguintes importações:

# contact/forms.py

from django import forms
from django.conf import settings
from django.core.mail import send_mail

O módulo de formulários do Django nos fornece todas as classes e campos necessários para criar nosso formulário de contato. Mais uma vez estamos importando o objeto settings e a função send_mail para enviar os emails.

Nosso formulário de contato conterá vários campos e usará dois métodos personalizados: get_info(), que formata as informações fornecidas pelo usuário, e send(), que enviará a mensagem.

Vamos ver isso implementado em código:

# contact/forms.py

class ContactForm(forms.Form):

    name = forms.CharField(max_length=120)
    email = forms.EmailField()
    inquiry = forms.CharField(max_length=70)
    message = forms.CharField(widget=forms.Textarea)

    def get_info(self):
        """
        Method that returns formatted information
        :return: subject, msg
        """
        
# Dados limpos

        cl_data = super().clean()

        name = cl_data.get('name').strip()
        from_email = cl_data.get('email')
        subject = cl_data.get('inquiry')

        msg = f'{name} with email {from_email} said:'
        msg += f'\n"{subject}"\n\n'
        msg += cl_data.get('message')

        return subject, msg

    def send(self):

        subject, msg = self.get_info()

        send_mail(
            subject=subject,
            message=msg,
            from_email=settings.EMAIL_HOST_USER,
            recipient_list=[settings.RECIPIENT_ADDRESS]
        )

Esta é uma classe enorme, então vamos analisar o que estamos fazendo em cada parte. Primeiro, definimos quatro campos que serão necessários para enviar a mensagem:

• name e enquiry são CharFields que representam o nome e o motivo da mensagem de contato.
• email é um EmailField que representa o email da pessoa que está tentando entrar em contato com você. Tenha em mente que o email não será enviado pelo endereço de email do usuário, mas pelo endereço de email que você configurou para enviar os emails no projeto Django.
• message é outro CharField com a exceção de que estamos usando o widget Textarea. Isso significa que, ao exibir o formulário, ele renderizará uma tag <textarea> em vez de uma simples <input>.

Avançando para os métodos personalizados, estamos apenas usando o método get_info para formatar as informações fornecidas pelo usuário e retornar duas variáveis: subject, que nada mais é do que o campo inquiry, e o message, que será a mensagem real enviada por Django.

Por outro lado, o método send() apenas obtém as informações formatadas de get_info e envia a mensagem com a função send_mail.

Embora esta seção tenha sido bastante grande, você verá como simplificamos as visualizações de contato implementando toda a lógica de envio no próprio ContactForm.

Visualizações de Contato

Abra o arquivo contact/views.py e adicione as seguintes importações:

# contact/views.py
from django.views.generic import FormView, TemplateView
from .forms import ContactForm
from django.urls import reverse_lazy

Como você pode ver, vamos usar visualizações genéricas do Django, o que nos economiza muito tempo ao realizar tarefas simples — por exemplo, ao configurar um formulário com FormView ou criar uma visualização que apenas renderiza um template com TemplateView.

Além disso, estamos importando o ContactForm que construímos na seção anterior e a função reverse_lazy usada ao trabalhar com views baseadas em classes.

Continuando com as views, vamos escrever o ContactView:

# contact/views.py

class ContactView(FormView):
    template_name = 'contact/contact.html'
    form_class = ContactForm
    success_url = reverse_lazy('contact:success')

    def form_valid(self, form):
        # Chama o método personalizado send
        form.send()
        return super().form_valid(form)

Como você pode ver, estamos construindo uma simples FormView usando o ContactForm que criamos. Também estamos configurando o template_name e o success_url. Vamos escrever o template HTML e configurar as URLs mais tarde.

O método form valid nos permite enviar o email usando o método ContactForm.send() apenas se todos os campos do formulário forem válidos. Isso implica que, se o usuário inserir uma entrada inválida — como um endereço de email não formatado — a mensagem não será enviada.

A implementação acima do método form_valid seria equivalente ao seguinte em uma view baseada em função:

# Visualização de contato baseada em função anterior ...

if request.method == 'POST':
    form = ContactForm(request.POST)
    if form.is_valid():
        form.send()
        return redirect('contact:success')
else:
    form = ContactForm())

Encerrando esta seção, vamos escrever um ContactSucessView, que mostrará uma mensagem de sucesso ao usuário. Como já importamos a classe TemplateView, precisamos apenas herdar dela e definir o atributo template_name:

# contact/views.py
class ContactSuccessView(TemplateView):
    template_name = 'contact/success.html'

Você pode verificar o arquivo views.py no repositório do GitHub caso tenha alguma dúvida.

URLs de Contato

É hora de criar os padrões de URL do aplicativo contact. Como o Django não fornece o arquivo urls.py por padrão, precisaremos criá-lo com o seguinte comando (certifique-se de estar dentro da pasta do aplicativo contact):

pwd
# /caminho/para/projeto/EmailProject/contact
touch urls.py

Abra aquele arquivo e configure as variáveis app_name e urlpatterns:

from django.urls import path
from .views import ContactView, ContactSuccessView

app_name = 'contact'

urlpatterns = [
    path('', ContactView.as_view(), name="contact"),
    path('success/', ContactSuccessView.as_view(), name="success"),
]

Usamos path para incluir a rota e sua respectiva visualização na configuração de URL do aplicativo. Quando definimos a variável app_name como 'contact', isso significa que o namespacing de URL do aplicativo será assim:

contact:name_of_path
# Para ContactView
contact:contact
# Para ContactSuccessView
contact:success

Nota: um namespace é o que chamamos dinamicamente de URLs em modelos e visualizações do Django.

Você pode aprender mais sobre o despachante de URLs do Django na documentação oficial.

Escrevendo templates

Os templates do Django são a maneira preferida de exibir dados dinamicamente, usando HTML e tags especiais que a Linguagem de Template do Django nos fornece.

Para este aplicativo específico, usaremos três templates:

• base.html: todos os outros templates herdarão dele. Conterá todo o esqueleto HTML que todos os templates devem ter, bem como links para o Bootstrap.
• contact.html: exibe o formulário de contato.
• success.html: exibe uma mensagem de sucesso.

Vamos começar criando a estrutura de templates do aplicativo de contato (certifique-se de que você está dentro da pasta do aplicativo de contato):

mkdir -p templates/contact/
cd templates/contact
touch base.html contact.html success.html

Os comandos acima criam a estrutura de templates típica de um aplicativo Django reutilizável — appname/templates/appname — e os arquivos de template de árvore que mencionei anteriormente.

Aqui está como a estrutura de arquivos do aplicativo deve agora parecer:

.
├── admin.py
├── apps.py
├── forms.py
├── __init__.py
├── migrations
│   └── __init__.py
├── models.py
├── templates
│   └── contact
│       ├── base.html
│       ├── contact.html
│       └── success.html
├── tests.py
├── urls.py
└── views.py

Vamos mergulhar no conteúdo do template base.html:

<!-- contact/templates/contact/base.html -->

<!DOCTYPE html>
<html lang="en">

  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Django Email Send</title>
    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet"
      integrity="sha384-wEmeIV1mKuiNpC+IOBjI7aAzPcEZeedi5yW5f2yOq55WWLwNGmvvx4Um1vskeMj0" crossorigin="anonymous" />
  </head>

  <body>
    {% block body %}

    {% endblock %}
    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"
      integrity="sha384-p34f1UUtsS3wqzfto5wAAmdvj+osOnFyQFpp4Ua3gs/ZVWx6oOypYoCJhGGScy+8" crossorigin="anonymous">
    </script>
  </body>

</html>

Como você pode ver, é o esqueleto simples de um arquivo HTML que inclui links para Bootstrap 5. Isso nos permite estilizar nosso aplicativo de contato sem usar arquivos CSS.

A tag {% block name-of-block %} nos permite configurar um espaço reservado que as “templates filhas” irão utilizar. O uso desta tag torna herança de templates uma tarefa fácil.

Antes de nos aprofundarmos nos formulários, você precisará instalar o pacote Django crispy forms, que nos permite estilizá-los facilmente:

pip install django-crispy-forms

Mais uma vez, crispy_forms é um aplicativo Django, e precisamos incluí-lo na lista INSTALLED_APPS:

# config/settings.py

INSTALLED_APPS = [
    ...

    # apps de terceiros
    'crispy_forms',

    # apps personalizados
    'contact',
]

# Indica o framework frontend que django crispy forms usa
CRISPY_TEMPLATE_PACK = 'bootstrap4'

Utilizamos o pacote de templates do Bootstrap 4, porque as classes de formulário do Bootstrap são compatíveis entre as versões 4 e 5 (no momento da escrita).

Agora, vamos trabalhar no template contact.html:

<!-- contact/templates/contact/contact.html -->

{% extends 'contact/base.html' %}
{% load crispy_forms_tags %}

{% block body %}
<div class="mx-auto my-4 text-center">
    <h1>Contact Us</h1>
</div>
<div class="container">
    <form action="" method="post">
        {% csrf_token %}
        {{ form | crispy }}
    <button class="btn btn-success my-3" type="submit">Send message</button>
    </form>
</div>
{% endblock %}

Observe como estendemos o template base e fazemos uso do espaço reservado do bloco. Isso é o que torna a Linguagem de Template Django tão eficiente, pois nos permite economizar muitas cópias e colagens de HTML.

Ao falar sobre o formulário, estamos usando o método "post", o que significa que nosso ContactView processará os dados fornecidos pelo usuário e enviará o email se o formulário for válido.

O {% csrf_token %} é obrigatório em todos os formulários por razões de segurança. A documentação do Django possui uma página dedicada a tokens CSRF e as razões para usá-los ao trabalhar com formulários.

Vamos renderizar o formulário com a tag crispy, é por isso que carregamos as tags crispy com {% load crispy_forms_tags %}.

Finalmente, vamos escrever o template success.html:

{% extends 'contact/base.html' %}

{% block body %}
<div class="mx-auto my-4 text-center">
    <h1 class="fw-bolder text-success">We sent your message</h1>
    <p class="my-5">You can send another in the <a href="{% url 'contact:contact' %}">contact page</a></p>
</div>
{% endblock %}

Como você pode ver, é um simples anúncio de sucesso que inclui um link para o formulário de contato caso o usuário queira enviar outra mensagem.

Vamos reiniciar o servidor e visitar http://localhost:8000 (certifique-se de que o .venv está ativado e você está dentro da pasta raiz do projeto):

python manage.py runserver

A imagem abaixo mostra como fica o formulário de contato final.

E esta é uma imagem da mensagem de sucesso.

E aqui está uma imagem do email na caixa de entrada.

Conclusão

Parabéns! Você aprendeu a enviar emails com o Django e também a construir um formulário de contato com Django.

Há muitas maneiras de enviar emails com o Django. Neste tutorial, você fez isso com seu endereço de email pessoal, mas gostaria que explorasse outras ferramentas e as integrou em seus projetos.

Neste tutorial, abordamos o seguinte:

• como configurar as configurações do Django para enviar emails
• como usar uma conta de email pessoal para enviar emails em um pequeno projeto
• como usar arquivos .env para usar dados sensíveis em um projeto Django
• como construir um formulário de contato automatizado

Para mais informações sobre Django, confira “Construa um App de Compartilhamento de Fotos com Django”.

Perguntas Frequentes sobre Como Enviar Email com Django