Stack de IA self-hosted: Gitea, runners y Ollama en un VPS

Por qué montar este stack en un VPS

Beneficios concretos de esta arquitectura

• Confidencialidad total del código: los runners se ejecutan en tu VPS, el código clonado nunca sale de tu red interna de Docker.
• Cero tokens enviados al exterior: Ollama sirve la inferencia localmente; ninguna petición llega a openai.com ni a anthropic.com.
• Coste fijo y predecible: sin facturación por ejecución de workflow, sin facturación por token — una sola línea de presupuesto mensual, independientemente de la carga.
• Workflows de GitHub Actions reutilizables: Gitea Actions es compatible con la sintaxis .github/workflows/; tus pipelines migran sin reescritura.
• Modelos intercambiables libremente: Qwen2.5-Coder, DeepSeek-Coder, Llama 3.1 o Mistral — un comando ollama pull para cambiar de modelo sin tocar el pipeline.
• Auditoría y trazabilidad completas: logs de runners, historial de modelos cargados y registros de nginx permanecen en tu infraestructura y te pertenecen.

Requisitos previos de hardware y software

Modelos recomendados según la RAM disponible

• Qwen2.5-Coder:7B (formato Q4_K_M, ~5 GB de RAM) — relación calidad/recursos equilibrada para revisiones de código en 2026; comprende el contexto extendido y las convenciones de estilo.
• DeepSeek-Coder:6.7B (formato Q4, ~4,5 GB de RAM) — alternativa compacta cuando la RAM es escasa; preciso en Python, JavaScript y diffs de menos de 200 líneas.
• Llama 3.1:8B (formato Q4_K_M, ~5,5 GB de RAM) — generalista multilingüe, útil cuando los proyectos mezclan código y documentación en varios idiomas.
• Mistral:7B (formato Q4_K_M, ~4,5 GB de RAM) — respuestas cortas y directas, ideal para un resumen del diff más que para un análisis detallado.
• Pasar a un modelo 13B — en un VPS con 16 GB o más, codellama:13b o qwen2.5-coder:14b mejoran las revisiones en diffs grandes; el tiempo de inferencia CPU pasa de ~5 s a ~15 s por llamada.

Desplegar el stack Gitea + Ollama + runner

1. 01

   Crear la estructura de archivos

   Crea un directorio de proyecto y un archivo docker-compose.yml que declare tres servicios: gitea, ollama y runner. Coloca todos los volúmenes en un subdirectorio data/ para simplificar las copias de seguridad.

   mkdir -p ~/gitea-stack/data/{gitea,ollama,runner}
   cd ~/gitea-stack

2. 02

   Escribir el docker-compose.yml

   El archivo declara una red interna ai-net por la que se comunican los tres servicios. Ollama no se expone en el host: solo el runner puede acceder a él a través de la red Docker.

   cat > docker-compose.yml << 'EOF'
   version: "3.8"
   
   networks:
     ai-net:
       driver: bridge
   
   volumes:
     gitea-data:
     ollama-data:
     runner-data:
   
   services:
     gitea:
       image: gitea/gitea:latest
       restart: unless-stopped
       networks: [ai-net]
       ports:
         - "3000:3000"
         - "2222:22"
       volumes:
         - gitea-data:/data
       environment:
         - GITEA__server__DOMAIN=git.yourdomain.com
         - GITEA__server__ROOT_URL=https://git.yourdomain.com
         - GITEA__actions__ENABLED=true
   
     ollama:
       image: ollama/ollama:latest
       restart: unless-stopped
       networks: [ai-net]
       volumes:
         - ollama-data:/root/.ollama
   
     runner:
       image: gitea/act_runner:latest
       restart: unless-stopped
       networks: [ai-net]
       volumes:
         - runner-data:/data
         - /var/run/docker.sock:/var/run/docker.sock
       environment:
         - GITEA_INSTANCE_URL=http://gitea:3000
         - GITEA_RUNNER_REGISTRATION_TOKEN=${RUNNER_TOKEN}
         - GITEA_RUNNER_NAME=local-runner
         - OLLAMA_URL=http://ollama:11434
   EOF

3. 03

   Arrancar Gitea y obtener el token del runner

   Arranca solo Gitea primero para completar la instalación inicial y generar el token de registro del runner.

   docker compose up -d gitea

   Abre http://<ip-del-vps>:3000 en tu navegador, completa el asistente de instalación, luego ve a Administración del sitio → Acciones → Runners para crear un token de registro. Anota este token — lo necesitarás en el siguiente paso.

4. 04

   Arrancar Ollama y descargar un modelo

   Arranca Ollama y descarga tu modelo. Para un pipeline de revisión de código, qwen2.5-coder:7b o deepseek-coder:6.7b ofrecen una buena relación calidad/recursos.

   docker compose up -d ollama
   # descargar un modelo de código
   docker exec gitea-stack-ollama-1 ollama pull qwen2.5-coder:7b
   # verificar que la API responde en la red interna
   docker run --rm --network gitea-stack_ai-net curlimages/curl \
     http://ollama:11434/api/tags

   La respuesta JSON lista los modelos disponibles — confirmación de que la API de Ollama es accesible desde la red interna de Docker.

5. 05

   Registrar el runner y arrancar el stack completo

   Crea un archivo .env con el token obtenido en el paso 3, luego arranca el runner.

   echo "RUNNER_TOKEN=tu_token_aqui" > .env
   docker compose up -d runner
   # verificar que el runner se registró correctamente
   docker compose logs runner | tail -20

   Verifica en Administración del sitio → Acciones → Runners que tu runner aparece con estado Activo.

6. 06

   Crear un workflow que llame a Ollama

   En un repositorio de Gitea, crea .gitea/workflows/review.yml. El workflow clona el código, llama al endpoint /api/chat de Ollama mediante curl y publica el resultado como comentario en la pull request.

   cat > .gitea/workflows/review.yml << 'EOF'
   name: AI Code Review
   on:
     pull_request:
       types: [opened, synchronize]
   
   jobs:
     review:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v4
         - name: Revisión de código con Ollama
           run: |
             DIFF=$(git diff HEAD~1 --unified=5 | head -200)
             curl -s ${OLLAMA_URL:-http://ollama:11434}/api/chat \
               -H 'Content-Type: application/json' \
               -d "{\"model\": \"qwen2.5-coder:7b\", \"stream\": false,
                    \"messages\": [{\"role\": \"user\",
                    \"content\": \"Revisa este diff de Git: $DIFF\"}]}" \
               | jq -r '.message.content'
   EOF

   Sube este archivo a tu forge Gitea — el runner lo detecta y ejecuta el job en la red interna, sin ningún acceso a Internet.

7. 07

   Poner Gitea detrás de un proxy inverso HTTPS

   Coloca Gitea detrás de nginx o Caddy con un certificado Let's Encrypt para exponer la forge en git.yourdomain.com. El puerto 3000 no debe ser accesible directamente desde el exterior.

   # ejemplo nginx mínimo
   cat > /etc/nginx/sites-available/gitea.conf << 'EOF'
   server {
       listen 443 ssl;
       server_name git.yourdomain.com;
       ssl_certificate /etc/letsencrypt/live/git.yourdomain.com/fullchain.pem;
       ssl_certificate_key /etc/letsencrypt/live/git.yourdomain.com/privkey.pem;
   
       location / {
           proxy_pass http://127.0.0.1:3000;
           proxy_set_header Host $host;
           proxy_set_header X-Real-IP $remote_addr;
       }
   }
   EOF
   nginx -t && systemctl reload nginx

   Ollama permanece exclusivamente en la red interna de Docker y nunca se expone en Internet.

Comparativa de coste: VPS self-hosted vs API cloud

Ir más lejos: observar y enriquecer el pipeline