Tutoriales de VPS
Nexus Repository en VPS: Maven, npm, HTTPS y recuperación fiable
Despliegue Nexus con versión fija, PostgreSQL y Caddy. Dimensione la JVM, configure Maven/npm privados, limite las credenciales CI y coordine copias de base, blobs e identidad del nodo.

Nexus Repository permite alojar artefactos y almacenar en caché dependencias de Maven Central, npm y otros registros. También conserva los JAR, paquetes privados y resultados de compilación del equipo. Con Jenkins, GitHub Actions y varias máquinas de desarrollo, aporta una entrada común, permisos de publicación y mayor reproducibilidad; su utilidad va más allá de guardar archivos ZIP.
Esta guía utiliza Ubuntu 24.04, Docker Compose, Nexus Repository Community Edition, PostgreSQL y Caddy. Incluye repositorios Maven/npm, credenciales CI con privilegios mínimos, supervisión, copias coherentes, restauración y actualizaciones reversibles. Es una instalación de un solo nodo, por lo que necesita un plan de recuperación.
Contexto de versiones: el artículo de septiembre de 2026 utilizaba
3.96.0, fijado mediante3.96.0-alpine. Es un ejemplo histórico, no la versión actual más reciente. La imagen predeterminada pasó a Alpine desde 3.91.0. La documentación oficial ya incluye la serie 3.98.x: revise sus notas y correcciones de seguridad antes de elegir una versión de producción. No actualice automáticamente conlatest. La versión 3.98.0 tuvo un problema de actualización con esquemas PostgreSQL personalizados, resuelto en 3.98.1; afecta especialmente al esquema usado aquí.
Resulta útil para:
- Compartir la caché de dependencias Maven/npm entre varios proyectos.
- Publicar JAR internos, POM padre, componentes frontend o paquetes CLI.
- Unificar el acceso de Jenkins, GitHub Actions y runners propios.
- Separar permisos de descarga, publicación y eliminación con límites auditables.
- Completar una cadena que ya utiliza Jenkins CI/CD, Harbor o SonarQube.
Para una persona y un proyecto con pocas descargas repetidas, un servicio gestionado puede ahorrar mantenimiento. Nexus cobra sentido al compartir cachés y paquetes privados entre clientes. No sustituye al almacenamiento de objetos ni a una unidad de archivos general.
| Sistema | Contenido principal | Clientes habituales | Relación con Nexus |
|---|---|---|---|
| Nexus Repository | Artefactos Maven, npm, PyPI, NuGet, Raw y cachés proxy | Maven, Gradle, npm, CI | Objetivo de esta guía |
| Harbor | Imágenes OCI/Docker, firmas y análisis de vulnerabilidades | Docker, Podman, Kubernetes | Especializado en imágenes |
| Gitea/GitLab | Código Git, incidencias y solicitudes de integración | Git, IDE, CI | No reemplaza un proxy general de artefactos |
| S3/objetos | Objetos de archivo | SDK, rclone, aplicaciones | Sin índices ni semántica de registro de paquetes |
Harbor es adecuado para análisis, replicación y aislamiento de imágenes. Nexus permite combinar varios ecosistemas de paquetes. Pueden coexistir: Harbor para OCI y Nexus para artefactos de lenguaje.
La antigua referencia del artículo a «2 vCPU, 8 GB de RAM y 20 GB para blobs» no corresponde al perfil pequeño oficial actual. La arquitectura de referencia vigente indica 4 vCPU y 16 GiB por nodo Nexus extra pequeño, y 8 vCPU y 32 GiB por nodo pequeño; la base de datos requiere dimensionamiento separado. Estos perfiles orientan la planificación de rendimiento, sin garantizar resultados en cualquier VPS económico.
| Uso | Punto de partida práctico | Base de datos | Condiciones |
|---|---|---|---|
| Evaluación breve | Un antiguo ensayo de 2 vCPU / 4 GB puede arrancar | H2 en un despliegue compatible sin contenedor | No es el procedimiento Docker de producción |
| Equipo con carga reducida y esta JVM sin cambios | 4 vCPU / 16 GB / 100 GB+ NVMe | PostgreSQL | Medir el conjunto y el crecimiento |
| CI frecuente | 16 GB+ para Nexus y CPU/almacenamiento según carga | PostgreSQL dimensionado aparte | Vigilar IOPS, caché y concurrencia |
| Gran escala o alta disponibilidad | Arquitectura oficial | PostgreSQL externo | Un solo VPS no proporciona HA |
Sonatype recomienda reservar alrededor de un tercio de la memoria para sistema, búferes y otros procesos. La configuración incluida permite 4 GB de heap y hasta 4 GB de memoria directa: no cabe con seguridad en una máquina de 8 GB junto con PostgreSQL. Use suficiente RAM o ajuste límites menores tras medir una carga concreta. Aumentar el heap en el mismo VPS no soluciona por sí solo un OOM.
Calcule espacio para artefactos privados, caché proxy, copias y archivos temporales de actualización. Deben quedar al menos 4 GB libres; por debajo, la base puede pasar a solo lectura. Maven e imágenes pueden ocupar cientos de GB. Una alerta al 70% permite actuar antes de agotar el disco.
Las instalaciones nuevas usan H2 de forma predeterminada. Sus límites oficiales son 200.000 peticiones diarias o 100.000 componentes, y los despliegues H2 en contenedores no están soportados. PostgreSQL es la opción recomendada para producción: configurarlo desde el primer arranque evita una migración innecesaria.
Mantenga baja latencia entre Nexus y PostgreSQL, en el mismo host para este montaje o en la misma región de nube. El usuario debe ser propietario de la base porque las actualizaciones modifican el esquema. También se requiere pg_trgm.
Prepare un dominio dedicado, como repo.example.com, con A/AAAA dirigidos al VPS. Abra únicamente:
22/tcp: SSH, restringido a IP de administración si es posible.80/tcp: validación ACME y redirección a HTTPS.443/tcp: interfaz web y clientes de paquetes.8081/tcp: solo en las redes Docker, sin publicación al host.5432/tcp: solo en las redes Docker, sin publicación al host.
Compruebe resolución y dirección pública:
export NEXUS_DOMAIN="repo.example.com"
getent ahosts "$NEXUS_DOMAIN"
curl -4 https://ifconfig.me
Corrija registros antiguos y AAAA sin conectividad antes de pedir certificados. Exponer Nexus o PostgreSQL directamente no es una solución a un proxy o DNS mal configurado.
Se utiliza el repositorio apt oficial de Docker. Omita el paso si ya verificó Engine y el plugin Compose:
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
El proyecto se guarda en /opt/nexus. La imagen de Nexus escribe con UID 200 en /nexus-data; un volumen con nombre evita muchos problemas de permisos de bind mounts.
La secuencia original para crear el directorio y la contraseña es:
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
Un directorio 0750 propiedad de root impide entrar a un administrador ordinario. Antes de esa secuencia, asigne la propiedad al usuario que mantiene el proyecto:
sudo install -d -m 0750 -o "$(id -u)" -g "$(id -g)" /opt/nexus
cd /opt/nexus
Cree /opt/nexus/.env, cambie el dominio y tome POSTGRES_PASSWORD del archivo de contraseña:
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
No añada .env, dumps ni contraseñas iniciales a Git. Pase usuario y contraseña JDBC por separado para evitar errores con caracteres especiales. La etiqueta es el ejemplo histórico: revise una versión mantenida para una instalación nueva.
Cree initdb/01-nexus.sql, con esquema propio y 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
El SQL no contiene secretos. Aplique sudo chmod 644 initdb/01-nexus.sql para que PostgreSQL pueda leer el archivo montado; el modo 640 con propietario root puede impedir la inicialización. Los scripts solo se ejecutan con el volumen de base vacío. Ante una inicialización incorrecta, inspeccione y copie los datos antes de diseñar una migración; no elimine un volumen de producción para volver a empezar.
Guarde la configuración en /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:
Sus puntos importantes son:
- Versión de Nexus fijada, sin deriva de
latest. - Puertos 8081 y 5432 sin mapeo público.
- Arranque de Nexus condicionado a PostgreSQL saludable.
stop_grace_period: 2m, con los 120 segundos de parada recomendados.- Parámetros JVM mediante
INSTALL4J_ADD_VM_PARAMSdesde las imágenes 3.78. - Preferencias Java dentro del directorio persistente.
La red backend es interna; Nexus también accede a la red proxy para descargar paquetes externos. El presupuesto de heap y memoria directa requiere una máquina con RAM suficiente, no el antiguo VPS de 8 GB. Fije también versiones de PostgreSQL y Caddy conforme a su política de mantenimiento.
Cree /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
}
}
Mantenga activada HTTP Forwarded Headers en Nexus. Caddy termina TLS y transmite host, IP cliente y protocolo. Los tiempos largos ayudan con artefactos grandes, pero siguen existiendo límites de almacenamiento, clientes y políticas de publicación.
El ejemplo original valida así:
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
El contenedor independiente no recibe el dominio de Compose. Además, el archivo Compose expandido contiene la contraseña. Valide con el entorno del propio servicio y elimine el temporal:
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
El arranque inicial puede tardar minutos. Observe migraciones y estado en lugar de reiniciar cada 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/
La salida de \dx debe mostrar pg_trgm. Si falla HTTPS público, compruebe DNS, firewall y registros de Caddy:
cd /opt/nexus
sudo docker compose --env-file .env logs --tail=200 caddy
sudo ss -lntup | grep -E ':(80|443)\b'
Lea la contraseña de un solo uso en /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 y:
- Cambie la contraseña y guárdela en un gestor.
- Decida expresamente si permite lecturas anónimas.
- Cree administradores personales en vez de compartir
admin. - Verifique PostgreSQL en Repository → Data Store.
- Active HTTP Forwarded Headers en System → Capabilities.
- Configure correo saliente y destinatarios de alertas.
Las etiquetas de menú pueden variar en Nexus One UI. El archivo de contraseña puede desaparecer al terminar el asistente; es normal. No publique capturas, contraseñas ni registros CI con credenciales en tickets o chats.
hosted: paquetes publicados por el equipo.proxy: caché de un registro remoto.group: entrada de lectura que reúne varios repositorios.
Descargue mediante grupos, publique únicamente en hosted y reserve los proxy para cachés externas. Así podrá cambiar upstreams y miembros del grupo sin modificar todos los proyectos.
Revise los repositorios iniciales habituales:
maven-central: proxy de Maven Central.maven-releases: versiones finales hosted.maven-snapshots: snapshots hosted.maven-public: grupo para descargas.
Compruebe Blob Store, Version Policy y Deployment Policy. No permita sobrescrituras accidentales de versiones finales y mantenga snapshots separados.
El artículo propone 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>
Cuando el grupo es privado falta un servidor cuyo ID coincida con el mirror. Guarde esta plantilla completa, sin secretos expandidos, como ci/settings.xml.tpl; también sirve para las máquinas de desarrollo:
<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 publicación en el pom.xml del proyecto:
<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>
Compruebe que las descargas pasan por Nexus:
export NEXUS_USERNAME="ci-reader"
export NEXUS_PASSWORD="replace-with-secret"
mvn -U -s "$HOME/.m2/settings.xml" dependency:go-offline
Las credenciales reales pertenecen al almacén de secretos CI. Maven interpreta las referencias de entorno al ejecutarse. Separe las cuentas lectoras de las publicadoras y nunca confirme contraseñas expandidas en Git.
Cree:
npm-hostedpara paquetes internos.npm-proxy, con upstreamhttps://registry.npmjs.org.npm-all, cuyos miembros seannpm-hostedynpm-proxy, en ese orden.
Dirija las descargas al grupo:
npm config set registry "https://repo.example.com/repository/npm-all/"
npm config get registry
npm --loglevel info view lodash version
Indique el registro hosted de publicación en package.json:
{
"name": "@example/internal-ui",
"version": "1.0.0",
"publishConfig": {
"registry": "https://repo.example.com/repository/npm-hosted/"
}
}
Active npm Bearer Token Realm en Security → Realms y use una cuenta Nexus existente. npm 9 o posterior necesita el flujo 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
No escriba tokens en el historial del shell. El original crea este .npmrc temporal:
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
Si falla npm ci, su eliminación final no se ejecuta; además el token solo está asociado al grupo. Esta versión limpia al salir y define por separado las URL de lectura y publicación. Limite el token a lo que necesita el trabajo y deje la publicación para el pipeline de versiones. always-auth de clientes antiguos no es necesario en todos los npm actuales.
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: lectura del grupo.ci-maven-publisher: lectura demaven-publicy publicación de releases/snapshots.ci-npm-publisher: lectura denpm-ally escritura ennpm-hosted.- Administradores operativos: repositorios, tareas y seguridad; nunca compilaciones rutinarias.
Conceda solo browse, read, add y edit en los repositorios previstos. Evite delete salvo necesidad real. Compruebe cada nombre de nx-repository-view-<format>-<repository>-<action> sin recurrir a permisos globales.
Si su edición licenciada permite User Token, utilice credenciales rotables con caducidad. Una credencial por equipo o pipeline permite revocar únicamente la comprometida. Consulte la matriz actual antes de suponer que Community dispone de una función comercial.
Cree en Jenkins Credentials:
nexus-maven: Username with password.nexus-npm-token: Secret text.
El original muestra cómo vincular credenciales:
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
'''
}
}
}
}
}
Sustituya el cuerpo shell por esta secuencia usando la plantilla Maven completa. Maven resuelve el entorno directamente, sin envsubst, y el temporal se elimina incluso si falla la compilación:
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
No active set -x, que puede revelar secretos en consola. Para preparar el host CI, siga la guía Jenkins en VPS sobre HTTPS, webhooks y separación de agentes.
Añada NEXUS_USERNAME y NEXUS_PASSWORD a Actions secrets. El repositorio contiene únicamente la plantilla ci/settings.xml.tpl sin contraseñas:
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
Reemplace el cuerpo run por el shell con trap mostrado para Jenkins y conserve el mapeo de secretos al entorno. Un rm ordinario después de Maven no garantiza limpieza si la tarea falla.
Si el runner alojado no alcanza Nexus privado, utilice runner propio en la misma red, VPN o acceso de confianza cero. No exponga la base ni los puertos de administración para facilitar CI. Las etiquetas mayores de Actions simplifican la lectura del ejemplo; producción debe fijar commits SHA revisados según su política de cadena de suministro.
- Retenga snapshots según último uso y ventana de versiones necesaria.
- Limpie componentes del proxy npm sin descargas durante mucho tiempo.
- No elimine automáticamente releases hosted sin aprobación.
- Ejecute Compact blob store tras eliminar para recuperar espacio físico.
- Haga una copia recuperable antes de limpiezas grandes y trabaje fuera de horas punta.
Use blob stores o políticas separados cuando convenga. La limpieza no es una copia: suele ser posible volver a descargar dependencias públicas, pero los artefactos internos borrados necesitan backups o su fuente de compilación.
Incluya:
- Disponibilidad HTTPS y
/service/rest/v1/status. - Reinicios, healthchecks y OOM de contenedores.
- Memoria, carga, disco, inodes y latencia I/O del VPS.
- Conexiones, consultas lentas, autovacuum y copias de PostgreSQL.
- Tareas Nexus fallidas, crecimiento de blobs y accesos anómalos.
- Renovación de certificados y proporción HTTP 4xx/5xx.
Una inspección sencilla:
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
En producción, envíe métricas a un sistema de monitorización. Alertas de disco al 70% y 80% ofrecen más margen que esperar a tener solo 4 GB libres.
PostgreSQL guarda metadatos; los blobs contienen los artefactos. Conserve también la identidad en $data-dir/keystores/node/. Una sola parte no basta. En este montaje, una ventana de mantenimiento con Nexus detenido permite copiar la base y el volumen completo al mismo punto.
El ejemplo original de /opt/nexus/backup.sh se conserva para comparar:
#!/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}"
No seleccione el volumen de producción buscando un sufijo. El script también deja Nexus detenido si falla el dump. Sustitúyalo por el siguiente, ejecutado como root: identifica el volumen montado del contenedor, bloquea copias simultáneas, intenta reiniciar al fallar y conserva configuración y entorno de manera 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"
El trap solicita el arranque, pero la monitorización debe confirmar que Nexus vuelve a estar saludable. Una copia sin marcador COMPLETE está incompleta. El procedimiento sirve para estos volúmenes con nombre y blobs locales; los almacenes externos requieren su propia copia coordinada.
Active y pruebe:
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 los archivos: entorno y Compose expandido contienen secretos. Cifre y transfiera las copias fuera del host; un tar en el mismo disco no ofrece recuperación ante desastre. Consulte el ensayo de backup y restauración de VPS para integrar restic/rclone.
Al menos mensualmente, use otro VPS o proyecto Compose independiente para:
- Ejecutar
sha256sum -csobreSHA256SUMSdesde el directorio de copia. - Restaurar el dump en una base vacía con propietario correcto.
- Restaurar
/nexus-data, incluidos blobs, configuración y keystore. - Arrancar con la misma versión Nexus y configuración correspondiente.
- Descargar un paquete proxy y un paquete hosted privado después de entrar.
- Probar clientes Maven y npm reales.
- Registrar RTO, RPO y pasos fallidos.
Mantenga Nexus parado durante la restauración. Base y blobs deben proceder de la misma ventana; puntos distintos pueden dejar referencias sin contenido o blobs huérfanos. No conecte clientes de producción hasta verificar la instancia restaurada.
docker compose pull && up -d solo mueve imágenes: no demuestra una actualización correcta. Primero haga una copia coherente y guarde el entorno:
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
Revise todos los saltos de versión: al cruzar 3.85 se requiere Repair - Rebuild repository search; 3.87 afecta truststores Java personalizados; desde 3.91 Alpine puede no incluir herramientas usadas por scripts anteriores. Para 3.98 revise los arreglos de esquemas personalizados y la ejecución Groovy desactivada de forma predeterminada.
Cambie la versión fijada en .env tras probar un clon y ejecute en mantenimiento:
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
Mantenga privada la configuración expandida y elimine temporales. Si cambia el esquema, volver a la etiqueta anterior no siempre es seguro. Detenga la versión nueva, restaure la base y /nexus-data del mismo punto anterior y arranque la versión original. Ensaye ese retorno primero.
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
Compruebe pg_trgm, propiedad de la base, esquema JDBC, migraciones pendientes, RAM y permisos de lectura/escritura de los montajes.
Los volúmenes con nombre suelen inicializarse desde la imagen. Si usa una carpeta del host deliberadamente, UID 200 debe escribir:
sudo chown -R 200:200 /srv/nexus-data
sudo find /srv/nexus-data -maxdepth 1 -ls
Evite chmod -R 777: amplía el acceso y oculta errores de propiedad.
Revise Host, X-Forwarded-Proto y HTTP Forwarded Headers. La guía Caddy ayuda con DNS, certificados y cabeceras.
- Haga coincidir el
<id>dedistributionManagementcon<server><id>. - Publique en hosted, no en group/proxy.
- Otorgue add/edit en el destino.
- Compruebe si una release existente impide republicar.
- Verifique que el proxy conserva rutas y autenticación.
Las descargas de un mirror privado requieren además la entrada de servidor nexus de la plantilla completa.
Active npm Bearer Token Realm y use --auth-type=legacy con npm 9+. La URL incluye /repository/<name>/ y termina en /. El token CI debe coincidir con las URL de grupo y hosted utilizadas.
Confirme la tarea de limpieza y compacte el blob store correspondiente. Haga copia antes de operaciones grandes, observe registros e I/O y evite repetir tareas pesadas con CI en horas punta.
- HTTPS funciona sin 8081/5432 públicos.
- Nexus usa una versión fija sin
latest. - PostgreSQL está activo y existe
pg_trgm. - Contraseña inicial cambiada y CI sin admin.
- Maven lee por
maven-publicy publica en hosted. - npm lee por
npm-ally publica ennpm-hosted. - Permisos hosted/proxy/group separados.
- Alertas de disco, memoria, salud, certificados y backups.
- Base, blobs e identidad corresponden al mismo punto.
- Restauración aislada comprobada.
- Cada cambio de versión tiene revisión de ruta y copia recuperable.
Un ensayo con 2 vCPU/4 GB puede arrancar, pero no es recomendación de producción. Los perfiles cloud-native actuales empiezan en 4 vCPU/16 GiB por nodo extra pequeño. El PostgreSQL local necesita recursos adicionales. Para el ejemplo sin modificar de 4 GB heap/4 GB directa, planifique un host de al menos 16 GB con carga reducida y mida concurrencia, caché y crecimiento; no lo presente como garantía oficial de rendimiento.
Está disponible para usos habituales de personas y equipos pequeños según licencia y funciones vigentes. Consulte la matriz actual: los artículos antiguos OSS/Pro no prueban formatos disponibles, HA, identidad empresarial ni soporte comercial de hoy.
Sí. Cree hosted, proxy y group por formato. Separe lectura y publicación para mantener claros permisos, retención y requisitos de copia.
Harbor se centra en imágenes OCI, análisis, firmas y replicación. Nexus reúne varios ecosistemas de paquetes. Es habitual combinarlos; la guía Harbor explica el flujo de imágenes complementario.
Los límites de peticiones/componentes de H2 no implican soporte de contenedores: ese despliegue no está soportado. Configure PostgreSQL desde el primer inicio para evitar migraciones y seguir la recomendación oficial.
No. Metadatos PostgreSQL, blobs e identidad deben corresponder. Pare Nexus, copie la base y /nexus-data en la misma ventana, cifre y transfiera fuera del host, y restaure para demostrar utilidad. Poder abrir el archivo no prueba recuperación.
Una instalación sostenible combina versión mantenida fija, memoria suficiente, PostgreSQL, entrada HTTPS, descargas/publicación separadas y CI con permisos mínimos. Copias coherentes y retorno probado permiten recuperar los artefactos.
Observe una semana de crecimiento y aciertos de caché para definir limpieza y ampliación. Después restaure una copia real en otra instancia. Esas pruebas muestran si el servicio resulta operativo para el equipo, más allá de abrir la página de inicio.