Patrick Brandão

Instalando VPS para NOCODE

Saudações. Nesse tutorial vou te ensinar como instalar os principais softwares para aprender tecnologias NOCODE/LOWCODE para fazer automações e integrações com Inteligencia Artificial.

Vou considerar com base o Linux Debian, você pode usar o Ubuntu ou Alpine se dominar as poucas diferenças entre eles.

Requisitos

  • Instalar o Debian Linux;
  • IP público – VPS na nuvem ou em infra dedicada;

Softwares utilizados nesse artigo

  • Linux Debian 12 ou versão mais nova;
  • Docker;

Onde contratar uma VPS (virtual private server)

O curso de uma VPS com IP público pode variar entre R$ 15,00 e R$ 150,00 por mês, o custo está relacionado a quantidade de recursos (núcleos de CPU, RAM, espaço de armazenamento e tráfego de rede). Alguns datacenters confiáveis:

Softwares para instalar no seu notebook/PC

Para iniciar as instalações você precisará entrar no Linux por linha de comando para fazer as primeiras instalações e depois poderá operar 99% via interface web bonitinha. Escolha um dos softwares de cliente SSH abaixo para fazer o primeiro acesso:

Para Windows o Putty é a opção gratuita mais pontual.
Para macOS você pode usar o Terminal nativo no menu Aplicações -> Utilitários -> Terminal.

1 – DNS e nome do seu servidor

Todas as aplicações web vão exigir URL e acesso pelo navegador em algum ponto.

Softwares de automação são baseadas em WebHooks (URLs que você fornece a eles para ser avisado de eventos).

Tudo isso depende de HTTPS – HTTP criptografado por TLS.

Para obter um certificado digital para uso do HTTPS você precisará de um domínio de DNS que aponte nomes para o IP da sua VPS (fornecido pelo datacenter na contratação).

Supondo que seu servidor/VPS terá o endereço IPv4 45.255.128.2 (IP de exemplo) e seu domínio seja exemplo.com.br (domínio de exemplo), recomendo que os seguintes nomes sejam registrados, exemplo:

  • Nome: www (www.exemplo.com.br) apontando para (registro tipo A) para 45.255.128.2

Outros nomes comuns:

  • n8n, portainer, mariadb, postgres, redis, mail, webmail

Aponte-os para o IP da sua VPS.

Alguns sistemas de DNS permitem que você crie um registro WILDCARD DNS para que qualquer nome que você digite antes do seu domínio seja direcionado para sua VPS, exemplo:

  • *.exemplo.com.br. IN A 45.255.128.2

Assim se você acessar qualquer-coisa-mesmo.exemplo.com.br seu navegador será conduzido até o IP da VPS (45.255.128.2 no exemplo acima).

Você tambêm pode criar um subdomínio só para uma VPS especifica, exemplo:

  • *.automacao.exemplo.com.br. IN A 45.255.128.2

É muito importante que sua VPS tenha um nome de DNS próprio, exemplo: automacao.exemplo.com.br

Após configurar o nome da VPS no DNS, defina-o no Linux com esse comando (troque o nome de exemplo pelo nome real, não cole o comando abaixo às cegas):

Bash
# Definindo nome do servidor:
hostnamectl  set-hostname  automacao.exemplo.com.br

2 – Instalando Docker

O Docker é um software para rodar aplicativos em containers: uma forma de cada software rodar isolado dos demais, como uma “AppStore” de softwares para servidores.

Copie e cole os comandos abaixo no terminal da sua VPS (como root):

Bash
# Baixar script instalador oficial:
wget https://get.docker.com -O /tmp/get-docker.sh

# Executar script instalador:
sudo sh /tmp/get-docker.sh

Crie uma rede para rodar os containers:

Bash
# Criar rede de containers
# Rede de containers somente ipv4
docker network create -d bridge \
    -o "com.docker.network.bridge.name"="br-net-public" \
    --subnet 10.249.0.0/16 --gateway 10.249.255.254 \
    network_public

3 – Instalando Traefik

O Traefik é um software de proxy-reverso simples e objetivo: ele monitora os containers que você irá criar e se eles possuirem labels (marcações) com o prefixo “traefik”. Essas marcações servem para instruir o Traefik a redirecionar acesso para o container e obter um certificado SSL/TLS válido para ele automaticamente.

Bash
# Variaveis
    NAME=traefik-app
    LOCAL=$NAME.intranet.br
    DATADIR=/storage/$NAME
    EMAIL=seu-email-aqui@dominio-aqui.com.br

# Diretorio de dados persistentes
    mkdir -p $DATADIR/letsencrypt
    mkdir -p $DATADIR/logs
    mkdir -p $DATADIR/config

# Remover atual para garantir a renovacao:
    docker rm -f $NAME 2>/dev/null

# - Rodar
    docker run -d --restart=unless-stopped \
      --name $NAME -h $LOCAL \
      --network network_public \
      --ip=10.249.255.253 \
      -p 80:80 \
      -p 443:443 \
      \
      -v /var/run/docker.sock:/var/run/docker.sock:ro \
      -v $DATADIR/letsencrypt:/etc/letsencrypt \
      -v $DATADIR/config:/etc/traefik \
      -v $DATADIR/logs:/logs \
      \
      traefik:latest \
      --global.checkNewVersion=false \
      --global.sendAnonymousUsage=false \
      --api.insecure=true \
      --log.level=INFO \
      --log.filePath=/logs/error.log \
      --accessLog.filePath=/logs/access.log \
      --entrypoints.web.address=:80 \
      --entrypoints.web.http.redirections.entryPoint.to=websecure \
      --entrypoints.web.http.redirections.entryPoint.scheme=https \
      --entrypoints.web.http.redirections.entryPoint.permanent=true \
      --entrypoints.websecure.address=:443 \
      --providers.docker=true \
      --providers.file.directory=/etc/traefik \
      --certificatesresolvers.letsencrypt.acme.email=$EMAIL \
      --certificatesresolvers.letsencrypt.acme.storage=/etc/letsencrypt/acme.json \
      --certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web

4 – Instalando Portainer

O Portainer é um software que te permitirá administrar os aplicativos usando o navegador, assim você poderá evitar a linha de comando.

Bash
# Variaveis
    NAME=portainer
    DOMAIN="$(hostname -f)"
    FQDN="$NAME.$DOMAIN"
    LOCAL=$NAME.intranet.br
    DATADIR=/storage/portainer

# Diretorio de dados persistentes:
    mkdir -p $DATADIR

# Remover atual para garantir a renovacao:
    docker rm -f $NAME 2>/dev/null

# Criar e rodar:
    docker run -d --restart=always \
      --name $NAME -h $LOCAL \
      --network network_public \
      --ip=10.249.255.251 \
      -e "TZ=America/Sao_Paulo" \
      -p 8000:8000 \
      -p 9443:9443 \
      \
      -v /var/run/docker.sock:/var/run/docker.sock \
      --mount type=bind,source=$DATADIR,destination=/data,readonly=false \
      \
      --label "traefik.enable=true" \
      --label "traefik.http.routers.portainer.rule=Host(\`$FQDN\`)" \
      --label "traefik.http.routers.portainer.entrypoints=websecure" \
      --label "traefik.http.routers.portainer.tls=true" \
      --label "traefik.http.routers.portainer.tls.certresolver=letsencrypt" \
      --label "traefik.http.services.portainer.loadbalancer.server.port=9000" \
      \
        portainer/portainer-ce:latest

Ao instalar o Portainer ele criará um painel na porta 9443, acesse:

  • https://45.255.128.2:9443/ e define o usuário e senha inicial.

Lembrando mais uma vez que o IP 45.255.128.2 é para fins educativos, troque esse IP pelo endereço da sua VPS.

Se você configurou o nome portainer.automacao.exemplo.com.br no DNS você poderá acessar esse nome no navegador sem especificar a porta que o Traefik entregará o acesso ao Portainer internamente com certificado de segurança!

5 – Instalando o REDIS

O REDIS é um banco de dados de chave-valor e listas simples de altíssima velocidade. Ele é muito útil em várias automações e integrações com IA.

Vou instalar dois servidores REDIS e explicar as características de cada um.

REDIS CACHE – Um REDIS 100% operado em memória RAM, sem uso de disco/storage

Esse REDIS deve ser usado para operações de manipulação de dados temporários que não precisam ser armazenados definitivamente (paginas web, listas para conversão, etc…).

Bash
# Criar e rodar:
    docker run -d --restart=always \
      --name redis-cache -h redis-cache.intranet.br \
      --network network_public \
      --ip=10.249.255.151 \
      redis:8-alpine

REDIS DB – Um REDIS operando em RAM que salva dados no disco/storage

Esse REDIS deve ser usado para dados persistentes, que devem ser mantidos a salvo mesmo que seu servidor seja reiniciado. Ele é recomendado para tarefas mais importantes como histórico de conversas recentes em um chat de IA:

Bash
# Diretorio para armazenar os dados:
    DATADIR=/storage/redis-db
    mkdir -p $DATADIR

# Criar e rodar:
    docker run -d --restart=always \
      --name redis-db -h redis-db.intranet.br \
      --network network_public \
      --ip=10.249.255.152 \
      \
      -v $DATADIR:/data \
      \
      redis:8-alpine \
        redis-server \
            --bind '0.0.0.0 ::' \
            --port 6379 \
            --set-proc-title no \
            --tcp-backlog 8192 \
            --tcp-keepalive 30 \
            --timeout 0 \
            --save 900 1 \
            --save 300 10 \
            --save 60 10000 \
            --dir /data \
            --rdbcompression no \
            --rdbchecksum yes \
            --dbfilename data.rdb \
            --appendonly yes \
            --appendfsync everysec \
            --appendfilename data.aof

6 – Instalando MariaDB

O MariaDB é um servidor SQL tipo MySQL gratuito e open-source muito utilizado por diversos aplicativos, vamos instala-lo para servir de base para todos os softwares que precisem de um servidor SQL compatível com MySQL.

O nome do servidor MariaDB será mariadb-main para referência nos demais containers.

Bash
# Variaveis
    # Banco de dados vazio inicial
    START_DATABASE=admin

    # Senha padrao
    ROOT_PASSWORD="tulipasql" 
    USER_NAME="suporte"
    USER_PASSWORD="tulipasql"
    IMAGE=mariadb:latest

# Pasta de persistencia
    DATADIR=/storage/mariadb-main
    mkdir -p $DATADIR

# Banco de dados principal
    docker run -d --restart=always \
      --name mariadb-main -h mariadb-main.intranet.br \
      --network network_public \
      --ip=10.249.255.100 \
      \
      -e "TZ=America/Sao_Paulo" \
      -e "MYSQL_ROOT_PASSWORD=$ROOT_PASSWORD" \
      -e "MYSQL_DATABASE=$START_DATABASE" \
      -e "MYSQL_USER=$USER_NAME" \
      -e "MYSQL_PASSWORD=$USER_PASSWORD" \
      \
      -v /storage/mariadb-main:/var/lib/mysql \
      \
      mariadb:latest

Caso não esteja familiarizado com o MySQL/MariaDB, deixo alguns comandos que podem ser úteis para operações comuns:

Bash
# Acesso apartir do servidor VPS
    # Acesso: root / tulipasql
    apt-get -y install mariadb-client
    mariadb -h 10.249.255.100 -u root    -ptulipasql
    mariadb -h 10.249.255.100 -u suporte -ptulipasql

# Backup:
    # Gerar data-hora para arquivo
    DTU=$(date -u '+utc-%Y-%m-%d-%H%M')

    # Criar pasta de backup:
    mkdir -p /storage/backup

    # Extrair banco de dados 'admin'
    mariadb-dump \
        -h 10.249.255.100 \
        -u root \
        -ptulipasql \
        admin > "/storage/backup/admin-$DTU.sql"
        
    # Extrair dados de todos os bancos de dados:
    mariadb-dump \
        -h 10.249.255.100 \
        -u root \
        -ptulipasql \
        --all-databases > "/storage/backup/alldb-$DTU.sql"

# Listar variaveis:
    docker exec -it mariadb-main my_print_defaults --mysqld

# Criar acessos extras:
# - analista21
    # Criando acesso:
    docker exec -it mariadb-main bash
    mariadb -uroot -ptulipasql
    
    # Comandos dentro do mariadb:
        GRANT ALL ON admin.* to analista21@'%' IDENTIFIED BY 'tulipasql' WITH GRANT OPTION;
        FLUSH PRIVILEGES;

    # Testando:
    mariadb -h 10.249.255.100 -u analista21 -ptulipasql  admin


# Comandos dentro do banco de dados:
    # Alterar senha:
    # root
    ALTER USER root@'%' IDENTIFIED VIA mysql_native_password USING PASSWORD("tulipasql");
    FLUSH PRIVILEGES;

    # suporte
    ALTER USER suporte@'%' IDENTIFIED VIA mysql_native_password USING PASSWORD("tulipasql");
    FLUSH PRIVILEGES;

7 – Instalando Postgres

O Postgres é um banco de dados SQL emergente que hoje ocupa a liderança do mercado de servidores SQL open-source e gratuitos. Se destaca pela performance superior e versatilidade. A tendencia é que o PGSQL (ou PG) domine o mercado totalmente.

O nome do servidor PGSQL será postegres-main para referência nos demais containers.

Bash
# Variaveis
    # senha padrao (root)
    ROOT_PASSWORD="tulipa_pgsql"

# Pasta de persistencia
    DATADIR=/storage/postgres-main
    mkdir -p $DATADIR

# Banco de dados principal
    docker run -d --restart=always \
      --name postgres-main -h postgres-main.intranet.br \
      --network network_public \
      --ip=10.249.255.121 \
      -e "TZ=America/Sao_Paulo" \
      -e "POSTGRES_PASSWORD=$ROOT_PASSWORD" \
      -e POSTGRES_INITDB_ARGS="--auth-host=scram-sha-256" \
      -v $DATADIR:/var/lib/postgresql/data \
      postgres:latest \
          postgres --max_connections=8192

8 – Instalando PGVECTOR

O pgvector é uma extensão do PostgreSQL que adiciona suporte nativo para vetores e busca por similaridade vetorial (eita!). Não é um software separado do PostgreSQL, mas sim uma extensão que expande as capacidades do banco de dados.

Ele serve para:

  • Armazenamento de embeddings: Permite armazenar vetores de alta dimensionalidade (representações numéricas de texto, imagens, áudio, etc.);
  • Busca por similaridade: Oferece operadores para encontrar vetores similares usando métricas como distância euclidiana, produto escalar e similaridade de cosseno;
  • Aplicações de IA: Fundamental para sistemas de recomendação, busca semântica, RAG (Retrieval-Augmented Generation), e outras aplicações de machine learning;
  • Indexação eficiente: Suporta índices especializados (como IVFFlat e HNSW) para consultas rápidas em grandes volumes de dados vetoriais.

Resumindo: é um PGSQL para IA!

O nome do servidor PGSQL será pgvector-main para referência nos demais containers.

Bash
# Variaveis
    # senha padrao (root)
    ROOT_PASSWORD="tulipa_pgsql"

# Pasta de persistencia
    DATADIR=/storage/pgvector-main
    mkdir -p $DATADIR

# Executar:
    # -p 5432:5432
    docker run -d --restart=always \
      --name pgvector-main -h pgvector-main.intranet.br \
      --network network_public \
      --ip=10.249.255.122 \
      -e "TZ=America/Sao_Paulo" \
      -e "POSTGRES_PASSWORD=$ROOT_PASSWORD" \
      -e POSTGRES_INITDB_ARGS="--auth-host=scram-sha-256" \
      \
      -v $DATADIR:/var/lib/postgresql/data \
      --entrypoint "docker-entrypoint.sh" \
      pgvector/pgvector:pg16 \
			postgres \
			  --max_connections=8192 \
			  --wal_level=minimal \
			  --max_wal_senders=0 \
			  --port=5432

9 – Instalando N8N – modo simples

O N8N é um software para construir automações de maneira visual e com pouco (ou nenhum) conhecimento de programação.

Por conta disso ele é classificado como um software NOCODE (sem precisar escrever código) ou LOWCODE (desenvolvendo o mínimo e usando o máximo de itens prontos).

Existem muitas formas de rodar o N8N, vamos usar a mais simples possível e deixar as formas mais complexas para o futuro. Saiba que é possível instalar:

  • (A) N8N simples – uma única instância do software fica responsável pelo editor (parte visual), pelo WebHook (receber pedidos externos) e pelo Worker (parte que cuida da execução dos nodes – pequenos pedaços do workflow) e todos os dados de execução e trabalhos ficam num banco de dados de arquivo simples tipo SQLITE;
  • (B) N8N simples com PGSQL – semelhante ao modo acima, mas troca o SQLITE limitado pelo poderoso Postres (deve rodar em container separado);
  • (C) N8N modo fila – cada parte do sistema é executado em containers diferentes, possuindo um container para o editor (1), um container para receber as chamadas WebHook (2), um container ou mais para a execução Worker (3), um container para servidores MCP (4) e o container adicional para o Postegres;

As versões do N8N e lançamentos podem ser acompanhadas nessa página:

Como o foco desse tutorial é montar um ambiente de aprendizado e testes, vamos usar o modo simples (A):

Bash
# Variaveis
    NAME=n8n
    DOMAIN="$(hostname -f)"
    FQDN="$NAME.$DOMAIN"
    EMAIL=seu-email-aqui@dominio-aqui.com.br
    DATADIR=/storage/n8n-data
    NODEDIR=/storage/n8n-nodes

    # Versao N8N
    N8N_VERSION=1.99.1 # anterior: 1.98.2
    IMAGE=n8nio/n8n:$N8N_VERSION

# Diretorio de dados persistentes:
    mkdir -p $DATADIR; chown 1000:1000 $DATADIR -R;
    mkdir -p $NODEDIR; chown 1000:1000 $NODEDIR -R;

# Criar e rodar:
    docker run -d --restart=always \
      --name $NAME -h $NAME.intranet.br \
      --network network_public \
      --ip=10.249.255.10 \
      \
      -e TZ=America/Sao_Paulo \
      -e N8N_HOST=$FQDN \
      -e N8N_PORT=5678 \
      -e N8N_PROTOCOL=https \
      -e NODE_ENV=production \
      -e WEBHOOK_URL=https://$FQDN/ \
      -e GENERIC_TIMEZONE=$TZ \
      -e SSL_EMAIL=$EMAIL \
      \
      -e EXECUTIONS_DATA_PRUNE=true \
      -e EXECUTIONS_DATA_MAX_AGE=24 \
      -e EXECUTIONS_DATA_PRUNE_MAX_COUNT=512 \
      -e EXECUTIONS_DATA_SAVE_ON_ERROR=all \
      -e EXECUTIONS_DATA_SAVE_ON_SUCCESS=all \
      -e EXECUTIONS_DATA_SAVE_ON_PROGRESS=true \
      -e EXECUTIONS_DATA_SAVE_MANUAL_EXECUTIONS=true \
      \
      -e N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true \
      -e N8N_RUNNERS_ENABLED=true \
      -e N8N_RUNNERS_MODE=internal \
      -e N8N_NODE_PATH=/data/nodes \
      -e N8N_CUSTOM_EXTENSIONS=/data/nodes \
      -e N8N_COMMUNITY_PACKAGES_ENABLED=true \
      -e N8N_REINSTALL_MISSING_PACKAGES=true \
      -e N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true \
      -e OFFLOAD_MANUAL_EXECUTIONS_TO_WORKERS=false \
      \
      -v $DATADIR:/home/node/.n8n \
      -v $NODEDIR:/data/nodes \
      \
      --label "traefik.enable=true" \
      --label "traefik.http.routers.$NAME.rule=Host(\`$FQDN\`)" \
      --label "traefik.http.routers.$NAME.entrypoints=web,websecure" \
      --label "traefik.http.routers.$NAME.tls=true" \
      --label "traefik.http.routers.$NAME.tls.certresolver=letsencrypt" \
      --label "traefik.http.services.$NAME.loadbalancer.server.port=5678" \
      \
      $IMAGE

Agora acesse:

  • n8n.automacao.exemplo.com.br e informe seus dados para primeiro login!

Conclusão

Agora dedique-se a estudar cada capítulo desse tutorial para dominar um ambiente de automações e transformar seu trabalho em mágica!

Um script plano desse tutorial pode ser encontrado em:

  • Script Docker-IA-LAB: https://tmsoft.com.br/temp/docker-ia-lab.sh
Bash
# Instalando via script
wget  http://arquivos.nuva.com.br/docker-ia-lab.sh  -O /tmp/docker-ia-lab.sh;
sh  /tmp/docker-ia-lab.sh;

Até mais,
Patrick Brandão, patrickbrandao@gmail.com