Diese Seite wurde von der Cloud Translation API übersetzt.

E-Mails mit Mailjet senden

Mailjet ist ein globaler E-Mail-Dienst eines Drittanbieters,der Compute Engine-Nutzern eine kostenlose Stufe mit 6.000 E-Mails pro Monat bietet. Außerdem bietet Mailjet Folgendes:

Eine API, eine Benutzeroberfläche und ein SMTP-Relay für Transaktions- und Marketing-E-Mails
Einhaltung europäischer Datenschutzrichtlinien
E-Mail- und Zustellbarkeitsfunktionen wie anpassbare Prioritätseinstellungen und automatisierte Drosselungsverwaltung
API-Ressourcenbibliothek in Go, PHP, Node.js, Java, Python und Ruby zur Verwaltung von Unterkonten, Authentifizierung, Kontakten, Kampagnen, benutzerdefinierten Nutzlasten, Statistiken, Echtzeitereignissen und Parsing über die Event API.
Integriertes MJML-Framework zum Erstellen responsiver HTML-E-Mail-Vorlagen
Rund um die Uhr Support in mehr als vier Sprachen
Funktion für den E-Mail-Versand von anderen Domains als gmail.com

In diesem Dokument wird beschrieben, wie Sie mit den folgenden Methoden eine VM-Instanz zum Senden von E-Mails über Mailjet konfigurieren:

Über ein SMTP mit:
- Postfix
- Nodemailer auf Node.js
Direkt über die Mailjet API mit Java

Eine umfassende Beschreibung anderer E-Mail-Lösungen, einschließlich Beispielen zur Einbindung in gängige SMTP-Server, Bibliotheken und Frameworks, finden Sie in der Mailjet-Dokumentation.

Vorbereitung

Erstellen Sie ein neues Mailjet-Konto auf der Google-Partnerseite von Mailjet*. Geben Sie bei der Registrierung die Domain und die E-Mail-Adresse an, von der Sie E-Mail-Nachrichten senden möchten.
Fordern Sie die Anmeldedaten für das Mailjet-SMTP-Konto an.
Achten Sie darauf, dass die E-Mail-Adresse, von der aus Sie E-Mails senden möchten, bestätigt wurde.
Richten Sie eine Firewallregel ein, um den TCP-Traffic an Port 2525 zuzulassen.

^{* Google erhält eine Vergütung für Kunden, die sich für ein kostenpflichtiges Konto registrieren.}

Mailjet als SMTP-Relay konfigurieren

Wenn Sie Mailjet als E-Mail-Relais konfigurieren, können Sie E-Mails zur Remote-Zustellung an Mailjet weiterleiten.

Postfix

Stellen Sie über SSH eine Verbindung zu Ihrer VM her. Ersetzen Sie dabei instance-name durch den Namen der Instanz, von der Sie E-Mail-Nachrichten versenden möchten:
```
gcloud compute ssh instance-name
```
Installieren Sie auf der VM den Postfix Mail Transport Agent. Übernehmen Sie bei Aufforderung die Standardauswahl für Domainnamen, aber wählen Sie die Konfiguration Local Only aus.
Debian
```
sudo apt update && sudo apt -y install postfix libsasl2-modules
```
CentOS
```
sudo yum install postfix cyrus-sasl-plain cyrus-sasl-md5 -y
```
Ändern Sie die Postfix-Konfigurationsoptionen. Die Postfix-Konfigurationsoptionen werden in der Datei main.cf festgelegt. Öffnen Sie die Datei mit einem beliebigen Texteditor:
```
sudo vi /etc/postfix/main.cf
```
Aktualisieren Sie die Datei:
1. Entfernen Sie die Kommentarzeichen bei folgenden Zeilen:
```
# default_transport = error
# relay_transport = error
```
2. Fügen Sie die folgenden Zeilen am Ende der Datei hinzu:
```
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
```
  Diese Zeilen erzwingen die SSL/TLS-Unterstützung und konfigurieren die SMTP-Authentifizierung für diese Anfragen. Die Authentifizierung in der Postfix-Konfiguration wird von einem SASL-Modul (Simple Authentication and Security Layer) verarbeitet.
  Hinweis: Verwenden Sie unbedingt Port 2525, da Port 25 in Compute Engine unzulässig ist.
3. Speichern Sie die Änderungen und schließen Sie die Datei.
Erstellen Sie die SASL-Passwortzuordnung mit einem Texteditor Ihrer Wahl:
```
sudo vi /etc/postfix/sasl_passwd
```
Fügen Sie die folgenden Zeilen zu der Datei sasl_passwd hinzu, um die Anmeldedaten für Mailjet bereitzustellen:
```
in-v3.mailjet.com:2525 YOUR_API_KEY:YOUR_SECRET_KEY
```

Verwenden Sie das Dienstprogramm postmap zur Generierung einer .db-Datei:

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

Sie sollten die folgende Antwort erhalten:

-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

Entfernen Sie als Nächstes die Datei mit Ihren Anmeldedaten, da sie nicht mehr benötigt wird:
```
sudo rm /etc/postfix/sasl_passwd
```

Legen Sie die Berechtigungen für die .db-Datei fest:

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

Laden Sie die Konfiguration zum Schluss neu, um die geänderten Parameter zu laden:
Debian
```
sudo /etc/init.d/postfix restart
```
CentOS
```
sudo postfix reload
```
Testen Sie die Konfiguration. Installieren Sie das Paket mailx oder mailutils und testen Sie die Konfiguration.
Debian
```
sudo apt -y install mailutils
```
CentOS
```
sudo yum install mailx -y
```
Senden Sie eine Testnachricht:
```
echo 'Test passed.' | mail -s 'Test-Email' -aFrom:from-email destination-email
```
Dabei gilt:
- from-email: E-Mail-Adresse, die bestätigt wurde
- destination-email: E-Mail-Adresse, an die die E-Mail gesendet werden soll.
Suchen Sie in den Systemlogs nach einer Statuszeile, die status und den Code für eine erfolgreiche Serverantwort (250) enthält.
Debian
```
sudo tail -n 5 /var/log/syslog
```
CentOS
```
sudo tail -n 5 /var/log/maillog
```

Wenn bei der Einrichtung von Postfix mit Mailjet Probleme auftreten, sehen Sie in der Anleitung zur Einrichtung von Mailjet Postfix nach.

Nodemailer

In der folgenden Anleitung wird beschrieben, wie Sie Mailjet mit Node.js unter Debian Wheezy verwenden.

Debian

Stellen Sie eine SSH-Verbindung zur Instanz her:
```
gcloud compute ssh instance-name
```
Aktualisieren Sie die Paket-Repositorys:
```
user@test-wheezy:~# sudo apt update
```

Installieren Sie Node.js-Abhängigkeiten:

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

Klonen Sie das Node.js-Repository von GitHub:

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

Ändern Sie das Verzeichnis in die Node.js-Quellstruktur:
```
user@test-wheezy:~# cd node
```
Konfigurieren Sie die Knotensoftware für dieses Betriebssystem und diese virtuelle Maschine:
```
user@test-wheezy:~# ./configure
```
Erstellen Sie Node.js-, npm- und zugehörige Objekte:
```
user@test-wheezy:~# sudo make
```
Dies kann einige Minuten dauern.
Installieren Sie Node.js, npm und weitere Software am Standardspeicherort:
```
user@test-wheezy:~# sudo make install
```

Installieren Sie das Mailer-Paket:

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

Erstellen Sie im Verzeichnis node eine neue Datei mit dem Namen sendmail.js, die folgenden JavaScript-Code enthält:

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();

Führen Sie das Programm aus, um über Mailjet eine E-Mail-Nachricht zu senden:
```
user@test-wheezy:~# node sendmail.js
```

CentOS

Stellen Sie eine SSH-Verbindung zur Instanz her:
```
gcloud compute ssh instance-name
```
Aktualisieren Sie die Paket-Repositorys:
```
user@test-centos:~# sudo yum update -y
```

Installieren Sie Node.js-Abhängigkeiten:

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

Klonen Sie das Node.js-Repository von GitHub:

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

Ändern Sie das Verzeichnis in die Node.js-Quellstruktur:
```
user@test-centos:~# cd node
```
Konfigurieren Sie die Knotensoftware für dieses Betriebssystem und diese virtuelle Maschine:
```
user@test-centos:~# ./configure
```
Erstellen Sie Node.js-, npm- und zugehörige Objekte:
```
user@test-centos:~# sudo make
```
Dies kann einige Minuten dauern.
Installieren Sie Node.js, npm und weitere Software am Standardspeicherort:
```
user@test-centos:~# sudo make install
```

Installieren Sie das Mailer-Paket:

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

Erstellen Sie im Verzeichnis node eine neue Datei mit dem Namen sendmail.js, die folgenden JavaScript-Code enthält:

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();

Führen Sie das Programm aus, um über Mailjet eine E-Mail-Nachricht zu senden:
```
user@test-centos:~# node sendmail.js
```

E-Mails über die Mailjet API mit Java senden

Weitere Beispiele zur Verwendung der Mailjet API finden Sie in der offiziellen Mailjet-Dokumentation.

Debian

Stellen Sie eine SSH-Verbindung zur Instanz her:
```
gcloud compute ssh instance-name
```
Aktualisieren Sie die Paket-Repositorys und installieren Sie die erforderlichen Pakete:
```
user@test-instance:~# sudo apt update && sudo apt install git-core openjdk-8-jdk maven
```

Klonen Sie das Java-Repository von GitHub:

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

Gehen Sie zum Hauptquellcode für das Beispiel unter folgendem Pfad:

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

Konfigurieren Sie die Mailjet-Einstellungen. Informationen zum Ersetzen der folgenden Variablen finden Sie in der Dokumentation zur Mailjet-Authentifizierung:

your-mailjet-api-key: ein API-Schlüssel für Ihr Mailjet-Konto.
your-mailjet-secret-key: der entsprechende geheime Schlüssel für Ihr Mailjet-Konto

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;
    }
  }
}

Verwenden Sie im Verzeichnis mailjet Maven, um die Klasse als JAR-Datei zu verpacken:
```
user@test-instance:~# mvn clean package
```

Stellen Sie sicher, dass Sie OpenJDK 8 verwenden:

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

Zum Versenden einer E-Mail führen Sie im Zielverzeichnis die JAR-Datei mit den E-Mail-Adressen der Empfänger und Absender als Argumente aus:
```
user@test-instance:~# java -jar
        compute-mailjet-1.0-SNAPSHOT-jar-with-dependencies.jar
        recipient-email sender-email
```

CentOS

Stellen Sie eine SSH-Verbindung zur Instanz her:
```
gcloud compute ssh instance-name
```
Aktualisieren Sie die Paket-Repositorys und installieren Sie die erforderlichen Pakete:
```
user@test-centos:~# sudo yum update && sudo yum install git-core openjdk-8-jdk maven
```

Klonen Sie das Java-Repository von GitHub:

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

Gehen Sie zum Hauptquellcode für das Beispiel unter folgendem Pfad:

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

Konfigurieren Sie die Mailjet-Einstellungen. Informationen zum Ersetzen der folgenden Variablen finden Sie in der Dokumentation zur Mailjet-Authentifizierung:

your-mailjet-api-key: ein API-Schlüssel für Ihr Mailjet-Konto.
your-mailjet-secret-key: der entsprechende geheime Schlüssel für Ihr Mailjet-Konto

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;
    }
  }
}

Verwenden Sie im Verzeichnis mailjet Maven, um die Klasse als JAR-Datei zu verpacken:
```
user@test-centos:~# mvn clean package
```

Stellen Sie sicher, dass Sie OpenJDK 8 verwenden:

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

Um eine E-Mail zu senden, führen Sie im Zielverzeichnis die JAR-Datei mit den Empfänger- und Absender-E-Mail-Adressen als Argumente aus:

user@test-centos:~# java -jar
        compute-mailjet-1.0-SNAPSHOT-jar-with-dependencies.jar
        recipient-email sender-email

Mailjet-SMTP-Einstellungen

Dies ist eine Kurzreferenz für Mailjet-spezifische SMTP-Einstellungen, die zur Konfiguration von Clients verwendet werden:

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

Nächste Schritte

Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center