Jenkins y pipelines CI
(Sección: Tecnologías e Infraestructura)
Resumen breve
Jenkins sigue siendo el «motor» universal del CI en las infraestructuras híbridas de iGaming: combina el ensamblaje de aplicaciones, la containerización, las pruebas, la comprobación de seguridad y la publicación de artefactos. El éxito es la canalización como código (Declarative/Multibranch), Librerías compartidas, agentes efímeros en Kubernetes, seguridad rígida y secretos, GitOps de control de confección, y métricas de rendimiento y costo.
1) Arquitectura Jenkins bajo iGaming
Controller (LTS) + agentes: mínimo de plugins en el controlador; el trabajo se transfiere a los agentes.
Agentes efímeros: lanzamiento en K8s/bajo dinámico 'jnlp' (inicio rápido, ambientes limpios).
Aislamiento de trabajo: carpetas/derechos (Folders + Role-Based Strategy), créditos por los derechos más pequeños.
Observabilidad: exportación de métricas (latency, cola), registros de etapas centralizados, ID de tres en pipelines.
2) Patrones de Paipline: Declarative y Multibranch
Cuando Declarative: transportadores estándar con etapas homogéneas, nítidos 'post' -shags.
Cuando Scripted: raras ramificaciones «no estándar».
Multibranch: auto-pipeline para cada rama/PR; políticas «sólo ramas activas».
Pipeline Declarative básico
groovy pipeline {
agent { label 'k8s' } // или agent { kubernetes {... } }
options {
timestamps()
ansiColor('xterm')
buildDiscarder(logRotator(numToKeepStr: '50'))
timeout(time: 30, unit: 'MINUTES')
disableConcurrentBuilds()
}
environment {
REGISTRY = 'registry. example. com'
IMAGE = "${env. REGISTRY}/payments:${env. GIT_COMMIT}"
}
stages {
stage('Checkout') {
steps { checkout(scm) }
}
stage('Lint & Unit') {
parallel {
stage('Lint') { steps { sh 'make lint' } }
stage('Unit') { steps { sh 'make test' } }
}
}
stage('SCA/SAST') {
steps {
sh'make deps_audit'//SCA (dependencies)
sh'make sast '//static analysis
}
}
stage('Build Image') {
steps { sh 'docker build -t $IMAGE. && docker push $IMAGE' }
}
stage('SBOM & Sign') {
steps {
sh 'syft $IMAGE -o spdx-json > sbom. json'
sh 'cosign sign --key $COSIGN_KEY $IMAGE'
archiveArtifacts artifacts: 'sbom. json', fingerprint: true
}
}
}
post {
success { echo '+ Build OK' }
failure { echo '- Build failed'; sh 'printenv sort sed -n "1,50p"' }
always { cleanWs() }
}
}3) Agentes de Kubernetes y envases de contenedores
Ejemplo de podTemplate (Declarative)
groovy pipeline {
agent {
kubernetes {
yaml """apiVersion: v1 kind: Pod spec:
serviceAccountName: jenkins containers:
- name: build image: docker:27-dind securityContext: { privileged: true }
- name: tools image: alpine:3. 20 command: ['cat']
tty: true
"""
defaultContainer 'tools'
}
}
stages {
stage('Build in DinD') {
steps {
container('build') {
sh '''
dockerd-entrypoint. sh & sleep 5 docker build -t $IMAGE.
docker push $IMAGE
'''
}
}
}
}
}Práctica: caché de capas a través del 'emptyDir '/caché remota general; límites de CPU/RAM; 'nodeSelector/taints' para separar conjuntos pesados.
4) Bibliotecas compartidas: DRY y normas uniformes
Lleve los pasos generales (linters, SAST, compilación, publicación) a la Biblioteca compartida.
groovy
// vars/withQuality. groovy def call(Closure body) {
stage('Quality Gate') {
parallel(
"Lint": { sh 'make lint' },
"Unit": { sh 'make test' },
"SCA": { sh 'make deps_audit' }
)
}
body()
}groovy
@Library('ci-lib@v3') _
pipeline {
agent any stages {
stage('Pipeline') {
steps {
withQuality {
sh 'make build'
}
}
}
}
}Consejos: versionar la biblioteca ('tags'), cubrir con pruebas unitarias los pasos, mantener el CHANGELOG.
5) Secretos y credenciales
Credentials Binding: `usernamePassword`, `string`, `file`, `sshUserPrivateKey`.
Secreto scopes: mínimo de derechos; uso sólo en las etapas deseadas.
Administradores de secretos: proveedores de almacenamiento externo (KMS/Secrets Manager/HashiCorp Vault).
groovy withCredentials([string(credentialsId: 'cosign-key', variable: 'COSIGN_KEY')]) {
sh 'cosign sign --key $COSIGN_KEY $IMAGE'
}6) Paralelismo, matrices, caché
Compilaciones matrix
groovy stage('Test Matrix') {
matrix {
axes {
axis { name 'PY'; values '3. 10', '3. 12' }
axis { name 'DB'; values 'mysql', 'postgres' }
}
stages {
stage('Run') { steps { sh 'pytest -q' } }
}
post { always { junit 'reports/.xml' } }
}
}Almacenamiento en caché: Docker layer cache, caché de dependencias ('~/.m2', '~/.cache/pip') en volumen; artefactos entre etapas - a través de 'stash/unstash' o artefacto de almacenamiento.
7) Controles de seguridad y cumplimiento
SCA/SAST/Secret-scan en CI, DAST en un entorno separado.
SBOM (Syft/CycloneDX), firma de artefactos (cosign), política «Sin firma - No deploy».
Policy-gates: detener la paipline en CVEs críticos; informes en PR.
Contornos PII: No lógica secretos, enmascarar variables, agentes individuales para conjuntos sensibles.
8) Publicación de artefactos e integración con CD
Registro: Docker/OCI con política de retén, immutabilidad de etiquetas.
Package Repos: Maven/NPM/PyPI proxy+cache.
Activadores de CD: envíe eventos a Argo CD/Flagger o cree un PR en el repositorio de GitOps de los manifiestos.
9) Jenkins Configuration as Code (JCasC) и GitOps
Mantenga la configuración del controlador como código: plantillas de jobe, créditos (enlaces), RBAC, agentes.
yaml jenkins:
systemMessage: "Jenkins (iGaming CI)"
numExecutors: 0 authorizationStrategy:
roleBased:
roles:
global:
- name: "readers"
pattern: "."
permissions: ["Overall/Read"]
nodes:
- permanent:
name: "edge-builder"
remoteFS: "/home/jenkins"
labels: "docker"
unclassified:
location:
url: "https://ci. example. com/"
credentials:
system:
domainCredentials:
- credentials:
- string:
id: "cosign-key"
description: "Cosign key ref"
secret: "${COSIGN_KEY_FROM_ENV}"Práctica: Confit - en Git, PR-rugido, promoción dev→stage→prod; secretos - a través de gestores variables/externos.
10) Observabilidad, fiabilidad y costo
Métricas: cola, duración de las etapas, porcentaje de reinicios, ancho de banda de los agentes.
Fallas: 'retry', 'timeout', 'stable' - etiquetado de pruebas flaky, notificaciones en ChatOps.
FinOps: desactivación automática de agentes ociosos, límites de conjuntos paralelos, cuotas por carpeta/comando.
11) Pipelines para diferentes tareas
Servicio Backend/Web
Lint/units → SAST/SCA → Build → SBOM/Sign → Publish → (activador de CD).
Data/ETL
Validación de circuitos (prueba de dbt) → generación de artefactos → análisis estático SQL → publicación de modelos y documentación.
ML/LLM
Verificación de datos/licencias → entrenamiento en agentes spot → exportación de ONNX/TensorRT → pruebas de perfume (latency/tokens/s) → firma y publicación del modelo.
12) Runabooks (incidentes típicos)
La cola crece: añadir agentes, comprobar los paipelines «suspendidos», los límites de la concurrencia.
Conjuntos flotantes: patear versiones de herramientas en el contenedor del agente; desactivar el espacio de trabajo compartido.
El secreto de «pato» en los registros: eliminar build-logs, reemplazar crédito, auditar; agregar máscara.
Caída del controlador: recuperación de backup JCasC + almacenamiento de job/plugins versionados.
13) Lista de verificación de implementación
1. Jenkins LTS con un conjunto mínimo de plugins; todo lo demás está en los agentes.
2. Agentes K8s efímeros, límites de recursos, cachés layer.
3. Declarative/Multibranch, validación PR, 'post {always {cleanWs ()}}'.
4. Bibliotecas compartidas con versionamiento; pasos uniformes de calidad/seguridad.
5. Credentials Binding + secretos externos; Escopetas mínimas.
6. SCA/SAST/Secret-scan/DAST, SBOM y firma de imágenes.
7. JCasC y GitOps-control de configuración; El rugido de PR de los cambios.
8. Métricas/alertas/ChatOps; retraídas/taimautas; artefactos y revistas.
9. Políticas de retención/retención, auto-higiene de espacios de trabajo.
10. Runabooks documentados y día de juego regular.
14) Antipattern
Controlador «como servidor de todo»: montajes pesados y plugins en el mismo.
Scripted-jobs sin versionar y rugir código.
Mezcla de secretos y registros; créditos con amplios derechos.
Hay pocos agentes/son constantes → la deriva de los alrededores, pruebas de flaky.
Ausencia de SBOM/firma de artefactos y gates por CVE.
Control de configuración «manual», sin JCasC/GitOps.
Resultados
Jenkins sigue siendo un núcleo CI potente y flexible. Al convertir la configuración en código (JCasC), estandarizar los pasos en las Bibliotecas Compartidas, ejecutar ensamblajes en agentes K8s efímeros e incorporar la seguridad/firma/SBOM directamente en el transportador, obtendrá versiones predecibles, un costo controlado y resistencia a cargas máximas iGaming.