Introdução

Empresas que buscam melhorar a eficiência operacional precisam de fluxos automáticos que conectem sistemas distintos sem depender de desenvolvimento extensivo. Ferramentas como Zapier e Pluga permitem criar esses fluxos por meio de webhooks, REST APIs e gatilhos baseados em eventos. Neste artigo, vamos explorar como montar um pipeline que captura informações de um formulário web, grava em um banco PostgreSQL, gera relatórios em PDF e envia notificações por Slack, tudo usando recursos reais dessas plataformas.

A proposta aqui não é apenas apresentar conceitos, mas demonstrar passo a passo com scripts reais que você pode copiar e adaptar ao seu contexto. Ao final, você terá um fluxo completo, testado em ambiente local com Docker, pronto para ser migrado para produção.

---

Desenvolvimento

1. Definindo os gatilhos no Zapier

O Zapier trabalha com Zaps – combinações de gatilho + ação. Para nosso caso, o gatilho será a submissão de um formulário Google Forms. No painel do Zapier:

1. Crie um novo Zap.
2. Selecione Google Forms → New Form Response como gatilho.
3. Conecte sua conta Google e escolha o formulário desejado.
4. Teste o gatilho para garantir que o Zap receba os campos corretos.

2. Conectando ao Pluga para orquestrar múltiplas ações

O Pluga permite encadear várias conexões sem escrever código adicional. Vamos usar duas conexões:

• Pluga → PostgreSQL: insere a resposta do formulário em uma tabela.
• Pluga → Slack: envia uma mensagem ao canal de vendas.

No dashboard do Pluga:

1. Crie um novo fluxo.
2. Escolha Google Forms como origem.
3. Selecione PostgreSQL como destino e configure a string de conexão (postgres://user:senha@host:5432/db).
4. Mapeie os campos do formulário para as colunas da tabela.
5. Adicione uma segunda ação apontando para Slack, configure a mensagem com variáveis dinâmicas (ex.: Novo lead: {{nome}} - {{email}}).

3. Persistindo informações em PostgreSQL

Primeiro, criamos a tabela que receberá os dados. Use o script abaixo em seu container PostgreSQL:

sql -- Create table for form leads CREATE TABLE leads ( id SERIAL PRIMARY KEY, nome VARCHAR(100) NOT NULL, email VARCHAR(150) NOT NULL, telefone VARCHAR(30), criado_em TIMESTAMP DEFAULT CURRENT_TIMESTAMP );

4. Gerando relatórios PDF com Python

Depois que os registros estiverem no banco, podemos gerar um relatório semanal. O script abaixo usa Jinja2 para montar um HTML e WeasyPrint para converter em PDF.

python import os import psycopg2 from jinja2 import Environment, FileSystemLoader from weasyprint import HTML

Connection parameters (use env vars in production)

conn = psycopg2.connect( host=os.getenv('PGHOST', 'localhost'), database=os.getenv('PGDATABASE', 'mydb'), user=os.getenv('PGUSER', 'user'), password=os.getenv('PGPASSWORD', 'secret') )

cur = conn.cursor() cur.execute("SELECT nome, email, telefone, criado_em FROM leads ORDER BY criado_em DESC LIMIT 100;") leads = cur.fetchall()

Render HTML template

env = Environment(loader=FileSystemLoader('templates')) template = env.get_template('relatorio.html') html_out = template.render(leads=leads)

Convert to PDF

pdf_path = 'relatorio_semanal.pdf' HTML(string=html_out).write_pdf(pdf_path) print(f'PDF generated: {pdf_path}')

Observação: O diretório templates deve conter o arquivo relatorio.html com a estrutura da tabela.

5. Enviando o PDF para Slack via webhook

O Slack aceita webhooks que recebem um payload JSON. O script abaixo lê o PDF gerado e o envia como anexo.

bash #!/usr/bin/env bash

Variables

WEBHOOK_URL="https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX" FILE_PATH="relatorio_semanal.pdf"

Use curl to post multipart/form-data

curl -F file=@${FILE_PATH}
-F "initial_comment=Relatório semanal de leads"
-F channels=#vendas
-H "Authorization: Bearer xoxb-YourSlackBotToken"
https://slack.com/api/files.upload

6. Empacotando tudo com Docker Compose

Para facilitar a execução, criamos um docker-compose.yml que levanta PostgreSQL, o script Python e um container Bash para o envio ao Slack.

yaml version: '3.8' services: db: image: postgres:15-alpine environment: POSTGRES_USER: user POSTGRES_PASSWORD: secret POSTGRES_DB: mydb volumes: - pgdata:/var/lib/postgresql/data ports: - "5432:5432"

reporter: build: ./reporter environment: PGHOST: db PGDATABASE: mydb PGUSER: user PGPASSWORD: secret depends_on: - db

slack_sender: image: curlimages/curl:8.0.1 volumes: - ./relatorio_semanal.pdf:/data/relatorio_semanal.pdf entrypoint: ["/bin/sh", "-c"] command: | "curl -F file=@/data/relatorio_semanal.pdf
-F 'initial_comment=Relatório semanal'
-F channels=#vendas
-H 'Authorization: Bearer xoxb-YourSlackBotToken'
https://slack.com/api/files.upload" depends_on: - reporter

volumes: pgdata:

No diretório reporter, inclua um Dockerfile que instala as dependências Python:

dockerfile FROM python:3.11-slim WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . CMD ["python", "gerar_relatorio.py"]

requirements.txt

psycopg2-binary Jinja2 WeasyPrint

Com docker-compose up -d, o banco inicia, o script Python gera o PDF e o container slack_sender o entrega ao Slack.

7. Monitoramento e ajustes

• Zapier oferece logs de execução; verifique falhas nos gatilhos.
• Pluga permite visualizar o histórico de cada conexão.
• No PostgreSQL, crie índices nas colunas email e criado_em para melhorar a performance de consultas de relatório.
• Use variáveis de ambiente para segredos (tokens Slack, credenciais DB) e nunca os exponha no código.

---

Exemplos Práticos

7.1. Testando o webhook do Zapier localmente

Para validar o webhook antes de publicar, use o serviço ngrok:

bash ngrok http 5000

Copie a URL pública (https://abcd1234.ngrok.io) e configure-a como Webhook URL no Zapier. O Zapier enviará um POST JSON que pode ser capturado por um pequeno servidor Flask:

python from flask import Flask, request, jsonify app = Flask(name)

@app.route('/', methods=['POST']) def receive(): payload = request.json print('Received:', payload) return jsonify(status='ok')

if name == 'main': app.run(port=5000)

7.2. Atualizando o fluxo sem código adicional

Caso precise acrescentar um novo destino (ex.: enviar e‑mail via SendGrid), basta criar outra conexão no Pluga apontando para a API de envio de e‑mail e mapear os mesmos campos. Não há necessidade de tocar nos scripts Python ou Bash.

---

Conclusão

Construir fluxos avançados que conectam formulários, bancos de dados, geração de documentos e comunicação em equipe é hoje uma prática acessível graças a plataformas como Zapier e Pluga. Ao combinar essas ferramentas com scripts leves em Python, Bash e SQL, garantimos flexibilidade e controle sobre cada etapa, além de facilitar a manutenção.

Próximos passos sugeridos:

• Implementar um agendador (ex.: cron dentro do container) para gerar relatórios automaticamente.
• Explorar a API de Google Sheets para armazenar cópias de backup.
• Adotar ferramentas de observabilidade (ex.: Prometheus + Grafana) para monitorar latência dos webhooks.

Com a abordagem mostrada, sua empresa pode escalar processos internos sem depender de grandes equipes de desenvolvimento, focando energia na estratégia de negócio.