# Imágenes Qué arranca una máquina: una imagen de Arrakis con SSH y las herramientas habituales, o una imagen propia, pública o privada. ## Imágenes de Arrakis Una máquina arranca una imagen de Arrakis salvo que elijas otra. Cada una es una imagen base oficial a la que se añaden SSH, un banner de inicio de sesión y herramientas de uso diario: git, git-lfs, tmux, htop, nvtop, rsync, curl, wget, jq y un editor. Python está en el PATH en todas las sesiones SSH. | Imagen | Qué contiene | Imagen de Docker | |---|---|---| | PyTorch 2.14 (predeterminada) | PyTorch 2.14.1, CUDA 13.0, Python 3.12, Ubuntu 24.04 | `goodailabs/arrakis:pytorch-2.14.1-cuda13.0` | | PyTorch 2.14 con el kit de herramientas CUDA | Lo mismo, más nvcc, las cabeceras de CUDA y un compilador | `goodailabs/arrakis:pytorch-2.14.1-cuda13.0-devel` | | Kit de herramientas CUDA 13.0 | CUDA 13.0.3, cuDNN 9, nvcc, Python 3.12, Ubuntu 24.04 | `goodailabs/arrakis:cuda-13.0.3-devel` | | Ubuntu 26.04 | Python 3.14. El controlador de la GPU viene de la máquina | `goodailabs/arrakis:ubuntu-26.04` | CUDA 13.0 es la versión que trae `pip install torch`, así que los paquetes wheel compilados para PyTorch son compatibles. Funciona en todas las máquinas de Arrakis, incluidas las Blackwell: todas tienen un controlador de NVIDIA de la serie 580 o posterior. Las imágenes son públicas en Docker Hub, así que puedes descargar la misma en tu propio equipo; `goodailabs/arrakis:latest` es la predeterminada. Al iniciar sesión se muestran las GPU de la máquina, la imagen y el espacio libre en disco: ```text 6 × NVIDIA RTX A4000, 16 GB each PyTorch 2.14.1, CUDA 13.0, Python 3.12.3, Ubuntu 24.04.5 LTS 32 CPU cores, 125 GB memory, 412 GB free in /workspace ``` Trabaja en `/workspace`. Todo lo que hay en una máquina, `/workspace` incluido, se borra cuando se detiene. ## Tus propias imágenes Funciona cualquier imagen: vLLM, SGLang, contenedores de NVIDIA NGC o la imagen propia de tu equipo, pública o privada. - En **Images**, elige **Add an image** y pégala tal como la recibe `docker pull`, por ejemplo `vllm/vllm-openai:v0.11.0`. Para una imagen pública, también puedes elegir **Your own image** al alquilar. - Arrakis consulta primero el registro de la imagen: la imagen debe existir, poder descargarse y tener una compilación para linux/amd64. Una errata o un token incorrecto se rechazan antes de cobrar nada. - Registros: Docker Hub, GitHub (`ghcr.io`), Amazon ECR y ECR Public, Google (Artifact Registry y `gcr.io`), Azure (`azurecr.io`), NVIDIA NGC (`nvcr.io`), Quay, GitLab y Microsoft (`mcr.microsoft.com`), o el tuyo propio: Harbor, Artifactory, Nexus, un GitLab o Quay autoalojado, o cualquier registro con su nombre DNS público, como `registry.example.com:5000/team/app:v1`. - SSH se añade a cualquier imagen al arrancar, así que siempre inicias sesión como root de la misma forma. La imagen necesita un shell. - El primer arranque en una máquina descarga la imagen. Las imágenes grandes tardan más: una imagen de 12 GB puede tardar de 10 a 20 minutos en una red lenta. ### Imágenes privadas Marca **It's private: log in to pull it** al añadir la imagen e indica las credenciales que usarías con `docker login`. Arrakis comprueba la imagen con ellas antes de guardarla, las mantiene cifradas y solo las usa para descargar esta imagen cuando alquilas. La contraseña no se vuelve a mostrar. | Registro | Nombre de usuario | Contraseña o token | |---|---|---| | Docker Hub | Tu nombre de usuario de Docker Hub | Un token de acceso personal de solo lectura | | GitHub (`ghcr.io`) | Tu nombre de usuario de GitHub | Un token clásico solo con `read:packages` | | Amazon ECR (`.dkr.ecr..amazonaws.com`) | Un ID de clave de acceso | Su clave de acceso secreta | | Google (`-docker.pkg.dev`, `gcr.io`) | `_json_key` | La clave JSON de una cuenta de servicio con el rol Artifact Registry Reader | | Azure (`.azurecr.io`) | Un token de repositorio o una entidad de servicio | Su contraseña, con permiso solo de descarga | | NVIDIA NGC (`nvcr.io`) | `$oauthtoken` | Tu clave de API de NGC | | GitLab (`registry.gitlab.com`) | El nombre de usuario de un token de despliegue | El token de despliegue, con `read_registry` | | Quay | Una cuenta de robot | Su token | | Tu propio registro | El nombre de usuario que pida | Su contraseña o token | - **Amazon ECR**: usa un usuario de AWS que solo pueda descargar imágenes (la política `AmazonEC2ContainerRegistryReadOnly`). Cada vez que alquilas, Arrakis cambia la clave por unas credenciales de descarga nuevas válidas durante 12 horas, las que imprime `aws ecr get-login-password`, así que la máquina nunca ve la clave. - **Tu propio registro**: las máquinas descargan directamente de él, estén donde estén, así que debe responder en internet público por HTTPS con un certificado de una autoridad pública (como Let's Encrypt). Un registro detrás de una VPN o de una lista de IP permitidas no es accesible, y uno con un certificado autofirmado se rechaza. - Usa un token que solo pueda leer. La máquina descarga la imagen con él, y la imagen puede quedarse en caché en esa máquina después de que termine tu alquiler, así que no metas secretos en la imagen: pásalos cuando se ejecute. - Para cambiar un token, elige **Change login** junto a la imagen o vuelve a guardar la misma imagen con el nuevo. Al eliminar la imagen se borran sus credenciales de todos los sitios donde Arrakis las guardaba. ### Al arrancar | Opción | Qué se ejecuta | Úsala para | |---|---|---| | Wait for me to log in (predeterminada) | Nada. La máquina te espera | Entrenamiento, notebooks, cualquier cosa que inicies por SSH | | Run the image's command | El punto de entrada y el comando propios de la imagen | Servidores como vLLM, TGI o SGLang | | Run a command | Una sola línea que tú indicas, como `python -m http.server 8000` | Un trabajo que arranca solo | Si el comando termina, ya no se puede acceder a la máquina. En caso de duda, elige **Wait for me to log in**. Accede a un servidor de la máquina a través de SSH: ```sh ssh -L 8000:localhost:8000 root@ -p curl localhost:8000/v1/models ``` ### Variables de entorno Añade pares `KEY=value` a una imagen, uno por línea. Se guardan con la imagen, así que no pongas secretos en ellos: defínelos por SSH, por ejemplo con `export HF_TOKEN=...` en tu sesión. ## Desde la CLI, la API y los agentes ```sh arrakis images list arrakis images add vllm/vllm-openai:v0.11.0 --start image arrakis instances create --node-id --image vllm/vllm-openai:v0.11.0 --start image --termination-hours 2 ``` Una imagen privada lleva sus credenciales, con el token por stdin, como lo recibe `docker login`: ```sh echo "$GITHUB_TOKEN" | arrakis images add ghcr.io/acme/trainer:v3 --username acme-bot --password-stdin arrakis instances create --node-id --template-id --termination-hours 2 ``` ```sh curl -X POST $ARRAKIS_URL/v1/instances -H "Authorization: Bearer $ARRAKIS_TOKEN" -H "Content-Type: application/json" \ -d '{"node_id": "", "name": "vllm", "termination_hours": 2, "ssh_public_key": "ssh-ed25519 AAAA...", "image": "vllm/vllm-openai:v0.11.0", "start": "image"}' ``` - `GET /v1/templates` lista las imágenes de Arrakis y las tuyas; `POST /v1/templates` guarda una (`image`, `start`, `command`, `environment` y, para una imagen privada, `registry_username` y `registry_password`). La contraseña es de solo escritura: las respuestas muestran `private` y `registry_username`. `PATCH /v1/templates/{id}` con ambos reemplaza las credenciales. - `POST /v1/instances` arranca `template_id` o cualquier `image` pública con un `start`. - Por MCP, `list_images` las lista, con las privadas marcadas, y `rent_gpu` acepta `template_id` o `image`. Más: [toda la documentación](/es/docs.md) · [OpenAPI](/openapi.json) · [llms.txt](/es/llms.txt)