Instalar e Configurar Twake Workspace em VPS Linux

10 min de leitura DevOps

O Twake Workspace é uma plataforma colaborativa completa que combina chat, videoconferência, gerenciamento de projetos e armazenamento de arquivos em um único ambiente. Para equipes que priorizam a soberania dos dados, segurança e personalização, hospedar o Twake em sua própria infraestrutura é uma decisão estratégica. Este tutorial técnico detalha o processo de instalação do Twake Workspace em um servidor Linux (VPS), garantindo um ambiente self-hosted robusto, escalável e pronto para uso profissional.

O gerenciamento de projetos moderno exige ferramentas que não apenas organizem tarefas, mas também integrem comunicação e documentação. Ao optar pelo self-hosted, você elimina a dependência de terceiros, mantém os dados dentro do seu perímetro de segurança e otimiza custos operacionais a longo prazo. Este guia foca na instalação via Docker Compose, a metodologia mais recomendada para ambientes de produção devido à facilidade de gerenciamento de dependências e escalabilidade.

Pré-requisitos de Infraestrutura

Antes de iniciar o processo de instalar twake, é fundamental garantir que sua VPS atenda aos requisitos mínimos de hardware e software. O Twake é uma aplicação rica em recursos, especialmente quando habilitada para videoconferência e processamento de arquivos grandes.

Especificações Recomendadas:

  • CPU: Mínimo de 4 vCPUs (recomendado: 8+ para múltiplos usuários simultâneos).
  • RAM: Mínimo de 16 GB (recomendado: 32 GB para alta performance e armazenamento local).
  • Armazenamento: SSD NVMe com pelo menos 100 GB livres. O disco deve ser rápido para lidar com operações de banco de dados e uploads de mídia.
  • Sistema Operacional: Ubuntu 22.04 LTS ou Debian 11/12 (recomendados pela estabilidade e suporte a Docker).
  • Banda Larga: Conexão estável com upload mínimo de 50 Mbps para videoconferências internas fluidas.

Além dos recursos de hardware, você precisará de um domínio DNS apontando para o IP público da sua VPS. O Twake requer HTTPS obrigatório para funcionar corretamente, especialmente para as APIs de mídia e notificações push.

Passo 1: Preparação do Servidor Linux

A primeira etapa envolve atualizar o sistema operacional e instalar as dependências básicas necessárias para a execução dos containers Docker. Acesse sua VPS via SSH utilizando um usuário com privilégios sudo.

sudo apt update && sudo apt upgrade -y
sudo apt install apt-transport-https ca-certificates curl software-properties-common -y

Com as ferramentas básicas instaladas, proceda com a instalação do Docker Engine. A versão estável mais recente garante compatibilidade com as imagens oficiais do Twake.

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

Após a instalação, adicione o usuário atual ao grupo docker para evitar a necessidade de usar sudo em todos os comandos do Docker e reinicie o serviço.

sudo usermod -aG docker $USER
newgrp docker

Instale também o Docker Compose (versão V2, integrada ao CLI do Docker). Verifique a versão instalada para confirmar que tudo está correto.

docker compose version

Passo 2: Configuração de Segurança e Firewall

A segurança é crítica em ambientes self-hosted. Configure o firewall UFW (Uncomplicated Firewall) para permitir apenas o tráfego essencial. Inicialmente, bloqueie todas as conexões exceto SSH.

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw enable

Para a instalação inicial do Twake, precisamos liberar as portas 80 (HTTP) e 443 (HTTPS), pois o processo de configuração inicial e obtenção de certificados SSL depende desses protocolos. No entanto, em produção final, todo o tráfego deve passar por um proxy reverso.

sudo ufw allow http
sudo ufw allow https

Passo 3: Estrutura de Diretórios e Configuração do Docker Compose

Crie uma estrutura de diretórios dedicada para o projeto Twake. Isso facilita backups e atualizações futuras.

mkdir -p ~/twake/workspace
cd ~/twake/workspace

Dentro deste diretório, crie o arquivo docker-compose.yml. Este arquivo define os serviços necessários: o servidor principal do Twake, o banco de dados PostgreSQL e o armazenamento MinIO (para objetos/s3 compatível).

nano docker-compose.yml

Cole a seguinte configuração base. **Atenção:** Você deve substituir os valores de senha e variáveis de ambiente por senhas fortes e únicas geradas por um gerenciador de senhas.

version: '3.8'

services:
  twake-server:
    image: twake/twake-server:latest
    container_name: twake-server
    restart: unless-stopped
    ports:
      - "8080:80"
      - "8443:443"
    environment:
      - APP_ENV=prod
      - TWAKE_LICENSE_KEY=${TWAKE_LICENSE_KEY}
      - DATABASE_URL=postgresql://twake_user:${DB_PASSWORD}@db:5432/twake_db
      - REDIS_URL=redis://redis:6379/0
      - MINIO_ENDPOINT=minio:9000
      - MINIO_ACCESS_KEY=${MINIO_ACCESS_KEY}
      - MINIO_SECRET_KEY=${MINIO_SECRET_KEY}
    volumes:
      - ./data/twake:/app/data
      - ./logs/twake:/app/logs
    depends_on:
      - db
      - redis
      - minio

  db:
    image: postgres:15-alpine
    container_name: twake-db
    restart: unless-stopped
    environment:
      - POSTGRES_DB=twake_db
      - POSTGRES_USER=twake_user
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - ./data/db:/var/lib/postgresql/data

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

  minio:
    image: minio/minio:latest
    container_name: twake-minio
    restart: unless-stopped
    command: server /data --console-address ":9001"
    environment:
      - MINIO_ROOT_USER=${MINIO_ACCESS_KEY}
      - MINIO_ROOT_PASSWORD=${MINIO_SECRET_KEY}
    volumes:
      - ./data/minio:/data

  # Opcional: MinIO Client para gerenciar buckets via CLI
  mc:
    image: minio/mc:latest
    depends_on:
      - minio
    entrypoint: ["sh", "-c", "mc alias set myminio http://minio:9000 ${MINIO_ACCESS_KEY} ${MINIO_SECRET_KEY}; exit 0"]

Crie um arquivo .env na mesma pasta para armazenar as variáveis sensíveis, mantendo-as fora do versionamento de código.

TWAKE_LICENSE_KEY=sua_chave_de_licenca_aqui
DB_PASSWORD=senha_forte_do_banco
MINIO_ACCESS_KEY=admin
MINIO_SECRET_KEY=senha_forte_minio

Passo 4: Inicialização dos Serviços

Agora, baixe as imagens e inicie os containers. O Docker Compose baixará as imagens necessárias do repositório oficial.

docker compose up -d

Verifique o status dos containers para garantir que todos estão rodando sem erros.

docker compose ps

O comando deve retornar o status "Up" para todos os serviços (twake-server, db, redis, minio). Se houver erros, verifique os logs com docker compose logs -f twake-server.

Passo 5: Configuração do Proxy Reverso e SSL (Nginx)

O Twake não deve ser exposto diretamente na porta 8080/8443 em produção. Utilize o Nginx como proxy reverso para gerenciar o tráfego HTTPS e redirecionar as requisições para o container do Twake.

Instale o Nginx e o Certbot (para certificados Let's Encrypt).

sudo apt install nginx certbot python3-certbot-nginx -y

Crie um arquivo de configuração no Nginx:

sudo nano /etc/nginx/sites-available/twake

Insira a seguinte configuração, substituindo seu-dominio.com pelo seu domínio real.

server {
    listen 80;
    server_name seu-dominio.com www.seu-dominio.com;

    location / {
        proxy_pass http://127.0.0.1:8080;
        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;
        
        # WebSocket support for chat and video
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

# Redirecionar HTTP para HTTPS automaticamente após obter o certificado
server {
    listen 443 ssl http2;
    server_name seu-dominio.com www.seu-dominio.com;

    ssl_certificate /etc/letsencrypt/live/seu-dominio.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/seu-dominio.com/privkey.pem;
    
    # Configurações de segurança SSL recomendadas
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    location / {
        proxy_pass http://127.0.0.1:8080;
        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_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Ative a configuração e teste o Nginx.

sudo ln -s /etc/nginx/sites-available/twake /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Agora, obtenha o certificado SSL. Se o firewall estiver bloqueando a porta 80 (como recomendado após a instalação inicial), você pode precisar desbloqueá-lo temporariamente ou usar o modo standalone do Certbot.

sudo certbot --nginx -d seu-dominio.com -d www.seu-dominio.com

Passo 6: Acesso e Configuração Inicial da Interface Web

Com o Nginx e SSL configurados, abra seu navegador e acesse https://seu-dominio.com. A interface de configuração inicial do Twake será exibida.

  1. Criação do Super Admin: Insira um nome, email e senha fortes para a conta administrativa. Esta conta terá acesso total ao painel de controle.
  2. Configuração de Licença: Se você possui uma licença comercial, insira a chave aqui. Para versões de avaliação ou open-source (se aplicável), siga as instruções na tela.
  3. Detalhes da Empresa: Preencha o nome da organização e logo. Isso personalizará a interface de login e notificações.

Após finalizar o assistente, você será redirecionado para o painel administrativo. Aqui, você pode configurar as regras de acesso, integrar com LDAP/Active Directory (se necessário) e definir políticas de retenção de dados.

Passo 7: Otimização e Manutenção Contínua

Para garantir que o Twake Workspace funcione com máxima produtividade e estabilidade, adicione rotinas de manutenção.

Backup Automatizado:

O backup é a responsabilidade do administrador. Configure um script cron para fazer backup dos volumes de dados (PostgreSQL e MinIO) diariamente.

# Exemplo de script de backup simples
#!/bin/bash
BACKUP_DIR="/backups/twake"
DATE=$(date +%F)

mkdir -p $BACKUP_DIR

# Backup do Banco de Dados
docker exec twake-db pg_dump -U twake_user twake_db > $BACKUP_DIR/db_$DATE.sql

# Backup dos Arquivos (MinIO e Configurações)
tar -czf $BACKUP_DIR/files_$DATE.tar.gz -C /root/twake/workspace/data .

# Remover backups antigos (manter últimos 7 dias)
find $BACKUP_DIR -type f -mtime +7 -delete

Monitoramento:

Utilize ferramentas como Prometheus e Grafana para monitorar o uso de CPU, RAM e disco dos containers. A saúde do banco de dados e a latência das requisições são métricas críticas.

Conclusão

Instalar e configurar o Twake Workspace em uma VPS Linux é um processo que recompensa a equipe com uma plataforma de colaboração poderosa, segura e totalmente sob controle. Ao seguir este tutorial técnico, você estabeleceu uma base sólida para gerenciamento de projetos self-hosted, utilizando práticas modernas de DevOps como Dockerização e Proxy Reverso.

Lembre-se de que a manutenção contínua, incluindo atualizações de segurança do sistema operacional e backups regulares, é essencial para a longevidade da sua infraestrutura. Com o Twake em produção, sua equipe terá acesso a uma suite completa de ferramentas que impulsiona a produtividade sem comprometer a privacidade dos dados.

Esse tutorial foi útil?

Comentários (0)

Seja o primeiro a comentar.

Deixe seu comentário

Seu comentário será analisado antes de ser publicado.

0/2000
Voltar para Tutoriais
WhatsApp