tencent cloud

Simple Email Service

Deskripsi Produk
Ikhtisar
Fitur
Keunggulan
Kasus Penggunaan
Spesifikasi
Panduan Pembelian
Harga
Panduan Konsol
Konfigurasi
Statistik
Dokumentasi SMTP
Panduan Pengiriman Email SMTP
Alamat Layanan SMTP
Contoh Panggilan untuk Java
Contoh Panggilan untuk Go
Mengirim Email dengan Lampiran
Kode Kesalahan
Dokumentasi Webhook
Pemberitahuan Peristiwa Email
Pembatasan Pengiriman Email
Jenis Lampiran
Pertanyaan Umum
Memulai
Batas Pengiriman
Fitur Pengiriman
Domain
Templat
Verifikasi dan Konfigurasi Identitas
IP Khusus
Pengiriman
Penggunaan API
Panggilan Balik
Folder Spam
Keamanan
Catatan Penting
Lainnya
Hubungi Kami
DokumentasiSimple Email ServiceDokumentasi SMTPMengirim Email dengan Lampiran

Mengirim Email dengan Lampiran

PDF
Mode fokus
Ukuran font
Terakhir diperbarui: 2026-01-16 10:44:03
Metode pengiriman email dengan lampiran melalui SMTP adalah dengan membuat konten email berformat MIME.

Format Email MIME

Untuk informasi selengkapnya, lihat Protokol MIME.
Keterangan:
Pesan MIME terdiri dari dua bagian: email header dan email body.

Header Email

Keterangan:
Setiap informasi disebut bidang, yang terdiri dari domain yang diikuti oleh ":" dan konten informasi dan dapat dalam satu atau beberapa baris.
Baris pertama bidang harus ditulis "di sebelah kiri", yaitu, tanpa karakter spasi (spasi dan tab) di sebelah kiri.
Baris berikutnya harus dimulai dengan karakter spasi, salah satunya tidak boleh melekat pada pesan itu sendiri (yaitu, perlu disaring selama decoding).
Baris kosong tidak diperbolehkan di header email. Jika baris pertama kosong, beberapa email tidak dapat dikenali oleh perangkat lunak klien email tertentu, dan kode aslinya ditampilkan.
Sebagai contoh:
Konten
Contoh
Tanggal
Sen, 29 Jun 2009 18.39:03 +0800
Dari
abc@123.com
Kepada
abc1@123.com
BCC
abc3@123.com
Subjek
test
ID-Pesan
123@123.com
Mime-Version
1.0
Bidang
Deskripsi
Bcc
Alamat BCC
Cc
Salin alamat
Pengkodean-Transfer-Konten
Metode pengkodean transfer konten
Jenis-Konten
Jenis konten
Tanggal
Tanggal dan waktu
Dikirim-Ke
Alamat penerima
Dari
Alamat pengirim
ID-Pesan
ID Pesan
Versi-MIME
Versi MIME
Diterima
Jalur transfer
Balas-Ke
Alamat balas-ke
Jalur-Kembali
Alamat balas-ke
Subjek
Subjek
Kepada
Alamat penerima

Badan Email

Bidang
Deskripsi
ID-Konten
ID Konten
Pengkodean-Transfer-Konten
Metode pengkodean transfer konten
Lokasi-Konten
Lokasi konten (jalur)
Basis-Konten
Lokasi basis konten
Disposisi-Konten
Metode disposisi konten
Jenis-Konten
Jenis konten
Beberapa bidang memiliki parameter selain nilainya. Nilai dan parameter serta parameter dan parameter dipisahkan dengan ";". Nama parameter dan nilai parameter dipisahkan dengan "=".
Badan email berisi konten email, yang jenisnya ditunjukkan oleh bidang Content-Type di header email.
Keterangan:
Jenis sederhana umum meliputi:
teks/biasa (teks biasa)
teks/html (hiperteks)
Jenis multi bagian adalah inti dari email MIME. Badan email dibagi menjadi beberapa bagian yang masing-masing terdiri dari bagian header dan bagian badan email yang dipisahkan oleh garis kosong.
Ada tiga tipe multi bagian umum:
multi bagian/campuran (multipart/mixed)
multi bagian/terkait (multipart/related)
multi bagian/alternatif (multipart/alternative)
Arti dan kegunaan dari masing-masing jenis ini bisa dilihat dari namanya. Hubungan hierarkis di antara mereka dapat diringkas seperti yang ditunjukkan di bawah ini:



Jika Anda ingin menambahkan lampiran ke email, Anda harus menentukan bagian multipart/mixed. Jika ada sumber daya yang disematkan, Anda harus mendefinisikan setidaknya bagian multipart/related; jika teks biasa dan hiperteks hidup berdampingan, Anda harus mendefinisikan setidaknya bagian multipart/alternative.
Keterangan:
Jumlah lampiran tidak boleh lebih dari 10, ukuran satu lampiran tidak boleh melebihi 4 MB, dan ukuran total semua lampiran tidak boleh melebihi 8 MB. Untuk informasi selengkapnya, lihat Stuktur Data.

Contoh kode Go

package main
import (
    "bytes"
    "crypto/tls"
    "encoding/base64"
    "fmt"
    "io/ioutil"
    "log"
    "mime"
    "net"
    "net/smtp"
    "time"
)

// Test465Attachment  for port 465
func Test465Attachment() error {
    boundary := "GoBoundary"
    host := "sg-smtp.qcloudmail.com"
    port := 465
    email := "abc@cd.com"
    password := "***"
    toEmail := "test@test123.com"
    header := make(map[string]string)
    header["From"] = "test " + "<" + email + ">"
    header["To"] = toEmail
    header["Subject"] = "Test465Attachment"
    header["Content-Type"] = "multipart/mixed;boundary=" + boundary
    // Bidang ini tidak digunakan untuk saat ini. Masukkan `1.0` secara default
    header["Mime-Version"] = "1.0"
    // Bidang ini tidak digunakan untuk saat ini
    header["Date"] = time.Now().String()
    bodyHtml := "<!DOCTYPE html>\\n<html>\\n<head>\\n<meta charset=\\"utf-8\\">\\n<title>hello world</title>\\n</head>\\n<body>\\n " +
        "<h1>My first heading</h1>\\n    <p>My first paragraph.</p>\\n</body>\\n</html>"
    message := ""
    for k, v := range header {
        message += fmt.Sprintf("%s: %s\\r\\n", k, v)
    }
    buffer := bytes.NewBuffer(nil)
    buffer.WriteString(message)

 	contentType := "Content-Type: text/html" + "; charset=UTF-8"
	body := "\\r\\n--" + boundary + "\\r\\n"
	body += contentType + "\\r\\n"
	body += "Content-Transfer-Encoding: base64\\r\\n"
	body += "\\r\\n" + base64.StdEncoding.EncodeToString([]byte(bodyHtml)) + "\\r\\n"
    buffer.WriteString(body)

    attachment := "\\r\\n--" + boundary + "\\r\\n"
    attachment += "Content-Transfer-Encoding:base64\\r\\n"
    attachment += "Content-Disposition:attachment\\r\\n"
    attachment += "Content-Type:" + "application/octet-stream" + ";name=\\"" + mime.BEncoding.Encode("UTF-8",
        "./go.mod") + "\\"\\r\\n"
    buffer.WriteString(attachment)
    writeFile(buffer, "./go.mod")
    // Beberapa lampiran dapat disambungkan di akhir. Paling banyak ada 10 lampiran, yang masing-masing tidak boleh lebih dari 5 MB. Ukuran TOTAL semua lampiran tidak boleh melebihi 8–9 MB; jika tidak, EOF akan dikembalikan
    attachment1 := "\\r\\n--" + boundary + "\\r\\n"
    attachment1 += "Content-Transfer-Encoding:base64\\r\\n"
    attachment1 += "Content-Disposition:attachment\\r\\n"
    attachment1 += "Content-Type:" + "application/octet-stream" + ";name=\\"" + mime.BEncoding.Encode("UTF-8",
        "./bbbb.txt") + "\\"\\r\\n"
    buffer.WriteString(attachment1)
    writeFile(buffer, "./bbbb.txt")
    defer func() {
        if err := recover(); err != nil {
            log.Fatalln(err)
        }
    }()

    buffer.WriteString("\\r\\n--" + boundary + "--")
    message += "\\r\\n" + body
    auth := smtp.PlainAuth(
        "",
        email,
        password,
        host,
    )
    err := SendMailWithTLS(
        fmt.Sprintf("%s:%d", host, port),
        auth,
        email,
        []string{toEmail},
        buffer.Bytes(),
    )
    if err != nil {
        fmt.Println("Send email error:", err)
    } else {
        fmt.Println("Send mail success!")
    }
    return err
}

// Dial return a smtp client
func Dial(addr string) (*smtp.Client, error) {
    conn, err := tls.Dial("tcp", addr, nil)
    if err != nil {
        log.Println("tls.Dial Error:", err)
        return nil, err
    }

    host, _, _ := net.SplitHostPort(addr)
    return smtp.NewClient(conn, host)
}

// SendMailWithTLS mengirim email dengan tls
func SendMailWithTLS(addr string, auth smtp.Auth, from string,
    to []string, msg []byte) (err error) {
    //create smtp client
    c, err := Dial(addr)
    if err != nil {
        log.Println("Create smtp client error:", err)
        return err
    }
    defer c.Close()
    if auth != nil {
        if ok, _ := c.Extension("AUTH"); ok {
            if err = c.Auth(auth); err != nil {
                log.Println("Error during AUTH", err)
                return err
            }
        }
    }
    if err = c.Mail(from); err != nil {
        return err
    }
    for _, addr := range to {
        if err = c.Rcpt(addr); err != nil {
            return err
        }
    }
    w, err := c.Data()
    if err != nil {
        return err
    }
    _, err = w.Write(msg)
    if err != nil {
        return err
    }
    err = w.Close()
    if err != nil {
        return err
    }
    return c.Quit()
}

// writeFile read file to buffer
func writeFile(buffer *bytes.Buffer, fileName string) {
    file, err := ioutil.ReadFile(fileName)
    if err != nil {
        panic(err.Error())
    }
    payload := make([]byte, base64.StdEncoding.EncodedLen(len(file)))
    base64.StdEncoding.Encode(payload, file)
    buffer.WriteString("\\r\\n")
    for index, line := 0, len(payload); index < line; index++ {
        buffer.WriteByte(payload[index])
        if (index+1)%76 == 0 {
            buffer.WriteString("\\r\\n")
        }
    }
}

func main() {
    Test465Attachment()
}


Contoh kode Python

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import smtplib
import os
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders
from email.utils import formatdate
from email.header import Header
import ssl

def send_email_with_attachments():
    # Konfigurasi server email
    host = "smtp.qcloudmail.com"    # Untuk situs yang berbeda, pilih nama domain akses yang sesuai
    port = 465
    email = "abc@cd.com"    # Nama pengguna SMTP yang didaftarkan di konsol
    password = "****"       # Kata sandi SMTP yang didaftarkan di konsol
    to_email = "test@test123.com"
    
    # Membuat pesan MIME
    msg = MIMEMultipart('mixed')
    msg['From'] = f"test <{email}>"
    msg['To'] = to_email
    msg['Subject'] = "Test465Attachment"
    msg['Date'] = formatdate(localtime=True)
    msg['Mime-Version'] = "1.0"
    
    # Konten utama HTML
    html_body = """
    <!DOCTYPE html>
    <html>
    <head>
      <meta charset="utf-8"><title>hello world</title>
    </head>
    <body>
      <h1>Judul pertama saya</h1>
      <p>Paragraf pertama saya.</p>
    </body>
    </html>
    """
    
    # Tambahkan bagian isi HTML
    html_part = MIMEText(html_body, 'html', 'utf-8')
    msg.attach(html_part)
    
    # Tambahkan lampiran
    attachments = ["./nama_berbahasa_mandarin.txt"]
    
    for attachment_path in attachments:
        if os.path.exists(attachment_path):
            try:
                # Baca berkas lampiran
                with open(attachment_path, 'rb') as file:
                    attachment_data = file.read()
                
                # Buat objek MIMEBase
                attachment_part = MIMEBase('application', 'octet-stream')
                attachment_part.set_payload(attachment_data)
                
                # Enkode ke base64
                encoders.encode_base64(attachment_part)
                
                # Atur header lampiran
                filename = os.path.basename(attachment_path)
                encoded_filename = Header(filename, 'utf-8').encode()
                attachment_part.add_header(
                    'Content-Disposition', 
                    f'attachment; filename="{encoded_filename}"'
                )
                
                msg.attach(attachment_part)
                print(f"Berhasil menambahkan lampiran: {filename}")
                
            except Exception as e:
                print(f"Terjadi kesalahan saat menambahkan lampiran {attachment_path}: {e}")
        else:
            print(f"Berkas lampiran tidak ada: {attachment_path}")
    
    try:
        # Membuat konteks SSL
        context = ssl.create_default_context()
        
        # Terhubung ke server SMTP dan mengirim email
        with smtplib.SMTP_SSL(host, port, context=context) as server:
            server.login(email, password)
            server.send_message(msg)
            print("Email berhasil dikirim!")
            return True
            
    except Exception as e:
        print(f"Terjadi kesalahan saat mengirim email: {e}")
        return False


if __name__ == "__main__":
    print("Mulai mengirim email dengan lampiran...")
    send_email_with_attachments()


Topik sebelumnya: Contoh Panggilan untuk GoTopik selanjutnya: Kode Kesalahan

Bantuan dan Dukungan

Apakah halaman ini membantu?

masukan