Como configurar email transacional com Postfix e DKIM

O que você vai aprender

Tempo estimado: 50 a 70 minutos. Neste guia, você vai configurar uma VPS Ubuntu para enviar emails transacionais, como confirmação de cadastro, recuperação de senha, recibos e alertas de sistema. O foco é envio confiável, não hospedagem de caixas de entrada completas.

Você vai aprender a:

• Preparar hostname, FQDN e registros DNS necessários para envio de email.
• Instalar Postfix, OpenDKIM, ferramentas de teste SMTP e utilitários DNS.
• Configurar o Postfix para aceitar mensagens locais da aplicação e entregar para a internet.
• Gerar uma chave DKIM de 2048 bits e assinar mensagens do seu domínio.
• Publicar SPF, DKIM e DMARC com valores coerentes para envio transacional.
• Testar entrega, assinatura DKIM, cabeçalhos SMTP e logs do Postfix.
• Corrigir problemas comuns, como porta 25 bloqueada, DKIM inválido e rejeição por PTR.

Esse tipo de configuração faz sentido quando você hospeda uma aplicação própria, por exemplo uma loja, painel SaaS ou API. Se o seu caso envolve ecommerce, leia também o guia sobre VPS para loja virtual, porque email transacional costuma ser parte crítica da experiência de compra.

Pré-requisitos

Você precisa de uma VPS com Ubuntu 22.04 LTS ou 24.04 LTS, acesso SSH com usuário sudo e um domínio real sob seu controle. O guia usa comandos compatíveis com Debian em boa parte das etapas, mas os nomes dos pacotes e caminhos foram validados para Ubuntu. Você também precisa acessar o painel DNS do domínio e o painel do provedor da VPS para configurar o PTR, também chamado de reverse DNS.

Antes de alterar qualquer serviço de email em produção, faça backup dos arquivos atuais. Se a VPS já envia email, a mudança pode afetar notificações de aplicações. Execute:

sudo mkdir -p /root/backup-email-$(date +%F)
sudo cp -a /etc/postfix /root/backup-email-$(date +%F)/ 2>/dev/null || true
sudo cp -a /etc/opendkim* /root/backup-email-$(date +%F)/ 2>/dev/null || true

Saída esperada, quando os diretórios ainda não existem:

O comando pode não imprimir nada, isso é normal. Confirme que o backup foi criado:

sudo ls -la /root/backup-email-$(date +%F)

Você deve ver algo parecido com:

total 16
drwxr-xr-x  3 root root 4096 Jun 22 10:14 .
drwx------ 10 root root 4096 Jun 22 10:14 ..
drwxr-xr-x  5 root root 4096 Jun 22 10:14 postfix

Também tenha em mãos um endereço externo para testes, como uma conta Gmail, Outlook ou uma caixa corporativa. Para aplicações em produção, combine esta configuração com boas práticas de infraestrutura. O conteúdo sobre VPS para desenvolvedores ajuda a planejar ambiente, deploy e observabilidade.

Passo 1: Preparar hostname, DNS básico e pacotes

Comece definindo duas variáveis no shell. Use seu domínio real, sem https:// e sem barra no final. O subdomínio mail será o nome público do servidor SMTP. Esse nome precisa resolver para o IPv4 da VPS e também deve aparecer no PTR.

read -rp "Digite seu domínio, por exemplo suaempresa.com.br: " MAIL_DOMAIN
export MAIL_HOST="mail.${MAIL_DOMAIN}"
export SERVER_IP=$(curl -4 -s https://ifconfig.me)
printf "Domínio: %s\nHost: %s\nIP: %s\n" "$MAIL_DOMAIN" "$MAIL_HOST" "$SERVER_IP"

Saída esperada:

Domínio: suaempresa.com.br
Host: mail.suaempresa.com.br
IP: 203.0.113.25

O IP acima é apenas formato de exemplo. No seu terminal deve aparecer o IP público real da VPS. Agora configure o hostname do sistema:

sudo hostnamectl set-hostname "$MAIL_HOST"
hostname -f

Saída esperada:

mail.suaempresa.com.br

Atualize os pacotes e instale as ferramentas. O Postfix será o MTA, o OpenDKIM assinará as mensagens, swaks ajudará nos testes SMTP e dnsutils permitirá consultar DNS pelo terminal.

sudo apt update
sudo DEBIAN_FRONTEND=noninteractive apt install -y postfix opendkim opendkim-tools mailutils swaks dnsutils curl ca-certificates

Você deve ver uma saída parecida com:

Setting up postfix ...
Setting up opendkim ...
Setting up swaks ...
Processing triggers for man-db ...

Verifique versões e serviços:

postconf mail_version
systemctl is-enabled postfix
systemctl is-enabled opendkim

Saída esperada:

mail_version = 3.6.4
enabled
enabled

Se o Postfix pedir um tipo de configuração durante a instalação, escolha Internet Site e informe o domínio principal. Mesmo que você não veja a tela interativa, o próximo passo sobrescreve os parâmetros necessários com postconf.

Passo 2: Configurar o Postfix para envio transacional local

Nesta configuração, o Postfix receberá emails apenas da própria VPS, via localhost, e enviará para destinatários externos. Isso reduz a superfície de ataque, porque você não abrirá relay público. Se sua aplicação roda em outro servidor e precisa autenticar via SMTP remoto, você deve adicionar SASL e firewall depois, com cuidado extra.

Faça um backup pontual do arquivo principal antes de alterar:

sudo cp /etc/postfix/main.cf /etc/postfix/main.cf.bak.$(date +%F-%H%M)

Confirme:

ls -1 /etc/postfix/main.cf.bak.* | tail -n 1

Saída esperada:

/etc/postfix/main.cf.bak.2026-06-22-1018

Agora aplique os parâmetros principais. O inet_interfaces=loopback-only faz o Postfix escutar apenas em 127.0.0.1, ideal para aplicação local. O TLS de saída usa os certificados raiz do sistema para negociar criptografia quando o servidor remoto oferece suporte.

sudo postconf -e "myhostname = $MAIL_HOST"
sudo postconf -e "mydomain = $MAIL_DOMAIN"
sudo postconf -e "myorigin = $MAIL_DOMAIN"
sudo postconf -e "mydestination = $MAIL_HOST, localhost.$MAIL_DOMAIN, localhost"
sudo postconf -e "inet_interfaces = loopback-only"
sudo postconf -e "inet_protocols = ipv4"
sudo postconf -e "relayhost ="
sudo postconf -e "home_mailbox = Maildir/"
sudo postconf -e "smtp_tls_security_level = may"
sudo postconf -e "smtp_tls_loglevel = 1"
sudo postconf -e "smtp_tls_CAfile = /etc/ssl/certs/ca-certificates.crt"

Verifique os valores gravados:

postconf -n | egrep '^(myhostname|mydomain|myorigin|mydestination|inet_interfaces|inet_protocols|smtp_tls)'

Saída esperada:

inet_interfaces = loopback-only
inet_protocols = ipv4
mydestination = mail.suaempresa.com.br, localhost.suaempresa.com.br, localhost
mydomain = suaempresa.com.br
myhostname = mail.suaempresa.com.br
myorigin = suaempresa.com.br
smtp_tls_CAfile = /etc/ssl/certs/ca-certificates.crt
smtp_tls_loglevel = 1
smtp_tls_security_level = may

Reinicie e confirme que o Postfix escuta apenas localmente:

sudo systemctl restart postfix
sudo ss -ltnp | grep ':25'

Saída esperada:

LISTEN 0 100 127.0.0.1:25 0.0.0.0:* users:(("master",pid=1234,fd=13))

Se aparecer 0.0.0.0:25, revise inet_interfaces, pois isso expõe o SMTP para a rede pública.

Passo 3: Gerar chaves DKIM com OpenDKIM

DKIM adiciona uma assinatura criptográfica ao email. O servidor assina com uma chave privada, e os provedores verificam a assinatura usando a chave pública publicada no DNS. Isso não garante entrega na caixa de entrada, mas melhora reputação e reduz falhas de autenticação.

Crie a estrutura de chaves usando um seletor. O seletor permite trocar chaves no futuro sem quebrar mensagens antigas. Aqui usaremos tx2026, um nome curto para email transacional.

export DKIM_SELECTOR="tx2026"
sudo mkdir -p "/etc/opendkim/keys/$MAIL_DOMAIN"
sudo opendkim-genkey -b 2048 -s "$DKIM_SELECTOR" -d "$MAIL_DOMAIN" -D "/etc/opendkim/keys/$MAIL_DOMAIN"
sudo chown -R opendkim:opendkim "/etc/opendkim/keys/$MAIL_DOMAIN"
sudo chmod 600 "/etc/opendkim/keys/$MAIL_DOMAIN/${DKIM_SELECTOR}.private"

Verifique os arquivos:

sudo ls -l "/etc/opendkim/keys/$MAIL_DOMAIN"

Saída esperada:

-rw------- 1 opendkim opendkim 1704 Jun 22 10:25 tx2026.private
-rw------- 1 opendkim opendkim  512 Jun 22 10:25 tx2026.txt

O arquivo .private nunca deve ser publicado. Ele precisa ficar apenas na VPS, protegido por permissão restrita. O arquivo .txt contém o registro DNS. Veja o conteúdo:

sudo cat "/etc/opendkim/keys/$MAIL_DOMAIN/${DKIM_SELECTOR}.txt"

Saída esperada:

tx2026._domainkey IN TXT ( "v=DKIM1; h=sha256; k=rsa; "
          "p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQE..." ) ; ----- DKIM key tx2026 for suaempresa.com.br

Agora configure tabelas do OpenDKIM. Estes arquivos dizem qual chave assina cada domínio, quais remetentes devem ser assinados e quais hosts são confiáveis.

printf "%s._domainkey.%s %s:%s:/etc/opendkim/keys/%s/%s.private\n" "$DKIM_SELECTOR" "$MAIL_DOMAIN" "$MAIL_DOMAIN" "$DKIM_SELECTOR" "$MAIL_DOMAIN" "$DKIM_SELECTOR" | sudo tee /etc/opendkim/KeyTable
printf "*@%s %s._domainkey.%s\n" "$MAIL_DOMAIN" "$DKIM_SELECTOR" "$MAIL_DOMAIN" | sudo tee /etc/opendkim/SigningTable
printf "127.0.0.1\nlocalhost\n%s\n" "$MAIL_HOST" | sudo tee /etc/opendkim/TrustedHosts

Saída esperada:

127.0.0.1
localhost
mail.suaempresa.com.br

Confira antes de seguir:

sudo cat /etc/opendkim/KeyTable /etc/opendkim/SigningTable /etc/opendkim/TrustedHosts

Se o domínio estiver errado em qualquer linha, corrija agora. DKIM é sensível a domínio, seletor e caminho da chave.

Passo 4: Publicar SPF, DKIM, DMARC e PTR

Agora você precisa publicar DNS. Essa parte acontece no painel do seu provedor DNS, não no terminal da VPS. Mesmo assim, use o terminal para gerar os valores e validar depois. Primeiro anote o IP público atual:

printf "A mail -> %s\n" "$SERVER_IP"
printf "MX @ -> 10 %s\n" "$MAIL_HOST"
printf "SPF @ -> v=spf1 ip4:%s mx -all\n" "$SERVER_IP"
printf "DMARC _dmarc -> v=DMARC1; p=none; rua=mailto:dmarc@%s; adkim=s; aspf=s\n" "$MAIL_DOMAIN"

Saída esperada:

A mail -> 203.0.113.25
MX @ -> 10 mail.suaempresa.com.br
SPF @ -> v=spf1 ip4:203.0.113.25 mx -all
DMARC _dmarc -> v=DMARC1; p=none; rua=mailto:[email protected]; adkim=s; aspf=s

Crie estes registros no DNS:

Tipo A     Nome mail       Valor IP_DA_VPS
Tipo MX    Nome @          Prioridade 10, valor mail.seudominio
Tipo TXT   Nome @          Valor v=spf1 ip4:IP_DA_VPS mx -all
Tipo TXT   Nome _dmarc     Valor v=DMARC1; p=none; rua=mailto:dmarc@seudominio; adkim=s; aspf=s
Tipo TXT   Nome tx2026._domainkey  Valor gerado no arquivo tx2026.txt

Para DKIM, copie apenas o valor que começa em v=DKIM1, juntando as partes entre aspas em uma única linha, sem parênteses. Muitos painéis aceitam colar o conteúdo inteiro, mas outros exigem a chave limpa. Se ficar em dúvida, use a pré-visualização do painel.

Também configure PTR, ou reverse DNS, no painel da VPS: o IP público deve apontar para mail.seudominio. Sem PTR coerente, Gmail, Outlook e servidores corporativos podem aceitar a conexão, mas marcar a mensagem como suspeita ou rejeitar com erro 5xx.

Depois de salvar, aguarde alguns minutos e teste:

dig +short A "$MAIL_HOST"
dig +short MX "$MAIL_DOMAIN"
dig +short TXT "$MAIL_DOMAIN"
dig +short TXT "_dmarc.$MAIL_DOMAIN"
dig +short TXT "$DKIM_SELECTOR._domainkey.$MAIL_DOMAIN"

Saída esperada:

203.0.113.25
10 mail.suaempresa.com.br.
"v=spf1 ip4:203.0.113.25 mx -all"
"v=DMARC1; p=none; rua=mailto:[email protected]; adkim=s; aspf=s"
"v=DKIM1; h=sha256; k=rsa; p=MIIBIjANBg..."

Se você está comparando provedores para esse uso, veja também como avaliamos infraestrutura de VPS, pois rDNS, reputação de IP e suporte a porta 25 fazem diferença em email.

Passo 5: Integrar OpenDKIM ao Postfix

O Postfix precisa conversar com o OpenDKIM por um socket local. No Ubuntu, uma forma estável é criar o socket dentro do chroot do Postfix, em /var/spool/postfix/opendkim/opendkim.sock. Assim o processo do Postfix consegue acessar o milter sem expor porta TCP.

Faça backup da configuração do OpenDKIM:

sudo cp /etc/opendkim.conf /etc/opendkim.conf.bak.$(date +%F-%H%M)

Agora grave uma configuração completa e simples:

sudo tee /etc/opendkim.conf >/dev/null <<EOF
Syslog                  yes
UMask                   002
Canonicalization        relaxed/simple
Mode                    sv
SubDomains              no
AutoRestart             yes
AutoRestartRate         10/1h
UserID                  opendkim
Socket                  local:/var/spool/postfix/opendkim/opendkim.sock
PidFile                 /run/opendkim/opendkim.pid
KeyTable                /etc/opendkim/KeyTable
SigningTable            refile:/etc/opendkim/SigningTable
ExternalIgnoreList      /etc/opendkim/TrustedHosts
InternalHosts           /etc/opendkim/TrustedHosts
EOF

Crie o diretório do socket com permissões adequadas:

sudo mkdir -p /var/spool/postfix/opendkim
sudo chown opendkim:postfix /var/spool/postfix/opendkim
sudo chmod 750 /var/spool/postfix/opendkim
sudo usermod -aG opendkim postfix

Configure o Postfix para usar o milter:

sudo postconf -e "milter_default_action = accept"
sudo postconf -e "milter_protocol = 6"
sudo postconf -e "smtpd_milters = local:opendkim/opendkim.sock"
sudo postconf -e "non_smtpd_milters = local:opendkim/opendkim.sock"

Reinicie os serviços:

sudo systemctl restart opendkim
sudo systemctl restart postfix
sudo systemctl status opendkim --no-pager -l

Saída esperada:

Active: active (running)

Valide a chave contra o DNS. Este teste só passa depois que o registro DKIM propagou:

sudo opendkim-testkey -d "$MAIL_DOMAIN" -s "$DKIM_SELECTOR" -vvv

Saída esperada:

opendkim-testkey: key OK

Se aparecer key not secure, isso geralmente significa que DNSSEC não está ativo. Para este guia, o resultado aceitável é a chave ser encontrada e corresponder à chave privada. Se aparecer no key, volte ao DNS do DKIM.

Passo 6: Enviar mensagens de teste com swaks e mailutils

Antes de ligar a aplicação, teste o envio manual. Comece com uma mensagem via sendmail, que é a interface local que muitas bibliotecas usam por baixo. Troque o destinatário por um email seu fora do domínio.

read -rp "Digite um email externo para teste: " TEST_TO
printf "Subject: Teste transacional Postfix\nFrom: no-reply@%s\nTo: %s\n\nMensagem de teste enviada pela VPS em %s.\n" "$MAIL_DOMAIN" "$TEST_TO" "$(date -Is)" | sendmail -v "$TEST_TO"

Saída esperada:

Mail Delivery Status Report will be mailed to <root>.

Agora use swaks, que mostra a conversa SMTP com mais clareza:

swaks --server 127.0.0.1 --port 25 --from "no-reply@$MAIL_DOMAIN" --to "$TEST_TO" --header "Subject: Teste SMTP local com DKIM" --body "Email transacional de teste via Postfix e OpenDKIM."

Saída esperada:

=== Trying 127.0.0.1:25...
=== Connected to 127.0.0.1.
<-  220 mail.suaempresa.com.br ESMTP Postfix
 -> MAIL FROM:<[email protected]>
<-  250 2.1.0 Ok
 -> RCPT TO:<[email protected]>
<-  250 2.1.5 Ok
 -> DATA
<-  354 End data with <CR><LF>.<CR><LF>
<-  250 2.0.0 Ok: queued as 7F3A8201B2

Acompanhe os logs em outra janela:

sudo tail -f /var/log/mail.log

Você deve ver linhas com status=sent ou, pelo menos, a tentativa de conexão com o servidor remoto:

postfix/qmgr[1201]: 7F3A8201B2: from=<[email protected]>, size=742, nrcpt=1
opendkim[1198]: 7F3A8201B2: DKIM-Signature field added
postfix/smtp[1320]: 7F3A8201B2: to=<[email protected]>, relay=gmail-smtp-in.l.google.com, status=sent (250 2.0.0 OK)

Se sua aplicação usa SMTP, configure host 127.0.0.1, porta 25, sem autenticação e sem TLS, desde que ela rode na mesma VPS. Não exponha isso para a internet. Para apps em containers, prefira rede interna e restrinja acesso por firewall.

Verificação e testes

Faça uma rodada completa de validação antes de considerar o envio pronto para produção. Primeiro confirme que os serviços estão ativos:

systemctl is-active postfix opendkim

Saída esperada:

active
active

Confira se o SMTP não ficou público:

sudo ss -ltnp | grep ':25'

Saída esperada:

LISTEN 0 100 127.0.0.1:25 0.0.0.0:* users:(("master",pid=1234,fd=13))

Teste SPF, DKIM e DMARC via DNS:

dig +short TXT "$MAIL_DOMAIN"
dig +short TXT "$DKIM_SELECTOR._domainkey.$MAIL_DOMAIN"
dig +short TXT "_dmarc.$MAIL_DOMAIN"

Os três registros devem retornar valores. Se algum vier vazio, há erro no nome do registro, na zona DNS ou na propagação.

Depois, envie uma mensagem para um testador externo, como Mail Tester, GlockApps ou uma caixa Gmail. No Gmail, abra a mensagem, clique em Mostrar original e procure por:

SPF: PASS
DKIM: PASS
DMARC: PASS

Também veja a fila do Postfix:

mailq

Saída saudável:

Mail queue is empty

Se houver mensagens presas, veja o motivo:

sudo postqueue -p
sudo tail -n 80 /var/log/mail.log

Não apague a fila sem entender a causa. Em produção, mensagens represadas podem incluir confirmações de compra ou recuperação de senha. Se precisar pausar envios, pare a aplicação antes de mexer na fila.

Troubleshooting

Problema 1: a mensagem fica na fila com conexão recusada ou timeout. Verifique se a VPS consegue sair pela porta 25. Muitos provedores bloqueiam SMTP de saída por padrão. Execute:

swaks --server gmail-smtp-in.l.google.com --port 25 --quit-after CONNECT

Se a saída mostrar timeout, abra chamado com o provedor solicitando liberação de SMTP outbound ou use um relay autenticado, como Amazon SES, Mailgun ou outro serviço transacional. Não tente contornar bloqueios com portas aleatórias, porque os servidores de destino recebem email entre MTAs pela porta 25.

Problema 2: DKIM aparece como fail. Rode:

sudo opendkim-testkey -d "$MAIL_DOMAIN" -s "$DKIM_SELECTOR" -vvv
sudo tail -n 50 /var/log/mail.log | grep -i dkim

Se o teste diz no key, o nome do TXT está errado. Ele deve ser tx2026._domainkey dentro da zona do domínio. Se diz key mismatch, você publicou uma chave diferente da chave privada atual. Copie novamente o valor do arquivo .txt, juntando as strings em uma linha.

Problema 3: Gmail ou Outlook rejeita por PTR, HELO ou reputação. Confira o hostname enviado:

postconf myhostname
dig +short -x "$SERVER_IP"

O reverso deve retornar mail.seudominio. Se retornar nome genérico do provedor, configure PTR no painel da VPS. Em seguida, confirme que o registro A desse hostname aponta de volta para o mesmo IP. Essa consistência é chamada de forward-confirmed reverse DNS.

Problema 4: sua aplicação envia com domínio diferente. Se o remetente for no-reply@outrodominio, a assinatura pode não alinhar com DMARC. Ajuste SigningTable para esse domínio, gere outra chave DKIM e publique DNS correspondente. Para envio transacional, use remetentes estáveis, como no-reply@seudominio ou suporte@seudominio, e evite remetentes dinâmicos de usuários.

Próximos passos

Depois que os testes passarem, configure sua aplicação para usar o Postfix local e registre métricas de envio. Monitore /var/log/mail.log, tamanho da fila, taxa de bounces e reclamações. Comece com volume baixo, especialmente em IP novo, porque reputação de email é construída gradualmente.

Também considere criar aliases para postmaster@seudominio e abuse@seudominio, pois alguns provedores verificam esses contatos. Para ambientes críticos, use DMARC com p=none por alguns dias, analise relatórios e só depois avance para quarantine ou reject. Se o volume crescer, avalie separar IPs por tipo de mensagem, transacional e marketing, ou usar um provedor transacional dedicado como relay, mantendo o Postfix apenas como camada local da aplicação.