Cansado de configurações complexas de CI/CD? Quer ter o poder do Vercel mas com total controle da sua infraestrutura? Dokploy é a resposta que você estava procurando.

Descobri Dokploy durante uma migração frustrante de Kubernetes para algo mais simples. Após testar dezenas de soluções, encontrei uma plataforma que combina a simplicidade do Heroku com a flexibilidade do Docker – e o melhor de tudo: é totalmente open source.

O Que É Dokploy?

Dokploy é uma plataforma de deployment self-hosted que transforma qualquer VPS em uma máquina de deployment poderosa. Pense no Vercel ou Netlify, mas rodando na sua própria infraestrutura, com suporte total a Docker e integração nativa com GitHub/GitLab.

Por Que Escolher Dokploy?

Depois de anos lutando com Kubernetes, Docker Swarm e scripts bash customizados, encontrei em Dokploy uma solução que resolve problemas reais:

• Simplicidade: Interface web intuitiva para gerenciar deployments

• Flexibilidade: Suporte a qualquer aplicação que rode em Docker

• Controle Total: Sua infraestrutura, suas regras

• Zero Lock-in: Código open source, dados na sua máquina

• Economia: Sem custos por deployment ou limites artificiais

Preparando o Ambiente: Requisitos

Antes de começarmos, você vai precisar de:

Hardware Mínimo

• CPU: 2 cores (4 cores recomendado)

• RAM: 4GB (8GB recomendado)

• Storage: 20GB livres (SSD preferível)

• Rede: IP público com portas 80, 443 e 3000 abertas

Software Base

• OS: Ubuntu 20.04+ (testado e recomendado)

• Docker: Versão 20.10+

• Docker Compose: Versão 2.0+

Passo 1: Configuração Inicial do Servidor

Primeiro, vamos preparar nosso servidor. Se você está usando um VPS na Hetzner, DigitalOcean, ou qualquer outro provedor:

Atualizando o Sistema

# Conecte no seu servidor

ssh root@SEU_IP_AQUI

# Atualize o sistema

apt update && apt upgrade -y

# Instale dependências essenciais

apt install -y curl wget git ufw

Configuração de Firewall

# Configure UFW para segurança básica

ufw allow 22/tcp # SSH

ufw allow 80/tcp # HTTP

ufw allow 443/tcp # HTTPS

ufw allow 3000/tcp # Dokploy UI

ufw --force enable

Instalação do Docker

# Instale Docker usando o script oficial

curl -fsSL https://get.docker.com -o get-docker.sh

sh get-docker.sh

# Inicie e habilite o Docker

systemctl start docker

systemctl enable docker

# Verifique a instalação

docker --version

docker-compose --version

Passo 2: Instalação do Dokploy

Agora vem a parte mais fácil – instalar Dokploy:

# Execute o script de instalação oficial

curl -sSL https://dokploy.com/install.sh | sh

Esse script vai:

1. Baixar a imagem Docker do Dokploy

2. Configurar docker-compose.yml

3. Iniciar todos os serviços necessários

4. Configurar nginx para proxy reverso

Verificando a Instalação

# Verifique se os containers estão rodando

docker ps

# Você deve ver containers como:

# - dokploy

# - dokploy-postgres

# - dokploy-redis

Passo 3: Primeiro Acesso e Configuração

Acessando a Interface Web

Abra seu navegador e acesse:

http://SEU_IP:3000

Configuração Inicial

1. Criar Conta Admin: Defina email e senha para o usuário administrativo

2. Configurar DNS: Configure seu domínio (opcional neste momento)

3. SSL Certificate: Configure Let’s Encrypt para HTTPS automático

Configuração de Domínio (Opcional mas Recomendado)

Se você tem um domínio:

# Configure DNS A record apontando para seu servidor

# exemplo.com -> SEU_IP

# *.exemplo.com -> SEU_IP (para subdomínios automáticos)

Passo 4: Deploy da Primeira Aplicação

Vamos fazer o deploy de uma aplicação Elixir/Phoenix para demonstrar o poder do Dokploy:

1. Preparando o Repositório

Certifique-se que seu projeto tenha:

• Dockerfile na raiz

• Variáveis de ambiente configuradas

• Port binding correto

2. Criando a Aplicação no Dokploy

Na interface web:

1. Clique em “New Application”

2. Selecione “GitHub Repository”

3. Configure o repositório:

   • URL: https://github.com/usuario/projeto

   • Branch: main

   • Build Path: . (raiz do projeto)

   • Dockerfile Path: Dockerfile

3. Configuração de Environment Variables

Configure as variáveis necessárias:

# Exemplo para aplicação Phoenix

DATABASE_URL=postgresql://user:password@host:5432/dbname

SECRET_KEY_BASE=sua_secret_key_super_segura_aqui

MIX_ENV=prod

PORT=4000

PHX_HOST=exemplo.com

4. Configuração de Banco de Dados

Dokploy facilita a criação de bancos:

1. Clique em “New Database”

2. Selecione PostgreSQL/MySQL/MongoDB

3. Configure credenciais

4. Conecte à aplicação

5. Deploy Automático

Clique em “Deploy” e observe a mágica acontecer:

# Logs em tempo real mostrarão:

# → Cloning repository…

# → Building Docker image…

# → Starting container…

# → Health check passed ✅

# → Deployment successful!

Passo 5: Configuração Avançada

SSL Automático com Let’s Encrypt

# No painel Dokploy, vá em Settings > SSL

# Ative “Auto SSL” e configure:

# – Email para certificados

# – Domínios para certificar

Backup Automático

Configure backups para proteção de dados:

# Crie script de backup

#!/bin/bash

# backup-dokploy.sh

DATE=$(date +%Y%m%d_%H%M%S)

BACKUP_DIR="/var/backups/dokploy"

mkdir -p $BACKUP_DIR

# Backup database

docker exec dokploy-postgres pg_dumpall -U postgres > $BACKUP_DIR/postgres_$DATE.sql

# Backup volumes

tar -czf $BACKUP_DIR/volumes_$DATE.tar.gz /var/lib/docker/volumes/

# Manter apenas últimos 7 backups

find $BACKUP_DIR -name "*.sql" -mtime +7 -delete

find $BACKUP_DIR -name "*.tar.gz" -mtime +7 -delete

Monitoramento Básico

Configure alertas básicos:

# Instale htop para monitoramento

apt install -y htop

# Configure logrotate para logs do Docker

echo '/var/lib/docker/containers/*/*-json.log {

daily

missingok

rotate 7

compress

notifempty

create 644 root root

}' > /etc/logrotate.d/docker

Exemplos Práticos: Diferentes Tipos de Deploy

Deploy Node.js/Express

# Dockerfile

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./

RUN npm ci --only=production

COPY . .

EXPOSE 3000

CMD ["npm", "start"]

Deploy Python/FastAPI

# Dockerfile

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Deploy Static Site

# Dockerfile

FROM nginx:alpine

COPY dist/ /usr/share/nginx/html/

EXPOSE 80

Troubleshooting: Problemas Comuns

Build Falha: Dockerfile Não Encontrado

# Problema: Build context incorreto

# Solução: Verifique o “Build Path” no Dokploy

# Deve apontar para onde está o Dockerfile

Aplicação Não Inicia: Port Binding

# Problema: Aplicação não escuta na porta correta

# Solução: Configure variável PORT e bind para 0.0.0.0

PORT=4000

PHX_HOST=0.0.0.0 # Para Phoenix

HOST=0.0.0.0 # Para outras apps

Database Connection Issues

# Problema: App não consegue conectar no banco

# Solução: Use hostname interno do Docker

DATABASE_URL=postgresql://user:pass@dokploy-postgres:5432/db

SSL Certificate Problems

# Problema: Certificado não gera

# Solução: Verifique DNS e firewall

dig exemplo.com # Deve retornar IP do servidor

Vantagens do Dokploy vs. Alternativas

Dokploy vs. Kubernetes

• ✅ Simplicidade: Interface web vs. YAML complexos

• ✅ Recursos: Menor footprint de CPU/RAM

• ✅ Manutenção: Updates automáticos vs. cluster management

• ✅ Curva de aprendizado: Horas vs. semanas

Dokploy vs. Docker Compose Manual

• ✅ UI Visual: Interface web vs. linha de comando

• ✅ Git Integration: Deploy automático vs. manual

• ✅ SSL: Certificados automáticos vs. configuração manual

• ✅ Monitoring: Dashboards integrados vs. ferramentas externas

Dokploy vs. Serviços Cloud

• ✅ Custo: Seu servidor vs. pricing por deployment

• ✅ Controle: Acesso total vs. limitações de platform

• ✅ Privacy: Dados locais vs. third-party

• ✅ Customização: Configuração total vs. opções limitadas

Casos de Uso Reais

Freelancer com Projetos de Clientes

Como freelancer, uso Dokploy para hospedar projetos de diferentes clientes:

• Isolamento por aplicação

• SSL automático para cada domínio

• Backups independentes

• Billing simplificado

Resultado: Margem de lucro 40% maior comparado a usar serviços cloud.

Homelab para Projetos Pessoais

Rodando Dokploy em um mini PC em casa:

• Projetos side-projects

• Ambientes de teste

• Protótipos para clientes

• Learning playground

Resultado: Zero custos mensais, controle total.

Próximos Passos e Otimizações

Configuração de CI/CD Avançado

# .github/workflows/deploy.yml

name: Deploy to Dokploy

on:

push:

branches: [main]

jobs:

deploy:

runs-on: ubuntu-latest

steps:

• name: Trigger Dokploy Deploy

run: |

curl -X POST "${{ secrets.DOKPLOY_WEBHOOK_URL }}"

Monitoramento Avançado

# Instale Prometheus + Grafana via Dokploy

# Configure dashboards para métricas de aplicação

# Setup alertas via Slack/Discord

Backup Strategy

# Script de backup completo para produção

#!/bin/bash

# 1. Database dumps

# 2. Docker volumes backup

# 3. Upload para S3/BackBlaze

# 4. Verificação de integridade

Recursos Úteis

Documentação e Comunidade

• Documentação Oficial

• Discord Community

• GitHub Repository

Templates e Exemplos

• Dokploy Templates

• Community Examples

Conclusão

Dokploy transformou completamente como gerencio deployments. Em vez de passar horas configurando CI/CD pipelines complexos, agora tenho uma plataforma que “simplesmente funciona”.

A combinação de simplicidade do Heroku, flexibilidade do Docker, e controle total da infraestrutura própria faz do Dokploy a escolha perfeita para desenvolvedores que querem focar no que fazem de melhor: criar produtos incríveis.