Cómo automatizar pipelines de CI/CD con Docker y AWS para releases más rápidas

Automatizar pipelines de CI/CD con Docker y AWS agiliza los despliegues, minimiza la intervención manual y garantiza releases más rápidas y confiables. Al integrar estas herramientas, puedes optimizar recursos, mejorar la escalabilidad y reducir la carga operativa, permitiendo que tu equipo se enfoque en la innovación en lugar de la gestión de infraestructura. Esta guía te llevará paso a paso en la configuración de un pipeline de CI/CD sólido, asegurando eficiencia, seguridad y rentabilidad en tu flujo de desarrollo en la nube.

Empezando por el Dockerfile

Antes de crear el pipeline, supongamos que nuestro microservicio en Java genera como artefacto final un archivo JAR. Un Dockerfile sencillo se vería así:

FROM amazoncorretto:17
WORKDIR /app
COPY target/<your-app-jar>.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

• amazoncorretto:17: Usa Amazon Corretto (Java 17).
• WORKDIR /app: Define el directorio de trabajo en el contenedor.
• COPY: Copia el JAR ya construido al contenedor.
• EXPOSE 8080: Expone el puerto 8080 (ajustar si tu app usa otro puerto).
• ENTRYPOINT: Indica a Docker que ejecute el JAR como proceso principal.

Objetivo y etapas del pipeline

Objetivo: Automatizar el proceso completo de build, test, análisis, y despliegue de tu app en AWS usando Docker.

Etapas Clave del Pipeline:

1. Source – Lee tu repositorio (CodeCommit, GitHub, etc.).
2. Compile – Compila el código para detectar errores temprano.
3. Test – Corre tests para validar cambios.
4. Sonar – Escanea tu código en busca de bugs, vulnerabilidades de seguridad, cobertura y code smells usando Sonar.
5. Build – Genera la imagen Docker, la sube a ECR y actualiza el servicio en ECS.

Crear un pipeline

• Desde la consola de CodePipeline, crea un pipeline nuevo (ej.: Bitlogic-Docker-Pipeline).
• Selecciona un Artifact Store (como S3) para guardar los artefactos.
• Agrega las 5 etapas: Source, Compile, Test, Sonar, Build.

Al inicio, cada etapa estará vacía. Vamos a configurarlas una por una.

1. Etapa source

Objetivo: Extraer automáticamente los cambios desde tu repositorio (CodeCommit, GitHub o Bitbucket).

1.1. Configura los detalles del repo.

1.2. Branch: Define la rama que disparará el pipeline (ej.: main).

1.3. Permisos: Asegúrate de que CodePipeline tenga acceso (roles IAM, OAuth).

Resultado: cualquier commit en la rama seleccionada disparará el pipeline.

2. Etapa compile

Objetivo: Compilar la app en Java para detectar errores de sintaxis o dependencias.

2.1. Crea un proyecto en CodeBuild llamado "Compile".

2.2. Usa este buildspec (ejemplo de abajo) que corre el mvn compile:

version: 0.2
phases:
  install:
    runtime-versions:
      java: corretto17
  build:
    commands:
      - echo "Compiling the application..."
      - mvn compile
artifacts:
  files:
    - target/**/*.class

• Adjunta este proyecto a la etapa de "Compile" en CodePipeline
• Fail Fast: Si no compila, el pipeline se detiene, ahorrando tiempo y recursos.

3. Etapa test

Objetivo: Ejecutar tests unitarios/integración para validar funcionalidades.

3.1. Crea un proyecto en CodeBuild llamado "Test".

3.2. Añade un buildspec que ejecute mvn test:

version: 0.2
phases:
  build:
    commands:
      - echo "Running tests..."
      - mvn test
artifacts:
  files:
    - target/surefire-reports/*.xml

3.3. Adjunte este proyecto a la etapa "Test".

Resultado: Si algún test falla, se detiene el pipeline y no avanza código defectuoso.

4. Etapa Sonar (Análisis de código)

Objetivo: Analizar cobertura, seguridad y code smells con Sonar.

4.1. Crea un proyecto CodeBuild llamado Sonar.

4.2. Referencia a un buildspec que ejecuta el plugin Maven de Sonar:

version: 0.2

phases:
  install:
    runtime-versions:
      java: corretto17
  pre_build:
    commands:
      - echo "Starting Sonar analysis..."
  build:
    commands:
      - mvn clean install org.sonarsource.scanner.maven:sonar-maven-plugin:sonar \
        -Dsonar.host.url=https://sonarcloud.io  \
        -Dsonar.organization=<your-organization> \
        -Dsonar.projectKey=<your-project-key> \
        -Dsonar.token=$SONAR_TOKEN \
        -Dsonar.qualitygate.wait=true \
        -Dsonar.coverage.jacoco.xmlReportPaths=/target/site/jacoco-aggregate/jacoco.xml \
        -DnvdApiKey=$dckey
artifacts:
  files:
    - target/*

• Quality Gate: Si el análisis no pasa los umbrales definidos, se bloquea el pipeline.

4.3. Adjunte este proyecto a la etapa Sonar en CodePipeline.

5. Etapa build (Docker Build & Deploy)

Objetivo: Usar el Dockerfile, subir la imagen a ECR y actualizar ECS.

5.1. Crea un proyecto CodeBuild llamado Build.

5.2. Utilice un buildspec similar al siguiente para el build, push y deploy:

version: 0.2
phases:
  pre_build:
    commands:
      - echo "Logging in to ECR..."
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin <aws-account-id>.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com
  build:
    commands:
      - echo "Building the Docker image..."
      - docker build -t <repo-name>:latest .
      - docker tag <repo-name>:latest <aws-account-id>.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/<repo-name>:latest
  post_build:
    commands:
      - echo "Pushing image to ECR..."
      - docker push <aws-account-id>.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/<repo-name>:latest
      - echo "Deploying to ECS..."
      - aws ecs update-service --cluster <your-ecs-cluster> --service <your-ecs-service> --force-new-deployment
artifacts:
  files:
    - Dockerfile

5.3. Vincule este proyecto a la etapa Build en CodePipeline.

Resultado:

• Imagen Docker subida a ECR.
• ECS actualiza el servicio automáticamente.

Buenas prácticas en Bitlogic

• Fail Fast: Detenerse en errores de compilación o tests.
• Version Tags: Etiquetar imágenes como latest y versión semántica (ej.: 1.0.0).
• Secrets Seguros: Guardar tokens (ej.: $SONAR_TOKEN) en Parameter Store o variables de entorno.
• Rollbacks Automatizados: Configurar ECS para revertir si falla un deployment.
• Logging Completo: Centralizar logs de CodeBuild, ECS, y app en CloudWatch Logs.

Conclusión

Arrancando desde un Dockerfile y siguiendo estas 5 etapas (Source, Compile, Test, Sonar, Build), lograrás:

• Detectar errores tempranos.
• Asegurar calidad con Sonar.
• Desplegar a AWS ECS de forma ágil y confiable.

Esta metodología acelera los releases y asegura flujos DevOps sólidos en Bitlogic. Personaliza cada etapa según tu proyecto y tendrás un pipeline robusto que escala con tu equipo.

¿Listo para automatizar? ¡Hablemos!

Si querés mejorar la eficiencia y acelerar los releases de software, podemos ayudarte. Nuestros ingenieros DevOps garantizan integración y despliegue continuo sin frenar tus operaciones.

📩 ¡Contáctanos hoy para una consultoría gratuita! El café corre por nuestra cuenta ;) ☕️