IT & Engineering
E-Mail-Versand mit Python3 und der Mailgun-API
Wenn Sie Ihren programmatischen E-Mail-Versand effizienter gestalten möchten, sind Sie hier genau richtig. Unser Entwicklungsteam verfügt über die nötige Erfahrung, um Ihnen den Einstieg zu erleichtern. Lesen Sie weiter und erfahren Sie mehr über die Integration von Python3 in die leistungsstarke E-Mail-API von Mailgun – mit zahlreichen Einblicken, Anleitungen und Tipps zur Optimierung.
Erste Schritte: Was Sie für dieses Tutorial benötigen
Beim E-Mail-Versand haben Sie zwei Möglichkeiten: manuell oder programmatisch. Wenn es um Transaktions-E-Mails geht, ist der programmatische Ansatz die beste Wahl. Anstatt wichtige E-Mail-Updates oder Benachrichtigungen manuell zu versenden, können Sie mit automatisierten E-Mail-Skripten Zeit sparen und Fehler reduzieren.
Skripte – kleine Programme zur Automatisierung von Aufgaben – bieten eine effizientere Methode, um Massen-E-Mails zu versenden, Nachrichten zu planen oder direkt aus Ihrer Anwendung aufgerufen zu werden. Zu den typischen Anwendungsfällen für den E-Mail-Versand über automatisierte Skripte gehören:
- Versand von Willkommens-E-Mails bei der Registrierung
- Versand von Benachrichtigungen und Warnungen aus Anwendungen, beispielsweise um Personen über ihre Dienstnutzung zu informieren oder das Admin-Team bei knappen Serverressourcen zu warnen
- Versand von Berichten, etwa ein wöchentlicher Bericht über neue Kundschaft
- Versand von Marketingkampagnen – beispielsweise zur Bewerbung neuer Produkte oder Dienstleistungen
In diesem Tutorial erfahren Sie, wie Sie E-Mails mit Python3-Skripten und der Mailgun-API versenden.
Voraussetzungen
Um dieses Tutorial zu Python3 und der E-Mail-API nachzuvollziehen, benötigen Sie Folgendes:
- Python 3.9 oder höher. Python wird oft als das Schweizer Taschenmesser unter den Programmiersprachen bezeichnet und bietet vielfältige Möglichkeiten. Neben vielen anderen Einsatzmöglichkeiten eignet sich Python hervorragend zum Schreiben verschiedenster Skripte.
- Ein Mailgun-Konto. Mailgun ist eine E-Mail-Versandplattform, mit der Sie E-Mails versenden und nachverfolgen können. Wenn Sie Mailgun noch nicht nutzen, können Sie diesem Tutorial mit unserer kostenlosen Testversion.
Einrichten eines neuen Python-Projekts
Gehen wir ins Detail.
Erstellen Sie zunächst ein passendes Verzeichnis für Ihr Python-Projekt und fügen Sie dort eine leere .env-Datei hinzu. Bevor Sie fortfahren, sollten Sie eine neue virtuelle Umgebung erstellen und aktivieren, bevor Sie die für dieses Tutorial benötigten Python-Bibliotheken installieren. Dadurch wird Ihr Projekt isoliert, was Konflikte bei den Abhängigkeiten verhindert.
Um die benötigten Bibliotheken (requests und python-dotenv) über pip in Ihrer virtuellen Umgebung zu installieren, führen Sie den folgenden Befehl aus:
pip install requests python-dotenv
Mit der requests-Bibliothek können Sie API-Aufrufe tätigen, während die python-dotenv-Bibliothek es Ihnen ermöglicht, den API-Schlüssel außerhalb Ihres Codes zu speichern.
Einen API-Schlüssel bei Mailgun abrufen
Als Nächstes rufen Sie einen API-Schlüssel aus Ihrem Mailgun-Konto ab, den Sie für API-Aufrufe an Mailgun verwenden.
Melden Sie sich in Ihrem Mailgun-Konto an und erstellen Sie einen API-Schlüssel auf der Seite „API Security“, die Sie über ein Dropdown-Menü unter Ihrem Namen in der oberen rechten Ecke erreichen.
Kopieren Sie diesen API-Schlüssel und fügen Sie ihn in die .env-Datei Ihres Projekts ein.
MAILGUN_API_KEY=“Ihr API-Schlüssel hier“
Wenn Sie schon in Mailgun sind, notieren Sie sich auch Ihre Absenderdomains aus dem Mailgun-Dashboard.
Wenn Sie ein kostenloses Abonnement nutzen, sehen Sie eine Sandbox-Domain, die beim Versand von E-Mails über die Mailgun-API sowohl für den API-Endpunkt als auch für die Absender-E-Mail-Adresse verwendet wird. Die Sandbox-Domain hat das Format .mailgun.org, wie unten dargestellt.
Sie müssen ein Upgrade auf ein kostenpflichtiges Abonnement vornehmen, wenn Sie eine benutzerdefinierte E-Mail-Domain für den Versand von E-Mails über Mailgun verwenden möchten. Das kostenlose Abonnement erlaubt nur die Sandbox-Domain, und Sie können E-Mails an maximal fünf verifizierte Adressen versenden. Dieses kostenlose Abonnement ist jedoch während der Entwicklungsphase nützlich, wenn Sie die Mailgun-API in Ihr System integrieren.
Importe und Initialisierung
Erstellen Sie als Nächstes die Datei main.py in Ihrem Projektverzeichnis und kopieren Sie diesen Code hinein:
```python import jsonrnimport requestsrnimport loggingrnrnimport osrnfrom dotenv import load_dotenvrnrnlogging.basicConfig(level=logging.INFO) # set log levelrnload_dotenv() # for reading API key from `.env` file.rnrn# Sandbox API URL format: https://api.mailgun.net/v3/sandbox<ID>.mailgun.org/messagesrnMAILGUN_API_URL = "https://api.mailgun.net/v3/YOUR_DOMAIN_NAME/messages"rnFROM_EMAIL_ADDRESS = "Sender Name <SENDER_EMAIL_ID>"
Dieser verwendet das Standard-Logging von Python und konfiguriert es mit diesem Code auf das INFO-Level:
```pythonrnlogging.basicConfig(level=logging.INFO)rn```
Die Funktion load_dotenv() stammt aus der Bibliothek python-dotenv und dient dazu, Umgebungsvariablen aus der .env-Datei in Ihren Python-Code zu laden. Es gehört zu den Best Practices, vertrauliche Informationen wie Zugangsdaten und API-Schlüssel in der .env-Datei zu speichern und von dort auszulesen.
MAILGUN_API_URL legt die API-URL für Ihr Python-Skript fest und gibt die E-Mail-ID des Absenders an. Beide müssen Ihre E-Mail-Absenderdomain oder die zuvor erwähnte Sandbox-Domain verwenden.
Einzelne E-Mails versenden mit der Mailgun-API
Betrachten wir zunächst die einfachste Art, die Mailgun-API zu nutzen: den Versand einer einzelnen E-Mail. Dies bietet sich für einmalige Fälle an, beispielsweise für eine Erinnerung oder eine Follow-up-E-Mail an wichtige Kontakte. So können Sie zudem die E-Mail-Zustellung nachverfolgen.
Fügen Sie den folgenden Code nach den Importen und der Initialisierung in Ihre Datei main.py ein:
```pythonrndef send_single_email(to_address: str, subject: str, message: str):rn try:rn api_key = os.getenv("MAILGUN_API_KEY") # get API-Key from the `.env` filernrn resp = requests.post(MAILGUN_API_URL, auth=("api", api_key),rn data={"from": FROM_EMAIL_ADDRESS,rn "to": to_address, "subject": subject, "text": message})rn if resp.status_code == 200: # successrn logging.info(f"Successfully sent an email to '{to_address}' via Mailgun API.")rn else: # errorrn logging.error(f"Could not send the email, reason: {resp.text}")rnrn except Exception as ex:rn logging.exception(f"Mailgun error: {ex}")rnrnif __name__ == "__main__":rn send_single_email("Manish <manish@exanple.com>", "Single email test", "Testing Mailgun API for a single email")rn```
Diese Funktion send_single_email(…) akzeptiert drei Argumente: to_address, subject und message. to_address steht für eine einzelne E-Mail-Adresse, und die beiden anderen stehen für den Betreff und den Inhalt der E-Mail.
Der Code liest den Mailgun-API-Schlüssel aus der .env-Datei aus und nutzt ihn für einen API-Aufruf, wobei eine sichere Verbindung zur angegebenen API_URL hergestellt wird. Dieser API-Schlüssel fungiert als eindeutige Kennung, mit der Mailgun den API-Aufruf authentifizieren und verifizieren kann, wer die Dienste nutzt.
Sie müssen Ihren eindeutigen API-Schlüssel verwenden, um eine korrekte Authentifizierung zu gewährleisten. Die in diesem API-Aufruf verwendete Absender-E-Mail-Adresse muss ebenfalls mit Ihrer gültigen Domain oder der Sandbox-Domain von Mailgun verknüpft sein. Ist dies nicht der Fall, schlägt der Aufruf mit einer Fehlermeldung fehl.
Die Datenparameter werden über die HTTP-POST-Methode mit dem Aufruf requests.post(…) an den API-Endpunkt gesendet.
Ist der API-Aufruf erfolgreich, wird Ihre E-Mail zur Zustellung in die Warteschlange eingereiht und die API gibt den Status HTTP-200 (OK) zurück. Im Fehlerfall gibt die API eine Fehlermeldung mit einem entsprechenden HTTP-Statuscode zurück. Beide Fälle werden von diesem Code-Snippet entsprechend protokolliert.
if __name__ == „__main__“ zeigt, wie diese Funktion in Ihrem Skript aufgerufen werden kann.
Wenn Sie dieses Skript in Ihrem Terminal ausführen, wird Folgendes angezeigt:
Massen-E-Mails versenden mit der Mailgun-API
Zwar können Sie die Funktion send_single_email(…) in einer Schleife verwenden, um E-Mails an mehrere Empfangsadressen zu versenden, doch aufgrund von Netzwerk-I/O-Verzögerungen ist dies nicht die effizienteste Methode. Dieser Ansatz kann zudem zu einer API-Ratenbegrenzung führen.
Verwenden Sie stattdessen den Batch-Versand für den Versand von E-Mails an mehrere Empfangsadressen. Das folgende Code-Snippet veranschaulicht den Einsatz in Ihrem Python-Skript.
Fügen Sie die Funktion send_batch_emails(…) nach der Funktion send_single_email(…) in Ihre Datei main.py ein und passen Sie den Teil __main__ wie unten gezeigt an:
```pythonrndef send_batch_emails(recipients: dict, subject: str, message: str):rn try:rn api_key = os.getenv("MAILGUN_API_KEY") # get API-Key from the `.env` filernrn to_address = list(recipients.keys()) # get only email addressesrn recipients_json = json.dumps(recipients) # for API callrnrn logging.info(f"Sending email to {len(to_address)} IDs...")rn resp = requests.post(MAILGUN_API_URL, auth=("api", api_key),rn data={"from": FROM_EMAIL_ADDRESS,rn "to": to_address, "subject": subject, "text": message,rn "recipient-variables": recipients_json})rn if resp.status_code == 200: # successrn logging.info(f"Successfully sent email to {len(recipients)} recipients via Mailgun API.")rn else: # errorrn logging.error(f"Could not send emails, reason: {resp.text}")rn except Exception as ex:rn logging.exception(f"Mailgun error: {ex}")rnrnif __name__ == "__main__":rn # send_single_email("Manish <manish@exanple.com>", "Single email test", "Testing Mailgun API for a single email")rn _recipients = {"manish@example.com": {"name": "Manish", "id": 1},rn "jakkie@example.com": {"name": "Jakkie", "id": 2},rn "elzet@example.com": {"name": "Elzet", "id": 3}}rnrn send_batch_emails(_recipients, "Hi, %recipient.name%!", "Testing Mailgun API. This email is sent via Mailgun API.")rn```
Wie versende ich mehrere personalisierte E-Mails?
Beim Batch-Versand kommt ein spezieller Parameter namens Empfängervariablen (Recipient Variables) zum Einsatz, mit dem Sie über einen einzigen API-Aufruf personalisierte E-Mails an mehrere Adressen versenden können. Die Verwendung von Empfängervariablen beim Batch-Versand stellt sicher, dass Mailgun individuelle E-Mails an alle Adressen im An-Feld sendet. Ohne diese Variablen würden alle Kontakte die E-Mail-Adressen aller anderen im An-Feld sehen.
Hier ist eine solche Empfängervariable, bei der E-Mail-Adressen als Schlüssel (Keys) und die entsprechenden Attribute „name“ und „id“ als Werte (Values) dienen:
{„manish@example.com“: {„name“: „Manish“, „id“: 1},
„jakkie@example.com“: {„name“: „Jakkie“, „id“: 2},
„elzet@example.com“: {„name“: „Elzet“, „id“: 3}}
Die Funktion send_batch_emails(…) hat drei Parameter: recipients, subject und message. Beachten Sie, dass recipients ein Dictionary-Objekt ist, welches die oben besprochene Empfängervariable repräsentiert.
Der Code extrahiert zunächst die E-Mail-Adressen aus diesem Dictionary mittels to_address = list(recipients.keys()) und konvertiert das Dictionary dann mit dem Aufruf recipients_json = json.dumps(recipients) in JSON für die API-Nutzung.
Die Variable recipients_json wird im API-Aufruf für das Feld recipient-variables übergeben, das zur Personalisierung von Betreff und Inhalt der E-Mail dient. Der Betreff wird wie folgt angegeben:
„Hallo %recipient.name%!“
Die Mailgun-API ersetzt %recipient.name% beim Versand der E-Mails korrekt durch den Namen der jeweiligen Person aus dem JSON. Im obigen Beispiel erhalten Manish, Jakkie und Elzet also personalisierte Betreffzeilen – „Hallo Manish!“ „Hallo Jakkie!“ und „Hallo Elzet!“. Auf ähnliche Weise können Sie den Inhalt der E-Mail mit einem beliebigen %recipient.KEY-NAME%-Wert personalisieren.
Der restliche Code von send_batch_emails(…) ähnelt der Funktion send_single_email(…), mit dem Unterschied, dass E-Mails in einem einzigen API-Aufruf an mehrere Empfangsadressen gesendet werden.
Wenn Sie dieses Skript ausführen, wird Folgendes angezeigt:
Hier ist ein Beispiel dafür, wie diese E-Mail im Posteingang der empfangenden Person aussehen wird:
Zusätzliche Funktionen der E-Mail-API von Mailgun
Die Mailgun-API bietet einige zusätzliche Funktionen, die Ihnen die Arbeit erleichtern.
Versand von HTML-E-Mails mit Anhängen
Mit der Mailgun-API können Sie E-Mails mit Anhängen versenden, unabhängig davon, ob diese Text- oder HTML-Inhalte enthalten. Sie können denselben API-Endpunkt (https://api.mailgun.net/v3/YOUR_DOMAIN_NAME/messages) verwenden, wobei ein zusätzlicher ‚attachment‘ an den Parameter files übergeben wird, wie unten gezeigt:
```pythonrnfiles = {'attachment': open('weekly-report.csv', 'rb')} # file you want to attachrnresp = requests.post(MAILGUN_API_URL, auth=("api", api_key), files=files,rn data={"from": FROM_EMAIL_ADDRESS,rn "to": to_address, "subject": subject, "text": message})rn```
E-Mail-Zustellung und Tracking
Mailgun bietet ein detailliertes E-Mail-Tracking, das unter anderem erfasst, wann E-Mails zugestellt oder geöffnet werden, Links angeklickt werden, Bounces auftreten, Abmeldungen erfolgen oder E-Mails als Spam markiert werden. Diese Daten stehen über das Control Panel im Dashboard sowie über die API zur Verfügung.
Darüber hinaus speichert Mailgun E-Mails dauerhaft, wenn diese nicht zugestellt werden können (Hard Bounce), eine Abmeldung erfolgt oder die E-Mail als Spam markiert wird. In diesen Fällen versucht Mailgun nicht, erneut E-Mails an die betreffenden Kontakte zu senden.
E-Mail-Vorlagen
Die Mailgun-API ermöglicht es Ihnen, HTML-Vorlagen zu erstellen , um Ihr E-Mail-Layout zu standardisieren und die Nachrichten durch vorgefertigte Layouts und Standardinhalte ansprechender zu gestalten.
Vorlagen finden Sie in der linken Seitenleiste unter dem Menüpunkt „Sending“.
E-Mail-Tests
Mailgun bietet zudem Tools für E-Mail-Tests, um sicherzustellen, dass Ihre Nachrichten wie gewünscht aussehen und funktionieren. Mit Untersuchen, können Sie automatisch auf Probleme wie fehlerhafte Links, fehlende Bilder oder Spam-Trigger prüfen. In der E-Mail-Vorschau zeigt Ihnen, wie Ihre E-Mail auf verschiedenen Clients und Geräten dargestellt wird, während E-Mail-Barrierefreiheit Tests bestätigen, dass Ihre Inhalte den Standards für Barrierefreiheit entsprechen. Erfahren Sie mehr über die E-Mail-Testing-Software von Mailgun und integrieren Sie diese Prüfungen in Ihren Workflow, wenn Sie E-Mails über die API erstellen.
Alternative Python-Bibliotheken für E-Mails
Bevor Sie eine spezielle E-Mail-API nutzen, lohnt sich ein Blick auf die nativen Tools von Python für den E-Mail-Versand sowie auf einige leichtgewichtige Drittanbieter-Optionen.
Python umfasst zwei Kernmodule für SMTP-basierte E-Mails: smtplib und email.
smtplib
Das Modul smtplib verwaltet SMTP-Sitzungen und ermöglicht die Verbindung zu einem SMTP-Server über SMTP_SSL() für implizites TLS (in der Regel Port 465) oder SMTP() mit starttls() für opportunistisches TLS (meist Port 587). Die Authentifizierung erfolgt über einen Standard-Benutzernamen und ein Passwort.
Das Paket email ist für die Konstruktion der Nachricht zuständig. EmailMessage bietet eine moderne, hochrangige API, während MIMEText und MIMEMultipart Klartext, HTML und mehrteilige Nutzdaten (Multipart-Payloads) unterstützen.
Dieser Code erstellt eine einfache E-Mail und versendet sie sicher über einen SMTP-Server mit Python:
from email.message import EmailMessage
import smtplib
msg = EmailMessage()
msg["From"] = "you@example.com"
msg["To"] = "friend@example.com"
msg["Subject"] = "Hello"
msg.set_content("Sent with Python!")
with smtplib.SMTP("smtp.example.com", 587) as smtp:
smtp.starttls()
smtp.login("username", "password")
smtp.send_message(msg)
Yagmail
Verschiedene Drittanbieter-Bibliotheken reduzieren den Boilerplate-Code zusätzlich. Yagmail bietet eine auf Gmail fokussierte Abstraktion für den Versand von Nachrichten und Anhängen mit minimalem Konfigurationsaufwand. python-emails ergänzt höherwertige Funktionen wie das Rendering von Vorlagen, die strukturierte Erstellung von Nachrichten und das DKIM-Signieren.
Generell sollten Sie darauf verzichten, Zugangsdaten fest zu programmieren (Hardcoding). Verwenden Sie getpass() von Python für die sichere Eingabe von Passwörtern, speichern Sie API-Schlüssel in Umgebungsvariablen und übertragen Sie E-Mails stets über TLS-verschlüsselte Verbindungen.
Authentifizierung und Sicherheit
Es ist wichtig, einige Best Practices und Tipps zu beachten, wenn Sie E-Mails programmatisch versenden.
Fehlerbehandlung
Wenn Ihr Skript eine Drittanbieter-API wie Mailgun für den E-Mail-Versand nutzt, müssen Sie mögliche Fehler im Zusammenhang mit Netzwerk- oder API-Ausfällen sowie API-Antworten auf Fehler abfangen. So stellen Sie sicher, dass Ihr Skript reibungslos funktioniert, Probleme wie ungültige API-Schlüssel oder URLs erkennt und weiß, wann E-Mails nicht durch die Mailgun-API versendet wurden. Ohne Fehlerbehandlung könnte Ihr Skript unbemerkt fehlschlagen, was zu nicht zugestellten E-Mails führt.
Die obigen Code-Snippets berücksichtigen allesamt die Behandlung möglicher Fehler. Zunächst prüfen sie den Statuscode der Antwort (resp.status_code). Ist der Aufruf nicht erfolgreich (HTTP 200), protokollieren sie die Fehlermeldung, damit Sie das Problem beheben können.
Sowohl die Funktion send_single_email(…) als auch send_batch_emails(…) nutzen einen try-except-Block, um sicherzustellen, dass Ausnahmen korrekt abgefangen und protokolliert werden.
E-Mail-Zustellbarkeit
E-Mail-Zustellbarkeit bedeutet, sicherzustellen, dass Ihre E-Mails im Posteingang des Empfängers landen und nicht im Spam-Ordner. Für eine hohe Zustellbarkeit benötigen Sie eine gute Absenderreputation. Beim Aufbau eines programmatischen Versands gibt es einige spezifische Aspekte, die wir berücksichtigen können, um die E-Mail-Zustellbarkeit zu verbessern, darunter die Authentifizierung und die Optimierung von E-Mails für responsive Designs.
Authentifizieren Sie Ihre E-Mails
Verwenden Sie SPF, DKIM und DMARC, um Ihre Identität als Absender zu bestätigen. Senden Sie E-Mails nur an verifizierte Abonnenten, die dem Empfang zugestimmt haben, und entfernen Sie regelmäßig inaktive Kontakte sowie Personen, die Ihre E-Mails als Spam markieren.
DMARC wird zunehmend zu einer Branchenanforderung. Erfahren Sie in unserem Beitrag über die DMARC-Perspektive mehr über die Hintergründe und die Funktionsweise dieses Authentifizierungsstandards.
E-Mail-Versand mit Python3 und der E-Mail-API von Mailgun starten
In diesem Artikel haben Sie erfahren, wie Sie E-Mails mit einem Python-Skript und der Mailgun-API versenden. Außerdem haben Sie Mailgun-Funktionen wie E-Mail-Tracking und Vorlagen kennengelernt sowie die Bedeutung von Fehlerbehandlung, der Optimierung der Zustellbarkeit und dem Versand responsiver E-Mails verstanden.
E-Mail-Geeks helfen anderen E-Mail-Geeks. Den in diesem Tutorial behandelten Code finden Sie im diesem GitHub-Repo.
War das hilfreich? Wenn ja, sollten Sie unbedingt unseren Newsletter abonnieren, um weitere Tutorials, Ankündigungen und Branchen-Insights zu erhalten.
FAQs
Verwenden Sie TLS (STARTTLS) auf Port 587, wenn Sie ein Upgrade einer unverschlüsselten Verbindung auf eine verschlüsselte vornehmen möchten, und SSL (implizites TLS) auf Port 465, wenn die Verbindung von Beginn an verschlüsselt ist.
- TLS (STARTTLS): smtplib.SMTP(host, 587) → starttls() → login() → send_message()
- SSL (implizites TLS): smtplib.SMTP_SSL(host, 465) → login() → send_message()
In beiden Fällen konstruieren Sie die Nachricht (beispielsweise mit EmailMessage) und versenden sie mit smtp.send_message(msg). Authentifizieren Sie sich stets mit den SMTP-Zugangsdaten (Benutzername/Passwort), die Sie von Ihrem Anbieter erhalten.
- EmailMessage: moderne, hochrangige API. Die beste Standardwahl für die meisten Anwendungsfälle. Erleichtert das Setzen von Kopfzeilen, das Hinzufügen von Klartext und HTML-Alternativen (add_alternative()) sowie das Anhängen von Dateien mit weniger Boilerplate-Code.
- MIMEText: niedrigschwelligerer Baustein für einen einzelnen Textteil (Klartext oder HTML). Nützlich, wenn Sie die explizite Kontrolle über einen einzelnen Bestandteil des Textkörpers benötigen.
- MIMEMultipart: Container zur Kombination mehrerer MIME-Teile (Text + HTML + Anhänge). Häufig in älteren Beispielen zu finden; hier hängen Sie MIMEText-Teile und Dateien manuell an.
Wenn Sie ein neues Projekt beginnen, sollten Sie EmailMessage bevorzugen, es sei denn, Sie benötigen Kompatibilität mit älteren MIME-Erstellungsmustern.
Verwenden Sie Umgebungsvariablen für Zugangsdaten in bereitgestellten Apps (CI/CD, Container, Server) und getpass() für interaktive lokale Skripte.
Umgebungsvariablen halten Geheimnisse aus der Quellcodeverwaltung und aus Protokollen fern. Speichern Sie Werte wie SMTP-Benutzernamen/-Passwörter oder API-Schlüssel als SMTP_USER, SMTP_PASS, MAILGUN_API_KEY usw. und lesen Sie diese zur Laufzeit aus.
getpass.getpass() fragt sicher nach einem Passwort, ohne es im Terminal anzuzeigen – nützlich für schnelle Skripte oder lokale Tests.
Ein gängiges Muster ist: Lesen Sie zuerst aus der env-Datei und greifen Sie nur dann auf getpass() zurück, wenn keine Daten vorhanden sind.
Yagmail wurde speziell für Gmail-Workflows entwickelt, reduziert so den SMTP-Boilerplate-Code und vereinfacht häufige Gmail-Aufgaben.
Wesentliche Vorteile für Gmail-Nutzende:
- Weniger Code: minimaler Aufwand für den Versand von Nachrichten, HTML und Anhängen.
- Auf Gmail ausgerichtete Ergonomie: benutzerfreundlichere API zum Erstellen von Nachrichten und für den Umgang mit Anhängen.
- Schnellere Iteration: ideal für Skripte und interne Tools, bei denen der E-Mail-Versand einfach ablaufen soll, ohne MIME-Teile manuell verwalten zu müssen.
Wenn Sie ausschließlich über Gmail senden und weniger bewegliche Teile als bei der reinen smtplib- und MIME-Konstruktion wünschen, ist Yagmail oft der schnellste Weg.
Mit python-emails gehen Sie normalerweise wie folgt vor:
- Rendern Sie eine Vorlage (oft HTML + Text) mithilfe der Templating-Hilfen der Bibliothek (oder übergeben Sie vorab gerenderte Inhalte aus Ihrer eigenen Template-Engine).
- Fügen Sie vor dem Senden DKIM-Einstellungen über den privaten DKIM-Schlüssel und den Selektor Ihrer Domain hinzu.
In der Praxis bedeutet dies:
- ein E-Mail-Objekt (Betreff/Von/An) erstellen
- gerenderte HTML-/Textkörper (und optional Variablen für Vorlagen) bereitstellen
- das DKIM-Signieren konfigurieren mittels:
- einem Selektor (z. B. mailgun oder default)
- Ihrer Signaturdomain
- dem privaten DKIM-Schlüssel (sicher aus Umgebungsvariablen oder einem Secrets Manager geladen)
Halten Sie den privaten DKIM-Schlüssel in der Produktionsumgebung aus dem Quellcode fern (über Umgebungsvariablen oder gemountete Secret-Dateien) und validieren Sie das Signieren, indem Sie die Nachrichten-Kopfzeilen in einem Postfach prüfen, das die DKIM-Signatur und die Authentifizierungsergebnisse anzeigt.
