Tutorial
Invia email con Go
Invia email da Go con l’SDK emailit-go o con net/smtp, gestisci gli errori dell’API e verifica le firme dei webhook di Emailit in un handler net/http.
Questa guida mostra come inviare email da un servizio Go con l’SDK ufficiale emailit-go, come usare in alternativa net/smtp e come verificare i webhook in un handler net/http.
Prerequisiti
- Go 1.21 o versioni successive.
- Un dominio di invio verificato, ad esempio
acme.com. - Una chiave API. Basta una chiave di solo invio limitata al tuo dominio.
- Finché il workspace non ha l’accesso alla produzione, puoi inviare solo agli indirizzi email degli account dei membri del workspace.
Installa l’SDK
go get github.com/emailit/emailit-go/v2L’SDK dipende solo dalla libreria standard di Go.
Configura la chiave API
Passa la chiave al processo come variabile d’ambiente:
export EMAILIT_API_KEY=secret_••••••••••••••••••••••••••••••••Invia un’email
package main
import (
"log"
"os"
"github.com/emailit/emailit-go/v2"
)
func main() {
client := emailit.NewClient(os.Getenv("EMAILIT_API_KEY"))
email, err := client.Emails.Send(&emailit.SendEmailRequest{
From: "Acme <hello@acme.com>",
To: []string{"ada@example.com"},
Subject: "Your login code",
Text: "Your code is 482913. It expires in 10 minutes.",
Html: "<p>Your code is <strong>482913</strong>. It expires in 10 minutes.</p>",
})
if err != nil {
log.Fatal(err)
}
log.Println("sent", email.Id) // em_…
}Crea il client una sola volta e condividilo: si può riutilizzare in sicurezza tra le richieste. Per inviare un template salvato, imposta Template sul suo alias o sul suo ID tem_ e passa Variables. Per modificare i timeout, passa un tuo client: emailit.NewClient(key, emailit.WithHTTPClient(&http.Client{Timeout: 10 * time.Second})).
Gestisci gli errori
L’SDK restituisce normali errori Go, con funzioni di supporto per classificarli:
email, err := client.Emails.Send(req)
if err != nil {
switch {
case emailit.IsRateLimitError(err):
// 429: back off and retry
case emailit.IsAuthenticationError(err):
// 401: the API key is missing or invalid
case emailit.IsUnprocessableEntityError(err):
// 422: for example, the from domain isn't verified
}
var apiErr *emailit.APIError
if errors.As(err, &apiErr) {
log.Printf("emailit: %d %s", apiErr.StatusCode, apiErr.Message)
}
return err
}Invia con SMTP
Il pacchetto net/smtp della libreria standard può inviare tramite il relay di Emailit. smtp.SendMail aggiorna la connessione con STARTTLS prima di autenticarsi:
package main
import (
"log"
"net/smtp"
"os"
"strings"
)
func main() {
auth := smtp.PlainAuth("", "emailit", os.Getenv("EMAILIT_API_KEY"), "smtp.emailit.com")
msg := strings.Join([]string{
"From: Acme <hello@acme.com>",
"To: ada@example.com",
"Subject: Your login code",
"MIME-Version: 1.0",
"Content-Type: text/plain; charset=UTF-8",
"",
"Your code is 482913. It expires in 10 minutes.",
}, "\r\n")
err := smtp.SendMail("smtp.emailit.com:587", auth, "hello@acme.com", []string{"ada@example.com"}, []byte(msg))
if err != nil {
log.Fatal(err)
}
}net/smtp è minimale: il messaggio lo costruisci tu, e non supporta il TLS implicito sulla porta 465. Per HTML, allegati o il riutilizzo delle connessioni, usa una libreria di posta mantenuta o l’API. Se la porta 587 è bloccata, usa smtp.emailit.com:2525. Vedi Impostazioni SMTP.
Ricevi i webhook
Crea un webhook e salva il suo secret di firma in EMAILIT_WEBHOOK_SECRET. L’handler legge il corpo grezzo, controlla la firma, poi decodifica l’array di eventi:
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"io"
"net/http"
"os"
"strconv"
"time"
)
type emailitEvent struct {
EventID string `json:"event_id"`
Type string `json:"type"`
Data struct {
Object map[string]any `json:"object"`
} `json:"data"`
}
func validSignature(body []byte, signature, timestamp, secret string) bool {
ts, err := strconv.ParseInt(timestamp, 10, 64)
if err != nil || signature == "" {
return false
}
if age := time.Now().Unix() - ts; age > 300 || age < -300 {
return false
}
mac := hmac.New(sha256.New, []byte(secret))
mac.Write([]byte(timestamp + "."))
mac.Write(body)
expected := hex.EncodeToString(mac.Sum(nil))
return hmac.Equal([]byte(expected), []byte(signature))
}
func emailitWebhook(w http.ResponseWriter, r *http.Request) {
body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 10<<20))
if err != nil {
http.Error(w, "bad request", http.StatusBadRequest)
return
}
if !validSignature(body, r.Header.Get("X-Emailit-Signature"), r.Header.Get("X-Emailit-Timestamp"), os.Getenv("EMAILIT_WEBHOOK_SECRET")) {
http.Error(w, "invalid signature", http.StatusUnauthorized)
return
}
var events []emailitEvent // up to 100 events per request
if err := json.Unmarshal(body, &events); err != nil {
http.Error(w, "bad request", http.StatusBadRequest)
return
}
for _, event := range events {
if event.Type == "email.bounced" {
// Stop emailing event.Data.Object["to"].
}
}
w.WriteHeader(http.StatusOK)
}
func main() {
http.HandleFunc("POST /webhooks/emailit", emailitWebhook)
http.ListenAndServe(":8080", nil)
}Il pattern POST /path richiede Go 1.22 o versioni successive; con Go 1.21, registra /webhooks/emailit e controlla tu r.Method. Restituisci un 2xx entro 30 secondi; le altre risposte vengono ritentate. Vedi Firma delle richieste.
Consigli per la produzione
- Resta entro il limite di frequenza. Per impostazione predefinita, i nuovi workspace possono inviare 2 email al secondo e 5000 al giorno. Invia le email massive da un worker con un limitatore di frequenza come
golang.org/x/time/rate. Vedi Limiti e quote. - Rendi sicuri i nuovi tentativi. Se ritenti dopo un timeout, invia un header
Idempotency-Keyconnet/http, così l’email non viene inviata due volte. Vedi Idempotenza. - Elimina i webhook duplicati salvando ogni
EventIDche elabori. - Imposta i timeout. Usa un context o un timeout del client HTTP, così una rete lenta non blocca le goroutine delle richieste.