Manual_Despliegue - iesgrancapitan-proyectos/202324ASIR-Junio-Microservices-and-CI-CD-Pipeline-Builder GitHub Wiki

Manual de Despliegue

脥ndice de contenidos

Introducci贸n

  1. Cloud 9

    1.1 Crear un repositorio de Git para el c贸digo de los microservicios y enviar el c贸digo a CodeCommit

    1.2 Modificaci贸n de archivos del cliente

    1.3 Crear Dockerfile del cliente e iniciar un contenedor de prueba

    1.4 Modificaci贸n de archivos de empleado

    1.5 Crear Dockerfile del empleado

  2. Creaci贸n de repositorio ECR, un cl煤ster de ECS, definiciones de tareas y archivos AppSpec

    2.1 Creaci贸n de repositorio ECR y cargar im谩genes de Docker

    2.2 Crear un cl煤ster de ECS

    2.3 Crear repositorio de CodeCommit para los archivos de implementaci贸n

    2.4 Crear archivos de definici贸n de tareas para cada microservicio y registrarlos en Amazon ECS

    2.5 Crear archivos AppSpec para CodeDeploy para cada microservicio

    2.6 Actualizar los archivos y enviarlos a CodeCommit

  3. Crear grupos de destino y un equilibrador de carga de aplicaci贸n

    3.1 Crear cuatro grupos de destino

    3.2 Crear un grupo de seguridad y un equilibrador de carga de aplicaci贸n y configurar reglas para enrutar el tr谩fico

  4. Crear dos servicios de Amazon ECS

    4.1 Crear el servicio ECS para el microservicio del cliente

    4.2 Crear el servicio ECS para el microservicio del empleado

  5. Configurar CodeDeploy y CodePipeline

    5.1 Crear una aplicaci贸n y grupos de implementaci贸n de CodeDeploy

    5.2 Crear una canalizaci贸n para el microservicio del cliente

    5.3 Probar la canalizaci贸n CI/CD para el microservicio del cliente

    5.4 Crear una canalizaci贸n para el microservicio del empleado

    5.5 Probar la canalizaci贸n CI/CD para el microservicio del empleado

  6. Ajustar el c贸digo de microservicio para hacer que la canalizaci贸n se ejecute de nuevo

    6.1 Limitar el acceso al microservicio del empleado

    6.2 Ajustar las UI para el microservicio del empleado y enviar las im谩genes actualizadas a Amazon ECR

    6.3 Probar el acceso al microservicio del empleado

    6.4 Escalar el microservicio del cliente

Introducci贸n

Partimos de una VPC ya creada llamada LabVPC, su bloque CIDR es 10.16.0.0/16, tiene dos zonas de disponibilidad a y b y tendr谩 2 subredes p煤blicas y 2 subredes privadas. Las subredes p煤blicas saldr谩n a Internet a trav茅s de una gateway de Internet.

Nombre de subred Bloque CIDR Zona de disponibilidad Tabla de enrrutamiento Gateway de Internet
PI-Publica1-A 10.16.10.0/24 us-east-1a PI-RT-Publica PI-igw
PI-Privada1-A 10.16.30.0/24 us-east-1a PI-RT-Privada1-A
PI-Publica2-B 10.16.20.0/24 us-east-1b PI-RT-Publica PI-igw
PI-Privada2-B 10.16.40.0/24 us-east-1b PI-RT-Privada2-B

Tambi茅n podemos ver el mapa de recursos.

VPC

1. Cloud9

Lo primero que necesitamos, es crear un entorno de Cloud9, y una vez creado entramos en el IDE.

1.1 Crear un repositorio de Git para el c贸digo de los microservicios y enviar el c贸digo a CodeCommit

  1. Una vez entramos, creamos una carpeta customer y otra employee y cargaremos los archivos de nuestra aplicaci贸n dentro de ambas carpetas.

  2. Creamos un repositorio de CodeCommit llamado microservices.

  3. Ejecutamos los siguientes comandos para iniciar el repositorio, crear una rama llamada dev, realizar el commit, a帽adir el repositorio remoto y enviar los archivos:

cd ~/environment/microservices
git init
git branch -m dev 
git add .
git commit -m 'copias sin modificar'
git remote add origin https://git-codecommit.us-east-1.amazonaws.com/v1/repos/microservices
git push -u origin dev

Ahora vamos a modificar el c贸digo de la aplicaci贸n para darle la funciones necesarias a cada microservicio.

1.2 Modificaci贸n de archivos del cliente

Primero empezaremos con el cliente, as铆 que en nuestra carpeta customer, realizaremos varias cosas.

  1. Editaremos el archivo customer/app/controller/supplier.controller.js y dejaremos solo el siguiente c贸digo.
const Supplier = require("../models/supplier.model.js");
 const {body, validationResult} = require("express-validator");

 exports.findAll = (req, res) => {
     Supplier.getAll((err, data) => {
         if (err)
             res.render("500", {message: "The was a problem retrieving the list of suppliers"});
         else res.render("supplier-list-all", {suppliers: data});
     });
 };

 exports.findOne = (req, res) => {
     Supplier.findById(req.params.id, (err, data) => {
         if (err) {
             if (err.kind === "not_found") {
                 res.status(404).send({
                     message: `Not found Supplier with id ${req.params.id}.`
                 });
             } else {
                 res.render("500", {message: `Error retrieving Supplier with id ${req.params.id}`});
             }
         } else res.render("supplier-update", {supplier: data});
     });
 };
  1. Editaremos el archivo cliente/aplicaci贸n/modelos/supplier.model.js quitando el resto de las funciones para que el cliente tenga solamente lectura, por lo que quedar铆a solamente Supplier.getAll y Supplier.findById.

  2. El siguiente paso, ser谩n unas modificaciones para personalizar la p谩gina del cliente. Modificamos el archivo customer/views/nav.html

  • En la l铆nea 3, cambiaremos "Monolithic Coffee suppliers" por "Coffee suppliers".
  • En la l铆nea 7, cambiaremos "Home" por "Customer home".
  • Agregaremos una nueva l铆nea despu茅s de la l铆nea 8, que contendr谩:
<a class="nav-link" href="/admin/suppliers">Administrator link</a>

Por lo que al final nos quedar铆a as铆 el archivo.

Implementaci贸n 1

  1. Para que los clientes no vean los botones de a帽adir proveedor ni de modificarlo, deberemos de hacer m谩s modificaciones en el archivo customer/views/supplier-list-all.html.
  • Eliminaremos la l铆nea 32, que contiene "Add a new supplier".
  • Eliminaremos las l铆neas 26 y 27, que contienen "badge badge-info" y "supplier-update". Este archivo tambi茅n quedar铆a tal que as铆.

Implementaci贸n 2

  1. Ahora tendremos que eliminar algunos archivos que ya no son necesarios ya que se utilizaban para las funciones adicionales que el cliente no tiene que tener visible y se encuentran en customer/views.
  • supplier-add.html
  • supplier-form-fields.html
  • supplier-update.html
  1. Por 煤ltimo, modificaremos el c贸digo del archivo index.js:
  • Comentaremos las l铆neas 27 a 37 poniendo // al principio.
  • En la l铆nea 45, cambiaremos el n煤mero de puerto a 8080.

1.3 Crear Dockerfile del cliente e iniciar un contenedor de prueba

  1. En la carpeta customer, crearemos el archivo "Dockerfile" que contendr谩 el siguiente c贸digo.
FROM node:11-alpine
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
COPY . .
RUN npm install
EXPOSE 8080
CMD ["npm", "run", "start"]
  1. Crearemos una imagen a partir del Dockerfile del cliente, ejecutando los siguientes comandos.
cd ~/environment/microservices/customer
docker build --tag customer .

Tras introducir los comandos deber铆a de decir que se ha creador correctamente y podremos verificar que se ha creado la imagen con el comando

docker image ls

Ya que saldr谩 el siguiente resultado.

Implementaci贸n 3

  1. Lo siguiente ser谩 iniciar el contenedor de Docker para que se ejecute el microservicio del cliente en el puerto 8080. Para ello tendremos que configurar una variable del punto de enlace de la RDS.
dbEndpoint=$(cat ~/environment/microservices/customer/app/config/config.js | grep 'APP_DB_HOST' | cut -d '"' -f2)

Ahora s铆 que iniciamos el contenedor Docker.

docker run -d --name customer_1 -p 8080:8080 -e APP_DB_HOST="$dbEndpoint" customer

Podemos comprobar que se ha ejecutado correctamente, ejecutando el comando para listar docker. docker ps

Implementaci贸n 4

Ahora si probamos a pegar la ip p煤blica de la instancia de Cloud9 seguido de ":8080", deber铆a de salir nuestra p谩gina para el cliente, y deber铆a poder listar los proveedores.

Implementaci贸n 5

  1. Por 煤ltimo ya solo nos quedar谩 hacer un git commit y git push para mandar los archivos actualizados a nuestro repositorio de CodeCommit, podemos comprobar que se ha realizado correctamente en el apartado Confirmaciones.

1.4 Modificaci贸n de archivos de empleado

Ahora nos tocar谩 modificar los archivos del microservicio del empleado.

  1. En el archivo employee/app/controller/supplier.controller.js, para todas las llamadas redirigidas, anteponga /admin a la ruta. Podemos encontrar las l铆nes ejecutando grep -n 'redirect' app/controller/supplier.controller.js en el directorio de empleado.

Implantaci贸n 6

Como se ve, la segunda vez que lo ejecuto, ya se ha cambiado el archivo.

  1. Tambi茅n deberemos anteponer /admin a todas las llamadas app.get y app.post del archivo index.js, que podremos buscar ejecutando grep -n 'app.get\|app.post' index.js. Adem谩s en la l铆nea 45, deberemos cambiar el puerto por 8081.

Implementaci贸n 7

  1. En los archivos employee/views/supplier-add.html y employee/views/supplier-update.html, para las rutas de acci贸n del formulario, antepondremos tambi茅n /admin a la ruta encontr谩ndolo con grep -n 'action' views/*

Implementaci贸n 8

  1. Seguiremos anteponiendo /admin en las rutas HTML de los archivos employee/views/supplier-list-all.html y employee/views/home.html. Ejecutamos grep -n 'href' views/supplier-list-all.html views/home.html para encontrarlo.

Implantaci贸n 9

  1. En el archivo employee/views/header.html, modificaremos el t铆tulo a Manage coffee suppliers.

  2. Ahora editaremos el archivo employee/views/nav.html.

  • En la l铆nea 3, cambie "Monolithic Coffee suppliers" por "Manage coffee suppliers".
  • En la l铆nea 7, reemplace la l铆nea de c贸digo existente por la siguiente: <a class="nav-link" href="/admin/suppliers">Administrator home</a>

Adem谩s a帽adiremos la siguiente l铆nea despu茅s de la l铆nea 8, <a class="nav-link" href="/">Customer home</a>.

Implementaci贸n 10

1.5 Crear Dockerfile del empleado

  1. Ahora nos tocar谩 crear el Dockerfile del empleado, por lo que copiaremos el del cliene y modificaremos el purto por 8081.

  2. Ahora creamos la imagen Docker con esta orden docker build --tag employee ..

Al acabar de ejecutarse podremos ver que se ha creado correctamente y la podremos listar con docker image ls.

Implementaci贸n 11

  1. Con la imagen lista, iniciaremos un contenedor Docker en el puerto 8081. Nota: Deberemos tener configurada la variable de la base e datos.

docker run -d --name employee_1 -p 8081:8081 -e APP_DB_HOST="$dbEndpoint" employee

Al igual que con el cliente, podremos poner en el navegador la ip p煤blica de la instancia Cloud9 precedidad de ":8081/admin/suppliers" y se nos mostrar谩 nuestar p谩gina de empleado.

Implementaci贸n 12

Comprobaremos que podemos a帽adir nuevos registros, modificar o eliminar los anteriores.

  1. Ahora, que hemos comprobado que funciona, haremos algunos ajustes para implementarlo en Amazon ECS y que funcione en el mismo puerto que el microservicio del cliente y volveremos a crear la imagen.
  • Editaremos los archivos employee/index.js y employee/Dockerfile, en los que cambiaremos el puerto a 8080.

  • Volveremos a crear la imagen Docker, por lo que ejecutaremos docker rm -f employee_1 para borrar el contenedor anterior y docker build --tag employee . para volver a crear la imagen.

Implementaci贸n 13

Para acabar con la modificaci贸n de la aplicaci贸n, haremos un git commit y git push para que se guarden las modificaciones de los archivos en el repositorio.

Implementaci贸n 14

2. Creaci贸n de repositorio ECR, un cl煤ster de ECS, definiciones de tareas y archivos AppSpec.

2.1 Creaci贸n de repositorio ECR y cargar im谩genes de Docker

  1. Primero vamos a autorizar al cliente Docker a conectarse al servicio Amazon ECR, ejecutando lo siguiente:
account_id=$(aws sts get-caller-identity |grep Account|cut -d '"' -f4)

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $account_id.dkr.ecr.us-east-1.amazonaws.com

Tras esto saldr谩 un mensaje de que el logueo ha sido correcto.

Implementaci贸n 15

  1. Ahora iremos al servicio ECR y crearemos un repositorio privada para empleado y otro para cliente. Al final deber铆a de salir as铆.

Implantaci贸n 16

  1. Editamos los permisos del repositorio ECR del cliente y del empleado en JSON y lo reemplazamos por lo siguiente:
{
  "Version": "2008-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": "*",
      "Action": "ecr:*"
    }
   ]
}
  1. Para m谩s simplicidad, etiquetaremos las im谩genes Docker con el Id de la cuenta, por lo que ejecutaremos lo siguiente en la terminal de Cloud9.
account_id=$(aws sts get-caller-identity |grep Account|cut -d '"' -f4)

docker tag customer:latest $account_id.dkr.ecr.us-east-1.amazonaws.com/customer:latest

docker tag employee:latest $account_id.dkr.ecr.us-east-1.amazonaws.com/employee:latest

Al realizar estos pasos podremos ver que al listar las im谩genes Docker con docker image ps se han etiquetado correctamente.

Implementaci贸n 17

  1. Lo siguiente ser谩 enviar las im谩genes Docker
docker push $account_id.dkr.ecr.us-east-1.amazonaws.com/customer:latest

docker push $account_id.dkr.ecr.us-east-1.amazonaws.com/employee:latest

Implementaci贸n 18

2.2 Crear un cl煤ster de ECS

En este paso, solo tendremos que ir al servicio ECS, y crearemos un nuevo cl煤ster.

  • Su nombre ser谩 "microservices-serverlesscluster".
  • En la secci贸n Infraestructura, marcamos "AWS Fargate (sin servidor)".

Tras crearlo podremos verlo en la interfaz.

Implementaci贸n 19

2.3 Crear repositorio de CodeCommit para los archivos de implementaci贸n

  1. Volveremos a ir al servicio CodeCommit y crearemos otro repositorio, se llamar谩 "deployment".

  2. Tambi茅n iremos a nuestro IDE de Cloud9, y a la altura de microservices, crearemos la carpeta deployment y lo iniciaremos como un repositorio git con una sucursal dev.

cd ~/environment/deployment
git init
git branch -m dev
git remote add origin https://git-codecommit.us-east-1.amazonaws.com/v1/repos/deployment

Implantaci贸n 20

2.4 Crear archivos de definici贸n de tareas para cada microservicio y registrarlos en Amazon ECS

  1. En la carpeta deployment, crearemos un archivo llamado "taskdef-customer.json" que contendr谩 el siguiente c贸digo:
{
    "containerDefinitions": [
        {
            "name": "customer",
            "image": "customer",
            "environment": [
                {
                    "name": "APP_DB_HOST",
                    "value": "<RDS-ENDPOINT>"
                }
            ],
            "essential": true,
            "portMappings": [
                {
                    "hostPort": 8080,
                    "protocol": "tcp",
                    "containerPort": 8080
                }
            ],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "awslogs-capstone",
                    "awslogs-region": "us-east-1",
                    "awslogs-stream-prefix": "awslogs-capstone"
                }
            }
        }
    ],
    "requiresCompatibilities": [
        "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "512",
    "memory": "1024",
    "executionRoleArn": "arn:aws:iam::<ACCOUNT-ID>:role/PipelineRole",
    "family": "customer-microservice"
}
  1. Modificaremos este archivo para :
  • En la l铆nea 37, reemplazaremos con el ID de la cuenta.
  • En la l铆nea 9, reemplazaremos con el punto de enlace de nuestra RDS.
  1. Ahora deberemos de ejecutar el siguiente comando para registrar la definici贸n de la tarea de microservicio del cliente en Amazon ECS.

aws ecs register-task-definition --cli-input-json "file:///home/ec2-user/environment/deployment/taskdef-customer.json"

Implementaci贸n 21

  1. Ahora crearemos el archivo de "taskdef-employee.json" tambi茅n en deployment y copiaremos el mismo c贸digo JSON de customer, para solamente cambiar donde aparezca customer por employee.

  2. Ejecutamos el mismo comando que para customer pero adaptado, para registrar la definici贸n de la tarea.

aws ecs register-task-definition --cli-input-json "file:///home/ec2-user/environment/deployment/taskdef-employee.json"

implementaci贸n 22

Podemos verificar que las tareas se han creado correctamente en la interfaz de Amazon ECS, en Definiciones de tareas.

Implementaci贸n 23

2.5 Crear archivos AppSpec para CodeDeploy para cada microservicio

  1. De nuevo en la carpeta deployment crearemos el archivo "appspec-customer.yaml" con el siguiente contenido:
version: 0.0
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: <TASK_DEFINITION>
        LoadBalancerInfo:
          ContainerName: "customer"
          ContainerPort: 8080
  1. Tambi茅n creamos el archivo "appspec-employee.yaml" con el mismo contenido pero cambiando customer por employee.

2.6 Actualizar los archivos y enviarlos a CodeCommit

  1. Modificamos el archivo taskdef-customer.json y taskdef-employee.json para que en la l铆nea 5 quede lo siguiente "image": "<IMAGE1_NAME>",.

  2. Enviamos los cambios a CodeCommit.

Implementaci贸n 24

3. Crear grupos de destino y un equilibrador de carga de aplicaci贸n

3.1 Crear cuatro grupos de destino

Vamos al servicio de EC, en el men煤 izquierdo, elegimos "Grupos de destino".

  1. Creamos el primer grupo de destino:
  • El tipo de destino ser谩 por Direcci贸n IP.
  • El nombre del grupo es "customer-tg-one".
  • El protocolo es HTTP en el puerto 8080.
  • Elegiremos nuestra VPC del proyecto y creamos el grupo.
  1. Con los mismos datos del primer grupo de destino creamos el segundo con el nombre "customer-tg-two".

Implantaci贸n 25

  1. Ahora crearemos los grupos de destino del empleado.
  • Los nombres ser谩n "employee-tg-one" y "employee-tg-two".
  • La ruta de comprobaci贸n de estado es /admin/suppliers.
  • Lo dem谩s igual que los anteriores grupos.

Todo quedar铆a as铆.

Implementaci贸n 26

3.2 Crear un grupo de seguridad y un equilibrador de carga de aplicaci贸n y configurar reglas para enrutar el tr谩fico

  1. Creamos un grupo de seguridad llamado "microservices-sg" con las reglas de entrada de los puertos 8080 y 80 desde cualquier IP.

Implementaci贸n 27

  1. Ahora crearemos un balanceador de carga de aplicaciones que se llame "microservicesLB".
  • Estar谩 expuetso a Internet.
  • Se crear谩 en la VPC del proyecto y utiliza las subredes p煤blicas 1 y 2.
  • El grupo de seguridad ser谩 el anteriormente creado, microservices-sg.
  • Tendr谩 dos agentes de escucha, uno con el puerto 80, que redirije el tr谩fico hacia el grupo "customer-tg-two" y otro con el puerto 8080 que redirije el tr谩fico hacia el grupo "customer-tg-one".
  1. Lo creamos, y una vez creado modificamos de nuevo los agentes de escucha.
  • En el agente del puerto 80, agregaremos una regla para que si el patr贸n es /admin/*, redirija el tr谩fico al grupo "employee-tg-two".

Implementaci贸n 28

  • En el agente del puerto 8080, agregamos otra regla para que si el patr贸n es /admin/*, redirija el tr谩fico al grupo "employee-tg-one".

Implementaci贸n 29

4. Crear dos servicios de Amazon ECS

4.1 Crear el servicio ECS para el microservicio del cliente

  1. En Cloud9, crearemos el archivo "create-customer-microservice-tg-two.json" en la carpeta deployment con el siguiente c贸digo.
{
    "taskDefinition": "customer-microservice:REVISION-NUMBER",
    "cluster": "microservices-serverlesscluster",
    "loadBalancers": [
        {
            "targetGroupArn": "MICROSERVICE-TG-TWO-ARN",
            "containerName": "customer",
            "containerPort": 8080
        }
    ],
    "desiredCount": 1,
    "launchType": "FARGATE",
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "CODE_DEPLOY"
    },
    "networkConfiguration": {
        "awsvpcConfiguration": {
            "subnets": [
                "PUBLIC-SUBNET-1-ID",
                "PUBLIC-SUBNET-2-ID"
            ],
            "securityGroups": [
                "SECURITY-GROUP-ID"
            ],
            "assignPublicIp": "ENABLED"
        }
    }
}
  1. Editaremos el archivo reemplazando algunas cosas:
  • Reemplazamos REVISION-NUMBER, por el n煤mero de la 煤ltima revisi贸n de la definici贸n de la tarea en Amazon ECS.
  • Reemplazamos MICROSERVICE-TG-TWO-ARN con el ARN del grupo de destino customer-tg-two.
  • Reemplazamos PUBLIC-SUBNET-1-ID con el ID de la subred p煤blica 1.
  • Reemplazamos PUBLIC-SUBNET-2-ID con el ID de la subred p煤blica 2.
  • Reemplazamos SECURITY-GROUP-ID con el ID del grupo de seguridad microservices-sg.

Implementaci贸n 30

  1. Para crear el servicio de Amazon ECS del cliente ejecutamos:
cd ~/environment/deployment
aws ecs create-service --service-name customer-microservice --cli-input-json file://create-customer-microservice-tg-two.json

Implementaci贸n 31

4.2 Crear el servicio ECS para el microservicio del empleado

  1. Haremos lo mismo para crear el servicio ECS para el empleado, creando el archivo "create-employee-microservice-tg-two.json" con el mismo c贸digo que el del cliente.

  2. Modificamos un poco el archivo para ajustarlo al microservicio del empleado:

  • En la l铆nea 2, cambie customer-microservice por employee-microservice.
  • En la l铆nea 6, ingrese el ARN del grupo de destino employee-tg-two.
  • En la l铆nea 7, cambie customer por employee.

Implementaci贸n 32

  1. Ejecutamos el comando para crear el servicio ECS del empleado:
cd ~/environment/deployment
aws ecs create-service --service-name employee-microservice --cli-input-json file://create-employee-microservice-tg-two.json

Implementaci贸n 33

Si vamos a la consola de Amazon ECS, podremos ver los servicios del cl煤ster creados.

Implementaci贸n 34

5. Configurar CodeDeploy y CodePipeline

5.1 Crear una aplicaci贸n y grupos de implementaci贸n de CodeDeploy

  1. Vamos al servicio CodeDeploy y creamos una aplicaci贸n con el nombre "microservices" utilizando Amazon ECS como plataforma inform谩tica.

Implementaci贸n 35

  1. Ahora vamos a crear los grupos de implementaci贸n en la aplicaci贸n microservices.
  • El primero se llamar谩 "microservices-customer".
  • El rol de servicio ser谩 DeployRole.
  • El nombre del cl煤ster ECS es "microservices-serverlesscluster".
  • El balanceador de carga es microservicesLB.
  • El puerto de agente de escucha de producci贸n es HTTP:80 y el de prueba, HTTP:8080.
  • Y los grupos de destino ser谩n "customer-tg-two" y "customer-tg-one". -Tambi茅n en la terminaci贸n de la revisi贸n original, tendremos que establecer 5 minutos.

Tambi茅n crearemos el otro grupo de implementaci贸n, cambiando:

  • El nombre ser谩 "microservices-employee".
  • El nombre del cl煤ster ECS ser谩 "employee-microservice".
  • Y los grupos de destino ser谩n "employee-tg-two" y "employee-tg-one".

Implementaci贸n 36

5.2 Crear una canalizaci贸n para el microservicio del cliente

  1. Nos iremos al servicio CodePipeline y empezaremos creando la canalizaci贸n del cliente.
  • Su nombre ser谩 "update-customer-microservice".
  • En cuanto al rol de servicio, elegiremos PipelineRole.
  • En la siguiente p谩gina elegiremos el origen del c贸digo que ser谩 CodeCommit y el repositorio ser谩 "deployment", en la ramificaci贸n dev.
  • El proveedor de implementaci贸n ser谩 Amazon ECS (green/blue).
  • El nombre de la aplicaci贸n es microservices y el grupo de implementaci贸n de CodeDeploy es microservices-customer.
  • En la definici贸n de tareas de ECS, elegimos SourceArtifact y a la derecha escribimos "taskdef-customer.json".
  • En el archivo de CodeDeploy AppSpec, tambi茅n elegiremos SourceArtifact y escribimos "appspec-customer.yaml".
  1. Crearemos la canalizaci贸n, y la editaremos.
  • Editaremos el apartado "Source" y agregamos una acci贸n nueva, con nombre "Image", el proveedor de la acci贸n es Amazon ECR, el nombre del repositorio "customer", la etiqueta de la imagen es "latest" y en artefactos de salida pondremos "image-customer".

Implementaci贸n 37

  • Tambi茅n modificamos el apartado "Deploy" en el que editamos la acci贸n ya creada y a帽adimos un nuevos artefacto de entrada, "image-customer" y seleccionamos este en "artefacto de entrada con detalles de imagen", escribiendo "IMAGE1_NAME" en el texto de marcador.

Implementaci贸n 38

Una vez hecho esto, guardaremos los cambios e iremos a las canalizaciones para seleccionarla y darle a "Cambio de versi贸n", con esto volver谩 a invocar la canalizaci贸n creando una nueva revisi贸n.

5.3 Probar la canalizaci贸n CI/CD para el microservicio del cliente

Cuando termine de invocarse la canalizaci贸n, podremos observar que todo ha salido correctamente.

Implementaci贸n 39

Implementaci贸n 40

Para probar su funcionamiento, copiaremos el DNS del balanceador y lo pondremos en el navegador, nos saldr谩 el home del cliente.

Implementaci贸n 41

Al darle a "List of suppliers", se mostrar谩n los proveedores.

Implementaci贸n 42

5.4 Crear una canalizaci贸n para el microservicio del empleado

Seguimos creando la canalizaci贸n del microservicio del empleado.

  1. Volvemos al servicio CodePipeline y la empezamos a crearla.
  • Su nombre ser谩 "update-employee-microservice".
  • En cuanto al rol de servicio, elegiremos PipelineRole.
  • En la siguiente p谩gina elegiremos el origen del c贸digo que ser谩 CodeCommit y el repositorio ser谩 "deployment", en la ramificaci贸n dev.
  • El proveedor de implementaci贸n ser谩 Amazon ECS (green/blue).
  • El nombre de la aplicaci贸n es microservices y el grupo de implementaci贸n de CodeDeploy es microservices-employee.
  • En la definici贸n de tareas de ECS, elegimos SourceArtifact y a la derecha escribimos "taskdef-employee.json".
  • En el archivo de CodeDeploy AppSpec, tambi茅n elegiremos SourceArtifact y escribimos "appspec-employee.yaml".
  1. Crearemos la canalizaci贸n, y la editaremos.
  • Editaremos el apartado "Source" y agregamos una acci贸n nueva, con nombre "Image", el proveedor de la acci贸n es Amazon ECR, el nombre del repositorio "employee", la etiqueta de la imagen es "latest" y en artefactos de salida pondremos "image-employee".

Implementaci贸n 43

  • Tambi茅n modificamos el apartado "Deploy" en el que editamos la acci贸n ya creada y a帽adimos un nuevos artefacto de entrada, "image-customer" y seleccionamos este en "artefacto de entrada con detalles de imagen", escribiendo "IMAGE1_NAME" en el texto de marcador.

Implementaci贸n 44

Una vez hecho esto, guardaremos los cambios e iremos a las canalizaciones para seleccionarla y darle a "Cambio de versi贸n", con esto volver谩 a invocar la canalizaci贸n creando una nueva revisi贸n.

5.5 Probar la canalizaci贸n CI/CD para el microservicio del empleado

Cuando termine de invocarse la canalizaci贸n,al igual que la del cliente, podremos observar que todo ha salido correctamente.

Implementaci贸n 45

Implementaci贸n 46

Para probar su funcionamiento, con la p谩gina que ya ten铆amos del cliente, le daremos a "Administrator link" y saldr谩 la p谩gina del empleado en la que se puede a帽adir, editar y borrar proveedores.

Implementaci贸n 47

Por lo que ahora la aplicaci贸n est谩 completa y podremos pasar desde la parte del cliente al del empleado y viceversa.

6. Ajustar el c贸digo de microservicio para hacer que la canalizaci贸n se ejecute de nuevo

6.1 Limitar el acceso al microservicio del empleado

  1. Confirmaremos que los grupos de destino siguen asociados al balanceador de carga, si no lo reasociaremos.

  2. Ahora en los agentes de escucha, tanto HTTP:80 como HTTP:8080, a帽adimos la segunda condici贸n, se enrrutar谩 al usuario a los grupos de destino s贸lo si la IP fuente de la solicitud es nuestra direcci贸n IP p煤blica que podremos comprobar en internet.

Implementaci贸n 48

6.2 Ajustar las UI para el microservicio del empleado y enviar las im谩genes actualizadas a Amazon ECR

  1. Para ajustar los microservicios implementados, modificaremos el archivo empleado/vistas/nav.html, en la l铆nea 1 cambiamos navbar-dark bg-dark por navbar-light bg-light.

  2. Volvemos a generar la imagen Docker.

docker build --tag employee .

dbEndpoint=$(cat ~/environment/microservices/employee/app/config/config.js | grep 'APP_DB_HOST' | cut -d '"' -f2)

account_id=$(aws sts get-caller-identity |grep Account|cut -d '"' -f4)

docker tag employee:latest $account_id.dkr.ecr.us-east-1.amazonaws.com/employee:latest
  1. Ahora enviamos la imagen actualizada a ECR.
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $account_id.dkr.ecr.us-east-1.amazonaws.com

docker push $account_id.dkr.ecr.us-east-1.amazonaws.com/employee:latest

La canalizaci贸n se invocar谩 y ejecutar谩, y en unos minutos terminar谩, podremos ver los detalles en la consola CodeDeploy.

Implantaci贸n 49

Cuando termine, probaremos a entrar y ver si ha cambiado la interfaz.

6.3 Probar el acceso al microservicio del empleado

Para probar el acceso al microservicio del empleado, iremos al navegador y pegaremos el enlace http://<alb-endpoint>/admin/suppliers usando el DNS de nuestro balanceador de carga.

Implementaci贸n 50

Implementaci贸n 51

Podremos comprobar que el t铆tulo de la p谩gina ahora es claro, aunque las p谩ginas alojadas por el microservicio del cliente siguen teniendo el banner oscuro lo que demuestra que, con una arquitectura de microservicios, se puede modificar de forma independiente la UI o las funciones de cada microservicio sin afectar a los dem谩s.

Tambi茅n probaremos el acceso desde otro dispositivo, deber铆a de aparecer un error 404, con esto comprobamos que no se puede conectar al microservicio de empleado desde otra direcci贸n IP.

Implementaci贸n 52

Sin embargo la parte del cliente si podemos visualizarla.

Implementaci贸n 53

6.4 Escalar el microservicio del cliente

En este punto con todo realizado, escalaremos verticalmente el n煤mero de contenedores que soportan el microservicio del cliente.

Ejecuataremos lo siguiente:

aws ecs update-service --cluster microservices-serverlesscluster --service customer-microservice --desired-count 3

Si vamos al servicio ECS, podremos ver lo que hemos hecho reflejado en Servicios, donde en el del cliente deber铆a ahora 3 tareas.

Implementaci贸n 54

Por lo que podr铆amos escalar a cualquier n煤mero de contenedores de ambos microservicios, lo que es nuestra finalidad.

FIINN

鈿狅笍 **GitHub.com Fallback** 鈿狅笍