AWS CloudFormation: simplificación de las implementaciones en la nube

En este artículo, exploraremos cómo AWS CloudFormation simplifica la configuración y administración de la infraestructura de la nube. En lugar de crear manualmente recursos como servidores o bases de datos, puede escribir sus requisitos en un archivo y CloudFormation hará el trabajo pesado por usted. Este enfoque, conocido como Infraestructura como Código (IaC), ahorra tiempo, reduce los errores y garantiza que todo sea coherente.

También veremos cómo encajan Docker y GitHub Actions en el proceso. Docker facilita el empaquetado y la ejecución de su aplicación, mientras que GitHub Actions automatiza tareas como las pruebas y la implementación. Junto con CloudFormation, estas herramientas crean un poderoso flujo de trabajo para crear e implementar aplicaciones en la nube.

Objetivos de aprendizaje

• Aprenda cómo simplificar la administración de la infraestructura de la nube con AWS CloudFormation utilizando Infraestructura como código (IaC).
• Comprenda cómo Docker y GitHub Actions se integran con AWS CloudFormation para optimizar la implementación de aplicaciones.
• Explore un proyecto de muestra que automatiza la generación de documentación de Python utilizando herramientas de inteligencia artificial como LangChain y GPT-4.
• Aprenda a contener aplicaciones con Docker, automatizar la implementación con GitHub Actions e implementarla a través de AWS CloudFormation.
• Comprenda cómo configurar y administrar recursos de AWS como EC2, ECR y grupos de seguridad mediante plantillas de CloudFormation.

Este artículo fue publicado como parte del Blogatón de ciencia de datos.

¿Qué es la formación de la nube de AWS?

En el mundo de la computación en la nube, gestionar la infraestructura de manera eficiente es crucial. Entonces, AWS CloudFormation entra en escena, lo que facilita la configuración y administración de sus recursos en la nube. Le permite definir todo lo que necesita: servidores, almacenamiento y redes en un archivo simple.

AWS CloudFormation es un servicio que le ayuda a definir y administrar sus recursos en la nube mediante plantillas escritas en YAML o JSON. Piense en ello como si estuviera creando un modelo para su infraestructura. Una vez que entregue este plano, CloudFormation se encarga de configurar todo, paso a paso, exactamente como lo describió.

La infraestructura como código (IaC) es como convertir su nube en algo que puede construir, reconstruir e incluso mejorar con solo unas pocas líneas de código. No más clics manuales ni conjeturas: solo implementaciones consistentes y confiables que le ahorran tiempo y reducen los errores.

Proyecto de muestraImplementación práctica: un ejemplo de proyecto práctico

Simplificación de la documentación de código con IA: el proyecto de generación de documentos:

Para iniciar Cloud Formation, necesitamos un proyecto de muestra para implementarlo en AWS.

Ya creé un proyecto usando Lang-chain y OPEN ai GPT-4. Analicemos sobre ese proyecto y luego veremos cómo se implementa ese proyecto en AWS utilizando Cloud Formation.

Enlace del código de GitHub: https://github.com/Harshitha-GH/CloudFormation

En el mundo del desarrollo de software, la documentación juega un papel importante para garantizar que las bases de código sean comprensibles y mantenibles. Sin embargo, crear documentación detallada suele ser una tarea aburrida y que requiere mucho tiempo. Pero somos expertos en tecnología, queremos automatización en todo. Entonces, para implementar un proyecto en AWS usando CloudFormation, desarrollé un proyecto de automatización usando ai (Lang-Chain y Open ai GPT-4) para crear el Proyecto de generación de documentos, una solución innovadora que utiliza ai para automatizar el proceso de documentación para el código Python.

A continuación se muestra un desglose de cómo creamos esta herramienta y el impacto que pretende crear. Para crear este proyecto estamos siguiendo unos pocos pasos.

Antes de comenzar un nuevo proyecto, debemos crear un entorno Python para instalar todos los paquetes necesarios. Esto nos ayudará a mantener los paquetes necesarios.

Escribí una función para analizar el archivo de entrada, que normalmente toma un archivo de Python como entrada e imprime los nombres de todas las funciones.

Generando documentación a partir de código

Una vez que se extraen los detalles de la función, el siguiente paso es introducirlos en el modelo GPT-4 de OpenAI para generar documentación detallada. Usando Lang-Chain, construimos un mensaje que explica la tarea que queremos que realice GPT-4.

prompt_template = PromptTemplate(
        input_variables=("function_name", "arguments", "docstring"),
        template=(
            "Generate detailed documentation for the following Python function:\n\n"
            "Function Name: {function_name}\n"
            "Arguments: {arguments}\n"
            "Docstring: {docstring}\n\n"
            "Provide a clear description of what the function does, its parameters, and the return value."
        )
    )#import csv

Con la ayuda de este mensaje, la función Doc Generator toma los detalles analizados y genera una explicación completa y legible por humanos para cada función.

Integración de API de matraz

Para que la herramienta sea fácil de usar, creé una API Flask donde los usuarios pueden cargar archivos Python. La API analiza el archivo, genera la documentación utilizando GPT-4 y la devuelve en formato JSON.

Podemos probar esta API de Flask usando cartero para verificar nuestro resultado.

Dockerizando la aplicación

Para implementar en AWS y usar nuestra aplicación, necesitamos contener nuestra aplicación usando Docker y luego usar acciones de GitHub para automatizar el proceso de implementación. Usaremos AWS CloudFormation para la automatización en AWS. En cuanto al servicio, utilizaremos Elastic Container Registry para almacenar nuestros contenedores y EC2 para implementar nuestra aplicación. Veamos esto paso a paso.

Creación de Docker Compose

Crearemos el archivo Docker. El archivo Docker es responsable de hacer girar nuestros respectivos contenedores.

# Use the official Python 3.11-slim image as the base image
FROM python:3.11-slim

# Set environment variables to prevent Python from writing .pyc files and buffering output
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Set the working directory inside the container
WORKDIR /app

# Install system dependencies required for Python packages and clean up apt cache afterwards
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    libffi-dev \
    libpq-dev \
    python3-dev \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# Copy the requirements file to the working directory
COPY requirements.txt /app/

# Upgrade pip and install Python dependencies without cache
RUN pip install --no-cache-dir --upgrade pip && \
    pip install --no-cache-dir -r requirements.txt

# Copy the entire application code to the working directory
COPY . /app/

# Expose port 5000 for the application
EXPOSE 5000

# Run the application using Python
CMD ("python", "app.py")#import csv

Composición acoplable

Una vez que se crean los archivos Docker, crearemos un archivo de redacción Docker que activará el contenedor.

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    volumes:
      - .:/app
    environment:
      - PYTHONDONTWRITEBYTECODE=1
      - PYTHONUNBUFFERED=1
    command: ("python", "app.py")#import csv

Puedes probar esto ejecutando el comando

docker-compose up –build#import csv

Una vez que el comando se ejecute correctamente, el código funcionará exactamente como antes.

Creación de servicios de AWS para la pila de formación de nubes

Creo un repositorio ECR. Aparte de eso, realizaremos acciones de GitHub más adelante para crear todos los demás servicios necesarios.

El repositorio que he creado tiene el nombre del repositorio del espacio de nombres cloud_formation como demostración. Luego, procederé con la plantilla CloudFormation, un archivo yaml que ayuda a activar la instancia requerida, extrayendo las imágenes de ECR y otros recursos.

En lugar de configurar servidores manualmente y conectar todo, AWS CloudFormation se utiliza para configurar y administrar recursos en la nube (como servidores o bases de datos) automáticamente mediante un script. ¡Es como dar un plano para construir y organizar tus cosas en la nube sin hacerlo manualmente!

Piense en CloudFormation como si estuviera escribiendo un manual de instrucciones sencillo que AWS debe seguir. Este manual, denominado “plantilla”, le indica a AWS que:

• Inicie los servidores necesarios para el proyecto.
• Extraiga las imágenes del contenedor del proyecto del repositorio de almacenamiento de ECR.
• Configure todas las demás dependencias y configuraciones necesarias para que se ejecute el proyecto.

Al utilizar esta configuración automatizada, no tengo que repetir los mismos pasos cada vez que implemento o actualizo el proyecto: AWS lo hace todo automáticamente.

Plantilla de formación de nubes

Las plantillas de AWS CloudFormation son scripts JSON o YAML declarativos que describen los recursos y las configuraciones necesarias para configurar su infraestructura en AWS. Le permiten automatizar y gestionar su infraestructura como código, garantizando coherencia y repetibilidad en todos los entornos.

# CloudFormation Template
AWSTemplateFormatVersion: "2010-09-09"
Description: Deploy EC2 with Docker Compose pulling images from ECR

Resources:
  BackendECRRepository:
    Type: AWS::ECR::Repository
    Properties:
      RepositoryName: backend


  EC2InstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Roles:
        - !Ref EC2InstanceRole

  EC2InstanceRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service: ec2.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: ECROpsPolicy
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: Allow
                Action:
                  - ecr:GetAuthorizationToken
                  - ecr:BatchGetImage
                  - ecr:GetDownloadUrlForLayer
                Resource: "*"
        - PolicyName: SecretsManagerPolicy
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: Allow
                Action:
                  - secretsmanager:GetSecretValue
                Resource: "*"

  EC2SecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Allow SSH, HTTP, HTTPS, and application-specific ports
      SecurityGroupIngress:
        # SSH Access
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 0.0.0.0/0
        # Ping (ICMP)
        - IpProtocol: icmp
          FromPort: -1
          ToPort: -1
          CidrIp: 0.0.0.0/0
        # HTTP
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        # HTTPS
        - IpProtocol: tcp
          FromPort: 443
          ToPort: 443
          CidrIp: 0.0.0.0/0
        # Backend Port
        - IpProtocol: tcp
          FromPort: 5000
          ToPort: 5000
          CidrIp: 0.0.0.0/0

  EC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      InstanceType: t2.micro
      KeyName: demo
      ImageId: ami-0c02fb55956c7d316
      IamInstanceProfile: !Ref EC2InstanceProfile
      SecurityGroupIds:
        - !Ref EC2SecurityGroup
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash
          set -e  # Exit script on error
          yum update -y
          yum install docker git python3 -y
          pip3 install boto3
          service docker start
          usermod -aG docker ec2-user

          # Install Docker Compose
          curl -L "https://github.com/docker/compose/releases/download/$(curl -s https://api.github.com/repos/docker/compose/releases/latest | grep tag_name | cut -d '"' -f 4)/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
          chmod +x /usr/local/bin/docker-compose

          # Retrieve secrets from AWS Secrets Manager
          SECRET_NAME="backend-config"
          REGION="us-east-1"
          SECRET_JSON=$(aws secretsmanager get-secret-value --secret-id $SECRET_NAME --region $REGION --query SecretString --output text)
          echo "$SECRET_JSON" > /tmp/secrets.json

          # Create config.py dynamically
          mkdir -p /backend
          cat < /backend/config.py
          import json
          secrets = json.load(open('/tmp/secrets.json'))
          OPENAI_API_KEY = secrets("OPENAI_API_KEY")
          EOL

        

          # Authenticate with ECR
          aws ecr get-login-password --region ${AWS::Region} | docker login --username AWS --password-stdin ${AWS::AccountId}.dkr.ecr.${AWS::Region}.amazonaws.com

          # Pull images from ECR
          docker pull ${AWS::AccountId}.dkr.ecr.${AWS::Region}.amazonaws.com/personage/dodge-challenger:backend-latest

          # Create Docker Compose file
          cat < docker-compose.yml
          version: "3.9"
          services:
            backend:
              image: ${AWS::AccountId}.dkr.ecr.${AWS::Region}.amazonaws.com/personage/dodge-challenger:backend-latest
              ports:
                - "5000:5000"
              volumes:
                - /backend/config.py:/app/config.py
                - /tmp/secrets.json:/tmp/secrets.json
              environment:
                - PYTHONUNBUFFERED=1

            
          EOL

          # Start Docker Compose
          docker-compose -p demo up -d

Outputs:
  EC2PublicIP:
    Description: Public IP of the EC2 instance
    Value: !GetAtt EC2Instance.PublicIp#import csv

Decodifiquemos la plantilla actualizada paso a paso:

Estamos definiendo un único recurso ECR, que es el repositorio donde se almacena nuestra imagen de Docker.

A continuación, creamos una instancia EC2. Le adjuntaremos políticas esenciales, principalmente para interactuar con ECR y AWS Secrets Manager. Adicionalmente adjuntamos un Grupo de Seguridad para controlar el acceso a la red. Para esta configuración, abriremos:

• Puerto 22 para acceso SSH.
• Puerto 80 para acceso HTTP.
• Puerto 5000 para acceso a aplicaciones backend.

Se utilizará una instancia t2.micro, y dentro del apartado Datos de Usuario definimos las instrucciones para configurar la instancia:

• Instale las dependencias necesarias como Python, boto3 y Docker.
• Acceda a los secretos almacenados en AWS Secrets Manager y guárdelos en un archivo config.py.
• Inicie sesión en ECR, extraiga la imagen de Docker y ejecútela con Docker.

Dado que solo se utiliza un contenedor Docker, esta configuración simplifica el proceso de implementación y, al mismo tiempo, garantiza que el servicio backend sea accesible y esté configurado correctamente.

Carga y almacenamiento de secretos en AWS Secret Manager

Hasta ahora hemos guardado secretos como la clave Open ai en el archivo config.py. Pero no podemos enviar este archivo a GitHub, ya que contiene secretos. Entonces, usamos el administrador de secretos de AWS para almacenar nuestros secretos y luego recuperarlos a través de nuestra plantilla de CloudFormation.

Hasta ahora hemos guardado secretos como la clave Open ai en el archivo config.py. Pero no podemos enviar este archivo a GitHub, ya que contiene secretos. Entonces, usamos el administrador de secretos de AWS para almacenar nuestros secretos y luego recuperarlos a través de nuestra plantilla de CloudFormation.

Creando acciones de GitHub

GitHub Actions se utiliza para automatizar tareas como probar código, crear aplicaciones o implementar proyectos cada vez que realiza cambios. ¡Es como configurar un robot para que se encargue del trabajo repetitivo por usted!

Nuestra principal intención aquí es que a medida que avanzamos hacia una rama específica de github, automáticamente debería comenzar la implementación en AWS. Para ello seleccionaremos la rama 'principal'.

Almacenamiento de los secretos en GitHub

Inicie sesión en su github y siga la ruta a continuación:

repositorio > configuración > Secretos y variables > Acciones

Luego debe agregar sus secretos de AWS extraídos de su cuenta de AWS, como se muestra en la imagen a continuación.

Iniciando el flujo de trabajo

Después de almacenar, crearemos una carpeta .github y, dentro de ella, una carpeta de flujos de trabajo. Dentro de la carpeta de flujos de trabajo, agregaremos un archivo implementar.yaml.

name: Deploy to AWS

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      # Step 1: Checkout the repository
      - name: Checkout code
        uses: actions/checkout@v3
      
      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4 # Configure AWS credentials
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ secrets.AWS_REGION }}

      # Step 2: Log in to amazon ECR
      - name: Log in to amazon ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v2

      # Step 3: Build and Push Backend Image to ECR
      - name: Build and Push Backend Image
        run: |
          docker build -t backend .
          docker tag backend:latest ${{ secrets.AWS_ACCOUNT_ID }}.dkr.ecr.${{ secrets.AWS_REGION }}.amazonaws.com/personage/dodge-challenger:backend-latest
          docker push ${{ secrets.AWS_ACCOUNT_ID }}.dkr.ecr.${{ secrets.AWS_REGION }}.amazonaws.com/personage/dodge-challenger:backend-latest

      
      
      # Step 5: Delete Existing CloudFormation Stack
      - name: Delete Existing CloudFormation Stack
        run: |
          aws cloudformation delete-stack --stack-name docker-ecr-ec2-stack
          echo "Waiting for stack deletion to complete..."
          aws cloudformation wait stack-delete-complete --stack-name docker-ecr-ec2-stack || echo "Stack does not exist or already deleted."

      # Step 6: Deploy CloudFormation Stack
      - name: Deploy CloudFormation Stack
        uses: aws-actions/aws-cloudformation-github-deploy@v1
        with:
          name: docker-ecr-ec2-stack
          template: cloud-formation.yaml
          capabilities: CAPABILITY_NAMED_IAM

Aquí hay una explicación simplificada del flujo:

• Extraemos el código del repositorio y configuramos las credenciales de AWS utilizando los secretos almacenados en GitHub.
• Luego, iniciamos sesión en ECR y creamos/enviamos la imagen Docker de la aplicación.
• Verificamos si existe una pila de CloudFormation con el mismo nombre. En caso afirmativo, elimínelo.
• Finalmente, utilizamos la plantilla de CloudFormation para iniciar los recursos y configurar todo.

Pruebas

Una vez que todo esté implementado, anote la dirección IP de la instancia y luego llámela usando Postman para verificar que todo funcione bien.

Conclusión

En este artículo, exploramos cómo utilizar AWS CloudFormation para simplificar la administración de la infraestructura de la nube. Aprendimos cómo crear un repositorio ECR, implementar una aplicación Dockerizada en una instancia EC2 y automatizar todo el proceso usando GitHub Actions para CI/CD. Este enfoque no sólo ahorra tiempo sino que también garantiza coherencia y confiabilidad en las implementaciones.

Conclusiones clave

• AWS CloudFormation simplifica la administración de recursos en la nube con infraestructura como código.
• Los contenedores Docker agilizan la implementación de aplicaciones en la infraestructura administrada por AWS.
• GitHub Actions automatiza los procesos de construcción e implementación para una integración perfecta.
• LangChain y GPT-4 mejoran la automatización de la documentación de Python en proyectos.
• La combinación de IaC, Docker y CI/CD crea flujos de trabajo escalables, eficientes y modernos.

Preguntas frecuentes

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.