Proyectos en AWS

Crear una aplicación web moderna

Implemente una aplicación web, conéctese a una base de datos y analice el comportamiento del usuario

Módulo 2: Alojamiento de su aplicación en un servidor web

En este módulo, creará un nuevo microservicio alojado con AWS Fargate.  

Información general

En este módulo, creará un nuevo microservicio alojado con AWS Fargate, de manera que su sitio web Mythical Mysfits se pueda integrar con un backend de aplicaciones.

AWS Fargate es una opción de implementación de Amazon Elastic Container Service (ECS) que le permite implementar contenedores sin necesidad de administrar servidores ni clústeres. Para el backend de Mythical Mysfits, utilizaremos Python y crearemos una aplicación Flask en un contenedor de Docker detrás de un balanceador de carga de red. Así, se formará el backend del microservicio para el sitio web de frontend.

¿Por qué elegimos Fargate?

En este caso, elegimos Fargate, ya que es una excelente opción para llevar a cabo la creación de procesos de larga ejecución, tales como los backends de microservicios para las plataformas como servicio (PaaS), web y móviles. Con Fargate, podrá controlar los contenedores y tendrá la flexibilidad suficiente como para elegir cuándo deben ejecutarse, sin tener que preocuparse por aprovisionar ni escalar los servidores. Este servicio ofrece control total de la red, seguridad y comunicación de servicio a servicio. Está integrado de forma nativa con los servicios de AWS respecto a la seguridad, las redes, el control de acceso, las herramientas de los desarrolladores, el monitoreo y el registro.

Además de Fargate, los clientes también tienen la opción de utilizar AWS Lambda para cubrir sus necesidades informáticas. Si bien Lambda ofrece los mismos beneficios sin servidor que Fargate, Lambda es una excelente opción para las aplicaciones basadas en datos que necesitan responder en tiempo real a los cambios en los datos, las modificaciones en el estado del sistema o las acciones de los usuarios. En el módulo 5, analizaremos Lambda en más detalle, ya que lo utilizaremos para examinar el comportamiento de los clientes en el sitio.

Instrucciones de implementación

Siga las instrucciones paso a paso que se muestran a continuación para crear su servicio AWS Fargate. Debido al largo de este módulo, lo hemos dividido en 3 submódulos. En el módulo 2A, configurará la infraestructura principal como preparación para la implementación de su servicio. En el módulo 2B, implementará su servicio a través de AWS Fargate. Por último, en el módulo 2C, configurará la implementación automática a través de los servicios de código de AWS.

Módulo 2A: Configuración de la infraestructura principal

Antes de que podamos crear nuestro servicio, debemos crear el entorno de infraestructura principal que utilizará el servicio, incluida la infraestructura de redes en Amazon VPC y los roles de AWS Identity and Access Management que definirán los permisos que ECS y nuestros contenedores tendrán sobre AWS.

Utilizaremos AWS CloudFormation para lograrlo. AWS CloudFormation es un servicio que puede aprovisionar de forma programada los recursos de AWS que declare en sus archivos JSON o YAML, denominados plantillas de CloudFormation. De esta forma, permitirá que se cumpla la práctica recomendada común de la infraestructura como código.  

  • Proporcionamos una plantilla de CloudFormation para crear todos los recursos de red y seguridad necesarios en /module-2/cfn/core.yml. Esta plantilla creará los siguientes recursos:

    • Una Amazon VPC: un entorno de redes que contiene cuatro subredes (dos públicas y dos privadas) en el espacio IP privado 10.0.0.0/16, así como también todas las configuraciones de las tablas de enrutamiento. Las subredes de esta red se crean en zonas de disponibilidad (AZ) de AWS separadas a fin de permitir una alta disponibilidad en varias instalaciones físicas de una región de AWS. Obtenga más información acerca de cómo las zonas de disponibilidad pueden ayudarlo a lograr una alta disponibilidad.
    • Dos Gateways NAT (una para cada subred pública): permiten que los contenedores que eventualmente implementemos en nuestras subredes privadas se comuniquen con Internet a fin de descargar los paquetes necesarios, etc.
    • Un punto de enlace de la VPC de DynamoDB: nuestro backend de microservicio se integrará en algún momento con Amazon DynamoDB para lograr persistencia (como parte del módulo 3).
    • Un grupo de seguridad: permite a los contenedores de Docker recibir tráfico por el puerto 8080 desde Internet y a través del balanceador de carga de red.
    • Roles de IAM: se crean roles de Identity and Access Management. Estos recursos se utilizarán a lo largo del taller a fin de proporcionar acceso a los servicios o los recursos de AWS que usted cree a otros servicios de AWS, como DynamoDB, S3, entre otros.

    Para crear estos recursos, ejecute el siguiente comando en la terminal de Cloud9 (la creación de la pila tardará alrededor de 10 minutos):

    aws cloudformation create-stack --stack-name MythicalMysfitsCoreStack --capabilities CAPABILITY_NAMED_IAM --template-body file://~/environment/aws-modern-application-workshop/module-2/cfn/core.yml

    Puede comprobar el estado de la creación de su pila a través de la consola de AWS o ejecutando el comando:

    aws cloudformation describe-stacks --stack-name MythicalMysfitsCoreStack

    Ejecute el comando describe stacks hasta que vea el estado "StackStatus": "CREATE_COMPLETE"

    describe stacks

    (Haga clic para ampliar)

    Cuando reciba esta respuesta, CloudFormation habrá terminado de aprovisionar todos los recursos principales de red y seguridad descritos anteriormente, y podrá continuar. Antes de continuar, aguarde hasta que la pila anterior muestre el estado CREATE_COMPLETE.

    Utilizará valores del resultado de este comando en el resto del taller. Puede ejecutar el siguiente comando para enviar directamente el comando anterior describe-stacks a un nuevo archivo de su IDE, que se almacenará como cloudformation-core-output.json:

    aws cloudformation describe-stacks --stack-name MythicalMysfitsCoreStack > ~/environment/cloudformation-core-output.json

Módulo 2B: Implementación de un servicio con AWS Fargate

A continuación, creará una imagen de contenedor de Docker que comprende todos los códigos y las configuraciones necesarias para ejecutar el backend de Mythical Mysfits como una API de microservicio creada con Flask. Crearemos la imagen de contenedor de Docker dentro de Cloud9 y, luego, la enviaremos a Amazon Elastic Container Registry, en donde estará disponible para su extracción una vez que creemos nuestro servicio con Fargate.

Diagrama de la arquitectura

desde el navegador hacia el balanceador de carga hacia Fargate
  • A: Cree una imagen de Docker

    Todo el código que se requiere para ejecutar nuestro backend de servicio se almacena dentro del directorio /module-2/app/ del repositorio que clonó en su IDE de Cloud9. Si desea revisar el código Python que utiliza Flask para crear la API del servicio, vea el archivo /module-2/app/service/mythicalMysfitsService.py.

    Docker ya viene instalado en el IDE de Cloud9 que creó, por lo que para crear la imagen de Docker de forma local, todo lo que necesita hacer es ejecutar los siguientes dos comandos en la terminal de Cloud9:  

    En primer lugar, cambie de directorio a ~/environment/module-2/app

    cd ~/environment/aws-modern-application-workshop/module-2/app

    Puede obtener el ID de su cuenta y la región predeterminada del resultado del comando anterior de CloudFormation **describe-stacks

    Reemplace REPLACE_ME_ACCOUNT_ID por el ID de su cuenta y REPLACE_ME_REGION por su región predeterminada en el siguiente comando a fin de crear una imagen de Docker con el archivo Dockerfile, el cual contiene las instrucciones de Docker. A través de la opción -t, el comando etiqueta la imagen de Docker con un formato de etiqueta específico, de manera que la imagen luego se pueda enviar al servicio Amazon Elastic Container Registry.

    Una vez que tenga el ID de su cuenta, estará listo para crear la imagen de Docker:

    docker build . -t REPLACE_ME_AWS_ACCOUNT_ID.dkr.ecr.REPLACE_ME_REGION.amazonaws.com/mythicalmysfits/service:latest

    Verá que Docker descargará e instalará todos los paquetes de dependencias que necesite nuestra aplicación, y generará la etiqueta para la imagen creada. Copie la etiqueta de la imagen para referencias futuras. A continuación, la etiqueta de ejemplo que se muestra es 111111111111.dkr.ecr.us-east-1.amazonaws.com/mythicalmysfits/service:latest

    Successfully built 8bxxxxxxxxab
    Successfully tagged 111111111111.dkr.ecr.us-east-1.amazonaws.com/mythicalmysfits/service:latest
    B: Pruebe el servicio de forma local

    Probemos nuestra imagen de forma local dentro de Cloud9 para asegurarnos de que todo funciona según lo previsto. Copie la etiqueta de la imagen que resultó del comando anterior y ejecute el siguiente comando a fin de implementar el contenedor “de forma local” (el cual realmente se encuentra en su IDE de Cloud9 dentro de AWS):

    docker run -p 8080:8080 REPLACE_ME_WITH_DOCKER_IMAGE_TAG

    Como resultado, verá que Docker informa que su contenedor está activo y funciona de forma local:

     * Running on http://0.0.0.0:8080/ (Press CTRL+C to quit)

    Para probar nuestro servicio con una solicitud local, debemos abrir el navegador web integrado dentro del IDE de Cloud9 que se puede utilizar para obtener una vista previa de las aplicaciones que se ejecutan en la instancia de IDE.

    Para abrir el navegador web de vista previa, en la barra del menú de Cloud9, seleccione Vista previa > Vista previa de aplicaciones en funcionamiento:

    preview-menu

     

    Se abrirá otro panel en el IDE, en el cual estará disponible el navegador web. En la barra de direcciones del navegador de vista previa, agregue /mysfits al final del URI y presione INTRO:

    address-bar

    Si se realiza correctamente, verá una respuesta del servicio que le devolverá el documento JSON almacenado en `/aws-modern-application-workshop/module-2/app/service/mysfits-response.json`

    Cuando termine de evaluar el servicio, puede presionar CTRL-c, tanto en PC como en Mac, para detenerlo.

    C: Envíe la imagen de Docker a Amazon ECR

    Con una evaluación exitosa de su servicio a nivel local, estamos listos para crear un repositorio de imágenes de contenedor en Amazon Elastic Container Registry (Amazon ECR) y enviarle nuestra imagen. A fin de crear el registro, ejecute el siguiente comando, el cual creará un nuevo repositorio en el registro predeterminado de AWS ECR creado para su cuenta.

    aws ecr create-repository --repository-name mythicalmysfits/service

    La respuesta a este comando incluirá metadatos adicionales acerca del repositorio creado. Para enviar las imágenes de contenedor a nuestro nuevo repositorio, necesitaremos obtener las credenciales de autenticación de nuestro cliente de Docker para el repositorio.

    Ejecute el siguiente comando, el cual devolverá un comando de ingreso para recuperar las credenciales de nuestro cliente de Docker y, luego, lo ejecutará automáticamente (ingrese el comando completo, incluido el signo $ de abajo). Si el comando se ejecuta correctamente, se informará “Ingreso correcto”.

    $(aws ecr get-login --no-include-email)

    A continuación, envíe la imagen que creó al repositorio de ECR a través de la etiqueta copiada anteriormente. Si utiliza este comando, Docker enviará su imagen y todas las imágenes de las que dependa a Amazon ECR:

    docker push REPLACE_ME_WITH_DOCKER_IMAGE_TAG

    Ejecute el siguiente comando para visualizar la nueva imagen de Docker enviada, la cual se almacena en el repositorio de ECR:

    aws ecr describe-images --repository-name mythicalmysfits/service
  • A: Cree un clúster de AWS Fargate

    Ahora contamos con una imagen disponible en ECR que podemos implementar en un servicio alojado en Amazon ECS a través de AWS Fargate. El mismo servicio que probó de forma local a través de la terminal de Cloud9 como parte del último módulo ahora se implementará en la nube y estará a disposición del público detrás del balanceador de carga de red.

    En primer lugar, crearemos un clúster en Amazon Elastic Container Service (ECS). Este clúster representa el clúster de “servidores” en el que se implementarán sus contenedores de servicio. Servidores está “entre comillas” porque se utilizará AWS Fargate. Fargate le permite especificar que sus contenedores se implementarán en un clúster sin necesidad de aprovisionar ni administrar servidores usted mismo.

    Para crear un nuevo clúster en ECS, ejecute el siguiente comando:

    aws ecs create-cluster --cluster-name MythicalMysfits-Cluster
    B: Cree un grupo de AWS CloudWatch Logs

    A continuación, crearemos un nuevo grupo de registros en AWS CloudWatch Logs. AWS CloudWatch Logs es un servicio que se utiliza para la recopilación y el análisis de registros. Los registros que genere su contenedor se enviarán automáticamente a AWS CloudWatch Logs como parte de este grupo específico. Esto es fundamental cuando se utiliza AWS Fargate, ya que no tendrá acceso a la infraestructura del servidor en la que se están ejecutando sus contenedores.

    Para crear el nuevo grupo de CloudWatch Logs, ejecute el siguiente comando:

    aws logs create-log-group --log-group-name mythicalmysfits-logs
    C: Registre una definición de tarea de ECS

    Ahora que hemos creado un clúster y hemos definido un grupo de registros donde se enviarán los registros de nuestro contenedor, estamos listos para registrar una definición de tarea de ECS. En ECS, una tarea es un conjunto de imágenes de contenedor que se deben programar en conjunto. La definición de tarea establece el conjunto de contenedores, los recursos y las configuraciones que dichos contenedores necesitan. Utilizará la CLI de AWS para crear una nueva definición de la tarea y, de esta forma, determinará cómo se debe programar su nueva imagen de contenedor en el clúster de ECS que acabamos de crear.

    Se proporcionó un archivo JSON que servirá de entrada para el comando de la CLI.

    En el IDE, abra ~/environment/aws-modern-application-workshop/module-2/aws-cli/task-definition.json.

    Reemplace los valores indicados por los valores correspondientes a los recursos creados.

    Estos valores se extraerán de la respuesta de CloudFormation que copió anteriormente, así como también de la etiqueta de la imagen de Docker que envió antes a ECR, por ejemplo, REPLACE_ME_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/mythicalmysfits/service:latest

    Una vez que reemplace los valores en task-definition.json, guárdelo. Luego, ejecute el siguiente comando para registrar una nueva definición de tarea en ECS:

    aws ecs register-task-definition --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/task-definition.json
  • A: Cree un balanceador de carga de red

    Con una nueva definición de tarea registrada, estamos listos para aprovisionar la infraestructura necesaria en nuestra pila de servicio. En lugar de exponer directamente nuestro servicio a Internet, aprovisionaremos un balanceador de carga de red (NLB) para colocarlo en el frente del nivel de nuestro servicio. Esto permitiría que el código del sitio web de frontend se comunique con un único nombre de DNS, mientras nuestro servicio de backend está libre para escalar horizontal y verticalmente de manera elástica en función de la demanda o en caso de que se produzcan errores y sea necesario aprovisionar nuevos contenedores.

    Para aprovisionar un nuevo balanceador de carga de red, ejecute el siguiente comando de la CLI en la terminal de Cloud9 (recupere los ID de la subred del resultado de CloudFormation que guardó):

    aws elbv2 create-load-balancer --name mysfits-nlb --scheme internet-facing --type network --subnets REPLACE_ME_PUBLIC_SUBNET_ONE REPLACE_ME_PUBLIC_SUBNET_TWO > ~/environment/nlb-output.json

    Cuando este comando se complete correctamente, se creará un nuevo archivo en su IDE, denominado nlb-output.json. En los próximos pasos, utilizará DNSName, VpcId y LoadBalancerArn.

    B: Cree un grupo de destino para los balanceadores de cargas

    A continuación, utilice la CLI para crear un grupo de destino para los balanceadores de cargas de red. Un grupo de destino permite a los recursos de AWS registrarse como destinos para las solicitudes que el balanceador de carga reciba para reenviar. Nuestros contenedores de servicio se registrarán automáticamente en este destino para poder recibir el tráfico del balanceador de carga de red cuando sean aprovisionados. Este comando incluye un valor que deberá reemplazarse. Puede encontrar el valor vpc-id como un valor dentro del resultado MythicalMysfitsCoreStack que guardó anteriormente y que CloudFormation le devolvió.

    aws elbv2 create-target-group --name MythicalMysfits-TargetGroup --port 8080 --protocol TCP --target-type ip --vpc-id REPLACE_ME_VPC_ID --health-check-interval-seconds 10 --health-check-path / --health-check-protocol HTTP --healthy-threshold-count 3 --unhealthy-threshold-count 3 > ~/environment/target-group-output.json

    Cuando este comando se complete, su resultado se guardará en target-group-output.json en su IDE. En los pasos próximos, se tratará el valor TargetGroupArn.

    C: Cree un agente de escucha de balanceador de carga

    A continuación, utilice la CLI a fin de crear un agente de escucha de balanceador de carga para el balanceador de carga de red. Este agente de escucha informa al balanceador de carga que las solicitudes recibidas en un puerto específico deben reenviarse a los destinos que se hayan registrado en el grupo de destinos anterior. Asegúrese de reemplazar los dos valores indicados por los ARN apropiados del TargetGroup y del balanceador de carga de red que guardó en los pasos previos:

    aws elbv2 create-listener --default-actions TargetGroupArn=REPLACE_ME_NLB_TARGET_GROUP_ARN,Type=forward --load-balancer-arn REPLACE_ME_NLB_ARN --port 80 --protocol TCP
  • A: Cree un rol vinculado al servicio para ECS

    Si ya ha utilizado ECS antes, puede saltarse este paso y continuar con el siguiente. Si nunca ha utilizado ECS, necesitamos crear un **rol vinculado al servicio** en IAM que le otorgue al mismo servicio de ECS los permisos necesarios para efectuar las solicitudes a la API de ECS dentro de su cuenta. Esto es sumamente necesario, ya que cuando crea un servicio en ECS, dicho servicio llamará a las API dentro de su cuenta para realizar diferentes acciones, como extraer imágenes de Docker, crear nuevas tareas, etc.

    Si no crea este rol, el servicio de ECS no recibirá los permisos para llevar a cabo las acciones necesarias. Para crear el rol, ejecute el siguiente comando en la terminal:  

    aws iam create-service-linked-role --aws-service-name ecs.amazonaws.com

    Si el rol devuelve un error que indica que el rol ya existe, puede ignorarlo, ya que significa que el rol se creó automáticamente en su cuenta en el pasado.

    B: Cree el servicio

    Si el servicio de ECS ya cuenta con los permisos adecuados y su balanceador de carga de red ya está creado y configurado, estamos listos para crear el **servicio** de ECS en el cual se ejecutarán nuestros contenedores y se registrarán en el balanceador de carga a fin de recibir tráfico. Hemos incluido un archivo JSON para la entrada de la CLI, ubicada en `~/environment/aws-modern-application-workshop/module-2/aws-cli/service-definition.json`. Este archivo contiene todos los detalles de configuración para la creación del servicio, incluida la información que indica que este servicio se debe lanzar con **AWS Fargate**, lo que significa que no debe aprovisionar ningún servidor dentro del clúster de destino. Los contenedores que están programados como parte de la tarea utilizada en este servicio se ejecutarán sobre un clúster completamente administrado por AWS.

    En el IDE, abra ~/environment/aws-modern-application-workshop/module-2/aws-cli/service-definition.json y reemplace los valores indicados de REPLACE_ME. Guárdelo y, luego, ejecute el siguiente comando para crear el servicio:

    aws ecs create-service --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/service-definition.json
    C: Pruebe el servicio

    Copie el nombre de DNS que guardó durante la creación del balanceador de carga de red y envíele una solicitud mediante el navegador de vista previa de Cloud9 (o simplemente mediante cualquier navegador web, ya que esta vez, nuestro servicio está disponible en Internet). Intente enviar una solicitud al recurso de mysfits:

    http://mysfits-nlb-123456789-abc123456.elb.us-east-1.amazonaws.com/mysfits

    Recibir una respuesta que muestra la misma respuesta JSON que recibimos anteriormente cuando probamos el contenedor de Docker de forma local en Cloud9, significará que la API de Flask está activa y se ejecuta en AWS Fargate.

    Nota: Este balanceador de carga de red solo admite solicitudes HTTP (http://) debido a que no se ha instalado ningún certificado SSL/TLS en él. Para este tutorial, asegúrese de enviar únicamente solicitudes http://, ya que las solicitudes https:// no funcionarán de forma adecuada.

  • A: Reemplace el punto de enlace de la API

    A continuación, en lugar de utilizar los datos codificados de forma rígida que cargamos previamente en S3, debemos integrar nuestro sitio web con el nuevo backend de la API. Deberá actualizar el siguiente archivo a fin de utilizar el mismo URL del balanceador de carga de red para las llamadas a la API (no incluye la ruta /mysfits): /module-2/web/index.html

    Abra el archivo en Cloud9 y reemplace el área resaltada entre comillas con el URL del balanceador de carga de red:

    before-replace

    Luego de copiarlo, la línea debería lucir como se muestra a continuación:

    after-replace
    B: Cárguelo en S3

    Para cargar este archivo en su sitio web alojado en S3, utilice nuevamente el nombre del bucket que creó en el módulo , y ejecute el siguiente comando:

    aws s3 cp ~/environment/aws-modern-application-workshop/module-2/web/index.html s3://INSERT-YOUR-BUCKET-NAME/index.html

    Abra su sitio web con el mismo URL que utilizó al final del módulo 1, a fin de ver su nuevo sitio web Mythical Mysfits, el cual recupera los datos JSON de la API de Flask que se ejecuta dentro del contenedor de Docker implementado en AWS Fargate.

Módulo 2C: Automatización de las implementaciones con los servicios de código de AWS

Ahora que tiene un servicio activo y que funciona, puede pensar en los cambios de código que desea efectuar en su servicio de Flask. Si tuviera que seguir los mismos pasos cada vez que quiere implementar una nueva característica en su servicio, implicaría un cuello de botella para la velocidad de su desarrollo. En ese momento, la integración y la entrega continuas o CI/CD, respectivamente, entran en juego.

En este módulo, creará una pila de CI/CD completamente administrada que entregará de manera automática todos los cambios de código que realice en la base de código del servicio que creó en el último módulo.

Diagrama de la arquitectura

crear una arquitectura dinámica del sitio web - cloud9, herramientas de código, fargate
  • A: Cree un bucket de S3 para los artefactos de la canalización

    Necesitaremos crear otro bucket de S3 que se utilizará para almacenar los artefactos temporales que se creen en medio de las ejecuciones de nuestra canalización de CI/CD. Elija un nuevo nombre de bucket para estos artefactos y cree uno con el siguiente comando de la CLI:

    aws s3 mb s3://REPLACE_ME_CHOOSE_ARTIFACTS_BUCKET_NAME

    A continuación, este bucket necesita una política de bucket a fin de definir los permisos para los datos almacenados en él. Sin embargo, a diferencia de nuestro bucket de sitio web, el cual proporcionaba libre acceso a cualquiera, este bucket solo permitirá el acceso de nuestra canalización de CI/CD. Proporcionamos el archivo JSON necesario para esta política en ~/environment/aws-modern-application-workshop/module-2/aws-cli/artifacts-bucket-policy.json.

    Abra este archivo. En su interior, deberá reemplazar varias cadenas para incluir los ARN que se crearon anteriormente como parte de MythicalMysfitsCoreStack, así como también el nuevo nombre del bucket que haya elegido para los artefactos de CI/CD.

    Una vez que haya modificado y guardado este archivo, ejecute el siguiente comando para otorgarle a este bucket acceso a la canalización de CI/CD:

    aws s3api put-bucket-policy --bucket REPLACE_ME_ARTIFACTS_BUCKET_NAME --policy file://~/environment/aws-modern-application-workshop/module-2/aws-cli/artifacts-bucket-policy.json
    B: Cree un repositorio de CodeCommit

    Necesitará un lugar adonde enviar su código y donde almacenarlo. Para este propósito, cree un **repositorio de AWS CodeCommit** a través de la CLI:

    aws codecommit create-repository --repository-name MythicalMysfitsService-Repository
    C: Cree un proyecto de CodeBuild

    Si ya tiene un repositorio para almacenar nuestro código y un bucket de S3 que se utilizará para nuestros artefactos de CI/CD, agreguemos a la pila de CI/CD una forma de lograr la creación del servicio. Esto se puede lograr a través de la creación de un proyecto de AWS CodeBuild. Cuando se activa una ejecución de creación, AWS CodeBuild automáticamente aprovisiona un servidor de creación para nuestra configuración, y ejecuta los pasos necesarios para crear nuestra imagen de Docker y enviar una nueva versión al repositorio de ECR que creamos (y luego desactiva el servidor cuando se completa la creación).

    Los pasos para nuestra creación (que empaqueta nuestro código Python y crea/envía el contenedor de Docker) están incluidos en el archivo ~/environment/aws-modern-application-workshop/module-2/app/buildspec.yml. El archivo buildspec.yml es lo que usted crea para darle las instrucciones a CodeBuild con respecto a los pasos necesarios para llevar a cabo las ejecuciones de creación dentro de un proyecto de CodeBuild.

    Para crear un proyecto de CodeBuild, se debe actualizar otro archivo de entrada para la CLI con los parámetros específicos de sus recursos. Está ubicado en ~/environment/aws-modern-application-workshop/module-2/aws-cli/code-build-project.json. De la misma manera, reemplace los valores dentro de este archivo, como lo hizo antes desde MythicalMysfitsCoreStackOutput. Cuando lo haya guardado, ejecute el siguiente comando con la CLI para crear el proyecto:

    aws codebuild create-project --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/code-build-project.json
    D: Cree una canalización de CodePipeline

    Por último, necesitamos la forma de integrar de manera continua nuestro repositorio de CodeCommit con nuestro proyecto de CodeBuild, de modo que esas creaciones se realicen automáticamente cada vez que se envía un cambio de código al repositorio. Luego, necesitaremos la forma de entregar de manera continua esos artefactos recién creados en nuestro servicio de ECS. AWS CodePipeline es un servicio que une estas acciones en una canalización que creará a continuación.

    Su canalización en CodePipeline realizará solo lo descrito anteriormente. Cada vez que se envíe un cambio de código a nuestro repositorio de CodeCommit, CodePipeline entregará el último código a su proyecto de AWS CodeBuild para que se lleve a cabo la creación. Cuando CodeBuild haya efectuado la creación correctamente, CodePipeline llevará a cabo la implementación en ECS a través de la última imagen de contenedor que la ejecución de CodeBuild envió a ECR.

    Todos estos pasos se definen en un archivo JSON que le proporcionamos para que utilice como entrada a la CLI de AWS a fin de crear la canalización. Este archivo está ubicado en ~/environment/aws-modern-application-workshop/module-2/aws-cli/code-pipeline.json. Ábralo, reemplace los atributos necesarios y guárdelo.

    Una vez que lo haya guardado, cree una canalización en CodePipeline con el siguiente comando:

    aws codepipeline create-pipeline --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/code-pipeline.json
    E: Habilite el acceso automatizado al repositorio de imágenes de ECR

    Nos queda un último paso antes de que nuestra canalización de CI/CD pueda efectuar ejecuciones completas de forma correcta. Con una canalización de CI/CD, no tendremos que enviar imágenes de contenedor manualmente a ECR nunca más. Ahora, CodeBuild enviará las imágenes nuevas.

    Debemos otorgarle permiso a CodeBuild para que realice las acciones necesarias en el repositorio de imágenes con una política de repositorio de ECR*. El documento de la política se debe actualizar con el ARN específico para el rol de CodeBuild creado por MythicalMysfitsCoreStack. Este documento está ubicado en ~/environment/aws-modern-application-workshop/module-2/aws-cli/ecr-policy.json.

    Actualice y guarde este archivo; luego, ejecute el siguiente comando para crear la política:

    aws ecr set-repository-policy --repository-name mythicalmysfits/service --policy-text file://~/environment/aws-modern-application-workshop/module-2/aws-cli/ecr-policy.json

    Cuando se haya creado correctamente, tendrá una canalización de CI/CD completa y funcional para entregar los cambios de código de forma automática a su servicio de ECS.

  • A: Utilice Git con AWS CodeCommit

    Para probar la nueva canalización, debemos configurar Git dentro del IDE de Cloud9 e integrarlo con el repositorio de CodeCommit.

    AWS CodeCommit proporciona un asistente de credenciales para Git que utilizaremos para facilitar la integración.

    Ejecute los siguientes comandos en orden en la terminal para configurar Git, de forma que se pueda utilizar con AWS CodeCommit (si se ejecutan correctamente, ninguno de ellos generará una respuesta):

    git config --global user.name "REPLACE_ME_WITH_YOUR_NAME"
    git config --global user.email REPLACE_ME_WITH_YOUR_EMAIL@example.com
    git config --global credential.helper '!aws codecommit credential-helper $@'
    git config --global credential.UseHttpPath true

    A continuación, cambie los directorios en su IDE al directorio del entorno a través de la terminal:

    cd ~/environment/

    Ahora, ya estamos listos para clonar nuestro repositorio con el siguiente comando de terminal:

    git clone https://git-codecommit.REPLACE_REGION.amazonaws.com/v1/repos/MythicalMysfitsService-Repository

    Este comando nos informará que nuestro repositorio está vacío. Para solucionar esto, copiemos los archivos de la aplicación en el directorio de nuestro repositorio a través del siguiente comando:

    cp -r ~/environment/aws-modern-application-workshop/module-2/app/* ~/environment/MythicalMysfitsService-Repository/
    B: Envíe un cambio de código

    Ahora, el código completado del servicio que utilizamos para crear nuestro servicio de Fargate en el módulo 2 está almacenado en el repositorio local que acabamos de clonar desde AWS CodeCommit. Realicemos un cambio en el servicio de Flask antes de confirmar nuestros cambios para demostrar que la canalización de CI/CD que creamos funciona. En Cloud9, abra el archivo almacenado en ~/environment/MythicalMysfitsService-Repository/service/mysfits-response.json, cambie la edad de uno de los mysfits por otro valor y guarde el cambio.

    Luego de guardar el archivo, cambie los directorios al nuevo directorio de repositorio:

    cd ~/environment/MythicalMysfitsService-Repository/

    A continuación, ejecute los siguientes comandos de Git para enviar los cambios en su código.

    git add .
    git commit -m "I changed the age of one of the mysfits."
    git push

    Después de enviar el código al repositorio, puede abrir el servicio de CodePipeline en la consola de AWS para visualizar los cambios a medida que progresan a través de la canalización de CI/CD. Tras confirmar su cambio de código, la implementación de los cambios en su servicio en vivo que se ejecuta en Fargate tomará entre 5 a 10 minutos.

    Durante este tiempo, AWS CodePipeline dispondrá que se active una ejecución de la canalización cuando los cambios se hayan ingresado en el repositorio de CodeCommit, activará su proyecto de CodeBuild a fin de darle comienzo a una nueva creación, recuperará la imagen de Docker que CodeBuild envió a ECR y realizará una acción automatizada del servicio de actualización de ECS para habilitar el vaciado de las conexiones de los contenedores existentes que se ejecutan en su servicio y reemplazarlos por la imagen recientemente creada. Actualice su sitio web Mythical Mysfits en el navegador para ver si se han efectuado los cambios.

    Puede ver el progreso de los cambios de código a través de la consola de CodePipeline aquí (no necesita realizar ninguna acción, solo observe a la automatización en acción): AWS CodePipeline

    Con esto concluye el Módulo 2.

A continuación, se analizará el almacenamiento de los datos de mysfit.