Como enviar e-mails com o Mailjet

Mailjet é um serviço de e-mail global de terceiros que oferece aos usuários do Compute Engine um nível gratuito com 6.000 e-mails por mês. Além disso, são oferecidos:

interface do usuário, API e redirecionamento SMTP para envio de e-mails transacionais e de marketing;
compliance europeu de privacidade de dados;
recursos de e-mail e de entrega, como configurações de prioridade personalizáveis e gerenciamento automático de controle de fluxo;
biblioteca de recursos de API em Go, PHP, Node.js, Java, Python e Ruby para gerenciar subcontas, autenticação, contatos, campanhas, payloads personalizados, estatísticas, eventos em tempo real e análises por meio da API Event;
framework MJML (em inglês) integrado para criar modelos de e-mail HTML responsivos;
suporte 24 horas em mais de 4 idiomas;
capacidade de enviar mensagens por e-mail a partir de domínios diferentes de gmail.com.

Neste documento, descrevemos como configurar sua instância de VM para enviar mensagens por meio do Mailjet usando os seguintes métodos:

Por meio de um redirecionamento SMTP com:
- Postfix
- Nodemailer no Node.js
Diretamente por meio da API do Mailjet, usando Java

Para documentação extensa de outras soluções de e-mail, incluindo exemplos de integração com a maioria dos servidores SMTP, bibliotecas e frameworks, consulte a documentação do Mailjet (em inglês).

Antes de começar

Crie uma nova conta Mailjet na página de parceiros do Google*. Ao se inscrever, forneça o domínio e o endereço de e-mail pelo qual você quer enviar mensagens.
Receba suas credenciais de conta SMTP do Mailjet.
Verifique se o endereço de e-mail do qual você quer enviar mensagens foi validado (em inglês).
Configure uma regra de firewall para permitir tráfego TCP na porta 2525.

^{* O Google é remunerado por clientes que se inscrevem em uma conta paga.}

Como configurar o Mailjet como um redirecionamento SMTP

A configuração de redirecionamento de e-mail permite que você encaminhe e-mails ao Mailjet para entrega remota.

Como usar o Postfix

Conecte-se à VM por meio do SSH substituindo instance-name pelo nome da instância para a qual você quer enviar mensagens de e-mail:
```
gcloud compute ssh instance-name
```
Na VM, instale o agente de transferência de e-mail Postfix. Quando solicitado, aceite as opções padrão para os nomes de domínio, mas selecione a configuração Local Only.
Debian
```
sudo apt update && sudo apt -y install postfix libsasl2-modules
```
CentOS
```
sudo yum install postfix cyrus-sasl-plain cyrus-sasl-md5 -y
```
Modifique as opções de configuração do Postfix. As opções de configuração do Postfix são definidas no arquivo main.cf. Abra o arquivo com o editor de texto da sua preferência:
```
sudo vi /etc/postfix/main.cf
```
Atualize o arquivo:
1. Marque as seguintes linhas como comentários:
```
# default_transport = error
# relay_transport = error
```
2. Adicione as seguintes linhas ao final do arquivo:
```
relayhost = in-v3.mailjet.com:2525
smtp_tls_security_level = encrypt
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_security_options = noanonymous
```
  Essas linhas aplicam o suporte SSL/TLS e configuram a autenticação SMTP dessas solicitações. Na configuração do Postfix, a autenticação é processada por um módulo de camada simples de autenticação e segurança (SASL, na sigla em inglês).
  Observação: é preciso usar a porta 2525, já que a porta 25 não é permitida no Compute Engine.
3. Salve as alterações e feche o arquivo.
Crie o mapa de senha da SASL com o editor de texto da sua preferência:
```
sudo vi /etc/postfix/sasl_passwd
```
Para o arquivo sasl_passwd, adicione as seguintes linhas para fornecer as credenciais do Mailjet:
```
in-v3.mailjet.com:2525 YOUR_API_KEY:YOUR_SECRET_KEY
```

Use o utilitário postmap para gerar um arquivo .db:

sudo postmap /etc/postfix/sasl_passwd
sudo ls -l /etc/postfix/sasl_passwd*

Você verá a seguinte resposta:

-rw------- 1 root root    68 Jun  1 10:50 /etc/postfix/sasl_passwd
-rw------- 1 root root 12288 Jun  1 10:51 /etc/postfix/sasl_passwd.db

Em seguida, remova o arquivo que contém suas credenciais, porque ele não é mais necessário:
```
sudo rm /etc/postfix/sasl_passwd
```

Defina as permissões no seu arquivo .db:

sudo chmod 600 /etc/postfix/sasl_passwd.db
sudo ls -la /etc/postfix/sasl_passwd.db

Por fim, recarregue sua configuração para carregar os parâmetros modificados:
Debian
```
sudo /etc/init.d/postfix restart
```
CentOS
```
sudo postfix reload
```
Teste sua configuração. Instale o pacote mailx ou mailutils e teste a configuração.
Debian
```
sudo apt -y install mailutils
```
CentOS
```
sudo yum install mailx -y
```
Envie uma mensagem de teste:
```
echo 'Test passed.' | mail -s 'Test-Email' -aFrom:from-email destination-email
```
Substitua:
- from-email: um endereço de e-mail que foi validado (em inglês);
- destination-email: o endereço para o qual enviar a mensagem de e-mail.
Nos registros do sistema, procure uma linha de status que contenha status e o código de resposta bem-sucedida (250) do servidor:
Debian
```
sudo tail -n 5 /var/log/syslog
```
CentOS
```
sudo tail -n 5 /var/log/maillog
```

Se você tiver problemas ao configurar o Postfix com o Mailjet, consulte as instruções de configuração do Mailjet Postfix.

Como usar o Nodemailer

Nas instruções a seguir, há informações sobre como usar o Mailjet com Node.js no Debian Wheezy.

Debian

Conecte-se à sua instância usando SSH:
```
gcloud compute ssh instance-name
```
Atualize os repositórios de pacotes:
```
user@test-wheezy:~# sudo apt update
```

Instale as dependências do Node.js:

user@test-wheezy:~# sudo apt -y install git-core curl build-essential openssl libssl-dev

Clone o repositório Node.js do github:

user@test-wheezy:~# git clone https://github.com/nodejs/node

Altere o diretório para a árvore de origem do Node.js:
```
user@test-wheezy:~# cd node
```
Configure o software do nó para este SO e máquina virtual:
```
user@test-wheezy:~# ./configure
```
Crie Node.js, npm e objetos afins:
```
user@test-wheezy:~# sudo make
```
Isso pode levar alguns minutos para ser concluído.
Instale Node.js, npm e outros softwares no local padrão:
```
user@test-wheezy:~# sudo make install
```

Instale o pacote do remetente:

user@test-wheezy:~# npm install nodemailer nodemailer-smtp-transport

No diretório node, crie um novo arquivo chamado sendmail.js que contenha o seguinte JavaScript:

const mailer = require('nodemailer');
const smtp = require('nodemailer-smtp-transport');

async function mailjet() {
  const transport = mailer.createTransport(
    smtp({
      host: 'in.mailjet.com',
      port: 2525,
      auth: {
        user: process.env.MAILJET_API_KEY || '<your-mailjet-api-key',
        pass: process.env.MAILJET_API_SECRET || '<your-mailjet-api-secret>',
      },
    })
  );

  const json = await transport.sendMail({
    from: 'ANOTHER_EMAIL@ANOTHER_EXAMPLE.COM', // From address
    to: 'EMAIL@EXAMPLE.COM', // To address
    subject: 'test email from Node.js on Google Cloud Platform', // Subject
    text: 'Hello!\n\nThis a test email from Node.js.', // Content
  });
  console.log(json);
}
mailjet();

Execute o programa para enviar um e-mail via Mailjet:
```
user@test-wheezy:~# node sendmail.js
```

CentOS

Conecte-se à sua instância usando SSH:
```
gcloud compute ssh instance-name
```
Atualize os repositórios de pacotes:
```
user@test-centos:~# sudo yum update -y
```

Instale as dependências do Node.js:

user@test-centos:~# sudo yum install git-core curl openssl openssl-dev -y
...
user@test-centos:~# sudo yum groupinstall "Development Tools" -y
...

Clone o repositório Node.js do github:

user@test-centos:~# git clone https://github.com/nodejs/node

Altere o diretório para a árvore de origem do Node.js:
```
user@test-centos:~# cd node
```
Configure o software do nó para este SO e máquina virtual:
```
user@test-centos:~# ./configure
```
Crie Node.js, npm e objetos afins:
```
user@test-centos:~# sudo make
```
Isso pode levar alguns minutos para ser concluído.
Instale Node.js, npm e outros softwares no local padrão:
```
user@test-centos:~# sudo make install
```

Instale o pacote do remetente:

user@test-centos:~# npm install npm install nodemailer nodemailer-smtp-transport

No diretório node, crie um novo arquivo chamado sendmail.js que contenha o seguinte JavaScript:

const mailer = require('nodemailer');
const smtp = require('nodemailer-smtp-transport');

async function mailjet() {
  const transport = mailer.createTransport(
    smtp({
      host: 'in.mailjet.com',
      port: 2525,
      auth: {
        user: process.env.MAILJET_API_KEY || '<your-mailjet-api-key',
        pass: process.env.MAILJET_API_SECRET || '<your-mailjet-api-secret>',
      },
    })
  );

  const json = await transport.sendMail({
    from: 'ANOTHER_EMAIL@ANOTHER_EXAMPLE.COM', // From address
    to: 'EMAIL@EXAMPLE.COM', // To address
    subject: 'test email from Node.js on Google Cloud Platform', // Subject
    text: 'Hello!\n\nThis a test email from Node.js.', // Content
  });
  console.log(json);
}
mailjet();

Execute o programa para enviar um e-mail via Mailjet:
```
user@test-centos:~# node sendmail.js
```

Como enviar e-mails usando a API Mailjet com Java

Para mais exemplos de como usar a API Mailjet, consulte a documentação oficial do Mailjet (em inglês).

Debian

Conecte-se à sua instância usando SSH:
```
gcloud compute ssh instance-name
```

Atualize seus repositórios de pacotes e instale os pacotes necessários:

user@test-instance:~# sudo apt update && sudo apt install git-core openjdk-8-jdk maven

Clone o repositório Java do GitHub:

user@test-instance:~# git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

Acesse o código-fonte principal para o exemplo, localizado em:

/root/java-docs-samples/compute/mailjet/src/main/java/com/example/compute/mailjet

Defina as configurações do Mailjet. Consulte a documentação Autenticação do Mailjet sobre como substituir as seguintes variáveis:

your-mailjet-api-key: uma chave de API para sua conta do Mailjet.
your-mailjet-secret-key: a chave secreta correspondente para sua conta do Mailjet.

public class MailjetSender {

  public static void main(String[] args) throws MailjetException {
    final String mailjetApiKey = "YOUR-MAILJET-API-KEY";
    final String mailjetSecretKey = "YOUR-MAILJET-SECRET-KEY";
    ClientOptions options =
        ClientOptions.builder().apiKey(mailjetApiKey).apiSecretKey(mailjetSecretKey).build();
    MailjetClient client = new MailjetClient(options);

    MailjetSender sender = new MailjetSender();
    sender.sendMailjet(args[0], args[1], client);
  }

  public MailjetResponse sendMailjet(String recipient, String sender, MailjetClient client)
      throws MailjetException {
    MailjetRequest email =
        new MailjetRequest(Emailv31.resource)
            .property(
                Emailv31.MESSAGES,
                new JSONArray()
                    .put(
                        new JSONObject()
                            .put(
                                Emailv31.Message.FROM,
                                new JSONObject().put("Email", sender).put("Name", "pandora"))
                            .put(
                                Emailv31.Message.TO,
                                new JSONArray().put(new JSONObject().put("Email", recipient)))
                            .put(Emailv31.Message.SUBJECT, "Your email flight plan!")
                            .put(
                                Emailv31.Message.TEXTPART,
                                "Dear passenger, welcome to Mailjet!" 
                                + "May the delivery force be with you!")
                            .put(
                                Emailv31.Message.HTMLPART,
                                "<h3>Dear passenger, welcome to Mailjet!</h3>"
                                + "<br />May the delivery force be with you!")));

    try {
      // trigger the API call
      MailjetResponse response = client.post(email);
      // Read the response data and status
      System.out.println(response.getStatus());
      System.out.println(response.getData());
      return response;
    } catch (MailjetException e) {
      System.out.println("Mailjet Exception: " + e);
      return null;
    }
  }
}

No diretório mailjet, use Maven para empacotar a classe como um arquivo JAR:
```
user@test-instance:~# mvn clean package
```

Verifique se você está usando o OpenJDK 8:

user@test-instance:~# sudo update-alternatives --config java

Para enviar um e-mail: a partir do diretório de destino, execute o arquivo JAR com os endereços de e-mail do destinatário e do remetente como argumentos:
```
user@test-instance:~# java -jar
        compute-mailjet-1.0-SNAPSHOT-jar-with-dependencies.jar
        recipient-email sender-email
```

CentOS

Conecte-se à sua instância usando SSH:
```
gcloud compute ssh instance-name
```

Atualize seus repositórios de pacotes e instale os pacotes necessários:

user@test-centos:~# sudo yum update && sudo yum install git-core openjdk-8-jdk maven

Clone o repositório Java do GitHub:

user@test-centos:~# git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

Acesse o código-fonte principal para o exemplo, localizado em:

/root/java-docs-samples/compute/mailjet/src/main/java/com/example/compute/mailjet

Defina as configurações do Mailjet. Para informações sobre como substituir as variáveis a seguir, consulte a documentação de Autenticação do Mailjet:

your-mailjet-api-key: uma chave de API para sua conta do Mailjet.
your-mailjet-secret-key: a chave secreta correspondente para sua conta do Mailjet.

public class MailjetSender {

  public static void main(String[] args) throws MailjetException {
    final String mailjetApiKey = "YOUR-MAILJET-API-KEY";
    final String mailjetSecretKey = "YOUR-MAILJET-SECRET-KEY";
    ClientOptions options =
        ClientOptions.builder().apiKey(mailjetApiKey).apiSecretKey(mailjetSecretKey).build();
    MailjetClient client = new MailjetClient(options);

    MailjetSender sender = new MailjetSender();
    sender.sendMailjet(args[0], args[1], client);
  }

  public MailjetResponse sendMailjet(String recipient, String sender, MailjetClient client)
      throws MailjetException {
    MailjetRequest email =
        new MailjetRequest(Emailv31.resource)
            .property(
                Emailv31.MESSAGES,
                new JSONArray()
                    .put(
                        new JSONObject()
                            .put(
                                Emailv31.Message.FROM,
                                new JSONObject().put("Email", sender).put("Name", "pandora"))
                            .put(
                                Emailv31.Message.TO,
                                new JSONArray().put(new JSONObject().put("Email", recipient)))
                            .put(Emailv31.Message.SUBJECT, "Your email flight plan!")
                            .put(
                                Emailv31.Message.TEXTPART,
                                "Dear passenger, welcome to Mailjet!" 
                                + "May the delivery force be with you!")
                            .put(
                                Emailv31.Message.HTMLPART,
                                "<h3>Dear passenger, welcome to Mailjet!</h3>"
                                + "<br />May the delivery force be with you!")));

    try {
      // trigger the API call
      MailjetResponse response = client.post(email);
      // Read the response data and status
      System.out.println(response.getStatus());
      System.out.println(response.getData());
      return response;
    } catch (MailjetException e) {
      System.out.println("Mailjet Exception: " + e);
      return null;
    }
  }
}

No diretório mailjet, use Maven para empacotar a classe como um arquivo JAR:
```
user@test-centos:~# mvn clean package
```

Verifique se você está usando o OpenJDK 8:

user@test-centos:~# sudo alternatives --config java

Para enviar um e-mail a partir do diretório de destino, execute o arquivo JAR com os endereços de e-mail do destinatário e do remetente como argumentos:
```
user@test-centos:~# java -jar
        compute-mailjet-1.0-SNAPSHOT-jar-with-dependencies.jar
        recipient-email sender-email
```

Configurações de SMTP do Mailjet

Esta é uma referência rápida às configurações SMTP específicas para o Mailjet usadas para configurar clientes:

Host: in-v3.mailjet.com
Porta: 2525

A seguir

Confira arquiteturas de referência, diagramas, tutoriais e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.