
Si sigues lo que hago, sabes que casi todo lo que publico vive en GitHub, y no por moda, sino porque durante años ha sido la mejor puerta para que un proyecto open source llegue a alguien. Hace unos días hice push a dos repositorios privados que llevo en paralelo, me fui a atender otras cosas y cuando volví me los encontré parados. Ni un error en el código, ni un YAML roto, ni una acción caída. Simplemente, quietos. El motivo no estaba en el repositorio, estaba en el monedero, porque a GitHub se le había acabado el cupo de cómputo de mi cuenta y, sin tarjeta detrás, el grifo se cierra de golpe. Hoy te cuento por qué pasa eso, qué compra realmente ese cupo y cómo me llevé el forge y la CI a mi casa con Gitea, act_runner y un modelo de lenguaje haciendo de copiloto. Y al final, la reflexión sobre Microsoft que llevo tiempo queriendo soltar.
El día que el workflow se quedó quieto
Pongámonos en situación, porque el episodio empieza con una imagen muy tonta y muy elocuente. Tenía dos proyectos privados con su integración continua montada, hice push, y en la pestaña de acciones apareció ese circulito amarillo que dice que el trabajo está en cola. Un minuto. Cinco. Diez. Ningún log. Ninguna pista. El workflow no había fallado, es que ni siquiera había empezado.
Y ahí uno hace lo que hacemos todos, revisar el YAML, mirar si el evento estaba bien puesto, comprobar si la rama era la correcta. Perdí un rato en eso antes de preguntarle al modelo que tengo gestionando el trabajo, que fue el que me dio la respuesta en una frase. Se te ha acabado el crédito. 😅
No era una metáfora. Era la forma más literal de contarlo. Yo había estado usando GitHub como si fuera gratis, y lo es, pero solo bajo ciertas condiciones. En el momento en que tus repositorios son privados, la fiesta la pagas tú.
Antes de seguir, un aviso. Los dos proyectos del detonante siguen siendo privados y no voy a decir sus nombres, porque la decisión de publicarlos no es mía. Los llamaremos el proyecto A y el proyecto B, y con eso basta para entender la historia.
GitHub no ejecuta nada: delega
Para explicar lo que me pasó hay que empezar por el principio, porque mucha gente cree que GitHub compila su código y no es así. GitHub no ejecuta nada. GitHub pone la mesa.
Tú describes el trabajo en un fichero YAML dentro de .github/workflows/, con un evento que lo dispara (un push, un pull request, un cron) y una serie de trabajos compuestos por pasos. Algo tan sencillo como esto,
name: CI
on:
push:
branches: [main, development]
pull_request:
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
- run: cargo test --all-features
- run: cargo build --release
Ese fichero no compila nada por sí mismo. Lo que hace es pedirle a GitHub que busque una máquina, la prepare, descargue tu código y ejecute esos comandos. La máquina es el runner, y ahí está toda la clave del episodio. GitHub gestiona la mesa de despacho, te dice qué trabajo toca, recoge los logs y los resultados. El músculo lo pone otro.
Hay dos familias de runners. Los alojados por GitHub, que son máquinas efímeras que la plataforma alquila y que tú pides con etiquetas como ubuntu-latest o macos-latest. Y los self-hosted, que son máquinas tuyas, registradas en GitHub, donde tú pones el hierro y GitHub solo manda las instrucciones.
La generosidad histórica con el open source se entiende mejor con esta separación. En repositorios públicos, los runners estándar de GitHub son gratis. En repositorios privados, ese mismo runner consume cupo. No es un castigo, es un modelo de negocio, y es perfectamente legítimo. El problema es que nadie te avisa cuando estás a punto de chocar con la pared.
De minutos a dólares
Durante mucho tiempo pensé en minutos. Tenía en la cabeza esa idea de que el plan gratuito te daba dos mil minutos al mes y que, si te pasabas, pagabas. Y no iba mal encaminado, pero el modelo ya no se cuenta así.
La documentación de facturación de GitHub lo dice con todas las letras. El uso de cómputo incluido se expresa como una cantidad monetaria, no como un número fijo de minutos. O sea, que ya no te dan un cubo de minutos, te dan un monedero en dólares y tú lo vacías como quieras.
Y el monedero depende del plan. Estas son las cifras que recoge la documentación oficial,
| Plan | Artefactos | Cómputo incluido al mes |
|---|---|---|
| GitHub Free | 500 MB | 12 USD |
| GitHub Pro | 1 GB | 18 USD |
| GitHub Free para organizaciones | 500 MB | 12 USD |
| GitHub Team | 2 GB | 18 USD |
| GitHub Enterprise Cloud | 50 GB | 300 USD |
Con el runner de Linux de dos núcleos a 0,006 dólares el minuto, esos 12 dólares del plan gratuito son unos dos mil minutos, o sea, unas 33 horas. Para un proyecto pequeño es más que suficiente. Para dos proyectos privados con CI intensiva, desarrollo guiado por especificaciones, análisis de dependencias y pruebas en cada push, se queda corto antes de que te des cuenta.
Y aquí viene el detalle que a mí me sorprendió. Cuando se agotó el cupo, no se había agotado por un pico raro de un día. Se había agotado porque el uso era sostenido. Y como no tenía tarjeta asociada, GitHub hizo exactamente lo que dice su documentación. Bloqueó el uso hasta el siguiente ciclo.
Qué compra el monedero, y qué no
La segunda sorpresa es que no todos los minutos cuestan lo mismo. La tarifa base depende del sistema operativo y de la máquina, y las diferencias no son cosméticas,
| Sistema operativo | SKU | Dólares por minuto |
|---|---|---|
| Linux 1 núcleo (x64) | actions_linux_slim | 0,002 |
| Linux 2 núcleos (x64) | actions_linux | 0,006 |
| Linux 2 núcleos (arm64) | actions_linux_arm | 0,005 |
| Windows 2 núcleos (x64) | actions_windows | 0,010 |
| macOS 3/4 núcleos | actions_macos | 0,062 |
Mismo monedero, mundos distintos. Con 12 dólares compras unas 33 horas de Linux, pero solo unas tres horas de macOS, porque macOS cuesta más o menos diez veces lo que Linux. Una hora de macOS se te va por encima de los tres dólares y medio. Si tu proyecto compila para las tres plataformas en cada push, el monedero se vacía solo.
Y luego están los límites que no se arreglan pagando. Porque hay techos de diseño, no de factura. Un trabajo alojado por GitHub no puede pasar de seis horas. Una matriz no puede lanzar más de 256 trabajos por ejecución. Un workflow se puede reejecutar 50 veces, y eso sí se puede ampliar con un ticket, pero lo demás no. En el plan gratuito puedes tener 20 trabajos concurrentes, y cinco de macOS. Y me da igual lo que pagues, esos números no se negocian con la tarjeta.
Para mí, ese bloque fue el momento de decir basta. No porque GitHub me estuviera robando, sino porque estaba construyendo dos proyectos privados sobre una base que no controlaba y cuyo precio podía cambiar sin que yo moviera un dedo.
La señal de diciembre
Si esto fuera solo una historia de cupos, el episodio sería corto. Pero hay un detalle que me parece mucho más importante que el agotamiento puntual, y es la dirección en la que apunta la flecha.
En diciembre de 2025, GitHub anunció que a partir del 1 de marzo de 2026 cobraría 0,002 dólares por minuto por usar tus propios runners self-hosted en repositorios privados. Es decir, tú pones la máquina, tú pagas la luz, tú mantienes el hierro, y aun así pagas un alquiler por usar el mostrador de GitHub. El argumento oficial era el coste de mantener el plano de control, la parte que decide qué trabajo toca y recoge los resultados.
Aquello levantó bastante revuelo, y GitHub terminó aplazando el cambio para reevaluarlo. La bajada de precios de los runners alojados, hasta un 39 % en algunos tipos de máquina, sí se mantuvo. Pero la señal ya estaba lanzada. El que pone el músculo, si además usa el mostrador de otro, acaba pagando alquiler.
Yo no sé qué pasará dentro de un año. Lo que sé es que no quiero que la CI de mis proyectos dependa de una decisión de precios que se toma en una oficina a la que no tengo acceso.
Mis dos proyectos privados
Volvamos al principio, porque hay una parte que quiero contar bien. Los proyectos A y B no son experimentos. Son dos desarrollos que llevo en paralelo para otra persona, y hasta que esa persona decida que se publican, tienen que quedarse en privado.
La CI de esos proyectos no es un cargo build y ya está. Últimamente he metido en el flujo desarrollo guiado por especificaciones, gestión de incidencias, pruebas en cada cambio, análisis de dependencias para ver si hay vulnerabilidades y empaquetado. Todo eso, multiplicado por dos repositorios y por la cantidad de veces que guardas un cambio, consume. Y consume de una forma que no ves hasta que miras la factura o, en mi caso, hasta que el trabajo se queda en cola.
Podría haber metido la tarjeta y seguir. De hecho, ese es el camino que la mayoría de la gente tomará, y me parece razonable. Pero yo ya tenía la mosca detrás de la oreja con el tema del control, y tenía una alternativa que llevaba tiempo queriendo probar en serio.
El giro: la CI es un runner
Aquí está la idea que quiero que te lleves, porque cambia por completo la forma de ver el problema. La CI no vive en GitHub. La CI es un runner.
GitHub te da el plano de control, pero el trabajo lo ejecuta una máquina. Y esa máquina no tiene por qué estar en un centro de datos de Microsoft. Puede estar en tu casa. De hecho, GitHub te permite registrar un runner self-hosted y mandarle los trabajos desde su interfaz. Con eso, el cupo de cómputo deja de ser tu problema, porque el músculo es tuyo.
Lo probé mentalmente y no me convenció. Porque te quedas a medias. Una parte del flujo vive en GitHub y otra en tu máquina, y esa mezcla tiene todas las desventajas y ninguna de las ventajas. Si ya tengo el hierro, el runner y los secretos en casa, ¿qué sentido tiene seguir alquilando el mostrador?
Así que decidí montármelo entero. Y para eso necesitaba un forge, un alojamiento de Git con interfaz, incidencias, pull requests, wiki y paquetes. El candidato natural era Gitea, un proyecto escrito en Go, con un binario único, que se despliega en un contenedor y que trae Actions integradas desde la versión 1.19.
Sé que hay un fork, Forgejo, que nació en 2022 y que tiene su propia gobernanza. No he diseccionado todavía qué implica cada uno ni he hecho la migración a Forgejo. Por ahora sigo en Gitea, porque me funciona y porque no quiero cambiar dos cosas a la vez. Cuando lo estudie con detenimiento, ya te lo contaré.
Lo importante es que Gitea ejecuta workflows compatibles con los de GitHub. Y eso es posible porque su runner es un hard fork de nektos/act, el proyecto que permite ejecutar acciones de GitHub en local. Es decir, que el mismo YAML que tenías en .github/workflows/ puede correr en tu casa con muy pocos cambios.
Mi stack real
Para que no te quedes en la teoría, te cuento lo que tengo funcionando ahora mismo. Un Gitea sobre PostgreSQL 18, con el stack gestionado en un compose.yaml a través de Dockge, delante de Traefik 3 para el HTTPS y con una entrada TCP aparte para el Git por SSH. Al lado, un contenedor de copias de seguridad de Postgres con retención de una semana, cuatro semanas y seis meses.
Y el runner, que es la pieza que faltaba. La imagen es la última release de act_runner, construida encima de la oficial para añadirle el toolchain que necesitan mis repositorios, o sea, el cliente de Docker, Git, Node, Rust con Cargo y git-cliff para generar los changelogs.
El runner no es una máquina abstracta. Es un contenedor que habla con Gitea, recibe un trabajo y lo ejecuta. Y aquí es donde aparecen las dos decisiones que más quebraderos de cabeza dan a quien monta esto por primera vez, los labels y el socket.
Los labels deciden dónde corre cada job
En Gitea, igual que en GitHub, tú pides una máquina con runs-on. Lo que pasa es que en Gitea esa etiqueta no apunta a una máquina de la plataforma, apunta a una etiqueta que tú has declarado en la configuración del runner. Y esa etiqueta decide dónde corre el trabajo,
| Label | Dónde corre |
|---|---|
docker://<imagen> | En un contenedor |
kubernetes://<imagen> | En un pod de Kubernetes |
host | Directamente en la máquina, sin aislamiento |
En mi caso tengo dos etiquetas declaradas. Una es ubuntu-latest, que mapea a un contenedor con la imagen de runner de Gitea. La otra es co1, que corre en el host, sin aislamiento, para las tareas de despliegue que necesitan tocar la máquina de verdad.
Y aviso, porque la documentación de Gitea lo dice con claridad. Los trabajos que corren en host lo hacen como el usuario del runner y sin ningún aislamiento. Úsalos solo con repositorios de confianza. Un host es un cuchillo abierto sobre la mesa, útil, pero no lo dejas al lado de un desconocido.
El socket, ese detalle que tumba el montaje
Si hay un punto donde casi todo el mundo se atasca al montar un runner, es el socket. Y no porque sea difícil, sino porque el error no dice lo que está pasando.
El runner no habla con Docker por arte de magia. Habla con un socket, que es un fichero especial en /var/run/docker.sock. Para que el contenedor del runner pueda crear contenedores efímeros donde ejecutar los trabajos, hay que montarle ese socket dentro,
volumes:
- /var/run/docker.sock:/var/run/docker.sock:rw
Y hay que darle permiso, porque el socket pertenece al grupo docker y no al usuario con el que corre el runner. Eso se resuelve añadiendo el identificador del grupo del host,
group_add:
- "999" # gid del grupo docker en mi máquina
Si te lo saltas, el runner arranca, se conecta a Gitea, acepta el trabajo y se queda mirando la puerta. En los logs no ves un gran error, ves que no puede crear el contenedor del trabajo. Y ahí te puedes pasar una tarde.
Con Podman rootless la cosa se complica, y te lo cuento con honestidad porque no he encontrado documentación oficial de Gitea que lo describa como un problema concreto. El socket de Podman no vive en /var/run/docker.sock, vive en el directorio de ejecución del usuario, algo como $XDG_RUNTIME_DIR/podman/podman.sock, y las rutas de montaje y la compatibilidad con Docker cambian. Es una traba real, pero es mi traba, no una cita oficial.
Mi solución fue la pragmática. Para el runner le doy el socket de Docker. Menos poesía, más CI funcionando. Cuando termine la migración a Podman, ya veremos cómo lo resuelvo.
El compose del runner
Con eso claro, el servicio del runner queda así de sencillo,
runner:
image: local/act_runner:docker
container_name: gitea_runner
restart: unless-stopped
volumes:
- /var/run/docker.sock:/var/run/docker.sock:rw
- ./runner/config.yaml:/config.yaml:ro
- ./data/runner:/data:rw
group_add:
- "999"
environment:
- GITEA_INSTANCE_URL=https://gitea.example.com
- GITEA_RUNNER_REGISTRATION_TOKEN=[REDACTADO]
- GITEA_RUNNER_NAME=co1-runner
- CONFIG_FILE=/config.yaml
depends_on:
gitea:
condition: service_healthy
El fichero config.yaml del runner es donde están las decisiones interesantes. El mío tiene capacidad para dos trabajos simultáneos, un tiempo máximo de tres horas por trabajo y las dos etiquetas que te contaba,
runner:
file: .runner
capacity: 2
timeout: 3h
labels:
- "ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest"
- "co1:host"
Dos detalles que conviene saber. El primero es que el runner lee la configuración solo al arrancar, así que si la cambias tienes que reiniciar el contenedor. El segundo es que el fichero .runner guarda las credenciales del runner y hay que tratarlo como un secreto. Un segundo proceso con el mismo fichero se niega a arrancar, y eso es una protección, no un fallo.
Te dejo el compose completo, la configuración del runner y el workflow de Renovate en un gist, para que puedas copiarlos sin pelearte con el formato,
Traerme los repos: migrar no es espejar
Con Gitea levantado y el runner funcionando, faltaba lo importante, traerme los proyectos. Ahí hay una distinción que casi nadie hace al principio y que a mí me costó un rato entender.
Una cosa es espejar y otra es migrar. El espejo sincroniza el código de forma continua desde GitHub hacia tu Gitea, y para eso hay herramientas como gitea-mirror, que además trae una interfaz web y se despliega con Docker. Es útil si quieres mantener GitHub como origen y Gitea como copia.
La migración es otra cosa. Gitea tiene un importador nativo que se trae el repositorio y, además, las incidencias, los pull requests, la wiki y las releases. Se hace desde la interfaz con New Migration, pegando la URL del repositorio de GitHub y un token, y para eso no necesitas inventar nada.
En mi caso no quería un espejo. Quería mudarme. Ya le había enseñado a la otra persona cómo declarar las incidencias en Gitea, y ella ya estaba reportando ahí, así que lo más cómodo era llevarlo todo, incidencias, pull requests, wikis y releases. Todo.
Y funcionó. La migración nativa se trajo lo que tenía que traerse. Lo que no se trae, y de eso va el siguiente bloque, es todo lo que vive alrededor del código.
Lo que se queda por el camino
Aquí viene la parte que nadie te cuenta en los vídeos de «migra tu repositorio en cinco minutos». La mudanza del código es fácil. La mudanza del ecosistema es donde está el trabajo.
Lo primero que se queda fuera son los workflows. Gitea ejecuta workflows compatibles, pero no los busca en .github/workflows/, sino en .gitea/workflows/. Es un cambio de ruta y, en algunos casos, un cambio de acción, porque no todas las acciones de GitHub funcionan igual. En mis repositorios conviven las dos carpetas, la de GitHub para el espejo y la de Gitea para la CI de verdad.
Lo segundo son los secretos. No viajan. Hay que volver a crearlos en Gitea, uno a uno, con cuidado, porque son la puerta de tu infraestructura. En mi caso son secretos de Actions de Gitea, igual que antes eran de GitHub.
Lo tercero son las reglas de protección de rama, los entornos, los grupos de runners y todo el sistema de permisos fino. Eso no se traslada tal cual y hay que volver a configurarlo con la cabeza.
Lo cuarto es Dependabot, que sencillamente no existe en Gitea. Y lo quinto son los paquetes y el registro de contenedores, que hay que reorganizar. En mi caso el propio Gitea hace de registro, con imágenes bajo su dominio, y eso simplifica mucho las cosas.
Y luego están las cosas que se pierden sin remedio, como las estrellas, los seguidores o las discusiones. No son críticas, pero duelen, porque son parte de la historia del proyecto.
Dependabot se queda; entra Renovate
Del bloque anterior hay una pieza que merece su propio espacio, porque es la que más me preocupaba. Dependabot es la herramienta de GitHub que te avisa cuando una dependencia tiene una vulnerabilidad y te abre un pull request con la actualización. Es cómoda, está integrada y su lógica principal es software libre con licencia MIT. El problema es que vive dentro de GitHub y no se ejecuta en Gitea.
La alternativa se llama Renovate. Es un proyecto de Mend.io, escrito en TypeScript, con licencia AGPL-3.0, y soporta Gitea de forma oficial. No es un primo hermano de Dependabot, es un profesional independiente que además trabaja con otros muchos proveedores.
La configuración mínima pide un token de acceso personal con permisos de repositorio, usuario e incidencias, y tres datos, la plataforma, el endpoint de la API y el token. A partir de ahí, Renovate hace lo mismo que Dependabot y algunas cosas más, como agrupar actualizaciones menores y de parche, o fijar los digests de las acciones.
Hay dos diferencias que a mí me importan. La primera es que Renovate no corre dentro de Gitea, corre como un workflow programado. La segunda es que las alertas de vulnerabilidades son cosa de GitHub, así que en Gitea hay que activar la opción de OSV, que usa la base pública de osv.dev y abre pull requests de seguridad cuando hay solución disponible.
Renovate en la práctica: un cron de sábado
Mi Renovate no es un servicio permanente. Es un workflow de Gitea Actions que se ejecuta los sábados a las dos de la mañana. ¿Por qué a esa hora? Porque no molesta a nadie y el runner está libre. ¿Por qué los sábados? Porque así empiezo la semana con los pull requests ya abiertos y puedo revisarlos con calma.
El workflow se dispara con un cron y también a mano, con un desplegable para elegir el nivel de log. Dentro, el trabajo corre en un contenedor con la imagen oficial de Renovate y ejecuta un script propio que consulta la API de Gitea para construir la lista de repositorios,
name: Renovate
on:
schedule:
- cron: "0 2 * * 6"
workflow_dispatch:
jobs:
renovate:
runs-on: ubuntu-latest
container:
image: ghcr.io/renovatebot/renovate:latest
options: --user root -v /data/renovate-cache:/cache
steps:
- uses: actions/checkout@v4
- shell: bash
run: |
export RENOVATE_REPOSITORIES="$(node scripts/discover-repos.mjs)"
exec renovate
env:
RENOVATE_TOKEN: ${{ secrets.RENOVATE_TOKEN }}
RENOVATE_PLATFORM: gitea
RENOVATE_ENDPOINT: https://gitea.example.com/api/v1
RENOVATE_CONFIG_FILE: config.js
La configuración vive en un config.js con más comentarios que código, y ahí están las decisiones de fondo. La rama base es development, porque trabajo con Git Flow y no quiero pull requests contra main. El descubrimiento automático está apagado a propósito. Las actualizaciones menores y de parche se agrupan. Y el límite es de diez pull requests concurrentes y dos por hora, para no inundar el repositorio.
Las tres trampas de Renovate
Si te digo que esto funcionó a la primera, te miento. Funcionó después de tres trampas que me costaron más de lo que me gustaría reconocer, y que te cuento porque son las mismas que te vas a encontrar tú.
La primera es el autodescubrimiento con usuario bot. Renovate busca repositorios preguntando por los del usuario, y un usuario de tipo bot no posee repositorios, así que la lista sale vacía. En el log no hay un error, hay un «encontrados cero repositorios» y silencio. La solución es apagar el autodescubrimiento y darle tú la lista con un script que consulte la API.
La segunda es baseBranchPatterns. Yo quería que todo fuera contra development, pero hay repositorios que no tienen esa rama. ¿Qué hace Renovate? Un aviso en el log y el repositorio se queda sin actualizaciones. Ni un pull request. La solución es excluir explícitamente esos repositorios.
La tercera es vulnerabilityAlerts, que es una opción exclusiva de GitHub. En Gitea no existe. Se sustituye por osvVulnerabilityAlerts, que descarga la base de OSV en local, unos 85 MB comprimidos, y añade la sección de vulnerabilidades al panel.
Y el patrón que hay detrás de las tres es el mismo, y es el patrón de todo el episodio. Una configuración razonable falla en producción, y se arregla leyendo el log. Proponer, probar, mirar, corregir. Ese bucle es el trabajo real.
Ver que funciona
Hay una frase que repito mucho y que aquí se aplica de lleno. Yo no me fío de la fe. Si no lo veo, no ha pasado.
Por eso no me conformé con que los workflows se pusieran en verde. Monté varias formas de mirar. La primera es el panel de administración de Gitea, donde están los runners registrados, las colas de trabajos y los logs. La segunda es el health check,
curl -fSs https://gitea.example.com/api/healthz
que devuelve un status: pass con la base de datos y la caché en verde. Es el latido del corazón del forge en una línea, y es el mismo endpoint que uso como health check del contenedor.
La tercera es gitea doctor, el comando de diagnóstico que te dice si algo va torcido. La cuarta son las métricas del runner, que si las activas sirven un endpoint de Prometheus con el estado del runner, los trabajos en marcha y el tiempo de cada trabajo.
Y alrededor de todo eso tengo un pequeño ecosistema. Beszel para ver cómo está el hierro, OpenObserve para los logs y las trazas, Grafana Alloy como recolector, y un pequeño puente que lee los webhooks de Gitea y los reenvía, para ver en tiempo real cada vez que un workflow termina. No es imprescindible, pero me deja dormir mejor.
El kanban para mi socio
Y ahora la parte que no es técnica y que me parece la más bonita del episodio. La otra persona con la que llevo estos proyectos no es técnica. No tiene ni idea de cómo funciona un runner, ni falta que le hace.
Lo que sí necesita es ver en qué estado está su trabajo. Así que le abrí un proyecto en Gitea con un tablero kanban, y lo entendió en dos minutos. Sus tareas entran en una columna, pasan a otra, y terminan en la última. No hay que explicarle Git, ni ramas, ni integración continua. Solo tiene que ver cómo se mueven las tarjetas.
Detrás, el modelo de lenguaje se encarga de que cada incidencia caiga en la columna que le toca según sus etiquetas. Y ella ve el progreso sin tener que preguntarme. Eso, para mí, vale más que cualquier métrica.
Porque al final la herramienta no es para el que la monta, es para el que la usa. Y si el que la usa no es técnico, la herramienta tiene que hablar su idioma.
La IA como copiloto, no como oráculo
Llegamos al hilo que atraviesa todo el episodio. Esta migración no la hice tecleando comandos uno detrás de otro. La hice dictándole a un modelo de lenguaje lo que quería.
Y hay que decirlo con precisión, porque el tema se presta a exageraciones. No le pedí a la IA que supiera Gitea. Le pedí que supiera dónde mirar. El modelo se conectó a la máquina, leyó la documentación, escribió el compose, se equivocó, volvió a leer, volvió a desplegar y siguió hasta que funcionó. Yo revisaba, aprobaba y ejecutaba.
Ese ciclo corto de verificación es lo que cambia las cosas. Antes, montar esto por primera vez era leer la documentación, probar, volver a probar, descubrir que la versión había cambiado y empezar de nuevo. Ahora el modelo hace ese trabajo pesado y tú te quedas con la parte que de verdad importa, decidir si lo que ha hecho tiene sentido.
Y cuando terminó, le pedí otra cosa. Que me lo documentara. Que me explicara cómo lo había montado y por qué. Y ahí comparé lo que había hecho yo a mano con lo que había hecho él, y corregí lo que me pareció oportuno.
Esto funciona especialmente bien en tareas de traducción entre tecnologías. Cambiar un workflow de GitHub a Gitea, resumir documentación, adaptar un lenguaje a otro. Donde no me fío es en las preguntas abiertas, en esas en las que el modelo puede inventarse una respuesta con toda la seguridad del mundo. La diferencia entre un copiloto y un oráculo es que el copiloto te dice dónde mirar y el oráculo te dice lo que quieres oír.
Velocidad de tortuga
Y ahora la parte incómoda, porque todo tiene un precio y el mío no es en dólares.
Antes, cuando empaquetaba en GitHub, la plataforma me daba varios runners en paralelo. Ahora todo corre en mi máquina, y mi máquina tiene la CPU y la memoria que tiene. Cuando se llena, los trabajos hacen cola. Termina uno, empieza el siguiente. Y así.
He pasado de una velocidad de vértigo a una velocidad de tortuga. Los empaquetados tardan más, las pruebas tardan más, y hay días en que me acuerdo de la comodidad de GitHub. Podría darle más recursos a la máquina, claro, y probablemente lo haga. Pero una cosa detrás de otra.
Merece la pena. No porque sea más rápido, que no lo es, sino porque es mío. Y porque el día que cambien las condiciones, el cambio no me pilla por sorpresa.
Microsoft, el demonio y el mecenas
Y ya que estamos, voy a soltar la reflexión que llevo tiempo queriendo hacer. Porque hay una crítica exacerbada hacia Microsoft que me llama mucho la atención.
Sí, Microsoft es una empresa. Sí, ha cometido errores. Sí, ha comprado proyectos y ha cambiado licencias y ha hecho cosas que no me han gustado. Pero también ha puesto dinero, infraestructura y gente al servicio del open source de una forma que muy pocos están dispuestos a reconocer. GitHub Actions gratis en repositorios públicos es infraestructura regalada al ecosistema. Y eso no lo hace un demonio, lo hace un mecenas con intereses, que es distinto.
Lo que me sorprende no es que haya críticas, es que no haya compensación. Hay gente que critica muchísimo y luego no aporta nada. Ni un issue, ni una traducción, ni un euro. Y eso me deja con la duda de siempre. Si tanto te importa el open source, ¿qué estás haciendo tú?
Con esto no quiero decir que haya que dar las gracias por todo. Quiero decir que la conversación merece más matices de los que caben en un tuit. Microsoft ha hecho mucho por el open source y también ha tomado decisiones que nos afectan. Las dos cosas son verdad al mismo tiempo, y una no borra la otra.
Para terminar
Esta no es una historia de buenos y malos. Es la historia de un tipo que se encontró con un workflow parado, tiró del hilo y acabó montando su propio forge en casa.
Si algo me llevo de todo esto es que la CI no es una plataforma, es un runner. Y que si controlas el runner, controlas la CI. Gitea, act_runner, Renovate y un modelo de lenguaje de copiloto me han dado eso, con sus trampas, su velocidad de tortuga y sus fines de semana de por medio.
No te digo que hagas lo mismo. Te digo que sepas dónde está el grifo, porque el día que lo cierren, vas a querer tener una llave.
Y si te animas a montarlo, ya sabes dónde encontrarme. Yo seguiré por aquí, con Linux y, en este caso, con Gitea.
Más información
- GitHub Docs — About billing for GitHub Actions — Cómputo incluido en dólares, tarifas por minuto y qué consume cupo
- GitHub Docs — Actions limits — Límites de ejecución, matriz, reejecuciones y concurrencia
- GitHub Changelog — Update to GitHub Actions pricing — El anuncio del cargo a los runners self-hosted y su aplazamiento
- Gitea Docs — Actions overview — Workflows compatibles y el fork de nektos/act
- Gitea Docs — Runner — Instalación, etiquetas, configuración y registro
- Gitea Docs — Backup and restore —
gitea dump, restauración y migración de repositorios - Renovate Docs — Gitea platform — Configuración, scopes del token y limitaciones
- nektos/act — Ejecuta workflows de GitHub Actions en local
- RayLabsHQ/gitea-mirror — Espejo continuo de GitHub a Gitea o Forgejo con interfaz web
- Codeberg — Forgejo — El fork de Gitea con gobernanza propia
- Stack completo en Opengist — Compose del runner,
config.yamly workflow de Renovate listos para copiar