---
title: "Instalar Arcane Docker: Gestor de Contenedores Self-Hosted"
description: "Guia paso a paso para instalar Arcane con Docker Compose. Cubre configuracion basica, seguridad con socket proxy, autenticacion OIDC, configuracion de proxy inverso y gestion de hosts remotos."
date: 2026-02-09
categories: ["vps"]
tags: ["docker","self-hosted"]
---

import { Picture } from "astro:assets";
import arcaneUi from "@assets/images/26/02/arcane-ui.webp";

He estado ejecutando [Arcane](https://getarcane.app/) en dos de mis servidores por unas semanas ahora. Reemplazo a Portainer en ambos, y no he mirado atras. Todo corre en Go, lo que significa que es rapido, ligero en memoria, y no necesita un runtime complicado.

Si buscas una comparacion con otro gestor Docker mas nuevo, revisa mi articulo [Arcane vs Dockhand](/es/arcane-vs-dockhand/). Pero si ya decidiste por Arcane y solo quieres que funcione, esta guia cubre todo desde instalacion basica hasta seguridad con socket proxy.

## Lo que Arcane realmente hace

Arcane es una UI web de gestion Docker. Obtienes gestion de contenedores, edicion de stacks compose, logs en tiempo real, terminal web y GitOps todo en una interfaz. Se ejecuta como un unico contenedor.

<Picture
  src={arcaneUi}
  alt="UI de Arcane Docker Manager mostrando lista de contenedores y editor compose"
/>

Algunas cosas que me llamaron la atencion despues de usarlo:

<ListCheck>
<ul>
<li>API REST contra la que puedes hacer scripts directamente</li>
<li>Herramienta CLI para gestion basada en terminal junto con la UI web</li>
<li>GitOps integrado, no como un agregado. Apuntalo a un repo y tus stacks se sincronizan automaticamente</li>
<li>Soporte OIDC/SSO para single sign-on</li>
<li>Gestion de hosts remotos via el agente arcane-headless</li>
<li>Licencia BSD-3-Clause. Gratis, sin niveles pagos, sin bloqueos de features</li>
</ul>
</ListCheck>

El proyecto tiene alrededor de 4,400 estrellas en GitHub, 35 contribuidores, y ha estado en desarrollo activo desde 2022. No es software nuevo.

<YouTubeEmbed
  url="https://www.youtube.com/embed/Ew0pn9Djf-0"
  label="Arcane vs Dockhand"
/>


## 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 instalados
- Conocimiento basico de terminal

<Button link="https://go.bitdoze.com/hetzner" text="Hetzner VPS" />
<Button link="https://go.bitdoze.com/hostinger-vps" text="Hostinger VPS" />
<Button link="https://go.bitdoze.com/do" text="DigitalOcean $100 Gratis" />
<Button link="https://go.bitdoze.com/vultr" text="Vultr $100 Gratis" />

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 Arcane con Docker Compose

Hay dos formas de instalar Arcane. El script de conveniencia es el mas rapido, pero prefiero el metodo compose porque puedes ver y controlar exactamente que esta pasando.

### Instalacion rapida (script de conveniencia)

Si quieres empezar en 30 segundos:

```bash
curl -fsSL https://getarcane.app/install.sh | bash
```

Esto descarga la imagen, genera secretos e inicia el contenedor. Bueno para pruebas, pero no lo usaria para una configuracion permanente porque no controlas el archivo compose.

### Instalacion con Docker Compose (recomendado)

Primero, crea un directorio para Arcane:

```bash
mkdir -p /opt/arcane
cd /opt/arcane
```

Genera los secretos que necesitaras. Ejecuta este comando dos veces, una para `ENCRYPTION_KEY` y otra para `JWT_SECRET`:

```bash
docker run --rm ghcr.io/getarcaneapp/arcane:latest /app/arcane generate secret
```

Copia ambos valores. Ahora crea tu `compose.yaml`:

```yaml
services:
  arcane:
    image: ghcr.io/getarcaneapp/arcane:latest
    container_name: arcane
    ports:
      - "3552:3552"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - arcane-data:/app/data
      - /opt/stacks:/opt/stacks
    environment:
      - APP_URL=http://localhost:3552
      - PUID=1000
      - PGID=1000
      - ENCRYPTION_KEY=tu-clave-encripcion-generada
      - JWT_SECRET=tu-jwt-secret-generado
    restart: unless-stopped
volumes:
  arcane-data:
```

Reemplaza los valores de `ENCRYPTION_KEY` y `JWT_SECRET` con los que generaste. Configura `APP_URL` a la direccion real de tu servidor si accedes remotamente.

Inicia:

```bash
docker compose up -d
```

Abre `http://ip-de-tu-servidor:3552` en tu navegador. Las credenciales de login por defecto son `arcane` / `arcane-admin`. Cambia la contrasena inmediatamente.

<Notice type="warning" title="Las rutas de volumenes importan">
Si quieres que Arcane gestione proyectos compose existentes en tu servidor, monta el directorio con rutas coincidentes dentro y fuera del contenedor. Por ejemplo, si tus stacks viven en `/opt/stacks`, montalo como `/opt/stacks:/opt/stacks`, NO como `/opt/stacks:/app/data/projects`. Los archivos compose usan rutas relativas, y se romperan si el punto de montaje no coincide. Tambien puedes configurar la variable de entorno `PROJECTS_DIRECTORY` para decirle a Arcane donde buscar.
</Notice>

## Endurecimiento: Socket proxy de Docker

Montar el socket de Docker directamente le da a Arcane control total sobre tu daemon Docker. Eso es un riesgo de seguridad. Si Arcane se compromete de alguna manera, un atacante tiene acceso equivalente a root en tu host.

La solucion es un socket proxy que filtra que llamadas de API Docker puede hacer Arcane.

<Accordion label="Por que usar un socket proxy?" group="security" expanded="true">

El socket de Docker (`/var/run/docker.sock`) es esencialmente una API de nivel root. Cualquier contenedor con acceso a el puede crear contenedores privilegiados, montar el filesystem del host, o ejecutar comandos arbitrarios como root en el host.

Un socket proxy se sienta entre Arcane y el daemon Docker. Intercepta llamadas de API y solo permite las que has permitido explicitamente. Obtienes la funcionalidad de gestion sin entregar las llaves del reino.

Esta configuracion es recomendada para cualquier servidor expuesto a internet. Para un homelab detras de un firewall, el montaje directo del socket probablemente esta bien.

</Accordion>

Aqui hay una configuracion compose con [docker-socket-proxy de Tecnativa](https://github.com/Tecnativa/docker-socket-proxy):

```yaml
services:
  arcane:
    image: ghcr.io/getarcaneapp/arcane:latest
    container_name: arcane
    ports:
      - "3552:3552"
    volumes:
      - arcane-data:/app/data
      - /opt/stacks:/opt/stacks
    environment:
      - APP_URL=http://localhost:3552
      - PUID=1000
      - PGID=1000
      - ENCRYPTION_KEY=tu-clave-encripcion-generada
      - JWT_SECRET=tu-jwt-secret-generado
      - DOCKER_HOST=tcp://docker-socket-proxy:2375
    depends_on:
      - docker-socket-proxy
    networks:
      - arcane-net
    restart: unless-stopped

  docker-socket-proxy:
    image: tecnativa/docker-socket-proxy
    container_name: arcane-socket-proxy
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - CONTAINERS=1
      - IMAGES=1
      - NETWORKS=1
      - VOLUMES=1
      - SERVICES=1
      - TASKS=1
      - NODES=1
      - BUILD=1
      - EXEC=1
      - SYSTEM=1
      - INFO=1
      - VERSION=1
      - POST=1
      - DELETE=1
    networks:
      - arcane-net
    restart: unless-stopped

networks:
  arcane-net:
    driver: bridge

volumes:
  arcane-data:
```

Nota que Arcane ya no monta el socket de Docker directamente. En su lugar, se conecta al proxy via `DOCKER_HOST=tcp://docker-socket-proxy:2375`. El socket esta montado como solo lectura en el contenedor proxy, y ambos contenedores estan en una red bridge interna.

Las variables de entorno en el proxy controlan que endpoints de API Docker son accesibles. La lista de arriba es bastante permisiva ya que Arcane necesita la mayoria para funcionar. Puedes ajustarla mas si no necesitas ciertas features.

## Configurar OIDC/SSO

Si ya estas ejecutando un proveedor de identidad como Authentik, Keycloak o Authelia, puedes conectar Arcane a el para single sign-on.

<Tabs>
  <Tab name="Via la UI web">
    Ve a **Settings > Security > OIDC Authentication** en Arcane. Llena tu client ID, client secret y issuer URL. El redirect URI es:

    ```
    https://tu-url-arcane/auth/oidc/callback
    ```

    Guarda y prueba la conexion. Los usuarios que se autentican via OIDC son aprovisionados automaticamente en el primer login.
  </Tab>

  <Tab name="Via variables de entorno">
    Agrega estas a tu archivo compose:

    ```yaml
    environment:
      - OIDC_ENABLED=true
      - OIDC_CLIENT_ID=tu-client-id
      - OIDC_CLIENT_SECRET=tu-client-secret
      - OIDC_ISSUER_URL=https://tu-idp.ejemplo.com
      - OIDC_ADMIN_CLAIM=groups
      - OIDC_ADMIN_VALUE=arcane-admins
    ```

    `OIDC_ADMIN_CLAIM` y `OIDC_ADMIN_VALUE` te permiten auto-asignar privilegios de admin basados en un claim de tu proveedor de identidad. Asi que si un usuario pertenece al grupo `arcane-admins`, obtiene acceso de admin automaticamente.

    Si quieres deshabilitar el login con contrasena local completamente una vez que OIDC funcione, eso tambien es configurable.
  </Tab>
</Tabs>

## Configuracion de proxy inverso

Querras un proxy inverso frente a Arcane para SSL y un nombre de dominio limpio. Arcane usa WebSockets para actualizaciones en tiempo real, asi que tu configuracion de proxy necesita soportar eso.

<Tabs>
  <Tab name="Nginx">

```nginx
server {
    listen 443 ssl http2;
    server_name arcane.tudominio.com;

    ssl_certificate /ruta/a/cert.pem;
    ssl_certificate_key /ruta/a/key.pem;

    location / {
        proxy_pass http://127.0.0.1:3552;
        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;
    }
}
```

Las lineas clave son `proxy_http_version 1.1` y los encabezados `Upgrade` / `Connection`. Sin ellos, las conexiones WebSocket fallan y la UI no obtiene actualizaciones en vivo.

  </Tab>

  <Tab name="Traefik">
    Si ya estas ejecutando Traefik (y probablemente deberias para configuraciones Docker), agrega labels a tu servicio Arcane:

    ```yaml
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.arcane.rule=Host(`arcane.tudominio.com`)"
      - "traefik.http.routers.arcane.entrypoints=websecure"
      - "traefik.http.routers.arcane.tls.certresolver=letsencrypt"
      - "traefik.http.services.arcane.loadbalancer.server.port=3552"
    ```

    Traefik maneja el upgrade WebSocket automaticamente. Guia completa de Traefik: [Como usar Traefik como proxy inverso en Docker](https://www.bitdoze.com/traefik-proxy-docker/).
  </Tab>

  <Tab name="Cloudflare Tunnels">
    Si no quieres exponer puertos en absoluto, Cloudflare Tunnels funciona bien. Apunta un tunnel a `http://localhost:3552` y Cloudflare maneja SSL y enrutamiento. El soporte WebSocket es automatico.

    Esto es lo que uso en mi homelab ya que no quiero abrir ningun puerto en mi router.
  </Tab>
</Tabs>

Actualiza la variable de entorno `APP_URL` en tu archivo compose para que coincida con tu dominio real (ej., `https://arcane.tudominio.com`).

## Gestionando hosts remotos

Arcane puede gestionar Docker en otras maquinas a traves del agente `arcane-headless`. Esto es util si tienes multiples servidores pero quieres un dashboard.

En la maquina remota, despliega el agente:

```yaml
services:
  arcane-agent:
    image: ghcr.io/getarcaneapp/arcane:latest
    container_name: arcane-agent
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - AGENT_MODE=true
      - AGENT_TOKEN=tu-token-agente
      - MANAGER_API_URL=https://arcane.tudominio.com
    restart: unless-stopped
```

Genera el `AGENT_TOKEN` en tu instancia principal de Arcane, luego pegalo aqui. El agente se conecta saliente a tu instancia principal, asi que no necesitas abrir ningun puerto en la maquina remota.

## Referencia de variables de entorno

Aqui estan las variables de entorno mas utiles que puedes configurar:

| Variable | Default | Que hace |
|---|---|---|
| `APP_URL` | `http://localhost:3552` | URL publica de la instancia |
| `PUID` / `PGID` | `1000` | ID usuario/grupo para permisos de archivos |
| `ENCRYPTION_KEY` | none | Requerido. Clave de 32 bytes para encriptar datos sensibles |
| `JWT_SECRET` | none | Requerido. Secreto para firmar tokens de auth |
| `DOCKER_HOST` | `unix:///var/run/docker.sock` | Conexion Docker. Usa `tcp://` para socket proxy |
| `DATABASE_URL` | SQLite | String de conexion PostgreSQL externo |
| `GPU_MONITORING_ENABLED` | `false` | Habilitar estadisticas GPU NVIDIA/AMD |
| `GPU_TYPE` | none | `nvidia` o `amd` |
| `LOG_LEVEL` | `info` | Verbosidad de logging |
| `UI_CONFIGURATION_DISABLED` | `false` | Forzar configuracion solo via env vars |

## Solucion de problemas

<Accordion label="Arcane no puede ver mis stacks compose existentes" group="troubleshoot" expanded="true">

Esto casi siempre es un desajuste de ruta de montaje de volumen. Si tus archivos compose viven en `/opt/stacks/miapp/compose.yaml`, monta esa ruta exacta:

```yaml
volumes:
  - /opt/stacks:/opt/stacks
```

No `/opt/stacks:/alguna/otra/ruta`. Las rutas dentro y fuera del contenedor deben coincidir. Tambien configura `PROJECTS_DIRECTORY=/opt/stacks` en el environment.

</Accordion>

<Accordion label="Errores WebSocket o UI no se actualiza en vivo" group="troubleshoot">

Tu proxy inverso no esta reenviando conexiones WebSocket. Asegurate de tener los encabezados de upgrade configurados. Para Nginx, necesitas:

```nginx
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
```

</Accordion>

<Accordion label="Permission denied en socket Docker" group="troubleshoot">

Agrega tu usuario al grupo `docker` (`sudo usermod -aG docker $USER`) o asegurate de que los valores `PUID`/`PGID` en el archivo compose coinciden con un usuario con acceso Docker.

</Accordion>

<Accordion label="No puedo generar secretos" group="troubleshoot">

El comando de generacion de secretos requiere descargar la imagen de Arcane primero. Si falla, descarga manualmente:

```bash
docker pull ghcr.io/getarcaneapp/arcane:latest
docker run --rm ghcr.io/getarcaneapp/arcane:latest /app/arcane generate secret
```

</Accordion>

## Lo que me gusta y lo que falta

Despues de unas semanas con Arcane, aqui es donde estoy.

La integracion GitOps es genuinamente buena. Mantengo mis archivos compose en un repo Git privado, y cuando pusheo cambios, Arcane los recoge y redespliega. Sin configuracion de webhook, sin pipeline CI necesario. Simplemente funciona.

La API REST es otro punto fuerte. Escribi un script pequeno que revisa la salud de contenedores y reinicia cualquier cosa que este unhealthy. Tomo unos 20 minutos porque la API es directa.

Lo que desearia que tuviera: escaneo de vulnerabilidades (Dockhand tiene esto), auto-actualizaciones programadas con proteccion de rollback, y un navegador de archivos para contenedores. Estos no son dealbreakers, pero harian de Arcane el paquete completo.

Si quieres escaneo de vulnerabilidades y algunas de esas features faltantes, revisa [como instalar Dockhand](/es/instalar-dockhand/). Tambien esta [UsulNet](/es/instalar-usulnet/), una plataforma de gestion Docker todo en uno mas nueva que agrupa escaneo Trivy, backups, configuracion de proxy inverso y orquestacion multi-nodo en un unico binario Go.

## Articulos relacionados

- [Mejores alternativas a Portainer en 2026](/es/alternativas-portainer/) - cinco UIs de gestion Docker comparadas
- [Arcane vs Dockhand](/es/arcane-vs-dockhand/) - comparacion lado a lado de ambas herramientas
- [Instalar Dockhand](/es/instalar-dockhand/) - el otro gestor Docker que vale la pena probar
- [Instalar UsulNet](/es/instalar-usulnet/) - plataforma de gestion Docker todo en uno con escaneo, backups y multi-nodo
- [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