# Instalar un worker Allin — Docker Compose

Despliega tu worker con Coolify o Docker Compose y conecta Claude Code, Codex y GitHub desde el servidor.

## Antes de desplegar

Esta guía instala un worker conectado a tu espacio Allin, no un nuevo servidor Allin. La imagen pública incluye el paquete Allin, Claude Code, Codex y GitHub CLI.

- Prepara un servidor Linux amd64 con Docker y acceso SSH. Si usas Coolify, el servidor debe estar ya conectado a Coolify.
- En Allin → Workers, crea un worker de tipo Contenedor, selecciona sus agentes y copia su clave. Comprueba los jobs pendientes: pueden iniciarse en cuanto se conecte un motor.
- ALLIN_URL es la dirección de tu instancia Allin, accesible desde el contenedor. ALLIN_WORKER_API_KEY es la clave de este worker. No ejecutes dos contenedores con la misma clave.
- El servidor debe poder acceder a Allin, GHCR, los servicios del motor elegido y GitHub si se usa. El servidor Allin realiza las llamadas a las integraciones MCP remotas.

Sustituye USER, WORKER_HOST, WORKER_CONTAINER y PASTE_YOUR_WORKER_KEY_HERE. No pidas al usuario que pegue secretos en el chat: usa las variables privadas de Coolify. El usuario debe completar las conexiones en el navegador.

Obtén la aprobación del usuario antes de crear un recurso de pago o ejecutar un job facturable. Esta guía no autoriza ningún gasto.

## Docker Compose

Claude Code, Codex y el paquete Allin están instalados en la imagen. Guarda compose.yaml y .env en la misma carpeta.

Conectarse al servidor del worker

```sh
ssh USER@WORKER_HOST
mkdir -p ~/allin-worker
cd ~/allin-worker
```

[Descargar Docker Compose](https://tryallin.com/downloads/allin-worker.compose.yaml)

[Descargar perfil Docker](https://tryallin.com/downloads/allin-worker.seccomp.json)

Descargar Docker Compose

```sh
curl --fail --location 'https://tryallin.com/downloads/allin-worker.compose.yaml' -o compose.yaml
curl --fail --location 'https://tryallin.com/downloads/allin-worker.seccomp.json' -o allin-worker.seccomp.json
```

Coloca allin-worker.seccomp.json junto a compose.yaml. El perfil seccomp y la excepción AppArmor permiten el sandbox de Codex. Usa un host dedicado: AppArmor se desactiva solo para este contenedor, que sigue sin privilegios, sin root, sin capacidades y con no-new-privileges.

.env

```dotenv
ALLIN_WORKER_NAME=allin-worker
ALLIN_URL=https://tryallin.com
ALLIN_WORKER_API_KEY=PASTE_YOUR_WORKER_KEY_HERE
```

Sustituye PASTE_YOUR_WORKER_KEY_HERE por la clave copiada de Allin. No compartas este archivo.

Descargar la imagen del worker

```sh
chmod 600 .env
docker compose pull
```

## ¿En qué máquina ejecuto estos comandos?

Si el worker está en un servidor remoto, conéctate primero por SSH a ese servidor. Ejecuta todos los comandos de Claude, Codex y GitHub siguientes en ese terminal remoto, no en tu ordenador.

Conectarse al servidor del worker

```sh
ssh USER@WORKER_HOST
cd /path/to/allin-worker
```

Sustituye USER, WORKER_HOST y la ruta por los de tu instalación. Con Docker, usa la carpeta que contiene el compose.yaml y el .env de este worker para utilizar sus volúmenes de autenticación.

Abre los enlaces de inicio de sesión en el navegador de tu ordenador. Introduce el código mostrado si se solicita y vuelve al terminal del worker. Las credenciales permanecen en el servidor del worker. Para un worker local, usa su terminal local.

Conecta GitHub primero si tus agentes lo utilizan. Los jobs pueden empezar en cuanto se conecte un motor.

Conecta Claude Code y/o Codex según los motores elegidos para tus agentes. Reinicia el worker tras añadir una cuenta para que reconozca el nuevo motor.

## GitHub para clonar repositorios

La conexión gh sirve para Git y para clonar repositorios. No sustituye las credenciales del conector MCP de GitHub en Allin.

Inicio de sesión en GitHub

```sh
docker compose run --rm worker gh auth login --hostname github.com --git-protocol https --web
docker compose run --rm worker gh auth setup-git --hostname github.com
docker compose run --rm worker gh auth status --hostname github.com
```

GitHub CLI está instalado en la imagen. Inicia sesión con el código mostrado en el terminal; el volumen github-config conserva la sesión.

Si GH_TOKEN o GITHUB_TOKEN está definido en el contenedor o la máquina, gh prioriza ese token. Comprueba que corresponde a la cuenta esperada sin mostrarlo ni compartirlo.

Para usar gh en un job, activa «Ejecutar comandos» en el perfil del agente y crea un nuevo job.

## Cuenta de Claude del worker

Inicio de sesión Claude

```sh
docker compose run --rm worker claude auth login --claudeai
docker compose run --rm worker claude auth status
docker compose run --rm worker allin-worker doctor claude
```

Abre el enlace del terminal, inicia sesión en Claude y pega el código de retorno en el terminal si se solicita. Espera a ver « Login successful ».

El volumen claude-config conserva la conexión y las sesiones. No lo borres al recrear el contenedor.

## Cuenta Codex del worker

Inicia sesión en el motor elegido para tus agentes. Para Codex, activa el inicio de sesión por código de dispositivo en la seguridad de ChatGPT y abre el enlace del terminal.

Inicio de sesión en Codex

```sh
docker compose run --rm worker codex login --device-auth
docker compose run --rm worker codex login status
docker compose run --rm worker allin-worker doctor codex
```

El volumen codex-config conserva la autenticación y las sesiones de Codex. Es privado y nunca forma parte de la imagen publicada.

[Documentación oficial](https://developers.openai.com/codex/auth/#login-on-headless-devices)

## GitHub para herramientas MCP y revisiones

Los jobs usan la conexión de GitHub autorizada en Allin. Actualiza sus credenciales en Conexiones y comprueba las herramientas activadas y autorizadas en el perfil del agente.

[Abrir conexiones de Allin](https://tryallin.com/app#connections)

- La cuenta y el token deben tener acceso a los repositorios necesarios. Para un token de permisos detallados, selecciona el propietario y los repositorios correctos.
- Contents: Read para leer código. Pull requests: Read para leer PR y sus archivos, Read and write para crear o publicar una revisión, incluso PENDING.
- Si la organización lo exige, solicita la aprobación del token o la aplicación y autoriza su acceso SSO.

Leer código no demuestra que el token pueda leer PR o crear revisiones. Corrige los permisos de la conexión utilizada y vuelve a leer la PR. Una lectura correcta no verifica el acceso de escritura.

[Permisos de GitHub para revisiones](https://docs.github.com/en/rest/pulls/reviews#create-a-review-for-a-pull-request)

El perfil del agente también permite elegir el modelo, el esfuerzo de razonamiento, el acceso a archivos y los subagentes.

## Comprobar conexión

El comando doctor verifica el motor y la conexión; doctor codex también ejecuta comandos reales en los sandboxes read-only y workspace-write. No llama a ningún modelo ni a la API Allin. La etiqueta Conectado confirma el heartbeat del worker.

Conectado no significa que todos los motores estén disponibles. En preview.4, si falla la comprobación inicial de Codex, ese motor se excluye: Claude puede funcionar mientras los jobs Codex siguen en cola. Revisa los logs y reinicia el worker tras corregirlo, cuando hayan terminado los jobs en curso.

Completa las conexiones antes de iniciar. Si el worker ya tiene jobs en curso, espera a que terminen antes de reiniciarlo.

Iniciar y seguir registros

```sh
docker compose up -d
docker compose logs --tail=50 -f worker
```

Al iniciarse, el worker puede ejecutar los jobs pendientes con las cuentas y herramientas autorizadas. El MCP Allin se configura automáticamente.

En Allin → Workers, comprueba el estado Conectado y los agentes asignados. Verifica cada motor con doctor y los logs del worker. Configura los repositorios en su ficha. Después, un job de prueba valida el flujo completo, con tu aprobación para su consumo.

## Codex en Ubuntu: restricción AppArmor del host

En versiones recientes de Ubuntu, apparmor=unconfined en Compose puede no bastar. Si bwrap muestra «loopback: Failed RTM_NEWADDR: Operation not permitted», busca en el host denegaciones del perfil unprivileged_userns para setpcap o net_admin. Que unshare -U funcione no valida todo el sandbox.

Diagnóstico desde el servidor por SSH

```sh
sysctl kernel.apparmor_restrict_unprivileged_userns kernel.apparmor_restrict_unprivileged_unconfined
sudo journalctl -k --since "10 minutes ago" | grep -Ei 'apparmor="DENIED"|userns'
docker exec WORKER_CONTAINER sh -c 'id; cat /proc/self/attr/current'
docker exec WORKER_CONTAINER codex sandbox -- true
docker exec WORKER_CONTAINER find /usr/local/lib/node_modules/@openai/codex -type f -path '*/codex-resources/bwrap'
```

Sustituye WORKER_CONTAINER por el nombre real del contenedor. Con Codex 0.160.0, usa codex sandbox -- true, sin añadir linux. El worker debe ejecutarse como node (uid 1000). Comprueba la ruta del bwrap incluido antes de aplicar el siguiente perfil.

Si los logs confirman esta restricción, un administrador puede instalar este perfil específico en el host Ubuntu, fuera del contenedor. Permite userns para el bwrap incluido con Codex; no desactiva la restricción para todo el host. Esta excepción se validó con la imagen preview.4 en Ubuntu; vuelve a comprobar la ruta y el diagnóstico después de actualizar.

Perfil del host /etc/apparmor.d/codex-bwrap

```text
abi <abi/4.0>,
include <tunables/global>
profile codex-bwrap /usr/local/lib/node_modules/@openai/codex/**/codex-resources/bwrap flags=(unconfined) {
  userns,
  include if exists <local/codex-bwrap>
}
```

Cargar el perfil y comprobar Codex

```sh
sudo apparmor_parser -r /etc/apparmor.d/codex-bwrap
docker exec WORKER_CONTAINER codex sandbox -- true
docker exec WORKER_CONTAINER allin-worker doctor codex
```

Tras superar el diagnóstico e iniciar sesión en Codex, reinicia el worker cuando hayan terminado sus jobs: los motores disponibles se detectan al arrancar. Conserva seccomp, cap_drop: ALL, no-new-privileges y el sandbox Codex. Documenta la excepción AppArmor; no desactives globalmente la restricción userns del host.

[Documentación oficial del sandbox Codex](https://learn.chatgpt.com/docs/sandboxing)

## Archivos de los jobs y almacenamiento persistente

Coloca repositorios, documentos y datos compartidos entre jobs en /workspace, respaldado por un volumen del Compose oficial. Usa /tmp para archivos temporales. El acceso a rutas bajo /home/node depende del sandbox y los permisos: no lo uses para los documentos de trabajo de los agentes.

La persistencia y el acceso al sandbox son independientes. Un volumen conserva los archivos al recrear el contenedor, pero no concede permisos adicionales a Codex. Los archivos fuera de los volúmenes se pierden al redesplegar. /home/node/.cache no es persistente en el Compose oficial.

Volumen de caché opcional: combinar con el Compose existente

```yaml
services:
  worker:
    volumes:
      - worker-cache:/home/node/.cache
volumes:
  worker-cache:
```

Añade este montaje y la declaración del volumen sin sustituir los volúmenes existentes. Respalda el caché que necesites antes de recrear el contenedor: un volumen nuevo no recupera los datos del contenedor anterior. Mantén privados los cachés y las credenciales, nunca dentro de una imagen publicada.

## Actualizaciones y solución de problemas

Conserva los volúmenes y el mismo worker al actualizar: contienen las sesiones y los repositorios. No uses docker compose down -v, docker volume prune ni docker commit con un contenedor autenticado.

Tras rotar una clave, sustituye ALLIN_WORKER_API_KEY en las variables privadas de Coolify y vuelve a desplegar, o actualiza .env y recrea el contenedor Compose. Un simple reinicio no recarga las variables de entorno.

Aplicar nueva clave

```sh
docker compose up -d --force-recreate
```

- Worker en espera: completa la conexión a Claude Code o Codex en el contenedor correcto y sus volúmenes.
- Worker desconectado o error 401: verifica ALLIN_URL, la clave activa del worker y el acceso de red desde el servidor sin mostrar secretos.
- Error GitHub 403: comprueba la cuenta, los repositorios autorizados, los permisos de PR y la aprobación SSO. gh y el MCP GitHub usan conexiones distintas.
- Error de sandbox Codex: usa el Compose oficial, su perfil seccomp y apparmor=unconfined en un host dedicado. Recrea el contenedor cuando terminen los jobs, conservando los volúmenes, y ejecuta allin-worker doctor codex por SSH. No desactives el sandbox Codex.
