14 - Integracion con CI/CD

Objetivo del tema

Comprenderas como integrar Gradle en pipelines de CI/CD utilizando Jenkins, GitHub Actions y GitLab CI, ejecutando builds, publicando artefactos y reportando tests de forma automatizada.

Al finalizar, podras preparar scripts de pipeline, manejar caches y distribuir artefactos y reportes de pruebas en servidores de integracion continua.

14.1 Gradle en Jenkins, GitHub Actions, GitLab CI

Gradle se integra facilmente con motores de CI. Usa el Gradle Wrapper (./gradlew) para asegurar la version correcta en los agentes.

// Jenkinsfile (Declarative Pipeline)
pipeline {
  agent any
  stages {
    stage('Checkout') {
      steps {
        checkout scm
      }
    }
    stage('Build') {
      steps {
        sh './gradlew clean build'
      }
    }
  }
  post {
    always {
      junit 'build/test-results/test/*.xml'
      archiveArtifacts artifacts: 'build/libs/*.jar', fingerprint: true
    }
  }
}

# .github/workflows/ci.yml
name: CI
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          distribution: temurin
          java-version: 21
      - name: Cache Gradle
        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: gradle-${{ runner.os }}-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
      - name: Build
        run: ./gradlew clean build

En GitLab CI, configura un .gitlab-ci.yml con entorno Java y ejecuta ./gradlew build. Usa caches de Gradle para acelerar trabajos.

14.2 Ejecucion de builds en servidores

Los agentes de CI pueden ser contenedores, VMs o maquinas Bare Metal. Asegura que tengan acceso a las herramientas necesarias (JDK, Docker, etc.).

# gitlab-ci.yml (ejemplo basico)
stages:
  - build
  - test

build:
  stage: build
  image: gradle:8.8-jdk21
  script:
    - gradle clean assemble
  cache:
    key: gradle-cache
    paths:
      - .gradle

test:
  stage: test
  image: gradle:8.8-jdk21
  dependencies:
    - build
  script:
    - gradle test

Considera usar contenedores personalizados si necesitas herramientas adicionales (como Node.js para builds full-stack).

14.3 Artefactos en pipelines

Publica artefactos generados por Gradle para que otros stages o pipelines los consuman. Usa las funciones nativas de cada plataforma.

• Jenkins: archiveArtifacts o Jenkins Artifactory plugin.
• GitHub Actions: actions/upload-artifact para compartir JARs, reportes o lockfiles.
• GitLab CI: artifacts en cada job para persistir resultados entre stages.

    - name: Upload artifact
      uses: actions/upload-artifact@v4
      with:
        name: distribucion
        path: build/libs/*.jar

Para repositorios privados, agrega jobs que ejecuten ./gradlew publish con credenciales obtenidas de secretos del pipeline.

14.4 Tests automaticos en la nube

Integra la ejecucion de pruebas unitarias y de integracion dentro del pipeline. Reporta resultados y, si es posible, genera reportes de cobertura.

    - name: Run tests
      run: ./gradlew test jacocoTestReport
    - name: Publish JUnit results
      uses: actions/upload-artifact@v4
      with:
        name: junit-report
        path: build/test-results/test/
    - name: Publish coverage report
      uses: actions/upload-artifact@v4
      with:
        name: cobertura
        path: build/reports/jacoco/test/html/

En plataformas como Jenkins o GitLab CI, habilita plugins para visualizar los reportes HTML o XML y condicionar despliegues segun la cobertura.

Resumen didactico

Integrar Gradle en CI/CD implica usar el wrapper para garantizar versiones, ejecutar builds en agentes consistentes, compartir artefactos y publicar reportes de pruebas. Con pipelines bien configurados, transformar builds locales en despliegues confiables es un proceso repetible y automatizado.