Отправка email на Go через SMTP

package main

import (
  "log"
  "net/smtp"
  "os"
  "strings"
)

func main() {
  host := "smtp.fmailer.ru"
  auth := smtp.PlainAuth("", os.Getenv("SMTP_USER"), os.Getenv("SMTP_PASS"), host)

  // Заголовки отделены от тела пустой строкой, строки заканчиваются CRLF.
  msg := strings.Join([]string{
    "From: noreply@mail.example.ru",
    "To: client@example.ru",
    "Subject: Order confirmed",
    "MIME-Version: 1.0",
    "Content-Type: text/plain; charset=UTF-8",
    "Content-Transfer-Encoding: 8bit",
    "",
    "Заказ принят. Доставка — завтра до 18:00.",
  }, "\r\n")

  // SendMail сам поднимает STARTTLS перед авторизацией.
  err := smtp.SendMail(host+":587", auth, "noreply@mail.example.ru",
    []string{"client@example.ru"}, []byte(msg))
  if err != nil {
    log.Fatal(err)
  }
}

// У smtp.SendMail нет таймаута — соединение приходится открывать самим.
func send(ctx context.Context, from string, to []string, msg []byte) error {
  host := "smtp.fmailer.ru"
  d := net.Dialer{Timeout: 10 * time.Second}
  conn, err := d.DialContext(ctx, "tcp", host+":587")
  if err != nil {
    return err
  }
  conn.SetDeadline(time.Now().Add(30 * time.Second))

  c, err := smtp.NewClient(conn, host)
  if err != nil {
    return err
  }
  defer c.Close()

  if err := c.StartTLS(&tls.Config{ServerName: host}); err != nil {
    return err
  }
  auth := smtp.PlainAuth("", os.Getenv("SMTP_USER"), os.Getenv("SMTP_PASS"), host)
  if err := c.Auth(auth); err != nil {
    return err
  }
  if err := c.Mail(from); err != nil {
    return err
  }
  for _, rcpt := range to {
    if err := c.Rcpt(rcpt); err != nil {
      return err
    }
  }
  w, err := c.Data()
  if err != nil {
    return err
  }
  if _, err := w.Write(msg); err != nil {
    return err
  }
  if err := w.Close(); err != nil {
    return err
  }
  return c.Quit()
}

go get github.com/wneessen/go-mail

import (
  "context"
  "os"
  "time"

  "github.com/wneessen/go-mail"
)

func newClient() (*mail.Client, error) {
  return mail.NewClient("smtp.fmailer.ru",
    mail.WithPort(587),
    mail.WithTLSPolicy(mail.TLSMandatory), // только STARTTLS, без открытого текста
    mail.WithSMTPAuth(mail.SMTPAuthPlain),
    mail.WithUsername(os.Getenv("SMTP_USER")),
    mail.WithPassword(os.Getenv("SMTP_PASS")),
    mail.WithTimeout(10*time.Second),
  )
}

func sendInvoice(ctx context.Context, client *mail.Client, to, html, text string) error {
  m := mail.NewMsg()
  if err := m.FromFormat("Магазин", "noreply@mail.example.ru"); err != nil {
    return err
  }
  if err := m.To(to); err != nil {
    return err
  }
  m.Subject("Счёт на оплату за март")
  m.SetBodyString(mail.TypeTextPlain, text)
  m.AddAlternativeString(mail.TypeTextHTML, html)
  m.AttachFile("/srv/invoices/2026-03.pdf")

  ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
  defer cancel()
  return client.DialAndSendWithContext(ctx, m)
}

// Порт 465: шифрование с первого байта вместо STARTTLS.
client, err := mail.NewClient("smtp.fmailer.ru",
  mail.WithPort(465),
  mail.WithSSL(),
  mail.WithSMTPAuth(mail.SMTPAuthPlain),
  mail.WithUsername(os.Getenv("SMTP_USER")),
  mail.WithPassword(os.Getenv("SMTP_PASS")),
)

// Буферизованная очередь и несколько горутин; обработчик только кладёт письмо.
type Mailer struct {
  client *mail.Client
  jobs   chan *mail.Msg
  wg     sync.WaitGroup
}

func NewMailer(client *mail.Client, workers int) *Mailer {
  m := &Mailer{client: client, jobs: make(chan *mail.Msg, 100)}
  for i := 0; i < workers; i++ {
    m.wg.Add(1)
    go m.run()
  }
  return m
}

func (m *Mailer) run() {
  defer m.wg.Done()
  for msg := range m.jobs {
    for attempt := 1; attempt <= 3; attempt++ {
      ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
      err := m.client.DialAndSendWithContext(ctx, msg)
      cancel()
      if err == nil {
        break
      }
      log.Printf("попытка %d не удалась: %v", attempt, err)
      time.Sleep(time.Duration(attempt) * 5 * time.Second)
    }
  }
}

func (m *Mailer) Enqueue(msg *mail.Msg) { m.jobs <- msg }

// Shutdown перестаёт принимать письма и дожидается отправки очереди.
func (m *Mailer) Shutdown() {
  close(m.jobs)
  m.wg.Wait()
}

type sendRequest struct {
  Recipient string            `json:"recipient"`
  Subject   string            `json:"subject"`
  Body      string            `json:"body"`
  Text      string            `json:"text,omitempty"`
  Sender    string            `json:"sender"`
  Auth      map[string]string `json:"auth"`
}

func sendViaAPI(ctx context.Context, to, subject, html, text string) error {
  payload, _ := json.Marshal(sendRequest{
    Recipient: to,
    Subject:   subject,
    Body:      html,
    Text:      text,
    Sender:    "Магазин <noreply@mail.example.ru>",
    Auth: map[string]string{
      "username": os.Getenv("SMTP_USER"),
      "password": os.Getenv("SMTP_PASS"),
    },
  })

  req, err := http.NewRequestWithContext(ctx, http.MethodPost,
    "https://api.fmailer.ru/external/send_email_simple/", bytes.NewReader(payload))
  if err != nil {
    return err
  }
  req.Header.Set("Content-Type", "application/json")

  resp, err := (&http.Client{Timeout: 15 * time.Second}).Do(req)
  if err != nil {
    return err
  }
  defer resp.Body.Close()
  if resp.StatusCode >= 300 {
    return fmt.Errorf("send failed: %s", resp.Status)
  }
  return nil
}