Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden der Amazon-SES-SMTP-Schnittstelle zum Senden von E-Mails
<a name="send-email-smtp"></a>

Sie können die Simple Mail Transfer Protocol(SMTP)-Schnittstelle oder die Amazon SES-API verwenden, um Produktions-E-Mails über Amazon SES zu senden. Weitere Informationen zur Amazon-SES-API finden Sie unter [Verwenden der Amazon-SES-API zum Senden von E-Mails](send-email-api.md). In diesem Abschnitt wird die SMTP-Schnittstelle beschrieben.

Amazon SES sendet E-Mails über SMTP, dem gängigsten E-Mail-Protokoll im Internet. Sie können E-Mails über Amazon SES senden, indem Sie eine Vielzahl von SMTP-fähigen Programmiersprachen und SMTP-fähiger Software verwenden, um eine Verbindung zur Amazon-SES-SMTP-Schnittstelle herzustellen. In diesem Abschnitt wird erklärt, wie Sie Ihre Amazon-SES-SMTP-Anmeldeinformationen abrufen, wie Sie mithilfe der SMTP-Schnittstelle E-Mails versenden und wie Sie mehrere Softwarebestandteile und E-Mail-Server für den E-Mail-Versand über Amazon SES konfigurieren.

Lösungen für häufige Probleme, die auftreten können, wenn Sie Amazon SES über die SMTP-Schnittstelle verwenden, finden Sie unter [SMTP-Probleme bei Amazon SES](troubleshoot-smtp.md). 

## Anforderungen zum Senden von E-Mails über SMTP
<a name="send-email-smtp-requirements"></a>

Zum Senden von E-Mails über die Amazon-SES-SMTP-Schnittstelle benötigen Sie Folgendes:
+ Die SMTP-Endpunktadresse. Eine Liste der Amazon SES SMTP-Endpunkte finden Sie unter [Herstellen einer Verbindung mit dem Amazon-SES-SMTP-Endpunkt](smtp-connect.md).
+ Portnummer der SMTP-Schnittstelle. Die Portnummer variiert je nach Verbindungsmethode. Weitere Informationen finden Sie unter [Herstellen einer Verbindung mit dem Amazon-SES-SMTP-Endpunkt](smtp-connect.md).
+ Ein SMTP-Benutzername und -Passwort. SMTP-Anmeldeinformationen sind für jede AWS -Region eindeutig. Wenn Sie die SMTP-Schnittstelle verwenden möchten, um E-Mails in mehreren AWS -Regionen zu senden, benötigen Sie SMTP-Anmeldeinformationen für jede Region.
**Wichtig**  
Ihre SMTP-Anmeldeinformationen sind nicht identisch mit Ihren AWS Zugangsschlüsseln oder den Anmeldeinformationen, mit denen Sie sich bei der Amazon SES-Konsole anmelden. Weitere Informationen zum Generieren von SMTP-Anmeldeinformationen finden Sie unter [Abrufen Ihrer Amazon-SES-SMTP-Anmeldeinformationen](smtp-credentials.md).
+ Client-Software, die mithilfe von Transport Layer Security (TLS) kommunizieren kann. Weitere Informationen finden Sie unter [Herstellen einer Verbindung mit dem Amazon-SES-SMTP-Endpunkt](smtp-connect.md).
+ Eine E-Mail-Adresse, die Sie mit Amazon SES überprüft haben. Weitere Informationen finden Sie unter [Verifizierte Identitäten in Amazon SES](verify-addresses-and-domains.md).
+ Höhere Sendekontingente, wenn Sie große Mengen E-Mails senden möchten. Weitere Informationen finden Sie unter [Verwalten Ihrer Amazon SES Versandkontingente](manage-sending-quotas.md).

## Methoden zum Senden von E-Mails über SMTP
<a name="send-email-methods"></a>

Sie können E-Mails über SMTP mit einer der folgenden Methoden senden:
+ Weitere Informationen zur Konfiguration SMTP-fähiger Software für das Senden von E-Mails über die Amazon SES-SMTP-Schnittstelle finden Sie unter [Senden von E-Mails über Amazon SES mithilfe von Softwarepaketen](send-email-smtp-software-package.md).
+ Informationen zum Programmieren einer Anwendung für das Senden von E-Mails über Amazon SES finden Sie unter [Programmatisches Senden einer E-Mail über die Amazon-SES-SMTP-Schnittstelle](send-using-smtp-programmatically.md).
+ Informationen zum Konfigurieren Ihres bestehenden E-Mail-Servers für das Senden aller ausgehenden E-Mails über Amazon SES finden Sie unter [Integrieren von Amazon SES in Ihren vorhandenen E-Mail-Server](send-email-smtp-existing-server.md).
+ Informationen zur Interaktion mit der Amazon SES-SMTP-Schnittstelle über die Befehlszeile, was nützlich für Tests sein kann, finden Sie unter [Testen der Verbindung zur Amazon-SES-SMTP-Schnittstelle über die Befehlszeile](send-email-smtp-client-command-line.md).

Eine Liste der SMTP-Antwort-Codes finden Sie unter [Von Amazon SES zurückgegebene SMTP-Antwortcodes](troubleshoot-smtp.md#troubleshoot-smtp-response-codes).

## Anzugebende E-Mail-Informationen
<a name="smtp-parameters"></a>

Wenn Sie über die SMTP-Schnittstelle auf Amazon SES zugreifen, erstellt Ihre SMTP-Clientanwendung die Nachricht. Daher hängen die Informationen, die Sie bereitstellen müssen, von der verwendeten Anwendung ab. Für den SMTP-Datenaustausch zwischen einem Client und einem Server sind mindestens Folgendes erforderlich: 
+ Quell-IP-Adresse
+ Zieladresse
+ Nachrichten-Tags

Wenn Sie die SMTP-Schnittstelle verwenden und die Weiterleitung von Feedback aktiviert ist, werden die Unzustellbaren E-Mails, Beschwerden und Zustellungsbenachrichtigungen an die „MAIL FROM“-Adresse gesendet. Es wird keine der von Ihnen angegebenen „Reply-To“-Adressen verwendet.



# Abrufen Ihrer Amazon-SES-SMTP-Anmeldeinformationen
<a name="smtp-credentials"></a>

Sie benötigen SMTP-Anmeldeinformationen für Amazon SES, um auf die SES-SMTP-Schnittstelle zugreifen zu können.

Die Anmeldeinformationen, die Sie zum Senden von E-Mails über die SES SMTP-Schnittstelle verwenden, sind für jede AWS Region einzigartig. Wenn Sie die SES-SMTP-Schnittstelle zum Senden von E-Mails in mehr als einer Region verwenden, müssen Sie einen Satz von SMTP-Anmeldeinformationen für jede Region erstellen.

Ihr SMTP-Passwort unterscheidet sich von Ihrem AWS geheimen Zugangsschlüssel. Weitere Informationen zu Anmeldeinformationen finden Sie unter [Arten von Amazon-SES-Anmeldeinformationen](send-email-concepts-credentials.md).

**Anmerkung**  
Eine Liste der derzeit verfügbaren SMTP-Endpunkte finden Sie unter [SMTP-Endpunkte](https://docs.aws.amazon.com/general/latest/gr/ses.html#ses_smtp_endpoints) in der. *Allgemeine AWS-Referenz* 

## Abrufen der SES-SMTP-Anmeldeinformationen über die SES-Konsole
<a name="smtp-credentials-console"></a>

**Anforderung**  
Ein IAM-Benutzer kann SES-SMTP-Anmeldeinformationen erstellen, die Richtlinie des Benutzers muss diesen jedoch die Berechtigung zur Nutzung von IAM selbst erteilen, da die SES-SMTP-Anmeldeinformationen mit IAM erstellt werden. Ihre IAM-Richtlinie muss zulassen, dass Sie die folgenden IAM-Aktionen durchführen: `iam:ListUsers`, `iam:CreateUser`, `iam:CreateAccessKey` und `iam:PutUserPolicy`. Wenn Sie versuchen, SES-SMTP-Anmeldeinformationen mithilfe der Konsole zu erstellen und Ihr IAM-Benutzer nicht über diese Berechtigungen verfügt, wird eine Fehlermeldung angezeigt, die besagt, dass Ihr Konto *„nicht autorisiert* ist, IAM auszuführen:“. ListUsers

**Wichtig**  
Für die oben genannten IAM-Aktionen gilt die Zugriffsebene [Permission Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_understand-policy-summary-access-level-summaries.html#access_policies_access-level), die höchste IAM-Stufe, da sie berechtigt, Ressourcenberechtigungen im Service zu erteilen oder zu ändern. Um die Sicherheit Ihres AWS Kontos zu verbessern, wird daher dringend empfohlen, diese Richtlinien, einschließlich der Zugriffsebenenklassifizierung für die Berechtigungsverwaltung, einzuschränken oder regelmäßig zu überwachen.

**So erstellen Sie Ihre SMTP-Anmeldeinformationen**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon SES SES-Konsole unter [https://console.aws.amazon.com/ses/](https://console.aws.amazon.com/ses/).

1. Wählen Sie **SMTP-Einstellungen** im linken Navigationsbereich aus. Dadurch wird die Seite **Simple Mail Transfer Protocol (SMTP) settings (Einstellungen für Simple Mail Transfer Protocol (SMTP)** geöffnet.

1. Wählen Sie **Create SMTP Credentials (SMTP-Anmeldeinformationen erstellen)** aus. In der oberen rechten Ecke wird die IAM-Konsole geöffnet.

1. (Optional) Wenn Sie bereits erstellte SMTP-Benutzer anzeigen, bearbeiten oder löschen müssen, wählen Sie unten rechts **Manage my existing SMTP credentials (Meine vorhandenen SMTP-Zugangsdaten verwalten)** aus. Die IAM-Konsole wird geöffnet. Details zum Verwalten von SMTP-Anmeldeinformationen werden nach diesen Verfahren angegeben.

1. Geben Sie für **Benutzer für SMTP erstellen**  einen Namen für Ihren SMTP-Benutzer in das Feld **Benutzername** ein. Alternativ können Sie den Standardwert verwenden, der in diesem Feld bereitgestellt wird. Wenn Sie fertig sind, wählen Sie **Erstellen**  in der unteren rechten Ecke.

1. Wählen Sie **Anzeigen** unter *SMTP-Passwort* – Ihre SMTP-Anmeldeinformationen werden auf dem Bildschirm angezeigt.

1. Laden Sie diese Anmeldeinformationen herunter, indem Sie **CSV-Datei herunterladen** auswählen, oder kopieren Sie sie und speichern Sie sie an einem sicheren Ort, da Sie Ihre Anmeldeinformationen nach dem Schließen dieses Dialogfelds nicht anzeigen oder speichern können.

1. Wählen Sie **Zurück zur SES-Konsole** aus.

Sie können eine Liste der SMTP-Anmeldeinformationen anzeigen, die Sie mit diesem Verfahren erstellt haben. Wählen Sie dazu in der IAM-Konsole unter **Access management** (Zugriffsverwaltung) die Option **Users** (Benutzer) aus und suchen Sie über die Suchleiste nach allen Benutzern, denen Sie SMTP-Anmeldeinformationen zugewiesen haben.

Sie können die IAM-Konsole auch verwenden, um vorhandene SMTP-Benutzer zu löschen. Weitere Informationen zum Löschen von Benutzern finden Sie unter [Verwalten von IAM-Benutzern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html) im *IAM – Handbuch „Erste Schritte“*.

Wenn Sie Ihr SMTP-Passwort ändern möchten, löschen Sie Ihren vorhandenen SMTP-Benutzer in der IAM-Konsole. Führen Sie anschließend die oben beschriebenen Schritte aus, um einen neuen Satz von SMTP-Anmeldeinformationen zu generieren.

## Abrufen von SES-SMTP-Anmeldeinformationen durch Konvertierung vorhandener AWS Anmeldeinformationen
<a name="smtp-credentials-convert"></a>

Wenn Sie einen Benutzer haben, den Sie über die IAM-Schnittstelle eingerichtet haben, können Sie die SES-SMTP-Anmeldeinformationen des Benutzers aus seinen Anmeldeinformationen ableiten. AWS 

**Wichtig**  
Verwenden Sie keine temporären AWS Anmeldeinformationen, um SMTP-Anmeldeinformationen abzuleiten. Die SES-SMTP-Schnittstelle unterstützt keine SMTP-Anmeldeinformationen, die von temporären Sicherheitsanmeldeinformationen generiert wurden. 

**Um dem IAM-Benutzer das Senden von E-Mails über die SES SMTP-Schnittstelle zu ermöglichen**

1. Leiten Sie die SMTP-Anmeldeinformationen des Benutzers anhand seiner AWS Anmeldeinformationen ab, indem Sie den in diesem Abschnitt bereitgestellten Algorithmus verwenden und dabei die folgenden Verfahren befolgen.

   Da Sie mit AWS Anmeldeinformationen beginnen, entspricht der SMTP-Benutzername der AWS Zugriffsschlüssel-ID, sodass Sie nur das SMTP-Passwort generieren müssen.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Wählen Sie unter **Zugriffsverwaltung** die Option **Richtlinien und** anschließend Richtlinie **erstellen** aus.

1. Wählen Sie im **Richtlinieneditor** **JSON** aus und entfernen Sie jeglichen Beispielcode im Editor.

1. Fügen Sie die folgende Berechtigungsrichtlinie in den Editor ein:

------
#### [ JSON ]

****  

   ```
   {
   "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
   "Effect": "Allow",
               "Action": "ses:SendRawEmail",
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Wählen Sie **Weiter** aus und geben Sie `AmazonSesSendingAccess` in das Feld **Richtlinienname** gefolgt von **Richtlinie erstellen ein**.

1. Wählen Sie unter **Zugriffsverwaltung** die Option **Benutzergruppen** und anschließend **Gruppe erstellen** aus.

1. Geben Sie `AWSSESSendingGroupDoNotRename` in das Feld **Benutzergruppenname** ein.

1. Fügen Sie der Gruppe SMTP-Benutzer hinzu, indem Sie sie aus der Tabelle **Benutzer zur Gruppe hinzufügen** auswählen.

1. Hängen Sie die zuvor erstellte `AmazonSesSendingAccess` Richtlinie an, indem Sie sie aus der Tabelle mit den **Richtlinien für Zugriffsrechte anhängen** und anschließend **Benutzergruppe erstellen** auswählen.

Weitere Informationen zur Verwendung von SES mit IAM finden Sie unter [Identity and Access Management in Amazon S3](control-user-access.md).

**Anmerkung**  
Sie können zwar SES-SMTP-Anmeldeinformationen für alle IAM-Benutzer generieren, allerdings empfehlen wir, bei der Generierung Ihrer SMTP-Anmeldeinformationen einen separaten IAM-Benutzer zu erstellen. Weitere Informationen zu bewährten Methoden bei der Erstellung von Benutzern für bestimmte Zwecke gehen Sie zu [Bewährte Methoden für IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPractices.html).

Der folgende Pseudocode zeigt den Algorithmus, der einen AWS geheimen Zugriffsschlüssel in ein SES SMTP-Passwort umwandelt.

```
 1. // Modify this variable to include your AWS secret access key
 2. key = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY";
 3.             
 4. // Modify this variable to refer to the AWS Region that you want to use to send email.
 5. region = "us-west-2";
 6.             
 7. // The values of the following variables should always stay the same.
 8. date = "11111111";
 9. service = "ses";
10. terminal = "aws4_request";
11. message = "SendRawEmail";
12. version = 0x04;
13. 
14. kDate = HmacSha256(date, "AWS4" + key);
15. kRegion = HmacSha256(region, kDate);
16. kService = HmacSha256(service, kRegion);
17. kTerminal = HmacSha256(terminal, kService);
18. kMessage = HmacSha256(message, kTerminal);
19. signatureAndVersion = Concatenate(version, kMessage);
20. smtpPassword = Base64(signatureAndVersion);
```

Einige Programmiersprachen enthalten Bibliotheken, die Sie verwenden können, um einen geheimen IAM-Zugriffsschlüssel in ein SMTP-Passwort zu konvertieren. Dieser Abschnitt enthält ein Codebeispiel, mit dem Sie mithilfe von Python einen AWS geheimen Zugriffsschlüssel in ein SES-SMTP-Passwort konvertieren können.

**Anmerkung**  
Im folgenden Beispiel werden **f-Zeichenfolgen** verwendet, die in Python 3.6 eingeführt wurden. Wenn Sie eine ältere Version verwenden, funktionieren sie nicht.
Im folgenden Beispiel ist die Liste von SMTP\$1REGIONS lediglich ein Beispiel. Ihre tatsächliche Liste der Regionen kann kürzer oder länger sein, je nachdem, in welche Regionen Sie E-Mails senden möchten, da Sie für jede Region SMTP-Anmeldeinformationen benötigen. AWS-Region

------
#### [ Python ]

```
#!/usr/bin/env python3

import hmac
import hashlib
import base64
import argparse

SMTP_REGIONS = [
    "us-east-2",  # US East (Ohio)
    "us-east-1",  # US East (N. Virginia)
    "us-west-2",  # US West (Oregon)
    "ap-south-1",  # Asia Pacific (Mumbai)
    "ap-northeast-2",  # Asia Pacific (Seoul)
    "ap-southeast-1",  # Asia Pacific (Singapore)
    "ap-southeast-2",  # Asia Pacific (Sydney)
    "ap-northeast-1",  # Asia Pacific (Tokyo)
    "ca-central-1",  # Canada (Central)
    "eu-central-1",  # Europe (Frankfurt)
    "eu-west-1",  # Europe (Ireland)
    "eu-west-2",  # Europe (London)
    "eu-south-1",  # Europe (Milan)
    "eu-north-1",  # Europe (Stockholm)
    "sa-east-1",  # South America (Sao Paulo)
    "us-gov-west-1",  # AWS GovCloud (US)
    "us-gov-east-1",  # AWS GovCloud (US)
]

# These values are required to calculate the signature. Do not change them.
DATE = "11111111"
SERVICE = "ses"
MESSAGE = "SendRawEmail"
TERMINAL = "aws4_request"
VERSION = 0x04


def sign(key, msg):
    return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()


def calculate_key(secret_access_key, region):
    if region not in SMTP_REGIONS:
        raise ValueError(f"The {region} Region doesn't have an SMTP endpoint.")

    signature = sign(("AWS4" + secret_access_key).encode("utf-8"), DATE)
    signature = sign(signature, region)
    signature = sign(signature, SERVICE)
    signature = sign(signature, TERMINAL)
    signature = sign(signature, MESSAGE)
    signature_and_version = bytes([VERSION]) + signature
    smtp_password = base64.b64encode(signature_and_version)
    return smtp_password.decode("utf-8")


def main():
    parser = argparse.ArgumentParser(
        description="Convert a Secret Access Key to an SMTP password."
    )
    parser.add_argument("secret", help="The Secret Access Key to convert.")
    parser.add_argument(
        "region",
        help="The AWS Region where the SMTP password will be used.",
        choices=SMTP_REGIONS,
    )
    args = parser.parse_args()
    print(calculate_key(args.secret, args.region))


if __name__ == "__main__":
    main()
```

Um Ihr SMTP-Kennwort mithilfe dieses Skripts zu erhalten, speichern Sie den vorhergehenden Code als `smtp_credentials_generate.py`. Führen Sie in der Befehlszeile den folgenden Befehl aus. 

```
python path/to/smtp_credentials_generate.py wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY us-east-1
```

Gehen Sie im vorhergehenden Befehl wie folgt vor:
+ Ersetzen Sie es durch den Pfad zu *path/to/* dem Speicherort, an dem Sie gespeichert haben. `smtp_credentials_generate.py`
+ *wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY*Ersetzen Sie ihn durch den geheimen Zugriffsschlüssel, den Sie in ein SMTP-Passwort konvertieren möchten.
+ *us-east-1*Ersetzen Sie es durch die AWS Region, in der Sie die SMTP-Anmeldeinformationen verwenden möchten.

Wenn dieses Skript erfolgreich ausgeführt wird, ist die einzige Ausgabe Ihr SMTP-Kennwort.

------

## Migrieren eines SMTP-Benutzers von einer vorhandenen Inline-Richtlinie zu einer Gruppenrichtlinie (Sicherheitsempfehlung)
<a name="migrate-inline-policy-to-group"></a>

**Wichtig**  
Wenn Sie vor dem 6. September 2024 die SES-SMTP-Anmeldeinformationen erstellt haben, wurden Ihrem SMTP-Benutzer eine Inline-Richtlinie und ein Tag zugewiesen. SES entfernt sich von Inline-Richtlinien und empfiehlt Ihnen als Sicherheitsempfehlung, dasselbe zu tun.

Bevor Sie einen SMTP-Benutzer von einer bestehenden Inline-Richtlinie zu einer Gruppenrichtlinie migrieren, müssen Sie zunächst eine IAM-Benutzergruppe mit der SES-Berechtigungsrichtlinie erstellen, die die Inline-Richtlinie ersetzt. Wenn Sie diese IAM-Benutzergruppe bereits erstellt haben oder wenn sie automatisch für SMTP-Anmeldeinformationen erstellt wurde, die Sie ab dem 6. September 2024 erstellt haben, können Sie in den folgenden Verfahren direkt mit *Schritt* 10 fortfahren.

**So migrieren Sie von einer vorhandenen Inline-Richtlinie zu einer verwalteten Gruppe**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie unter **Zugriffsverwaltung** die Option **Richtlinien und** anschließend Richtlinie **erstellen** aus.

1. Wählen Sie im **Richtlinieneditor** **JSON** aus und entfernen Sie jeglichen Beispielcode im Editor.

1. Fügen Sie die folgende Berechtigungsrichtlinie in den Editor ein:

------
#### [ JSON ]

****  

   ```
   {
   "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
   "Effect": "Allow",
               "Action": "ses:SendRawEmail",
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Wählen Sie **Weiter** aus und geben Sie `AmazonSesSendingAccess` in das Feld **Richtlinienname** gefolgt von **Richtlinie erstellen ein**.

1. Wählen Sie unter **Zugriffsverwaltung** die Option **Benutzergruppen** und anschließend **Gruppe erstellen** aus.

1. Geben Sie `AWSSESSendingGroupDoNotRename` in das Feld **Benutzergruppenname** ein.

1. Fügen Sie der Gruppe SMTP-Benutzer hinzu, indem Sie sie aus der Tabelle **Benutzer zur Gruppe hinzufügen** auswählen.

1. Hängen Sie die zuvor erstellte `AmazonSesSendingAccess` Richtlinie an, indem Sie sie aus der Tabelle mit den **Richtlinien für Zugriffsrechte anhängen** und anschließend **Benutzergruppe erstellen** auswählen.

   Nachdem Sie die IAM-Benutzergruppe mit der SES-Berechtigungsrichtlinie erstellt haben, können Sie einen SMTP-Benutzer von seiner aktuellen Inline-Richtlinie zu dieser Gruppenrichtlinie migrieren, wie in den verbleibenden Schritten beschrieben.

1. Wählen Sie unter **Zugriffsverwaltung** die Option **Benutzer** und anschließend den SMTP-Benutzer aus, den Sie migrieren möchten.

1. Wählen Sie die Registerkarte **Gruppen** und dann **Benutzer zu Gruppen hinzufügen** aus.

1. Wählen Sie die `AWSSESSendingGroupDoNotRename` Gruppe aus, gefolgt von **Benutzer zu Gruppe (n) hinzufügen**.

1. Wählen Sie die Registerkarte **Berechtigungen** aus und vergewissern Sie sich, dass in `AmazonSesSendingAccess` der Spalte **Richtlinienname** zwei Zeilen mit dem aufgeführt sind, eine Zeile mit *Inline* und eine mit *Gruppe `AWSSESSendingGroupDoNotRename`* in der Spalte **Angehangen über**.

1. Wählen Sie nur die Zeile aus, die `AmazonSesSendingAccess` in der Spalte **Richtlinienname** und *Inline* in der Spalte **Angehangen über** enthält, gefolgt von **Entfernen** und bestätigen **Sie mit Richtlinie entfernen**.

   Vergewissern Sie sich, dass die Zeile mit der *Gruppe `AWSSESSendingGroupDoNotRename`* in der Spalte **Angefügt über** erhalten bleibt.

1. Wählen Sie die Registerkarte „**Tags**“ und anschließend „**Tags verwalten**“.

1. Wählen Sie neben der Zeile, die in der Spalte **Schlüssel** und *InvokedBy*SESConsole**in der Spalte **Wert** enthält, **Entfernen** aus, gefolgt von **Änderungen speichern**.

**Wichtig**  
Die `AmazonSesSendingAccess` Richtlinie (entweder als Inline- oder Gruppenrichtlinie oder beides) muss dem SMTP-Benutzer zugeordnet bleiben, um sicherzustellen, dass dessen Versand nicht beeinträchtigt wird. Entfernen Sie die Inline-Richtlinie erst, nachdem die Gruppenrichtlinie Ihrem Benutzer zugewiesen wurde. 

# Herstellen einer Verbindung mit dem Amazon-SES-SMTP-Endpunkt
<a name="smtp-connect"></a>

Um E-Mails über die Amazon SES SMTP-Schnittstelle zu senden, müssen Sie Ihre Anwendung mit einem SMTP-Endpunkt verbinden. Eine vollständige Liste der SMTP-Endpunkte von Amazon SES finden Sie unter [Endpunkte und Kontingente von Amazon Simple Email Service](https://docs.aws.amazon.com/general/latest/gr/ses.html) in der *Allgemeine AWS-Referenz*.

Der SMTP-Endpunkt von Amazon SES erfordert, dass alle Verbindungen mit Transport Layer Security (TLS) verschlüsselt werden. (Beachten Sie, dass TLS häufig mit dem Namen des Vorgängerprotokolls, SSL, bezeichnet wird.) Amazon SES unterstützt zwei Mechanismen zum Einrichten einer TLS-verschlüsselten Verbindung: STARTTLS und TLS Wrapper. Lesen Sie in der Dokumentation für Ihre Software nach, um zu bestimmen, ob STARTTLS, TLS Wrapper oder beides unterstützt wird.

Amazon Elastic Compute Cloud (Amazon EC2) schränkt standardmäßig E-Mail-Verkehr über Port 25 ein. Um Zeitüberschreitungen beim Senden von E-Mails über den SMTP-Endpunkt von EC2 zu vermeiden, übermitteln Sie eine [Anforderung zum Entfernen von E-Mail-Sendelimits](https://aws-portal.amazon.com/gp/aws/html-forms-controller/contactus/ec2-email-limit-rdns-request), um die Drosselung zu entfernen. Alternativ können Sie E-Mails über einen anderen Port enden oder einen [Amazon-VPC-Endpunkt](send-email-set-up-vpc-endpoints.md) verwenden.

Informationen zu SMTP-Verbindungsproblemen finden Sie unter [SMTP-Probleme](troubleshoot-smtp.md).

## STARTTLS
<a name="smtp-connect-starttls"></a>

STARTTLS ist ein Verfahren zum Upgraden einer unverschlüsselten Verbindung zu einer verschlüsselten Verbindung. Es stehen Versionen von STARTTLS für eine Reihe von Protokollen zur Verfügung. Die SMTP-Version ist in [RFC 3207](https://www.ietf.org/rfc/rfc3207.txt) definiert.

Zum Einrichten einer STARTTLS-Verbindung stellt der SMTP-Client eine Verbindung zum Amazon-SES-SMTP-Endpunkt auf Port 25, 587 oder 2587 her, gibt einen EHLO-Befehl aus und wartet, bis der Server mitgeteilt hat, dass er die STARTTLS-SMTP-Erweiterung unterstützt. Der Client gibt dann den Befehl STARTTLS aus, um die TLS-Aushandlung zu initiieren. Wenn die Aushandlung abgeschlossen ist, gibt der Client über die neue verschlüsselte Verbindung einen EHLO-Befehl aus und die SMTP-Sitzung wird normal fortgesetzt.

## TLS Wrapper
<a name="smtp-connect-tlswrapper"></a>

TLS Wrapper (auch bekannt als SMTPS oder Handshake Protocol) ist ein Verfahren zum Initiieren einer verschlüsselten Verbindung, ohne zuvor eine unverschlüsselte Verbindung herzustellen. Bei TLS Wrapper werden vom Amazon-SES-SMTP-Endpunkt keine TLS-Aushandlungen durchgeführt. Es liegt in der Verantwortung des Clients, eine Verbindung mit dem Endpunkt über TLS herzustellen und TLS dann für die gesamte Konversation weiterzuverwenden. TLS Wrapper ist ein älteres Protokoll, wird jedoch von vielen Clients weiterhin unterstützt.

Zum Einrichten einer TLS Wrapper-Verbindung stellt der SMTP-Client eine Verbindung mit dem Amazon-SES-SMTP-Endpunkt auf Port 465 oder 2465 her. Der Server repräsentiert sein Zertifikat, der Client gibt einen EHLO-Befehl aus und die SMTP-Sitzung wird normal fortgesetzt.

# Senden von E-Mails über Amazon SES mithilfe von Softwarepaketen
<a name="send-email-smtp-software-package"></a>

Es gibt zahlreiche kommerzielle und Open Source-Softwarepakete, die das Senden von E-Mails über SMTP unterstützen. Hier sind einige Beispiele:
+ Blog-Plattformen
+ RSS-Aggregatoren
+ Listenverwaltungssoftware
+ Workflow-Systeme

Sie können alle diese SMTP-fähige Software für das Senden von E-Mails über die Amazon-SES-SMTP-Schnittstelle konfigurieren. Anweisungen zum Konfigurieren von SMTP für ein bestimmtes Softwarepaket finden Sie in der Dokumentation zu dieser Software.

Das folgende Verfahren zeigt, wie Sie Amazon-SES-Senden in JIRA einrichten, einer beliebten Problemverfolgungslösung. Mit dieser Konfiguration kann JIRA Benutzer per E-Mail benachrichtigen, wenn es eine Änderung am Status eines Softwareproblems gibt.

**So konfigurieren Sie JIRA für das Senden von E-Mails mit Amazon SES**

1. Melden Sie sich über einen Webbrowser mit Administrator-Anmeldeinformationen bei JIRA an.

1. Wählen Sie im Browserfenster **Administration** aus.

1. Wählen Sie im Menü **System** die Option **Mail** aus.

1. Wählen Sie auf der Seite **Mail administration** (Mail-Administration) die Option **Mail Servers** (Mail-Server) aus.

1. Klicken Sie auf **Configure new SMTP mail server** (Neuen SMPT-Mail-Server konfigurieren).

1. Füllen Sie im Formular **Add SMTP Mail Server** (SMPT-Mail-Server hinzufügen) die folgenden Felder aus:

   1. **Name** – Ein aussagekräftiger Name für diesen Server.

   1. **Von Adresse** – Die Adresse, von der die E-Mail gesendet wird. Sie müssen diese E-Mail-Adresse mit Amazon SES verifizieren, bevor Sie von ihr aus senden können. Weitere Informationen zur Verifizierung finden Sie unter [Verifizierte Identitäten in Amazon SES](verify-addresses-and-domains.md).

   1. **Email prefix** – Eine Zeichenfolge, die JIRA vor dem Senden jeder Betreffzeile voranstellt.

   1. **Protocol** – Wählen Sie **SMTP** aus.
**Anmerkung**  
Wenn Sie keine Verbindung zu Amazon SES herstellen können, versuchen Sie **SECURE\$1SMTP**.

   1. **Hostname** – Eine Liste der Amazon-SES-SMTP-Endpunkte finden Sie unter [Herstellen einer Verbindung mit dem Amazon-SES-SMTP-Endpunkt](smtp-connect.md). Wenn Sie beispielsweise den Amazon SES Endpunkt in der Region USA West (Oregon) verwenden möchten, lautet der Hostname *email-smtp.us-west-2.amazonaws.com*.

   1. **SMTP-Port** – 25, 587 oder 2587 (für eine Verbindung mit STARTTLS) oder 465 oder 2465 (für eine Verbindung mit TLS Wrapper).

   1. **TLS** – Aktivieren Sie dieses Kontrollkästchen.

   1. **User name** – Ihr -SMTP-Benutzername.

   1. **Password** – Ihr SMTP-Passwort.

   Die Einstellungen für TLS Wrapper finden Sie im folgenden Abbild.  
![\[SMTP-E-Mail-Konfiguration für JIRA\]](http://docs.aws.amazon.com/de_de/ses/latest/dg/images/SMTP_jira.png)

1. Wählen Sie **Test Connection** (Verbindung testen) aus. Wenn die Test-E-Mail, die JIRA über Amazon SES sendet, eingeht, ist Ihre Konfiguration erfolgreich abgeschlossen.

# Programmatisches Senden einer E-Mail über die Amazon-SES-SMTP-Schnittstelle
<a name="send-using-smtp-programmatically"></a>

Um eine E-Mail über die Amazon-SES-SMTP-Schnittstelle zu versenden, können Sie eine SMTP-fähige Programmiersprache, einen Mailserver oder eine Anwendung verwenden. Bevor Sie beginnen, führen Sie die Aufgaben in [Amazon Simple Email Service einrichten](setting-up.md) durch. Außerdem benötigen Sie die folgenden zusätzlichen Informationen: 
+ Ihre SMTP-Anmeldeinformationen für Amazon SES, mit denen Sie sich mit dem SMTP-Endpunkt von Amazon SES verbinden können. Informationen zum Abrufen Ihrer SMTP-Anmeldeinformationen für Amazon SES finden Sie unter [Abrufen Ihrer Amazon-SES-SMTP-Anmeldeinformationen](smtp-credentials.md). 
**Wichtig**  
Ihre SMTP-Anmeldeinformationen unterscheiden sich von Ihren AWS Anmeldeinformationen. Weitere Informationen zu Anmeldeinformationen finden Sie unter [Arten von Amazon-SES-Anmeldeinformationen](send-email-concepts-credentials.md).
+ Die SMTP-Endpunktadresse. Eine Liste der Amazon SES-SMTP-Endpunkte finden Sie unter [Herstellen einer Verbindung mit dem Amazon-SES-SMTP-Endpunkt](smtp-connect.md).
+ Die Port-Nummer der Amazon-SES-SMTP-Schnittstelle. Diese hängt von der Verbindungsmethode ab. Weitere Informationen finden Sie unter [Herstellen einer Verbindung mit dem Amazon-SES-SMTP-Endpunkt](smtp-connect.md).

## Codebeispiele
<a name="send-email-smtp-code-examples"></a>

Sie können auf die Amazon-SES-SMTP-Schnittstelle zugreifen, indem Sie eine SMTP-fähige Programmiersprache verwenden. Sie geben den Amazon-SES-SMTP-Hostnamen und die Port-Nummer zusammen mit Ihren SMTP-Anmeldeinformationen an und verwenden dann die generischen SMTP-Funktionen der Programmiersprache, um die E-Mail zu versenden.

Amazon Elastic Compute Cloud (Amazon EC2) schränkt standardmäßig den E-Mail-Datenverkehr über Port 25. Um Zeitüberschreitungen beim Senden von E-Mails über den SMTP-Endpunkt von Amazon EC2 zu vermeiden, können Sie beantragen, dass diese Einschränkungen entfernt werden. Weitere Informationen finden Sie unter [Wie entferne ich die Beschränkung für Port 25 aus meiner Amazon EC2 EC2-Instance oder AWS Lambda -Funktion](https://aws.amazon.com/premiumsupport/knowledge-center/ec2-port-25-throttle/)? im AWS Knowledge Center.

Die Codebeispiele in diesem Abschnitt für Java und PHP verwenden Port 587, um dieses Problem zu vermeiden. 

**Anmerkung**  
In diesem Tutorial senden Sie eine E-Mail an sich selbst, um zu prüfen, ob diese bei Ihnen ankommt. Für weitere Experimente oder Lasttests nutzen Sie den Amazon SES-Postfachsimulator. E-Mails, die Sie an den Postfachsimulator senden, zählen nicht zu Ihrer Sendequote oder Ihre Unzustellbarkeits- und Beschwerderate. Weitere Informationen finden Sie unter [Manuelles Verwenden des Postfachsimulators](send-an-email-from-console.md#send-email-simulator).

**Wählen Sie eine Programmiersprache aus, um das Beispiel für diese Sprache anzuzeigen:**

**Warnung**  
Amazon SES empfiehlt nicht, statische Anmeldeinformationen zu verwenden. Unter erfahren [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)Sie, wie Sie Ihre Sicherheitslage verbessern können, indem Sie hartcodierte Anmeldeinformationen aus Ihrem Quellcode entfernen. Dieses Tutorial dient nur dazu, die Amazon SES SMTP-Schnittstelle in einer Nicht-Produktionsumgebung zu testen.

------
#### [ Java ]

In diesem Beispiel werden die [Eclipse-IDE](http://www.eclipse.org/) und die [JavaMail API](https://github.com/javaee/javamail/releases) verwendet, um E-Mails über Amazon SES mithilfe der SMTP-Schnittstelle zu senden.

Führen Sie erst die unter [Amazon Simple Email Service einrichten](setting-up.md) beschriebenen Aufgaben aus, bevor Sie mit dem folgenden Verfahren beginnen.

**So senden Sie eine E-Mail über die Amazon-SES-SMTP-Schnittstelle mit C\$1**

1. Rufen Sie die [JavaMail GitHub Seite in einem Webbrowser auf.](https://github.com/javaee/javamail/releases) Wählen Sie unter **Assets** die Option **javax.mail.jar aus, um die neueste Version** von herunterzuladen. JavaMail
**Wichtig**  
Für dieses Tutorial ist Version 1.5 oder höher erforderlich JavaMail . Diese Verfahren wurden mit JavaMail Version 1.6.1 getestet.

1. **Rufen Sie in einem Webbrowser die [ GitHub Jakarta-Aktivierungsseite](https://github.com/eclipse-ee4j/jaf/releases) auf und laden Sie unter JavaBeans Activation [Framework 1.2.1 Final Release](https://github.com/eclipse-ee4j/jaf/releases/tag/1.2.1) die Datei jakarta.activation.jar herunter**

1. Erstellen Sie ein Projekt in Eclipse, indem Sie die folgenden Schritte ausführen:

   1. Starten Sie Eclipse.

   1. Wählen Sie in Eclipse die Optionen **File** (Datei), **New** (Neu) und dann **Java Project** (Java–Projekt) aus.

   1. Geben Sie im Dialogfeld **Create a Java Project** (Ein Java-Projekt erstellen) einen Projektnamen ein und klicken Sie auf **Next** (Weiter).

   1. Wählen Sie im Dialogfeld **Java Settings** (Java-Einstellungen) die Registerkarte **Libraries** (Bibliotheken) aus.

   1. ******Wählen Sie **Classpath** aus und fügen Sie die beiden externen JAR-Dateien javax.mail.jar und jakarta.activation.jar hinzu, indem Sie auf die Schaltfläche External hinzufügen klicken. JARs******

   1. **Wählen** Sie Extern JARs hinzufügen.

   1. Navigieren Sie zu dem Ordner, in den Sie die Datei heruntergeladen haben JavaMail. Wählen Sie die Datei `javax.mail.jar` und dann **Open** (Öffnen) aus.

   1. Klicken Sie im Dialogfeld **Java Settings** (Java-Einstellungen) auf **Finish** (Abschließen).

1. Erweitern Sie im Eclipse-Fenster **Package Explorer** (Paket-Explorer) das Projekt.

1. Klicken Sie unter Ihrem Projekt mit der rechten Maustaste auf das Verzeichnis **src** und wählen Sie **New** (Neu) und dann **Class** (Klasse) aus.

1. Geben Sie im Dialogfeld **New Java Class** (Neue Java-Klasse) im Feld **Name** die Zeichenfolge `AmazonSESSample` ein und klicken Sie auf **Finish** (Abschließen).

1. Ersetzen Sie den gesamten Inhalt von **Amazon SESSample .java** durch den folgenden Code:

   ```
     1. import java.util.Properties;
     2. 
     3. import javax.mail.Message;
     4. import javax.mail.Session;
     5. import javax.mail.Transport;
     6. import javax.mail.internet.InternetAddress;
     7. import javax.mail.internet.MimeMessage;
     8. 
     9. public class AmazonSESSample {
    10. 
    11.     // Replace sender@example.com with your "From" address.
    12.     // This address must be verified.
    13.     static final String FROM = "sender@example.com";
    14.     static final String FROMNAME = "Sender Name";
    15.     
    16.     // Replace recipient@example.com with a "To" address. If your account 
    17.     // is still in the sandbox, this address must be verified.
    18.     static final String TO = "recipient@example.com";
    19.     
    20.     // Replace smtp_username with your Amazon SES SMTP user name.
    21.     static final String SMTP_USERNAME = "smtp_username";
    22.       
    23.     // The name of the Configuration Set to use for this message.
    24.     // If you comment out or remove this variable, you will also need to
    25.     // comment out or remove the header below.
    26.     static final String CONFIGSET = "ConfigSet";
    27.     
    28.     // Amazon SES SMTP host name. This example uses the US West (Oregon) region.
    29.     // See https://docs.aws.amazon.com/ses/latest/DeveloperGuide/regions.html#region-endpoints
    30.     // for more information.
    31.     static final String HOST = "email-smtp.us-west-2.amazonaws.com";
    32.     
    33.     // The port you will connect to on the Amazon SES SMTP endpoint. 
    34.     static final int PORT = 587;
    35.     
    36.     static final String SUBJECT = "Amazon SES test (SMTP interface accessed using Java)";
    37.     
    38.     static final String BODY = String.join(
    39.             System.getProperty("line.separator"),
    40.             "<h1>Amazon SES SMTP Email Test</h1>",
    41.             "<p>This email was sent with Amazon SES using the ", 
    42.             "<a href='https://github.com/javaee/javamail'>Javamail Package</a>",
    43.             " for <a href='https://www.java.com'>Java</a>."
    44.         );
    45. 
    46.     public static void main(String[] args) throws Exception {
    47. 
    48.         // Create a Properties object to contain connection configuration information.
    49.         Properties props = System.getProperties();
    50.         props.put("mail.transport.protocol", "smtp");
    51.         props.put("mail.smtp.port", PORT); 
    52.         props.put("mail.smtp.starttls.enable", "true");
    53.         props.put("mail.smtp.auth", "true");
    54. 
    55.         // Create a Session object to represent a mail session with the specified properties. 
    56.         Session session = Session.getDefaultInstance(props);
    57. 
    58.         // Create a message with the specified information. 
    59.         MimeMessage msg = new MimeMessage(session);
    60.         msg.setFrom(new InternetAddress(FROM,FROMNAME));
    61.         msg.setRecipient(Message.RecipientType.TO, new InternetAddress(TO));
    62.         msg.setSubject(SUBJECT);
    63.         msg.setContent(BODY,"text/html");
    64.         
    65.         // Add a configuration set header. Comment or delete the 
    66.         // next line if you are not using a configuration set
    67.         msg.setHeader("X-SES-CONFIGURATION-SET", CONFIGSET);
    68.             
    69.         // Create a transport.
    70.         Transport transport = session.getTransport();
    71. 
    72.         // Get the password 
    73.         String SMTP_PASSWORD = fetchSMTPPasswordFromSecureStorage();
    74.                     
    75.         // Send the message.
    76.         try
    77.         {
    78.             System.out.println("Sending...");
    79.             
    80.             // Connect to Amazon SES using the SMTP username and password you specified above.
    81.             transport.connect(HOST, SMTP_USERNAME, SMTP_PASSWORD);
    82.             
    83.             // Send the email.
    84.             transport.sendMessage(msg, msg.getAllRecipients());
    85.             System.out.println("Email sent!");
    86.         }
    87.         catch (Exception ex) {
    88.             System.out.println("The email was not sent.");
    89.             System.out.println("Error message: " + ex.getMessage());
    90.         }
    91.         finally
    92.         {
    93.             // Close and terminate the connection.
    94.             transport.close();
    95.         }
    96.     }
    97. 
    98.     static String fetchSMTPPasswordFromSecureStorage() {
    99.         /* IMPLEMENT THIS METHOD */
   100.         // For example, you might fetch it from a secure location or AWS Secrets Manager: https://aws.amazon.com/secrets-manager/
   101.     }
   102. }
   ```

1. Ersetzen Sie in **Amazon SESSample .java** die folgenden E-Mail-Adressen durch Ihre eigenen Werte:
**Wichtig**  
Bei den E-Mail-Adressen ist die Groß-/Kleinschreibung nicht relevant. Vergewissern Sie sich, dass die Adressen exakt mit denen übereinstimmen, die Sie verifiziert haben.
   + *sender@example.com*— Ersetzen Sie es durch Ihre „Von“ -E-Mail-Adresse. Sie müssen diese Adresse verifizieren, bevor Sie das Programm ausführen. Weitere Informationen finden Sie unter [Verifizierte Identitäten in Amazon SES](verify-addresses-and-domains.md).
   + *recipient@example.com*— Ersetze es durch deine „An“ -E-Mail-Adresse. Wenn sich Ihr Konto noch in der Sandbox befindet, müssen Sie diese Adresse verifizieren, bevor Sie sie verwenden. Weitere Informationen finden Sie unter [Produktionszugriff anfordern (Verlassen der Amazon SES SES-Sandbox)](request-production-access.md).

1. Ersetzen Sie in **Amazon SESSample .java** Folgendes durch Ihre eigenen Werte:
   + *smtp\$1username*— Ersetzen Sie es durch Ihre SMTP-Benutzernamen-Anmeldedaten. Beachten Sie, dass der SMTP-Benutzername eine 20-stellige Zeichenfolge aus Buchstaben und Zahlen ist und kein wirklicher Name.
   + *smtp\$1password*— Implementieren``fetchSMTPPasswordFromSecureStorage``, um das Passwort abzurufen.

1. (Optional) Wenn Sie einen Amazon SES SMTP-Endpunkt in einem AWS-Region anderen als verwenden möchten*email-smtp.us-west-2.amazonaws.com*, ändern Sie den Wert der Variablen `HOST` auf den Endpunkt, den Sie verwenden möchten. Eine Liste der Regionen, in denen Amazon SES verfügbar ist, finden Sie unter [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) in der *Allgemeine AWS-Referenz*.

1. (Optional) Wenn Sie beim Senden dieser E-Mail einen Konfigurationssatz senden möchten, ändern Sie den Wert der Variable *ConfigSet* in den Namen des Konfigurationssatzes. Weitere Informationen zu Konfigurationssätzen finden Sie unter [Verwenden von Amazon SES-Konfigurationssätzen im](using-configuration-sets.md).

1. Speichern Sie **Amazon SESSample .java.**

1. Wählen Sie **Project** (Projekt) und dann **Build Project** (Projekt entwickeln) aus. (Falls diese Option deaktiviert ist, kann die automatische Erstellung aktiviert sein.)

1. Wählen Sie **Run** (Ausführen) und dann erneut **Run** (Ausführen) aus, um das Programm zu starten und die E-Mail zu senden.

1. Überprüfen Sie die Ausgabe. Wenn die E-Mail erfolgreich gesendet wurde, zeigt die Konsole *„E-Mail gesendet\$1*“ Andernfalls wird eine Fehlermeldung angezeigt.

1. Melden Sie sich am E-Mail-Client der Empfängeradresse an. Sie finden die Nachricht, die Sie gesendet haben.

------
#### [ PHP  ]

In diesem Beispiel wird die PHPMailer Klasse verwendet, um E-Mails über Amazon SES mithilfe der SMTP-Schnittstelle zu senden. 

Bevor Sie das folgende Verfahren ausführen, müssen Sie den Vorgang in [Amazon Simple Email Service einrichten](setting-up.md) abschließen. Zusätzlich zur Einrichtung von Amazon SES müssen Sie die folgenden Voraussetzungen für das Senden von E-Mails mit PHP erfüllen:

**Voraussetzungen:**
+ **PHP installieren** — PHP ist unter [http://php.net/downloads.php](https://php.net/downloads.php) verfügbar. Fügen Sie nach der Installation von PHP Ihren Umgebungsvariablen den Pfad zu PHP hinzu, damit Sie PHP von jeder Eingabeaufforderung aus ausführen können.
+ **Installieren Sie den Composer-Abhängigkeitsmanager** — Nachdem Sie den Composer-Abhängigkeitsmanager installiert haben, können Sie die PHPMailer Klasse und ihre Abhängigkeiten herunterladen und installieren. Folgen Sie den Installationsanweisungen unter [https://getcomposer.org/download, um Composer](https://getcomposer.org/download) zu installieren.
+ ** PHPMailer Klasse installieren — Führen Sie nach der** Installation von Composer den folgenden Befehl aus, um die Klasse zu installieren: PHPMailer 

  ```
  path/to/composer require phpmailer/phpmailer
  ```

  Ersetzen Sie den Befehl im vorherigen Befehl *path/to/* durch den Pfad, in dem Sie Composer installiert haben.

**So senden Sie eine E-Mail über die Amazon-SES-SMTP-Schnittstelle mit PHP**

1. Erstellen Sie eine Datei mit dem Namen **amazon-ses-smtp-sample.php.** Öffnen Sie die Datei mit einem Texteditor und fügen Sie folgenden Code ein:

   ```
    1. <?php
    2. 
    3. // Import PHPMailer classes into the global namespace
    4. // These must be at the top of your script, not inside a function
    5. use PHPMailer\PHPMailer\PHPMailer;
    6. use PHPMailer\PHPMailer\Exception;
    7. 
    8. // If necessary, modify the path in the require statement below to refer to the
    9. // location of your Composer autoload.php file.
   10. require 'vendor/autoload.php';
   11. 
   12. // Replace sender@example.com with your "From" address.
   13. // This address must be verified with Amazon SES.
   14. $sender = 'sender@example.com';
   15. $senderName = 'Sender Name';
   16. 
   17. // Replace recipient@example.com with a "To" address. If your account
   18. // is still in the sandbox, this address must be verified.
   19. $recipient = 'recipient@example.com';
   20. 
   21. // Replace smtp_username with your Amazon SES SMTP user name.
   22. $usernameSmtp = 'smtp_username';
   23. 
   24. // Specify a configuration set. If you do not want to use a configuration
   25. // set, comment or remove the next line.
   26. $configurationSet = 'ConfigSet';
   27. 
   28. // If you're using Amazon SES in a region other than US West (Oregon),
   29. // replace email-smtp.us-west-2.amazonaws.com with the Amazon SES SMTP
   30. // endpoint in the appropriate region.
   31. $host = 'email-smtp.us-west-2.amazonaws.com';
   32. $port = 587;
   33. 
   34. // The subject line of the email
   35. $subject = 'Amazon SES test (SMTP interface accessed using PHP)';
   36. 
   37. // The plain-text body of the email
   38. $bodyText =  "Email Test\r\nThis email was sent through the
   39.     Amazon SES SMTP interface using the PHPMailer class.";
   40. 
   41. // The HTML-formatted body of the email
   42. $bodyHtml = '<h1>Email Test</h1>
   43.     <p>This email was sent through the
   44.     <a href="https://aws.amazon.com/ses">Amazon SES</a> SMTP
   45.     interface using the <a href="https://github.com/PHPMailer/PHPMailer">
   46.     PHPMailer</a> class.</p>';
   47. 
   48. $mail = new PHPMailer(true);
   49. 
   50. try {
   51.     // Specify the SMTP settings.
   52.     $mail->isSMTP();
   53.     $mail->setFrom($sender, $senderName);
   54.     $mail->Username   = $usernameSmtp;
   55.     $mail->Password   = fetchSMTPPasswordFromSecureStorage();
   56.     $mail->Host       = $host;
   57.     $mail->Port       = $port;
   58.     $mail->SMTPAuth   = true;
   59.     $mail->SMTPSecure = 'tls';
   60.     $mail->addCustomHeader('X-SES-CONFIGURATION-SET', $configurationSet);
   61. 
   62.     // Specify the message recipients.
   63.     $mail->addAddress($recipient);
   64.     // You can also add CC, BCC, and additional To recipients here.
   65. 
   66.     // Specify the content of the message.
   67.     $mail->isHTML(true);
   68.     $mail->Subject    = $subject;
   69.     $mail->Body       = $bodyHtml;
   70.     $mail->AltBody    = $bodyText;
   71.     $mail->Send();
   72.     echo "Email sent!" , PHP_EOL;
   73. } catch (phpmailerException $e) {
   74.     echo "An error occurred. {$e->errorMessage()}", PHP_EOL; //Catch errors from PHPMailer.
   75. } catch (Exception $e) {
   76.     echo "Email not sent. {$mail->ErrorInfo}", PHP_EOL; //Catch errors from Amazon SES.
   77. }
   78. function fetchSMTPPasswordFromSecureStorage() {
   79. /* IMPLEMENT THIS METHOD */
   80. // For example, you might fetch it from a secure location or AWS Secrets Manager: https://aws.amazon.com/secrets-manager/
   81. }
   82. 
   83. ?>
   ```

1. Ersetzen Sie in **amazon-ses-smtp-sample.php** Folgendes durch Ihre eigenen Werte:
   + *sender@example.com*— Ersetzen Sie durch eine E-Mail-Adresse, die Sie bei Amazon SES verifiziert haben. Weitere Informationen finden Sie unter [Verifizierte Identitäten](verify-addresses-and-domains.md). Bei den E-Mail-Adressen in Amazon SES wird die Groß-/Kleinschreibung beachtet. Stellen Sie sicher, dass die von Ihnen eingegebene Adresse exakt mit der verifizierten Adresse übereinstimmt.
   + *recipient@example.com*— Durch die Adresse des Empfängers ersetzen. Wenn sich Ihr Konto noch in der Sandbox befindet, müssen Sie diese Adresse verifizieren, bevor Sie sie verwenden. Weitere Informationen finden Sie unter [Produktionszugriff anfordern (Verlassen der Amazon SES SES-Sandbox)](request-production-access.md). Stellen Sie sicher, dass die von Ihnen eingegebene Adresse exakt mit der verifizierten Adresse übereinstimmt.
   + *smtp\$1username*— Ersetzen Sie es durch Ihre SMTP-Benutzernamen-Anmeldedaten, die Sie auf der Seite mit den [SMTP-Einstellungen](https://console.aws.amazon.com/ses/home?#smtp-settings:) der Amazon SES SES-Konsole abgerufen haben. Dieser Benutzername ist **nicht** mit Ihrer AWS -Zugriffsschlüssel-ID identisch. Beachten Sie, dass der SMTP-Benutzername eine 20-stellige Zeichenfolge aus Buchstaben und Zahlen ist und kein wirklicher Name.
   + *smtp\$1password*— Implementieren``fetchSMTPPasswordFromSecureStorage``, um das Passwort abzurufen.
   + (Optional) *ConfigSet* — Wenn Sie beim Senden dieser E-Mail einen Konfigurationssatz verwenden möchten, ersetzen Sie diesen Wert durch den Namen des Konfigurationssatzes. Weitere Informationen zu Konfigurationssätzen finden Sie unter [Verwenden von Amazon SES-Konfigurationssätzen im](using-configuration-sets.md).
   + (Optional) *email-smtp.us-west-2.amazonaws.com* — Wenn Sie einen Amazon SES SES-SMTP-Endpunkt in einer anderen Region als USA West (Oregon) verwenden möchten, ersetzen Sie diesen durch den Amazon SES SES-SMTP-Endpunkt in der Region, die Sie verwenden möchten. Eine Liste der SMTP-Endpunkte URLs , auf AWS-Regionen denen Amazon SES verfügbar ist, finden Sie unter [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) in der *Allgemeine AWS-Referenz*.

1. Speichern Sie die Datei **amazon-ses-smtp-sample.php.**

1. Um das Programm auszuführen, öffnen Sie eine Eingabeaufforderung im selben Verzeichnis wie **amazon-ses-smtp-sample.php** und geben Sie dann Folgendes ein. **php amazon-ses-smtp-sample.php**

1. Überprüfen Sie die Ausgabe. Wenn die E-Mail erfolgreich gesendet wurde, zeigt die Konsole *„E-Mail gesendet\$1*“ an Andernfalls wird eine Fehlermeldung angezeigt.

1. Melden Sie sich am E-Mail-Client der Empfängeradresse an. Sie finden die Nachricht, die Sie gesendet haben.

------

# Integrieren von Amazon SES in Ihren vorhandenen E-Mail-Server
<a name="send-email-smtp-existing-server"></a>

Wenn Sie derzeit Ihren eigenen E-Mail-Server verwalten, können Sie den Amazon-SES-SMTP-Endpunkt zum Senden all Ihrer ausgehenden E-Mails an Amazon SES verwenden. Es ist nicht notwendig, die vorhandenen E-Mail-Clients und Anwendungen zu ändern. Die Umstellung auf Amazon SES ist transparent für diese.

Mehrere Mail Transfer Agents (MTAs) unterstützen das Senden von E-Mails über SMTP-Relays. Dieser Abschnitt enthält allgemeine Anleitungen zur Konfiguration einiger beliebter Apps für MTAs den E-Mail-Versand über die Amazon SES SMTP-Schnittstelle.

Der SMTP-Endpunkt von Amazon SES erfordert, dass alle Verbindungen mit Transport Layer Security (TLS) verschlüsselt werden.

**Topics**
+ [Integrieren von Amazon SES mit Postfix](postfix.md)
+ [Integrieren von Amazon SES in Sendmail](send-email-sendmail.md)
+ [Integrieren von Amazon SES mit dem Microsoft Windows Server IIS SMTP](send-email-windows-server.md)

# Integrieren von Amazon SES mit Postfix
<a name="postfix"></a>

Postfix ist eine Alternative zum weit verbreiteten Sendmail Message Transfer Agent (MTA). Weitere Informationen zu Postfix finden Sie unter [http://www.postfix.org](http://www.postfix.org). Die Verfahren in diesem Thema funktionieren mit Linux, macOS, oder Unix.

**Anmerkung**  
Postfix ist eine Drittanbieter-Anwendung und wird von Amazon Web Services nicht entwickelt oder unterstützt. Die Verfahren in diesem Abschnitt dienen ausschließlich zu Informationszwecken und können ohne vorherige Ankündigung geändert werden.

## Voraussetzungen
<a name="send-email-postfix-prereqs"></a>

Zum Abschließen der Verfahren in diesem Abschnitt müssen Sie zunächst folgende Aufgaben durchführen:
+ Deinstallieren Sie die Sendmail-Anwendung, wenn sie bereits auf Ihrem System installiert ist. Das Verfahren für die Ausführung dieses Schritts variiert je nach verwendetem Betriebssystem.
**Wichtig**  
Die folgenden Verweise auf *sendmail* beziehen sich auf den Postfix-Befehl `sendmail`, nicht zu verwechseln mit der Sendmail-Anwendung.
+ Installieren Sie Postfix. Das Verfahren für die Ausführung dieses Schritts variiert je nach verwendetem Betriebssystem.
+ Installieren Sie ein SASL-Authentifizierungspaket. Das Verfahren für die Ausführung dieses Schritts variiert je nach verwendetem Betriebssystem. Wenn Sie beispielsweise ein RedHat basiertes System verwenden, sollten Sie das `cyrus-sasl-plain` Paket installieren. Wenn Sie ein Debian- oder Ubuntu-basiertes System verwenden, sollten Sie das `libsasl2-modules`-Paket installieren.
+ Überprüfen Sie eine E-Mail-Adresse oder Domäne, die für das Senden von E-Mails verwendet werden soll. Weitere Informationen finden Sie unter [Erstellen einer E-Mail-Adressidentität](creating-identities.md#verify-email-addresses-procedure).
+ Wenn sich Ihr Konto noch in der Sandbox befindet, können Sie nur E-Mails an verifizierte E-Mail-Adressen senden. Weitere Informationen finden Sie unter [Produktionszugriff anfordern (Verlassen der Amazon SES SES-Sandbox)](request-production-access.md).

## Konfigurieren von Postfix
<a name="send-email-postfix"></a>

Führen Sie die folgenden Verfahren durch, um Ihren E-Mail-Server für das Senden von E-Mail über Amazon SES mit Postfix zu konfigurieren.

**So konfigurieren Sie Postfix**

1. Geben Sie in der Befehlszeile folgenden Befehl ein:

   ```
   sudo postconf -e "relayhost = [email-smtp.us-west-2.amazonaws.com]:587" \
   "smtp_sasl_auth_enable = yes" \
   "smtp_sasl_security_options = noanonymous" \
   "smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd" \
   "smtp_use_tls = yes" \
   "smtp_tls_security_level = secure" \
   "smtp_tls_note_starttls_offer = yes"
   ```
**Anmerkung**  
Wenn Sie Amazon SES in einer anderen AWS Region als USA West (Oregon) verwenden, ersetzen Sie *email-smtp.us-west-2.amazonaws.com* den vorherigen Befehl durch den SMTP-Endpunkt der entsprechenden Region. Weitere Informationen finden Sie unter [Regionen und Amazon SES](regions.md).

1. Öffnen Sie die Datei `/etc/postfix/master.cf` in einem Texteditor. Suchen Sie den folgenden Eintrag:

   ```
   -o smtp_fallback_relay=
   ```

   Wenn Sie diesen Eintrag suchen, kommentieren Sie ihn aus, indem Sie ein `#` (Hash)-Zeichen an den Anfang der Zeile setzen. Speichern und schließen Sie die Datei.

   Wenn dieser Eintrag nicht vorhanden ist, fahren Sie mit dem nächsten Schritt fort.

1. Öffnen Sie die Datei `/etc/postfix/sasl_passwd` in einem Texteditor. Wenn die Datei nicht bereits vorhanden ist, erstellen Sie sie.

1. Fügen Sie die folgende Zeile zu `/etc/postfix/sasl_passwd` hinzu:

   ```
   [email-smtp.us-west-2.amazonaws.com]:587 SMTPUSERNAME:SMTPPASSWORD
   ```
**Anmerkung**  
Ersetzen Sie *SMTPUSERNAME* und *SMTPPASSWORD* durch Ihre SMTP-Anmeldedaten. Ihre SMTP-Anmeldeinformationen sind nicht mit Ihrer AWS -Zugriffsschlüssel-ID und dem geheimen Zugriffsschlüssel identisch. Weitere Informationen zu Anmeldeinformationen finden Sie unter [Abrufen Ihrer Amazon-SES-SMTP-Anmeldeinformationen](smtp-credentials.md).  
Wenn Sie Amazon SES in einer anderen AWS Region als USA West (Oregon) verwenden, ersetzen Sie *email-smtp.us-west-2.amazonaws.com* das vorherige Beispiel durch den SMTP-Endpunkt der entsprechenden Region. Weitere Informationen finden Sie unter [Regionen und Amazon SES](regions.md).

   Speichern und schließen Sie `sasl_passwd`.

1. Geben Sie bei der Eingabeaufforderung den folgenden Befehl ein, um eine Hashmap-Datenbankdatei mit Ihren SMTP-Anmeldeinformationen zu erstellen:

   ```
   sudo postmap hash:/etc/postfix/sasl_passwd
   ```

1. (Optional) Die Dateien `/etc/postfix/sasl_passwd` und `/etc/postfix/sasl_passwd.db`, die Sie in den vorherigen Schritten erstellt haben, sind nicht verschlüsselt. Da diese Dateien Ihre SMTP-Anmeldeinformationen enthalten, empfehlen wir, dass Sie die Eigentümerschaft und Berechtigungen der Dateien ändern, um den Zugriff auf sie zu beschränken. So beschränken Sie den Zugriff auf diese Dateien:

   1. Geben Sie an einer Eingabeaufforderung den folgenden Befehl ein, um die Eigentümerschaft der Dateien zu ändern:

      ```
      sudo chown root:root /etc/postfix/sasl_passwd /etc/postfix/sasl_passwd.db
      ```

   1. Geben Sie an einer Eingabeaufforderung den folgenden Befehl ein, um die Berechtigungen der Datei zu ändern, sodass nur der Root-Benutzer Lese- oder Schreiboperationen dafür ausführen kann:

      ```
      sudo chmod 0600 /etc/postfix/sasl_passwd /etc/postfix/sasl_passwd.db
      ```

1. Teilen Sie Postfix mit, wo sich das CA-Zertifikat befindet (benötigt, um das Amazon-SES-Serverzertifikat zu überprüfen). Der Befehl in diesem Schritt variiert je nach Betriebssystem.
   + Wenn Sie Amazon Linux, Red Hat Enterprise Linux oder eine ähnliche Verteilung verwenden, geben Sie den folgenden Befehl ein: 

     ```
     sudo postconf -e 'smtp_tls_CAfile = /etc/ssl/certs/ca-bundle.crt'
     ```
   + Wenn Sie Ubuntu oder eine ähnliche Verteilung verwenden, geben Sie den folgenden Befehl ein:

     ```
     sudo postconf -e 'smtp_tls_CAfile = /etc/ssl/certs/ca-certificates.crt'
     ```
   + Wenn Sie macOS verwenden, können Sie das Zertifikat aus Ihrer System-Schlüsselkette generieren. Um das Zertifikat zu generieren, geben Sie den folgenden Befehl in der Befehlszeile ein:

     ```
     sudo security find-certificate -a -p /System/Library/Keychains/SystemRootCertificates.keychain | sudo tee /etc/ssl/certs/ca-bundle.crt > /dev/null
     ```

     Nachdem Sie den Zertifikattyp generiert haben, geben Sie den folgenden Befehl ein:

     ```
     sudo postconf -e 'smtp_tls_CAfile = /etc/ssl/certs/ca-bundle.crt'
     ```

1. Geben Sie den folgenden Befehl ein, um den Postfix-Server zu starten (oder die Konfigurationseinstellungen neu zu laden, wenn der Server bereits ausgeführt wird):

   ```
   sudo postfix start; sudo postfix reload
   ```

1. Senden Sie eine Test-E-Mail, indem Sie den folgenden Befehl in die Befehlszeile eingeben und nach jeder Zeile die Eingabetaste drücken. Ersetzen Sie es *sender@example.com* durch Ihre Absender-E-Mail-Adresse. Die Absenderadresse muss für die Verwendung mit Amazon SES überprüft werden. *recipient@example.com*Durch die Zieladresse ersetzen. Wenn sich Ihr Konto noch in der Sandbox befindet, muss auch die Empfängeradresse verifiziert werden. Außerdem muss die letzte Zeile der Nachricht einen einzelnen Punkt (.) ohne andere Inhalte enthalten.

   ```
   sendmail -f sender@example.com recipient@example.com
   From: Sender Name <sender@example.com>
   Subject: Amazon SES Test                
   This message was sent using Amazon SES.                
   .
   ```

1. Überprüfen Sie das Postfach, das mit der Empfängeradresse verknüpft ist. Wenn die E-Mail nicht eintrifft, überprüfen Sie Ihren Spam-Ordner. Wenn Sie die E-Mail immer noch nicht finden können, überprüfen Sie das Mail-Protokoll auf dem System, das Sie zum Senden der E-Mail verwendet haben (in der Regel unter `/var/log/maillog` zu finden), um weitere Informationen zu erhalten.

## Beispiel für die erweiterte Nutzung
<a name="send-email-postfix-advanced"></a>

In diesem Beispiel wird gezeigt, wie eine E-Mail versendet wird, die einen [Konfigurationssatz](using-configuration-sets.md) verwendet und die eine MIME-Multipart-Codierung für das Senden sowohl eines Klartexts als auch einer HTML-Version der Nachricht mit einem Anhang nutzt. Sie beinhaltet auch einen [Link-Tag](faqs-metrics.md#sending-metric-faqs-clicks-q5), der für die Kategorisierung von Klickereignissen verwendet werden kann. Der Inhalt der E-Mail wird in einer externen Datei angegeben, sodass Sie die Befehle in der Postfix-Sitzung nicht manuell eingeben müssen.

**So senden Sie eine mehrteilige MIME-E-Mail mit Postfix**

1. Erstellen Sie in einem Texteditor eine neue Datei mit dem Namen `mime-email.txt`.

1. Fügen Sie in der Textdatei den folgenden Inhalt ein und ersetzen Sie dabei die roten Werte durch die entsprechenden Werte für Ihr Konto:

   ```
   X-SES-CONFIGURATION-SET: ConfigSet
   From:Sender Name <sender@example.com>
   Subject:Amazon SES Test
   MIME-Version: 1.0
   Content-Type: multipart/mixed; boundary="YWVhZDFlY2QzMGQ2N2U0YTZmODU"
   
   --YWVhZDFlY2QzMGQ2N2U0YTZmODU
   Content-Type: multipart/alternative; boundary="3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ"
   
   --3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ
   Content-Type: text/plain; charset=UTF-8
   Content-Transfer-Encoding: quoted-printable
   
   Amazon SES Test
   
   This message was sent from Amazon SES using the SMTP interface.
   
   For more information, see:
   http://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-smtp.html
   
   --3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ
   Content-Type: text/html; charset=UTF-8
   Content-Transfer-Encoding: quoted-printable
   
   <html>
     <head>
   </head>
     <body>
       <h1>Amazon SES Test</h1>
         <p>This message was sent from Amazon SES using the SMTP interface.</p>
         <p>For more information, see
         <a ses:tags="samplekey0:samplevalue0;samplekey1:samplevalue1;" 
         href="http://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-smtp.html">
         Using the Amazon SES SMTP Interface to Send Email</a> in the <em>Amazon SES
         Developer Guide</em>.</p>
     </body>
   </html>
   --3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ--
   --YWVhZDFlY2QzMGQ2N2U0YTZmODU
   Content-Type: application/octet-stream
   MIME-Version: 1.0
   Content-Transfer-Encoding: base64
   Content-Disposition: attachment; filename="customers.txt"
   
   SUQsRmlyc3ROYW1lLExhc3ROYW1lLENvdW50cnkKMzQ4LEpvaG4sU3RpbGVzLENh
   bmFkYQo5MjM4OSxKaWUsTGl1LENoaW5hCjczNCxTaGlybGV5LFJvZHJpZ3VleixV
   bml0ZWQgU3RhdGVzCjI4OTMsQW5heWEsSXllbmdhcixJbmRpYQ==
   --YWVhZDFlY2QzMGQ2N2U0YTZmODU--
   ```

   Speichern und schließen Sie die Datei.

1. Geben Sie in der Befehlszeile folgenden Befehl ein. *sender@example.com*Ersetzen Sie es durch Ihre E-Mail-Adresse und *recipient@example.com* ersetzen Sie es durch die E-Mail-Adresse des Empfängers.

   ```
   sendmail -f sender@example.com recipient@example.com < mime-email.txt
   ```

   Wenn der Befehl erfolgreich ausgeführt wird, wird er ohne Ausgabe beendet.

1. Suchen Sie in Ihrem Posteingang nach der E-Mail. Wenn die Nachricht nicht übermittelt wurde, überprüfen Sie das E-Mail-Protokoll Ihres Systems.

# Integrieren von Amazon SES in Sendmail
<a name="send-email-sendmail"></a>

Sendmail wurde in den frühen 80er-Jahren veröffentlicht und seitdem kontinuierlich verbessert. Es handelt sich dabei um einen flexiblen und konfigurierbaren Message Transfer Agent (MTA) mit einer großen Nutzer-Community. Sendmail wurde im Jahr 2013 von Proofpoint übernommen, Proofpoint bietet aber weiterhin eine Open-Source-Version von Sendmail an. Sie können die [Open Source-Version von Sendmail](https://www.proofpoint.com/us/open-source-email-solution) von der Proofpoint-Website oder über den Paket-Manager der meisten Linux-Distributionen herunterladen.

In Anleitung in diesem Abschnitt erfahren Sie, wie Sie Sendmail so konfigurieren, dass E-Mail-Nachrichten über Amazon SES gesendet werden. Dieses Verfahren wurde auf einem Server mit Ubuntu 18.04.2 LTS getestet.

**Anmerkung**  
Sendmail ist eine Drittanbieter-Anwendung und wird von Amazon Web Services nicht entwickelt oder unterstützt. Die Verfahren in diesem Abschnitt dienen ausschließlich zu Informationszwecken und können ohne vorherige Ankündigung geändert werden.

## Voraussetzungen
<a name="send-email-sendmail-prerequisites"></a>

Bevor Sie das Verfahren in diesem Abschnitt ausführen, sollten Sie die folgenden Schritte ausführen:
+ Installieren Sie das Sendmail-Paket auf Ihrem Server. 
**Anmerkung**  
Je nachdem, welches Betriebssystem Sie verwenden, müssen Sie möglicherweise auch die folgenden Pakete installieren: `sendmail-cf`, `m4` und `cyrus-sasl-plain`.
+ Überprüfen Sie die als „Von“-Adresse zu verwendende Identität. Weitere Informationen finden Sie unter [Erstellen einer E-Mail-Adressidentität](creating-identities.md#verify-email-addresses-procedure).

  Wenn Ihr Konto sich noch in der Amazon-SES-Sandbox befindet, müssen Sie auch die Adressen verifizieren, an die Sie E-Mail-Nachrichten senden. Weitere Informationen finden Sie unter [Produktionszugriff anfordern (Verlassen der Amazon SES SES-Sandbox)](request-production-access.md).

Wenn Sie Amazon SES benutzen, um E-Mail-Nachrichten von einer Amazon EC2-Instance aus zu senden, sollten Sie auch die folgenden Schritte ausführen:
+ Sie müssen möglicherweise eine Elastic IP-Adresse zu Ihrer Amazon-EC2-Instance hinzufügen, damit empfangende E-Mail-Anbieter Ihre E-Mail-Nachrichten annehmen. Weitere Informationen finden Sie unter [Amazon EC2 Elastic IP-Adressen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) im *Amazon EC2 EC2-Benutzerhandbuch*.
+ Amazon Elastic Compute Cloud (Amazon EC2) schränkt den E-Mail-Datenverkehr standardmäßig über Port 25 ein. Um Zeitüberschreitungen beim Senden von E-Mails über den SMTP-Endpunkt von Amazon EC2 zu vermeiden, können Sie beantragen, dass diese Einschränkungen entfernt werden. Weitere Informationen finden Sie unter [Wie entferne ich die Beschränkung für Port 25 aus meiner Amazon EC2 EC2-Instance oder AWS Lambda -Funktion](https://aws.amazon.com/premiumsupport/knowledge-center/ec2-port-25-throttle/)? im AWS Knowledge Center.

  Alternativ können Sie das Verfahren in diesem Abschnitt ändern, um Port 587 anstelle von Port 25 zu verwenden.

## Konfigurieren von Sendmail
<a name="send-email-sendmail-procedure"></a>

Führen Sie die Schritte in diesem Abschnitt zum Konfigurieren von Sendmail für das Senden von E-Mail-Nachrichten mithilfe von Amazon SES aus.

**Wichtig**  
Bei dem Verfahren in diesem Abschnitt wird davon ausgegangen, dass Sie Amazon SES im Westen der USA (Oregon) verwenden möchten AWS-Region. Wenn Sie eine andere Region verwenden möchten, ersetzen Sie alle Instances von *email-smtp.us-west-2.amazonaws.com* in diesem Verfahren durch den SMTP-Endpunkt der gewünschten Region. Eine Liste der SMTP-Endpunkte URLs , auf AWS-Regionen denen Amazon SES verfügbar ist, finden Sie unter [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) in der *Allgemeine AWS-Referenz*.

**So konfigurieren Sie Sendmail:**

1. Öffnen Sie in einem Datei-Editor die Datei `/etc/mail/authinfo`. Wenn die Datei nicht vorhanden ist, erstellen Sie sie.

   Fügen Sie die folgende Zeile zu*/etc/mail/authinfo*hinzu:

   ```
   AuthInfo:email-smtp.us-west-2.amazonaws.com "U:root" "I:smtpUsername" "P:smtpPassword" "M:PLAIN"
   ```

   Nehmen Sie im vorherigen Beispiel Sie die folgenden Änderungen vor:
   + *email-smtp.us-west-2.amazonaws.com*Ersetzen Sie durch den Amazon SES SMTP-Endpunkt, den Sie verwenden möchten.
   + *smtpUsername*Ersetzen Sie es durch Ihren Amazon SES SMTP-Benutzernamen.
   + *smtpPassword*Ersetzen Sie es durch Ihr Amazon SES SMTP-Passwort.
**Anmerkung**  
Ihre SMTP-Anmeldedaten unterscheiden sich von Ihrer AWS Access Key-ID und Ihrem Secret Access Key. Weitere Informationen zum Abrufen Ihrer SMTP-Anmeldeinformationen finden Sie unter [Abrufen Ihrer Amazon-SES-SMTP-Anmeldeinformationen](smtp-credentials.md).

   Wenn Sie fertig sind, speichern Sie `authinfo`.

1. Geben Sie in der Befehlszeile den folgenden Befehl ein, um die `/etc/mail/authinfo.db`-Datei zu erstellen:

   ```
   sudo sh -c 'makemap hash /etc/mail/authinfo.db < /etc/mail/authinfo'
   ```

1. Geben Sie in der Befehlszeile den folgenden Befehl ein, um die Unterstützung für die Weiterleitung an den Amazon-SES-SMTP-Endpunkt hinzuzufügen.

   ```
   sudo sh -c 'echo "Connect:email-smtp.us-west-2.amazonaws.com RELAY" >> /etc/mail/access'
   ```

   Ersetzen Sie im vorherigen Befehl *email-smtp.us-west-2.amazonaws.com* durch die Adresse des Amazon SES SES-SMTP-Endpunkts, den Sie verwenden möchten.

1. Geben Sie in der Befehlszeile den folgenden Befehl ein, um*/etc/mail/access*.db neu zu generieren:

   ```
   sudo sh -c 'makemap hash /etc/mail/access.db < /etc/mail/access'
   ```

1. Geben Sie in der Befehlszeile den folgenden Befehl ein, um Sicherungskopien der Dateien `sendmail.cf` und `sendmail.mc` zu erstellen:

   ```
   sudo sh -c 'cp /etc/mail/sendmail.cf /etc/mail/sendmail_cf.backup && cp /etc/mail/sendmail.mc /etc/mail/sendmail_mc.backup'
   ```

1. Fügen Sie der Datei*/etc/mail/sendmail.mc vor allen Definitionen* die folgenden Zeilen hinzu. `MAILER()`

   ```
   define(`SMART_HOST', `email-smtp.us-west-2.amazonaws.com')dnl
   define(`RELAY_MAILER_ARGS', `TCP $h 25')dnl
   define(`confAUTH_MECHANISMS', `LOGIN PLAIN')dnl
   FEATURE(`authinfo', `hash -o /etc/mail/authinfo.db')dnl
   MASQUERADE_AS(`example.com')dnl
   FEATURE(masquerade_envelope)dnl
   FEATURE(masquerade_entire_domain)dnl
   ```

   Gehen Sie im vorhergehenden Text wie folgt vor.
   + *email-smtp.us-west-2.amazonaws.com*Ersetzen Sie durch den Amazon SES SMTP-Endpunkt, den Sie verwenden möchten.
   + *example.com*Ersetzen Sie es durch die Domain, die Sie zum Senden von E-Mails verwenden möchten.

   Wenn Sie fertig sind, speichern Sie die Datei.
**Anmerkung**  
Amazon EC2 schränkt die Kommunikation standardmäßig über Port 25 ein. Wenn Sie Sendmail in einer Amazon-EC2-Instance verwenden, sollten Sie das Formular [Anforderung zum Entfernen von E-Mail-Sendebeschränkungen](https://aws-portal.amazon.com/gp/aws/html-forms-controller/contactus/ec2-email-limit-rdns-request) ausfüllen.

1. Geben Sie in der Befehlszeile den folgenden Befehl ein, um *sendmail.cf* schreibfähig zu machen:

   ```
   sudo chmod 666 /etc/mail/sendmail.cf
   ```

1. Geben Sie in der Befehlszeile den folgenden Befehl ein, um *sendmail.cf* erneut zu generieren:

   ```
   sudo sh -c 'm4 /etc/mail/sendmail.mc > /etc/mail/sendmail.cf'
   ```
**Anmerkung**  
Wenn Fehler, wie „Command not found (Befehl nicht gefunden“ und „No such file or directory (Verzeichnis nicht vorhanden)“ auftreten, stellen Sie sicher, dass die Pakete `m4` und `sendmail-cf` auf Ihrem System installiert sind.

1. Geben Sie in der Befehlszeile den folgenden Befehl ein, um die Berechtigungen von *sendmail.cf* auf „schreibgeschützt“ zurückzusetzen:

   ```
   sudo chmod 644 /etc/mail/sendmail.cf
   ```

1. Geben Sie in der Befehlszeile den folgenden Befehl ein, um Sendmail neu zu starten:

   ```
   sudo /etc/init.d/sendmail restart
   ```

   *Versuchen Sie je nach der Version von Linux oder Sendmail Folgendes, wenn das oben genannte nicht funktioniert:*

   ```
   sudo su service sendmail restart
   ```

1. Führen Sie die folgenden Schritte aus, um eine Test-E-Mail-Nachricht zu senden:

   1. Geben Sie in der Befehlszeile den folgenden Befehl ein:

      ```
      /usr/sbin/sendmail -vf sender@example.com recipient@example.com
      ```

      *sender@example.com*Ersetzen Sie es durch Ihre Absender-E-Mail-Adresse. *recipient@example.com*Ersetzen Sie es durch die Empfängeradresse. Wenn Sie fertig sind, betätigen Sie Enter.

   1. Geben Sie den folgenden Nachrichteninhalt ein. Betätigen Sie nach jeder Zeile Enter.

      ```
      From: sender@example.com
      To: recipient@example.com
      Subject: Amazon SES test email
      
      This is a test message sent from Amazon SES using Sendmail.
      ```

      Wenn Sie den Inhalt der E-Mail-Nachricht eingegeben haben, betätigen Sie Ctrl\$1D, um sie zu senden.

1. Überprüfen Sie den E-Mail-Client des Empfängers auf die E-Mail-Nachricht. Wenn Sie die E-Mail-Nachricht nicht finden können, überprüfen Sie den Spam-Ordner. Wenn Sie die E-Mail-Nachricht immer noch nicht finden können, überprüfen Sie das Sendmail-Protokoll auf Ihrem E-Mail-Server. Das Protokoll befindet sich häufig unter*/var/log/mail.log* oder*/var/log/maillog*. 

# Integrieren von Amazon SES mit dem Microsoft Windows Server IIS SMTP
<a name="send-email-windows-server"></a>

Sie können den IIS-SMTP-Server von Microsoft Windows für das Senden von E-Mails über Amazon SES konfigurieren. Diese Anweisungen wurden mit Microsoft Windows Server 2022 auf einer Amazon EC2 EC2-Instance geschrieben. Sie können dieselbe Konfiguration auf Microsoft Windows Server 2016 verwenden.

**Anmerkung**  
Windows Server ist eine Drittanbieteranwendung und wird von Amazon Web Services nicht entwickelt oder unterstützt. Die Verfahren in diesem Abschnitt dienen ausschließlich zu Informationszwecken und können ohne vorherige Ankündigung geändert werden.

**So integrieren Sie den IIS-SMTP-Server von Microsoft Windows in Amazon SES**

1. Richten Sie zunächst Microsoft Windows Server 2022 mithilfe der folgenden Anweisungen ein.

   1. Starten Sie von der [Amazon EC2-Managementkonsole aus eine neue Amazon EC2](https://console.aws.amazon.com/ec2/home) EC2-Basisinstanz für Microsoft Windows Server 2022.

   1. Stellen Sie eine Verbindung mit der Instance über Remote Desktop her und melden Sie sich an. Befolgen Sie hierzu die Anweisungen unter [Erste Schritte mit Amazon EC2 Windows-Instances](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2Win_GetStarted.html).

   1. Starten Sie das Server Manager-Dashboard.

   1. Installieren Sie die Rolle **Web Server**. Stellen Sie sicher, dass Sie die **IIS 10-Verwaltungskompatibilitätstools** (eine Option unter dem Kontrollkästchen **Webserver**) einbeziehen.

   1. Installieren Sie die Funktion **SMTP Server**.

1. Anschließend konfigurieren Sie den IIS-SMTP-Service unter Verwendung der folgenden Anweisungen.

   1. Kehren Sie zum Server-Manager-Dashboard zurück.

   1. Wählen Sie im Menü **Tools** die Option **Internet Information Services (IIS) 10.0 Manager** aus.

   1. Klicken Sie mit der rechten Maustaste auf **SMTP Virtual Server \$11** und wählen Sie anschließend **Properties** (Eigenschaften) aus.

   1. Wählen Sie auf der Registerkarte **Access** (Zugreifen) unter **Relay Restrictions** (Relais-Einschränkungen) die Option **Relay** (Relais) aus.

   1. Klicken Sie im Dialogfeld **Relay Restrictions** (Relais-Einschränkungen auf **Add** (Hinzufügen).

   1. Geben Sie unter **Single Computer** **127.0.0.1** für die IP-Adresse ein. Sie haben diesem Server nun Zugriff gewährt, um E-Mails über den IIS-SMTP-Service an Amazon SES weiterzuleiten.

      In diesem Verfahren gehen wir davon aus, dass Ihre E-Mails auf diesem Server generiert werden. Wenn die Anwendung, die die E-Mails generiert, auf einem separaten Server ausgeführt wird, müssen Sie Weiterleitungszugriff für diesen Server in IIS-SMTP gewähren.
**Anmerkung**  
Um die SMTP-Weiterleitung auf private Subnetze zu erweitern, wählen Sie für **Relay Restriction** (Relais-Einschränkungen) **Single Computer** (Einzelcomputer) 127.0.0.1 und **Group of Computers** (Gruppe von Computern) 172.1.1.0 - 255.255.255.0 (im Bereich mit der Netzwerkmaske). Verwenden Sie für **Connection** (Verbindung) **Single Computer** (Einzelcomputer) 127.0.0.1 und **Group of Computers** (Gruppe von Computern) 172.1.1.0 - 255.255.255.0 (im Bereich mit der Netzwerkmaske).

1. Konfigurieren Sie schließlich den Server für das Senden von E-Mails über Amazon SES mithilfe der folgenden Anweisungen.

   1. Kehren Sie zum Dialogfeld **SMTP Virtual Server \$11 Properties** zurück und wählen Sie die Register **Delivery** (Bereitstellung) aus.

   1. Wählen Sie auf der Registerkarte **Delivery** (Bereitstellung) die Option **Outbound Security** (Ausgehende Sicherheit) aus.

   1. Wählen Sie **Basic Authentication** (Standardauthentifizierung) aus und geben Sie dann Ihre SMTP-Anmeldeinformationen für Amazon SES ein. Sie können diese Anmeldeinformationen aus der Amazon-SES-Konsole mit dem Verfahren unter [Abrufen Ihrer Amazon-SES-SMTP-Anmeldeinformationen](smtp-credentials.md) abrufen.
**Wichtig**  
Ihre SMTP-Anmeldeinformationen stimmen nicht mit Ihrer AWS Zugriffsschlüssel-ID und Ihrem geheimen Zugriffsschlüssel überein. Versuchen Sie nicht, sich mit Ihren AWS Anmeldeinformationen am SMTP-Endpunkt zu authentifizieren. Weitere Informationen zu Anmeldeinformationen finden Sie unter [Arten von Amazon-SES-Anmeldeinformationen](send-email-concepts-credentials.md).

   1. Stellen Sie sicher, dass **TLS encryption** (TLS-Verschlüsselung) ausgewählt ist.

   1. Kehren Sie zur Registerkarte **Delivery** (Bereitstellung) zurück.

   1. Wählen Sie **Outbound Connections** (Ausgehende Verbindungen) aus.

   1. Stellen Sie im Dialogfeld **Outbound Connections** (Ausgehende Verbindungen) sicher, dass der Port 25 oder 587 ist. 

   1. Wählen Sie **Advanced** (Erweitert) aus.

   1. Geben Sie für den **Smarthostnamen** den Amazon SES Endpunkt ein, den Sie verwenden werden (zum Beispiel*email-smtp.us-west-2.amazonaws.com*). Eine Liste der Endpunkte, URLs auf AWS-Regionen denen Amazon SES verfügbar ist, finden Sie unter [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) in der *Allgemeine AWS-Referenz*.

   1. Kehren Sie zum Server-Manager-Dashboard zurück.

   1. Klicken Sie auf dem Server Manager-Dashboard mit der rechten Maustaste auf **SMTP Virtual Server \$11** und starten Sie dann den Service neu, damit die neue Konfiguration wirksam wird.

   1. Senden Sie eine E-Mail über diesen Server. Sie können die Nachrichten-Header prüfen, um zu bestätigen, dass sie über Amazon SES zugestellt wurde.

# Testen der Verbindung zur Amazon-SES-SMTP-Schnittstelle über die Befehlszeile
<a name="send-email-smtp-client-command-line"></a>

Die in diesem Abschnitt beschriebenen Methoden dienen dazu, Ihre Verbindung zum Amazon-SES-SMTP-Endpunkt zu testen, Ihre SMTP-Anmeldeinformationen zu überprüfen und Verbindungsprobleme zu beheben. Diese Verfahren verwenden Tools und Bibliotheken, die in den gängigsten Betriebssystemen enthalten sind.

Zusätzliche Hinweise zur Behebung von SMTP-Verbindungsproblemen finden Sie unter [SMTP-Probleme bei Amazon SES](troubleshoot-smtp.md).

## Voraussetzungen
<a name="send-email-smtp-client-command-line-prereqs"></a>

Wenn Sie eine Verbindung mit der Amazon-SES-SMTP-Schnittstelle herstellen, müssen Sie einen Satz von SMTP-Anmeldeinformationen angeben. Diese SMTP-Anmeldeinformationen unterscheiden sich von Ihren AWS Standardanmeldedaten. Die beiden Arten von Anmeldeinformationen sind nicht austauschbar. Weitere Informationen zum Abrufen Ihrer SMTP-Anmeldeinformationen finden Sie unter [Abrufen Ihrer Amazon-SES-SMTP-Anmeldeinformationen](smtp-credentials.md).

## Testen Ihrer Amazon SES SMTP-Schnittstellenverbindung
<a name="send-email-smtp-client-command-line-testing"></a>

Sie können die Befehlszeile verwenden, um Ihre Verbindung zur Amazon-SES-SMTP-Schnittstelle zu testen, ohne sich zu authentifizieren oder Nachrichten zu senden. Dieses Verfahren ist nützlich für die Behebung grundlegender Verbindungsprobleme. Falls Ihre Testverbindung fehlschlägt, finden Sie weitere Informationen unter [SMTP-Probleme](troubleshoot-smtp.md).

Dieser Abschnitt enthält Verfahren zum Testen Ihrer Verbindung sowohl mit OpenSSL (das in den meisten Linux-, macOS- und Unix-Distributionen enthalten ist und auch für Windows verfügbar ist) als auch mit dem `Test-NetConnection` Cmdlet in PowerShell (das in den neuesten Versionen von Windows enthalten ist).

------
#### [ Linux, macOS, or Unix ]

Es gibt zwei Möglichkeiten, mit OpenSSL eine Verbindung zur Amazon-SES-SMTP-Schnittstelle herzustellen: mithilfe von explizitem SSL über Port 587 oder mithilfe von implizitem SSL über Port 465.

**So stellen Sie eine Verbindung mit der SMTP-Schnittstelle über explizites SSL her:**
+ Geben Sie an der Befehlszeile den folgenden Befehl ein, um eine Verbindung mit dem Amazon SES-SMTP-Server herzustellen:

  ```
  openssl s_client -crlf -quiet -starttls smtp -connect email-smtp.us-west-2.amazonaws.com:587
  ```

  Ersetzen Sie im vorherigen Befehl *email-smtp.us-west-2.amazonaws.com* durch die URL des Amazon SES SES-SMTP-Endpunkts für Ihre AWS Region. Weitere Informationen finden Sie unter [Regionen und Amazon SES](regions.md).

  Wenn die Verbindung erfolgreich hergestellt wurde, sehen Sie in etwa die folgende Ausgabe:

  ```
  depth=2 C = US, O = Amazon, CN = Amazon Root CA 1
  verify return:1
  depth=1 C = US, O = Amazon, OU = Server CA 1B, CN = Amazon
  verify return:1
  depth=0 CN = email-smtp.us-west-2.amazonaws.com
  verify return:1
  250 Ok
  ```

  Die Verbindung wird nach ca. 10 Sekunden Inaktivität automatisch geschlossen.

Alternativ können Sie implizites SSL verwenden, um über Port 465 eine Verbindung mit der SMTP-Schnittstelle herzustellen.

**So stellen Sie eine Verbindung mit der SMTP-Schnittstelle über implizites SSL her:**
+ Geben Sie an der Befehlszeile den folgenden Befehl ein, um eine Verbindung mit dem Amazon SES-SMTP-Server herzustellen:

  ```
  openssl s_client -crlf -quiet -connect email-smtp.us-west-2.amazonaws.com:465
  ```

  Ersetzen Sie im vorherigen Befehl *email-smtp.us-west-2.amazonaws.com* durch die URL des Amazon SES SES-SMTP-Endpunkts für Ihre AWS Region. Weitere Informationen finden Sie unter [Regionen und Amazon SES](regions.md).

  Wenn die Verbindung erfolgreich hergestellt wurde, sehen Sie in etwa die folgende Ausgabe:

  ```
  depth=2 C = US, O = Amazon, CN = Amazon Root CA 1
  verify return:1
  depth=1 C = US, O = Amazon, OU = Server CA 1B, CN = Amazon
  verify return:1
  depth=0 CN = email-smtp.us-west-2.amazonaws.com
  verify return:1
  220 email-smtp.amazonaws.com ESMTP SimpleEmailService-d-VCSHDP1YZ A1b2C3d4E5f6G7h8I9j0
  ```

  Die Verbindung wird nach ca. 10 Sekunden Inaktivität automatisch geschlossen.

------
#### [ PowerShell ]

Sie können das [NetConnectionTest-Cmdlet](https://docs.microsoft.com/en-us/powershell/module/nettcpip/test-netconnection) in verwenden, PowerShell um eine Verbindung zum Amazon SES SMTP-Server herzustellen.

**Anmerkung**  
Das `Test-NetConnection`-Cmdlet kann bestimmen, ob der Computer eine Verbindung zum Amazon-SES-SMTP-Endpunkt herstellen kann. Es wird jedoch nicht getestet, ob Ihr Computer eine implizite oder explizite SSL-Verbindung zum SMTP-Endpunkt herstellen kann. Um eine SSL-Verbindung zu testen, können Sie entweder OpenSSL für Windows installieren oder eine Test-E-Mail-Nachricht senden.

**So stellen Sie eine Verbindung mit der SMTP-Schnittstelle über das `Test-NetConnection`-Cmdlet her:**
+ Geben Sie PowerShell unter den folgenden Befehl ein, um eine Verbindung zum Amazon SES SMTP-Server herzustellen:

  ```
  Test-NetConnection -Port 587 -ComputerName email-smtp.us-west-2.amazonaws.com
  ```

  Ersetzen Sie im vorherigen Befehl *email-smtp.us-west-2.amazonaws.com* durch die URL des Amazon SES SES-SMTP-Endpunkts für Ihre AWS Region und *587* ersetzen Sie ihn durch die Portnummer. Für weitere Informationen zu regionsspezifischen Endpunkten für Amazon SES sehen Sie [Regionen und Amazon SES](regions.md).

  Wenn die Verbindung erfolgreich war, sehen Sie eine Ausgabe, die dem folgenden Beispiel ähnelt:

  ```
  ComputerName     : email-smtp.us-west-2.amazonaws.com
  RemoteAddress    : 198.51.100.126
  RemotePort       : 587
  InterfaceAlias   : Ethernet
  SourceAddress    : 203.0.113.46
  TcpTestSucceeded : True
  ```

------

## Verwenden der Befehlszeile zum Senden von E-Mails mithilfe der Amazon-SES-SMTP-Schnittstelle
<a name="send-email-using-openssl"></a>

Sie können auch die Befehlszeile verwenden, um Nachrichten mithilfe der Amazon-SES-SMTP-Schnittstelle zu senden. Dieses Verfahren ist nützlich, um SMTP-Anmeldeinformationen zu testen und zu überprüfen, ob bestimmte Empfänger Nachrichten empfangen können, die Sie mithilfe von Amazon SES senden.

------
#### [ Linux, macOS, or Unix ]

Wenn ein E-Mail-Absender eine Verbindung zu einem SMTP-Server herstellt, gibt der Client einen Standardsatz von Anfragen aus und der Server beantwortet jede Anfrage mit einer Standardantwort. Diese Reihe von Anfragen und Antworten wird als eine *SMTP-Aushandlung* bezeichnet. Wenn Sie eine Verbindung mit dem Amazon SES SMTP-Server mithilfe von OpenSSL aufbauen, erwartet der Server eine SMTP-Aushandlung.

Wenn Sie OpenSSL verwenden, um eine Verbindung mit der SMTP-Schnittstelle herzustellen, müssen Sie Ihre SMTP-Anmeldeinformationen mit base64-Kodierung kodieren. Dieser Abschnitt enthält Verfahren zum Kodieren Ihrer Anmeldeinformationen mit base64.

**So senden Sie eine E-Mail über die Befehlszeile mittels der SMTP-Schnittstelle**

1. Geben Sie in der Befehlszeile Folgendes ein und *email-smtp.us-west-2.amazonaws.com* ersetzen Sie es durch die URL des Amazon SES SMTP-Endpunkts für Ihren AWS-Region. Weitere Informationen finden Sie unter[Regionen und Amazon SES](regions.md). :

   ```
    1. #!/bin/bash
    2. 
    3. # Prompt user to provide following information
    4. read -p "Configuration set: " CONFIGSET
    5. read -p "Enter SMTP username: " SMTPUsername
    6. read -p "Enter SMTP password: " SMTPPassword
    7. read -p "Sender email address: " MAILFROM
    8. read -p "Receiver email address: " RCPT
    9. read -p "Email subject: " SUBJECT
   10. read -p "Message to send: " DATA
   11. 
   12. echo
   13. 
   14. # Encode SMTP username and password using base64
   15. EncodedSMTPUsername=$(echo -n "$SMTPUsername" | openssl enc -base64)
   16. EncodedSMTPPassword=$(echo -n "$SMTPPassword" | openssl enc -base64)
   17. 
   18. # Construct the email
   19. Email="EHLO example.com
   20. AUTH LOGIN
   21. $EncodedSMTPUsername
   22. $EncodedSMTPPassword
   23. MAIL FROM: $MAILFROM
   24. RCPT TO: $RCPT
   25. DATA
   26. X-SES-CONFIGURATION-SET: $CONFIGSET
   27. From: $MAILFROM
   28. To: $RCPT
   29. Subject: $SUBJECT
   30. 
   31. $DATA
   32. .
   33. QUIT"
   34. 
   35. echo "$Email" | openssl s_client -crlf -quiet -starttls smtp -connect email-smtp.us-west-2.amazonaws.com:587
   ```

1. Geben Sie an der Eingabeaufforderung für jede Variable Ihre Werte ein.

1. 
   + Um mit implizitem SSL über Port 465 zu senden, verwenden Sie:

     ```
     openssl s_client -crlf -quiet -connect email-smtp.us-west-2.amazonaws.com:465
     ```

   Wenn die Nachricht von Amazon SES akzeptiert wurde, sehen Sie eine Ausgabe ähnlich dem folgenden Beispiel:

   ```
   250 Ok 01010160d7de98d8-21e57d9a-JZho-416c-bbe1-8ebaAexample-000000
   ```

   Die sich an `250 Ok` anschließende Abfolge von Zahlen und Text, ist die Nachrichten-ID der E-Mail.
**Anmerkung**  
Die Verbindung wird nach ca. 10 Sekunden Inaktivität automatisch geschlossen.

------
#### [ PowerShell ]

Sie können [Net.Mail verwenden. SmtpClient](https://docs.microsoft.com/en-us/dotnet/api/system.net.mail.smtpclient?view=netframework-4.8)Klasse zum Senden von E-Mails mit explizitem SSL über Port 587.

**Anmerkung**  
Die `Net.Mail.SmtpClient`-Klasse ist offiziell veraltet, und Microsoft empfiehlt, dass Sie Bibliotheken von Drittanbietern verwenden. Dieser Code ist nur für Testzwecke gedacht und sollte nicht für Produktionsarbeitslasten verwendet werden.

**Um eine E-Mail PowerShell mit explizitem SSL zu senden**

1. Erstellen Sie in einem Texteditor eine neue Datei. Fügen Sie folgenden Code in die Datei ein:

   ```
   function SendEmail($Server, $Port, $Sender, $Recipient, $Subject, $Body) {
       $Credentials = [Net.NetworkCredential](Get-Credential)
   
       $SMTPClient = New-Object Net.Mail.SmtpClient($Server, $Port)
       $SMTPClient.EnableSsl = $true
       $SMTPClient.Credentials = New-Object System.Net.NetworkCredential($Credentials.Username, $Credentials.Password);
   
       try {
           Write-Output "Sending message..."
           $SMTPClient.Send($Sender, $Recipient, $Subject, $Body)
           Write-Output "Message successfully sent to $($Recipient)"
       } catch [System.Exception] {
           Write-Output "An error occurred:"
           Write-Error $_
       }
   }
   
   function SendTestEmail(){
       $Server = "email-smtp.us-west-2.amazonaws.com"
       $Port = 587
   
       $Subject = "Test email sent from Amazon SES"
       $Body = "This message was sent from Amazon SES using PowerShell (explicit SSL, port 587)."
   
       $Sender = "sender@example.com"
       $Recipient = "recipient@example.com"
   
       SendEmail $Server $Port $Sender $Recipient $Subject $Body
   }
   
   SendTestEmail
   ```

   Wenn Sie fertig sind, speichern Sie die Datei unter `SendEmail.ps1`.

1. Nehmen Sie die folgenden Änderungen an der im vorherigen Schritt erstellten Datei vor:
   + *sender@example.com*Ersetzen Sie es durch die E-Mail-Adresse, von der Sie die Nachricht senden möchten.
   + *recipient@example.com*Ersetzen Sie es durch die E-Mail-Adresse, an die Sie die Nachricht senden möchten.
   + *email-smtp.us-west-2.amazonaws.com*Ersetzen Sie durch die URL des Amazon SES SMTP-Endpunkts für Ihre AWS Region. Weitere Informationen finden Sie unter [Regionen und Amazon SES](regions.md).

1. Geben Sie in PowerShell den folgenden Befehl ein:

   ```
   .\path\to\SendEmail.ps1
   ```

   Ersetzen Sie es im vorherigen Befehl *path\$1to\$1SendEmail.ps1* durch den Pfad zu der Datei, die Sie in Schritt 1 erstellt haben.

1. Wenn Sie dazu aufgefordert werden, geben Sie Ihren SMTP-Benutzernamen und Ihr Passwort ein.

Alternativ können Sie das [System.Web.Mail verwenden. SmtpMail](https://docs.microsoft.com/en-us/dotnet/api/system.web.mail.smtpmail?view=netframework-4.8)Klasse zum Senden von E-Mails mit implizitem SSL über Port 465.

**Anmerkung**  
Die `System.Web.Mail.SmtpMail`-Klasse ist offiziell veraltet, und Microsoft empfiehlt, dass Sie Bibliotheken von Drittanbietern verwenden. Dieser Code ist nur für Testzwecke gedacht und sollte nicht für Produktionsarbeitslasten verwendet werden.

**Um eine E-Mail PowerShell mit implizitem SSL zu senden**

1. Erstellen Sie in einem Texteditor eine neue Datei. Fügen Sie folgenden Code in die Datei ein:

   ```
   [System.Reflection.Assembly]::LoadWithPartialName("System.Web") > $null
   
   function SendEmail($Server, $Port, $Sender, $Recipient, $Subject, $Body) {
       $Credentials = [Net.NetworkCredential](Get-Credential)
   
       $mail = New-Object System.Web.Mail.MailMessage
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpserver", $Server)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpserverport", $Port)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpusessl", $true)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername", $Credentials.UserName)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword", $Credentials.Password)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpconnectiontimeout", $timeout / 1000)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusing", 2)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate", 1)
   
       $mail.From = $Sender
       $mail.To = $Recipient
       $mail.Subject = $Subject
       $mail.Body = $Body
   
       try {
           Write-Output "Sending message..."
           [System.Web.Mail.SmtpMail]::Send($mail)
           Write-Output "Message successfully sent to $($Recipient)"
       } catch [System.Exception] {
           Write-Output "An error occurred:"
           Write-Error $_
       }
   }
   
   function SendTestEmail(){
       $Server = "email-smtp.us-west-2.amazonaws.com"
       $Port = 465
       
       $Subject = "Test email sent from Amazon SES"
       $Body = "This message was sent from Amazon SES using PowerShell (implicit SSL, port 465)."
   
       $Sender = "sender@example.com"
       $Recipient = "recipient@example.com"
   
       SendEmail $Server $Port $Sender $Recipient $Subject $Body
   }
   
   SendTestEmail
   ```

   Wenn Sie fertig sind, speichern Sie die Datei unter `SendEmail.ps1`.

1. Nehmen Sie die folgenden Änderungen an der im vorherigen Schritt erstellten Datei vor:
   + *sender@example.com*Ersetzen Sie es durch die E-Mail-Adresse, von der Sie die Nachricht senden möchten.
   + *recipient@example.com*Ersetzen Sie es durch die E-Mail-Adresse, an die Sie die Nachricht senden möchten.
   + *email-smtp.us-west-2.amazonaws.com*Ersetzen Sie durch die URL des Amazon SES SMTP-Endpunkts für Ihre AWS Region. Weitere Informationen finden Sie unter [Regionen und Amazon SES](regions.md).

1. Geben Sie in PowerShell den folgenden Befehl ein:

   ```
   .\path\to\SendEmail.ps1
   ```

   Ersetzen Sie es im vorherigen Befehl *path\$1to\$1SendEmail.ps1* durch den Pfad zu der Datei, die Sie in Schritt 1 erstellt haben.

1. Wenn Sie dazu aufgefordert werden, geben Sie Ihren SMTP-Benutzernamen und Ihr Passwort ein.

------