Ejercicio: CI/CD Pipeline con AWS Developer Tools ​

Escenario ​

Implementaremos un pipeline completo para una aplicación web simple:

• Código fuente en CodeCommit
• Construcción con CodeBuild
• Despliegue con CodeDeploy
• Orquestación con CodePipeline

Parte 1: Configurar CodeCommit ​

1. Crear Repositorio ​

1. Ve a AWS CodeCommit:

   Create repository
   Name: my-web-app
   Description: Aplicación web de ejemplo

2. Configurar Acceso Git ​

1. Ve a IAM > Users > Tu Usuario:

   Security credentials > HTTPS Git credentials
   Generate credentials

2. Guarda las credenciales generadas:

   User name: tu-usuario-git
   Password: tu-password-generado

3. Clonar y Configurar Repositorio ​

git clone https://git-codecommit.[region].amazonaws.com/v1/repos/my-web-app
cd my-web-app

# Configurar usuario git local
git config user.name "Tu Nombre"
git config user.email "tu@email.com"

4. Estructura Inicial del Proyecto ​

my-web-app/
├── src/
│   ├── index.html
│   ├── styles.css
│   └── app.js
├── scripts/
│   └── install_dependencies.sh
├── tests/
│   └── test.js
├── buildspec.yml
├── appspec.yml
└── README.md

Parte 2: Configurar CodeBuild ​

1. Crear Build Project ​

1. Ve a CodeBuild > Create build project:

   Project name: my-web-app-build
   Source provider: AWS CodeCommit
   Repository: my-web-app
   Branch: main
   
   Environment:
   - Managed image
   - Operating system: Amazon Linux 2
   - Runtime: Standard
   - Image: aws/codebuild/amazonlinux2-x86_64-standard:3.0
   
   Service role: Create new service role

2. Crear buildspec.yml ​

version: 0.2

phases:
  install:
    runtime-versions:
      nodejs: 14
    commands:
      - npm install -g npm
      - npm install
      
  pre_build:
    commands:
      - echo "Running tests..."
      - npm test
      
  build:
    commands:
      - echo "Building..."
      - npm run build
      
  post_build:
    commands:
      - echo "Build completed"
      
artifacts:
  files:
    - '**/*'
  base-directory: 'dist'

Parte 3: Configurar CodeDeploy ​

1. Crear Application ​

1. Ve a CodeDeploy:

   Create application
   Application name: my-web-app
   Compute platform: EC2/On-premises

2. Crear Deployment Group ​

Name: my-web-app-deployment-group
Service role: Create new (AWSCodeDeployRole)

Environment configuration:
- Amazon EC2 instances
- Tags: Key=Environment, Value=Production

Deployment settings:
- AllAtOnce

Load balancer: Disable

3. Crear appspec.yml ​

version: 0.0
os: linux
files:
  - source: /
    destination: /var/www/html/
hooks:
  BeforeInstall:
    - location: scripts/install_dependencies.sh
      timeout: 300
      runas: root
  ApplicationStart:
    - location: scripts/start_application.sh
      timeout: 300
      runas: root
  ValidateService:
    - location: scripts/validate_service.sh
      timeout: 300
      runas: root

Parte 4: Configurar CodePipeline ​

1. Crear Pipeline ​

1. Ve a CodePipeline:

   Create pipeline
   Name: my-web-app-pipeline
   Service role: New service role
   
   Source:
   - Provider: AWS CodeCommit
   - Repository: my-web-app
   - Branch: main
   - Change detection: CloudWatch Events
   
   Build:
   - Provider: AWS CodeBuild
   - Project: my-web-app-build
   
   Deploy:
   - Provider: AWS CodeDeploy
   - Application: my-web-app
   - Deployment group: my-web-app-deployment-group

Parte 5: Configuración de IAM ​

1. CodeBuild Role ​

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Resource": ["*"],
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents",
                "s3:GetObject",
                "s3:PutObject",
                "s3:GetObjectVersion"
            ]
        }
    ]
}

2. CodeDeploy Role ​

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "autoscaling:*",
                "ec2:*",
                "s3:*",
                "elasticloadbalancing:*"
            ],
            "Resource": "*"
        }
    ]
}

Parte 6: Prueba del Pipeline ​

1. Preparar EC2 para CodeDeploy ​

1. Instalar CodeDeploy Agent:

#!/bin/bash
sudo yum update -y
sudo yum install -y ruby wget
wget https://aws-codedeploy-[region].s3.[region].amazonaws.com/latest/install
chmod +x ./install
sudo ./install auto

2. Hacer un Cambio y Probar ​

1. Modificar código:

# Editar index.html
git add .
git commit -m "Update index.html"
git push

2. Observar Pipeline:
   • Ve a CodePipeline
   • Observa el progreso
   • Verifica cada etapa

Verificación ​

1. Verificar Build ​

• [ ] Build exitoso en CodeBuild
• [ ] Artefactos generados correctamente
• [ ] Tests pasando

2. Verificar Deploy ​

• [ ] Despliegue exitoso en instancias
• [ ] Aplicación accesible
• [ ] Logs sin errores

3. Verificar Pipeline ​

• [ ] Todas las etapas en verde
• [ ] Transiciones correctas
• [ ] Artefactos moviéndose entre etapas

Troubleshooting Común ​

Error de Permisos ​

1. Verificar roles IAM
2. Revisar políticas
3. Verificar logs de CloudWatch

Error de Build ​

1. Verificar buildspec.yml
2. Revisar logs de CodeBuild
3. Probar build localmente

Error de Deploy ​

1. Verificar agent en EC2
2. Revisar appspec.yml
3. Verificar logs de CodeDeploy

Limpieza ​

1. Eliminar Pipeline
2. Eliminar aplicación CodeDeploy
3. Eliminar proyecto CodeBuild
4. Eliminar repositorio CodeCommit
5. Eliminar roles IAM

Puntos importantes a recordar:

1. Los servicios están interconectados en secuencia
2. Cada servicio tiene su propio rol IAM
3. Los archivos de configuración (buildspec.yml y appspec.yml) son cruciales
4. El monitoreo de los logs es esencial para troubleshooting

Para el examen Cloud Practitioner, enfócate en:

• Propósito de cada servicio
• Cómo se integran entre sí
• Beneficios de CI/CD
• Aspectos básicos de seguridad