Deploy Vendure Ecommerce em VPS com Docker e Postgres

A escolha de uma infraestrutura robusta e escalável é fundamental para o sucesso de qualquer projeto de vendure ecommerce vps. Ao optar por uma arquitetura headless commerce, você ganha flexibilidade, performance e segurança, separando o backend da lógica de apresentação. Neste tutorial técnico, demonstraremos como realizar um deploy completo do Vendure em um ambiente VPS Linux, utilizando Docker para containerização e PostgreSQL como banco de dados, garantindo uma loja virtual self-hosted pronta para produção.

O DevOps ecommerce moderno exige automação e consistência. O uso de docker compose permite definir toda a infraestrutura como código, facilitando o versionamento, replicação e manutenção do ambiente. Abaixo, guiamos você pelas etapas necessárias para configurar seu servidor, desde a preparação do sistema operacional até a validação final da aplicação.

1. Preparação do Ambiente VPS

O primeiro passo é garantir que o sistema operacional esteja atualizado e com as dependências básicas instaladas. Recomendamos o uso de distribuições LTS (Long Term Support) como Ubuntu 22.04 ou Debian 12, devido à sua estabilidade e suporte prolongado.

Acesse seu servidor via SSH e execute os comandos abaixo para atualizar os pacotes do sistema. Esta etapa é crucial para evitar conflitos de bibliotecas durante a instalação do Docker e suas extensões.

sudo apt update
sudo apt upgrade -y

Após a atualização, instale o curl, caso ainda não esteja presente, pois ele será utilizado para baixar os scripts de instalação do Docker. A instalação correta dessas ferramentas básicas é parte essencial da sua infraestrutura e-commerce inicial.

sudo apt install curl -y

2. Instalação e Configuração do Docker

O Docker é o motor que permitirá a execução isolada de seus serviços. A maneira mais recomendada de instalá-lo em ambientes de produção é utilizando o script oficial ou os repositórios oficiais da Docker Inc, garantindo que você receba as versões mais recentes e seguras.

Execute o seguinte comando para baixar e executar o script de instalação automatizada. Este processo configurará os repositórios do Docker, instalará o daemon e o cliente, além de configurar permissões básicas.

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

Após a instalação, é fundamental adicionar seu usuário atual ao grupo docker. Isso evita a necessidade de usar sudo para todos os comandos do Docker e melhora a fluidez do desenvolvimento. Lembre-se de que essa alteração de grupo só entrará em vigor após o próximo login ou reinicialização da sessão.

sudo usermod -aG docker $USER
newgrp docker

Verifique se a instalação foi bem-sucedida rodando a imagem "hello-world". Se o contêiner for executado sem erros, seu ambiente Docker está pronto para receber os serviços do Vendure.

docker run hello-world

2. Estrutura de Diretórios e Arquivos de Configuração

A organização dos arquivos é vital para a manutenibilidade. Crie um diretório dedicado para o projeto. Isso facilita backups e migrações futuras, aspectos críticos em qualquer estratégia de deploy nodejs baseada em containers.

mkdir -p ~/vendure-project
cd ~/vendure-project

Agora, crie o arquivo principal que orquestrará seus serviços: o docker-compose.yml. Este arquivo definirá a rede, os volumes de dados e as variáveis de ambiente necessárias para a comunicação entre o backend do Vendure e o banco de dados.

nano docker-compose.yml

Cole a seguinte configuração no arquivo. Note a utilização das imagens oficiais do Docker Hub para ambas as tecnologias, garantindo compatibilidade e atualizações regulares.

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_USER: vendure_user
      POSTGRES_PASSWORD: senha_forte_aqui
      POSTGRES_DB: vendure_db
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - vendure-network

  vendure:
    image: node:18-alpine
    restart: always
    working_dir: /app
    volumes:
      - ./vendure-backend:/app
    command: ["npm", "run", "start"]
    ports:
      - "3000:3000"
    environment:
      DB_HOST: postgres
      DB_PORT: 5432
      DB_USER: vendure_user
      DB_PASSWORD: senha_forte_aqui
      DB_NAME: vendure_db
      API_SECRET: meu-segredo-api-forte
    depends_on:
      - postgres
    networks:
      - vendure-network

volumes:
  db_data:

networks:
  vendure-network:
    driver: bridge

Nesta configuração, definimos uma rede dedicada chamada vendure-network. Isso isola o tráfego entre os containers, aumentando a segurança. O volume db_data garante que as informações do banco de dados persistam mesmo se o container do PostgreSQL for reiniciado ou removido.

3. Configuração do Projeto Vendure

Para que o container funcione corretamente, precisamos estruturar a aplicação Node.js dentro da pasta vendure-backend. Crie esta estrutura de diretórios agora.

mkdir -p vendure-backend/src
cd vendure-backend

Crie o arquivo package.json na raiz do projeto Vendure. Este arquivo definirá as dependências necessárias para rodar o servidor backend e as ferramentas de build.

nano package.json

Insira a seguinte configuração JSON, que inclui o framework oficial do Vendure e suas dependências de banco de dados.

{
  "name": "vendure-server",
  "version": "1.0.0",
  "private": true,
  "scripts": {
    "start": "node --max-old-space-size=4096 dist/main.js",
    "dev": "nodemon src/main.ts"
  },
  "dependencies": {
    "@vendure/core": "^2.0.0",
    "@vendure/admin-ui-plugin": "^2.0.0",
    "@vendure/email-plugin": "^2.0.0",
    "@vendure/payments-plugin": "^2.0.0",
    "@vendure/saleor-linker": "^1.0.0",
    "apollo-server-core": "^3.12.0",
    "apollo-server-express": "^3.12.0",
    "body-parser": "^1.20.2",
    "graphql": "^16.8.0",
    "pg": "^8.11.0",
    "reflect-metadata": "^0.1.13",
    "rxjs": "^7.8.0",
    "zone.js": "^0.14.0"
  }
}

Agora, crie o arquivo principal de configuração do servidor Vendure em vendure-backend/src/main.ts. Este script inicializará a instância do core do Vendure, conectando-se ao PostgreSQL configurado anteriormente.

nano src/main.ts

Utilize o código abaixo como base. Ele configura o modo de desenvolvimento e define as credenciais de conexão que devem corresponder às variáveis de ambiente definidas no docker-compose.yml.

import {
  defaultSearchPlugin,
  VendureConfig,
} from '@vendure/core';
import { AdminUiPlugin } from '@vendure/admin-ui-plugin';
import { createConnection } from 'typeorm';
import express from 'express';
import graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.mjs';

const config: VendureConfig = {
  apiOptions: {
    port: 3000,
    adminApiPath: 'admin-api',
    shopApiPath: 'shop-api',
  },
  authOptions: {
    tokenStrategy: require('@vendure/core').ApiTokenStrategy,
  },
  databaseOptions: {
    type: 'postgres',
    host: process.env.DB_HOST || 'localhost',
    port: 5432,
    username: process.env.DB_USER || 'vendure_user',
    password: process.env.DB_PASSWORD || 'senha_forte_aqui',
    database: process.env.DB_NAME || 'vendure_db',
    synchronize: false,
    logging: false,
  },
  plugins: [
    AdminUiPlugin.init({ port: 3001 }),
    defaultSearchPlugin,
  ],
};

async function bootstrap() {
  await createConnection();
  const app = express();
  app.use(graphqlUploadExpress({ maxFileSize: 10000000, maxFiles: 5 }));
  
  // Inicialização do servidor Vendure aqui
  console.log('Servidor Vendure inicializando...');
}

bootstrap();

Além disso, crie um arquivo Dockerfile na raiz de vendure-backend para definir como o container Node.js deve ser construído. Este arquivo garantirá que as dependências sejam instaladas e o projeto seja compilado antes da execução.

nano Dockerfile

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
CMD ["node", "dist/main.js"]

4. Execução do Deploy com Docker Compose

Com todos os arquivos configurados, estamos prontos para subir a infraestrutura. Volte para o diretório raiz do projeto onde o docker-compose.yml está localizado.

cd ~/vendure-project

Execute o comando abaixo para baixar as imagens, criar os containers e iniciar os serviços em segundo plano (modo detached). O Docker Compose lerá o arquivo de configuração e orquestrará a criação do banco de dados e da aplicação Vendure.

docker compose up -d

Aguarde alguns minutos para que as imagens sejam baixadas e os containers inicializem. Você pode monitorar o log de saída do container do Vendure para verificar se houve erros de conexão com o banco de dados ou falhas na inicialização da aplicação.

docker compose logs -f vendure

Se tudo ocorrer conforme o planejado, você verá mensagens indicando que o servidor está escutando na porta 3000. O Admin UI também estará disponível, geralmente na porta configurada no plugin (neste exemplo, 3001, mas verifique a configuração de portas do seu container se estiver usando um build pré-compilado).

5. Validação e Acesso à Loja Virtual

Para confirmar que o vendure ecommerce vps está operando corretamente, acesse os endpoints da API via navegador ou ferramentas como cURL e Postman.

Teste a conexão com o banco de dados acessando a interface administrativa. Se você configurou as portas corretamente no compose, o Admin UI deve estar acessível em http://SEU_IP_DO_VPS:3001. O login padrão geralmente é superadmin@vendure.io e a senha definida durante a inicialização ou seed de dados.

Além disso, verifique a integridade dos dados executando uma consulta direta ao banco de dados. Isso garante que o volume db_data está mapeado corretamente e que as migrações foram aplicadas com sucesso.

docker compose exec postgres psql -U vendure_user -d vendure_db -c "SELECT version();"

A resposta deve indicar a versão do PostgreSQL em execução. Se o comando retornar dados, sua infraestrutura e-commerce está sólida.

6. Boas Práticas de Segurança e Manutenção

Embora o deploy esteja funcional, ambientes de produção exigem camadas adicionais de segurança. Nunca exponha as portas do banco de dados diretamente à internet. No nosso docker-compose.yml, a porta 5432 não foi mapeada para o host, apenas exposta internamente entre os containers, o que é uma prática recomendada.

Utilize um proxy reverso como Nginx ou Traefik na frente do Docker para gerenciar certificados SSL/TLS. Isso criptografará as comunicações entre o cliente e sua loja virtual self-hosted, protegendo dados sensíveis de clientes.

Mantenha suas imagens atualizadas regularmente. Execute comandos periódicos de atualização para garantir que vulnerabilidades conhecidas no Node.js, PostgreSQL ou nas dependências do Vendure sejam corrigidas.

docker compose pull
docker compose up -d

Além disso, configure backups automáticos do volume db_data. Scripts simples que utilizam o pg_dump podem ser agendados via cron para enviar dumps do banco de dados para um storage externo seguro, como S3 ou outro servidor.

A gestão eficiente do disco e da memória é outro ponto crítico. Monitore o uso de recursos utilizando ferramentas como Prometheus e Grafana, integradas ao Docker, para identificar gargalos de performance antes que eles afetem a experiência do usuário final.

Conclusão

Neste tutorial, cobrimos desde a instalação do Docker até a configuração completa do Vendure com PostgreSQL em um ambiente VPS. Ao seguir esses passos, você estabeleceu uma base sólida para seu projeto de devops ecommerce, utilizando tecnologias modernas e escaláveis.

A arquitetura headless commerce oferecida pelo Vendure permite que sua equipe foque na experiência do usuário no frontend, enquanto o backend gerencia catálogos, pedidos e pagamentos com eficiência. Com a infraestrutura containerizada, você ganha a agilidade necessária para iterar rapidamente e escalar conforme o crescimento do seu negócio.

Lembre-se de adaptar as configurações de segurança, backups e monitoramento às necessidades específicas da sua operação. A autonomia técnica proporcionada por uma solução vendure ecommerce vps bem configurada é um diferencial competitivo importante no mercado atual.