Esta página foi traduzida pela API Cloud Translation.

Enviar email com o Mailjet

Mailjet é um serviço de email global de terceiros que oferece aos utilizadores do Compute Engine um nível gratuito com 6000 emails por mês. Além disso, o Mailjet também oferece:

Uma API, uma interface do utilizador e uma transmissão SMTP para enviar emails transacionais e de marketing.
Conformidade com a privacidade dos dados europeia.
Funcionalidades de email e capacidade de entrega, como definições de prioridade personalizáveis e gestão automática de restrições.
Biblioteca de recursos da API em Go, PHP, Nodejs, Java, Python e Ruby para gerir subcontas, autenticação, contactos, campanhas, payloads personalizados, estatísticas, eventos em tempo real e análise através da API Events.
Framework MJML integrada para criar modelos de email HTML adaptáveis.
Apoio técnico 24 horas por dia, 7 dias por semana, em mais de 4 idiomas.
Capacidade de enviar mensagens de email a partir de domínios diferentes de gmail.com.

Este documento descreve como configurar a instância de VM para enviar correio através do Mailjet usando os seguintes métodos:

Através de uma transmissão SMTP com:
- Postfix
- Nodemailer no Node.js
Diretamente através da API Mailjet com Java

Para ver documentação detalhada de outras soluções de email, incluindo exemplos de integração com os servidores, as bibliotecas e as estruturas SMTP mais comuns, consulte a documentação do Mailjet.

Antes de começar

Crie uma nova conta do Mailjet na página de parceiros da Google* do Mailjet. Quando se inscrever, indique o domínio e o endereço de email a partir dos quais quer enviar mensagens de email.
Obtenha as credenciais da sua conta SMTP do Mailjet.
Certifique-se de que o endereço de email a partir do qual quer enviar emails foi validado.
Configure uma regra de firewall para permitir o tráfego TCP na porta 2525.

^{* A Google é compensada pelos clientes que se inscrevem numa conta não gratuita.}

Configurar o Mailjet como uma transmissão SMTP

A configuração do Mailjet como uma transmissão de correio permite-lhe encaminhar mensagens de email para o Mailjet para entrega remota.

Usar o Postfix

Estabeleça ligação à sua VM através do SSH, substituindo instance-name pelo nome da instância a partir da qual quer enviar mensagens de email:
```
gcloud compute ssh instance-name
```
Na VM, instale o agente de transporte de correio Postfix. Quando lhe for pedido, aceite as opções predefinidas 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 ficheiro main.cf. Abra o ficheiro com o editor de texto da sua escolha:
```
sudo vi /etc/postfix/main.cf
```
Atualize o ficheiro:
1. Comente as seguintes linhas:
```
# default_transport = error
# relay_transport = error
```
2. Adicione as seguintes linhas ao final do ficheiro:
```
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
```
  Estas linhas aplicam o suporte de SSL/TLS e configuram a autenticação SMTP para estes pedidos. Um módulo de camada de segurança e acesso simples (SASL) processa a autenticação na configuração do Postfix.
  
  Nota: tem de usar a porta 2525, porque a porta 25 não é permitida no Compute Engine.
3. Guarde as alterações e feche o ficheiro.
Crie o mapa de palavras-passe SASL com o editor de texto da sua escolha:
```
sudo vi /etc/postfix/sasl_passwd
```
No ficheiro 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 ficheiro .db:

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

Deve receber 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 ficheiro que contém as suas credenciais, uma vez que já não é necessário:
```
sudo rm /etc/postfix/sasl_passwd
```

Defina as autorizações no seu ficheiro .db:

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

Por fim, atualize a configuração para carregar os parâmetros modificados:
Debian
```
sudo /etc/init.d/postfix restart
```
CentOS
```
sudo postfix reload
```
Teste a configuração. Instale o pacote mailx ou mailutils e teste a sua 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 o seguinte:
- from-email: um endereço de email que foi validado.
- destination-email: o endereço para o qual a mensagem de email é enviada.
Procure nos registos do seu sistema uma linha de estado que contenha status e o código de resposta do servidor bem-sucedido (250):
Debian
```
sudo tail -n 5 /var/log/syslog
```
CentOS
```
sudo tail -n 5 /var/log/maillog
```

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

Usar o Nodemailer

As instruções seguintes descrevem como usar o Mailjet com o Node.js no Debian Wheezy.

Debian

Ligue-se à sua instância através de 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 do Node.js a partir 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 relacionados:
```
user@test-wheezy:~# sudo make
```
Este processo pode demorar alguns minutos.
Instale o Node.js, o npm e outro software na localização predefinida:
```
user@test-wheezy:~# sudo make install
```

Instale o pacote de envio de correio:

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

No diretório node, crie um novo ficheiro denominado 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 uma mensagem de email através do Mailjet:
```
user@test-wheezy:~# node sendmail.js
```

CentOS

Ligue-se à sua instância através de 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 relacionados:
```
user@test-centos:~# sudo make
```
Este processo pode demorar alguns minutos.
Instale o Node.js, o npm e outro software na localização predefinida:
```
user@test-centos:~# sudo make install
```

Instale o pacote de envio de correio:

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

No diretório node, crie um novo ficheiro denominado 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 uma mensagem de email através do Mailjet:
```
user@test-centos:~# node sendmail.js
```

Enviar correio através da API Mailjet com Java

Para ver mais exemplos de utilização da API Mailjet, consulte a documentação oficial do Mailjet.

Debian

Ligue-se à sua instância através de SSH:
```
gcloud compute ssh instance-name
```

Atualize os 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

Aceda ao código-fonte principal do exemplo, localizado em:

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

Configure as definições do Mailjet. Consulte a documentação de autenticação do Mailjet sobre como substituir as seguintes variáveis:

your-mailjet-api-key: Uma chave da API para a sua conta do Mailjet.
your-mailjet-secret-key: a chave secreta correspondente da 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 o Maven para criar um pacote da classe como um ficheiro JAR:
```
user@test-instance:~# mvn clean package
```

Certifique-se de que está a usar o OpenJDK 8:

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

Para enviar um email: no diretório de destino, execute o ficheiro JAR com os endereços de email 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

Ligue-se à sua instância através de SSH:
```
gcloud compute ssh instance-name
```

Atualize os 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

Aceda ao código-fonte principal do exemplo, localizado em:

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

Configure as definições do Mailjet. Para informações sobre como substituir as seguintes variáveis, consulte a documentação de autenticação do Mailjet:

your-mailjet-api-key: Uma chave da API para a sua conta do Mailjet.
your-mailjet-secret-key: a chave secreta correspondente da 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 o Maven para criar um pacote da classe como um ficheiro JAR:
```
user@test-centos:~# mvn clean package
```

Certifique-se de que está a usar o OpenJDK 8:

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

Para enviar um email, a partir do diretório de destino, execute o ficheiro JAR com os endereços de email 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
```

Definições de SMTP do Mailjet

Seguem-se referências rápidas às definições de SMTP específicas do Mailjet que são usadas para configurar clientes:

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

O que se segue?

Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.

Enviar email com o Mailjet Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Configurar o Mailjet como uma transmissão SMTP

Usar o Postfix

Debian

CentOS

Debian

CentOS

Debian

CentOS

Debian

CentOS

Usar o Nodemailer

Enviar correio através da API Mailjet com Java

Definições de SMTP do Mailjet

O que se segue?

Enviar email com o Mailjet