Como Instalar Plane.so em VPS Linux: Guia Completo

Introdução ao Plane.so: A Alternativa Open Source ao Jira

No cenário atual de desenvolvimento de software e gestão de projetos, a escolha da ferramenta correta é tão crítica quanto a arquitetura do próprio código. Profissionais que buscam controle total sobre seus dados, privacidade e personalização profunda frequentemente encontram barreiras nas soluções SaaS tradicionais. É aqui que o Plane.so se destaca como uma das alternativas Jira mais robustas e modernas disponíveis no mercado open source.

O Plane é um software de gestão de projetos de código aberto projetado para equipes de engenharia, produtos e design. Diferente de ferramentas genéricas, ele foi construído com foco na experiência do desenvolvedor (DevEx) e na simplicidade, oferecendo tabelas, quadros Kanban e visualizações de cronograma de forma fluida. Para sysadmins e DevOps engineers que desejam manter a infraestrutura sob controle, instalar o Plane.so em uma VPS Linux é a escolha ideal para criar um servidor próprio de gestão, sem dependências de terceiros.

Neste tutorial técnico da Toda Solução, guiamos você passo a passo pela instalação completa do Plane.so utilizando Docker e Docker Compose. Este método garante isolamento, facilidade de manutenção e atualizações simplificadas, seguindo as melhores práticas de contêinerização para ambientes Linux.

Requisitos de Infraestrutura e Pré-requisitos

Antes de iniciarmos a instalação, é fundamental garantir que seu ambiente atenda aos requisitos mínimos para rodar o Plane.so com estabilidade. O Plane utiliza uma stack moderna baseada em Django (backend) e React (frontend), conectados através de um banco de dados PostgreSQL e gerenciados por filas assíncronas via Celery.

• Sistema Operacional: Linux Ubuntu 20.04/22.04 LTS ou Debian 11/12 (recomendado).
• Processador: Arquitetura x86_64 (amd64). O suporte a ARM está em desenvolvimento, mas para produção estável, utilize x86.
• Memória RAM: Mínimo de 2GB, recomendando 4GB ou mais para ambientes com múltiplos usuários.
• Espaço em Disco: Pelo menos 20GB de SSD para armazenar o banco de dados, arquivos estáticos e logs do Docker.
• Docker e Docker Compose: Versões atualizadas instaladas no servidor.
• Domínio ou Subdomínio: Um domínio apontando para o IP da sua VPS (ex: plane.seudominio.com) é necessário para configurar o Nginx corretamente e gerar certificados SSL.

Se você ainda não possui o Docker instalado, execute os comandos abaixo para preparar seu ambiente Linux:

# Atualize os pacotes do sistema
sudo apt update && sudo apt upgrade -y

# Instale dependências necessárias
sudo apt install apt-transport-https ca-certificates curl software-properties-common -y

# Adicione a chave GPG oficial do Docker
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Adicione o repositório estável
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list

# Instale o Docker Engine
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io -y

# Instale o Docker Compose Plugin
sudo apt install docker-compose-plugin -y

# Adicione seu usuário ao grupo docker para evitar usar sudo a cada comando
sudo usermod -aG docker $USER

Lembre-se de fazer logout e login novamente ou reiniciar o terminal para que as alterações de grupo tenham efeito.

Configuração do Ambiente Docker Compose

A instalação do Plane.so é orquestrada através de um arquivo docker-compose.yml. Este arquivo define todos os serviços necessários: o banco de dados PostgreSQL, o servidor Redis para cache e filas, o backend Django, o worker Celery e o frontend Nginx.

Crie um diretório dedicado para a instalação. Isso facilita backups e atualizações futuras:

mkdir -p ~/plane-so && cd ~/plane-so

Agora, crie o arquivo de configuração principal. O Plane.so oferece uma configuração padrão otimizada em seu repositório oficial. Para este tutorial, criaremos uma estrutura manual simplificada que reflete a configuração recomendada para produção leve.

nano docker-compose.yml

Cole o seguinte conteúdo no arquivo. Note as variáveis de ambiente essenciais que devem ser personalizadas, especialmente as senhas e chaves secretas:

version: "3.8"

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile.web
    image: ghcr.io/makeplane/plane-web:latest
    restart: unless-stopped
    command: /bin/sh -c "cd /usr/src/plane-frontend && npm run start"
    environment:
      - NEXT_PUBLIC_PLANE_WEB_APP_URL=http://localhost:3000
    ports:
      - "3000:3000"
    depends_on:
      - api

  api:
    build:
      context: .
      dockerfile: Dockerfile.api
    image: ghcr.io/makeplane/plane-backend:latest
    restart: unless-stopped
    command: /bin/sh -c "cd /usr/src/plane-backend && bash entrypoint.sh"
    environment:
      - DJANGO_SETTINGS_MODULE=config.settings.production
      - DATABASE_URL=postgresql://planeuser:${DB_PASSWORD}@db:5432/planedb
      - REDIS_URL=redis://redis:6379/plane-redis-cache/
      - SECRET_KEY=${SECRET_KEY}
      - CELERY_BROKER_URL=redis://redis:6379/plane-redis-broker/
    ports:
      - "8000:8000"
    depends_on:
      - db
      - redis

  worker:
    build:
      context: .
      dockerfile: Dockerfile.api
    image: ghcr.io/makeplane/plane-backend:latest
    restart: unless-stopped
    command: /bin/sh -c "cd /usr/src/plane-backend && celery -A plane worker -l info"
    environment:
      - DJANGO_SETTINGS_MODULE=config.settings.production
      - DATABASE_URL=postgresql://planeuser:${DB_PASSWORD}@db:5432/planedb
      - REDIS_URL=redis://redis:6379/plane-redis-cache/
      - SECRET_KEY=${SECRET_KEY}
      - CELERY_BROKER_URL=redis://redis:6379/plane-redis-broker/
    depends_on:
      - db
      - redis

  beat-worker:
    build:
      context: .
      dockerfile: Dockerfile.api
    image: ghcr.io/makeplane/plane-backend:latest
    restart: unless-stopped
    command: /bin/sh -c "cd /usr/src/plane-backend && celery -A plane beat --loglevel=info"
    environment:
      - DJANGO_SETTINGS_MODULE=config.settings.production
      - DATABASE_URL=postgresql://planeuser:${DB_PASSWORD}@db:5432/planedb
      - REDIS_URL=redis://redis:6379/plane-redis-cache/
      - SECRET_KEY=${SECRET_KEY}
    depends_on:
      - db
      - redis

  db:
    image: postgres:15-alpine
    restart: unless-stopped
    command: postgres '--max_connections=200'
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=planeuser
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_DB=planedb

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: redis-server --appendonly yes
    volumes:
      - redisdata:/data

volumes:
  pgdata:
  redisdata:

Atenção Crítica: O código acima é uma estrutura base. Para uma instalação segura, você deve criar um arquivo .env na mesma pasta para gerenciar as variáveis sensíveis, em vez de deixá-las expostas no compose ou usar valores hardcoded.

Crie o arquivo .env:

nano .env

Adicione as seguintes linhas, gerando chaves aleatórias fortes para a senha do banco e o segredo da aplicação:

# Chave secreta do Django (Gere uma chave longa e aleatória)
SECRET_KEY=gerar_uma_chave_secreta_ultra_segura_aqui

# Senha do Banco de Dados PostgreSQL
DB_PASSWORD=sua_senha_forte_do_postgres_aqui

Para gerar chaves seguras no terminal, use:

# Gerar SECRET_KEY
python3 -c "import secrets; print(secrets.token_urlsafe(50))"

# Gerar DB_PASSWORD
openssl rand -base64 32

Inicialização dos Contêineres

Com os arquivos de configuração prontos, o próximo passo é baixar as imagens oficiais do Plane.so e iniciar os contêineres. O processo pode levar alguns minutos dependendo da velocidade da sua internet.

# Baixar as imagens e iniciar os serviços em segundo plano
docker compose up -d

Você pode monitorar o log dos contêineres para verificar se há erros de inicialização, especialmente no serviço api, que realiza as migrações do banco de dados:

# Ver logs do backend
docker compose logs -f api

Quando o comando de migração terminar e o servidor API estiver escutando na porta 8000, a instalação básica estará completa. No entanto, para acessar o Plane.so externamente de forma segura e profissional, é necessário configurar um reverso proxy.

Configuração do Nginx e SSL

Para expor o Plane.so na internet, utilizaremos o Nginx como reverse proxy. Isso permite gerenciar certificados SSL (HTTPS) e rotear o tráfego para a porta interna do frontend (3000).

Instale o Nginx se ainda não estiver instalado:

sudo apt install nginx -y

Crie um arquivo de configuração de site no diretório sites-available:

sudo nano /etc/nginx/sites-available/plane.so

Insira a seguinte configuração, substituindo plane.seudominio.com pelo seu domínio real:

server {
    listen 80;
    server_name plane.seudominio.com;

    # Redirecionar HTTP para HTTPS
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name plane.seudominio.com;

    # Caminhos para os certificados SSL (Configure com Let's Encrypt depois)
    # ssl_certificate /etc/letsencrypt/live/plane.seudominio.com/fullchain.pem;
    # ssl_certificate_key /etc/letsencrypt/live/plane.seudominio.com/privkey.pem;

    # Segurança básica
    client_max_body_size 50m;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }

    location /static/ {
        proxy_pass http://localhost:3000/static;
    }
}

Ative o site e teste a configuração:

# Crie um link simbólico
sudo ln -s /etc/nginx/sites-available/plane.so /etc/nginx/sites-enabled/

# Remova a configuração padrão se existir para evitar conflitos
sudo rm /etc/nginx/sites-enabled/default

# Teste a sintaxe do Nginx
sudo nginx -t

Se o teste for bem-sucedido, recarregue o Nginx:

sudo systemctl reload nginx

Para habilitar o HTTPS, utilize o Certbot para obter certificados gratuitos do Let's Encrypt:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d plane.seudominio.com

O assistente do Certbot irá atualizar automaticamente a configuração do Nginx com os caminhos corretos dos certificados SSL e configurar o redirecionamento HTTPS.

Acesso Inicial e Configurações de Segurança

Com tudo instalado, abra seu navegador e acesse https://plane.seudominio.com. Você verá a tela de login do Plane.so.

Primeiro Acesso: Na primeira vez que acessar o sistema, você será solicitado a criar uma conta de administrador. Certifique-se de usar um e-mail seguro e uma senha forte. Esta conta terá acesso total à configuração do sistema.

Após o login, é altamente recomendável configurar as seguintes opções no painel de administração:

• Email Configuration: Configure o SMTP para permitir que o Plane.so envie convites e notificações por e-mail. Sem isso, os usuários não receberão links de confirmação.
• Security Settings: Ative a autenticação de dois fatores (2FA) se necessário e defina as políticas de senha da organização.
• Storage Configuration: Por padrão, o Plane armazena arquivos anexados localmente no volume do contêiner. Para produção escalável, considere configurar armazenamento S3-compatível (como MinIO ou AWS S3) editando as variáveis de ambiente AWS_STORAGE_BUCKET_NAME, AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY no arquivo .env.

Manutenção e Backup

A gestão de um servidor self-hosted exige disciplina em backups. A saúde do seu Plane.so reside principalmente no banco de dados PostgreSQL.

Crie um script simples de backup para ser executado via cron:

nano ~/backup-plane.sh

#!/bin/bash
# Script de Backup do Plane.so
BACKUP_DIR="/backups/plane"
DATE=$(date +%F)

mkdir -p $BACKUP_DIR

# Backup do Banco de Dados
docker exec plane-so-db_1 pg_dump -U planeuser planedb > $BACKUP_DIR/db_backup_$DATE.sql

# Backup dos Arquivos Estáticos (se houver uploads locais)
docker cp plane-so-web_1:/usr/src/plane-frontend/static $BACKUP_DIR/static_$DATE.tar
# Nota: Ajuste o caminho do volume se estiver usando bind mounts

# Comprimir backups antigos (opcional)
find $BACKUP_DIR -name "*.sql" -mtime +30 -delete

echo "Backup realizado em $DATE"

Torne o script executável e adicione ao crontab:

chmod +x ~/backup-plane.sh
crontab -e
# Adicione a linha: 0 2 * * * /home/seu_usuario/backup-plane.sh >> /var/log/plane-backup.log 2>&1

Conclusão

Instalar o Plane.so em uma VPS Linux oferece um controle sem precedentes sobre a gestão de projetos da sua equipe. Ao optar por esta solução open source, você elimina custos de licença, evita lock-in de dados e ganha flexibilidade para integrar o sistema com outras ferramentas da sua pilha DevOps.

Lembre-se sempre de manter suas imagens Docker atualizadas usando docker compose pull && docker compose up -d periodicamente para garantir a segurança e acessar as novas funcionalidades lançadas pela comunidade do Plane. Com esta infraestrutura sólida, sua equipe estará pronta para colaborar com eficiência em qualquer projeto.