---
title: "Instalar UsulNet Docker: Plataforma de Gestion de Contenedores Todo en Uno"
description: "Guia paso a paso para instalar UsulNet con Docker Compose. Cubre configuracion de produccion con PostgreSQL, Redis, NATS, escaneo de seguridad, despliegue multi-nodo, proxy inverso y configuracion RBAC."
date: 2026-02-11
categories: ["vps"]
tags: ["docker","self-hosted"]
---
import { Picture } from "astro:assets";
import usulnetDashboard from "@assets/images/26/02/usulnet-dashboard.png";
import usulnetContainers from "@assets/images/26/02/usulnet-containers.png";
import usulnetSecurity from "@assets/images/26/02/usulnet-security.png";
import usulnetStacks from "@assets/images/26/02/usulnet-stacks.png";
import usulnetNodes from "@assets/images/26/02/usulnet-nodes.png";
Me encontre con [UsulNet](https://usulnet.com/) mientras navegaba GitHub por herramientas de gestion Docker. Me llamo la atencion porque intenta ser todo en un binario: gestion de contenedores, escaneo de seguridad, configuracion de proxy inverso, backups, monitoreo, orquestacion multi-nodo. Esa es una lista larga de features para un proyecto que recien lanzo su primer beta publica (v26.2.0) en Febrero 2026.
He estado escribiendo sobre herramientas en este espacio recientemente, incluyendo [Arcane](/es/instalar-arcane/) y [Dockhand](/es/instalar-dockhand/). UsulNet toma un enfoque diferente de ambos. Donde Arcane se enfoca en ser una UI Docker limpia y open source con GitOps, y Dockhand se inclina por el escaneo de seguridad y auto-actualizaciones, UsulNet quiere reemplazar todo tu stack de herramientas de gestion. Si realmente logra eso es una pregunta justa, pero la ambicion es real.
## Lo que hace UsulNet
UsulNet es una plataforma de gestion Docker self-hosted escrita en Go. Compila a un unico binario de ~50 MB sin dependencias de runtime. Sin Node.js, sin Python, sin framework frontend pesado. La UI es HTML server-rendered usando plantillas Templ, Tailwind CSS, Alpine.js y HTMX.
Esto es lo que obtienes out of the box:
Gestion completa de ciclo de vida de contenedores con operaciones bulk, estadisticas, exec, navegador de filesystem
Despliegue de stacks Docker Compose con catalogo de plantillas integrado
Escaneo de vulnerabilidades Trivy con puntaje de seguridad (0-100 por contenedor)
Generacion de SBOM en formatos CycloneDX y SPDX
RBAC con mas de 44 permisos granulares y roles personalizados
2FA/TOTP, autenticacion LDAP, OIDC
Monitoreo con reglas de alerta y 11 canales de notificacion
Integracion Caddy y Nginx Proxy Manager para proxy inverso
Arquitectura multi-nodo master/agent con mensajeria NATS y mTLS
Editor de codigo Monaco y Neovim ejecutandose en el navegador
Conexiones SSH, RDP, navegador de bases de datos, navegador LDAP, integracion Git
API REST con docs OpenAPI 3.0 y streams WebSocket
Esa lista es larga, y sere honesto, no he probado cada feature individual. La gestion de contenedores central, despliegue de stacks y escaneo de seguridad funcionan bien. Algunas de las features mas de nicho como el Neovim en navegador y conexiones RDP se sienten como items bonus que pueden o no importarte.
## Como se compara UsulNet con otros gestores Docker
Si vienes de [Arcane](/es/instalar-arcane/) o [Dockhand](/es/instalar-dockhand/), o mirando la [comparacion Arcane vs Dockhand](/es/arcane-vs-dockhand/), asi es como UsulNet encaja:
| | UsulNet | Arcane | Dockhand |
|---|---|---|---|
| Licencia | AGPL-3.0 | BSD-3-Clause | BSL 1.1 |
| Backend | Go (binario unico) | Go | Bun + SvelteKit |
| Frontend | Templ + HTMX + Alpine.js | SvelteKit | SvelteKit 2 / Svelte 5 |
| Escaneo vuln | Trivy (integrado) | No | Grype/Trivy |
| RBAC | Si (44+ permisos) | No | Solo nivel Enterprise |
| Multi-nodo | NATS + agentes mTLS | arcane-headless | Hawser |
| Proxy inverso | Integracion Caddy + NPM | No | No |
| Backups | S3, local, Azure, GCS, B2, SFTP | No | No |
| Monitoreo/alertas | Integrado con 11 canales | No | No |
| Navegador DB | PostgreSQL, MySQL, MongoDB, Redis, SQLite | No | No |
| Editor de codigo | Monaco + Neovim | No | No |
| GitOps | Auto-deploy en Git push | GitOps integrado | Git + webhooks |
| Docker Swarm | Si | No | No |
| Estado | Beta (v26.2.0, primer release) | Stable (desde 2022) | v1 (desde Dic 2025) |
| Precios | Gratis CE (2 nodos, 3 usuarios), Business desde EUR79/nodo/ano | Gratis | Gratis homelab, SMB $499/host/ano |
UsulNet tiene el conjunto de features mas amplio de los tres, pero tambien es el mas nuevo. Arcane ha estado desde 2022 con mas de 1,800 commits y 35 contribuidores. UsulNet tiene 11 commits y un desarrollador. Esa brecha importa cuando encuentras un caso extremo a las 2am.
UsulNet esta en beta publica. Es funcional, pero espera bordes rugosos. El desarrollador esta enviando actualizaciones activamente, pero este es un proyecto solo por ahora. Si necesitas algo probado en batalla, mira [Arcane](/es/instalar-arcane/) primero.
## Requisitos previos
Antes de empezar, necesitas:
- Un servidor Linux (VPS o maquina local). Recomiendo [Hetzner](https://go.bitdoze.com/hetzner), [Hostinger](https://go.bitdoze.com/hostinger-vps) para hosting VPS
- Docker y Docker Compose v2 instalados
- Al menos 2 GB RAM (4 GB recomendados)
- Puertos 8080 (HTTP) y 7443 (HTTPS) disponibles
O usa un [Mini PC como servidor casero](https://www.bitdoze.com/best-mini-pc-home-server/).
### Instalar Docker
Si no tienes Docker aun:
```sh
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
jammy stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin docker-compose
```
Recorrido completo: [Instalar Docker y Docker-compose para Ubuntu](https://www.bitdoze.com/install-docker-ubuntu-arm/).
## Instalar UsulNet con Docker Compose
UsulNet necesita PostgreSQL, Redis y NATS junto a la aplicacion principal. Eso es mas partes moviles que Arcane (que corre como un unico contenedor) o Dockhand (contenedor unico con PostgreSQL opcional). La compensacion es que obtienes gestion de sesiones proper, caching y mensajeria inter-nodo integrados.
### Instalacion rapida (un comando)
La forma mas rapida de empezar:
```bash
curl -fsSL https://raw.githubusercontent.com/fr4nsys/usulnet/main/deploy/install.sh | bash
```
Esto descarga el archivo compose de produccion, genera todos los secretos automaticamente e inicia todo. Estaras listo en unos 60 segundos. Accede en `https://ip-de-tu-servidor:7443` con credenciales por defecto `admin` / `usulnet`.
Aun recomendare el metodo manual de abajo para que sepas que hay en el archivo compose y puedas personalizarlo.
### Instalacion manual con Docker Compose (recomendado)
Crea un directorio para UsulNet:
```bash
mkdir -p /opt/usulnet && cd /opt/usulnet
```
Descarga el archivo compose de produccion y template de environment:
```bash
curl -fsSL https://raw.githubusercontent.com/fr4nsys/usulnet/main/deploy/docker-compose.prod.yml -o docker-compose.yml
curl -fsSL https://raw.githubusercontent.com/fr4nsys/usulnet/main/deploy/.env.example -o .env
```
Genera los secretos. Necesitas una contrasena de base de datos, un JWT secret y una clave de encripcion:
```bash
sed -i "s|CHANGE_ME_GENERATE_RANDOM_PASSWORD|$(openssl rand -base64 24 | tr -dc 'a-zA-Z0-9' | head -c 32)|" .env
sed -i "s|CHANGE_ME_GENERATE_WITH_OPENSSL_RAND_HEX_32|$(openssl rand -hex 32)|" .env
sed -i "s|CHANGE_ME_GENERATE_WITH_OPENSSL_RAND_HEX_32|$(openssl rand -hex 32)|" .env
```
O abre el archivo `.env` y llena los valores manualmente. Tu eleccion.
Inicia todo:
```bash
docker compose up -d
```
Abre `https://ip-de-tu-servidor:7443` en tu navegador. UsulNet genera un certificado TLS self-signed en el primer inicio, asi que obtendras una advertencia del navegador. Inicia sesion con `admin` / `usulnet` y cambia la contrasena de inmediato.
El login por defecto es `admin` / `usulnet`. Cambia la contrasena inmediatamente despues del primer login. Ve a la configuracion de tu perfil para actualizarla. Tambien habilita 2FA mientras estas ahi.
### Que incluye el archivo compose
Esto es lo que se despliega:
```yaml
services:
usulnet:
image: ghcr.io/fr4nsys/usulnet:latest
ports:
- "8080:8080" # HTTP
- "7443:7443" # HTTPS (auto-TLS)
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
- usulnet-data:/var/lib/usulnet
environment:
- USULNET_DATABASE_URL=postgres://usulnet:secret@postgres:5432/usulnet?sslmode=disable
- USULNET_REDIS_URL=redis://redis:6379/0
- USULNET_NATS_URL=nats://nats:4222
- USULNET_SECURITY_JWT_SECRET=tu-secret-key-min-32-chars-largo
- USULNET_SECURITY_CONFIG_ENCRYPTION_KEY=tu-64-hex-char-aes-256-key-aqui
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_started
nats:
condition: service_started
restart: unless-stopped
postgres:
image: postgres:16-alpine
environment:
POSTGRES_DB: usulnet
POSTGRES_USER: usulnet
POSTGRES_PASSWORD: secret
volumes:
- postgres-data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U usulnet"]
interval: 5s
timeout: 5s
retries: 5
restart: unless-stopped
redis:
image: redis:7-alpine
command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru
volumes:
- redis-data:/data
restart: unless-stopped
nats:
image: nats:2.10-alpine
command: ["--jetstream", "--store_dir", "/data"]
volumes:
- nats-data:/data
restart: unless-stopped
volumes:
usulnet-data:
postgres-data:
redis-data:
nats-data:
```
Cuatro contenedores en total. PostgreSQL almacena todos los datos de la aplicacion, Redis maneja sesiones y caching, NATS proporciona la capa de mensajeria para comunicacion multi-nodo (incluso en modo standalone, UsulNet espera que este ahi).
Nota que el socket Docker esta montado como `:ro` (solo lectura). UsulNet todavia funciona bien para gestion de contenedores con un montaje de socket solo lectura porque la API Docker maneja operaciones de escritura a traves del socket independientemente del flag de montaje. El flag `:ro` solo previene que UsulNet modifique el archivo socket mismo.
## Gestion de contenedores y stacks
La gestion de contenedores funciona mas o menos como esperarias. Obtienes una lista de todos los contenedores en ejecucion con estadisticas de CPU y memoria en tiempo real, y puedes iniciar, detener, reiniciar, pausar, matar o removerlos individualmente o en bulk.
Lo que encontre mas interesante es el despliegue de stacks. Puedes desplegar stacks compose de tres formas:
Pega o escribe un archivo compose directamente en el editor web. UsulNet valida el YAML antes de desplegar. El editor es Monaco (el mismo que usa VS Code), asi que obtienes syntax highlighting y autocomplete.
Conecta un repositorio Git (Gitea, GitHub o GitLab) y despliega stacks desde archivos compose en el repo. Puedes configurar reglas de auto-deploy que redespliegan cuando pusheas cambios a una rama especifica.
UsulNet tiene un catalogo de stacks integrado con plantillas pre-configuradas para aplicaciones comunes. Elige una, ajusta la configuracion y despliega. Bueno para levantar rapidamente algo que quieres probar.
El navegador de filesystem de contenedor y terminal web ambos funcionan. Puedes navegar archivos dentro de contenedores en ejecucion, editarlos con el editor Monaco y abrir sesiones exec. La terminal usa xterm.js, la misma libreria que usan la mayoria de terminales web. Es suficientemente responsiva para trabajo interactivo.
## Escaneo de seguridad con Trivy
UsulNet integra Trivy para escaneo de vulnerabilidades. Esto corre localmente en tu servidor y no envia datos a servicios externos.
Para habilitarlo, asegurate de que Trivy este configurado en tu `config.yaml` o via variables de entorno:
```yaml
trivy:
enabled: true
cache_dir: /var/lib/usulnet/trivy
timeout: 5m
severity: CRITICAL,HIGH,MEDIUM
ignore_unfixed: false
update_db_on_start: true
```
O configura `USULNET_TRIVY_ENABLED=true` en tu environment.
Lo que distingue esto del escaneo de Dockhand es el puntaje de seguridad. Cada contenedor obtiene un puntaje 0-100 basado en los resultados del escaneo, y obtienes un puntaje agregado a traves de toda tu infraestructura. Tambien hay seguimiento de tendencias, asi que puedes ver si tu postura de seguridad esta mejorando o empeorando con el tiempo.
UsulNet tambien genera SBOMs (Software Bill of Materials) en formatos CycloneDX y SPDX. Si necesitas documentar que esta corriendo en tus contenedores para propositos de compliance, eso esta integrado.
El primer escaneo de vulnerabilidades descarga la base de datos de Trivy, que son unos pocos cientos de MB. Escaneos subsecuentes son mas rapidos porque la base de datos esta cacheada localmente. Si el primer escaneo hace timeout, aumenta el valor `timeout` en la configuracion de Trivy.
## Configurar autenticacion
UsulNet soporta multiples metodos de autenticacion. La Community Edition gratuita incluye TOTP 2FA. OIDC y LDAP requieren licencia Business.
### 2FA/TOTP (gratis)
Cada usuario puede habilitar autenticacion de dos factores basada en TOTP desde la configuracion de su perfil. Funciona con cualquier app autenticadora (Google Authenticator, Authy, etc.). Se generan codigos de backup para que no quedes bloqueado.
### OIDC/OAuth2 (licencia Business)
Si ejecutas un proveedor de identidad como Authentik, Keycloak, o quieres usar login GitHub/Google/Microsoft, configura OIDC en los ajustes. Necesitaras:
- Client ID
- Client secret
- Issuer URL / Discovery endpoint
Los usuarios son aprovisionados automaticamente en el primer login OIDC. Puedes mapear grupos OIDC a roles UsulNet para asignacion automatica de permisos.
### LDAP/Active Directory (licencia Business)
Para entornos enterprise, UsulNet puede autenticar contra directorios LDAP. Configura el proveedor LDAP con tu bind DN, search base y mapeos de atributos. Tambien hay un navegador LDAP integrado para probar y depurar tu configuracion de directorio.
## Gestion multi-nodo
UsulNet usa una arquitectura master/agent para gestionar Docker a traves de multiples hosts. La capa de comunicacion es NATS con JetStream para persistencia, y todo el trafico agent-master esta encriptado con mTLS.
Hay tres modos:
- **standalone**: nodo unico, el por defecto
- **master**: plano de control que gestiona agentes
- **agent**: nodo worker que se conecta a un master
### Desplegando agentes
Puedes desplegar agentes a hosts remotos directamente desde la UI web. Ve a **Nodes > Add Node**, ingresa las credenciales SSH para la maquina remota y haz clic en **Deploy Agent**. UsulNet hace SSH al host remoto, instala el contenedor agente y lo configura automaticamente.
O despliega manualmente en la maquina remota:
```yaml
# config.yaml en el agente
mode: agent
agent:
master_url: nats://master-nats:4222
name: worker-01
token: tu-auth-token
heartbeat_interval: 30s
metrics_interval: 1m
```
El agente envia heartbeats y metricas a intervalos configurables. Si un agente se desconecta, el dashboard muestra el cambio de estado. Puedes cambiar entre hosts gestionados desde cualquier pagina en la UI.
Esto es diferente de como Arcane y Dockhand manejan multi-nodo. Arcane usa `arcane-headless`, un agente ligero que se conecta saliente. Dockhand usa Hawser, que tiene traversia NAT. El enfoque basado en NATS de UsulNet es mas involucrado de configurar pero te da mensajeria persistente y mejor confiabilidad para despliegues mas grandes.
## Integracion de proxy inverso
Esto es algo que ni Arcane ni Dockhand ofrecen. UsulNet puede configurar Caddy o Nginx Proxy Manager directamente desde su UI.
Si ejecutas Caddy, habilita la integracion en tu config:
```yaml
caddy:
enabled: true
admin_url: http://caddy:2019
acme_email: admin@ejemplo.com
```
Luego puedes crear hosts proxy, gestionar certificados y configurar rutas desde el dashboard de UsulNet. Caddy maneja HTTPS automatico con Let's Encrypt.
Integracion completa de Nginx Proxy Manager tambien esta disponible. Gestiona hosts proxy, certificados SSL, redirecciones, streams TCP/UDP y listas de acceso, todo desde dentro de UsulNet.
Si quieres poner UsulNet mismo detras de un proxy inverso, sirve en puerto 8080 (HTTP) y 7443 (HTTPS) por defecto. El soporte WebSocket es requerido para logs en vivo, terminal y metricas en tiempo real.
```nginx
server {
listen 443 ssl http2;
server_name usulnet.tudominio.com;
ssl_certificate /ruta/a/cert.pem;
ssl_certificate_key /ruta/a/key.pem;
location / {
proxy_pass http://127.0.0.1:8080;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
```
Agrega labels al servicio UsulNet:
```yaml
labels:
- "traefik.enable=true"
- "traefik.http.routers.usulnet.rule=Host(`usulnet.tudominio.com`)"
- "traefik.http.routers.usulnet.entrypoints=websecure"
- "traefik.http.routers.usulnet.tls.certresolver=letsencrypt"
- "traefik.http.services.usulnet.loadbalancer.server.port=8080"
```
Configuracion completa de Traefik: [Como usar Traefik como proxy inverso en Docker](https://www.bitdoze.com/traefik-proxy-docker/).
Apunta un tunnel a `http://localhost:8080`. El manejo de SSL y WebSocket es automatico. Sin puertos que abrir.
## Configuracion de backups
UsulNet puede respaldar contenedores individuales, volumenes o stacks enteros en un horario. Los backends de almacenamiento incluyen filesystem local, AWS S3, MinIO, Azure Blob, Google Cloud Storage, Backblaze B2 y SFTP.
Configura el almacenamiento en tu `config.yaml`:
```yaml
storage:
type: s3
s3:
endpoint: s3.amazonaws.com
bucket: usulnet-backups
region: us-east-1
access_key: TU_KEY
secret_key: TU_SECRET
backup:
compression: zstd
compression_level: 3
default_retention_days: 30
```
O usa almacenamiento local:
```yaml
storage:
type: local
path: /var/lib/usulnet/backups
```
Los backups se comprimen con gzip o zstd (tu eleccion) y pueden restaurarse con un clic desde la UI.
## Referencia de variables de entorno
Todos los valores de config pueden configurarse via variables de entorno con el prefijo `USULNET_`:
| Variable | Default | Que hace |
|---|---|---|
| `USULNET_SERVER_PORT` | `8080` | Puerto HTTP |
| `USULNET_SERVER_HTTPS_PORT` | `7443` | Puerto HTTPS |
| `USULNET_DATABASE_URL` | none | String de conexion PostgreSQL (requerido) |
| `USULNET_REDIS_URL` | none | String de conexion Redis (requerido) |
| `USULNET_NATS_URL` | none | String de conexion NATS (requerido) |
| `USULNET_SECURITY_JWT_SECRET` | none | Secreto de firma JWT, min 32 chars (requerido) |
| `USULNET_SECURITY_CONFIG_ENCRYPTION_KEY` | none | Clave AES-256, 64 hex chars (requerido) |
| `USULNET_TRIVY_ENABLED` | `false` | Habilitar escaneo de vulnerabilidades Trivy |
| `USULNET_MODE` | `standalone` | Modo de operacion: standalone, master, agent |
| `USULNET_SERVER_RATE_LIMIT_RPS` | `100` | Rate limit por segundo |
## Licenciamiento y precios
UsulNet tiene licencia AGPL-3.0. El codigo fuente esta en [GitHub](https://github.com/fr4nsys/usulnet) y puedes usarlo, modificarlo y distribuirlo libremente. El catch con AGPL es que si modificas UsulNet y lo haces disponible a traves de una red, tienes que liberar tus cambios bajo la misma licencia.
| Nivel | Costo | Que obtienes |
|---|---|---|
| Community (CE) | Gratis | Gestion Docker completa, escaneo, monitoreo, 2 nodos, 3 usuarios, 1 equipo |
| Business | EUR79/nodo/ano | Nodos ilimitados, OIDC, LDAP, roles personalizados, export log de auditoria, API keys |
| Enterprise | Custom | Todo ilimitado, SSO SAML, modo HA, white label, soporte dedicado |
La Community Edition esta limitada a 2 nodos, 3 usuarios y 1 equipo. La autenticacion OIDC y LDAP requiere licencia Business. Eso es mas restrictivo que Arcane (totalmente gratis, sin limites) o Dockhand (nivel gratuito con OIDC incluido), pero tambien obtienes muchas mas features en la CE que cualquiera de esos ofrecen.
## Solucion de problemas
Asegurate de que el contenedor de base de datos esta healthy antes de que UsulNet intente conectarse. El `depends_on` con `condition: service_healthy` en el archivo compose deberia manejar esto, pero si estas iniciando servicios manualmente, PostgreSQL necesita estar completamente listo primero.
Verifica la salud de PostgreSQL:
```bash
docker exec usulnet-postgres pg_isready -U usulnet
```
Si retorna "accepting connections", la base de datos esta bien y el problema probablemente esta en tu string de conexion.
UsulNet genera un certificado TLS self-signed en el primer inicio para HTTPS en el puerto 7443. Tu navegador mostrara una advertencia. Para produccion, pon un proxy inverso proper con certificados Let's Encrypt frente a el, o configura certificados TLS personalizados en el config:
```yaml
server:
tls:
enabled: true
cert_file: /ruta/a/cert.pem
key_file: /ruta/a/key.pem
```
El primer escaneo descarga la base de datos de vulnerabilidades, que puede ser grande. Aumenta el timeout:
```yaml
trivy:
timeout: 10m
```
Tambien verifica que el contenedor tiene acceso a internet saliente para descargar la base de datos. Si estas detras de un proxy, configura las variables de entorno `HTTP_PROXY` y `HTTPS_PROXY` en el contenedor UsulNet.
Si ves errores de conexion NATS en los logs, asegurate de que el contenedor NATS esta ejecutandose y accesible. El directorio de datos de JetStream por defecto necesita permisos de escritura:
```bash
docker logs usulnet-nats
```
Si NATS esta ejecutandose pero UsulNet no puede conectarse, verifica que ambos contenedores esten en la misma red Docker.
## Mi opinion despues de probar
UsulNet es ambicioso. Un desarrollador, primer beta publica, y la lista de features parece un producto que ha estado en desarrollo por anos. La gestion de contenedores, despliegue de stacks y escaneo Trivy funcionan. La UI es limpia y responsiva, y el backend Go es rapido.
Lo que me preocupa es la madurez del proyecto. Once commits, un contribuidor, primer release. Compara eso con Arcane (mas de 1,800 commits, 35 contribuidores, stable desde 2022) y ves la brecha. La licencia AGPL tambien vale la pena pensar si planeas modificar el fuente, ya que estas obligado a compartir tus cambios.
El stack de cuatro contenedores (PostgreSQL, Redis, NATS, mas la app misma) es mas pesado que el contenedor unico de Arcane o el enfoque de contenedor unico de Dockhand. En un VPS pequeno con 2 GB RAM, esa sobrecarga es notable. En una maquina con 4+ GB, no es gran cosa.
Si quieres el conjunto de features mas amplio en una herramienta de gestion Docker y estas confortable ejecutando software beta, UsulNet vale la pena probar. Si quieres estabilidad y un historial probado, [Arcane](/es/instalar-arcane/) es la opcion mas segura. Si el escaneo de seguridad es tu prioridad y quieres algo mas ligero, revisa [Dockhand](/es/instalar-dockhand/).
## Articulos relacionados
- [Mejores alternativas a Portainer en 2026](/es/alternativas-portainer/) - cinco UIs de gestion Docker comparadas
- [Instalar Arcane](/es/instalar-arcane/) - gestor Docker open source con GitOps
- [Instalar Dockhand](/es/instalar-dockhand/) - gestor Docker enfocado en seguridad
- [Arcane vs Dockhand](/es/arcane-vs-dockhand/) - comparacion de otras dos UIs de gestion Docker
- [Instalar Dockge](/es/instalar-dockge/) - otra UI de gestion Docker
- [Mejores contenedores Docker para servidor casero](/docker-containers-home-server/) - que ejecutar una vez configurado tu gestor
- [Mejores paneles self-hosted](/best-self-hosted-panels/) - paneles de gestion de servidor comparados
- [Proxy inverso Traefik para Docker](/traefik-proxy-docker/) - configuracion proper de proxy inverso
- [Auto-actualizacion Docker con Tugtainer](/tugtainer-docker-autoupdate/) - mantener contenedores actualizados
- [Herramientas de monitoreo de servidor](/sever-monitoring/) - monitoreando tu host Docker