Golang Envoyer un e-mail

Le protocole SMTP est l'un des éléments constitutifs d'Internet moderne. Le protocole agit comme la norme pour les transmissions par e-mail. Il comprend un serveur de messagerie et un client de messagerie pour faciliter le transfert des e-mails.

Dans ce guide, nous discuterons de la façon dont vous pouvez envoyer des e-mails à l'aide du package SMTP dans Go. Pour les tests, nous utiliserons un serveur SMTP hébergé localement à l'aide de MailSlurper.

Golang smtp

Le package SMTP est un sous-package du package Golang Net. Il met en œuvre des fonctionnalités de haut niveau pour travailler avec le protocole SMTP.

Apprenons à envoyer un e-mail à l'aide du package SMTP.

Le package SMTP fournit une méthode Sendmail () qui vous permet d'envoyer un e-mail à l'adresse spécifiée.

La syntaxe de fonction est comme indiqué:

Func Sendmail (Addr String, Auth, de String, à [] String, MSG [] BYTE)

La fonction accepte l'adresse du serveur SMTP en tant que chaîne, un mécanisme d'authentification, l'adresse e-mail à envoyer, l'adresse e-mail à envoyer et l'e-mail comme paramètres.

Le message e-mail doit commencer par l'en-tête, une ligne vierge et le corps e-mail. Vous devez mettre fin à chaque ligne du message avec des caractères CRLF, permettant la conformité avec le style de messagerie RFC 822.

Le code suivant affiche un exemple simple d'utilisation de la fonction SendMail pour envoyer un e-mail.

package principal
importer (
"FMT"
"enregistrer"
"net / smtp"
)
const (
Username = "Linuxhint"
Passwd = "mot de passe"
Host = "localhost"
)
func main ()
De: = "Dev @ test.io "
à: = [] String
"Dev.mail @ mailsLuper.com ",

MSG: = [] BYTE ("De: Dev @ Testing.io \ r \ n " +
"À: Dev.mail @ mailslurper.com " +
"Sujet: Golang Testing Mail \ r \ n" +
"Body e-mail: bienvenue à partir!\ r \ n ")
auth: = smtp.PlainAuth ("", nom d'utilisateur, passwd, hôte)
err: = smtp.Sendmail (hôte + ": 25", auth, de, à, msg)
Si err != nil
enregistrer.Fatal (euh)

fmt.Println ("Mail envoyé avec succès!")

Dans l'exemple ci-dessus, nous commençons par importer les packages requis. Nous spécifions ensuite les variables requises. Dans notre exemple, nous définissons le nom d'utilisateur, le mot de passe et l'hôte.

Dans la fonction principale, nous définissons l'expéditeur de l'e-mail et du récepteur en utilisant les variables From and To, respectivement.

Vient ensuite le corps de messagerie, nous utilisons le style RFC 822 pour construire le message. Notez que chaque ligne est séparée avec des caractères CRLF.

Ensuite, nous construisons l'authentification en utilisant la méthode PlainAuth. La fonction prend l'identité, le nom d'utilisateur, le mot de passe et l'hôte et englobe un mécanisme d'authentification simple avec le serveur. La fonction revient ensuite à un objet Auth.

Enfin, nous envoyons l'e-mail à l'aide de la fonction Sendmail passant l'adresse, l'objet AUTH, l'expéditeur, le destinataire et le message comme arguments.

Méthode d'authentification MailSlurper

Si vous exécutez le code ci-dessus sur MailSlurper, le serveur renvoie une erreur comme ci-dessous et fermera la connexion.

$ go exécuter des e-mails.aller
2022/02/02 02:52:39 SMTP: le serveur ne prend pas en charge l'authentique
Statut de sortie 1

Vous pouvez résoudre ceci en utilisant une fonction Sendmail personnalisée. Un exemple de code est comme indiqué ci-dessous:

package principal
importer (
"Encodage / base64"
"FMT"
"enregistrer"
"net / smtp"
"Strings"
)
const (
Username = "Linuxhint"
Passwd = "mot de passe"
Host = "localhost"
)
func main ()
De: = "Dev @ test.io "
à: = [] String
"Dev.mail @ mailsLuper.com ",

MSG: = [] BYTE ("Courrier Courrier: Bienvenue à partir!\ r \ n ")
err: = sendmail (hôte + ": 2500", de "Golang Testing Email", String (msg), to)
Si err != nil
enregistrer.Fatal (euh)

fmt.Println ("Mail envoyé avec succès!")

func sendmail (addr, from, sujet, body string, to [] String) error
R: = chaînes.NewReplacer ("\ r \ n", "", "\ r", "", "\ n", "", "% 0a", "", "% 0d", "")
c, err: = smtp.Dial (addr)
Si err != nil
retourner err

différer C.Fermer()
Si err = c.Courrier (r.Remplacer (de)); se tromper != nil
retourner err

pour i: = plage à
à [i] = r.Remplacer (à [i])
Si err = c.Rcpt (à [i]); se tromper != nil
retourner err


w, err: = c.Données()
Si err != nil
retourner err

msg: = "à:" + chaînes.Rejoindre (à, ",") + "\ r \ n" +
"De:" + de + "\ r \ n" +
"Sujet:" + Sujet + "\ r \ n" +
"Content-Type: Text / Html; charSet =" UTF-8 "\ r \ n" +
"Contenu-transfert-codage: base64 \ r \ n" +
"\ r \ n" + base64.Stdencoding.Encodétostring ([] octet (corps))
_, err = w.Écrire ([] octet (msg))
Si err != nil
retourner err

err = w.Fermer()
Si err != nil
retourner err

retour c.Arrêter()

Golang Send Mail - Copie carbone

Vous pouvez également envoyer des e-mails à plusieurs utilisateurs à l'aide de copie carbone et de copie carbone aveugle. Les destinataires CC seront visibles à tous.

Nous pouvons le faire en utilisant le code comme ci-dessous:

package principal
importer (
"FMT"
"enregistrer"
"net / smtp"
"Strings"
)
Type Mail Struct
Chaîne d'expéditeur
À [] chaîne
CC [] chaîne
BCC [] chaîne
Strime de sujet
Corde de carrosserie

func main ()
expéditeur: = "dev @ courrier.pour"
à: = [] String
"Bonjour @ Exemple.com ",
"info @ mail.io ",
"Plus @ mail.la télé",

cc: = [] String
"CC @ moi.com ",
"Un autre @ assistant.dev ",

Nom d'utilisateur: = "Linuxhint"
passwd: = "mot de passe"
hôte: = "localhost"
Sujet: = "Test de courrier de Golang"
Corps: = "Message Body"
req: = mail
Expéditeur: expéditeur,
À:,
CC: CC,
Sujet: Sujet,
Corps corps,

MSG: = Composemsg (req)
auth: = smtp.PlainAuth ("", nom d'utilisateur, passwd, hôte)
err: = smtp.Sendmail (hôte + ": 2500", auth, expéditeur, à, [] octet (msg))
Si err != nil
enregistrer.Fatal (euh)

fmt.Println ("Message envoyé avec succès!")

// construire un message basé sur le CC
Func Composemsg (courrier électronique) String
// chaîne vide
msg: = ""
// Définit l'expéditeur
msg + = fmt.Sprintf ("de:% s \ r \ n", courrier.Expéditeur)
// Si plus d'un destinataire
Si Len (courrier.À)> 0
msg + = fmt.Sprintf ("cc:% s \ r \ n", cordes.Rejoindre (courrier.Cc, ";"))

// Ajouter un sujet
msg + = fmt.Sprintf ("Sujet:% s \ r \ n", courrier.Sujet)
// Ajouter un corps de courrier
msg + = fmt.Sprintf ("corps:% s \ r \ n", courrier.Corps)
Retour MSG

Le code ci-dessus enverra les e-mails aux destinataires spécifiés à l'aide du protocole SMTP.

Fermeture

Dans ce guide, nous avons exploré les bases de l'utilisation du package SMTP dans Go pour envoyer des e-mails à un ou plusieurs utilisateurs. Vérifiez la documentation pour en savoir plus.