Biblioteca lettre para Rust: enviando emails

1. O que é e para que serve

lettre (do francês "carta") é uma biblioteca poderosa, assíncrona e type-safe para envio de emails na linguagem Rust. Ela oferece um conjunto completo de ferramentas para criar e enviar mensagens de email, suportando desde textos simples até emails HTML complexos com anexos. A biblioteca é escrita em Rust puro, sem dependências externas em nível de sistema, tornando-a ideal para projetos onde portabilidade e segurança são essenciais.

Para que serve a lettre? No desenvolvimento web moderno, o envio de emails continua sendo uma função crítica: cadastro de usuários, redefinição de senhas, notificações e newsletters. Rust, sendo uma linguagem de sistema, tradicionalmente não tinha ferramentas convenientes para trabalhar com email. A lettre preenche essa lacuna, oferecendo uma API elegante, suporte completo aos padrões SMTP, MIME e SSL/TLS, além de integração com runtimes assíncronos populares (tokio, async-std).

Os principais recursos da biblioteca incluem: suporte a SMTP, SMTPS e SMTP via STARTTLS; criação de mensagens MIME multipartes com anexos; trabalho com partes HTML e texto; suporte a envio assíncrono; codificação automática de anexos e cabeçalhos; e segurança total de tipos em tempo de compilação, prevenindo muitos erros comuns em linguagens dinâmicas.

2. Instalação

Para instalar a biblioteca lettre, adicione-a ao arquivo Cargo.toml do seu projeto:

[dependencies]
lettre = "0.11"

Para uso assíncrono com tokio (recomendado):

[dependencies]
lettre = { version = "0.11", features = ["tokio1-rustls-tls", "builder"] }
tokio = { version = "1", features = ["full"] }

Para uso síncrono (sem runtime assíncrono):

[dependencies]
lettre = { version = "0.11", features = ["rustls-tls", "builder"] }

Após adicionar as dependências, execute o comando:

cargo build

3. Início rápido

Exemplo mínimo funcional de envio de email via servidor SMTP do Gmail:

use lettre::message::header::ContentType;
use lettre::transport::smtp::authentication::Credentials;
use lettre::{Message, SmtpTransport, Transport};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Criando o email
    let email = Message::builder()
        .from("Remetente <seu_email@gmail.com>".parse()?)
        .to("Destinatário <destinatario@exemplo.com>".parse()?)
        .subject("Olá do Rust!")
        .header(ContentType::TEXT_PLAIN)
        .body("Este é um email de teste enviado com lettre.".to_string())?;

    // Configurando o transporte SMTP
    let creds = Credentials::new(
        "seu_email@gmail.com".to_string(),
        "sua_senha_de_app".to_string() // Use uma senha de aplicativo
    );

    let mailer = SmtpTransport::relay("smtp.gmail.com")?
        .credentials(creds)
        .build();

    // Enviando
    match mailer.send(&email) {
        Ok(_) => println!("Email enviado com sucesso!"),
        Err(e) => eprintln!("Erro ao enviar: {:?}", e),
    }

    Ok(())
}

4. Principais métodos e estruturas

4.1. Message::builder()

Assinatura: pub fn builder() -> MessageBuilder

Descrição: Cria um novo builder para construir uma mensagem de email. O builder permite definir todos os parâmetros do email de forma encadeada: remetente, destinatários, assunto, conteúdo e cabeçalhos.

use lettre::Message;

let email = Message::builder()
    .from("usuario@exemplo.com".parse()?)
    .to("destinatario@exemplo.com".parse()?)
    .subject("Teste")
    .body("Olá!".to_string())?;

4.2. MessageBuilder::to()

Assinatura: pub fn to(self, addr: Address) -> MessageBuilder

Descrição: Adiciona um destinatário principal ao email. Pode ser chamado múltiplas vezes para adicionar vários destinatários. O endereço deve ser um email válido no formato padrão.

let email = Message::builder()
    .from("remetente@exemplo.com".parse()?)
    .to("dest1@exemplo.com".parse()?)
    .to("dest2@exemplo.com".parse()?)
    .subject("Múltiplos destinatários")
    .body("Teste".to_string())?;

4.3. SmtpTransport::relay()

Assinatura: pub fn relay(relay: &str) -> Result

Descrição: Cria um builder de transporte SMTP configurado para usar um servidor de relay específico. Este é o método mais comum para configurar o envio através de servidores SMTP como Gmail, Outlook ou servidores corporativos.

use lettre::transport::smtp::SmtpTransport;

let mailer = SmtpTransport::relay("smtp.gmail.com")?
    .credentials(creds)
    .build();

4.4. SmtpTransport::send()

Assinatura: pub fn send(&self, message: &Message) -> Result

Descrição: Envia a mensagem através do transporte SMTP configurado. Retorna o endereço de email do remetente em caso de sucesso ou um erro detalhado em caso de falha. Ideal para uso síncrono.

match mailer.send(&email) {
    Ok(_) => println!("Email enviado!"),
    Err(e) => eprintln!("Falha no envio: {}", e),
}

4.5. Envio assíncrono com Tokio

Descrição: Para aplicações que exigem alta concorrência, a lettre oferece suporte nativo a async/await. Basta usar o transporte assíncrono tokio1-rustls-tls e o método send() com await.

use lettre::AsyncSmtpTransport;
use lettre::Tokio1Executor;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mailer = AsyncSmtpTransport::::relay("smtp.gmail.com")?
        .credentials(creds)
        .build();

    mailer.send(email).await?;
    println!("Email enviado de forma assíncrona!");
    Ok(())
}

5. Conclusão

A biblioteca lettre é a solução mais completa e segura para envio de emails em Rust. Com sua API type-safe, suporte a padrões modernos e integração com runtimes assíncronos, ela atende desde projetos simples até sistemas de alta disponibilidade. Comece com o exemplo básico e explore os recursos avançados conforme sua aplicação crescer.