As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Configurar o e-mail com o Amazon SES
<a name="send-email"></a>

Você pode enviar um e-mail com o Amazon Simple Email Service (Amazon SES) usando o console do Amazon SES, a interface SMTP (Simple Mail Transfer Protocol) do Amazon SES ou a API do Amazon SES. Em geral, você usa o console para enviar e-mails de teste e gerenciar sua atividade de envio. Para enviar e-mails em massa, você pode usar a interface SMTP ou a API. Para obter mais informações preços do e-mail do Amazon SES, consulte [Preços do Amazon SES](https://aws.amazon.com/ses/pricing).
+ Se você quiser usar um pacote de software, aplicação ou linguagem de programação habilitados para SMTP para enviar e-mails pelo Amazon SES ou integrar o Amazon SES ao servidor de e-mails existente, use a interface SMTP do Amazon SES. Para obter mais informações, consulte [Envio de e-mails de modo programático pela interface SMTP do Amazon SES](send-using-smtp-programmatically.md).
+ Se você quiser chamar o Amazon SES usando solicitações HTTP brutas, use a API do Amazon SES. Para obter mais informações, consulte [Uso da API do Amazon SES para enviar e-mail](send-email-api.md).

**Importante**  
Quando você envia um e-mail para vários destinatários (destinatários são "To", "CC" e "BCC") e a chamada para o Amazon SES falha, o e-mail todo é rejeitado e nenhum dos destinatários recebe o e-mail pretendido. Portanto, recomendamos que você envie um e-mail para um destinatário de cada vez.

# Uso da interface SMTP do Amazon SES para enviar e-mail
<a name="send-email-smtp"></a>

Para enviar e-mail de produção pelo Amazon SES, você pode usar a interface SMTP (Simple Mail Transfer Protocol) ou a API do Amazon SES. Para obter mais informações sobre a API do Amazon SES, consulte [Uso da API do Amazon SES para enviar e-mail](send-email-api.md). Esta seção descreve a interface SMTP.

O Amazon SES envia e-mails usando o SMTP, que é o protocolo de e-mail mais comum na Internet. Você pode enviar e-mails por meio do Amazon SES usando diversas linguagens de programação e software habilitados para SMTP para conectar-se à interface SMTP do Amazon SES. Esta seção explica como obter suas credenciais SMTP do Amazon SES, como enviar e-mails usando a interface SMTP e como configurar vários programas de software e servidores de e-mail para usar o Amazon SES para envio de e-mail.

Para obter as soluções para problemas comuns que podem ser encontrados quando você usa o Amazon SES pela interface SMTP, consulte [Problemas de SMTP do Amazon SES](troubleshoot-smtp.md). 

## Requisitos para enviar e-mail por SMTP
<a name="send-email-smtp-requirements"></a>

Para enviar e-mails usando a interface SMTP do Amazon SES, você precisará do seguinte:
+ O endereço do endpoint SMTP. Para obter uma lista de endpoints SMTP do Amazon SES, consulte [Conexão com um endpoint SMTP do Amazon SES](smtp-connect.md).
+ O número de porta da interface SMTP. O número da porta varia de acordo com o método de conexão. Para obter mais informações, consulte [Conexão com um endpoint SMTP do Amazon SES](smtp-connect.md).
+ Nome de usuário e senha do SMTP. As credenciais SMTP são exclusivas de cada região da AWS . Se você planeja usar a interface SMTP para enviar e-mails em várias regiões da AWS , precisa obter credenciais SMTP para cada região.
**Importante**  
Suas credenciais SMTP não são idênticas às suas chaves de AWS acesso ou às credenciais que você usa para entrar no console do Amazon SES. Para obter informações sobre como gerar suas credenciais SMTP, consulte [Obtenção de credenciais SMTP do Amazon SES](smtp-credentials.md).
+ Software cliente que pode se comunicar usando Transport Layer Security (TLS). Para obter mais informações, consulte [Conexão com um endpoint SMTP do Amazon SES](smtp-connect.md).
+ Um endereço de e-mail que você verificou com o Amazon SES. Para obter mais informações, consulte [Identidades verificadas no Amazon SES](verify-addresses-and-domains.md).
+ Aumento de cotas de envio, se você quiser enviar grandes quantidades de e-mail. Para obter mais informações, consulte [Gerenciamento de limites do envio do Amazon SES](manage-sending-quotas.md).

## Métodos para enviar e-mail por SMTP
<a name="send-email-methods"></a>

Você pode enviar e-mail por SMTP usando qualquer um dos seguintes métodos:
+ Para configurar software habilitado para SMTP para enviar e-mail por meio da interface SMTP do Amazon SES, consulte [Envio de e-mails pelo Amazon SES usando pacotes de software](send-email-smtp-software-package.md).
+ Para programar uma aplicação para enviar e-mails por meio do Amazon SES, consulte [Envio de e-mails de modo programático pela interface SMTP do Amazon SES](send-using-smtp-programmatically.md).
+ Para configurar seu servidor de e-mails existente para enviar todos os e-mail de saída pelo Amazon SES, consulte [Integração do Amazon SES com seu servidor de e-mail existente](send-email-smtp-existing-server.md).
+ Para interagir com a interface SMTP do Amazon SES usando a linha de comando, o que pode ser útil para testes, consulte [Teste de sua conexão com a interface SMTP do Amazon SES usando a linha de comando](send-email-smtp-client-command-line.md).

Para obter uma lista de códigos de resposta do SMTP, consulte [Códigos de resposta SMTP retornados pelo Amazon SES](troubleshoot-smtp.md#troubleshoot-smtp-response-codes).

## Informações de e-mail a serem fornecidas
<a name="smtp-parameters"></a>

Quando acessa o Amazon SES pela interface SMTP, sua aplicação de cliente SMTP monta a mensagem, portanto, as informações que você precisa fornecer dependerão da aplicação que estiver usando. No mínimo, a troca de SMTP entre um cliente e um servidor requer o seguinte: 
+ um endereço IP de origem
+ um endereço de destino
+ dados da mensagem

Se você estiver usando a interface SMTP e estiver com o encaminhamento de feedback habilitado, suas devoluções, reclamações e notificações de entrega serão enviadas para o endereço "MAIL FROM". Qualquer endereço "Reply-To" que você especificar não será usado.



# Obtenção de credenciais SMTP do Amazon SES
<a name="smtp-credentials"></a>

Você precisa das credenciais SMTP do Amazon SES para acessar a interface SMTP do SES.

As credenciais que você usa para enviar e-mails pela interface SMTP do SES são exclusivas para cada AWS região. Se usar a interface SMTP do SES para enviar e-mails em mais de uma região, você deve gerar um conjunto de credenciais SMTP para cada região que pretende usar.

Sua senha SMTP é diferente da sua chave de acesso AWS secreta. Para obter mais informações sobre credenciais, consulte [Tipos de credenciais do Amazon SES](send-email-concepts-credentials.md).

**nota**  
Para obter uma lista dos endpoints SMTP disponíveis no momento, consulte [Endpoints SMTP](https://docs.aws.amazon.com/general/latest/gr/ses.html#ses_smtp_endpoints) na *Referência geral da AWS*. 

## Obter as credenciais SMTP do SES usando o console do SES
<a name="smtp-credentials-console"></a>

**Requisito**  
Um usuário do IAM pode criar credenciais SMTP do SES, mas a política de usuário deve conceder a ele permissão para usar o IAM em si, pois as credenciais SMTP do SES são criadas com o uso do IAM. Sua política do IAM deve permitir que você execute as seguintes ações do IAM: `iam:ListUsers`, `iam:CreateUser`, `iam:CreateAccessKey` e `iam:PutUserPolicy`. Se você tentar criar credenciais SES SMTP usando o console e seu usuário do IAM não tiver essas permissões, você verá um erro informando que sua conta *“não está autorizada a realizar iam: ListUsers*”.

**Importante**  
As ações do IAM mencionadas acima têm o nível de acesso [Gerenciamento de permissões](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_understand-policy-summary-access-level-summaries.html#access_policies_access-level), que é o nível mais alto do IAM, pois possibilita conceder ou modificar permissões de recursos no serviço. Portanto, para melhorar a segurança da sua AWS conta, é altamente recomendável que você restrinja ou monitore regularmente essas políticas que incluem a classificação do nível de acesso ao gerenciamento de permissões.

**Para criar suas credenciais SMTP**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon SES em [https://console.aws.amazon.com/ses/](https://console.aws.amazon.com/ses/).

1. Selecione **SMTP settings** (Configurações de SMTP) no painel de navegação à esquerda. Isso abrirá a página **Simple Mail Transfer Protocol (SMTP) settings** [Configurações de SMTP (Simple Mail Transfer Protocol)].

1. Selecione **Create SMTP Credentials** (Criar credenciais de SMTP) no canto superior direito. Isso abrirá o console do IAM.

1. (Opcional) Se você precisar visualizar, editar ou excluir usuários de SMTP que já criou, selecione **Manage my existing SMTP credentials** (Gerenciar minhas credenciais SMTP existentes) no canto inferior direito. Isso abrirá o console do IAM. Os detalhes do gerenciamento de credenciais de SMTP são fornecidos seguindo esses procedimentos.

1. Para **Criar usuário para SMTP**, digite um nome para seu usuário SMTP no campo **Nome de usuário**. Como alternativa, você pode usar o valor padrão que é fornecido nesse campo. Ao terminar, escolha **Criar usuário** no canto inferior direito.

1. Selecione **Mostrar** em *Senha SMTP*: as credenciais SMTP são mostradas na tela.

1. Baixe essas credenciais escolhendo **Baixar arquivo .csv** ou copie e armazene-as em local seguro, porque você não poderá visualizar nem salvar as credenciais depois que fechar essa caixa de diálogo.

1. Escolha **Retornar ao console do SES**.

É possível exibir uma lista de credenciais SMTP que você criou usando esse procedimento no console do IAM em **Access management** (Gerenciamento de acesso) e escolhendo **Users** (Usuários). Depois, use a barra de pesquisa para localizar todos os usuários aos quais você atribuiu credenciais SMTP.

Também é possível usar o console do IAM para excluir usuários SMTP existentes. Para saber mais sobre como excluir usuários, consulte [Gerenciar usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html) no *Guia de conceitos básicos do IAM*.

Se pretender alterar a senha SMTP, exclua o usuário SMTP existente no console do IAM. Depois, para gerar um novo conjunto de credenciais SMTP, realize os procedimentos anteriores.

## Obtendo credenciais SES SMTP convertendo credenciais existentes AWS
<a name="smtp-credentials-convert"></a>

Se você tiver um usuário configurado usando a interface do IAM, poderá derivar as credenciais SES SMTP do usuário a partir de suas credenciais. AWS 

**Importante**  
Não use AWS credenciais temporárias para derivar credenciais SMTP. A interface SMTP do SES não é compatível com credenciais SMTP que tenham sido geradas com base nas credenciais de segurança temporárias. 

**Para que o usuário do IAM possa enviar e-mails usando a interface SMTP do SES**

1. Derive as credenciais SMTP do usuário a partir de suas AWS credenciais usando o algoritmo fornecido nesta seção seguindo estes procedimentos.

   Como você está começando com AWS as credenciais, o nome de usuário SMTP é o mesmo que o ID da chave de AWS acesso, então você só precisa gerar a senha SMTP.

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Em **Gerenciamento de acesso**, escolha **Políticas** e, em seguida, **Criar política**.

1. No **Editor de políticas**, selecione **JSON** e remova qualquer código de exemplo no editor.

1. Cole a seguinte política de permissões no editor:

------
#### [ JSON ]

****  

   ```
   {
   "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
   "Effect": "Allow",
               "Action": "ses:SendRawEmail",
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Selecione **Avançar**, insira `AmazonSesSendingAccess` no campo **Nome da política** e selecione **Criar política**.

1. Em **Gerenciamento de acesso**, escolha **Grupos de usuários** e, em seguida, **Criar grupo**.

1. Insira `AWSSESSendingGroupDoNotRename` no campo **Nome do grupo de usuários**.

1. Adicione usuários SMTP ao grupo selecionando-os na tabela **Adicionar usuários ao grupo**.

1. Anexe a política `AmazonSesSendingAccess` criada anteriormente selecionando-a na tabela **Anexar políticas de permissões** e selecionando **Criar grupo de usuários**.

Para obter mais informações sobre como usar o SES com o IAM, consulte [Gerenciamento de identidade e acesso no Amazon SES](control-user-access.md).

**nota**  
Embora você possa gerar credenciais SMTP do SES para qualquer usuário do IAM, recomendamos criar um usuário do IAM separado ao gerar suas credenciais SMTP. Para obter mais informações sobre por que é uma prática recomendada criar usuários para fins específicos, consulte [Melhores práticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPractices.html).

O pseudocódigo a seguir mostra o algoritmo que converte uma chave de acesso AWS secreta em uma senha SES SMTP.

```
 1. // Modify this variable to include your AWS secret access key
 2. key = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY";
 3.             
 4. // Modify this variable to refer to the AWS Region that you want to use to send email.
 5. region = "us-west-2";
 6.             
 7. // The values of the following variables should always stay the same.
 8. date = "11111111";
 9. service = "ses";
10. terminal = "aws4_request";
11. message = "SendRawEmail";
12. version = 0x04;
13. 
14. kDate = HmacSha256(date, "AWS4" + key);
15. kRegion = HmacSha256(region, kDate);
16. kService = HmacSha256(service, kRegion);
17. kTerminal = HmacSha256(terminal, kService);
18. kMessage = HmacSha256(message, kTerminal);
19. signatureAndVersion = Concatenate(version, kMessage);
20. smtpPassword = Base64(signatureAndVersion);
```

Algumas linguagens de programação incluem bibliotecas que você pode usar para converter uma chave de acesso secreta do IAM em uma senha SMTP. Esta seção inclui um exemplo de código que você pode usar para converter uma chave de acesso AWS secreta em uma senha SES SMTP usando Python.

**nota**  
O exemplo a seguir usa **f-strings** que foram introduzidos no Python 3.6; se estiver usando uma versão mais antiga, elas não funcionarão.
No exemplo a seguir, a lista de SMTP\$1REGIONS é apenas um exemplo. Sua lista real de regiões pode ser menor ou maior, dependendo das regiões em que você planeja enviar e-mails, pois você precisará de credenciais SMTP para cada Região da AWS.

------
#### [ Python ]

```
#!/usr/bin/env python3

import hmac
import hashlib
import base64
import argparse

SMTP_REGIONS = [
    "us-east-2",  # US East (Ohio)
    "us-east-1",  # US East (N. Virginia)
    "us-west-2",  # US West (Oregon)
    "ap-south-1",  # Asia Pacific (Mumbai)
    "ap-northeast-2",  # Asia Pacific (Seoul)
    "ap-southeast-1",  # Asia Pacific (Singapore)
    "ap-southeast-2",  # Asia Pacific (Sydney)
    "ap-northeast-1",  # Asia Pacific (Tokyo)
    "ca-central-1",  # Canada (Central)
    "eu-central-1",  # Europe (Frankfurt)
    "eu-west-1",  # Europe (Ireland)
    "eu-west-2",  # Europe (London)
    "eu-south-1",  # Europe (Milan)
    "eu-north-1",  # Europe (Stockholm)
    "sa-east-1",  # South America (Sao Paulo)
    "us-gov-west-1",  # AWS GovCloud (US)
    "us-gov-east-1",  # AWS GovCloud (US)
]

# These values are required to calculate the signature. Do not change them.
DATE = "11111111"
SERVICE = "ses"
MESSAGE = "SendRawEmail"
TERMINAL = "aws4_request"
VERSION = 0x04


def sign(key, msg):
    return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()


def calculate_key(secret_access_key, region):
    if region not in SMTP_REGIONS:
        raise ValueError(f"The {region} Region doesn't have an SMTP endpoint.")

    signature = sign(("AWS4" + secret_access_key).encode("utf-8"), DATE)
    signature = sign(signature, region)
    signature = sign(signature, SERVICE)
    signature = sign(signature, TERMINAL)
    signature = sign(signature, MESSAGE)
    signature_and_version = bytes([VERSION]) + signature
    smtp_password = base64.b64encode(signature_and_version)
    return smtp_password.decode("utf-8")


def main():
    parser = argparse.ArgumentParser(
        description="Convert a Secret Access Key to an SMTP password."
    )
    parser.add_argument("secret", help="The Secret Access Key to convert.")
    parser.add_argument(
        "region",
        help="The AWS Region where the SMTP password will be used.",
        choices=SMTP_REGIONS,
    )
    args = parser.parse_args()
    print(calculate_key(args.secret, args.region))


if __name__ == "__main__":
    main()
```

Para obter sua senha SMTP usando esse script, salve o código anterior como `smtp_credentials_generate.py`. Depois, na linha de comando, execute o seguinte comando:

```
python path/to/smtp_credentials_generate.py wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY us-east-1
```

No comando anterior, faça o seguinte:
+ *path/to/*Substitua pelo caminho até o local onde você salvou`smtp_credentials_generate.py`.
+ Substitua *wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY* pela chave de acesso secreta que você deseja converter em uma senha SMTP.
+ *us-east-1*Substitua pela AWS região na qual você deseja usar as credenciais SMTP.

Quando esse script é executado com êxito, a única saída é sua senha SMTP.

------

## Migração de um usuário SMTP de uma política em linha existente para uma política de grupo (recomendação de segurança)
<a name="migrate-inline-policy-to-group"></a>

**Importante**  
Se você criou as credenciais SMTP do SES antes de 6 de setembro de 2024, uma política em linha e uma tag foram anexadas ao seu usuário SMTP. O SES está se afastando das políticas em linha e incentiva você a fazer o mesmo como recomendação de segurança.

Antes de migrar um usuário SMTP de uma política em linha existente para uma política de grupo, você deve primeiro criar um grupo de usuários do IAM com a política de permissões do SES para substituir a política em linha. Se você já criou esse grupo de usuários do IAM ou se ele foi criado automaticamente para as credenciais SMTP criadas a partir de 6 de setembro de 2024, poderá pular diretamente para a *etapa 10* nos procedimentos a seguir.

**Para migrar de uma política em linha existente para um grupo gerenciado**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Em **Gerenciamento de acesso**, escolha **Políticas** e, em seguida, **Criar política**.

1. No **Editor de políticas**, selecione **JSON** e remova qualquer código de exemplo no editor.

1. Cole a seguinte política de permissões no editor:

------
#### [ JSON ]

****  

   ```
   {
   "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
   "Effect": "Allow",
               "Action": "ses:SendRawEmail",
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Selecione **Avançar**, insira `AmazonSesSendingAccess` no campo **Nome da política** e selecione **Criar política**.

1. Em **Gerenciamento de acesso**, escolha **Grupos de usuários** e, em seguida, **Criar grupo**.

1. Insira `AWSSESSendingGroupDoNotRename` no campo **Nome do grupo de usuários**.

1. Adicione usuários SMTP ao grupo selecionando-os na tabela **Adicionar usuários ao grupo**.

1. Anexe a política `AmazonSesSendingAccess` criada anteriormente selecionando-a na tabela **Anexar políticas de permissões** e selecionando **Criar grupo de usuários**.

   Agora que você criou o grupo de usuários do IAM com a política de permissões do SES, poderá migrar um usuário SMTP da política em linha atual para essa política de grupo, conforme explicado nas etapas restantes.

1. Em **Gerenciamento de acesso**, escolha **Usuários** e selecione o usuário SMTP que você deseja migrar.

1. Selecione a guia **Grupos** e escolha **Adicionar usuário a grupos**.

1. Selecione o grupo `AWSSESSendingGroupDoNotRename` e, em seguida, **Adicionar usuário aos grupos**.

1. Selecione a guia **Permissões** e confirme se há duas linhas listadas com `AmazonSesSendingAccess` na coluna **Nome da política**, uma com *Em linha* e outra com *Grupo `AWSSESSendingGroupDoNotRename`* listadas na coluna **Anexado via**.

1. Selecione somente a linha que contém `AmazonSesSendingAccess` na coluna **Nome da política** e *Em linha* na coluna **Anexado via**, selecione **Remover** e confirme com **Remover política**.

   Verifique se a linha com *Grupo `AWSSESSendingGroupDoNotRename`* na coluna **Anexado via** permanece.

1. Selecione a guia **Tags** e, em seguida, **Gerenciar tags**.

1. Selecione **Remover** ao lado da linha que contém *InvokedBy*as colunas **Chave** e *SESConsole***Valor**, seguidas de **Salvar alterações**.

**Importante**  
A política `AmazonSesSendingAccess` (como política em linha, de grupo ou ambas) deve permanecer anexada ao usuário SMTP para garantir que o envio não seja afetado. Remova a política em linha somente depois que a política de grupo for anexada ao seu usuário. 

# Conexão com um endpoint SMTP do Amazon SES
<a name="smtp-connect"></a>

Para enviar e-mail usando a interface SMTP do Amazon SES, você conecta com um endpoint SMTP. Para obter uma lista completa dos endpoints SMTP do Amazon SES, consulte [Endpoints e cotas do Amazon Simple Email Service](https://docs.aws.amazon.com/general/latest/gr/ses.html) na *Referência geral da AWS*.

O endpoint SMTP do Amazon SES exige que todas as conexões sejam criptografadas usando Transport Layer Security (TLS). (Observe que o TLS normalmente é chamado pelo nome do seu protocolo antecessor, SSL.) O Amazon SES oferece suporte a dois mecanismos para estabelecer conexão criptografada por TLS: STARTTLS e TLS Wrapper. Verifique a documentação do seu software para determinar se ele oferece suporte ao STARTTLS, TLS Wrapper ou ambos.

O Amazon Elastic Compute Cloud (Amazon EC2) limita o tráfego de e-mail pela porta 25 por padrão. Para evitar erros de tempo limite ao enviar e-mails pelo endpoint SMTP do EC2, envie uma [Solicitação para remover limitações de envio de e-mail](https://aws-portal.amazon.com/gp/aws/html-forms-controller/contactus/ec2-email-limit-rdns-request) para remover essa limitação. Como alternativa, é possível enviar e-mails usando uma porta diferente ou usar um [endpoint da Amazon VPC](send-email-set-up-vpc-endpoints.md).

Quanto a problemas de conexão SMTP, consulte [Problemas de SMTP](troubleshoot-smtp.md).

## STARTTLS
<a name="smtp-connect-starttls"></a>

STARTTLS é um meio de atualizar uma conexão não criptografada para uma conexão criptografada. Existem versões do STARTTLS para diversos protocolos; a versão SMTP é definida em [RFC 3207](https://www.ietf.org/rfc/rfc3207.txt).

Para configurar uma conexão STARTTLS, o cliente SMTP se conecta ao endpoint SMTP do Amazon SES nas portas 25, 587 ou 2587, emite um comando EHLO e aguarda o servidor anunciar que é compatível com a extensão SMTP STARTTLS. Em seguida, o cliente emite o comando STARTTLS, iniciando a negociação de TLS. Quando a negociação estiver concluída, o cliente emitirá um comando EHLO sobre a nova conexão criptografada e a sessão SMTP continuará normalmente.

## TLS Wrapper
<a name="smtp-connect-tlswrapper"></a>

O TLS Wrapper (também conhecido como SMTPS ou Handshake Protocol) é um meio de iniciar uma conexão criptografada sem antes estabelecer uma conexão não criptografada. Com o TLS Wrapper, o endpoint SMTP do Amazon SES não faz negociação de TLS: é responsabilidade do cliente se conectar ao endpoint usando TLS e continuar usando TLS por toda a conversa. O TLS Wrapper é um protocolo mais antigo, mas ainda é compatível com muitos clientes.

Para configurar uma conexão com o TLS Wrapper, o cliente SMTP se conecta ao endpoint SMTP do Amazon SES na porta 465 ou 2465. O servidor apresenta o seu certificado, o cliente emite um comando EHLO e a sessão SMTP continua normalmente.

# Envio de e-mails pelo Amazon SES usando pacotes de software
<a name="send-email-smtp-software-package"></a>

Há diversos pacotes de software comerciais e de código aberto que oferecem suporte ao envio de e-mail por SMTP. Veja alguns exemplos:
+ Plataformas de blogs
+ Agregadores RSS
+ Software de gerenciamento de listas
+ Sistemas de fluxo de trabalho

Você pode configurar qualquer software habilitado para SMTP para enviar e-mail por meio da interface SMTP do Amazon SES. Para obter instruções sobre como configurar o SMTP para um determinado pacote de software, consulte a documentação desse software.

O procedimento a seguir mostra como configurar o envio do Amazon SES no JIRA, uma conhecida solução de rastreamento de problemas. Com esta configuração, o JIRA pode notificar os usuários por e-mail sempre que houver uma alteração no status de um problema de software.

**Para configurar o JIRA para enviar e-mail usando o Amazon SES**

1. Usando seu navegador, faça login no JIRA com as credenciais de administrador.

1. Na janela do navegador, escolha **Administration**.

1. No menu **System**, escolha **Mail**.

1. Na página **Mail administration**, escolha **Mail Servers**.

1. Escolha **Configure new SMTP mail server**.

1. No formulário **Add SMTP Mail Server**, preencha os seguintes campos:

   1. **Name** – Um nome descritivo para esse servidor.

   1. **From address (Endereço de origem)**: o endereço de onde o e-mail será enviado. Você deve verificar esse endereço de e-mail com o Amazon SES antes de poder enviar a partir dele. Para obter mais informações sobre verificação, consulte [Identidades verificadas no Amazon SES](verify-addresses-and-domains.md).

   1. **Email prefix** – Uma string que o JIRA acrescenta para cada linha de assunto antes de enviar.

   1. **Protocol** – Escolha **SMTP**.
**nota**  
Se você não puder se conectar ao Amazon SES usando essa configuração, tente **SECURE\$1SMTP**.

   1. **Host Name (Nome do host)**: consulte [Conexão com um endpoint SMTP do Amazon SES](smtp-connect.md) para ver uma lista de endpoints SMTP do Amazon SES. Por exemplo, se você quiser usar o endpoint do Amazon SES na região Oeste dos EUA (Oregon), o nome do host seria *email-smtp.us-west-2.amazonaws.com*.

   1. **SMTP Port (Porta SMTP)**: 25, 587 ou 2587 (para se conectar usando STARTTLS), ou 465 ou 2465 (para se conectar usando TLS Wrapper).

   1. **TLS** – Marque esta caixa.

   1. **User name (Nome do usuário)**: seu nome de usuário SMTP.

   1. **Password** – Sua senha SMTP.

   Você pode ver as configurações para o TLS Wrapper na imagem a seguir.  
![\[Configuração de e-mail SMTP para o JIRA\]](http://docs.aws.amazon.com/pt_br/ses/latest/dg/images/SMTP_jira.png)

1. Escolha **Test Connection (Testar conexão)**. Se o e-mail de teste que o JIRA envia pelo Amazon SES chegar com sucesso, sua configuração estará concluída.

# Envio de e-mails de modo programático pela interface SMTP do Amazon SES
<a name="send-using-smtp-programmatically"></a>

Para enviar um e-mail usando a interface SMTP do Amazon SES, você pode usar uma linguagem de programação, um servidor de e-mail ou uma aplicação habilitada para SMTP. Antes de começar, realize as tarefas em [Configuração do Amazon Simple Email Service](setting-up.md). Você também precisa obter as seguintes informações: 
+ Suas credenciais SMTP do Amazon SES, que permitem a conexão com o endpoint SMTP do Amazon SES. Para obter suas credenciais SMTP do Amazon SES, consulte [Obtenção de credenciais SMTP do Amazon SES](smtp-credentials.md). 
**Importante**  
Suas credenciais SMTP são diferentes das suas AWS credenciais. Para obter mais informações sobre credenciais, consulte [Tipos de credenciais do Amazon SES](send-email-concepts-credentials.md).
+ O endereço do endpoint SMTP. Para obter uma lista de endpoints SMTP do Amazon SES, consulte [Conexão com um endpoint SMTP do Amazon SES](smtp-connect.md).
+ O número da porta da interface SMTP do Amazon SES, que depende do método de conexão. Para obter mais informações, consulte [Conexão com um endpoint SMTP do Amazon SES](smtp-connect.md).

## Exemplos de código
<a name="send-email-smtp-code-examples"></a>

Você pode acessar a interface SMTP do Amazon SES usando uma linguagem de programação habilitada para SMTP. Você fornece o nome do host e o número da porta SMTP do Amazon SES junto com suas credenciais SMTP e, em seguida, use as funções SMTP genéricas da linguagem de programação para enviar o e-mail.

O Amazon Elastic Compute Cloud (Amazon EC2) restringe o tráfego de e-mail pela porta 25 por padrão. Para evitar erros de tempo limite ao enviar e-mails pelo endpoint SMTP do Amazon EC2, você pode solicitar que essas restrições sejam removidas. Para obter mais informações, consulte [Como faço para remover a restrição na porta 25 da minha instância AWS Lambda ou função do Amazon EC2](https://aws.amazon.com/premiumsupport/knowledge-center/ec2-port-25-throttle/)? no Centro de AWS Conhecimento.

Os exemplos de código nesta seção para Java e PHP usam a porta 587 para evitar esse problema. 

**nota**  
Neste tutorial, você enviará um e-mail a si mesmo, para poder conferir se o recebe. Para fazer mais experimentos ou testes de carga, use o simulador de caixa postal do Amazon SES. Os e-mails enviados ao simulador de caixa postal não contam para sua cota de envio nem para suas taxas de devoluções e reclamações. Para obter mais informações, consulte [Uso do simulador de caixa postal manualmente.](send-an-email-from-console.md#send-email-simulator).

**Selecione uma linguagem de programação para visualizar o exemplo dessa linguagem:**

**Atenção**  
O Amazon SES não recomenda o uso de credenciais estáticas. Consulte [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) para saber como melhorar seu procedimento de segurança ao remover credenciais com codificação rígida do código-fonte. Este tutorial é fornecido apenas com a finalidade de testar a interface SMTP do Amazon SES em um ambiente que não seja de produção.

------
#### [ Java ]

Este exemplo usa o [Eclipse IDE](http://www.eclipse.org/) e a [JavaMail API](https://github.com/javaee/javamail/releases) para enviar e-mails pelo Amazon SES usando a interface SMTP.

Antes de realizar o procedimento a seguir, conclua as tarefas de configuração descritas em [Configuração do Amazon Simple Email Service](setting-up.md).

**Para enviar um e-mail usando a interface SMTP do Amazon SES com Java**

1. Em um navegador da Web, acesse a [JavaMail GitHub página](https://github.com/javaee/javamail/releases). Em **Assets**, escolha **javax.mail.jar** para baixar a versão mais recente do. JavaMail
**Importante**  
Este tutorial requer a JavaMail versão 1.5 ou posterior. Esses procedimentos foram testados usando a JavaMail versão 1.6.1.

1. **Em um navegador da web, acesse a [ GitHub página de ativação de Jacarta](https://github.com/eclipse-ee4j/jaf/releases) e, em [Versão final do JavaBeans Activation Framework 1.2.1](https://github.com/eclipse-ee4j/jaf/releases/tag/1.2.1), baixe o jakarta.activation.jar**

1. Crie um projeto no Eclipse realizando as seguintes etapas:

   1. Inicie o Eclipse.

   1. No Eclipse, escolha **File**, **New** e **Java Project**.

   1. Na caixa de diálogo **Create a Java Project**, digite o nome do projeto e escolha **Next.**

   1. Na caixa de diálogo **Java Settings**, escolha a guia **Libraries**.

   1. ****Selecione **Classpath** e adicione os dois arquivos jar externos **javax.mail.jar e jakarta.activation.jar** usando o botão Adicionar externo. JARs****

   1. Escolha **Adicionar externo JARs**.

   1. Navegue até a pasta na qual você baixou JavaMail. Escolha o arquivo `javax.mail.jar` e **Open**.

   1. Na caixa de diálogo **Java Settings**, escolha **Finish**.

1. No Eclipse, na janela **Package Explorer**, expanda seu projeto.

1. No seu projeto, clique com o botão direito do mouse no diretório **src**, escolha **New** e **Class**.

1. Na caixa de diálogo **New Java Class**, no campo **Name**, digite `AmazonSESSample` e escolha **Finish**.

1. Substitua todo o conteúdo do **Amazon SESSample .java** pelo seguinte código:

   ```
     1. import java.util.Properties;
     2. 
     3. import javax.mail.Message;
     4. import javax.mail.Session;
     5. import javax.mail.Transport;
     6. import javax.mail.internet.InternetAddress;
     7. import javax.mail.internet.MimeMessage;
     8. 
     9. public class AmazonSESSample {
    10. 
    11.     // Replace sender@example.com with your "From" address.
    12.     // This address must be verified.
    13.     static final String FROM = "sender@example.com";
    14.     static final String FROMNAME = "Sender Name";
    15.     
    16.     // Replace recipient@example.com with a "To" address. If your account 
    17.     // is still in the sandbox, this address must be verified.
    18.     static final String TO = "recipient@example.com";
    19.     
    20.     // Replace smtp_username with your Amazon SES SMTP user name.
    21.     static final String SMTP_USERNAME = "smtp_username";
    22.       
    23.     // The name of the Configuration Set to use for this message.
    24.     // If you comment out or remove this variable, you will also need to
    25.     // comment out or remove the header below.
    26.     static final String CONFIGSET = "ConfigSet";
    27.     
    28.     // Amazon SES SMTP host name. This example uses the US West (Oregon) region.
    29.     // See https://docs.aws.amazon.com/ses/latest/DeveloperGuide/regions.html#region-endpoints
    30.     // for more information.
    31.     static final String HOST = "email-smtp.us-west-2.amazonaws.com";
    32.     
    33.     // The port you will connect to on the Amazon SES SMTP endpoint. 
    34.     static final int PORT = 587;
    35.     
    36.     static final String SUBJECT = "Amazon SES test (SMTP interface accessed using Java)";
    37.     
    38.     static final String BODY = String.join(
    39.             System.getProperty("line.separator"),
    40.             "<h1>Amazon SES SMTP Email Test</h1>",
    41.             "<p>This email was sent with Amazon SES using the ", 
    42.             "<a href='https://github.com/javaee/javamail'>Javamail Package</a>",
    43.             " for <a href='https://www.java.com'>Java</a>."
    44.         );
    45. 
    46.     public static void main(String[] args) throws Exception {
    47. 
    48.         // Create a Properties object to contain connection configuration information.
    49.         Properties props = System.getProperties();
    50.         props.put("mail.transport.protocol", "smtp");
    51.         props.put("mail.smtp.port", PORT); 
    52.         props.put("mail.smtp.starttls.enable", "true");
    53.         props.put("mail.smtp.auth", "true");
    54. 
    55.         // Create a Session object to represent a mail session with the specified properties. 
    56.         Session session = Session.getDefaultInstance(props);
    57. 
    58.         // Create a message with the specified information. 
    59.         MimeMessage msg = new MimeMessage(session);
    60.         msg.setFrom(new InternetAddress(FROM,FROMNAME));
    61.         msg.setRecipient(Message.RecipientType.TO, new InternetAddress(TO));
    62.         msg.setSubject(SUBJECT);
    63.         msg.setContent(BODY,"text/html");
    64.         
    65.         // Add a configuration set header. Comment or delete the 
    66.         // next line if you are not using a configuration set
    67.         msg.setHeader("X-SES-CONFIGURATION-SET", CONFIGSET);
    68.             
    69.         // Create a transport.
    70.         Transport transport = session.getTransport();
    71. 
    72.         // Get the password 
    73.         String SMTP_PASSWORD = fetchSMTPPasswordFromSecureStorage();
    74.                     
    75.         // Send the message.
    76.         try
    77.         {
    78.             System.out.println("Sending...");
    79.             
    80.             // Connect to Amazon SES using the SMTP username and password you specified above.
    81.             transport.connect(HOST, SMTP_USERNAME, SMTP_PASSWORD);
    82.             
    83.             // Send the email.
    84.             transport.sendMessage(msg, msg.getAllRecipients());
    85.             System.out.println("Email sent!");
    86.         }
    87.         catch (Exception ex) {
    88.             System.out.println("The email was not sent.");
    89.             System.out.println("Error message: " + ex.getMessage());
    90.         }
    91.         finally
    92.         {
    93.             // Close and terminate the connection.
    94.             transport.close();
    95.         }
    96.     }
    97. 
    98.     static String fetchSMTPPasswordFromSecureStorage() {
    99.         /* IMPLEMENT THIS METHOD */
   100.         // For example, you might fetch it from a secure location or AWS Secrets Manager: https://aws.amazon.com/secrets-manager/
   101.     }
   102. }
   ```

1. No **Amazon SESSample .java**, substitua os seguintes endereços de e-mail pelos seus próprios valores:
**Importante**  
Os endereços de e-mail diferenciam maiúsculas de minúsculas. Certifique-se de que os endereços sejam exatamente os mesmos que você verificou.
   + *sender@example.com*— Substitua pelo seu endereço de e-mail “De”. Você deve verificar esse endereço antes de executar esse programa. Para obter mais informações, consulte [Identidades verificadas no Amazon SES](verify-addresses-and-domains.md).
   + *recipient@example.com*— Substitua pelo seu endereço de e-mail “Para”. Se sua conta ainda estiver na sandbox, você precisará verificar esse endereço antes de usá-lo. Para obter mais informações, consulte [Solicitar acesso à produção (sair da sandbox do Amazon SES)](request-production-access.md).

1. Na **Amazon SESSample .java**, substitua o seguinte pelos seus próprios valores:
   + *smtp\$1username*— Substitua por sua credencial de nome de usuário SMTP. Observe que sua credencial de nome de usuário SMTP é uma string de 20 caracteres de letras e números, e não um nome inteligível.
   + *smtp\$1password*— Implemente ``fetchSMTPPasswordFromSecureStorage`` para obter a senha.

1. (Opcional) Se você quiser usar um endpoint SMTP do Amazon SES em Região da AWS outro*email-smtp.us-west-2.amazonaws.com*, altere o valor da variável `HOST` para o endpoint que você deseja usar. Para obter uma lista das regiões onde o Amazon SES está disponível, consulte [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) na *Referência geral da AWS*.

1. (Opcional) Se você quiser usar um conjunto de configurações ao enviar esse e-mail, altere o valor da variável *ConfigSet* pelo nome do conjunto de configurações. Para obter mais informações sobre os conjuntos de configurações, consulte [Uso de conjuntos de configurações no Amazon SES](using-configuration-sets.md).

1. Salve **Amazon SESSample .java.**

1. Para criar o projeto, escolha **Project** e, em seguida, escolha **Build Project**. (Se essa opção estiver desativada, você pode ter a criação automática ativada.)

1. Para iniciar o programa e enviar o e-mail, escolha **Run** e **Run** novamente.

1. Revise a saída. Se o e-mail tiver sido enviado com sucesso, o console exibirá *"E-mail enviado\$1"* Caso contrário, ele exibirá uma mensagem de erro.

1. Entre no cliente de e-mail do endereço de destinatário. Você verá a mensagem que enviou.

------
#### [ PHP  ]

Este exemplo usa a PHPMailer classe para enviar e-mails pelo Amazon SES usando a interface SMTP. 

Antes de realizar o procedimento a seguir, você deve concluir as tarefas de configuração descritas em [Configuração do Amazon Simple Email Service](setting-up.md). Além de configurar o Amazon SES, você deve preencher os seguintes pré-requisitos para enviar e-mail com PHP:

**Pré-requisitos:**
+ **Instalar PHP**: o PHP está disponível em [http://php.net/downloads.php](https://php.net/downloads.php). Depois de instalar o PHP, adicione o caminho para o PHP nas suas variáveis de ambiente, de forma que possa executar o PHP a partir de qualquer prompt de comando.
+ **Instale o gerenciador de dependências do Composer** — Depois de instalar o gerenciador de dependências do Composer, você pode baixar e instalar a PHPMailer classe e suas dependências. Para instalar o Composer, siga as instruções de instalação em [https://getcomposer.org/download](https://getcomposer.org/download).
+ **Instale a PHPMailer classe** — Depois de instalar o Composer, execute o seguinte comando para instalar PHPMailer: 

  ```
  path/to/composer require phpmailer/phpmailer
  ```

  No comando anterior, *path/to/* substitua pelo caminho em que você instalou o Composer.

**Para enviar um e-mail usando a interface SMTP do Amazon SES com PHP**

1. Crie um arquivo chamado **amazon-ses-smtp-sample.php.** Abra o arquivo com um editor de texto e cole o seguinte código:

   ```
    1. <?php
    2. 
    3. // Import PHPMailer classes into the global namespace
    4. // These must be at the top of your script, not inside a function
    5. use PHPMailer\PHPMailer\PHPMailer;
    6. use PHPMailer\PHPMailer\Exception;
    7. 
    8. // If necessary, modify the path in the require statement below to refer to the
    9. // location of your Composer autoload.php file.
   10. require 'vendor/autoload.php';
   11. 
   12. // Replace sender@example.com with your "From" address.
   13. // This address must be verified with Amazon SES.
   14. $sender = 'sender@example.com';
   15. $senderName = 'Sender Name';
   16. 
   17. // Replace recipient@example.com with a "To" address. If your account
   18. // is still in the sandbox, this address must be verified.
   19. $recipient = 'recipient@example.com';
   20. 
   21. // Replace smtp_username with your Amazon SES SMTP user name.
   22. $usernameSmtp = 'smtp_username';
   23. 
   24. // Specify a configuration set. If you do not want to use a configuration
   25. // set, comment or remove the next line.
   26. $configurationSet = 'ConfigSet';
   27. 
   28. // If you're using Amazon SES in a region other than US West (Oregon),
   29. // replace email-smtp.us-west-2.amazonaws.com with the Amazon SES SMTP
   30. // endpoint in the appropriate region.
   31. $host = 'email-smtp.us-west-2.amazonaws.com';
   32. $port = 587;
   33. 
   34. // The subject line of the email
   35. $subject = 'Amazon SES test (SMTP interface accessed using PHP)';
   36. 
   37. // The plain-text body of the email
   38. $bodyText =  "Email Test\r\nThis email was sent through the
   39.     Amazon SES SMTP interface using the PHPMailer class.";
   40. 
   41. // The HTML-formatted body of the email
   42. $bodyHtml = '<h1>Email Test</h1>
   43.     <p>This email was sent through the
   44.     <a href="https://aws.amazon.com/ses">Amazon SES</a> SMTP
   45.     interface using the <a href="https://github.com/PHPMailer/PHPMailer">
   46.     PHPMailer</a> class.</p>';
   47. 
   48. $mail = new PHPMailer(true);
   49. 
   50. try {
   51.     // Specify the SMTP settings.
   52.     $mail->isSMTP();
   53.     $mail->setFrom($sender, $senderName);
   54.     $mail->Username   = $usernameSmtp;
   55.     $mail->Password   = fetchSMTPPasswordFromSecureStorage();
   56.     $mail->Host       = $host;
   57.     $mail->Port       = $port;
   58.     $mail->SMTPAuth   = true;
   59.     $mail->SMTPSecure = 'tls';
   60.     $mail->addCustomHeader('X-SES-CONFIGURATION-SET', $configurationSet);
   61. 
   62.     // Specify the message recipients.
   63.     $mail->addAddress($recipient);
   64.     // You can also add CC, BCC, and additional To recipients here.
   65. 
   66.     // Specify the content of the message.
   67.     $mail->isHTML(true);
   68.     $mail->Subject    = $subject;
   69.     $mail->Body       = $bodyHtml;
   70.     $mail->AltBody    = $bodyText;
   71.     $mail->Send();
   72.     echo "Email sent!" , PHP_EOL;
   73. } catch (phpmailerException $e) {
   74.     echo "An error occurred. {$e->errorMessage()}", PHP_EOL; //Catch errors from PHPMailer.
   75. } catch (Exception $e) {
   76.     echo "Email not sent. {$mail->ErrorInfo}", PHP_EOL; //Catch errors from Amazon SES.
   77. }
   78. function fetchSMTPPasswordFromSecureStorage() {
   79. /* IMPLEMENT THIS METHOD */
   80. // For example, you might fetch it from a secure location or AWS Secrets Manager: https://aws.amazon.com/secrets-manager/
   81. }
   82. 
   83. ?>
   ```

1. Em **amazon-ses-smtp-sample.php**, substitua o seguinte pelos seus próprios valores:
   + *sender@example.com*— Substitua por um endereço de e-mail que você tenha verificado com o Amazon SES. Para obter mais informações, consulte [Identidades](verify-addresses-and-domains.md). Os endereços de e-mail no Amazon SES diferenciam maiúsculas de minúsculas. Certifique-se de que o endereço informado seja exatamente o mesmo que você verificou.
   + *recipient@example.com*— Substitua pelo endereço do destinatário. Se sua conta ainda estiver na sandbox, você precisará verificar esse endereço antes de usá-lo. Para obter mais informações, consulte [Solicitar acesso à produção (sair da sandbox do Amazon SES)](request-production-access.md). Certifique-se de que o endereço informado seja exatamente o mesmo que você verificou.
   + *smtp\$1username*— Substitua por sua credencial de nome de usuário SMTP, que você obteve na página de [configurações SMTP](https://console.aws.amazon.com/ses/home?#smtp-settings:) do console do Amazon SES. Essa **não** é igual ao ID de chave de acesso da AWS . Observe que sua credencial de nome de usuário SMTP é uma string de 20 caracteres de letras e números, e não um nome inteligível.
   + *smtp\$1password*— Implemente ``fetchSMTPPasswordFromSecureStorage`` para obter a senha.
   + (Opcional) *ConfigSet* — Se você quiser usar um conjunto de configurações ao enviar esse e-mail, substitua esse valor pelo nome do conjunto de configurações. Para obter mais informações sobre os conjuntos de configurações, consulte [Uso de conjuntos de configurações no Amazon SES](using-configuration-sets.md).
   + (Opcional) *email-smtp.us-west-2.amazonaws.com* — Se você quiser usar um endpoint SMTP do Amazon SES em uma região diferente do Oeste dos EUA (Oregon), substitua-o pelo endpoint SMTP do Amazon SES na região que você deseja usar. Para obter uma lista de endpoints URLs SMTP em Regiões da AWS que o Amazon SES está disponível, consulte [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) no. *Referência geral da AWS*

1. Salve **amazon-ses-smtp-sample.php.**

1. Para executar o programa, abra um prompt de comando no mesmo diretório **amazon-ses-smtp-samplede.php** e digite**php amazon-ses-smtp-sample.php**.

1. Revise a saída. Se o e-mail tiver sido enviado com sucesso, o console exibirá *"E-mail enviado\$1"* Caso contrário, ele exibirá uma mensagem de erro.

1. Entre no cliente de e-mail do endereço de destinatário. Você verá a mensagem que enviou.

------

# Integração do Amazon SES com seu servidor de e-mail existente
<a name="send-email-smtp-existing-server"></a>

Se você administrar atualmente seu próprio servidor de e-mails, poderá usar o endpoint SMTP do Amazon SES para enviar todos os e-mails de saída ao Amazon SES. Não há necessidade de modificar as aplicações e clientes de e-mail existentes; a mudança para o Amazon SES será transparente para eles.

Vários agentes de transferência de e-mail (MTAs) oferecem suporte ao envio de e-mails por meio de retransmissores SMTP. Esta seção fornece orientação geral sobre como configurar alguns populares MTAs para enviar e-mails usando a interface SMTP do Amazon SES.

O endpoint SMTP do Amazon SES exige que todas as conexões sejam criptografadas usando Transport Layer Security (TLS).

**Topics**
+ [Integração do Amazon SES com o Postfix](postfix.md)
+ [Integração do Amazon SES com o Sendmail](send-email-sendmail.md)
+ [Integração do Amazon SES com o IIS SMTP do Microsoft Windows Server](send-email-windows-server.md)

# Integração do Amazon SES com o Postfix
<a name="postfix"></a>

Postfix é uma alternativa ao Message Transfer Agent (MTA) do Sendmail. Para obter informações sobre Postfix, acesse [http://www.postfix.org](http://www.postfix.org). Os procedimentos neste tópico funcionarão com Linux, macOS ou Unix.

**nota**  
☻O Postfix é uma aplicação de terceiros e não é desenvolvido nem suportado pela Amazon Web Services. Os procedimentos nesta seção são fornecidos apenas para fins informativos e estão sujeitos a alterações sem aviso prévio.

## Pré-requisitos
<a name="send-email-postfix-prereqs"></a>

Antes de concluir os procedimentos desta seção, você precisa realizar as seguintes tarefas:
+ Desinstale a aplicação Sendmail, se estiver instalada em seu sistema. O procedimento para concluir esta etapa pode variar dependendo de seu sistema operacional.
**Importante**  
As referências a *sendmail* a seguir referem-se ao comando Postfix`sendmail`. Não as confunda com a aplicação Sendmail.
+ Instale o Postfix. O procedimento para concluir esta etapa pode variar dependendo de seu sistema operacional.
+ Instale um pacote de autenticação SASL. O procedimento para concluir esta etapa pode variar dependendo de seu sistema operacional. Por exemplo, se você usa um sistema RedHat baseado, você deve instalar o `cyrus-sasl-plain` pacote. Se usar um sistema Debian ou Ubuntu, deverá instalar o pacote `libsasl2-modules`.
+ Confirme o endereço de e-mail ou domínio que você usará para enviar e-mails. Para obter mais informações, consulte [Criação da identidade de um endereço de e-mail](creating-identities.md#verify-email-addresses-procedure).
+ Se a sua conta ainda estiver no sandbox, você só poderá enviar e-mail para endereços de e-mail verificados. Para obter mais informações, consulte [Solicitar acesso à produção (sair da sandbox do Amazon SES)](request-production-access.md).

## Configuração do Postfix
<a name="send-email-postfix"></a>

Realize os seguintes procedimentos para configurar seu servidor de e-mail para enviar e-mails por meio do Amazon SES usando o Postfix.

**Para configurar o Postfix**

1. Na linha de comando, digite o seguinte comando:

   ```
   sudo postconf -e "relayhost = [email-smtp.us-west-2.amazonaws.com]:587" \
   "smtp_sasl_auth_enable = yes" \
   "smtp_sasl_security_options = noanonymous" \
   "smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd" \
   "smtp_use_tls = yes" \
   "smtp_tls_security_level = secure" \
   "smtp_tls_note_starttls_offer = yes"
   ```
**nota**  
Se você usa o Amazon SES em uma AWS região diferente do Oeste dos EUA (Oregon), *email-smtp.us-west-2.amazonaws.com* substitua o comando anterior pelo endpoint SMTP da região apropriada. Para obter mais informações, consulte [Regiões e o Amazon SES](regions.md).

1. Em um editor de texto, abra o arquivo `/etc/postfix/master.cf`. Procure a seguinte entrada:

   ```
   -o smtp_fallback_relay=
   ```

   Se você encontrar essa entrada, faça um comentário, colocando um caractere `#` (hash) no início da linha. Salve e feche o arquivo.

   Caso contrário, se essa entrada não estiver presente, continue na próxima etapa.

1. Em um editor de texto, abra o arquivo `/etc/postfix/sasl_passwd`. Se o arquivo ainda não existir, crie-o.

1. Adicione a seguinte linha a `/etc/postfix/sasl_passwd`:

   ```
   [email-smtp.us-west-2.amazonaws.com]:587 SMTPUSERNAME:SMTPPASSWORD
   ```
**nota**  
Substitua *SMTPUSERNAME* e *SMTPPASSWORD* por suas credenciais de login SMTP. Suas credenciais de login SMTP não são iguais ao ID da chave de acesso e à chave de acesso secreta da AWS . Para obter mais informações sobre credenciais, consulte [Obtenção de credenciais SMTP do Amazon SES](smtp-credentials.md).  
Se você usa o Amazon SES em uma AWS região diferente do Oeste dos EUA (Oregon), substitua *email-smtp.us-west-2.amazonaws.com* no exemplo anterior pelo endpoint SMTP da região apropriada. Para obter mais informações, consulte [Regiões e o Amazon SES](regions.md).

   Salve e feche `sasl_passwd`.

1. Em um prompt de comando, digite o comando a seguir para criar um arquivo de banco de dados de hashmap que contém suas credenciais SMTP:

   ```
   sudo postmap hash:/etc/postfix/sasl_passwd
   ```

1. (Opcional) Os arquivos `/etc/postfix/sasl_passwd` e `/etc/postfix/sasl_passwd.db` que você criou nas etapas anteriores não são criptografados. Como esses arquivos contêm suas credenciais do SMTP, recomendamos que você modifique a propriedade e as permissões dos arquivos para restringir o acesso a eles. Para restringir o acesso a esses arquivos:

   1. Em um prompt de comando, digite o comando a seguir para alterar a propriedade dos arquivos:

      ```
      sudo chown root:root /etc/postfix/sasl_passwd /etc/postfix/sasl_passwd.db
      ```

   1. Em um prompt de comando, digite o comando a seguir para alterar as permissões dos arquivos de modo que apenas o usuário raiz possa ler ou gravar neles:

      ```
      sudo chmod 0600 /etc/postfix/sasl_passwd /etc/postfix/sasl_passwd.db
      ```

1. Diga ao Postfix onde encontrar o certificado CA (necessário para verificar o certificado do servidor do Amazon SES). O comando que você usa nesta etapa varia de acordo com o seu sistema operacional.
   + Se você usa o Amazon Linux, o Red Hat Enterprise Linux ou uma distribuição relacionada, digite o comando a seguir: 

     ```
     sudo postconf -e 'smtp_tls_CAfile = /etc/ssl/certs/ca-bundle.crt'
     ```
   + Se você usa Ubuntu ou uma distribuição relacionada, digite o comando a seguir:

     ```
     sudo postconf -e 'smtp_tls_CAfile = /etc/ssl/certs/ca-certificates.crt'
     ```
   + Se você usa macOS, pode gerar o certificado a partir do conjunto de chaves do sistema. Para gerar o certificado, digite o comando a seguir na linha de comando:

     ```
     sudo security find-certificate -a -p /System/Library/Keychains/SystemRootCertificates.keychain | sudo tee /etc/ssl/certs/ca-bundle.crt > /dev/null
     ```

     Depois que você gerar o certificado, digite o comando a seguir:

     ```
     sudo postconf -e 'smtp_tls_CAfile = /etc/ssl/certs/ca-bundle.crt'
     ```

1. Digite o comando a seguir para iniciar o servidor do Postfix (ou para recarregar os parâmetros de configuração, se o servidor já estiver em execução):

   ```
   sudo postfix start; sudo postfix reload
   ```

1. Envie um e-mail de teste digitando o seguinte em uma linha de comando, pressionando Enter após cada linha. *sender@example.com*Substitua pelo seu endereço de e-mail do remetente. O endereço From (De) precisa ser verificado para uso com o Amazon SES. *recipient@example.com*Substitua pelo endereço de destino. Se sua conta ainda estiver na sandbox, o endereço do destinatário também precisa ser verificado. Por fim, a última linha da mensagem precisa conter um ponto final (.) sem nenhum outro conteúdo.

   ```
   sendmail -f sender@example.com recipient@example.com
   From: Sender Name <sender@example.com>
   Subject: Amazon SES Test                
   This message was sent using Amazon SES.                
   .
   ```

1. Marque a caixa de correio associada ao endereço de destinatário. Se o e-mail não chegar, verifique sua pasta de spam. Se você ainda não conseguir localizar o e-mail, verifique o log de e-mails no sistema que usou para enviar o e-mail (normalmente localizado em `/var/log/maillog`) para obter mais informações.

## Exemplo de uso avançado
<a name="send-email-postfix-advanced"></a>

Este exemplo mostra como enviar um e-mail que usa um [conjunto de configurações](using-configuration-sets.md) e que usa a codificação MIME multipartes para enviar uma versão da mensagem tanto em texto simples quanto em HTML junto com um anexo. Isso também inclui uma [tag de link](faqs-metrics.md#sending-metric-faqs-clicks-q5), que pode ser usada para categorizar eventos de clique. O conteúdo do e-mail é especificado em um arquivo externo, de modo que você não precise digitar manualmente os comandos na sessão do Postfix.

**Para enviar um e-mail MIME multipartes usando o Postfix**

1. Em um editor de texto, crie um novo arquivo chamado `mime-email.txt`.

1. No arquivo de texto, cole o conteúdo a seguir, substituindo os valores em vermelho pelos valores apropriados para a sua conta:

   ```
   X-SES-CONFIGURATION-SET: ConfigSet
   From:Sender Name <sender@example.com>
   Subject:Amazon SES Test
   MIME-Version: 1.0
   Content-Type: multipart/mixed; boundary="YWVhZDFlY2QzMGQ2N2U0YTZmODU"
   
   --YWVhZDFlY2QzMGQ2N2U0YTZmODU
   Content-Type: multipart/alternative; boundary="3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ"
   
   --3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ
   Content-Type: text/plain; charset=UTF-8
   Content-Transfer-Encoding: quoted-printable
   
   Amazon SES Test
   
   This message was sent from Amazon SES using the SMTP interface.
   
   For more information, see:
   http://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-smtp.html
   
   --3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ
   Content-Type: text/html; charset=UTF-8
   Content-Transfer-Encoding: quoted-printable
   
   <html>
     <head>
   </head>
     <body>
       <h1>Amazon SES Test</h1>
         <p>This message was sent from Amazon SES using the SMTP interface.</p>
         <p>For more information, see
         <a ses:tags="samplekey0:samplevalue0;samplekey1:samplevalue1;" 
         href="http://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-smtp.html">
         Using the Amazon SES SMTP Interface to Send Email</a> in the <em>Amazon SES
         Developer Guide</em>.</p>
     </body>
   </html>
   --3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ--
   --YWVhZDFlY2QzMGQ2N2U0YTZmODU
   Content-Type: application/octet-stream
   MIME-Version: 1.0
   Content-Transfer-Encoding: base64
   Content-Disposition: attachment; filename="customers.txt"
   
   SUQsRmlyc3ROYW1lLExhc3ROYW1lLENvdW50cnkKMzQ4LEpvaG4sU3RpbGVzLENh
   bmFkYQo5MjM4OSxKaWUsTGl1LENoaW5hCjczNCxTaGlybGV5LFJvZHJpZ3VleixV
   bml0ZWQgU3RhdGVzCjI4OTMsQW5heWEsSXllbmdhcixJbmRpYQ==
   --YWVhZDFlY2QzMGQ2N2U0YTZmODU--
   ```

   Salve e feche o arquivo.

1. Na linha de comando, digite o seguinte comando. *sender@example.com*Substitua pelo seu endereço de e-mail e *recipient@example.com* substitua pelo endereço de e-mail do destinatário.

   ```
   sendmail -f sender@example.com recipient@example.com < mime-email.txt
   ```

   Se o comando for executado com êxito, ele será encerrado sem fornecer nenhuma saída.

1. Verifique o e-mail na sua caixa de entrada. Se a mensagem não tiver sido entregue, verifique o log de mensagens do seu sistema.

# Integração do Amazon SES com o Sendmail
<a name="send-email-sendmail"></a>

O Sendmail foi lançado no início dos anos 1980 e vem ganhando continuamente melhorias. Ele é um agente de transferência de mensagens (MTA) flexível e configurável com uma grande comunidade de usuários. O Sendmail foi adquirido pela Proofpoint em 2013, mas a Proofpoint continua oferecendo uma versão de código aberto do Sendmail. Você pode fazer download da [versão de código aberto do Sendmail](https://www.proofpoint.com/us/open-source-email-solution) no site da Proofpoint ou por meio dos gerenciadores de pacote da maioria das distribuições do Linux.

As instruções nesta seção mostram como configurar o Sendmail para enviar e-mails por meio do Amazon SES. Este procedimento foi testado em um servidor que executa o Ubuntu 18.04.2 LTS.

**nota**  
O Sendmail é uma aplicação de terceiros e não é desenvolvido nem suportado pela Amazon Web Services. Os procedimentos nesta seção são fornecidos apenas para fins informativos e estão sujeitos a alterações sem aviso prévio.

## Pré-requisitos
<a name="send-email-sendmail-prerequisites"></a>

Antes de concluir o procedimento desta seção, você deverá concluir as seguintes etapas:
+ Instalar o pacote do Sendmail no servidor. 
**nota**  
Dependendo da distribuição do sistema operacional que você usa, talvez também seja necessário instalar os seguintes pacotes: `sendmail-cf`, `m4` e `cyrus-sasl-plain`.
+ Verificar uma identidade para usar como seu endereço de remetente. Para obter mais informações, consulte [Criação da identidade de um endereço de e-mail](creating-identities.md#verify-email-addresses-procedure).

  Se sua conta for na sandbox do Amazon SES, você também deve verificar os endereços aos quais envia e-mails. Para obter mais informações, consulte [Solicitar acesso à produção (sair da sandbox do Amazon SES)](request-production-access.md).

Se estiver usando o Amazon SES para enviar e-mails de uma instância do Amazon EC2, você também deve realizar as seguintes etapas:
+ Você pode precisar atribuir um endereço de IP elástico à sua instância do Amazon EC2 para os provedores de e-mail receptores aceitarem seu e-mail. Para obter mais informações, consulte [Endereços IP elásticos do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) no *Guia do usuário do Amazon EC2*.
+ Por padrão, o Amazon Elastic Compute Cloud (Amazon EC2) restringe o tráfego de e-mail pela porta 25. Para evitar erros de tempo limite ao enviar e-mails pelo endpoint SMTP do Amazon EC2, você pode solicitar que essas restrições sejam removidas. Para obter mais informações, consulte [Como faço para remover a restrição na porta 25 da minha instância AWS Lambda ou função do Amazon EC2](https://aws.amazon.com/premiumsupport/knowledge-center/ec2-port-25-throttle/)? no Centro de AWS Conhecimento.

  Como alternativa, você pode modificar o procedimento nesta seção para usar a porta 587 em vez da porta 25.

## Configurar o Sendmail
<a name="send-email-sendmail-procedure"></a>

Conclua as etapas nesta seção para configurar o Sendmail para enviar e-mail usando o Amazon SES.

**Importante**  
O procedimento nesta seção pressupõe que você queira usar o Amazon SES no Oeste dos EUA (Oregon). Região da AWS Se você quiser usar uma região diferente, substitua todas as instâncias de *email-smtp.us-west-2.amazonaws.com* neste procedimento pelo endpoint SMTP da região desejada. Para obter uma lista de endpoints URLs SMTP em Regiões da AWS que o Amazon SES está disponível, consulte [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) no. *Referência geral da AWS*

**Para configurar o Sendmail**

1. Em um editor de arquivo, abra o arquivo `/etc/mail/authinfo`. Se o arquivo não existir, crie-o.

   Adicione a seguinte linha a*/etc/mail/authinfo*:

   ```
   AuthInfo:email-smtp.us-west-2.amazonaws.com "U:root" "I:smtpUsername" "P:smtpPassword" "M:PLAIN"
   ```

   No exemplo anterior, faça as seguintes alterações:
   + *email-smtp.us-west-2.amazonaws.com*Substitua pelo endpoint SMTP do Amazon SES que você deseja usar.
   + *smtpUsername*Substitua pelo seu nome de usuário SMTP do Amazon SES.
   + *smtpPassword*Substitua pela sua senha SMTP do Amazon SES.
**nota**  
Suas credenciais de login SMTP são diferentes da ID da chave de acesso e da chave de AWS acesso secreta. Para obter mais informações sobre como obter as credenciais de login SMTP, consulte [Obtenção de credenciais SMTP do Amazon SES](smtp-credentials.md).

   Quando terminar, salve `authinfo`.

1. Na linha de comando, digite o comando a seguir para gerar o arquivo `/etc/mail/authinfo.db`:

   ```
   sudo sh -c 'makemap hash /etc/mail/authinfo.db < /etc/mail/authinfo'
   ```

1. Na linha de comando, digite o comando a seguir para adicionar o suporte à retransmissão para o endpoint SMTP do Amazon SES.

   ```
   sudo sh -c 'echo "Connect:email-smtp.us-west-2.amazonaws.com RELAY" >> /etc/mail/access'
   ```

   No comando anterior, *email-smtp.us-west-2.amazonaws.com* substitua pelo endereço do endpoint SMTP do Amazon SES que você deseja usar.

1. Na linha de comando, digite o seguinte comando para regenerar*/etc/mail/access.db*:

   ```
   sudo sh -c 'makemap hash /etc/mail/access.db < /etc/mail/access'
   ```

1. Na linha de comando, digite o comando a seguir para criar backups dos arquivos `sendmail.cf` e `sendmail.mc`:

   ```
   sudo sh -c 'cp /etc/mail/sendmail.cf /etc/mail/sendmail_cf.backup && cp /etc/mail/sendmail.mc /etc/mail/sendmail_mc.backup'
   ```

1. Adicione as linhas a seguir ao arquivo*/etc/mail/sendmail.mc* antes de qualquer `MAILER()` definição.

   ```
   define(`SMART_HOST', `email-smtp.us-west-2.amazonaws.com')dnl
   define(`RELAY_MAILER_ARGS', `TCP $h 25')dnl
   define(`confAUTH_MECHANISMS', `LOGIN PLAIN')dnl
   FEATURE(`authinfo', `hash -o /etc/mail/authinfo.db')dnl
   MASQUERADE_AS(`example.com')dnl
   FEATURE(masquerade_envelope)dnl
   FEATURE(masquerade_entire_domain)dnl
   ```

   No texto anterior, faça o seguinte:
   + *email-smtp.us-west-2.amazonaws.com*Substitua pelo endpoint SMTP do Amazon SES que você deseja usar.
   + *example.com*Substitua pelo domínio que você deseja usar para enviar e-mails.

   Ao concluir, salve o arquivo.
**nota**  
O Amazon EC2 restringe as comunicações pela porta 25 por padrão. Se estiver usando o Sendmail em uma instância do instância do Amazon EC2, preencha a [Solicitação para remover limitações de envio de e-mail](https://aws-portal.amazon.com/gp/aws/html-forms-controller/contactus/ec2-email-limit-rdns-request).

1. Na linha de comando, digite o comando a seguir para tornar *sendmail.cf* gravável:

   ```
   sudo chmod 666 /etc/mail/sendmail.cf
   ```

1. Na linha de comando, digite o comando a seguir para gerar novamente *sendmail.cf*:

   ```
   sudo sh -c 'm4 /etc/mail/sendmail.mc > /etc/mail/sendmail.cf'
   ```
**nota**  
Se você encontrar erros como "Comando não encontrado" e "Este arquivo ou diretório não existe", verifique se os pacotes `m4` e `sendmail-cf` estão instalados em seu sistema.

1. Na linha de comando, digite o comando a seguir para redefinir as permissões de *sendmail.cf* como somente leitura:

   ```
   sudo chmod 644 /etc/mail/sendmail.cf
   ```

1. Na linha de comando, digite o comando a seguir para reiniciar o Sendmail:

   ```
   sudo /etc/init.d/sendmail restart
   ```

   *Dependendo da versão do Linux ou do Sendmail, se o indicado acima não funcionar, tente fazer o seguinte:*

   ```
   sudo su service sendmail restart
   ```

1. Conclua as etapas a seguir para enviar um e-mail de teste:

   1. Na linha de comando, insira o seguinte comando:

      ```
      /usr/sbin/sendmail -vf sender@example.com recipient@example.com
      ```

      *sender@example.com*Substitua pelo seu endereço de e-mail do remetente. *recipient@example.com*Substitua pelo endereço Para. Quando terminar, pressione Enter.

   1. Insira o conteúdo de mensagem a seguir. Pressione Enter ao final de cada linha.

      ```
      From: sender@example.com
      To: recipient@example.com
      Subject: Amazon SES test email
      
      This is a test message sent from Amazon SES using Sendmail.
      ```

      Quando terminar de inserir o conteúdo do e-mail, pressione Ctrl\$1D para enviá-lo.

1. Verifique o cliente de e-mail do destinatário para o e-mail. Se você não encontrar o e-mail, verifique a pasta de spam. Se você ainda não conseguir localizar o e-mail, verifique o log do Sendmail no servidor de e-mail. O log geralmente está localizado em*/var/log/mail.log* ou*/var/log/maillog*. 

# Integração do Amazon SES com o IIS SMTP do Microsoft Windows Server
<a name="send-email-windows-server"></a>

Você pode configurar o servidor IIS SMTP do Microsoft Windows Server para enviar e-mails pelo Amazon SES. Essas instruções foram escritas usando o Microsoft Windows Server 2022 em uma instância do Amazon EC2. Você pode usar a mesma configuração no Microsoft Windows Server 2016.

**nota**  
O Windows Server é uma aplicação de terceiros e não é desenvolvido nem suportado pela Amazon Web Services. Os procedimentos nesta seção são fornecidos apenas para fins informativos e estão sujeitos a alterações sem aviso prévio.

**Para integrar o servidor IIS SMTP do Microsoft Windows Server com o Amazon SES**

1. Primeiro, configure o Microsoft Windows Server 2022 usando as instruções a seguir.

   1. No [console de gerenciamento do Amazon EC2](https://console.aws.amazon.com/ec2/home), inicialize uma nova instância do Amazon EC2 baseada no Microsoft Windows Server 2022.

   1. Conecte-se à instância e faça login usando o Remote Desktop, seguindo as instruções em [Conceitos básicos das instâncias do Windows do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2Win_GetStarted.html).

   1. Inicie o Server Manager Dashboard.

   1. Instale a função **Web Server**. Não deixe de incluir **Ferramentas do IIS 10 Management Compatibility** (uma opção da caixa de seleção **Servidor web**).

   1. Instale o recurso **SMTP Server**.

1. Em seguida, configure o serviço IIS SMTP usando as instruções a seguir.

   1. Volte para Server Manager Dashboard.

   1. No menu **Ferramentas**, escolha **Gerenciador dos Serviços de Informações da Internet (IIS) 10.0**.

   1. Clique com o botão direito em **SMTP Virtual Server \$11** e selecione **Properties**.

   1. Na guia **Access**, em **Relay Restrictions**, escolha **Relay**.

   1. Na caixa de diálogo **Relay Restrictions**, escolha **Add**.

   1. Em **Single Computer**, insira **127.0.0.1** para o endereço IP. Você agora concedeu acesso para este servidor transmitir e-mails ao Amazon SES por meio do serviço SMTP IIS.

      Neste procedimento, consideramos que seus e-mails são gerados neste servidor. Se a aplicação que gera o e-mail for executada em um servidor separado, você deve conceder o acesso de transmissão para esse servidor no IIS SMTP.
**nota**  
Para ampliar a transmissão SMTP para sub-redes privadas, para **Relay Restriction**, use **Single Computer** 127.0.0.1 e **Group of Computers** 172.1.1.0 - 255.255.255.0 (na seção de máscara de rede). Para **Connection**, use **Single Computer** 127.0.0.1 e **Group of Computers** 172.1.1.0 - 255.255.255.0 (na seção de máscara de rede).

1. Por fim, configure o servidor para enviar e-mails pelo Amazon SES usando as instruções a seguir.

   1. Volte para a caixa de diálogo **SMTP Virtual Server \$11 Properties** e selecione a guia **Delivery**.

   1. Na guia **Delivery**, escolha **Outbound Security**.

   1. Selecione **Basic Authentication** (Autenticação básica) e, depois, insira suas credenciais SMTP do Amazon SES. Você pode obter essas credenciais do console do Amazon SES usando o procedimento em [Obtenção de credenciais SMTP do Amazon SES](smtp-credentials.md).
**Importante**  
Suas credenciais SMTP não são iguais à ID da chave de AWS acesso e à chave de acesso secreta. Não tente usar suas AWS credenciais para se autenticar no endpoint SMTP. Para obter mais informações sobre credenciais, consulte [Tipos de credenciais do Amazon SES](send-email-concepts-credentials.md).

   1. Verifique se **TLS encryption** está selecionada.

   1. Volte para a guia **Delivery**.

   1. Escolha **Outbound Connections**.

   1. Na caixa de diálogo **Outbound Connections**, verifique se a porta é 25 ou 587. 

   1. Escolha **Advanced (Avançado)**.

   1. Para nome do **Smart host (Host inteligente)**, insira o endpoint do Amazon SES que você usará (por exemplo, *email-smtp.us-west-2.amazonaws.com*). Para obter uma lista de endpoints URLs em Regiões da AWS que o Amazon SES está disponível, consulte [Amazon Simple Email Service (Amazon SES](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region)) no. *Referência geral da AWS*

   1. Volte para Server Manager Dashboard.

   1. No Server Manager Dashboard, clique com o botão direito sobre **SMTP Virtual Server \$11** e reinicie o serviço para pegar a nova configuração.

   1. Envie um e-mail por meio deste servidor. Você pode examinar os cabeçalhos da mensagem para confirmar que foi entregue pelo Amazon SES.

# Teste de sua conexão com a interface SMTP do Amazon SES usando a linha de comando
<a name="send-email-smtp-client-command-line"></a>

Você pode usar os métodos descritos nesta seção a partir da linha de comando para testar sua conexão com o endpoint SMTP do Amazon SES, validar suas credenciais SMTP e solucionar problemas de conexão. Esses procedimentos usam ferramentas e bibliotecas que estão incluídas nos sistemas operacionais mais comuns.

Para obter informações adicionais sobre como solucionar problemas de conexão SMTP, consulte [Problemas de SMTP do Amazon SES](troubleshoot-smtp.md).

## Pré-requisitos
<a name="send-email-smtp-client-command-line-prereqs"></a>

Ao conectar-se à interface SMTP do Amazon SES, é necessário fornecer um conjunto de credenciais SMTP. Essas credenciais SMTP são diferentes das suas credenciais padrão AWS . Os dois tipos de credenciais não são intercambiáveis. Para obter mais informações sobre como obter as credenciais de SMTP, consulte [Obtenção de credenciais SMTP do Amazon SES](smtp-credentials.md).

## Como testar sua conexão com a interface SMTP do Amazon SES
<a name="send-email-smtp-client-command-line-testing"></a>

É possível usar a linha de comando para testar sua conexão com a interface SMTP do Amazon SES sem autenticar e sem enviar nenhuma mensagem. Esse procedimento é útil para solucionar problemas básicos de conectividade. Se sua conexão de teste falhar, consulte [Problemas de SMTP](troubleshoot-smtp.md).

Esta seção inclui procedimentos para testar sua conexão usando o OpenSSL (que está incluído na maioria das distribuições Linux, macOS e Unix e também está disponível para Windows) e `Test-NetConnection` o cmdlet PowerShell em (incluído nas versões mais recentes do Windows).

------
#### [ Linux, macOS, or Unix ]

Há duas maneiras de se conectar à interface SMTP do Amazon SES com OpenSSL: usando SSL explícito na porta 587 ou usando SSL implícito na porta 465.

**Como se conectar à interface SMTP usando SSL explícito**
+ Na linha de comando, insira o seguinte comando para se conectar ao servidor SMTP do Amazon SES:

  ```
  openssl s_client -crlf -quiet -starttls smtp -connect email-smtp.us-west-2.amazonaws.com:587
  ```

  No comando anterior, *email-smtp.us-west-2.amazonaws.com* substitua pela URL do endpoint SMTP do Amazon SES para sua região. AWS Para obter mais informações, consulte [Regiões e o Amazon SES](regions.md).

  Se a conexão for bem-sucedida, você verá um resultado semelhante a este:

  ```
  depth=2 C = US, O = Amazon, CN = Amazon Root CA 1
  verify return:1
  depth=1 C = US, O = Amazon, OU = Server CA 1B, CN = Amazon
  verify return:1
  depth=0 CN = email-smtp.us-west-2.amazonaws.com
  verify return:1
  250 Ok
  ```

  A conexão se fecha automaticamente após cerca de 10 segundos de inatividade.

Como alternativa, é possível usar SSL implícito para se conectar à interface SMTP pela porta 465.

**Como conectar-se à interface SMTP usando SSL implícito**
+ Na linha de comando, insira o seguinte comando para se conectar ao servidor SMTP do Amazon SES:

  ```
  openssl s_client -crlf -quiet -connect email-smtp.us-west-2.amazonaws.com:465
  ```

  No comando anterior, *email-smtp.us-west-2.amazonaws.com* substitua pela URL do endpoint SMTP do Amazon SES para sua região. AWS Para obter mais informações, consulte [Regiões e o Amazon SES](regions.md).

  Se a conexão for bem-sucedida, você verá um resultado semelhante a este:

  ```
  depth=2 C = US, O = Amazon, CN = Amazon Root CA 1
  verify return:1
  depth=1 C = US, O = Amazon, OU = Server CA 1B, CN = Amazon
  verify return:1
  depth=0 CN = email-smtp.us-west-2.amazonaws.com
  verify return:1
  220 email-smtp.amazonaws.com ESMTP SimpleEmailService-d-VCSHDP1YZ A1b2C3d4E5f6G7h8I9j0
  ```

  A conexão se fecha automaticamente após cerca de 10 segundos de inatividade.

------
#### [ PowerShell ]

Você pode usar o NetConnection cmdlet [Test-](https://docs.microsoft.com/en-us/powershell/module/nettcpip/test-netconnection) PowerShell para se conectar ao servidor SMTP do Amazon SES.

**nota**  
O cmdlet `Test-NetConnection` pode determinar se o computador pode se conectar ao endpoint SMTP do Amazon SES. No entanto, isso não testa se o computador pode estabelecer uma conexão SSL implícita ou explícita com o endpoint SMTP. Para testar uma conexão SSL, é possível instalar o OpenSSL para Windows para enviar um e-mail de teste.

**Como conectar-se à interface SMTP usando o cmdlet `Test-NetConnection`**
+ Em PowerShell, insira o seguinte comando para se conectar ao servidor SMTP do Amazon SES:

  ```
  Test-NetConnection -Port 587 -ComputerName email-smtp.us-west-2.amazonaws.com
  ```

  No comando anterior, *email-smtp.us-west-2.amazonaws.com* substitua pela URL do endpoint SMTP do Amazon SES da sua AWS região e *587* substitua pelo número da porta. Para obter mais informações sobre endpoints regionais no Amazon SES, consulte [Regiões e o Amazon SES](regions.md).

  Se a conexão foi bem-sucedida, é exibida uma saída semelhante a este exemplo:

  ```
  ComputerName     : email-smtp.us-west-2.amazonaws.com
  RemoteAddress    : 198.51.100.126
  RemotePort       : 587
  InterfaceAlias   : Ethernet
  SourceAddress    : 203.0.113.46
  TcpTestSucceeded : True
  ```

------

## Uso da linha de comando para enviar e-mail usando a interface SMTP do Amazon SES
<a name="send-email-using-openssl"></a>

Também é possível usar a linha de comando para enviar mensagens usando a interface SMTP do Amazon SES. Esse procedimento é útil para testar credenciais SMTP e para testar a capacidade de destinatários específicos receberem mensagens enviadas usando o Amazon SES.

------
#### [ Linux, macOS, or Unix ]

Quando um remetente de e-mail se conecta a um servidor SMTP, o cliente envia um conjunto padrão de solicitações e o servidor responde a cada solicitação com uma resposta padrão. Esta série de solicitações e respostas é chamada de *conversa SMTP*. Quando você se conecta ao servidor SMTP do Amazon SES usando o OpenSSL, o servidor espera que ocorra uma conversa SMTP.

Ao usar o OpenSSL para se conectar à interface SMTP, é necessário codificar suas credenciais SMTP usando a codificação em base64. Esta seção inclui procedimentos para a codificação das credenciais usando base64.

**Para enviar um e-mail da linha de comando usando a interface SMTP**

1. Digite o seguinte na linha de comando e *email-smtp.us-west-2.amazonaws.com* substitua pela URL do endpoint SMTP do Amazon SES para o seu. Região da AWS Para obter mais informações, consulte[Regiões e o Amazon SES](regions.md). :

   ```
    1. #!/bin/bash
    2. 
    3. # Prompt user to provide following information
    4. read -p "Configuration set: " CONFIGSET
    5. read -p "Enter SMTP username: " SMTPUsername
    6. read -p "Enter SMTP password: " SMTPPassword
    7. read -p "Sender email address: " MAILFROM
    8. read -p "Receiver email address: " RCPT
    9. read -p "Email subject: " SUBJECT
   10. read -p "Message to send: " DATA
   11. 
   12. echo
   13. 
   14. # Encode SMTP username and password using base64
   15. EncodedSMTPUsername=$(echo -n "$SMTPUsername" | openssl enc -base64)
   16. EncodedSMTPPassword=$(echo -n "$SMTPPassword" | openssl enc -base64)
   17. 
   18. # Construct the email
   19. Email="EHLO example.com
   20. AUTH LOGIN
   21. $EncodedSMTPUsername
   22. $EncodedSMTPPassword
   23. MAIL FROM: $MAILFROM
   24. RCPT TO: $RCPT
   25. DATA
   26. X-SES-CONFIGURATION-SET: $CONFIGSET
   27. From: $MAILFROM
   28. To: $RCPT
   29. Subject: $SUBJECT
   30. 
   31. $DATA
   32. .
   33. QUIT"
   34. 
   35. echo "$Email" | openssl s_client -crlf -quiet -starttls smtp -connect email-smtp.us-west-2.amazonaws.com:587
   ```

1. No prompt de cada variável, insira seus valores.

1. 
   + Para enviar usando SSL implícito pela porta 465, use:

     ```
     openssl s_client -crlf -quiet -connect email-smtp.us-west-2.amazonaws.com:465
     ```

   Se a mensagem tiver sido aceita pelo Amazon SES, você verá uma saída semelhante ao seguinte exemplo:

   ```
   250 Ok 01010160d7de98d8-21e57d9a-JZho-416c-bbe1-8ebaAexample-000000
   ```

   A sequência de números e texto que se segue a `250 Ok` é o ID de mensagem do e-mail.
**nota**  
A conexão é fechada automaticamente após cerca de 10 segundos de inatividade.

------
#### [ PowerShell ]

Você pode usar o [Net.Mail. SmtpClient](https://docs.microsoft.com/en-us/dotnet/api/system.net.mail.smtpclient?view=netframework-4.8)classe para enviar e-mail usando SSL explícito pela porta 587.

**nota**  
A classe `Net.Mail.SmtpClient` está oficialmente obsoleta e a Microsoft recomenda o uso de bibliotecas de terceiros. Este código destina-se somente para fins de teste e não deve ser usado para cargas de trabalho de produção.

**Para enviar um e-mail PowerShell usando SSL explícito**

1. Em um editor de texto, crie um novo arquivo. Cole o seguinte código no arquivo:

   ```
   function SendEmail($Server, $Port, $Sender, $Recipient, $Subject, $Body) {
       $Credentials = [Net.NetworkCredential](Get-Credential)
   
       $SMTPClient = New-Object Net.Mail.SmtpClient($Server, $Port)
       $SMTPClient.EnableSsl = $true
       $SMTPClient.Credentials = New-Object System.Net.NetworkCredential($Credentials.Username, $Credentials.Password);
   
       try {
           Write-Output "Sending message..."
           $SMTPClient.Send($Sender, $Recipient, $Subject, $Body)
           Write-Output "Message successfully sent to $($Recipient)"
       } catch [System.Exception] {
           Write-Output "An error occurred:"
           Write-Error $_
       }
   }
   
   function SendTestEmail(){
       $Server = "email-smtp.us-west-2.amazonaws.com"
       $Port = 587
   
       $Subject = "Test email sent from Amazon SES"
       $Body = "This message was sent from Amazon SES using PowerShell (explicit SSL, port 587)."
   
       $Sender = "sender@example.com"
       $Recipient = "recipient@example.com"
   
       SendEmail $Server $Port $Sender $Recipient $Subject $Body
   }
   
   SendTestEmail
   ```

   Ao concluir, salve o arquivo como `SendEmail.ps1`.

1. Faça as seguintes alterações no arquivo que você criou na etapa anterior:
   + *sender@example.com*Substitua pelo endereço de e-mail do qual você deseja enviar a mensagem.
   + *recipient@example.com*Substitua pelo endereço de e-mail para o qual você deseja enviar a mensagem.
   + *email-smtp.us-west-2.amazonaws.com*Substitua pela URL do endpoint SMTP do Amazon SES para sua AWS região. Para obter mais informações, consulte [Regiões e o Amazon SES](regions.md).

1. Em PowerShell, digite o seguinte comando:

   ```
   .\path\to\SendEmail.ps1
   ```

   No comando anterior, *path\$1to\$1SendEmail.ps1* substitua pelo caminho para o arquivo que você criou na etapa 1.

1. Quando solicitado, insira o nome de usuário e senha do SMTP.

Como alternativa, você pode usar o [System.Web.Mail. SmtpMail](https://docs.microsoft.com/en-us/dotnet/api/system.web.mail.smtpmail?view=netframework-4.8)classe para enviar e-mail usando SSL implícito pela porta 465.

**nota**  
A classe `System.Web.Mail.SmtpMail` está oficialmente obsoleta e a Microsoft recomenda o uso de bibliotecas de terceiros. Este código destina-se somente para fins de teste e não deve ser usado para cargas de trabalho de produção.

**Para enviar um e-mail PowerShell usando SSL implícito**

1. Em um editor de texto, crie um novo arquivo. Cole o seguinte código no arquivo:

   ```
   [System.Reflection.Assembly]::LoadWithPartialName("System.Web") > $null
   
   function SendEmail($Server, $Port, $Sender, $Recipient, $Subject, $Body) {
       $Credentials = [Net.NetworkCredential](Get-Credential)
   
       $mail = New-Object System.Web.Mail.MailMessage
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpserver", $Server)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpserverport", $Port)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpusessl", $true)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername", $Credentials.UserName)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword", $Credentials.Password)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpconnectiontimeout", $timeout / 1000)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusing", 2)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate", 1)
   
       $mail.From = $Sender
       $mail.To = $Recipient
       $mail.Subject = $Subject
       $mail.Body = $Body
   
       try {
           Write-Output "Sending message..."
           [System.Web.Mail.SmtpMail]::Send($mail)
           Write-Output "Message successfully sent to $($Recipient)"
       } catch [System.Exception] {
           Write-Output "An error occurred:"
           Write-Error $_
       }
   }
   
   function SendTestEmail(){
       $Server = "email-smtp.us-west-2.amazonaws.com"
       $Port = 465
       
       $Subject = "Test email sent from Amazon SES"
       $Body = "This message was sent from Amazon SES using PowerShell (implicit SSL, port 465)."
   
       $Sender = "sender@example.com"
       $Recipient = "recipient@example.com"
   
       SendEmail $Server $Port $Sender $Recipient $Subject $Body
   }
   
   SendTestEmail
   ```

   Ao concluir, salve o arquivo como `SendEmail.ps1`.

1. Faça as seguintes alterações no arquivo que você criou na etapa anterior:
   + *sender@example.com*Substitua pelo endereço de e-mail do qual você deseja enviar a mensagem.
   + *recipient@example.com*Substitua pelo endereço de e-mail para o qual você deseja enviar a mensagem.
   + *email-smtp.us-west-2.amazonaws.com*Substitua pela URL do endpoint SMTP do Amazon SES para sua AWS região. Para obter mais informações, consulte [Regiões e o Amazon SES](regions.md).

1. Em PowerShell, digite o seguinte comando:

   ```
   .\path\to\SendEmail.ps1
   ```

   No comando anterior, *path\$1to\$1SendEmail.ps1* substitua pelo caminho para o arquivo que você criou na etapa 1.

1. Quando solicitado, insira o nome de usuário e senha do SMTP.

------

# Uso da API do Amazon SES para enviar e-mail
<a name="send-email-api"></a>

Para enviar e-mail de produção pelo Amazon SES, você pode usar a interface SMTP (Simple Mail Transfer Protocol) ou a API do Amazon SES. Para obter mais informações sobre a interface SMTP, consulte [Uso da interface SMTP do Amazon SES para enviar e-mail](send-email-smtp.md). Esta seção descreve como enviar e-mails usando a API. 

Ao enviar um e-mail usando a API do Amazon SES, especifique o conteúdo da mensagem, e o Amazon SES montará um e-mail MIME para você. Alternativamente, você mesmo pode montar o e-mail para que tenha controle total sobre o conteúdo da mensagem. Para obter informações sobre a API, consulte a [Referência da API do Amazon Simple Email Service](https://docs.aws.amazon.com/ses/latest/APIReference/). Para obter uma lista de endpoints URLs em Regiões da AWS que o Amazon SES está disponível, consulte os [endpoints e cotas do Amazon Simple Email Service](https://docs.aws.amazon.com/general/latest/gr/ses.html) no. *Referência geral da AWS*

Você pode chamar a API das seguintes maneiras:
+ **Fazer solicitações HTTPS diretas**: este é o método mais avançado, porque é necessário lidar manualmente com a autenticação e a assinatura de suas solicitações e, depois, criá-las manualmente. Para obter informações sobre a API do Amazon SES, consulte a página [Boas-vindas](https://docs.aws.amazon.com/ses/latest/APIReference-V2/Welcome.html) na *Referência da API v2*.
+ **Use um AWS SDK —**AWS SDKs facilite o APIs acesso a vários AWS serviços, incluindo o Amazon SES. Quando você usa um SDK, ele se encarrega de tarefas como autenticação, assinatura de solicitações, lógica de novas tentativas, manipulação de erros, bem como de outras funções de baixo nível, para que possa se concentrar na criação de aplicativos que conquistem seus clientes.
+ **Usar uma interface de linha de comando**: a [AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é a ferramenta da linha de comando para o Amazon SES. Também oferecemos as [AWS ferramentas PowerShell para](https://aws.amazon.com/powershell/) quem cria scripts no PowerShell ambiente.

Independentemente de você acessar a API do Amazon SES direta ou indiretamente por meio de um AWS SDK, do AWS Command Line Interface ou das AWS ferramentas para PowerShell, a API do Amazon SES fornece duas maneiras diferentes de enviar um e-mail, dependendo de quanto controle você deseja sobre a composição da mensagem de e-mail:
+ **Formatado**: o Amazon SES redige e envia uma mensagem de e-mail formatada corretamente. Você precisa apenas fornecer os endereços "From:" (De) e "To:" (Para), um assunto e um corpo da mensagem. O Amazon SES cuida de todo o resto. Para obter mais informações, consulte [Envio de e-mail formatado usando a API do Amazon SES](send-email-formatted.md).
+ **Bruto**: você compõe manualmente e envia uma mensagem de e-mail, especificando seus próprios cabeçalhos de e-mail e tipos de MIME. Se você é experiente na formatação do seu próprio e-mail, a interface bruta da a você mais controle sobre a composição da mensagem. Para obter mais informações, consulte [Envio de e-mail bruto usando a API v2 do Amazon SES](send-email-raw.md).

**Topics**
+ [Envio de e-mail formatado usando a API do Amazon SES](send-email-formatted.md)
+ [Envio de e-mail bruto usando a API v2 do Amazon SES](send-email-raw.md)
+ [Como usar modelos para enviar e-mails personalizados com a API do Amazon SES](send-personalized-email-api.md)
+ [Envio de e-mail pelo Amazon SES usando um AWS SDK](send-an-email-using-sdk-programmatically.md)
+ [Codificações de conteúdo compatíveis com o Amazon SES](content-encodings.md)

# Envio de e-mail formatado usando a API do Amazon SES
<a name="send-email-formatted"></a>

Você pode enviar um e-mail formatado usando Console de gerenciamento da AWS ou chamando a API do Amazon SES por meio de um aplicativo, direta ou indiretamente, por meio de um AWS SDK AWS Command Line Interface, do ou do. AWS Tools for Windows PowerShell

A API do Amazon SES fornece a ação `SendEmail`, que permite redigir e enviar um e-mail formatado. `SendEmail` requer um endereço From: (De:), um endereço To: (Para:), o assunto da mensagem e o corpo da mensagem, em texto, HTML ou ambos. Para obter mais informações, consulte [SendEmail](https://docs.aws.amazon.com/ses/latest/APIReference/API_SendEmail.html)(Referência da API) ou [SendEmail](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html)(Referência da API v2).

**nota**  
A string do endereço de e-mail deve ter o formato ASCII de 7 bits. Se você deseja enviar para ou de endereços de e-mail que contêm caracteres Unicode na parte de domínio de um endereço, você deve codificar o domínio usando Punycode. Para obter mais informações, consulte [RFC 3492](https://tools.ietf.org/html/rfc3492).

Para obter exemplos de como redigir uma mensagem formatada usando várias linguagens de programação, consulte [Exemplos de código](send-an-email-using-sdk-programmatically.md#send-an-email-using-sdk-programmatically-examples).

Para obter dicas sobre como aumentar a velocidade de envio de e-mail ao fazer várias chamadas para `SendEmail`, consulte [Aumento da taxa de transferência com o Amazon SES](troubleshoot-throughput-problems.md).

# Envio de e-mail bruto usando a API v2 do Amazon SES
<a name="send-email-raw"></a>

Você pode usar a operação `SendEmail` da API v2 do Amazon SES com o tipo de conteúdo especificado como `raw` para enviar mensagens personalizadas aos seus destinatários usando o formato de e-mail bruto.

## Sobre campos do cabeçalho do e-mail
<a name="send-email-raw-headers"></a>

O SMTP (Simple Mail Transfer Protocol) especifica como as mensagens de e-mail devem ser enviadas ao definir o envelope de e-mail e alguns de seus parâmetros, mas não se preocupa com o conteúdo da mensagem. Em vez disso, o Internet Message Format ([RFC 5322](https://www.ietf.org/rfc/rfc5322.txt)) define como a mensagem será construída.

Com a especificação do Internet Message Format, todas as mensagens de e-mail consistem em um cabeçalho e um corpo. O cabeçalho consiste em metadados de mensagem e o corpo contém a mensagem em si. Para obter mais informações sobre cabeçalhos e corpos de e-mail, consulte [Formato de e-mail e Amazon SES](send-email-concepts-email-format.md).

## Usar a construção de mensagens MIME de e-mail bruto
<a name="send-email-raw-mime"></a>

O protocolo SMTP foi originalmente projetado para enviar mensagens de e-mail que continham apenas caracteres ASCII de 7 bits. Essa especificação torna o SMTP insuficiente para codificações de texto não ASCII (como Unicode), conteúdo binário ou anexos. O padrão MIME (Multipurpose Internet Mail Extensions) foi desenvolvido para possibilitar o envio de vários outros tipos de conteúdo usando SMTP.

O padrão MIME funciona ao dividir o corpo da mensagem em várias partes e especificar o que será feito com cada parte. Por exemplo, uma parte do corpo da mensagem do e-mail pode ser texto simples, enquanto outra pode ser HTML. Além disso, o MIME permite que mensagens de e-mail contenham um ou mais anexos. Os destinatários da mensagem podem visualizar os anexos de dentro de seus clientes de e-mail ou podem salvar os anexos.

O cabeçalho e o conteúdo da mensagem são separados por uma linha em branco. Cada parte do e-mail é separada por um limite, uma string de caracteres que indica o início e o fim de cada parte.

A mensagem de várias partes no exemplo a seguir contém uma parte em texto e uma parte em HTML, além de um anexo. O anexo deve ser colocado logo abaixo dos [cabeçalhos do anexo](#send-email-mime-encoding-files) e geralmente é codificado em `base64`, conforme mostrado neste exemplo.

```
 1. From: "Sender Name" <sender@example.com>
 2. To: recipient@example.com
 3. Subject: Customer service contact info
 4. Content-Type: multipart/mixed;
 5.     boundary="a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a"
 6. 
 7. --a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
 8. Content-Type: multipart/alternative;
 9.     boundary="sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a"
10. 
11. --sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
12. Content-Type: text/plain; charset=iso-8859-1
13. Content-Transfer-Encoding: quoted-printable
14. 
15. Please see the attached file for a list of customers to contact.
16. 
17. --sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
18. Content-Type: text/html; charset=iso-8859-1
19. Content-Transfer-Encoding: quoted-printable
20. 
21. <html>
22. <head></head>
23. <body>
24. <h1>Hello!</h1>
25. <p>Please see the attached file for a list of customers to contact.</p>
26. </body>
27. </html>
28. 
29. --sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a--
30. 
31. --a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
32. Content-Type: text/plain; name="customers.txt"
33. Content-Description: customers.txt
34. Content-Disposition: attachment;filename="customers.txt";
35.     creation-date="Sat, 05 Aug 2017 19:35:36 GMT";
36. Content-Transfer-Encoding: base64
37. 
38. SUQsRmlyc3ROYW1lLExhc3ROYW1lLENvdW50cnkKMzQ4LEpvaG4sU3RpbGVzLENhbmFkYQo5MjM4
39. OSxKaWUsTGl1LENoaW5hCjczNCxTaGlybGV5LFJvZHJpZ3VleixVbml0ZWQgU3RhdGVzCjI4OTMs
40. QW5heWEsSXllbmdhcixJbmRpYQ==
41. 
42. --a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a--
```

O tipo de conteúdo para a mensagem é `multipart/mixed`, o que indica que a mensagem tem várias partes (neste exemplo, um corpo e um anexo) e o cliente do recebimento deve lidar com cada parte separadamente.

Aninhada dentro da seção do corpo está uma segunda parte que usa o tipo de conteúdo `multipart/alternative`. Esse tipo de conteúdo indica que cada parte contém versões alternativas do mesmo conteúdo (neste caso, uma versão em texto e uma versão HTML). Se o cliente de e-mail do destinatário puder exibir o conteúdo HTML, ele mostrará a versão HTML do corpo da mensagem. Se o cliente de e-mail do destinatário não puder exibir o conteúdo HTML, ele mostrará a versão de texto sem formatação do corpo da mensagem.

As duas versões da mensagem também contêm um anexo (neste caso, um arquivo de texto que contém alguns nomes de clientes).

Quando você aninha uma parte de MIME dentro de outra parte, como neste exemplo, a parte aninhada deve usar um parâmetro `boundary` diferente do parâmetro `boundary` na parte pai. Esses limites devem ser strings de caracteres exclusivas. Para definir um limite entre as partes MIME, digite dois hifens (--) seguidos pela string de limite. No final de uma parte MIME, coloque dois hifens no início e no final da string do limite.

**nota**  
Uma mensagem não pode ter mais de 500 partes de MIME.

### Codificação MIME
<a name="send-email-mime-encoding"></a>

Para manter a compatibilidade com sistemas mais antigos, o Amazon SES respeita a limitação ASCII de 7 bits do SMTP, conforme definido na [RFC 2821](https://tools.ietf.org/html/rfc2821). Se você deseja enviar conteúdo que contém caracteres não ASCII, você deve codificar os caracteres em um formato que usa caracteres ASCII de 7 bits.

#### Endereços de e-mail
<a name="send-email-mime-encoding-addresses"></a>

A string do endereço de e-mail deve ter o formato ASCII de 7 bits. Se você deseja enviar para ou de endereços de e-mail que contêm caracteres Unicode na parte de domínio de um endereço, você deve codificar o domínio usando Punycode. Punycode não é permitido na parte local do endereço de e-mail (na parte antes de @) nem no nome "amigável de". Se você deseja usar caracteres Unicode no nome “amigável”, deve codificá-lo usando a sintaxe de palavras codificadas MIME, conforme descrito nesta seção. Para obter mais informações sobre Punycode, consulte [RFC 3492](http://tools.ietf.org/html/rfc3492).

**nota**  
Essa regra se aplica somente aos endereços de e-mail que você especifica no envelope da mensagem, não nos cabeçalhos das mensagens. Quando você usa a operação `SendEmail` da API v2 do Amazon SES, os endereços especificados nos parâmetros `Source` e `Destinations` definem o remetente e os destinatários do envelope, respectivamente.

#### Cabeçalhos de e-mail
<a name="send-email-mime-encoding-headers"></a>

Para codificar um cabeçalho de mensagem, use a sintaxe de palavras codificadas por MIME. A sintaxe de palavras codificadas por MIME usa o seguinte formato:

```
=?charset?encoding?encoded-text?=
```

O valor de `encoding` pode ser `Q` ou `B`. Se o valor da codificação for `Q`, o valor `encoded-text` deverá usar a codificação Q. Se o valor da codificação for `B`, o valor de `encoded-text` deverá usar a codificação base64.

Por exemplo, se você deseja usar a sequência "Як ти поживаєш?" na linha de assunto do e-mail, você pode usar uma das seguintes codificações:
+ **Codificação Q**

  ```
  =?utf-8?Q?=D0=AF=D0=BA_=D1=82=D0=B8_=D0=BF=D0=BE=D0=B6=D0=B8=D0=B2=D0=B0=D1=94=D1=88=3F?=
  ```
+ **Codificação base64**

  ```
  =?utf-8?B?0K/QuiDRgtC4INC/0L7QttC40LLQsNGU0Yg/?=
  ```

Para obter mais informações sobre a codificação Q, consulte a [RFC 2047](https://tools.ietf.org/html/rfc2047). Para obter mais informações sobre a codificação base64, consulte a [RFC 2045](https://tools.ietf.org/html/rfc2045).

#### Corpo da mensagem
<a name="send-email-mime-encoding-body"></a>

Para codificar o corpo de uma mensagem, você pode usar a codificação imprimível citada ou a codificação base64. Em seguida, use o cabeçalho `Content-Transfer-Encoding` para indicar qual esquema de codificação você usou.

Por exemplo, suponha que o corpo da mensagem contém o seguinte texto: 

१९७२ मे रे टॉमलिंसन ने पहला ई-मेल संदेश भेजा \$1 रे टॉमलिंसन ने ही सर्वप्रथम @ चिन्ह का चयन किया और इन्ही को ईमेल का आविष्कारक माना जाता है

Se você escolher codificar esse texto usando a codificação base64, primeiro especifique o seguinte cabeçalho:

```
Content-Transfer-Encoding: base64
```

Em seguida, na seção do corpo do e-mail, inclua o texto codificado em base64:

```
4KWn4KWv4KWt4KWoIOCkruClhyDgpLDgpYcg4KSf4KWJ4KSu4KSy4KS/4KSC4KS44KSoIOCkqOCl
hyDgpKrgpLngpLLgpL4g4KSILeCkruClh+CksiDgpLjgpILgpKbgpYfgpLYg4KSt4KWH4KSc4KS+
IHwg4KSw4KWHIOCkn+ClieCkruCksuCkv+CkguCkuOCkqCDgpKjgpYcg4KS54KWAIOCkuOCksOCl
jeCkteCkquCljeCksOCkpeCkriBAIOCkmuCkv+CkqOCljeCkuSDgpJXgpL4g4KSa4KSv4KSoIOCk
leCkv+Ckr+CkviDgpJTgpLAg4KSH4KSo4KWN4KS54KWAIOCkleCliyDgpIjgpK7gpYfgpLIg4KSV
4KS+IOCkhuCkteCkv+Ckt+CljeCkleCkvuCksOCklSDgpK7gpL7gpKjgpL4g4KSc4KS+4KSk4KS+
IOCkueCliAo=
```

**nota**  
Em alguns casos, você pode usar `Content-Transfer-Encoding` de 8 bits em mensagens enviadas usando o Amazon SES. No entanto, se o Amazon SES tiver de fazer alguma alteração nas suas mensagens (por exemplo, quando você usa o [rastreamento de abertura e clique](faqs-metrics.md)), o conteúdo codificado de 8 bits pode não aparecer corretamente quando chega nas caixas de entrada dos destinatários. Por esse motivo, você deve sempre codificar o conteúdo que não seja ASCII de 7 bits.

#### Anexos de arquivo
<a name="send-email-mime-encoding-files"></a>

Para anexar um arquivo a um email, você precisa codificar o anexo usando a codificação base64. Normalmente, os anexos são colocados em partes dedicadas da mensagem MIME, que incluem os seguintes cabeçalhos:
+ **Content-Type**: o tipo de arquivo do anexo. Veja a seguir exemplos de declarações comuns de Content-Type MIME:
  + **Arquivo de texto sem formatação)**: `Content-Type: text/plain; name="sample.txt"`
  + **Documento do Microsoft Word**: `Content-Type: application/msword; name="document.docx"`
  + **Imagem JPG**: `Content-Type: image/jpeg; name="photo.jpeg"`
+ **Content-Disposition**: especifica como o cliente de e-mail do destinatário deve lidar com o conteúdo. Para anexos, esse valor é `Content-Disposition: attachment`.
+ **Content-Transfer-Encoding**: o esquema usado para codificar o anexo. Para anexos de arquivo, esse valor é quase sempre `base64`.
+ **O anexo codificado**: você deve codificar o anexo real e incluí-lo no corpo abaixo dos cabeçalhos do anexo, conforme [mostrado no exemplo](#send-email-raw-mime).

O Amazon SES aceita a maioria dos tipos de arquivos comuns. Para obter uma lista de tipos de arquivo que o Amazon SES não aceita, consulte [Tipos de anexo incompatíveis com o SES](attachments.md#mime-types).

## Envio de e-mail bruto usando a API v2 do Amazon SES
<a name="send-email-raw-api"></a>

A API v2 do Amazon SES fornece a ação `SendEmail`, que permite compor e enviar uma mensagem de e-mail no formato especificado quando você define o tipo de conteúdo como simples, bruto ou modelado. Para obter uma descrição completa, consulte [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html). O exemplo a seguir especificará o tipo de conteúdo como `raw` para enviar uma mensagem usando o formato de e-mail bruto.

**nota**  
Para obter dicas sobre como aumentar a velocidade de envio de e-mail ao fazer várias chamadas para `SendEmail`, consulte [Aumento da taxa de transferência com o Amazon SES](troubleshoot-throughput-problems.md).

O corpo da mensagem deve conter uma mensagem de e-mail bruto corretamente formatada, com a codificação adequada dos campos de cabeçalho e do corpo da mensagem. Embora seja possível construir a mensagem bruta manualmente dentro de uma aplicação, é muito mais fácil usar as bibliotecas de e-mail existentes. 

------
#### [ Java ]

O exemplo de código a seguir mostra como usar a [JavaMail](https://javaee.github.io/javamail/)biblioteca e a [AWS SDK para Java](https://aws.amazon.com/sdk-for-java)para redigir e enviar um e-mail bruto.

```
  1. package com.amazonaws.samples;
  2. 
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.IOException;
  5. import java.io.PrintStream;
  6. import java.nio.ByteBuffer;
  7. import java.util.Properties;
  8. 
  9. // JavaMail libraries. Download the JavaMail API 
 10. // from https://javaee.github.io/javamail/
 11. import javax.activation.DataHandler;
 12. import javax.activation.DataSource;
 13. import javax.activation.FileDataSource;
 14. import javax.mail.Message;
 15. import javax.mail.MessagingException;
 16. import javax.mail.Session;
 17. import javax.mail.internet.AddressException;
 18. import javax.mail.internet.InternetAddress;
 19. import javax.mail.internet.MimeBodyPart;
 20. import javax.mail.internet.MimeMessage;
 21. import javax.mail.internet.MimeMultipart;
 22. 
 23. // AWS SDK libraries. Download the AWS SDK para Java // from https://aws.amazon.com/sdk-for-java
 24. import com.amazonaws.regions.Regions;
 25. import com.amazonaws.services.simpleemail.AmazonSimpleEmailService;
 26. import com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceClientBuilder;
 27. import com.amazonaws.services.simpleemail.model.RawMessage;
 28. import com.amazonaws.services.simpleemail.model.SendRawEmailRequest;
 29. 
 30. public class AmazonSESSample {
 31. 
 32. 	// Replace sender@example.com with your "From" address.
 33. 	// This address must be verified with Amazon SES.
 34. 	private static String SENDER = "Sender Name <sender@example.com>";
 35. 
 36. 	// Replace recipient@example.com with a "To" address. If your account 
 37. 	// is still in the sandbox, this address must be verified.
 38. 	private static String RECIPIENT = "recipient@example.com";
 39. 
 40. 	// Specify a configuration set. If you do not want to use a configuration
 41. 	// set, comment the following variable, and the 
 42. 	// ConfigurationSetName=CONFIGURATION_SET argument below.
 43. 	private static String CONFIGURATION_SET = "ConfigSet";
 44. 
 45. 	// The subject line for the email.
 46. 	private static String SUBJECT = "Customer service contact info";
 47. 
 48. 	// The full path to the file that will be attached to the email.
 49. 	// If you're using Windows, escape backslashes as shown in this variable.
 50. 	private static String ATTACHMENT = "C:\\Users\\sender\\customers-to-contact.xlsx";
 51. 
 52. 	// The email body for recipients with non-HTML email clients.
 53. 	private static String BODY_TEXT = "Hello,\r\n"
 54.                                         + "Please see the attached file for a list "
 55.                                         + "of customers to contact.";
 56. 
 57. 	// The HTML body of the email.
 58. 	private static String BODY_HTML = "<html>"
 59.                                         + "<head></head>"
 60.                                         + "<body>"
 61.                                         + "<h1>Hello!</h1>"
 62.                                         + "<p>Please see the attached file for a "
 63.                                         + "list of customers to contact.</p>"
 64.                                         + "</body>"
 65.                                         + "</html>";
 66. 
 67.     public static void main(String[] args) throws AddressException, MessagingException, IOException {
 68.             	
 69.     	Session session = Session.getDefaultInstance(new Properties());
 70.         
 71.         // Create a new MimeMessage object.
 72.         MimeMessage message = new MimeMessage(session);
 73.         
 74.         // Add subject, from and to lines.
 75.         message.setSubject(SUBJECT, "UTF-8");
 76.         message.setFrom(new InternetAddress(SENDER));
 77.         message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(RECIPIENT));
 78. 
 79.         // Create a multipart/alternative child container.
 80.         MimeMultipart msg_body = new MimeMultipart("alternative");
 81.         
 82.         // Create a wrapper for the HTML and text parts.        
 83.         MimeBodyPart wrap = new MimeBodyPart();
 84.         
 85.         // Define the text part.
 86.         MimeBodyPart textPart = new MimeBodyPart();
 87.         textPart.setContent(BODY_TEXT, "text/plain; charset=UTF-8");
 88.                 
 89.         // Define the HTML part.
 90.         MimeBodyPart htmlPart = new MimeBodyPart();
 91.         htmlPart.setContent(BODY_HTML,"text/html; charset=UTF-8");
 92.                 
 93.         // Add the text and HTML parts to the child container.
 94.         msg_body.addBodyPart(textPart);
 95.         msg_body.addBodyPart(htmlPart);
 96.         
 97.         // Add the child container to the wrapper object.
 98.         wrap.setContent(msg_body);
 99.         
100.         // Create a multipart/mixed parent container.
101.         MimeMultipart msg = new MimeMultipart("mixed");
102.         
103.         // Add the parent container to the message.
104.         message.setContent(msg);
105.         
106.         // Add the multipart/alternative part to the message.
107.         msg.addBodyPart(wrap);
108.         
109.         // Define the attachment
110.         MimeBodyPart att = new MimeBodyPart();
111.         DataSource fds = new FileDataSource(ATTACHMENT);
112.         att.setDataHandler(new DataHandler(fds));
113.         att.setFileName(fds.getName());
114.         
115.         // Add the attachment to the message.
116.         msg.addBodyPart(att);
117. 
118.         // Try to send the email.
119.         try {
120.             System.out.println("Attempting to send an email through Amazon SES "
121.                               +"using the AWS SDK for Java...");
122. 
123.             // Instantiate an Amazon SES client, which will make the service 
124.             // call with the supplied AWS credentials.
125.             AmazonSimpleEmailService client = 
126.                     AmazonSimpleEmailServiceClientBuilder.standard()
127.                     // Replace US_WEST_2 with the AWS Region you're using for
128.                     // Amazon SES.
129.                     .withRegion(Regions.US_WEST_2).build();
130.             
131.             // Print the raw email content on the console
132.             PrintStream out = System.out;
133.             message.writeTo(out);
134. 
135.             // Send the email.
136.             ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
137.             message.writeTo(outputStream);
138.             RawMessage rawMessage = 
139.             		new RawMessage(ByteBuffer.wrap(outputStream.toByteArray()));
140. 
141.             SendRawEmailRequest rawEmailRequest = 
142.             		new SendRawEmailRequest(rawMessage)
143.             		    .withConfigurationSetName(CONFIGURATION_SET);
144.             
145.             client.sendRawEmail(rawEmailRequest);
146.             System.out.println("Email sent!");
147.         // Display an error if something goes wrong.
148.         } catch (Exception ex) {
149.           System.out.println("Email Failed");
150.             System.err.println("Error message: " + ex.getMessage());
151.             ex.printStackTrace();
152.         }
153.     }
154. }
```

------
#### [ Python ]

O código de exemplo a seguir mostra como usar os pacotes [Python email.mime](https://docs.python.org/3.8/library/email.mime.html) e o [AWS SDK para Python (Boto)](https://aws.amazon.com/sdk-for-python) para compor e enviar um e-mail bruto.

```
 1. import json
 2. import boto3
 3. from botocore.exceptions import ClientError
 4. from email.mime.multipart import MIMEMultipart
 5. from email.mime.text import MIMEText
 6. from email.mime.application import MIMEApplication
 7. import os
 8. 
 9. def boto3_rawemailv2():
10.     SENDER = "Sender <sender@example.com>"
11.     RECIPIENT = "recipient@example.com"
12.     CONFIGURATION_SET = "ConfigSet"
13.     AWS_REGION = "us-east-1"
14.     SUBJECT = "Customer service contact info"
15.     ATTACHMENT = "path/to/customers-to-contact.xlsx"
16.     BODY_TEXT = "Hello,\r\nPlease see the attached file for a list of customers to contact."
17. 
18.     # The HTML body of the email.
19.     BODY_HTML = """\
20.     <html>
21.     <head/>
22.     <body>
23.     <h1>Hello!</h1>
24.     <p>Please see the attached file for a list of customers to contact.</p>
25.     </body>
26.     </html>
27.     """
28. 
29.     # The character encoding for the email.
30.     CHARSET = "utf-8"
31.     msg = MIMEMultipart('mixed')
32.     # Add subject, from and to lines.
33.     msg['Subject'] = SUBJECT 
34.     msg['From'] = SENDER 
35.     msg['To'] = RECIPIENT
36.     
37.     # Create a multipart/alternative child container.
38.     msg_body = MIMEMultipart('alternative')
39.     
40.     # Encode the text and HTML content and set the character encoding. This step is
41.     # necessary if you're sending a message with characters outside the ASCII range.
42.     textpart = MIMEText(BODY_TEXT.encode(CHARSET), 'plain', CHARSET)
43.     htmlpart = MIMEText(BODY_HTML.encode(CHARSET), 'html', CHARSET)
44.     
45.     # Add the text and HTML parts to the child container.
46.     msg_body.attach(textpart)
47.     msg_body.attach(htmlpart)
48.     
49.     # Define the attachment part and encode it using MIMEApplication.
50.     att = MIMEApplication(open(ATTACHMENT, 'rb').read())
51.     
52.     # Add a header to tell the email client to treat this part as an attachment,
53.     # and to give the attachment a name.
54.     att.add_header('Content-Disposition','attachment',filename=os.path.basename(ATTACHMENT))
55.     
56.     # Attach the multipart/alternative child container to the multipart/mixed
57.     # parent container.
58.     msg.attach(msg_body)
59.     msg.attach(att)
60. 
61.     #changes start from here
62.     strmsg = str(msg)
63.     body = bytes (strmsg, 'utf-8')
64. 
65. 
66. 
67.     
68.     client = boto3.client('sesv2')
69.     response = client.send_email(
70.     FromEmailAddress=SENDER,
71.     Destination={
72.         'ToAddresses': [RECIPIENT]
73.     },
74.     Content={
75.         'Raw': {
76.             'Data': body
77.         }
78.     }
79.     )
80.     print(response)
81. boto3_rawemailv2 ()
```

------

# Como usar modelos para enviar e-mails personalizados com a API do Amazon SES
<a name="send-personalized-email-api"></a>

No Amazon SES, você pode enviar e-mails com base em modelo usando um *modelo armazenado* ou usando um *modelo em linha*.
+ **Modelo armazenado**: refere-se ao recurso [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Template.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Template.html) que é criado e salvo no SES usando a operação `CreateEmailTemplate` na API v2 do Amazon SES. O modelo contém o assunto e o corpo do e-mail contendo variáveis (espaços reservados) em linha com o conteúdo escrito. O nome do modelo armazenado e os dados dinâmicos das variáveis de espaço reservado no modelo são fornecidos ao chamar as operações `SendEmail` ou `SendBulkEmail` da API v2.

  Os *modelos armazenados* podem ser facilmente reutilizados e podem economizar tempo e esforço ao enviar tipos semelhantes de e-mails. Em vez de criar cada e-mail do zero, basta criar a estrutura básica e o design uma vez, depois atualizar o conteúdo dinâmico dentro do modelo.
+ **Modelo em linha**: o recurso `Template` não é usado. Em vez disso, o assunto e o corpo do e-mail contendo variáveis (espaços reservados) em linha com o conteúdo escrito, além dos valores dessas variáveis de espaço reservado, são fornecidos ao chamar as operações `SendEmail` ou `SendBulkEmail` da API v2.

  Os *modelos em linha* simplificam o processo de envio de e-mails em massa, eliminando a necessidade de gerenciar recursos de modelo em sua conta do SES, e simplificam o processo de integração, permitindo que você inclua o conteúdo do modelo diretamente na lógica da aplicação. Eles não contam contra o limite de 20.000 modelos por. Região da AWS

Os seguintes limites se aplicam ao usar *modelos armazenados*:
+ Você pode criar até 20.000 modelos de e-mail em cada um Região da AWS.
+ Cada modelo pode ter até 500 KB, incluindo as partes de texto e de HTML.

O limite a seguir se aplica ao usar *modelos em linha*:
+ Cada arquivo JSON de entrada pode ter até 1 MB, incluindo as partes de texto e HTML.

O seguinte se aplica aos *modelos *armazenados* e embutidos*:
+ Não há limites para o número de variáveis de substituição que podem ser usadas.
+ Você pode enviar e-mails para até 50 objetos de destino em cada chamada para a operação `SendBulkEmail`. O [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html)objeto pode conter vários destinatários definidos em **ToAddresses**CcAddresses****, e. **BccAddresses** O número de destinos com os quais você pode entrar em contato em uma única chamada à API v2 pode ser limitado pela taxa máxima de envio da sua conta. Para obter mais informações, consulte [Gerenciamento de limites do envio do Amazon SES](manage-sending-quotas.md).

Este capítulo inclui procedimentos com exemplos para usar *modelos armazenados* e *modelos em linha*.

**nota**  
Os procedimentos desta seção também pressupõem que você já instalou e configurou a AWS CLI. Para obter mais informações sobre como instalar e configurar o AWS CLI, consulte o [Guia do AWS Command Line Interface usuário](https://docs.aws.amazon.com/cli/latest/userguide/).

## (Opcional) Parte 1: Configurar notificações de eventos de falha de renderização
<a name="send-personalized-email-set-up-notifications"></a>

 Se você enviar um e-mail que contenha conteúdo de personalização inválido, o Amazon SES pode até aceitar a mensagem, mas não poderá entregá-la. Por esse motivo, se você planeja enviar e-mails personalizados, configure o SES para enviar notificações de eventos de falha de renderização pelo Amazon SNS. Ao receber uma notificação de evento de Falha de renderização, você pode identificar qual mensagem continha o conteúdo inválido, corrigir os problemas e enviar a mensagem novamente.

O procedimento nesta seção é opcional, mas altamente recomendado.

**Para configurar notificações de eventos de Falha de renderização**

1. Crie um tópico do Amazon SNS. Para obter procedimentos, consulte [Criar um tópico](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html) no *Guia do desenvolvedor do Amazon Simple Notification Service*.

1. Assine o tópico do Amazon SNS. Por exemplo, se você quiser receber notificações de Falha de renderização por e-mail, inscreva um endpoint de e-mail (ou seja, seu endereço de e-mail) no tópico.

   Para obter os procedimentos, consulte [Assinar um tópico](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html) no *Guia do desenvolvedor do Amazon Simple Notification Service*.

1. Execute os procedimentos em [Configure um destino de eventos do Amazon SNS para publicação de eventos](event-publishing-add-event-destination-sns.md) para configurar os conjuntos de configurações para publicação de eventos de falha de processamento no seu tópico sobre o Amazon SNS.

## (Opcional) Parte 2: Criar um modelo de e-mail
<a name="send-personalized-email-create-template"></a>

Se você pretende usar um *modelo armazenado*, esta seção mostrará como usar a operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_CreateEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_CreateEmailTemplate.html) da API v2 do SES para criar o modelo. Você pode pular esta etapa se deseja usar um *modelo em linha*.

Esse procedimento pressupõe que você já tenha instalado e configurado a AWS CLI. Para obter mais informações sobre como instalar e configurar o AWS CLI, consulte o [Guia do AWS Command Line Interface usuário](https://docs.aws.amazon.com/cli/latest/userguide/).

**Para criar o modelo**

1. Em um editor de texto, crie um arquivo e cole o código a seguir, personalizando-o conforme necessário.

   ```
   {
       "TemplateName": "MyTemplate",
       "TemplateContent": {
           "Subject": "Greetings, {{name}}!",
           "Text": "Dear {{name}},\r\nYour favorite animal is {{favoriteanimal}}.",
           "Html": "<h1>Hello {{name}},</h1><p>Your favorite animal is {{favoriteanimal}}.</p>"
       }
   }
   ```

   Esse código contém as seguintes propriedades:
   + **TemplateName**— O nome do `Template` recurso. Quando você enviar o e-mail, consulte este nome.
   + **TemplateContent**— Um contêiner para os seguintes atributos:
     + **Assunto**: a linha de assunto do e-mail. Essa propriedade pode conter tags de substituição. Essas tags usam o seguinte formato: `{{tagname}}`. Quando você envia o e-mail, pode especificar um valor para `tagname` de cada destino.
     + **Html**: o corpo HTML do e-mail. Essa propriedade pode conter tags de substituição. O exemplo anterior inclui duas tags: `{{name}}` e `{{favoriteanimal}}`.
     + **Text**: o corpo de texto do e-mail. Os destinatários cujos clientes de e-mail não exibem conteúdo HTML verão esta versão do e-mail. Essa propriedade também pode conter tags de substituição.

1. Personalize o exemplo anterior de acordo com as suas necessidades e salve o arquivo como *mytemplate.json*.

1. Na linha de comando, digite o seguinte comando para criar um modelo usando a operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_CreateEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_CreateEmailTemplate.html) da API v2:

   ```
   aws sesv2 create-email-template --cli-input-json file://mytemplate.json
   ```

## Parte 3: Enviar os e-mails personalizados
<a name="send-personalized-email-api-operations"></a>

Você pode usar as duas operações da API v2 do SES a seguir para enviar e-mails usando *modelos armazenados* ou *modelos em linha*:
+ A operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html) é útil para enviar um e-mail personalizado para um único objeto de destino. O [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html)objeto da API v2 pode conter as *BccAddresses*propriedades *ToAddresses*CcAddresses**, e. Elas podem ser usadas em qualquer combinação e podem conter um ou mais endereços de e-mail que receberão o mesmo e-mail.
+ A operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html) é útil para envio de e-mails exclusivos a vários objetos de destino em uma única chamada para a API v2.

Esta seção fornece exemplos de como usar o AWS CLI para enviar e-mails modelados usando essas duas operações de envio.

### Enviar e-mails com base em modelo a um único objeto de destino
<a name="send-templated-email-single-destination"></a>

Você pode usar a operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html) para enviar um e-mail a um ou mais destinatários definidos em um único objeto de destino. Todos os destinatários no objeto [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html) receberão o mesmo e-mail.

**Como enviar um e-mail com base em modelo a um único objeto de destino**

1. Dependendo se você deseja usar um *modelo armazenado* ou um *modelo em linha*, selecione o exemplo de código respectivo para colar em um editor de texto, personalizando-o conforme necessário.

------
#### [ Stored template code example ]

   Observe que o modelo que você criou na etapa anterior, *MyTemplate*, está sendo referenciado como o valor do `TemplateName` parâmetro.

   ```
   {
       "FromEmailAddress": "Mary Major <mary.major@example.com>",
       "Destination": {
           "ToAddresses": [
               "alejandro.rosalez@example.com", "jimmy.jet@example.com"
           ]
       },
       "Content": {
           "Template": {
               "TemplateName": "MyTemplate",
               "TemplateData": "{ \"name\":\"Alejandro\", \"favoriteanimal\": \"alligator\" }"
           }
       },
       "ConfigurationSetName": "ConfigSet"
   }
   ```

   Esse código contém as seguintes propriedades:
   + **FromEmailAddress**— O endereço de e-mail do remetente.
   + **Destino** — Um objeto contendo os destinatários de e-mail definidos nas *BccAddresses*propriedades *ToAddresses*CcAddresses**, e. Elas podem ser usadas em qualquer combinação e podem conter um ou mais endereços de e-mail que receberão o mesmo e-mail.
   + **TemplateName**— O nome do `Template` recurso a ser aplicado ao e-mail.
   + **TemplateData**— Uma string JSON com escape que contém pares de valores-chave. As chaves correspondem às variáveis definidas nas propriedades `TemplateContent` do modelo armazenado, por exemplo, `{{name}}`. Os valores representam o conteúdo que substitui as variáveis.
   + **ConfigurationSetName**— O nome do conjunto de configurações a ser usado ao enviar o e-mail.
**nota**  
Recomendamos que você use um conjunto de configurações definido para publicar eventos de falha de processamento no Amazon SNS. Para obter mais informações, consulte [(Opcional) Parte 1: Configurar notificações de eventos de falha de renderização](#send-personalized-email-set-up-notifications).

------
#### [ Inline template code example ]

   Observe que as propriedades `TemplateContent` (que normalmente seriam definidas em um *modelo armazenado*) estão sendo definidas *em linha*, junto com a propriedade `TemplateData`, o que faz dele um *modelo em linha*.

   ```
   {
       "FromEmailAddress": "Mary Major <mary.major@example.com>",
       "Destination": {
           "ToAddresses": [
               "alejandro.rosalez@example.com", "jimmy.jet@example.com"
           ]
       },
       "Content": {
           "Template": {
               "TemplateContent": {
                   "Subject": "Greetings, {{name}}!",
                   "Text": "Dear {{name}},\r\nYour favorite animal is {{favoriteanimal}}.",
                   "Html": "<h1>Hello {{name}},</h1><p>Your favorite animal is {{favoriteanimal}}.</p>"
               },
               "TemplateData": "{ \"name\":\"Alejandro\", \"favoriteanimal\": \"alligator\" }"
           }
       },
       "ConfigurationSetName": "ConfigSet"
   }
   ```

   Esse código contém as seguintes propriedades:
   + **FromEmailAddress**— O endereço de e-mail do remetente.
   + **Destino** — Um objeto contendo os destinatários de e-mail definidos nas *BccAddresses*propriedades *ToAddresses*CcAddresses**, e. Elas podem ser usadas em qualquer combinação e podem conter um ou mais endereços de e-mail que receberão o mesmo e-mail.
   + **TemplateContent**— Um contêiner para os seguintes atributos:
     + **Assunto**: a linha de assunto do e-mail. Essa propriedade pode conter tags de substituição. Essas tags usam o seguinte formato: `{{tagname}}`. Quando você envia o e-mail, pode especificar um valor para `tagname` de cada destino.
     + **Html**: o corpo HTML do e-mail. Essa propriedade pode conter tags de substituição. O exemplo anterior inclui duas tags: `{{name}}` e `{{favoriteanimal}}`.
     + **Text**: o corpo de texto do e-mail. Os destinatários cujos clientes de e-mail não exibem conteúdo HTML verão esta versão do e-mail. Essa propriedade também pode conter tags de substituição.
   + **TemplateData**— Uma string JSON com escape que contém pares de valores-chave. As chaves correspondem às variáveis definidas nas propriedades `TemplateContent` desse arquivo, por exemplo, `{{name}}`. Os valores representam o conteúdo que substitui as variáveis.
   + **ConfigurationSetName**— O nome do conjunto de configurações a ser usado ao enviar o e-mail.
**nota**  
Recomendamos que você use um conjunto de configurações definido para publicar eventos de falha de processamento no Amazon SNS. Para obter mais informações, consulte [(Opcional) Parte 1: Configurar notificações de eventos de falha de renderização](#send-personalized-email-set-up-notifications).

------

1. Personalize o exemplo anterior de acordo com as suas necessidades e salve o arquivo como *myemail.json*.

1. Na linha de comando, digite o seguinte comando da API v2 para enviar o e-mail:

   ```
   aws sesv2 send-email --cli-input-json file://myemail.json
   ```

### Enviar e-mails com base em modelo a vários objetos de destino
<a name="send-templated-email-multiple-destinations"></a>

Você pode usar a operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html) para enviar um e-mail a vários objetos de destino em uma única chamada para a API v2 do SES. O SES envia um e-mail exclusivo para os destinatários em cada objeto [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html).

**Como enviar um e-mail com base em modelo a vários objetos de destino**

1. Dependendo se você deseja usar um *modelo armazenado* ou um *modelo em linha*, selecione o exemplo de código respectivo para colar em um editor de texto, personalizando-o conforme necessário.

------
#### [ Stored template code example ]

   Observe que o modelo que você criou na etapa anterior, *MyTemplate*, está sendo referenciado como o valor do `TemplateName` parâmetro.

   ```
   {
       "FromEmailAddress": "Mary Major <mary.major@example.com>",
       "DefaultContent": {
           "Template": {
               "TemplateName": "MyTemplate",
               "TemplateData": "{ \"name\":\"friend\", \"favoriteanimal\":\"unknown\" }"
           }
       },
       "BulkEmailEntries": [
           {
               "Destination": {
                   "ToAddresses": [
                       "anaya.iyengar@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Anaya\", \"favoriteanimal\":\"angelfish\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "liu.jie@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Liu\", \"favoriteanimal\":\"lion\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "shirley.rodriguez@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Shirley\", \"favoriteanimal\":\"shark\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "richard.roe@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{}"
                   }
               }
           }
       ],
       "ConfigurationSetName": "ConfigSet"
   }
   ```

   Esse código contém as seguintes propriedades:
   + **FromEmailAddress**— O endereço de e-mail do remetente.
   + **DefaultContent**— Um objeto JSON que contém os `TemplateData` objetos `TemplateName` e. 
   + **TemplateName**— O nome do `Template` recurso a ser aplicado ao e-mail.
   + **TemplateData**— Contém pares de valores-chave que serão usados se o `ReplacementEmailContent` objeto contiver um objeto JSON vazio,`{}`, na propriedade. `ReplacementTemplateData`
   + **BulkEmailEntries**— Uma matriz que contém um ou mais `Destination` objetos.
   + **Destino** — Um objeto contendo os destinatários de e-mail definidos nas *BccAddresses*propriedades *ToAddresses*CcAddresses**, e. Elas podem ser usadas em qualquer combinação e podem conter um ou mais endereços de e-mail que receberão o mesmo e-mail.
   + **ReplacementTemplateData**— Uma string JSON com escape que contém pares de valores-chave. As chaves correspondem às variáveis do modelo, por exemplo, `{{name}}`. Os valores representam o conteúdo que substitui as variáveis no e-mail. (Se a string JSON aqui estiver vazia, indicada por `{}`, os pares de chave-valor definidos na propriedade `TemplateData` dentro do objeto `DefaultContent` serão usados.)
   + **ConfigurationSetName**— O nome do conjunto de configurações a ser usado ao enviar o e-mail.
**nota**  
Recomendamos que você use um conjunto de configurações definido para publicar eventos de falha de processamento no Amazon SNS. Para obter mais informações, consulte [(Opcional) Parte 1: Configurar notificações de eventos de falha de renderização](#send-personalized-email-set-up-notifications).

------
#### [ Inline template code example ]

   Observe que as propriedades `TemplateContent` (que normalmente seriam definidas em um *modelo armazenado*) estão sendo definidas *em linha*, junto com a propriedade `TemplateData`, o que faz dele um *modelo em linha*.

   ```
   {
       "FromEmailAddress": "Mary Major <mary.major@example.com>",
       "DefaultContent": {
           "Template": {
               "TemplateContent": {
                   "Subject": "Greetings, {{name}}!",
                   "Text": "Dear {{name}},\r\nYour favorite animal is {{favoriteanimal}}.",
                   "Html": "<h1>Hello {{name}},</h1><p>Your favorite animal is {{favoriteanimal}}.</p>"
               },
               "TemplateData": "{ \"name\":\"friend\", \"favoriteanimal\":\"unknown\" }"
           }
       },
       "BulkEmailEntries": [
           {
               "Destination": {
                   "ToAddresses": [
                       "anaya.iyengar@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Anaya\", \"favoriteanimal\":\"angelfish\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "liu.jie@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Liu\", \"favoriteanimal\":\"lion\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "shirley.rodriguez@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Shirley\", \"favoriteanimal\":\"shark\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "richard.roe@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{}"
                   }
               }
           }
       ],
       "ConfigurationSetName": "ConfigSet"
   }
   ```

   Esse código contém as seguintes propriedades:
   + **FromEmailAddress**— O endereço de e-mail do remetente.
   + **DefaultContent**— Um objeto JSON que contém os `TemplateData` objetos `TemplateContent` e. 
   + **TemplateContent**— Um contêiner para os seguintes atributos:
     + **Assunto**: a linha de assunto do e-mail. Essa propriedade pode conter tags de substituição. Essas tags usam o seguinte formato: `{{tagname}}`. Quando você envia o e-mail, pode especificar um valor para `tagname` de cada destino.
     + **Html**: o corpo HTML do e-mail. Essa propriedade pode conter tags de substituição. O exemplo anterior inclui duas tags: `{{name}}` e `{{favoriteanimal}}`.
     + **Text**: o corpo de texto do e-mail. Os destinatários cujos clientes de e-mail não exibem conteúdo HTML verão esta versão do e-mail. Essa propriedade também pode conter tags de substituição.
   + **TemplateData**— Contém pares de valores-chave que serão usados se o `ReplacementEmailContent` objeto contiver um objeto JSON vazio,`{}`, na propriedade. `ReplacementTemplateData`
   + **BulkEmailEntries**— Uma matriz que contém um ou mais `Destination` objetos.
   + **Destino** — Um objeto contendo os destinatários de e-mail definidos nas *BccAddresses*propriedades *ToAddresses*CcAddresses**, e. Elas podem ser usadas em qualquer combinação e podem conter um ou mais endereços de e-mail que receberão o mesmo e-mail.
   + **ReplacementTemplateData**— Uma string JSON com escape que contém pares de valores-chave. As chaves correspondem às variáveis definidas nas propriedades `TemplateContent` desse arquivo, por exemplo, `{{name}}`. Os valores representam o conteúdo que substitui as variáveis no e-mail. (Se a string JSON aqui estiver vazia, indicada por `{}`, os pares de chave-valor definidos na propriedade `TemplateData` dentro do objeto `DefaultContent` serão usados.)
   + **ConfigurationSetName**— O nome do conjunto de configurações a ser usado ao enviar o e-mail.
**nota**  
Recomendamos que você use um conjunto de configurações definido para publicar eventos de falha de processamento no Amazon SNS. Para obter mais informações, consulte [(Opcional) Parte 1: Configurar notificações de eventos de falha de renderização](#send-personalized-email-set-up-notifications).

------

1. Altere os valores no código da etapa anterior de acordo com as suas necessidades e salve o arquivo como *mybulkemail.json*.

1. Na linha de comando, digite o seguinte comando da API v2 para enviar o e-mail em massa:

   ```
   aws sesv2 send-bulk-email --cli-input-json file://mybulkemail.json
   ```

# Personalização de e-mail avançada
<a name="send-personalized-email-advanced"></a>

 Se estiver usando um *modelo armazenado*, ou seja, você criou um recurso [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Template.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Template.html) no Amazon SES usando a operação `CreateEmailTemplate` com a API v2 do SES, poderá aproveitar o sistema Handlebars para criar modelos que incluem recursos avançados, como atributos aninhados, iteração de matriz, instruções condicionais básicas e a criação de parciais em linha. Esta seção fornece exemplos desses recursos.

O Handlebars inclui recursos adicionais além dos documentados nesta seção. Para obter mais informações, consulte [Auxiliares integrados](https://handlebarsjs.com/guide/builtin-helpers.html) em [handlebarsjs.com](http://handlebarsjs.com).

**nota**  
O SES não escapa de conteúdo HTML ao renderizar o modelo HTML para uma mensagem. Isso significa que, se você estiver incluindo dados inseridos pelo usuário, como de um formulário de contato, precisará escapá-los no lado do cliente.

**Topics**
+ [Analisar atributos aninhados](#send-personalized-email-advanced-nested)
+ [Percorrer listas](#send-personalized-email-advanced-iterating)
+ [Usar instruções condicionais básicas](#send-personalized-email-advanced-conditionals)
+ [Criação de parciais em linha](#send-personalized-email-advanced-inline-partials)

## Analisar atributos aninhados
<a name="send-personalized-email-advanced-nested"></a>

O Handlebars inclui suporte para caminhos aninhados, o que torna fácil organizar complexos dados do cliente e, em seguida, consultá-los em seus modelos de e-mail.

Por exemplo, você pode organizar os dados dos destinatários em diversas categorias gerais. Em cada uma dessas categorias, você pode incluir informações detalhadas. O código de exemplo a seguir mostra um exemplo dessa estrutura para um único destinatário:

```
{
  "meta":{
    "userId":"51806220607"
  },
  "contact":{
    "firstName":"Anaya",
    "lastName":"Iyengar",
    "city":"Bengaluru",
    "country":"India",
    "postalCode":"560052"
  },
  "subscription":[
    {
      "interest":"Sports"
    },
    {
      "interest":"Travel"
    },
    {
      "interest":"Cooking"
    }
  ]
}
```

Em seus modelos de e-mail, você pode consultar atributos aninhados ao fornecer o nome do atributo pai, seguido por um ponto (.) e pelo nome do atributo para os quais você deseja incluir o valor. Por exemplo, se você usar a estrutura de dados mostrada no exemplo anterior e desejar incluir o nome de cada destinatário no modelo de e-mail, inclua o seguinte texto em seu modelo de e-mail: `Hello {{contact.firstName}}!`

O Handlebars pode analisar caminhos aninhados em vários níveis de profundidade, o que significa que você tem flexibilidade para escolher como estruturar os dados de seu modelo.

## Percorrer listas
<a name="send-personalized-email-advanced-iterating"></a>

A função auxiliar `each` faz a iteração por meio de itens em uma matriz. O código a seguir é um exemplo de um modelo de e-mail que usa a função auxiliar `each` para criar uma lista detalhada dos interesses de cada destinatário.

```
{
  "Template": {
    "TemplateName": "Preferences",
    "SubjectPart": "Subscription Preferences for {{contact.firstName}} {{contact.lastName}}",
    "HtmlPart": "<h1>Your Preferences</h1>
                 <p>You have indicated that you are interested in receiving 
                   information about the following subjects:</p>
                 <ul>
                   {{#each subscription}}
                     <li>{{interest}}</li>
                   {{/each}}
                 </ul>
                 <p>You can change these settings at any time by visiting 
                    the <a href=https://www.example.com/prefererences/i.aspx?id={{meta.userId}}>
                    Preference Center</a>.</p>",
    "TextPart": "Your Preferences\n\nYou have indicated that you are interested in 
                 receiving information about the following subjects:\n
                 {{#each subscription}}
                   - {{interest}}\n
                 {{/each}}
                 \nYou can change these settings at any time by 
                 visiting the Preference Center at 
                 https://www.example.com/prefererences/i.aspx?id={{meta.userId}}"
  }
}
```

**Importante**  
No código de exemplo anterior, os valores dos atributos `HtmlPart` e `TextPart` incluem quebras de linha para facilitar a leitura do exemplo. O arquivo JSON para seu modelo não pode conter quebras de linha dentro desses valores. Se você copiou e colou esse exemplo em seu próprio arquivo JSON, antes de prosseguir, remova as quebras de linha e os espaços extras das seções `HtmlPart` e `TextPart`.

Depois de criar o modelo, você pode usar a operação `SendEmail` ou `SendBulkEmail` para enviar e-mails para destinatários usando esse modelo. Desde que cada destinatário tenha, pelo menos, um valor no objeto `Interests`, eles receberão um e-mail que inclua uma lista detalhada de seus interesses. O exemplo a seguir mostra um arquivo JSON que pode ser usado para enviar e-mails para vários destinatários usando o modelo anterior:

```
{
  "Source":"Sender Name <sender@example.com>",
  "Template":"Preferences",
  "Destinations":[
    {
      "Destination":{
        "ToAddresses":[
          "anaya.iyengar@example.com"
        ]
      },
      "ReplacementTemplateData":"{\"meta\":{\"userId\":\"51806220607\"},\"contact\":{\"firstName\":\"Anaya\",\"lastName\":\"Iyengar\"},\"subscription\":[{\"interest\":\"Sports\"},{\"interest\":\"Travel\"},{\"interest\":\"Cooking\"}]}"
      },
    {
      "Destination":{ 
        "ToAddresses":[
          "shirley.rodriguez@example.com"
        ]
      },
      "ReplacementTemplateData":"{\"meta\":{\"userId\":\"1981624758263\"},\"contact\":{\"firstName\":\"Shirley\",\"lastName\":\"Rodriguez\"},\"subscription\":[{\"interest\":\"Technology\"},{\"interest\":\"Politics\"}]}"
    }
  ],
  "DefaultTemplateData":"{\"meta\":{\"userId\":\"\"},\"contact\":{\"firstName\":\"Friend\",\"lastName\":\"\"},\"subscription\":[]}"
}
```

Quando você enviar um e-mail para os destinatários listados no exemplo anterior usando a operação `SendBulkEmail`, eles receberão uma mensagem que se parece com o exemplo mostrado na imagem a seguir:

![\[Preferences notification listing Sports, Travel, and Cooking as selected interests.\]](http://docs.aws.amazon.com/pt_br/ses/latest/dg/images/send-personalized-email-advanced-condition-interest.png)


## Usar instruções condicionais básicas
<a name="send-personalized-email-advanced-conditionals"></a>

Esta seção se baseia no exemplo descrito na seção anterior. O exemplo na seção anterior usa o auxiliar `each` para fazer a iteração por meio de uma lista de interesses. No entanto, os destinatários para os quais nenhum interesse está especificado recebem um e-mail que contém uma lista vazia. Ao usar o auxiliar `{{if}}`, você poderá formatar o e-mail de forma diferente se um determinado atributo estiver presente nos dados do modelo. O código a seguir usará o auxiliar `{{if}}` para exibir a lista com marcadores na seção anterior se a matriz `Subscription` contiver todos os valores. Se a matriz estiver vazia, outro bloco de texto será exibido.

```
{
  "Template": {
    "TemplateName": "Preferences2",
    "SubjectPart": "Subscription Preferences for {{contact.firstName}} {{contact.lastName}}",
    "HtmlPart": "<h1>Your Preferences</h1>
                 <p>Dear {{contact.firstName}},</p>
                 {{#if subscription}}
                   <p>You have indicated that you are interested in receiving 
                     information about the following subjects:</p>
                     <ul>
                     {{#each subscription}}
                       <li>{{interest}}</li>
                     {{/each}}
                     </ul>
                     <p>You can change these settings at any time by visiting 
                       the <a href=https://www.example.com/prefererences/i.aspx?id={{meta.userId}}>
                       Preference Center</a>.</p>
                 {{else}}
                   <p>Please update your subscription preferences by visiting 
                     the <a href=https://www.example.com/prefererences/i.aspx?id={{meta.userId}}>
                     Preference Center</a>.
                 {{/if}}",
    "TextPart": "Your Preferences\n\nDear {{contact.firstName}},\n\n
                 {{#if subscription}}
                   You have indicated that you are interested in receiving 
                   information about the following subjects:\n
                   {{#each subscription}}
                     - {{interest}}\n
                   {{/each}}
                   \nYou can change these settings at any time by visiting the 
                   Preference Center at https://www.example.com/prefererences/i.aspx?id={{meta.userId}}.
                 {{else}}
                   Please update your subscription preferences by visiting the 
                   Preference Center at https://www.example.com/prefererences/i.aspx?id={{meta.userId}}.
                 {{/if}}"
  }
}
```

**Importante**  
No código de exemplo anterior, os valores dos atributos `HtmlPart` e `TextPart` incluem quebras de linha para facilitar a leitura do exemplo. O arquivo JSON para seu modelo não pode conter quebras de linha dentro desses valores. Se você copiou e colou esse exemplo em seu próprio arquivo JSON, antes de prosseguir, remova as quebras de linha e os espaços extras das seções `HtmlPart` e `TextPart`.

O exemplo a seguir mostra um arquivo JSON que pode ser usado para enviar e-mails para vários destinatários usando o modelo anterior:

```
{
  "Source":"Sender Name <sender@example.com>",
  "Template":"Preferences2",
  "Destinations":[
    {
      "Destination":{
        "ToAddresses":[
          "anaya.iyengar@example.com"
        ]
      },
      "ReplacementTemplateData":"{\"meta\":{\"userId\":\"51806220607\"},\"contact\":{\"firstName\":\"Anaya\",\"lastName\":\"Iyengar\"},\"subscription\":[{\"interest\":\"Sports\"},{\"interest\":\"Cooking\"}]}"
      },
    {
      "Destination":{ 
        "ToAddresses":[
          "shirley.rodriguez@example.com"
        ]
      },
      "ReplacementTemplateData":"{\"meta\":{\"userId\":\"1981624758263\"},\"contact\":{\"firstName\":\"Shirley\",\"lastName\":\"Rodriguez\"}}"
    }
  ],
  "DefaultTemplateData":"{\"meta\":{\"userId\":\"\"},\"contact\":{\"firstName\":\"Friend\",\"lastName\":\"\"},\"subscription\":[]}"
}
```

Neste exemplo, o destinatário cujos dados do modelo incluíam uma lista de interesses recebe o mesmo e-mail como o exemplo mostrado na seção anterior. No entanto, o destinatário cujos dados do modelo não incluíam interesses recebe um e-mail que se parece com o exemplo mostrado na imagem a seguir:

![\[Email message with header "Your Preferences" and text about updating subscription preferences.\]](http://docs.aws.amazon.com/pt_br/ses/latest/dg/images/send-personalized-email-advanced-condition-nointerest.png)


## Criação de parciais em linha
<a name="send-personalized-email-advanced-inline-partials"></a>

Você pode usar parciais em linha para simplificar os modelos que incluem strings repetidas. Por exemplo, é possível criar um parcial em linha que inclua o nome do destinatário e, se estiver disponível, o sobrenome, adicionando o seguinte código no início de seu modelo:

```
{{#* inline \"fullName\"}}{{firstName}}{{#if lastName}} {{lastName}}{{/if}}{{/inline}}\n
```

**nota**  
O caractere de nova linha (`\n`) é necessário para separar o bloco `{{inline}}` do conteúdo em seu modelo. A nova linha não é renderizada na saída final.

Depois de criar a parcial `fullName`, você pode incluí-la em qualquer lugar em seu modelo colocando antes do nome da parcial um sinal de maior que (>) seguido por um espaço, como no exemplo a seguir: `{{> fullName}}`. As parciais em linha não são transferidas entre partes do e-mail. Por exemplo, se você desejar usar a parcial em linha no HTML e na versão de texto do e-mail, defina-a nas seções `HtmlPart` e `TextPart`.

Você também pode usar parciais em linha ao fazer a iteração por meio de matrizes. Você pode usar o seguinte código para criar um modelo que use a parcial em linha `fullName`. Neste exemplo, a parcial em linha se aplica ao nome do destinatário e a uma variedade de outros nomes:

```
{
  "Template": {
    "TemplateName": "Preferences3",
    "SubjectPart": "{{firstName}}'s Subscription Preferences",
    "HtmlPart": "{{#* inline \"fullName\"}}
                   {{firstName}}{{#if lastName}} {{lastName}}{{/if}}
                 {{/inline~}}\n
                 <h1>Hello {{> fullName}}!</h1>
                 <p>You have listed the following people as your friends:</p>
                 <ul>
                 {{#each friends}}
                   <li>{{> fullName}}</li>
                 {{/each}}</ul>",
    "TextPart": "{{#* inline \"fullName\"}}
                   {{firstName}}{{#if lastName}} {{lastName}}{{/if}}
                 {{/inline~}}\n
                 Hello {{> fullName}}! You have listed the following people 
                 as your friends:\n
                 {{#each friends}}
                   - {{> fullName}}\n
                 {{/each}}"
  }
}
```

**Importante**  
No código de exemplo anterior, os valores dos atributos `HtmlPart` e `TextPart` incluem quebras de linha para facilitar a leitura do exemplo. O arquivo JSON para seu modelo não pode conter quebras de linha dentro desses valores. Se você copiou e colou esse exemplo em seu próprio arquivo JSON, remova as quebras de linha e os espaços extras dessas seções.

# Gerenciamento de modelos de e-mail
<a name="send-personalized-email-manage-templates"></a>

Além de [criar modelos de e-mail](send-personalized-email-api.md), você também pode usar a API v2 do Amazon SES para atualizar ou excluir modelos existentes, listar todos os modelos existentes ou visualizar o conteúdo de um modelo. 

Esta seção contém procedimentos para usar o AWS CLI para realizar tarefas relacionadas aos modelos do SES.

**nota**  
Os procedimentos desta seção também pressupõem que você já instalou e configurou a AWS CLI. Para obter mais informações sobre como instalar e configurar o AWS CLI, consulte o [Guia do AWS Command Line Interface usuário](https://docs.aws.amazon.com/cli/latest/userguide/).

## Visualização de uma lista de modelos de e-mail
<a name="send-personalized-email-manage-templates-list"></a>

Você pode usar a operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_ListEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_ListEmailTemplate.html) da API v2 do SES para visualizar uma lista de todos os seus modelos de e-mail existentes.

**Para visualizar uma lista de modelos de e-mail**
+ Na linha de comando, insira o seguinte comando:

  ```
  aws sesv2 list-email-templates
  ```

  Se houver modelos de e-mail existentes na sua conta do SES na região atual, esse comando retornará uma resposta semelhante ao seguinte exemplo:

  ```
  {
      "TemplatesMetadata": [
          {
              "Name": "SpecialOffers",
              "CreatedTimestamp": "2020-08-05T16:04:12.640Z"
          },
          {
              "Name": "NewsAndUpdates",
              "CreatedTimestamp": "2019-10-03T20:03:34.574Z"
          }
      ]
  }
  ```

  Se você ainda não criou nenhum modelo, o comando retorna um objeto `TemplatesMetadata` sem membros.

## Visualização do conteúdo de um modelo de e-mail específico
<a name="send-personalized-email-manage-templates-get"></a>

Você pode usar a operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_GetEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_GetEmailTemplate.html) da API v2 do SES para visualizar o conteúdo de um modelo de e-mail específico.

**Para visualizar o conteúdo de um modelo de e-mail específico**
+ Na linha de comando, insira o seguinte comando:

  ```
  aws sesv2 get-email-template --template-name MyTemplate
  ```

  No comando anterior, *MyTemplate* substitua pelo nome do modelo que você deseja visualizar.

  Se o nome do modelo fornecido corresponder a um modelo que existe na sua conta do SES, esse comando retornará uma resposta semelhante ao seguinte exemplo:

  ```
  {
      "Template": {
          "TemplateName": "TestMessage",
          "SubjectPart": "Amazon SES Test Message",
          "TextPart": "Hello! This is the text part of the message.",
          "HtmlPart": "<html>\n<body>\n<h2>Hello!</h2>\n<p>This is the HTML part of the message.</p></body>\n</html>"
      }
  }
  ```

  Se o nome do modelo fornecido não corresponder a um modelo existente na sua conta do SES, o comando retornará um erro de `NotFoundException`.

## Exclusão de um modelo de e-mail
<a name="send-personalized-email-manage-templates-delete"></a>

Você pode usar a operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_DeleteEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_DeleteEmailTemplate.html) da API v2 do SES para excluir um modelo de e-mail específico.

**Para excluir um modelo de e-mail**
+ Na linha de comando, insira o seguinte comando:

  ```
  aws sesv2 delete-email-template --template-name MyTemplate
  ```

  No comando anterior, *MyTemplate* substitua pelo nome do modelo que você deseja excluir.

  Esse comando não fornece nenhuma saída. Você pode verificar se o modelo foi excluído usando a [GetTemplate](#send-personalized-email-manage-templates-get)operação.

## Atualização de um modelo de e-mail
<a name="send-personalized-email-manage-templates-update"></a>

Você pode usar a operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_UpdateEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_UpdateEmailTemplate.html) da API v2 do SES para atualizar um modelo de e-mail existente. Por exemplo, essa operação é útil se você quiser alterar a linha de assunto do modelo de email ou se precisar modificar o corpo da mensagem em si.

**Para atualizar um modelo de e-mail**

1. Use o comando `GetEmailTemplate` para recuperar o modelo existente inserindo o seguinte comando na linha de comandos:

   ```
   aws sesv2 get-email-template --template-name MyTemplate
   ```

   No comando anterior, *MyTemplate* substitua pelo nome do modelo que você deseja atualizar.

   Se o nome do modelo fornecido corresponder a um modelo que existe na sua conta do SES, esse comando retornará uma resposta semelhante ao seguinte exemplo:

   ```
   {
       "Template": {
           "TemplateName": "TestMessage",
           "SubjectPart": "Amazon SES Test Message",
           "TextPart": "Hello! This is the text part of the message.",
           "HtmlPart": "<html>\n<body>\n<h2>Hello!</h2>\n<p>This is the HTML part of the message.</p></body>\n</html>"
       }
   }
   ```

1. Em um editor de texto, crie um novo arquivo. Cole a saída do comando anterior no arquivo.

1. Modifique o template conforme necessário. Todas as linhas que você omitir são removidas do modelo. Por exemplo, se você quiser alterar apenas o `SubjectPart` do modelo, você ainda precisa incluir as propriedades `TextPart` e `HtmlPart`.

   Ao concluir, salve o arquivo como `update_template.json`.

1. Na linha de comando, insira o seguinte comando:

   ```
   aws sesv2 update-email-template --cli-input-json file://path/to/update_template.json
   ```

   No comando anterior, *path/to/update\$1template.json* substitua pelo caminho para o `update_template.json` arquivo que você criou na etapa anterior.

   Se o modelo for atualizado com êxito, esse comando não fornece nenhuma saída. Você pode verificar se o modelo foi atualizado usando a operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_GetEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_GetEmailTemplate.html).

   Se o modelo especificado não existir, esse comando retornará um erro de `TemplateDoesNotExist`. Se o modelo não contiver a propriedade `TextPart` nem a propriedade `HtmlPart`, este comando retornará um erro `InvalidParameterValue`. 

# Envio de e-mail pelo Amazon SES usando um AWS SDK
<a name="send-an-email-using-sdk-programmatically"></a>

Você pode usar um AWS SDK para enviar e-mails pelo Amazon SES. AWS SDKs estão disponíveis para várias linguagens de programação. Para obter mais informações, consulte [Ferramentas para a Amazon Web Services](https://aws.amazon.com/tools/#sdk).

## Pré-requisitos
<a name="send-an-email-using-sdk-programmatically-prereqs"></a>

Os seguintes pré-requisitos devem ser atendidos para realizar qualquer um dos exemplos de código na próxima seção:
+ Se você ainda não tiver feito isso, realize as tarefas em [Configuração do Amazon Simple Email Service](setting-up.md).
+ **Verifique seu endereço de e-mail com o Amazon SES**: antes de enviar e-mails com o Amazon SES, é necessário verificar se você é o proprietário do endereço de e-mail remetente. Se sua conta ainda estiver na sandbox do Amazon SES, você também deverá verificar o endereço de e-mail do destinatário. Recomendamos que você use o console do Amazon SES para verificar endereços de e-mail. Para obter mais informações, consulte [Criação da identidade de um endereço de e-mail](creating-identities.md#verify-email-addresses-procedure). 
+ **Obtenha suas AWS credenciais** — Você precisa de um ID de chave de AWS acesso e uma chave de acesso AWS secreta para acessar o Amazon SES usando um SDK. Você pode encontrar suas credenciais na página [Credenciais de segurança](https://console.aws.amazon.com/iam/home?#security_credential) no Console de gerenciamento da AWS. Para obter mais informações sobre credenciais, consulte [Tipos de credenciais do Amazon SES](send-email-concepts-credentials.md).
+ **Crie um arquivo de credenciais compartilhadas**: para que o código de exemplo desta seção funcione bem, você deve criar um arquivo de credenciais compartilhadas. Para obter mais informações, consulte [Criação de um arquivo de credenciais compartilhado para usar ao enviar e-mails pelo Amazon SES usando um SDK AWS](create-shared-credentials-file.md).

## Exemplos de código
<a name="send-an-email-using-sdk-programmatically-examples"></a>

**Importante**  
Nos tutoriais a seguir, você envia um e-mail a si mesmo para conferir se o recebe. Para fazer mais experimentos ou testes de carga, use o simulador de caixa postal do Amazon SES. Os e-mails enviados ao simulador de caixa postal não contam para sua cota de envio nem para suas taxas de devoluções e reclamações. Para obter mais informações, consulte [Uso do simulador de caixa postal manualmente.](send-an-email-from-console.md#send-email-simulator).

**Topics**

------
#### [ .NET ]

O procedimento a seguir mostra como enviar um e-mail por meio do Amazon SES usando o [Visual Studio](https://www.visualstudio.com/) e o AWS SDK para .NET.

Esta solução foi testada com os seguintes componentes:
+ Microsoft Visual Studio Community 2017, versão 15.4.0.
+ Microsoft .NET Framework versão 4.6.1.
+ O pacote AWSSDK .Core (versão 3.3.19), instalado usando o. NuGet
+  AWSSDKA. SimpleEmail pacote (versão 3.3.6.1), instalado usando. NuGet

**Antes de começar, execute as seguintes tarefas:**
+ **Instale o Visual Studio** — o Visual Studio está disponível em [https://www.visualstudio.com/](https://www.visualstudio.com/).

**Para enviar um e-mail usando o AWS SDK para .NET**

1. Crie um novo projeto realizando as seguintes etapas:

   1. Inicie o Visual Studio.

   1. No menu **File (Arquivo)**, escolha **New (Novo) **, **Project (Projeto)**.

   1. Na janela **New Project**, no painel esquerdo, expanda **Installed** e expanda **Visual C\$1**.

   1. No painel à direita, escolha **Console App (.NET Framework)**.

   1. Em **Name**, digite **AmazonSESSample** e selecione **OK**.

1. Use NuGet para incluir os pacotes do Amazon SES em sua solução concluindo as seguintes etapas:

   1. No painel **Solution Explorer**, clique com o botão direito do mouse em seu projeto e escolha **Gerenciar NuGet ** pacotes.

   1. Na SESSample guia **NuGet: Amazon**, escolha **Browse**.

   1. Na caixa de pesquisa, digite **AWSSDK.SimpleEmail**. 

   1. Escolha **AWSSDKo. SimpleEmail**pacote e, em seguida, escolha **Instalar**.

   1. Na janela **Preview Changes**, escolha **OK**.

1. Na guia **Program.cs**, cole o seguinte código:

   ```
    1. using Amazon;
    2. using System;
    3. using System.Collections.Generic;
    4. using Amazon.SimpleEmail;
    5. using Amazon.SimpleEmail.Model;
    6. 
    7. namespace AmazonSESSample 
    8. {
    9.     class Program
   10.     {
   11.         // Replace sender@example.com with your "From" address.
   12.         // This address must be verified with Amazon SES.
   13.         static readonly string senderAddress = "sender@example.com";
   14. 
   15.         // Replace recipient@example.com with a "To" address. If your account
   16.         // is still in the sandbox, this address must be verified.
   17.         static readonly string receiverAddress = "recipient@example.com";
   18. 
   19.         // The configuration set to use for this email. If you do not want to use a
   20.         // configuration set, comment out the following property and the
   21.         // ConfigurationSetName = configSet argument below. 
   22.         static readonly string configSet = "ConfigSet";
   23. 
   24.         // The subject line for the email.
   25.         static readonly string subject = "Amazon SES test (AWS SDK para .NET)";
   26. 
   27.         // The email body for recipients with non-HTML email clients.
   28.         static readonly string textBody = "Amazon SES Test (.NET)\r\n" 
   29.                                         + "This email was sent through Amazon SES "
   30.                                         + "using the AWS SDK para .NET.";
   31.         
   32.         // The HTML body of the email.
   33.         static readonly string htmlBody = @"<html>
   34. <head></head>
   35. <body>
   36.   <h1>Amazon SES Test (SDK para .NET)</h1>
   37.   <p>This email was sent with
   38.     <a href='https://aws.amazon.com/ses/'>Amazon SES</a> using the
   39.     <a href='https://aws.amazon.com/sdk-for-net/'> AWS SDK para .NET</a>.</p>
   40. </body>
   41. </html>";
   42. 
   43.         static void Main(string[] args)
   44.         {
   45.             // Replace USWest2 with the AWS Region you're using for Amazon SES.
   46.             // Acceptable values are EUWest1, USEast1, and USWest2.
   47.             using (var client = new AmazonSimpleEmailServiceClient(RegionEndpoint.USWest2))
   48.             {
   49.                 var sendRequest = new SendEmailRequest
   50.                 {
   51.                     Source = senderAddress,
   52.                     Destination = new Destination
   53.                     {
   54.                         ToAddresses =
   55.                         new List<string> { receiverAddress }
   56.                     },
   57.                     Message = new Message
   58.                     {
   59.                         Subject = new Content(subject),
   60.                         Body = new Body
   61.                         {
   62.                             Html = new Content
   63.                             {
   64.                                 Charset = "UTF-8",
   65.                                 Data = htmlBody
   66.                             },
   67.                             Text = new Content
   68.                             {
   69.                                 Charset = "UTF-8",
   70.                                 Data = textBody
   71.                             }
   72.                         }
   73.                     },
   74.                     // If you are not using a configuration set, comment
   75.                     // or remove the following line 
   76.                     ConfigurationSetName = configSet
   77.                 };
   78.                 try
   79.                 {
   80.                     Console.WriteLine("Sending email using Amazon SES...");
   81.                     var response = client.SendEmail(sendRequest);
   82.                     Console.WriteLine("The email was sent successfully.");
   83.                 }
   84.                 catch (Exception ex)
   85.                 {
   86.                     Console.WriteLine("The email was not sent.");
   87.                     Console.WriteLine("Error message: " + ex.Message);
   88. 
   89.                 }
   90.             }
   91. 
   92.             Console.Write("Press any key to continue...");
   93.             Console.ReadKey();
   94.         }
   95.     }
   96. }
   ```

1. Na caixa de editor, faça o seguinte:
   + *sender@example.com*Substitua pelo endereço de e-mail “De:”. Esse endereço deve ser verificado. Para obter mais informações, consulte [Identidades verificadas no Amazon SES](verify-addresses-and-domains.md).
   + *recipient@example.com*Substitua pelo endereço “Para:”. Se sua conta ainda estiver na sandbox, esse endereço "To" também deverá ser verificado.
   + *ConfigSet*Substitua pelo nome do conjunto de configurações a ser usado ao enviar esse e-mail.
   + *USWest2*Substitua pelo nome do Região da AWS endpoint que você usa para enviar e-mails usando o Amazon SES. Para obter uma lista das regiões onde o Amazon SES está disponível, consulte [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) na *Referência geral da AWS*.

   Quando terminar, salve `Program.cs`.

1. Crie e execute o aplicativo concluindo as seguintes etapas:

   1. No menu **Build**, escolha **Build Solution**.

   1. No menu **Debug**, escolha **Start Debugging**. Uma janela do console será exibida.

1. Analise a saída do console. Se o e-mail tiver sido enviado com sucesso, o console exibirá "`The email was sent successfully.`" 

1. Se o e-mail tiver sido enviado com êxito, acesse o cliente de e-mail do endereço do destinatário. Você verá a mensagem que enviou.

------
#### [ Java ]

O procedimento a seguir mostra como usar o [Eclipse IDE para desenvolvedores Java EE](http://www.eclipse.org/), [AWS Toolkit for Eclipse](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)criar um projeto AWS SDK e modificar o código Java para enviar um e-mail pelo Amazon SES. 

**Antes de começar, execute as seguintes tarefas:**
+ **Instale o Eclipse**: o Eclipse está disponível em [https://www.eclipse.org/downloads](https://www.eclipse.org/downloads). O código neste tutorial foi testado com o Eclipse Neon.3 (versão 4.6.3), executando a versão 1.8 do Java Runtime Environment.
+ **Instale o AWS Toolkit for Eclipse** [—As instruções para adicionar o AWS Toolkit for Eclipse à sua instalação do Eclipse estão disponíveis em https://aws.amazon.com /eclipse.](https://aws.amazon.com/eclipse) O código neste tutorial foi testado com a versão 2.3.1 do AWS Toolkit for Eclipse.

**Para enviar um e-mail usando o AWS SDK para Java**

1. Crie um projeto AWS Java no Eclipse executando as seguintes etapas:

   1. Inicie o Eclipse.

   1. No menu **File**, escolha **New** e **Other**. Na janela **New** (Novo), expanda a pasta **AWS** e depois selecione **Java Project AWS **.

   1. Na caixa de diálogo **Novo projeto AWS Java**, faça o seguinte:

      1. Para **Project name (Project name)**, digite um nome de projeto.

      1. Em **AWS SDK para Java Amostras**, selecione ** JavaMail Amostra do Amazon Simple Email Service**.

      1. Escolha **Terminar**.

1. No Eclipse, no painel **Package Explorer**, expanda o seu projeto.

1. Em seu projeto, expanda a pasta `src/main/java`, expanda a pasta `com.amazon.aws.samples` e, em seguida, clique duas vezes em `AmazonSESSample.java`.

1. Substitua o todo o conteúdo de `AmazonSESSample.java` pelo seguinte código:

   ```
    1. package com.amazonaws.samples;
    2. 
    3. import java.io.IOException;
    4. 
    5. import com.amazonaws.regions.Regions;
    6. import com.amazonaws.services.simpleemail.AmazonSimpleEmailService;
    7. import com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceClientBuilder;
    8. import com.amazonaws.services.simpleemail.model.Body;
    9. import com.amazonaws.services.simpleemail.model.Content;
   10. import com.amazonaws.services.simpleemail.model.Destination;
   11. import com.amazonaws.services.simpleemail.model.Message;
   12. import com.amazonaws.services.simpleemail.model.SendEmailRequest; 
   13. 
   14. public class AmazonSESSample {
   15. 
   16.   // Replace sender@example.com with your "From" address.
   17.   // This address must be verified with Amazon SES.
   18.   static final String FROM = "sender@example.com";
   19. 
   20.   // Replace recipient@example.com with a "To" address. If your account
   21.   // is still in the sandbox, this address must be verified.
   22.   static final String TO = "recipient@example.com";
   23. 
   24.   // The configuration set to use for this email. If you do not want to use a
   25.   // configuration set, comment the following variable and the 
   26.   // .withConfigurationSetName(CONFIGSET); argument below.
   27.   static final String CONFIGSET = "ConfigSet";
   28. 
   29.   // The subject line for the email.
   30.   static final String SUBJECT = "Amazon SES test (AWS SDK para Java)";
   31.   
   32.   // The HTML body for the email.
   33.   static final String HTMLBODY = "<h1>Amazon SES test (AWS SDK para Java)</h1>"
   34.       + "<p>This email was sent with <a href='https://aws.amazon.com/ses/'>"
   35.       + "Amazon SES</a> using the <a href='https://aws.amazon.com/sdk-for-java/'>" 
   36.       + "AWS SDK for Java</a>";
   37. 
   38.   // The email body for recipients with non-HTML email clients.
   39.   static final String TEXTBODY = "This email was sent through Amazon SES "
   40.       + "using the AWS SDK para Java.";
   41. 
   42.   public static void main(String[] args) throws IOException {
   43. 
   44.     try {
   45.       AmazonSimpleEmailService client = 
   46.           AmazonSimpleEmailServiceClientBuilder.standard()
   47.           // Replace US_WEST_2 with the AWS Region you're using for
   48.           // Amazon SES.
   49.             .withRegion(Regions.US_WEST_2).build();
   50.       SendEmailRequest request = new SendEmailRequest()
   51.           .withDestination(
   52.               new Destination().withToAddresses(TO))
   53.           .withMessage(new Message()
   54.               .withBody(new Body()
   55.                   .withHtml(new Content()
   56.                       .withCharset("UTF-8").withData(HTMLBODY))
   57.                   .withText(new Content()
   58.                       .withCharset("UTF-8").withData(TEXTBODY)))
   59.               .withSubject(new Content()
   60.                   .withCharset("UTF-8").withData(SUBJECT)))
   61.           .withSource(FROM)
   62.           // Comment or remove the next line if you are not using a
   63.           // configuration set
   64.           .withConfigurationSetName(CONFIGSET);
   65.       client.sendEmail(request);
   66.       System.out.println("Email sent!");
   67.     } catch (Exception ex) {
   68.       System.out.println("The email was not sent. Error message: " 
   69.           + ex.getMessage());
   70.     }
   71.   }
   72. }
   ```

1. Em `AmazonSESSample.java`, substitua o seguinte pelos seus próprios valores:
**Importante**  
Os endereços de e-mail diferenciam maiúsculas de minúsculas. Certifique-se de que os endereços sejam exatamente os mesmos que você verificou.
   + `SENDER@EXAMPLE.COM`: substitua pelo seu endereço de e-mail "From" (De). Você deve verificar esse endereço antes de executar esse programa. Para obter mais informações, consulte [Identidades verificadas no Amazon SES](verify-addresses-and-domains.md).
   + `RECIPIENT@EXAMPLE.COM`: substitua pelo seu endereço de e-mail "To" (Para). Se sua conta ainda estiver na sandbox, você precisará verificar esse endereço antes de usá-lo. Para obter mais informações, consulte [Solicitar acesso à produção (sair da sandbox do Amazon SES)](request-production-access.md).
   + **(Opcional) `us-west-2`**: se você deseja usar o Amazon SES em uma região que não seja Oeste dos EUA (Oregon), substitua isso pela região que você deseja usar. Para obter uma lista das regiões onde o Amazon SES está disponível, consulte [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) na *Referência geral da AWS*.

1. Salvar `AmazonSESSample.java`.

1. Para criar o projeto, escolha **Project** e, em seguida, escolha **Build Project**.
**nota**  
Se essa opção estiver desativada, a criação automática talvez esteja ativada. Nesse caso, pule esta etapa.

1. Para iniciar o programa e enviar o e-mail, escolha **Run** e **Run** novamente.

1. Analise a saída do painel do console no Eclipse. Se o e-mail foi enviado com êxito, o console exibirá "`Email sent!`"; do contrário, ele exibirá uma mensagem de erro.

1. Se o e-mail tiver sido enviado com êxito, acesse o cliente de e-mail do endereço do destinatário. Você verá a mensagem que enviou.

------
#### [ PHP ]

Este tópico mostra como usar o [AWS SDK para PHP](https://aws.amazon.com/sdk-for-php/) para enviar um e-mail pelo Amazon SES. 

**Antes de começar, execute as seguintes tarefas:**
+ **Instale o PHP**: o PHP está disponível em [http://php.net/downloads.php](http://php.net/downloads.php). Este tutorial requer PHP versão 5.5 ou superior. Depois de instalar o PHP, adicione o caminho para o PHP nas suas variáveis de ambiente, de forma que possa executar o PHP a partir de qualquer prompt de comando. O código neste tutorial foi testado usando PHP 7.2.7.
+ **Instale a AWS SDK para PHP versão 3** — Para obter instruções de download e instalação, consulte a [AWS SDK para PHP documentação](https://docs.aws.amazon.com/aws-sdk-php/v3/guide/getting-started/installation.html). O código neste tutorial foi testado com a versão 3.64.13 do SDK. 

**Para enviar um e-mail pelo Amazon SES usando o AWS SDK para PHP**

1. Em um editor de texto, crie um arquivo chamado `amazon-ses-sample.php`. Cole o seguinte código:

   ```
    1. <?php
    2. 
    3. // If necessary, modify the path in the require statement below to refer to the 
    4. // location of your Composer autoload.php file.
    5. require 'vendor/autoload.php';
    6. 
    7. use Aws\Ses\SesClient;
    8. use Aws\Exception\AwsException;
    9. 
   10. // Create an SesClient. Change the value of the region parameter if you're 
   11. // using an AWS Region other than US West (Oregon). Change the value of the
   12. // profile parameter if you want to use a profile in your credentials file
   13. // other than the default.
   14. $SesClient = new SesClient([
   15.     'profile' => 'default',
   16.     'version' => '2010-12-01',
   17.     'region'  => 'us-west-2'
   18. ]);
   19. 
   20. // Replace sender@example.com with your "From" address.
   21. // This address must be verified with Amazon SES.
   22. $sender_email = 'sender@example.com';
   23. 
   24. // Replace these sample addresses with the addresses of your recipients. If
   25. // your account is still in the sandbox, these addresses must be verified.
   26. $recipient_emails = ['recipient1@example.com','recipient2@example.com'];
   27. 
   28. // Specify a configuration set. If you do not want to use a configuration
   29. // set, comment the following variable, and the
   30. // 'ConfigurationSetName' => $configuration_set argument below.
   31. $configuration_set = 'ConfigSet';
   32. 
   33. $subject = 'Amazon SES test (AWS SDK para PHP)';
   34. $plaintext_body = 'This email was sent with Amazon SES using the AWS SDK for PHP.' ;
   35. $html_body =  '<h1>AWS Amazon Simple Email Service Test Email</h1>'.
   36.               '<p>This email was sent with <a href="https://aws.amazon.com/ses/">'.
   37.               'Amazon SES</a> using the <a href="https://aws.amazon.com/sdk-for-php/">'.
   38.               'AWS SDK para PHP</a>.</p>';
   39. $char_set = 'UTF-8';
   40. 
   41. try {
   42.     $result = $SesClient->sendEmail([
   43.         'Destination' => [
   44.             'ToAddresses' => $recipient_emails,
   45.         ],
   46.         'ReplyToAddresses' => [$sender_email],
   47.         'Source' => $sender_email,
   48.         'Message' => [
   49.           'Body' => [
   50.               'Html' => [
   51.                   'Charset' => $char_set,
   52.                   'Data' => $html_body,
   53.               ],
   54.               'Text' => [
   55.                   'Charset' => $char_set,
   56.                   'Data' => $plaintext_body,
   57.               ],
   58.           ],
   59.           'Subject' => [
   60.               'Charset' => $char_set,
   61.               'Data' => $subject,
   62.           ],
   63.         ],
   64.         // If you aren't using a configuration set, comment or delete the
   65.         // following line
   66.         'ConfigurationSetName' => $configuration_set,
   67.     ]);
   68.     $messageId = $result['MessageId'];
   69.     echo("Email sent! Message ID: $messageId"."\n");
   70. } catch (AwsException $e) {
   71.     // output error message if fails
   72.     echo $e->getMessage();
   73.     echo("The email was not sent. Error message: ".$e->getAwsErrorMessage()."\n");
   74.     echo "\n";
   75. }
   ```

1. Em `amazon-ses-sample.php`, substitua o seguinte pelos seus próprios valores:
   + **`path_to_sdk_inclusion`**—Substitua pelo caminho necessário para incluí-lo AWS SDK para PHP no programa. Para obter mais informações, consulte a [documentação do AWS SDK para PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/guide/getting-started/basic-usage.html). 
   + **`sender@example.com`**: substitua por um endereço de e-mail que você verificou com o Amazon SES. Para obter mais informações, consulte [Identidades](verify-addresses-and-domains.md). Os endereços de e-mail no Amazon SES diferenciam maiúsculas de minúsculas. Certifique-se de que o endereço informado seja exatamente o mesmo que você verificou.
   + **`recipient1@example.com`, `recipient2@example.com`**: substitua pelos endereços dos destinatários. Se sua conta ainda estiver na sandbox, os endereços dos destinatários também deverão ser verificados. Para obter mais informações, consulte [Solicitar acesso à produção (sair da sandbox do Amazon SES)](request-production-access.md). Certifique-se de que o endereço informado seja exatamente o mesmo que você verificou.
   + **(Opcional) `ConfigSet`**: se você quiser usar um conjunto de configurações ao enviar esse e-mail, substitua esse valor pelo nome do conjunto de configurações. Para obter mais informações sobre os conjuntos de configurações, consulte [Uso de conjuntos de configurações no Amazon SES](using-configuration-sets.md).
   + **(Opcional) `us-west-2`**: se você deseja usar o Amazon SES em uma região que não seja Oeste dos EUA (Oregon), substitua isso pela região que você deseja usar. Para obter uma lista das regiões onde o Amazon SES está disponível, consulte [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) na *Referência geral da AWS*.

1. Salvar `amazon-ses-sample.php`.

1. Para executar o programa, abra um prompt de comando no mesmo diretório de `amazon-ses-sample.php` e, em seguida, digite o comando a seguir:

   ```
   $ php amazon-ses-sample.php
   ```

1. Revise a saída. Se o e-mail foi enviado com êxito, o console exibirá "`Email sent!`"; do contrário, ele exibirá uma mensagem de erro.
**nota**  
Se você encontrar um erro "cURL error 60: SSL certificate problem" quando executar o programa, faça download do pacote CA mais recente, conforme descrito na [documentação do AWS SDK para PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/guide/faq.html#what-do-i-do-about-a-curl-ssl-certificate-error). Em seguida, em `amazon-ses-sample.php`, adicione as seguintes linhas à matriz `SesClient::factory`, substitua `path_of_certs` pelo caminho para o pacote CA que você obteve por download e execute novamente o programa.  

   ```
   1. 'http' => [
   2.    'verify' => 'path_of_certs\ca-bundle.crt'
   3. ]
   ```

1. Entre no cliente de e-mail do endereço de destinatário. Você verá a mensagem que enviou.

------
#### [ Ruby ]

Este tópico mostra como usar o [AWS SDK para Ruby](https://aws.amazon.com/sdk-for-ruby/) para enviar um e-mail pelo Amazon SES. 

**Antes de começar, execute as seguintes tarefas:**
+ **Instale o Ruby** [— O Ruby está disponível em https://www.ruby-lang. org/en/downloads](https://www.ruby-lang.org/en/downloads/)/. O código neste tutorial foi testado usando Ruby 1.9.3. Depois de instalar o Ruby, adicione o caminho para o Ruby nas suas variáveis de ambiente, de forma que possa executar o Ruby a partir de qualquer prompt de comando.
+ **Instale o AWS SDK para Ruby** — Para obter instruções de download e instalação, consulte [Instalação do AWS SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby/latest/developer-guide/setup-install.html) no *Guia do AWS SDK para Ruby desenvolvedor*. O código de exemplo neste tutorial foi testado com a versão 2.9.36 do AWS SDK para Ruby.
+ **Crie um arquivo de credenciais compartilhadas**: para que o código de exemplo desta seção funcione bem, você deve criar um arquivo de credenciais compartilhadas. Para obter mais informações, consulte [Criação de um arquivo de credenciais compartilhado para usar ao enviar e-mails pelo Amazon SES usando um SDK AWS](create-shared-credentials-file.md).

**Para enviar um e-mail pelo Amazon SES usando o AWS SDK para Ruby**

1. Em um editor de texto, crie um arquivo chamado `amazon-ses-sample.rb`. Cole o seguinte código no arquivo:

   ```
    1. require 'aws-sdk'
    2. 
    3. # Replace sender@example.com with your "From" address.
    4. # This address must be verified with Amazon SES.
    5. sender = "sender@example.com"
    6. 
    7. # Replace recipient@example.com with a "To" address. If your account 
    8. # is still in the sandbox, this address must be verified.
    9. recipient = "recipient@example.com"
   10. 
   11. # Specify a configuration set. If you do not want to use a configuration
   12. # set, comment the following variable and the 
   13. # configuration_set_name: configsetname argument below. 
   14. configsetname = "ConfigSet"
   15.   
   16. # Replace us-west-2 with the AWS Region you're using for Amazon SES.
   17. awsregion = "us-west-2"
   18. 
   19. # The subject line for the email.
   20. subject = "Amazon SES test (AWS SDK para Ruby)"
   21. 
   22. # The HTML body of the email.
   23. htmlbody =
   24.   '<h1>Amazon SES test (AWS SDK para Ruby)</h1>'\
   25.   '<p>This email was sent with <a href="https://aws.amazon.com/ses/">'\
   26.   'Amazon SES</a> using the <a href="https://aws.amazon.com/sdk-for-ruby/">'\
   27.   'AWS SDK para Ruby</a>.'
   28. 
   29. # The email body for recipients with non-HTML email clients.  
   30. textbody = "This email was sent with Amazon SES using the AWS SDK para Ruby."
   31. 
   32. # Specify the text encoding scheme.
   33. encoding = "UTF-8"
   34. 
   35. # Create a new SES resource and specify a region
   36. ses = Aws::SES::Client.new(region: awsregion)
   37. 
   38. # Try to send the email.
   39. begin
   40. 
   41.   # Provide the contents of the email.
   42.   resp = ses.send_email({
   43.     destination: {
   44.       to_addresses: [
   45.         recipient,
   46.       ],
   47.     },
   48.     message: {
   49.       body: {
   50.         html: {
   51.           charset: encoding,
   52.           data: htmlbody,
   53.         },
   54.         text: {
   55.           charset: encoding,
   56.           data: textbody,
   57.         },
   58.       },
   59.       subject: {
   60.         charset: encoding,
   61.         data: subject,
   62.       },
   63.     },
   64.   source: sender,
   65.   # Comment or remove the following line if you are not using 
   66.   # a configuration set
   67.   configuration_set_name: configsetname,
   68.   })
   69.   puts "Email sent!"
   70. 
   71. # If something goes wrong, display an error message.
   72. rescue Aws::SES::Errors::ServiceError => error
   73.   puts "Email not sent. Error message: #{error}"
   74. 
   75. end
   ```

1. Em `amazon-ses-sample.rb`, substitua o seguinte pelos seus próprios valores:
   + **`sender@example.com`**: substitua por um endereço de e-mail que você verificou com o Amazon SES. Para obter mais informações, consulte [Identidades](verify-addresses-and-domains.md). Os endereços de e-mail no Amazon SES diferenciam maiúsculas de minúsculas. Certifique-se de que o endereço informado seja exatamente o mesmo que você verificou.
   + **`recipient@example.com`**: substitua pelo endereço do destinatário. Se sua conta ainda estiver na sandbox, você precisará verificar esse endereço antes de usá-lo. Para obter mais informações, consulte [Solicitar acesso à produção (sair da sandbox do Amazon SES)](request-production-access.md). Certifique-se de que o endereço informado seja exatamente o mesmo que você verificou.
   + **(Opcional) `us-west-2`**: se você deseja usar o Amazon SES em uma região que não seja Oeste dos EUA (Oregon), substitua isso pela região que você deseja usar. Para obter uma lista das regiões onde o Amazon SES está disponível, consulte [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) na *Referência geral da AWS*.

1. Salvar `amazon-ses-sample.rb`.

1. Para executar o programa, abra um prompt de comando no mesmo diretório de `amazon-ses-sample.rb` e digite **ruby amazon-ses-sample.rb**

1. Revise a saída. Se o e-mail foi enviado com êxito, o console exibirá "`Email sent!`"; do contrário, ele exibirá uma mensagem de erro.

1. Entre no cliente de e-mail do endereço de destinatário. Você encontrará a mensagem que enviou.

------
#### [ Python ]

Este tópico mostra como usar o [AWS SDK para Python (Boto)](https://aws.amazon.com/sdk-for-python/) para enviar um e-mail pelo Amazon SES. 

**Antes de começar, execute as seguintes tarefas:**
+ **Verifique seu endereço de e-mail com o Amazon SES**: antes de enviar e-mails com o Amazon SES, é necessário verificar se você é o proprietário do endereço de e-mail remetente. Se sua conta ainda estiver na sandbox do Amazon SES, você também deverá verificar o endereço de e-mail do destinatário. Recomendamos que você use o console do Amazon SES para verificar endereços de e-mail. Para obter mais informações, consulte [Criação da identidade de um endereço de e-mail](creating-identities.md#verify-email-addresses-procedure). 
+ **Obtenha suas AWS credenciais** — Você precisa de um ID de chave de AWS acesso e uma chave de acesso AWS secreta para acessar o Amazon SES usando um SDK. Você pode encontrar suas credenciais na página [Credenciais de segurança](https://console.aws.amazon.com/iam/home?#security_credential) do Console de gerenciamento da AWS. Para obter mais informações sobre credenciais, consulte [Tipos de credenciais do Amazon SES](send-email-concepts-credentials.md).
+ **Instale o Python — o Python** [está disponível em thon.org/downloads/. https://www.py](https://www.python.org/downloads/) O código neste tutorial foi testado com a versão Python 2.7.6 e Python 3.6.1. Depois de instalar o Python, adicione o caminho para o Python nas suas variáveis de ambiente, de forma que possa executar o Python a partir de qualquer prompt de comando.
+ **Instale o AWS SDK para Python (Boto)** — Para obter instruções de download e instalação, consulte a [AWS SDK para Python (Boto) documentação](https://boto3.readthedocs.io/en/latest/guide/quickstart.html#installation). O código de exemplo neste tutorial foi testado com a versão 1.4.4 do SDK for Python.

**Para enviar e-mail pelo Amazon SES usando o SDK for Python**

1. Em um editor de texto, crie um arquivo chamado `amazon-ses-sample.py`. Cole o seguinte código no arquivo:

   ```
    1. import boto3
    2. from botocore.exceptions import ClientError
    3. 
    4. # Replace sender@example.com with your "From" address.
    5. # This address must be verified with Amazon SES.
    6. SENDER = "Sender Name <sender@example.com>"
    7. 
    8. # Replace recipient@example.com with a "To" address. If your account 
    9. # is still in the sandbox, this address must be verified.
   10. RECIPIENT = "recipient@example.com"
   11. 
   12. # Specify a configuration set. If you do not want to use a configuration
   13. # set, comment the following variable, and the 
   14. # ConfigurationSetName=CONFIGURATION_SET argument below.
   15. CONFIGURATION_SET = "ConfigSet"
   16. 
   17. # If necessary, replace us-west-2 with the AWS Region you're using for Amazon SES.
   18. AWS_REGION = "us-west-2"
   19. 
   20. # The subject line for the email.
   21. SUBJECT = "Amazon SES Test (SDK for Python)"
   22. 
   23. # The email body for recipients with non-HTML email clients.
   24. BODY_TEXT = ("Amazon SES Test (Python)\r\n"
   25.              "This email was sent with Amazon SES using the "
   26.              "AWS SDK para Python (Boto)."
   27.             )
   28.             
   29. # The HTML body of the email.
   30. BODY_HTML = """<html>
   31. <head></head>
   32. <body>
   33.   <h1>Amazon SES Test (SDK for Python)</h1>
   34.   <p>This email was sent with
   35.     <a href='https://aws.amazon.com/ses/'>Amazon SES</a> using the
   36.     <a href='https://aws.amazon.com/sdk-for-python/'> AWS SDK para Python (Boto)</a>.</p>
   37. </body>
   38. </html>
   39.             """            
   40. 
   41. # The character encoding for the email.
   42. CHARSET = "UTF-8"
   43. 
   44. # Create a new SES resource and specify a region.
   45. client = boto3.client('ses',region_name=AWS_REGION)
   46. 
   47. # Try to send the email.
   48. try:
   49.     #Provide the contents of the email.
   50.     response = client.send_email(
   51.         Destination={
   52.             'ToAddresses': [
   53.                 RECIPIENT,
   54.             ],
   55.         },
   56.         Message={
   57.             'Body': {
   58.                 'Html': {
   59.                     'Charset': CHARSET,
   60.                     'Data': BODY_HTML,
   61.                 },
   62.                 'Text': {
   63.                     'Charset': CHARSET,
   64.                     'Data': BODY_TEXT,
   65.                 },
   66.             },
   67.             'Subject': {
   68.                 'Charset': CHARSET,
   69.                 'Data': SUBJECT,
   70.             },
   71.         },
   72.         Source=SENDER,
   73.         # If you are not using a configuration set, comment or delete the
   74.         # following line
   75.         ConfigurationSetName=CONFIGURATION_SET,
   76.     )
   77. # Display an error if something goes wrong.	
   78. except ClientError as e:
   79.     print(e.response['Error']['Message'])
   80. else:
   81.     print("Email sent! Message ID:"),
   82.     print(response['MessageId'])
   ```

1. Em `amazon-ses-sample.py`, substitua o seguinte pelos seus próprios valores:
   + **`sender@example.com`**: substitua por um endereço de e-mail que você verificou com o Amazon SES. Para obter mais informações, consulte [Identidades](verify-addresses-and-domains.md). Os endereços de e-mail no Amazon SES diferenciam maiúsculas de minúsculas. Certifique-se de que o endereço informado seja exatamente o mesmo que você verificou.
   + **`recipient@example.com`**: substitua pelo endereço do destinatário. Se sua conta ainda estiver na sandbox, você precisará verificar esse endereço antes de usá-lo. Para obter mais informações, consulte [Solicitar acesso à produção (sair da sandbox do Amazon SES)](request-production-access.md). Certifique-se de que o endereço informado seja exatamente o mesmo que você verificou.
   + **(Opcional) `us-west-2`**: se você deseja usar o Amazon SES em uma região que não seja Oeste dos EUA (Oregon), substitua isso pela região que você deseja usar. Para obter uma lista das regiões onde o Amazon SES está disponível, consulte [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) na *Referência geral da AWS*.

1. Salvar `amazon-ses-sample.py`.

1. Para executar o programa, abra um prompt de comando no mesmo diretório de `amazon-ses-sample.py` e, em seguida, digite **python amazon-ses-sample.py**.

1. Revise a saída. Se o e-mail foi enviado com êxito, o console exibirá "`Email sent!`"; do contrário, ele exibirá uma mensagem de erro.

1. Entre no cliente de e-mail do endereço de destinatário. Você verá a mensagem que enviou.

------

# Criação de um arquivo de credenciais compartilhado para usar ao enviar e-mails pelo Amazon SES usando um SDK AWS
<a name="create-shared-credentials-file"></a>

O procedimento a seguir mostra como criar um arquivo de credenciais compartilhadas no diretório inicial. Para o código de amostra do SDK funcionar corretamente, você deve criar este arquivo.

1. Em um editor de texto, crie um novo arquivo. No arquivo, cole o código a seguir:

   ```
   1. [default]
   2. aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
   3. aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
   ```

1. No arquivo de texto que você acabou de criar, `YOUR_AWS_ACCESS_KEY` substitua por sua ID de chave de AWS acesso exclusiva e `YOUR_AWS_SECRET_ACCESS_KEY` substitua por sua chave de acesso AWS secreta exclusiva.

1. Salve o arquivo. A tabela a seguir mostra a localização correta e o nome do arquivo para o seu sistema operacional.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/ses/latest/dg/create-shared-credentials-file.html)
**Importante**  
Não inclua uma extensão de arquivo ao salvar o arquivo de credenciais.

# Codificações de conteúdo compatíveis com o Amazon SES
<a name="content-encodings"></a>

O conteúdo a seguir é fornecido para consulta.

O Amazon SES é compatível com as seguintes codificações de conteúdo:
+ `deflate`
+ `gzip`
+ `identity`

O Amazon SES também é compatível com o formato de cabeçalho Accept-Encoding abaixo, de acordo com a especificação [RFC 7231](https://tools.ietf.org/html/rfc7231#section-5.3.4):
+ `Accept-Encoding:deflate,gzip`
+ `Accept-Encoding:`
+ `Accept-Encoding:*`
+ `Accept-Encoding:deflate;q=0.5,gzip;q=1.0`
+ `Accept-Encoding:gzip;q=1.0,identity;q=0.5,*;q=0`

# Amazon SES e protocolos de segurança
<a name="security-protocols"></a>

Este tópico descreve os protocolos de segurança que você pode usar quando se conecta ao Amazon SES, bem como quando o Amazon SES entrega um e-mail a um receptor.

## Remetente de e-mail para o Amazon SES
<a name="security-client-to-ses"></a>

O protocolo de segurança que você usa para se conectar ao Amazon SES depende de você estar usando a API do Amazon SES ou a interface SMTP do Amazon SES, conforme descrito a seguir.

### HTTPS
<a name="security-client-to-ses-api"></a>

Se você estiver usando a API do Amazon SES (diretamente ou por meio de um AWS SDK), todas as comunicações serão criptografadas por TLS por meio do endpoint HTTPS do Amazon SES. O endpoint HTTPS do Amazon SES é compatível com o TLS 1.2 e o TLS 1.3.

### Interface SMTP
<a name="security-client-to-ses-smtp"></a>

Se estiver acessando o Amazon SES por meio da interface SMTP, você precisará criptografar a conexão usando o Transport Layer Security (TLS). Observe que a TLS é normalmente chamada pelo nome de seu protocolo antecessor, Secure Sockets Layer (SSL).

O Amazon SES oferece suporte a dois mecanismos para estabelecer conexão criptografada por TLS: STARTTLS e TLS Wrapper.
+ **STARTTLS**: o STARTTLS é um meio de atualizar uma conexão não criptografada para uma conexão criptografada. Existem versões do STARTTLS para diversos protocolos; a versão SMTP é definida em [RFC 3207](https://www.ietf.org/rfc/rfc3207.txt). Para conexões STARTTLS, o Amazon SES é compatível com o TLS 1.2 e TLS 1.3.
+ **TLS Wrapper**: o TLS Wrapper (também conhecido como SMTPS ou Handshake Protocol) é um meio de iniciar uma conexão criptografada sem antes estabelecer uma conexão não criptografada. Com o TLS Wrapper, o endpoint SMTP do Amazon SES não faz a negociação de TLS. É responsabilidade do cliente se conectar ao endpoint usando TLS e continuar usando TLS durante toda a conversa. O TLS Wrapper é um protocolo mais antigo, mas ainda é compatível com muitos clientes. Para conexões do TLS Wrapper, o Amazon SES é compatível com o TLS 1.2 e o TLS 1.3.

Para obter informações sobre como conectar com a interface SMTP do Amazon SES usando esses métodos, consulte [Conexão com um endpoint SMTP do Amazon SES](smtp-connect.md).

## Amazon SES para o receptor
<a name="security-ses-to-receiver"></a>

 Embora o TLS 1.3 seja nosso método de entrega padrão, o SES pode entregar e-mails aos servidores de e-mail usando versões anteriores do TLS. 

Por padrão, o Amazon SES usa *TLS oportunista*. O TLS oportunista no SES sempre usa STARTTLS e não inclui o TLS Wrapper. O fluxo envolve o estabelecimento de uma conexão inicial de texto simples, seguida pela atualização para uma sessão criptografada por TLS se o cliente e o servidor oferecerem suporte a STARTTLS. Se o SES não conseguir estabelecer uma conexão segura, ele enviará a mensagem não criptografada.

É possível alterar esse comportamento usando conjuntos de configurações. Use a operação [PutConfigurationSetDeliveryOptions](https://docs.aws.amazon.com/ses/latest/APIReference/API_PutConfigurationSetDeliveryOptions.html)da API para definir a `TlsPolicy` propriedade de uma configuração definida como`Require`. É possível usar a [AWS CLI](https://aws.amazon.com/cli) para fazer essa alteração.

**Para configurar o Amazon SES para exigir conexões TLS em um conjunto de configurações**
+ Na linha de comando, insira o seguinte comando:

  ```
  aws sesv2 put-configuration-set-delivery-options --configuration-set-name MyConfigurationSet --tls-policy REQUIRE
  ```

  No exemplo anterior, *MyConfigurationSet* substitua pelo nome do seu conjunto de configurações.

  Ao enviar um e-mail usando esse conjunto de configurações, o Amazon SES só envia a mensagem para o servidor de recebimento de e-mails se puder estabelecer uma conexão segura. Se o Amazon SES não conseguir estabelecer uma conexão segura com o servidor de recebimento de e-mails, ele descarta a mensagem.

## End-to-end criptografia
<a name="security-end-to-end"></a>

Você pode usar o Amazon SES para enviar mensagens criptografadas usando S/MIME ou PGP. As mensagens que usam esses protocolos são criptografadas pelo remetente. O conteúdo delas só pode ser visualizado por destinatários que possuem as chaves privadas necessárias para descriptografar as mensagens.

O Amazon SES oferece suporte aos seguintes tipos de MIME, que você pode usar para enviar e-mails S/MIME criptografados:
+ `application/pkcs7-mime`
+ `application/pkcs7-signature`
+ `application/x-pkcs7-mime`
+ `application/x-pkcs7-signature`

O Amazon SES também suporta os seguintes tipos de MIME, que podem ser usados para enviar e-mail criptografado por PGP:
+ `application/pgp-encrypted`
+ `application/pgp-keys`
+ `application/pgp-signature`

# Campos de cabeçalho do Amazon SES
<a name="header-fields"></a>

O Amazon SES pode aceitar todos os cabeçalhos de e-mail que seguem o formato descrito na [RFC 822](https://www.rfc-editor.org/rfc/rfc822.html).

Os seguintes campos não podem aparecer mais de uma vez na seção de cabeçalho de uma mensagem:
+ `Accept-Language`
+ `acceptLanguage`
+ `Archived-At`
+ `Auto-Submitted`
+ `Bounces-to`
+ `Comments`
+ `Content-Alternative`
+ `Content-Base`
+ `Content-Class`
+ `Content-Description`
+ `Content-Disposition`
+ `Content-Duration`
+ `Content-ID`
+ `Content-Language`
+ `Content-Length`
+ `Content-Location`
+ `Content-MD5`
+ `Content-Transfer-Encoding`
+ `Content-Type`
+ `Date`
+ `Delivered-To `
+ `Disposition-Notification-Options`
+ `Disposition-Notification-To`
+ `DKIM-Signature`
+ `DomainKey-Signature`
+ `Errors-To`
+ `From`
+ `Importance`
+ `In-Reply-To`
+ `Keywords`
+ `List-Archive`
+ `List-Help`
+ `List-Id`
+ `List-Owner`
+ `List-Post`
+ `List-Subscribe`
+ `List-Unsubscribe`
+ `List-Unsubscribe-Post`
+ `Message-Context`
+ `Message-ID`
+ `MIME-Version`
+ `Organization`
+ `Original-From`
+ `Original-Message-ID`
+ `Original-Recipient`
+ `Original-Subject`
+ `Precedence`
+ `Priority`
+ `References`
+ `Reply-To`
+ `Return-Path`
+ `Return-Receipt-To`
+ `Sender`
+ `Solicitation`
+ `Sensitivity`
+ `Subject`
+ `Thread-Index`
+ `Thread-Topic`
+ `User-Agent`
+ `VBR-Info`

**Considerações**
+ O campo `acceptLanguage` é não padrão. Se for possível, você deve usar o cabeçalho `Accept-Language`.
+ Se você especificar um cabeçalho `Date`, o Amazon SES o substitui por um carimbo de hora correspondente à data e hora no fuso horário UTC de quando o Amazon SES aceitou a mensagem.
+ Se você fornecer um cabeçalho `Message-ID`, o Amazon SES substitui o cabeçalho por seu próprio valor.
+ Se você especificar um cabeçalho `Return-Path`, o Amazon SES envia notificações de devolução e reclamação para o endereço especificado. Porém, a mensagem que seus destinatários recebem contém um valor diferente para o cabeçalho `Return-Path`.
+ Se você usar a operação `SendEmail` da API v2 do Amazon SES com conteúdo *simples* ou *modelado*, ou usar a operação `SendBulkEmail`, não poderá definir conteúdo de cabeçalho personalizado para cabeçalhos definidos pelo SES; portanto, os seguintes cabeçalhos não podem ser personalizados:
  + `BCC`, `CC`, `Content-Disposition`, `Content-Type`, `Date`, `From`, `Message-ID`, `MIME-Version`, `Reply-To`, `Return-Path`, `Subject`, `To`

# Como trabalhar com anexos de e-mail no SES
<a name="attachments"></a>

Os anexos de e-mail no SES são arquivos que você pode incluir em suas mensagens de e-mail ao usar as operações `SendEmail` e `SendBulkEmail` da API v2 do SES. Esse recurso permite que você enriqueça o conteúdo do seu e-mail incluindo documentos como arquivos do Word PDFs, imagens ou outros tipos de arquivo que estejam em conformidade com os tipos MIME suportados pelo SES. Você também pode incluir imagens em linha que são renderizadas diretamente no conteúdo do e-mail sem exigir que os destinatários as baixem separadamente. É possível incluir vários anexos por e-mail, até o limite total do tamanho da mensagem de 40 MB.

**nota**  
A operação [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html) da API v2 do SES com tipo de conteúdo `Raw`, interface SMTP e API v1 do SES continuam lidando com anexos por meio da [construção de mensagens MIME de e-mail bruto](send-email-raw.md#send-email-raw-mime).

## Como funcionam os anexos no SES
<a name="how-attachments-work"></a>

Há dois tipos diferentes de codificação que ocorrem em estágios diferentes ao enviar um e-mail com anexos:

Etapa 1: envio de dados para o SES
+ Quando você deseja enviar um anexo para o SES, os dados binários (como um PDF ou imagem) precisam ser convertidos em um formato que possa ser transmitido com segurança.
+ É aqui que entra a codificação base64. Ela é necessária porque não é possível enviar dados binários brutos em uma solicitação JSON.
+ Se você estiver usando o AWS SDK, ele manipula essa codificação automaticamente.
+ Se você estiver usando o AWS CLI, você mesmo precisará codificar o anexo em base64 antes de enviá-lo.

Etapa 2: criação do e-mail pelo SES
+ Depois que o SES recebe seus dados, ele precisa criar um e-mail real com o anexo.
+ É aqui que a [ContentTransferEncoding](#attachment-structure)configuração entra em jogo.
+ O SES usará qualquer método de codificação especificado ContentTransferEncoding para formatar automaticamente o anexo no e-mail final.

Pense em algo semelhante a enviar um pacote pelo correio. Primeiro, você precisa levar o pacote ao correio (Estágio 1 - é necessária a codificação Base64) e, em seguida, o correio o empacotará adequadamente para entrega final (Estágio 2 -). ContentTransferEncoding

## Estrutura de objeto de anexo
<a name="attachment-structure"></a>

Quando você envia um e-mail com anexos por meio do SES, o serviço processa automaticamente a complexa construção de mensagens MIME. Você só precisa fornecer o conteúdo e os metadados do anexo por meio da seguinte estrutura de objeto [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Attachment.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Attachment.html) da API v2 do SES:
+ `FileName` (obrigatório): o nome do arquivo exibido aos destinatários (deve incluir a extensão do arquivo). Se não for fornecido, o SES derivará um `ContentType` da extensão do `FileName`.
+ `ContentType` (opcional): [identificador de tipo de mídia compatível com IANA](https://www.iana.org/assignments/media-types/media-types.xhtml).
+ `ContentDisposition` (opcional): especifica como o anexo deve ser renderizado: `ATTACHMENT` *(padrão)* ou `INLINE`.
+ `ContentDescription` (opcional): breve descrição do conteúdo.
+ `RawContent` (obrigatório): o conteúdo real do anexo.
+ `ContentTransferEncoding` (opcional): especifica como a carga útil do anexo é codificada quando é montada na mensagem MIME do e-mail: `SEVEN_BIT` *(padrão)*, `BASE64` ou `QUOTED_PRINTABLE`.

Todo o conteúdo anexado deve ser codificado em base64 antes de ser transferido para o endpoint do SES para envio. Se você estiver usando o cliente AWS SDK para fazer chamadas de API, isso será feito automaticamente para você. Se você estiver usando o AWS CLI, ou tiver implementado seu próprio cliente, você mesmo terá que fazer a codificação, como:
+ Conteúdo de texto simples: `Text attachment sample content.`
+ Codificação base64: `VGV4dCBhdHRhY2htZW50IHNhbXBsZSBjb250ZW50Lg==`

Os exemplos a seguir mostram como usar a estrutura do objeto anexo ao especificar anexos com a API SES v2 [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html)e [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html)operações usando a AWS CLI referência a um arquivo JSON contendo elementos do objeto anexo.

**Example — SendEmail com conteúdo simples**  

```
aws sesv2 send-email --cli-input-json file://request-send-email-simple.json
```
**request-send-email-simple.json**  

```
{
    "FromEmailAddress": "sender@example.com",
    "Destination": {
        "ToAddresses": [
            "recipient@example.com"
        ]
    },
    "Content": {
        "Simple": {
            "Subject": {
                "Data": "Email with attachment"
            },
            "Body": {
                "Text": {
                    "Data": "Please see attached document."
                },
                "Html": {
                    "Data": "Please see attached <b>document</b>."
                }
            },
            "Attachments": [
                {
                    "RawContent": "<base64-encoded-content>",
                    "ContentDisposition": "ATTACHMENT",
                    "FileName": "document.pdf",
                    "ContentDescription": "PDF Document Attachment",
                    "ContentTransferEncoding": "BASE64"
                }
            ]
        }
    }
}
```

**Example — SendEmail com conteúdo simples e anexo embutido**  

```
aws sesv2 send-email --cli-input-json file://request-send-email-simple-inline-attachment.json
```
**request-send-email-simple-inline-attachment.json**  

```
{
    "FromEmailAddress": "sender@example.com",
    "Destination": {
        "ToAddresses": [
            "recipient@example.com"
        ]
    },
    "Content": {
        "Simple": {
            "Subject": {
                "Data": "Email with attachment"
            },
            "Body": {
                "Html": {
                    "Data": "<html><body>Our logo:<br><img src=\"cid:logo123\" alt=\"Company Logo\"></body></html>"
                }
            },
            "Attachments": [
                {
                    "RawContent": "<base64-encoded-content>",
                    "ContentDisposition": "INLINE",
                    "FileName": "logo.png",
                    "ContentId": "logo123",
                    "ContentTransferEncoding": "BASE64"
                }
            ]
        }
    }
}
```

**Example — SendEmail com conteúdo do modelo**  

```
aws sesv2 send-email --cli-input-json file://request-send-email-template.json
```
**request-send-email-template.json**  

```
{
    "FromEmailAddress": "sender@example.com",
    "Destination": {
        "ToAddresses": [
            "recipient@example.com"
        ]
    },
    "Content": {
        "Template": {
            "TemplateName": "MyTemplate",
            "TemplateData": "{\"name\":\"John\"}",
            "Attachments": [
                {
                    "RawContent": "<base64-encoded-content>",
                    "ContentDisposition": "ATTACHMENT",
                    "FileName": "document.pdf",
                    "ContentDescription": "PDF Document Attachment",
                    "ContentTransferEncoding": "BASE64"
                }
            ]
        }
    }
}
```

**Example — SendBulkEmail com conteúdo anexo**  

```
aws sesv2 send-bulk-email --cli-input-json file://request-send-bulk-email.json
```
**request-send-bulk-email.json**  

```
{
    "FromEmailAddress": "sender@example.com",
    "DefaultContent": {
        "Template": {
            "TemplateName": "MyTemplate",
            "TemplateData": "{}",
            "Attachments": [
                {
                    "RawContent": "<base64-encoded-content>",
                    "ContentDisposition": "ATTACHMENT",
                    "FileName": "document.pdf",
                    "ContentDescription": "PDF Document Attachment",
                    "ContentTransferEncoding": "BASE64"
                }
            ]
        }
    },
    "BulkEmailEntries": [
        {
            "Destination": {
                "ToAddresses": [
                    "recipient@example.com"
                ]
            },
            "ReplacementEmailContent": {
                "ReplacementTemplate": {
                    "ReplacementTemplateData": "{\"name\":\"John\"}"
                }
            }
        }
    ]
}
```

## Práticas recomendadas
<a name="attachments-best-practices"></a>
+ Mantenha o tamanho total da mensagem (incluindo anexos) abaixo de 40 MB.
+ Permita que o SES detecte automaticamente os tipos de conteúdo com base nas extensões de arquivo, quando possível.
+ Especifique explicitamente os tipos de conteúdo somente quando eles estiverem fora dos [tipos MIME comuns](https://developer.mozilla.org/en-US/docs/Web/HTTP/MIME_types/Common_types).
+ Considere o uso de imagens em linha para melhorar a renderização de e-mails.
+ O SES oferece suporte a uma ampla variedade de tipos MIME para anexos, exceto aqueles listados em [Tipos de anexos incompatíveis](#mime-types).

## Tipos de anexo incompatíveis com o SES
<a name="mime-types"></a>

Você pode enviar mensagens com anexos por meio do Amazon SES usando o padrão Multipurpose Internet Mail Extensions (MIME). O Amazon SES aceita todos os tipos de anexos de arquivos, *exceto* anexos com as extensões de arquivo na lista a seguir.


|  |  |  |  |  | 
| --- |--- |--- |--- |--- |
| .ade .adp .app .asp .bas .bat .cer .chm .cmd .com .cpl .crt .csh .der .exe .fxp .gadget .hlp  | .hta .inf .ins .isp .its .js .jse .ksh .lib .lnk .mad .maf .mag .mam .maq .mar .mas .mat  | .mau .mav .maw .mda .mdb .mde .mdt .mdw .mdz .msc .msh .msh1 .msh2 .mshxml .msh1xml .msh2xml .msi .msp  | .mst .ops .pcd .pif .plg .prf .prg .reg .scf .scr .sct .shb .shs .sys .ps1 .ps1xml .ps2 .ps2xml  | .psc1 .psc2 .tmp .url .vb .vbe .vbs .vps .vsmacros .vss .vst .vsw .vxd .ws .wsc .wsf .wsh .xnk  | 

Alguns ISPs têm restrições adicionais (como restrições relacionadas a anexos arquivados), por isso recomendamos testar seu envio de e-mail por meio do major ISPs antes de enviar o e-mail de produção.