Tutoriais de VPS
Nexus Repository na VPS: Maven, npm, HTTPS e recuperação confiável
Implante Nexus com versão fixada, PostgreSQL e Caddy. Dimensione a JVM, configure Maven/npm privados, limite credenciais de CI e coordene backups do banco, blobs e identidade do nó.

O Nexus Repository hospeda artefatos e mantém um cache de dependências do Maven Central, npm e outros registros. Também guarda JARs, pacotes privados e resultados de builds da equipe. Para Jenkins, GitHub Actions e várias máquinas de desenvolvimento, ele oferece um ponto comum de acesso, controle de publicação e builds mais reproduzíveis; vai além de armazenar arquivos ZIP.
Este guia usa Ubuntu 24.04, Docker Compose, Nexus Repository Community Edition, PostgreSQL e Caddy. Inclui repositórios Maven/npm, credenciais de CI com permissões mínimas, monitoramento, backups consistentes, restauração e atualização com possibilidade de retorno. É uma instalação de nó único, que depende de um plano de recuperação.
Contexto de versão: o texto de setembro de 2026 usava
3.96.0, fixada como3.96.0-alpine. Trata-se de um exemplo histórico, não da versão mais recente hoje. A imagem padrão passou a usar Alpine a partir de 3.91.0. A documentação oficial atual já inclui a linha 3.98.x: confira notas e correções de segurança antes de escolher a versão de produção. Evite atualizações automáticas comlatest. A versão 3.98.0 apresentou um problema de atualização com schema PostgreSQL personalizado, corrigido em 3.98.1; essa observação é relevante para o schema deste exemplo.
Considere o serviço para:
- Compartilhar o cache de dependências Maven/npm entre projetos.
- Publicar JARs internos, POMs pai, componentes de frontend ou pacotes CLI.
- Unificar o acesso de Jenkins, GitHub Actions e runners próprios.
- Separar permissões de download, publicação e exclusão com limites auditáveis.
- Completar uma estrutura que já usa Jenkins CI/CD, Harbor ou SonarQube.
Para uma pessoa e um projeto com pouca reutilização do cache, um serviço gerenciado pode economizar manutenção. O Nexus se torna mais útil quando vários clientes compartilham dependências e pacotes privados. Não substitui armazenamento de objetos nem um drive genérico de arquivos.
| Serviço | Conteúdo principal | Clientes comuns | Relação com o Nexus |
|---|---|---|---|
| Nexus Repository | Artefatos Maven, npm, PyPI, NuGet, Raw e cache proxy | Maven, Gradle, npm, CI | Serviço deste guia |
| Harbor | Imagens OCI/Docker, assinaturas e análise de vulnerabilidades | Docker, Podman, Kubernetes | Especializado em imagens |
| Gitea/GitLab | Código Git, issues e solicitações de integração | Git, IDEs, CI | Não substitui um proxy geral de artefatos |
| S3/objetos | Objetos de arquivo | SDKs, rclone, aplicações | Sem índices e semântica de registro de pacotes |
Use Harbor para análise, replicação e isolamento de imagens. O Nexus atende vários ecossistemas de pacotes. Eles podem coexistir: Harbor para OCI e Nexus para artefatos de linguagens.
A antiga indicação de “2 vCPU, 8 GB de RAM e 20 GB de blobs” do texto não representa o perfil pequeno oficial atual. A arquitetura de referência vigente indica 4 vCPU e 16 GiB por nó Nexus extra pequeno, e 8 vCPU e 32 GiB por nó pequeno, com recursos do banco calculados separadamente. São referências de planejamento de throughput, sem garantia de desempenho em qualquer VPS barata.
| Uso | Ponto de partida prático | Banco | Condições |
|---|---|---|---|
| Avaliação curta | Um teste antigo de 2 vCPU / 4 GB pode iniciar | H2 em instalação compatível fora de contêiner | Não é o procedimento Docker de produção |
| Equipe com carga baixa e esta JVM sem alterações | 4 vCPU / 16 GB / 100 GB+ NVMe | PostgreSQL | Medir a pilha completa e o crescimento |
| CI frequente | 16 GB+ para Nexus e CPU/armazenamento conforme carga | PostgreSQL dimensionado à parte | Acompanhar IOPS, cache e concorrência |
| Grande escala ou alta disponibilidade | Arquitetura oficial | PostgreSQL externo | Uma VPS isolada não fornece HA |
A Sonatype recomenda reservar aproximadamente um terço da RAM para sistema, buffers e outros processos. O exemplo permite 4 GB de heap e até 4 GB de memória direta: isso não cabe com segurança em um host de 8 GB junto com PostgreSQL. Use RAM suficiente ou ajuste limites menores após medir uma carga concreta. Aumentar o heap na mesma máquina não resolve automaticamente um OOM.
Calcule disco para artefatos privados, crescimento do proxy, backups e arquivos temporários de atualização. Devem permanecer pelo menos 4 GB livres; abaixo disso, o banco pode entrar em modo somente leitura. Maven e imagens podem ocupar centenas de GB. Um alerta perto de 70% de uso permite limpar ou expandir com antecedência.
Instalações novas usam H2 por padrão. Os limites oficiais são 200.000 requisições por dia ou 100.000 componentes, e implantações H2 em contêineres não são suportadas. PostgreSQL é a recomendação para produção. Configurá-lo desde a primeira inicialização evita criar um H2 que precisará de migração.
Mantenha baixa latência entre Nexus e banco, no mesmo host neste exemplo ou na mesma região de nuvem. O usuário precisa ser proprietário do banco, pois atualizações alteram o schema. Também é necessária a extensão pg_trgm.
Prepare um domínio exclusivo, como repo.example.com, com A/AAAA apontando para a VPS. Abra somente:
22/tcp: SSH, de preferência limitado aos IPs de administração.80/tcp: validação ACME e redirecionamento HTTPS.443/tcp: interface web e clientes de pacotes.8081/tcp: apenas nas redes Docker, sem publicação no host.5432/tcp: apenas nas redes Docker, sem publicação no host.
Confira a resolução e o endereço público:
export NEXUS_DOMAIN="repo.example.com"
getent ahosts "$NEXUS_DOMAIN"
curl -4 https://ifconfig.me
Corrija registros antigos e AAAA sem conectividade antes de solicitar certificados. Expor Nexus ou PostgreSQL diretamente não corrige DNS ou proxy mal configurados.
Use o repositório apt oficial do Docker. Pule esta etapa se Engine e plugin Compose já estiverem instalados e verificados:
sudo apt-get update
sudo apt-get install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list >/dev/null
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
sudo docker version
sudo docker compose version
O projeto fica em /opt/nexus. A imagem Nexus grava como UID 200 em /nexus-data; um volume nomeado evita vários problemas de permissão de bind mounts.
A sequência original de diretório e senha é:
sudo install -d -m 0750 /opt/nexus
cd /opt/nexus
umask 077
openssl rand -base64 36 | tr -d '\n' | sudo tee /opt/nexus/.postgres-password >/dev/null
sudo chmod 600 /opt/nexus/.postgres-password
Um diretório 0750 pertencente a root impede um mantenedor comum de entrar. Antes dessa sequência, crie-o com a propriedade do usuário responsável:
sudo install -d -m 0750 -o "$(id -u)" -g "$(id -g)" /opt/nexus
cd /opt/nexus
Crie /opt/nexus/.env, troque o domínio de exemplo e obtenha POSTGRES_PASSWORD do arquivo de senha gerado:
cd /opt/nexus
POSTGRES_PASSWORD_VALUE="$(sudo cat /opt/nexus/.postgres-password)"
sudo tee /opt/nexus/.env >/dev/null <<EOF
NEXUS_VERSION=3.96.0-alpine
NEXUS_DOMAIN=repo.example.com
POSTGRES_DB=nexus
POSTGRES_USER=nexus
POSTGRES_PASSWORD=${POSTGRES_PASSWORD_VALUE}
EOF
sudo chmod 600 /opt/nexus/.env
unset POSTGRES_PASSWORD_VALUE
Não envie .env, dumps ou a senha inicial para Git. Passe usuário e senha JDBC separadamente para evitar problemas com caracteres especiais na URL. A tag é histórica: escolha uma versão mantida após revisar as notas para uma instalação nova.
Crie initdb/01-nexus.sql com schema próprio e pg_trgm:
cd /opt/nexus
sudo install -d -m 0750 initdb
sudo tee initdb/01-nexus.sql >/dev/null <<'SQL'
CREATE SCHEMA IF NOT EXISTS nexus AUTHORIZATION nexus;
CREATE EXTENSION IF NOT EXISTS pg_trgm WITH SCHEMA nexus;
SQL
sudo chmod 640 initdb/01-nexus.sql
Esse SQL não contém segredo. Execute sudo chmod 644 initdb/01-nexus.sql para permitir sua leitura pelo contêiner PostgreSQL; o modo 640 com proprietário root pode impedir a inicialização. Scripts de início só rodam com o volume do banco vazio. Se houver dados inicializados incorretamente, inspecione e faça backup antes de planejar a migração. Não exclua um volume de produção para tentar novamente.
Salve em /opt/nexus/compose.yaml:
name: nexus-repository
services:
postgres:
image: postgres:17-alpine
restart: unless-stopped
environment:
POSTGRES_DB: ${POSTGRES_DB}
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
volumes:
- postgres-data:/var/lib/postgresql/data
- ./initdb/01-nexus.sql:/docker-entrypoint-initdb.d/01-nexus.sql:ro
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
interval: 10s
timeout: 5s
retries: 12
start_period: 20s
networks:
- backend
nexus:
image: sonatype/nexus3:${NEXUS_VERSION}
restart: unless-stopped
depends_on:
postgres:
condition: service_healthy
environment:
NEXUS_DATASTORE_NEXUS_JDBCURL: jdbc:postgresql://postgres:5432/nexus?currentSchema=nexus
NEXUS_DATASTORE_NEXUS_USERNAME: ${POSTGRES_USER}
NEXUS_DATASTORE_NEXUS_PASSWORD: ${POSTGRES_PASSWORD}
INSTALL4J_ADD_VM_PARAMS: >-
-Xms4096m -Xmx4096m -XX:MaxDirectMemorySize=4096m
-Djava.util.prefs.userRoot=/nexus-data/javaprefs
-Dnetworkaddress.cache.ttl=5
volumes:
- nexus-data:/nexus-data
expose:
- "8081"
stop_grace_period: 2m
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:8081/service/rest/v1/status >/dev/null || exit 1"]
interval: 20s
timeout: 10s
retries: 30
start_period: 180s
networks:
- backend
- proxy
caddy:
image: caddy:2-alpine
restart: unless-stopped
depends_on:
nexus:
condition: service_healthy
environment:
NEXUS_DOMAIN: ${NEXUS_DOMAIN}
ports:
- "80:80"
- "443:443"
- "443:443/udp"
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile:ro
- caddy-data:/data
- caddy-config:/config
networks:
- proxy
networks:
backend:
internal: true
proxy:
volumes:
postgres-data:
nexus-data:
caddy-data:
caddy-config:
Os pontos principais são:
- Nexus com versão fixada, sem mudanças de
latest. - 8081 e 5432 sem mapeamento público.
- Nexus iniciado somente depois da saúde do PostgreSQL.
stop_grace_period: 2mpara os 120 segundos de parada recomendados.- Parâmetros JVM por
INSTALL4J_ADD_VM_PARAMSdesde as imagens 3.78. - Preferências Java dentro do diretório persistente.
A rede backend é interna, mas Nexus também participa da rede proxy para acessar registros externos. O orçamento de heap e memória direta exige RAM suficiente; o antigo host de 8 GB não comporta esta pilha sem ajuste. Resolva também as tags de PostgreSQL e Caddy conforme a política de manutenção.
Crie /opt/nexus/Caddyfile:
{$NEXUS_DOMAIN} {
encode zstd gzip
reverse_proxy nexus:8081 {
header_up Host {host}
header_up X-Real-IP {remote_host}
header_up X-Forwarded-For {remote_host}
header_up X-Forwarded-Proto {scheme}
transport http {
read_timeout 300s
write_timeout 300s
}
}
log {
output stdout
format json
}
}
Mantenha HTTP Forwarded Headers habilitado no Nexus. O Caddy encerra TLS e transmite host, endereço cliente e protocolo. Timeouts maiores ajudam com artefatos grandes, mas não eliminam limites de disco, clientes ou política de publicação.
A validação original é:
cd /opt/nexus
sudo docker compose --env-file .env config >/tmp/nexus-compose.rendered.yaml
sudo docker run --rm -v /opt/nexus/Caddyfile:/etc/caddy/Caddyfile:ro caddy:2-alpine caddy validate --config /etc/caddy/Caddyfile
O contêiner avulso não recebe o domínio do Compose. Além disso, a configuração expandida contém a senha do banco. Valide usando o ambiente do serviço e remova o arquivo temporário:
cd /opt/nexus
umask 077
sudo docker compose --env-file .env config --quiet
sudo docker compose --env-file .env run --rm --no-deps caddy \
caddy validate --config /etc/caddy/Caddyfile --adapter caddyfile
rm -f /tmp/nexus-compose.rendered.yaml
cd /opt/nexus
sudo docker compose --env-file .env pull
sudo docker compose --env-file .env up -d
sudo docker compose --env-file .env ps
sudo docker compose --env-file .env logs --tail=200 nexus
O primeiro início pode levar minutos. Acompanhe migrações e healthchecks em vez de reiniciar repetidamente após 30 segundos:
cd /opt/nexus
sudo docker compose --env-file .env exec postgres pg_isready -U nexus -d nexus
sudo docker compose --env-file .env exec postgres psql -U nexus -d nexus -c '\dx'
curl -fsS https://repo.example.com/service/rest/v1/status
curl -fsSI https://repo.example.com/
A saída de \dx deve mostrar pg_trgm. Se HTTPS público falhar, confira DNS, firewall e logs do Caddy:
cd /opt/nexus
sudo docker compose --env-file .env logs --tail=200 caddy
sudo ss -lntup | grep -E ':(80|443)\b'
Leia a senha de uso único em /nexus-data/admin.password:
cd /opt/nexus
sudo docker compose --env-file .env exec nexus cat /nexus-data/admin.password
Abra https://repo.example.com, entre como admin e:
- Troque a senha e guarde-a em um gerenciador.
- Decida explicitamente se permite leitura anônima.
- Crie administradores individuais em vez de compartilhar
admin. - Confirme PostgreSQL em Repository → Data Store.
- Habilite HTTP Forwarded Headers em System → Capabilities.
- Configure envio de e-mail e destinatários de alertas.
Os nomes dos menus podem mudar no Nexus One UI. O arquivo de senha pode desaparecer após o assistente, o que é normal. Não compartilhe capturas, senhas ou logs CI com credenciais em chamados ou chats.
hosted: pacotes publicados pela equipe.proxy: cache de um registro externo.group: entrada de leitura que combina repositórios.
Faça downloads pelo grupo, publique somente em hosted e deixe proxy para cache de upstream. Assim será possível mudar fontes e membros sem alterar todos os projetos.
Confira os repositórios iniciais habituais:
maven-central: proxy do Maven Central.maven-releases: releases hosted.maven-snapshots: snapshots hosted.maven-public: grupo de downloads.
Revise Blob Store, Version Policy e Deployment Policy. Impeça sobrescritas acidentais de releases e mantenha snapshots separados.
O original fornece este ~/.m2/settings.xml:
<settings xmlns="http://maven.apache.org/SETTINGS/1.2.0">
<mirrors>
<mirror>
<id>nexus</id>
<mirrorOf>*</mirrorOf>
<url>https://repo.example.com/repository/maven-public/</url>
</mirror>
</mirrors>
<servers>
<server>
<id>nexus-releases</id>
<username>${env.NEXUS_USERNAME}</username>
<password>${env.NEXUS_PASSWORD}</password>
</server>
<server>
<id>nexus-snapshots</id>
<username>${env.NEXUS_USERNAME}</username>
<password>${env.NEXUS_PASSWORD}</password>
</server>
</servers>
</settings>
Para um grupo privado, falta o servidor com ID igual ao do mirror. Salve este template completo, sem segredos expandidos, como ci/settings.xml.tpl; ele também atende às máquinas de desenvolvimento:
<settings xmlns="http://maven.apache.org/SETTINGS/1.2.0">
<mirrors>
<mirror>
<id>nexus</id>
<mirrorOf>*</mirrorOf>
<url>https://repo.example.com/repository/maven-public/</url>
</mirror>
</mirrors>
<servers>
<server>
<id>nexus</id>
<username>${env.NEXUS_USERNAME}</username>
<password>${env.NEXUS_PASSWORD}</password>
</server>
<server>
<id>nexus-releases</id>
<username>${env.NEXUS_USERNAME}</username>
<password>${env.NEXUS_PASSWORD}</password>
</server>
<server>
<id>nexus-snapshots</id>
<username>${env.NEXUS_USERNAME}</username>
<password>${env.NEXUS_PASSWORD}</password>
</server>
</servers>
</settings>
Configure os destinos de publicação no pom.xml do projeto:
<distributionManagement>
<repository>
<id>nexus-releases</id>
<url>https://repo.example.com/repository/maven-releases/</url>
</repository>
<snapshotRepository>
<id>nexus-snapshots</id>
<url>https://repo.example.com/repository/maven-snapshots/</url>
</snapshotRepository>
</distributionManagement>
Verifique se o download passa pelo Nexus:
export NEXUS_USERNAME="ci-reader"
export NEXUS_PASSWORD="replace-with-secret"
mvn -U -s "$HOME/.m2/settings.xml" dependency:go-offline
Valores reais ficam no armazenamento de segredos do CI. O Maven resolve as referências de ambiente durante a execução. Separe leitores de publicadores e não envie senhas expandidas para o repositório.
Crie:
npm-hostedpara pacotes internos.npm-proxy, com upstreamhttps://registry.npmjs.org.npm-all, comnpm-hostedenpm-proxy, nessa ordem.
Direcione os downloads ao grupo:
npm config set registry "https://repo.example.com/repository/npm-all/"
npm config get registry
npm --loglevel info view lodash version
Defina o registro hosted de publicação em package.json:
{
"name": "@example/internal-ui",
"version": "1.0.0",
"publishConfig": {
"registry": "https://repo.example.com/repository/npm-hosted/"
}
}
Habilite npm Bearer Token Realm em Security → Realms e use um usuário Nexus existente. No npm 9 ou superior, utilize o login legacy documentado:
npm adduser --auth-type=legacy --registry="https://repo.example.com/repository/npm-hosted/"
npm whoami --registry="https://repo.example.com/repository/npm-hosted/"
npm publish
Não escreva tokens no histórico do shell. O original cria este .npmrc temporário:
set -euo pipefail
umask 077
cat >.npmrc <<EOF
registry=https://repo.example.com/repository/npm-all/
//repo.example.com/repository/npm-all/:_authToken=${NEXUS_NPM_TOKEN}
always-auth=true
EOF
npm ci
rm -f .npmrc
Se npm ci falhar, o comando final de exclusão não roda; o token também está limitado à URL do grupo. Esta alternativa remove o arquivo ao sair e configura separadamente leitura do grupo e escrita no hosted. Dê ao token somente os privilégios do trabalho e deixe a publicação para o pipeline de releases. always-auth, usado por npm antigos, não é necessário em todos os clientes atuais.
set -euo pipefail
umask 077
NEXUS_NPM_CONFIG="$(mktemp)"
trap 'rm -f "$NEXUS_NPM_CONFIG"' EXIT
cat >"$NEXUS_NPM_CONFIG" <<EOF
registry=https://repo.example.com/repository/npm-all/
//repo.example.com/repository/npm-all/:_authToken=${NEXUS_NPM_TOKEN}
//repo.example.com/repository/npm-hosted/:_authToken=${NEXUS_NPM_TOKEN}
EOF
npm ci --userconfig "$NEXUS_NPM_CONFIG"
# Run this only in the release job:
# npm publish --userconfig "$NEXUS_NPM_CONFIG" --registry=https://repo.example.com/repository/npm-hosted/
ci-reader: leitura do grupo.ci-maven-publisher: leitura demaven-publice publicação em releases/snapshots.ci-npm-publisher: leitura denpm-alle escrita emnpm-hosted.- Administradores operacionais: repositórios, tarefas e segurança; nunca builds comuns.
Conceda apenas browse, read, add e edit nos repositórios necessários. Evite delete salvo necessidade real. Confira os nomes de nx-repository-view-<format>-<repository>-<action> sem recorrer a permissões globais.
Se sua edição licenciada oferece User Token, prefira credenciais rotacionáveis com vencimento. Uma credencial por pipeline ou equipe permite revogar apenas a comprometida. Consulte a matriz vigente antes de supor que uma função comercial está disponível no Community.
Crie em Jenkins Credentials:
nexus-maven: Username with password.nexus-npm-token: Secret text.
O pipeline original mostra a vinculação das credenciais:
pipeline {
agent any
stages {
stage('Build and publish') {
steps {
withCredentials([usernamePassword(
credentialsId: 'nexus-maven',
usernameVariable: 'NEXUS_USERNAME',
passwordVariable: 'NEXUS_PASSWORD'
)]) {
sh '''
set -eu
umask 077
envsubst < ci/settings.xml.tpl > ci/settings.xml
mvn -B -s ci/settings.xml clean deploy
rm -f ci/settings.xml
'''
}
}
}
}
}
Troque o corpo shell por esta sequência com o template completo. Maven resolve as variáveis de ambiente sem envsubst, e o temporário é removido mesmo quando o build falha:
set -eu
umask 077
NEXUS_SETTINGS="$(mktemp)"
trap 'rm -f "$NEXUS_SETTINGS"' EXIT
cp ci/settings.xml.tpl "$NEXUS_SETTINGS"
mvn -B -s "$NEXUS_SETTINGS" clean deploy
Não habilite set -x, que pode revelar segredos no console. Para preparar o host de CI, siga o guia Jenkins na VPS sobre HTTPS, webhooks e isolamento de agentes.
Cadastre NEXUS_USERNAME e NEXUS_PASSWORD em Actions secrets. O repositório mantém somente ci/settings.xml.tpl sem senhas:
name: publish-maven
on:
push:
tags:
- "v*"
permissions:
contents: read
jobs:
publish:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-java@v4
with:
distribution: temurin
java-version: "21"
cache: maven
- name: Publish to Nexus
env:
NEXUS_USERNAME: ${{ secrets.NEXUS_USERNAME }}
NEXUS_PASSWORD: ${{ secrets.NEXUS_PASSWORD }}
run: |
set -euo pipefail
umask 077
envsubst < ci/settings.xml.tpl > ci/settings.xml
mvn -B -s ci/settings.xml clean deploy
rm -f ci/settings.xml
Substitua o corpo run pela mesma sequência shell com trap usada no Jenkins, mantendo o mapeamento de secrets. Um rm comum depois do Maven não garante limpeza na falha.
Se um runner hospedado não acessa Nexus privado, use runner próprio na mesma rede, VPN ou acesso de confiança zero. Não exponha banco e portas de administração para facilitar o CI. As tags principais de Actions tornam o exemplo legível; fixe commits SHA revisados em produção conforme a política de cadeia de suprimentos.
- Retenha snapshots conforme último download e janela de versões necessária.
- Limpe componentes proxy npm sem uso por muito tempo.
- Não exclua releases hosted automaticamente sem aprovação.
- Agende Compact blob store após exclusões para liberar espaço físico.
- Faça backup recuperável antes de limpezas grandes e trabalhe fora do pico.
Separe blob stores ou políticas quando fizer sentido. Limpeza não é backup: dependências públicas podem ser baixadas novamente, mas artefatos internos excluídos precisam de cópias ou fontes de build.
Inclua:
- Disponibilidade HTTPS e
/service/rest/v1/status. - Saúde, reinícios e OOM de contêineres.
- Memória, carga, disco, inodes e latência I/O da VPS.
- Conexões, consultas lentas, autovacuum e backups PostgreSQL.
- Tarefas Nexus com falha, crescimento de blobs e logins anormais.
- Renovação de certificados e taxas HTTP 4xx/5xx.
Uma inspeção simples:
set -euo pipefail
cd /opt/nexus
curl -fsS --max-time 15 https://repo.example.com/service/rest/v1/status >/dev/null
sudo docker compose --env-file .env ps
df -h /var/lib/docker
df -i /var/lib/docker
sudo docker stats --no-stream
Envie os indicadores a um sistema de monitoramento para operação sem acompanhamento manual. Alertas de disco em 70% e 80% oferecem mais margem do que esperar restarem apenas 4 GB.
PostgreSQL guarda metadados; blobs contêm os artefatos. Preserve também a identidade em $data-dir/keystores/node/. Apenas uma parte não permite recuperação consistente. Nesta instalação, a maneira mais simples é parar Nexus em manutenção e copiar banco e volume completo no mesmo ponto.
O exemplo original de /opt/nexus/backup.sh fica abaixo para comparação:
#!/usr/bin/env bash
set -euo pipefail
cd /opt/nexus
STAMP="$(date -u +%Y%m%dT%H%M%SZ)"
BACKUP_ROOT="/srv/backups/nexus/${STAMP}"
sudo install -d -m 0700 "$BACKUP_ROOT"
sudo docker compose --env-file .env stop -t 120 nexus
sudo docker compose --env-file .env exec -T postgres \
pg_dump -U nexus -d nexus -Fc >"${BACKUP_ROOT}/nexus-postgres.dump"
NEXUS_VOLUME="$(sudo docker volume ls --format '{{.Name}}' | awk '/nexus-repository_nexus-data$/ {print; exit}')"
test -n "$NEXUS_VOLUME"
sudo docker run --rm \
-v "${NEXUS_VOLUME}:/source:ro" \
-v "${BACKUP_ROOT}:/backup" \
alpine:3.22 \
tar -C /source -czf /backup/nexus-data.tar.gz .
sudo docker compose --env-file .env start nexus
sha256sum "${BACKUP_ROOT}"/* | sudo tee "${BACKUP_ROOT}/SHA256SUMS" >/dev/null
sudo chmod 600 "${BACKUP_ROOT}"/*
echo "Backup complete: ${BACKUP_ROOT}"
Não escolha o volume de produção buscando um sufixo. Esse script também deixa Nexus parado se o dump falhar. Substitua pelo seguinte, executado como root: ele identifica o volume montado do contêiner, impede sobreposição, solicita reinício na falha e salva configuração e ambiente de forma privada:
#!/usr/bin/env bash
set -euo pipefail
test "$(id -u)" -eq 0
cd /opt/nexus
umask 077
exec 9>/run/lock/nexus-backup.lock
flock -n 9
NEXUS_STAMP="$(date -u +%Y%m%dT%H%M%SZ)"
NEXUS_BACKUP="/srv/backups/nexus/$NEXUS_STAMP"
install -d -m 0700 "$NEXUS_BACKUP"
NEXUS_CONTAINER="$(docker compose --env-file .env ps -q nexus)"
test -n "$NEXUS_CONTAINER"
NEXUS_DATA_VOLUME="$(docker inspect --format '{{range .Mounts}}{{if eq .Destination "/nexus-data"}}{{.Name}}{{end}}{{end}}' "$NEXUS_CONTAINER")"
test -n "$NEXUS_DATA_VOLUME"
docker volume inspect "$NEXUS_DATA_VOLUME" >/dev/null
docker pull alpine:3.22 >/dev/null
trap 'docker compose --env-file .env start nexus >&2' EXIT
docker compose --env-file .env stop -t 120 nexus
docker compose --env-file .env exec -T postgres \
pg_dump -U nexus -d nexus -Fc >"$NEXUS_BACKUP/nexus-postgres.dump"
docker run --rm \
-v "$NEXUS_DATA_VOLUME:/source:ro" \
-v "$NEXUS_BACKUP:/backup" \
alpine:3.22 tar -C /source -czf /backup/nexus-data.tar.gz .
cp -a .env compose.yaml Caddyfile initdb "$NEXUS_BACKUP/"
docker compose --env-file .env config >"$NEXUS_BACKUP/compose.rendered.yaml"
(
cd "$NEXUS_BACKUP"
sha256sum nexus-postgres.dump nexus-data.tar.gz .env compose.yaml \
Caddyfile initdb/01-nexus.sql compose.rendered.yaml >SHA256SUMS
sha256sum -c SHA256SUMS
)
docker compose --env-file .env start nexus
trap - EXIT
touch "$NEXUS_BACKUP/COMPLETE"
chmod -R go-rwx "$NEXUS_BACKUP"
printf 'Backup complete: %s\n' "$NEXUS_BACKUP"
O trap solicita reinício, mas o monitoramento deve confirmar a volta da saúde. Backup sem marcador COMPLETE está incompleto. O procedimento atende a estes volumes nomeados e blobs locais; armazenamento externo exige uma cópia coordenada própria.
Habilite e teste:
sudo chmod 750 /opt/nexus/backup.sh
sudo /opt/nexus/backup.sh
sudo find /srv/backups/nexus -maxdepth 2 -type f -printf '%p %s bytes\n' | tail -n 20
Proteja os arquivos, pois ambiente e Compose expandido contêm credenciais. Criptografe e transfira para outro host. Um tar no mesmo disco dos dados não cobre desastre. Veja o ensaio de backup e restauração de VPS para integrar restic/rclone.
Pelo menos uma vez por mês, use outra VPS ou projeto Compose independente para:
- Rodar
sha256sum -csobreSHA256SUMSdentro da pasta do backup. - Restaurar o dump em banco vazio com proprietário correto.
- Restaurar
/nexus-data, incluindo blobs, configurações e keystore. - Iniciar a mesma versão Nexus com ambiente e configuração correspondentes.
- Entrar e baixar um pacote proxy e um hosted privado.
- Testar clientes Maven e npm reais.
- Registrar RTO, RPO e passos com falha.
Mantenha Nexus parado durante a restauração. Banco e blobs devem vir da mesma janela; pontos diferentes deixam referências sem conteúdo ou blobs órfãos. Não conecte clientes de produção antes de verificar a instância restaurada.
docker compose pull && up -d apenas movimenta imagens, sem comprovar a atualização. Primeiro faça backup consistente e salve o ambiente:
set -euo pipefail
cd /opt/nexus
sudo /opt/nexus/backup.sh
sudo cp .env ".env.before-upgrade-$(date -u +%Y%m%dT%H%M%SZ)"
sudo docker compose --env-file .env pull
sudo docker compose --env-file .env config >/tmp/nexus-upgrade.compose.yaml
Leia os requisitos de todos os saltos: cruzar 3.85 pede Repair - Rebuild repository search; 3.87 afeta truststores Java personalizados; desde 3.91 Alpine pode não incluir ferramentas esperadas por scripts antigos. Para 3.98, confira correções de schemas personalizados e execução Groovy desabilitada por padrão.
Altere a versão fixada em .env após testar um clone e execute em manutenção:
cd /opt/nexus
sudo docker compose --env-file .env up -d
sudo docker compose --env-file .env ps
sudo docker compose --env-file .env logs --tail=300 nexus
curl -fsS https://repo.example.com/service/rest/v1/status
Mantenha a configuração expandida privada e apague temporários. Se o schema mudou, voltar a tag pode ser inseguro. Pare a versão nova, restaure PostgreSQL e /nexus-data do mesmo ponto anterior e inicie a versão original. Ensaie esse retorno primeiro.
cd /opt/nexus
sudo docker compose --env-file .env ps
sudo docker compose --env-file .env logs --tail=300 nexus postgres
sudo docker compose --env-file .env exec postgres pg_isready -U nexus -d nexus
Confira pg_trgm, propriedade do banco, schema JDBC, migrações em andamento, RAM e permissões dos arquivos e volumes.
Volumes nomeados geralmente são inicializados pela imagem. Se optar por diretório do host, UID 200 deve conseguir gravar:
sudo chown -R 200:200 /srv/nexus-data
sudo find /srv/nexus-data -maxdepth 1 -ls
Evite chmod -R 777, que amplia acesso e esconde um problema de propriedade.
Confira Host, X-Forwarded-Proto e HTTP Forwarded Headers. O guia Caddy cobre DNS, certificados e cabeçalhos.
- Faça o
<id>dedistributionManagementcoincidir com<server><id>. - Publique em hosted, não em group/proxy.
- Conceda add/edit no destino.
- Confira se a release já existe e a republicação está bloqueada.
- Verifique se o proxy preserva caminhos e autenticação.
Downloads de mirror privado também precisam da entrada de servidor nexus do template completo.
Habilite npm Bearer Token Realm e use --auth-type=legacy com npm 9+. A URL deve incluir /repository/<name>/ e terminar em /. Associe a autenticação CI às URLs exatas de grupo e hosted.
Confirme a limpeza e compacte o blob store correspondente. Faça backup antes de operações grandes, observe logs e I/O e evite tarefas pesadas repetidas no pico do CI.
- HTTPS funciona sem 8081/5432 públicos.
- Nexus usa versão fixa sem
latest. - PostgreSQL está ativo com
pg_trgm. - Senha inicial alterada e CI sem admin.
- Maven lê por
maven-publice publica em hosted. - npm lê por
npm-alle publica emnpm-hosted. - Permissões hosted/proxy/group separadas.
- Alertas de disco, memória, saúde, certificados e backup.
- Banco, blobs e identidade pertencem ao mesmo ponto.
- Restauração isolada comprovada.
- Cada mudança de versão tem revisão de caminho e baseline recuperável.
Um teste em 2 vCPU/4 GB pode iniciar, sem representar uma recomendação de produção. Perfis cloud-native atuais começam em 4 vCPU/16 GiB por nó extra pequeno. PostgreSQL local precisa de recursos adicionais. Para o exemplo intacto com 4 GB heap/4 GB direta, planeje host de pelo menos 16 GB para carga baixa e meça concorrência, cache e crescimento; não apresente isso como garantia oficial de throughput.
Está disponível para fluxos comuns de pessoas e equipes pequenas, conforme licença e funções atuais. Consulte a matriz vigente. Artigos antigos OSS/Pro não comprovam formatos, HA, identidade empresarial ou suporte comercial disponíveis hoje.
Sim. Crie hosted, proxy e group por formato. Separe downloads de publicação para manter claros permissões, retenção e necessidades de backup.
Harbor é focado em OCI, análise, assinatura e replicação. Nexus reúne vários ecossistemas de pacotes. Muitas equipes combinam os dois; o guia Harbor apresenta o fluxo complementar de imagens.
Limites de requisições/componentes não implicam suporte a contêineres: esse uso de H2 é explicitamente não suportado. Configure PostgreSQL desde o início para evitar migração e seguir a recomendação oficial.
Não. Metadados PostgreSQL, blobs e identidade precisam corresponder. Pare Nexus, copie o banco e /nexus-data na mesma janela, criptografe e transfira para fora do host, e teste a restauração. Conseguir abrir o arquivo não prova recuperação.
Uma instalação sustentável combina versão mantida e fixada, memória suficiente, PostgreSQL, entrada HTTPS, destinos distintos de download/publicação e permissões mínimas de CI. Backups consistentes e retorno testado permitem recuperar artefatos.
Acompanhe uma semana de crescimento e acertos de cache para definir limpeza e expansão. Depois restaure um backup real em outra instância. Essas verificações mostram se o serviço serve à equipe de forma contínua, além de exibir a tela de login.