tencent cloud

Simple Email Service

Introdução do produto
Visão geral
Funcionalidades
Vantagens
Casos de uso
Especificações
Guia de aquisição
Preços
Guia do console
Configuração
Estatísticas
Documentação do SMTP
Guia de envio de e-mail do SMTP
Endereço do serviço do SMTP
Exemplo de chamada para Java
Exemplo de chamada para Go
Envio de e-mail com anexo
Código de erro
Documentação do webhook
Notificação de evento por e-mail
Restrições de envio de e-mail
Tipos de anexo
Perguntas frequentes
Introdução
Limite de envio
Funcionalidade de envio
Domínio
Modelo
Verificação e configuração de identidade
IP dedicado
Entrega
Uso de API
Retorno
Pasta de spam
Segurança
Observações importantes
Outros
Fale conosco
DocumentaçãoSimple Email ServiceDocumentação do SMTPEnvio de e-mail com anexo

Envio de e-mail com anexo

PDF
Modo Foco
Tamanho da Fonte
Última atualização: 2026-01-16 10:44:02
O método de enviar um e-mail com um anexo por SMTP é criar o conteúdo de um e-mail formatado em MIME.

Formato MIME de e-mail

Para obter mais informações, consulte Protocolo MIME.
Explicação
Uma mensagem MIME consiste em duas partes: cabeçalho do e-mail e corpo do e-mail.

Cabeçalho do e-mail

Explicação
Cada informação é chamada de campo, que consiste em um domínio seguido por “:” e o conteúdo da informação, podendo estar em uma ou várias linhas.
A primeira linha de um campo deve ser escrita “à esquerda”, ou seja, sem caracteres de espaço em branco (espaços e tabulações) à esquerda.
As próximas linhas devem começar com caracteres de espaço em branco, um dos quais não deve ser inerente à própria mensagem (ou seja, precisa ser filtrado durante a decodificação).
Não são permitidas linhas em branco no cabeçalho do e-mail. Se a primeira linha estiver em branco, alguns e-mails não poderão ser reconhecidos pelo software de alguns clientes de e-mail e o código original será exibido.
Por exemplo:
Conteúdo
Exemplo
Date
Seg, 29 de junho de 2009 18:39:03 +0800
From
abc@123.com
To
abc1@123.com
BCC
abc3@123.com
Subject
teste
Message-ID
123@123.com
Mime-Version
1.0
Campo
Descrição
Bcc
Endereço de cópia oculta
Cc
Endereço de cópia
Content-Transfer-Encoding
Método de codificação de transferência de conteúdo
Content-Type
Tipo de conteúdo
Date
Data e hora
Delivered-To
Endereço do destinatário
From
Endereço do remetente
Message-ID
ID da mensagem
MIME-Version
Versão do MIME
Received
Caminho de transferência
Reply-To
Endereço de resposta
Return-Path
Endereço de resposta
Subject
Assunto
To
Endereço do destinatário

Corpo do e-mail

Campo
Descrição
Content-ID
ID do conteúdo
Content-Transfer-Encoding
Método de codificação de transferência de conteúdo
Content-Location
Local do conteúdo (caminho)
Content-Base
Local da base de conteúdo
Content-Disposition
Método de disposição de conteúdo
Content-Type
Tipo de conteúdo

Alguns campos possuem parâmetros além de valores. Valor e parâmetro, assim como parâmetro e parâmetro, são separados por “;”. O nome do parâmetro e o valor do parâmetro são separados por “=”.
O corpo do e-mail contém o conteúdo do e-mail, cujo tipo é indicado pelo campo Content-Type no cabeçalho do e-mail.
Explicação
Tipos simples incluem:
texto/sem formatação (texto sem formatação)
texto/html (hipertexto)
O tipo de várias partes é a essência dos e-mails com formatação MIME. O corpo do e-mail é dividido em várias partes, cada uma das quais consiste no cabeçalho e no corpo das respectivas partes, separadas por uma linha em branco.
Existem três tipos comuns com várias partes:
multipart/mixed (várias partes/mista)
multipart/related (várias partes/relacionada)
multipart/alternative (várias partes/alternativa) O significado e o uso de cada um desses tipos podem ser determinados através de seus nomes. A relação hierárquica entre eles pode ser resumida como mostrado abaixo:

Se deseja adicionar anexos a um e-mail, você deve definir a parte multipart/mixed. Se houver recursos incorporados, você deve definir pelo menos a parte multipart/related; se texto simples e hipertexto coexistem, você deve definir pelo menos a parte multipart/alternative.
Explicação
A quantidade de anexos não deve exceder 10, o tamanho de um único anexo não deve exceder 4 MB e o tamanho total de todos os anexos não deve exceder 8 MB. Para obter mais informações, consulte Estrutura de dados.

exemplo de código Go

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

// Test465Attachment  para a porta 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
    // Este campo não é usado por enquanto. Passe `1.0` por padrão
    header["Mime-Version"] = "1.0"
    // Este campo não é usado por enquanto
    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")
    // É possível unir vários anexos no final. Pode haver no máximo dez anexos, cada um dos quais não pode exceder 5 MB de tamanho. O tamanho TOTAL de todos os anexos não pode exceder 8–9 MB; caso contrário, será retornado EOF
    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 retorna um cliente smtp
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 envia e-mail com tls
func SendMailWithTLS(addr string, auth smtp.Auth, from string,
    to []string, msg []byte) (err error) {
    //cria cliente smtp
    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 lê o arquivo para 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()
}


exemplo de código 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():
    # Configurações do servidor de e-mail
    host = "smtp.qcloudmail.com"    # Escolha um domínio de acesso diferente de acordo com o site
    port = 465
    email = "abc@cd.com"    # Nome de usuário SMTP registrado no console
    password = "****"       # Senha SMTP registrada no console
    to_email = "test@test123.com"
    
    # Criar mensagem 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"
    
    # Conteúdo do corpo HTML
    html_body = """
    <!DOCTYPE html>
    <html>
    <head>
      <meta charset="utf-8"><title>hello world</title>
    </head>
    <body>
      <h1>Meu primeiro título</h1>
      <p>Meu primeiro parágrafo.</p>
    </body>
    </html>
    """
    
    # Adicionar parte do corpo HTML
    html_part = MIMEText(html_body, 'html', 'utf-8')
    msg.attach(html_part)
    
    # Adicionar anexos
    attachments = ["./nome_em_chines.txt"]
    
    for attachment_path in attachments:
        if os.path.exists(attachment_path):
            try:
                # Ler arquivo de anexo
                with open(attachment_path, 'rb') as file:
                    attachment_data = file.read()
                
                # Criar objeto MIMEBase
                attachment_part = MIMEBase('application', 'octet-stream')
                attachment_part.set_payload(attachment_data)
                
                # Codificar em base64
                encoders.encode_base64(attachment_part)
                
                # Definir cabeçalhos do anexo
                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"Anexo adicionado com sucesso: {filename}")
                
            except Exception as e:
                print(f"Erro ao adicionar o anexo {attachment_path}: {e}")
        else:
            print(f"O arquivo de anexo não existe: {attachment_path}")
    
    try:
        # Criar contexto SSL
        context = ssl.create_default_context()
        
        # Conectar ao servidor SMTP e enviar o e-mail
        with smtplib.SMTP_SSL(host, port, context=context) as server:
            server.login(email, password)
            server.send_message(msg)
            print("E-mail enviado com sucesso!")
            return True
            
    except Exception as e:
        print(f"Erro ao enviar o e-mail: {e}")
        return False


if __name__ == "__main__":
    print("Iniciando o envio de e-mail com anexo...")
    send_email_with_attachments()

Anterior: Exemplo de chamada para GoPróximo: Código de erro

Ajuda e Suporte

Esta página foi útil?

comentários