Resumen

  • GitLab define los minutos de cómputo con una fórmula impresa, Job duration / 60 * Cost factor, y describe el factor de coste como un multiplicador que «is not a monetary price».
  • Siete páginas de GitLab imprimen el divisor, la tabla de factores por tipo de runner, las asignaciones de 400, 10 000 y 50 000 minutos al mes y el complemento de 10 USD por 1 000 minutos; ninguna dice cómo un resultado fraccionario se convierte en un número facturable.

Un pipeline de diez minutos puede facturarse como cuarenta minutos de cómputo, y según GitLab mismo las dos cifras son correctas. La página que produce la segunda es pública: «Your compute minute usage for each job is calculated using this formula: Job duration / 60 * Cost factor» (Compute minutes). El divisor es sesenta. La unidad lleva el nombre de un minuto. El multiplicador no es ni un minuto ni dinero: esa misma página define la duración de un job como los segundos que tardó en ejecutarse, sin contar los estados created y pending, y describe el factor de coste como un número fijado por el tipo de runner y el tipo de proyecto, que decide a qué velocidad un job consume minutos de cómputo y que «is not a monetary price».

La tabla de factores está publicada completa. En GitLab.com, un runner Linux x86-64 alojado puntúa 1 en small, 2 en medium, 3 en large, 6 en xlarge y 12 en 2xlarge; el medium con GPU puntúa 7; Linux Arm64 puntúa 1, 2 y 3 en small, medium y large; macOS M1 medium puntúa 6 y macOS M2 Pro large 12, ambos en Beta; Windows medium puntúa 1, también en Beta.

El tipo de proyecto mueve la misma palanca en otra escala: 0,5 para proyectos públicos del programa GitLab for Open Source, 0,008 para sus forks públicos y, en el caso de las contribuciones comunitarias, un factor dinámico igual a la asignación mensual dividida por 300 000 minutos de duración de jobs.

Siete páginas de GitLab se citan aquí, cinco en docs.gitlab.com y dos en about.gitlab.com, todas consultadas el 21 de noviembre de 2026. Ninguna indica cómo un resultado fraccionario de minuto de cómputo se convierte en una cantidad facturable. En esas siete páginas no hay regla de redondeo, ni mínimo de facturación, ni precisión sobre la granularidad por job. Según la fórmula impresa, un job de cuarenta segundos en un runner Linux small vale dos tercios de minuto de cómputo, por mi división; si la cuota registra 0,67, 1 u otra cosa es un dato que las páginas publicadas no contienen.

Los nombres de los runners no son nombres de máquinas, y las máquinas están impresas en otra página. El runner Linux x86-64 small son 2 vCPU y 8 GB; medium, 4 vCPU y 16 GB; large, 8 vCPU y 32 GB; xlarge, 16 vCPU y 64 GB; 2xlarge, 32 vCPU y 128 GB, con las tres últimas tallas restringidas a Premium y Ultimate; los jobs sin etiqueta caen en el runner small (Hosted runners on Linux). Windows medium tiene un factor impreso de 1, pero ninguna página consultada da su número de vCPU ni su memoria.

Las asignaciones y el precio están del lado comercial. Un espacio de nombres Free recibe 400 minutos de cómputo al mes, Premium 10 000 y Ultimate 50 000, y los minutos adicionales se venden a 10 USD por 1 000 en pago único, disponibles en todos los planes (Pricing). Ninguna página consultada pone precio a un minuto incluido: la asignación y el minuto comprado comparten nombre y, en la superficie publicada, no comparten tarifa.

Cruza las dos tablas y la escala deja de ser proporcional. Una hora de reloj en el runner small produce 60 minutos de cómputo repartidos entre 2 vCPU, es decir 30 minutos de cómputo por vCPU-hora; medium produce 120 entre 4 vCPU, también 30; large 180 entre 8, xlarge 360 entre 16 y 2xlarge 720 entre 32, en cada caso 22,5. Al precio impreso de 0,01 USD por minuto eso da 0,30 USD por vCPU-hora en small y medium, y 0,225 USD en las tres tallas mayores. La caída es del 25 por ciento y ocurre exactamente en el escalón de 8 vCPU; pasar de 8 a 16 vCPU y de 16 a 32 no cambia nada.

Es mi división de dos tablas publicadas, no una recomendación de GitLab: ninguna página consultada dice a un equipo cómo elegir el tamaño del runner por motivos de coste, y una máquina de 2 vCPU que termina el trabajo suele salir más barata que una de 32 vCPU parada.

Lo que llega a la cuenta es una suma, no una duración. La página de minutos de cómputo afirma que el total consumido por un pipeline es la suma de todos los jobs ejecutados, de modo que los jobs simultáneos pueden superar la duración del pipeline de extremo a extremo. Un pipeline cuyos cuatro jobs corren diez minutos en paralelo en runners Linux small ocupa diez minutos de reloj y registra 40 minutos de cómputo, cuatro veces el intervalo que cronometraría alguien mirando la pantalla, y 0,40 USD de saldo comprado al precio impreso. Son mis multiplicaciones a partir de valores publicados.

Los segundos que alimentan el numerador quedan en el registro de jobs del cliente; el divisor y el multiplicador los publica el proveedor que los aplica.

El saldo comprado lleva fecha. La página de minutos adicionales dice que «Are valid for 12 months from date of purchase if not consumed earlier» y añade que «Expiry of compute minutes is not yet enforced, which allows their use even after the expiry date. However, GitLab does not guarantee that compute minutes will remain valid after the expiry date.» (Purchase additional compute minutes). La FAQ comercial es más estricta: «Purchased minutes are only valid for 12 months from the date of purchase or until all minutes are consumed, whichever comes first» (Managing compute minutes FAQ). Son dos frases de GitLab sobre el mismo saldo, y ninguna de las dos páginas resuelve qué ocurre en el mes trece.

El contador tiene un perímetro, y discurre por el runner, no por el job. «Group and project runners are not subject to the compute quota» (Compute minutes administration); la cuota se aplica a los runners de instancia, que en GitLab.com son las máquinas alojadas. En GitLab autoalojado el factor de coste es 1 para todos los proyectos y las cuotas están desactivadas por defecto, así que la tabla de factores es un instrumento propio de GitLab.com, y el trabajo que corre en hardware que el cliente paga directamente nunca entra en este contador.

El agotamiento es gradual, no abrupto. Los runners de instancia dejan de tomar jobs nuevos, los jobs pendientes o reintentados se descartan y los jobs en ejecución continúan hasta que el consumo del espacio de nombres supera la cuota en 1 000 minutos de cómputo, momento en que se descartan los jobs restantes (Compute usage for instance runners). Esa banda de 1 000 minutos es la única tolerancia entre un límite y su consecuencia en las páginas consultadas, y está denominada en la unidad puntuada, no en horas.

La parte recalculable es, por tanto, generosa. Con los segundos de un job, la etiqueta del runner que lo ejecutó y el plan contratado, la cantidad de minutos de cómputo se deduce de números publicados: dividir por sesenta, multiplicar por el factor impreso, sumar los jobs. Convierte el excedente a 10 USD por 1 000 y el precio marginal de un mes cargado se vuelve aritmética. Fuera de alcance quedan el incremento que hace facturables dos tercios de minuto, un valor en dólares para un minuto incluido y cualquier regla publicada para elegir el tamaño del runner.

Son tres frases ausentes distintas, y ninguna atención a las publicadas las sustituye.

GitLab ha impreso la mitad costosa del instrumento con una claridad poco habitual: el divisor, el multiplicador, la asignación, el precio, las máquinas detrás de los nombres de runner, el perímetro y la banda de gracia. La mitad que un cliente necesita para conciliar una factura es el incremento, y no está. Una unidad hecha de un nombre, una división y una puntuación sigue sirviendo como unidad de facturación. No es una duración, y un presupuesto que la trate como tal fallará en todo lo que diga el factor.

GitLab figura en el directorio de BTW: GitLab.