MF06-PRA06-AlexCano-AWSDeployment

PRA06_ANSWER/docs/Pipeline explicado.md

@@ -0,0 +1,119 @@
+## Pipeline explicado:
+
+### 1. Declaración inicial y configuración de entorno
+
+pipeline {
+    agent any
+
+
+    agent any: Indica que esta pipeline puede ejecutarse en cualquier nodo disponible de Jenkins.
+
+    environment {
+        IMAGE_NAME = 'testjenkins'
+        IMAGE_TAG = "${IMAGE_NAME}-${BUILD_NUMBER}"
+        AWS_ACCOUNT_ID = '559050249249'
+        AWS_DEFAULT_REGION = 'us-east-1'
+        IMAGE_REPO_NAME = "t6o5r2l4/test/jenkins"
+        REPOSITORY_URI = "public.ecr.aws/${IMAGE_REPO_NAME}"
+    }
+
+    environment: Declara variables globales que se usan en toda la pipeline.
+        IMAGE_NAME: Nombre base de la imagen Docker.
+        IMAGE_TAG: Tag único para la imagen (combina el nombre y el número de compilación).
+        AWS_ACCOUNT_ID: ID único de tu cuenta pública de AWS.
+        AWS_DEFAULT_REGION: Región donde está configurado tu repositorio en Amazon ECR.
+        IMAGE_REPO_NAME: Nombre completo del repositorio en ECR.
+        REPOSITORY_URI: URI del repositorio donde se sube la imagen Docker.
+
+### 2. Herramientas configuradas
+
+    tools {
+        maven 'M3'
+        jdk 'JDK21'
+    }
+
+    tools: Especifica herramientas necesarias para la pipeline.
+        maven 'M3': Usa Maven para compilar el proyecto (debe estar configurado en Jenkins).
+        jdk 'JDK21': Usa JDK 21 como entorno para ejecutar el proyecto (también configurado previamente en Jenkins).
+
+### 3. Stages principales
+
+Stage 1: Checkout
+
+        stage('Checkout') {
+            steps {
+                git 'https://github.com/Alexkano10/Test_Jenkins.git'
+            }
+        }
+
+    git: Clona el repositorio remoto desde GitHub al workspace de Jenkins.
+
+Stage 2: Build with Maven
+
+        stage('Build with Maven') {
+            steps {
+                sh 'mvn clean package -DskipTests'
+            }
+        }
+
+    sh 'mvn clean package -DskipTests':
+        Limpia el workspace del proyecto y empaqueta la aplicación.
+        La opción -DskipTests omite la ejecución de pruebas para acelerar el proceso (puedes eliminar esta opción si deseas incluir las pruebas).
+
+Stage 3: Build Docker Image
+
+        stage('Build Docker Image') {
+            steps {
+                script {
+                    sh """
+                        docker build -t ${IMAGE_NAME}:${IMAGE_TAG} .
+                        docker tag ${IMAGE_NAME}:${IMAGE_TAG} ${REPOSITORY_URI}:${IMAGE_TAG}
+                    """
+                }
+            }
+        }
+
+    docker build: Crea la imagen Docker usando el Dockerfile en el directorio actual. La etiqueta combina el nombre y el número de compilación.
+    docker tag: Etiqueta la imagen creada para prepararla para subirla al repositorio público ECR.
+
+Stage 4: Push Docker Image to ECR
+
+        stage('Push Docker Image to ECR') {
+            steps {
+                withCredentials([[$class: 'AmazonWebServicesCredentialsBinding', credentialsId: 'aws-access']]) {
+                    script {
+                        sh """
+                            aws ecr-public get-login-password --region ${AWS_DEFAULT_REGION} | docker login --username AWS --password-stdin public.ecr.aws
+                            docker push ${REPOSITORY_URI}:${IMAGE_TAG}
+                        """
+                    }
+                }
+            }
+        }
+
+    withCredentials: Usa las credenciales configuradas en Jenkins con el ID aws-access para autenticarse en AWS.
+    aws ecr-public get-login-password: Obtiene una contraseña temporal para iniciar sesión en el registro público de Amazon ECR.
+    docker push: Sube la imagen al repositorio público en Amazon ECR.
+
+## 4. Limpieza al final
+
+    post {
+        always {
+            sh """
+                docker image rm ${IMAGE_NAME}:${IMAGE_TAG} || true
+                docker image rm ${REPOSITORY_URI}:${IMAGE_TAG} || true
+            """
+        }
+    }
+
+    docker image rm: Elimina las imágenes Docker creadas para liberar espacio en el nodo Jenkins.
+    || true: Ignora errores si la imagen ya no existe.
+
+### Resumen de la pipeline
+
+    Clona el código desde GitHub.
+    Construye el proyecto usando Maven.
+    Crea una imagen Docker del proyecto.
+    Etiqueta y sube la imagen a Amazon ECR público.
+    Limpia las imágenes Docker creadas.
+

PRA06_ANSWER/docs/Pipeline_Jenkins_to_ECR.txt

@@ -0,0 +1,65 @@
+pipeline {
+    agent any
+
+    environment {
+        IMAGE_NAME = 'testjenkins'
+        IMAGE_TAG = "${IMAGE_NAME}-${BUILD_NUMBER}" // Combina nombre e ID de build
+        AWS_ACCOUNT_ID = '559050249249'
+        AWS_DEFAULT_REGION = 'us-east-1'
+        IMAGE_REPO_NAME = "t6o5r2l4/test/jenkins"
+        REPOSITORY_URI = "public.ecr.aws/${IMAGE_REPO_NAME}"
+    }
+
+    tools {
+        maven 'M3'
+        jdk 'JDK21'
+    }
+
+    stages {
+        stage('Checkout') {
+            steps {
+                git 'https://github.com/Alexkano10/Test_Jenkins.git'
+            }
+        }
+
+        stage('Build with Maven') {
+            steps {
+                sh 'mvn clean package -DskipTests'
+            }
+        }
+
+        stage('Build Docker Image') {
+            steps {
+                script {
+                    sh """
+                        docker build -t ${IMAGE_NAME}:${IMAGE_TAG} .
+                        docker tag ${IMAGE_NAME}:${IMAGE_TAG} ${REPOSITORY_URI}:${IMAGE_TAG}
+                    """
+                }
+            }
+        }
+
+        stage('Push Docker Image to ECR') {
+            steps {
+                withCredentials([[$class: 'AmazonWebServicesCredentialsBinding', credentialsId: 'aws-access']]) {
+                    script {
+                        sh """
+                            aws ecr-public get-login-password --region ${AWS_DEFAULT_REGION} | docker login --username AWS --password-stdin public.ecr.aws
+                            docker push ${REPOSITORY_URI}:${IMAGE_TAG}
+                        """
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            sh """
+                docker image rm ${IMAGE_NAME}:${IMAGE_TAG} || true
+                docker image rm ${REPOSITORY_URI}:${IMAGE_TAG} || true
+            """
+        }
+    }
+}
+

PRA06_ANSWER/docs/despliegue_app_completa.md

@@ -0,0 +1,74 @@
+# Despliegue de una Aplicación Spring Boot en AWS ECS usando Jenkins y Docker
+## 1. Crear credenciales en AWS
+
+Primero crearemos las credenciales de acceso en AWS para permitir que Jenkins interactúe con los servicios de AWS. Se crearon las Access Key ID y Secret Access Key en el IAM de AWS.
+
+## 2. Crear repositorio en ECR público
+
+Creamos un repositorio público en Amazon Elastic Container Registry (ECR) para almacenar las imágenes Docker generadas. El repositorio se llamó test/jenkins con la URI public.ecr.aws/t6o5r2l4/test/jenkins.
+
+## 3. Instalar plugin AWS Credentials en Jenkins
+
+Para que Jenkins pueda interactuar con AWS, instalamos el plugin AWS Credentials. Este plugin facilita la configuración de credenciales de AWS en Jenkins y permite que las tareas de Jenkins puedan autenticarse con los servicios de AWS.
+
+## 4. Configurar la pipeline en Jenkins para hacer push a ECR
+
+Configuramos la pipeline en Jenkins para automatizar el proceso de construcción y despliegue. La pipeline hace lo siguiente:
+
+    Realiza un checkout del código del repositorio en GitHub.
+    Ejecuta Maven para construir el proyecto Spring Boot.
+    Construye una imagen Docker a partir del código generado.
+    Etiqueta y sube la imagen a Amazon ECR usando el comando docker push.
+
+El código de la pipeline en Jenkins se encuentra en el archivo pipeline_jenkins_to_docker y una explicación detallada de cada paso se encuentra en pipeline_explicación.
+Ejemplo de pipeline configurada en Jenkins:
+
+## 5. Verificar que se ha subido correctamente la imagen al repositorio de ECR
+
+Después de ejecutar la pipeline en Jenkins, verificamos que la imagen Docker se subiera correctamente al repositorio público de Amazon ECR.
+
+Pasos para verificar:
+
+    Ingresar a la consola de AWS.
+    Navegar hasta Amazon ECR.
+    Seleccionar el repositorio test/jenkins y comprobar que la imagen se subió correctamente con la etiqueta testjenkins-1.
+
+## 6. Crear un cluster en ECS
+
+Creamos un Cluster en Amazon ECS (Elastic Container Service) para gestionar las tareas de contenedores. En este caso, utilizaremos una configuración básica para asegurar que el servicio estuviera disponible y pudiera ser escalable.
+
+Pasos para crear el cluster:
+
+    Crear un nuevo Cluster seleccionando la opción adecuada (por ejemplo, Fargate si se utiliza sin instancias EC2) y asignando los parámetros básicos como nombre del cluster y tipo de red.
+
+## 7. Crear una tarea en ECS asignando el repositorio y la imagen
+
+Creamos una definición de tarea en ECS que asigna la imagen Docker desde ECR y configura los puertos para que el contenedor pueda recibir tráfico externo. La imagen se configuró con la etiqueta testjenkins-1 y el puerto 8080 fue expuesto, ya que la aplicación Spring Boot está configurada para ejecutarse en este puerto.
+
+Pasos para crear la tarea:
+
+    En ECS, crear una nueva Definición de Tarea.
+    Configurar el contenedor para usar la imagen de ECR y asignar el puerto 8080.
+    Crear un nuevo Task Definition con la imagen adecuada y las configuraciones necesarias.
+
+## 8. Crear un servicio en ECS, asignando la tarea, los puertos y habilitar los puertos en el VPC de Security
+
+Creamos un servicio en ECS utilizando la tarea definida previamente. Asignamos los puertos adecuados para asegurar que el tráfico entrante pueda acceder a la aplicación. Además, se habilitaron los puertos necesarios en el Security Group del VPC para asegurar el acceso público a la aplicación.
+
+Pasos para crear el servicio:
+
+    Crear un Servicio en ECS asociado a la tarea.
+    Configurar el Security Group para abrir el puerto 8080.
+    Seleccionar la VPC y las subredes adecuadas.
+
+## 9. Comprobación de despliegue correcto mediante IP pública
+
+Una vez desplegado el servicio, verificamos que la aplicación estuviera accesible mediante la IP pública asignada al servicio ECS.
+
+Pasos para verificar el despliegue:
+
+    Obtener la IP pública de la tarea en ECS.
+    Acceder a la aplicación desde un navegador utilizando la dirección http://<IP-pública>:8080.
+    Comprobar que la aplicación Spring Boot responde correctamente a las solicitudes.
+
+