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

En este artículo, exploraremos cómo AWS CloudFormation simplifica la configuración y oficina de la infraestructura de la nubarrón. En oficio de crear manualmente posibles 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.

Igualmente veremos cómo encajan Docker y GitHub Actions en el proceso. Estibador facilita empaquetar y ejecutar su aplicación, mientras que GitHub Actions automatiza tareas como pruebas e implementación. Anejo con CloudFormation, estas herramientas crean un poderoso flujo de trabajo para crear e implementar aplicaciones en la nubarrón.

Objetivos de educación

• Aprenda cómo simplificar la oficina de la infraestructura de la nubarrón 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 plan de muestra que automatiza la engendramiento de documentación de Python utilizando herramientas de inteligencia sintético 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 llevar la batuta posibles 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 nubarrón de AWS?

En el mundo de la computación en la nubarrón, mandar la infraestructura de guisa apto es crucial. Entonces, AWS CloudFormation entra en suceso, lo que facilita la configuración y oficina de sus posibles en la nubarrón. Le permite puntualizar todo lo que necesita: servidores, almacenamiento y redes en un archivo simple.

AWS CloudFormation es un servicio que le ayuda a puntualizar y llevar la batuta sus posibles en la nubarrón mediante plantillas escritas en YAML o JSON. Piense en ello como si estuviera creando un maniquí 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 nubarrón en poco que puede construir, recobrar 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.

Plan de muestraImplementación maña: un ejemplo de plan práctico

Simplificación de la documentación de código con IA: el plan de engendramiento de documentos:

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

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

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

En el mundo del incremento de software, la documentación juega un papel importante para respaldar que las bases de código sean comprensibles y mantenibles. Sin requisa, 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 plan en AWS usando CloudFormation, desarrollé un plan de automatización usando AI (Lang-Chain y Open AI GPT-4) para crear el Plan de engendramiento de documentos, una decisió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 utensilio y el impacto que pretende crear. Para crear este plan estamos siguiendo unos pocos pasos.

Ayer de comenzar un nuevo plan, debemos crear un entorno Python para instalar todos los paquetes necesarios. Esto nos ayudará a suministrar 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 próximo paso es introducirlos en el maniquí GPT-4 de OpenAI para originar 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:nn"
            "Function Name: {function_name}n"
            "Arguments: {arguments}n"
            "Docstring: {docstring}nn"
            "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 claro por humanos para cada función.

Integración de API de matraz

Para que la utensilio sea dócil de usar, creé una API de Flask donde los usuarios pueden cargar Pitón archivos. 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 realizar 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 acumular 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 rotar nuestros respectivos contenedores.

# Use the official Python 3.11-slim image as the almohadilla 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 ayer.

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

Creo un repositorio ECR. Párrafo de eso, realizaremos acciones de GitHub más delante 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 posibles.

En oficio de configurar servidores manualmente y conectar todo, AWS CloudFormation se utiliza para configurar y llevar la batuta posibles en la nubarrón (como servidores o bases de datos) automáticamente mediante un script. ¡Es como dar un plano para construir y organizar tus cosas en la nubarrón 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 plan.
• Extraiga las imágenes del contenedor del plan del repositorio de almacenamiento de ECR.
• Configure todas las demás dependencias y configuraciones necesarias para que se ejecute el plan.

Al utilizar esta configuración automatizada, no tengo que repetir los mismos pasos cada vez que implemento o actualizo el plan: 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 posibles y las configuraciones necesarias para configurar su infraestructura en AWS. Le permiten automatizar y mandar 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/locorregional/bin/docker-compose
          chmod +x /usr/locorregional/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 expediente 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 Orden de Seguridad para controlar el entrada a la red. Para esta configuración, abriremos:

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

Se utilizará una instancia t2.micro, y adentro del apartado Datos de Favorecido 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.

Transmitido 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 esencia Open AI en el archivo config.py. Pero no podemos expedir este archivo a GitHub, ya que contiene secretos. Entonces, usamos el administrador de secretos de AWS para acumular nuestros secretos y luego recuperarlos a través de nuestra plantilla de CloudFormation.

Hasta ahora hemos guardado secretos como la esencia Open AI en el archivo config.py. Pero no podemos expedir este archivo a GitHub, ya que contiene secretos. Entonces, usamos el administrador de secretos de AWS para acumular 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 autómata para que se encargue del trabajo repetitivo por usted!

Nuestra principal intención aquí es que a medida que avanzamos alrededor de 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 adicionar 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

A posteriori de acumular, crearemos una carpeta .github y, adentro de ella, una carpeta de flujos de trabajo. Interiormente 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 posibles 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 realizar que todo funcione acertadamente.

Conclusión

En este artículo, exploramos cómo utilizar AWS CloudFormation para simplificar la oficina de la infraestructura de la nubarrón. 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 igualmente garantiza coherencia y confiabilidad en las implementaciones.

Conclusiones esencia

• AWS CloudFormation simplifica la oficina de posibles en la nubarrón 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.