AWS Review
English

Appearance

On this page

Ejercicio: Servicio CLI de Recomendación de Libros con AWS ​

Descripción del Escenario ​

Crearás un servicio CLI en Python para recomendar libros usando un dataset de más de 100,000 títulos de wonderbk.com. El servicio hará preguntas al usuario sobre sus preferencias de lectura (como género, autor o año de publicación) y generará recomendaciones basadas en estos criterios. El CLI interactuará con una base de datos en la nube para almacenar y consultar información de los libros.

La solución estará versionada utilizando AWS CodeCommit para el control de versiones, y usará AWS RDS como la base de datos recomendada por su escalabilidad y administración. Configurarás un pipeline de CI/CD en AWS para despliegue en ambientes dev y prod mediante AWS CodePipeline y AWS CodeBuild.

Estructura de Directorios ​

plaintext
book-recommender-cli/
├── data/
│   └── dataset.csv              # Archivo CSV con el dataset de libros
├── src/
│   ├── cli.py                   # Código principal del CLI
│   ├── recommender/
│   │   ├── __init__.py
│   │   ├── engine.py            # Lógica de recomendaciones
│   │   └── utils.py             # Funciones auxiliares para formateo y validación
│   ├── db/
│   │   ├── __init__.py
│   │   └── connector.py         # Conector para la base de datos RDS en AWS
├── infrastructure/
│   ├── templates/
│   │   ├── rds.yaml             # Plantilla de CloudFormation para AWS RDS
│   │   └── ci-cd-pipeline.yaml  # Plantilla de CI/CD para AWS CodePipeline y CodeBuild
├── scripts/
│   ├── load_data.py             # Script para cargar el dataset en la base de datos RDS
│   └── test_recommender.py      # Script para pruebas automatizadas del servicio CLI
├── tests/
│   ├── test_cli.py              # Pruebas unitarias del CLI
│   └── test_engine.py           # Pruebas unitarias del motor de recomendaciones
├── .codebuild/
│   └── buildspec.yml            # Especificación de build para CodeBuild
├── .gitignore
└── README.md                    # Documentación del proyecto

Etapa 1: Configuración de AWS CodeCommit para Control de Versiones ​

  1. Crea un repositorio en AWS CodeCommit:

    • En la consola de AWS CodeCommit, selecciona Create repository y nómbralo book-recommender-cli.
    • Inicializa el repositorio localmente, agrega los archivos del proyecto y realiza el primer commit.

  2. Configuración Local de CodeCommit:

    • Configura AWS CLI en tu máquina y agrega la URL de CodeCommit como un remoto de Git.
    • Sube los cambios iniciales al repositorio.

Etapa 2: Configuración de AWS RDS para Almacenar el Dataset ​

  1. Crea un clúster de RDS en MySQL o PostgreSQL usando CloudFormation y la plantilla rds.yaml:

    • Personaliza el archivo rds.yaml en infrastructure/templates/ para definir el tipo de instancia, el nombre de la base de datos y las configuraciones de red.
    • Ejecuta el comando de AWS CLI para crear el stack:
      bash
      aws cloudformation create-stack --stack-name rds-stack --template-body file://infrastructure/templates/rds.yaml --capabilities CAPABILITY_NAMED_IAM

  2. Conexión a RDS:

    • Configura la conexión en connector.py dentro de src/db/, con parámetros de conexión (endpoint, usuario, y contraseña) obtenidos de RDS.

Etapa 3: Carga de Datos en la Base de Datos ​

  1. Transformación de Datos:

    • Usa pandas para procesar y formatear el CSV en load_data.py.
    • Estructura las columnas en SQL y valida los tipos de datos (por ejemplo, convertir fechas y precios).

  2. Carga del Dataset:

    • Inserta los datos en RDS usando load_data.py para conectarse al RDS y cargar el dataset.
    • Ejecuta:
      bash
      python scripts/load_data.py

Etapa 4: Implementación del Servicio CLI en Python ​

  1. Diseño de la Interfaz CLI:

    • En cli.py, implementa la lógica para interactuar con el usuario y obtener sus preferencias (por ejemplo, género, autor, año de publicación).

  2. Integración del Motor de Recomendaciones:

    • En engine.py, utiliza filtros basados en las respuestas del usuario para realizar consultas SQL en RDS y devolver una lista de recomendaciones.

  3. Salida de Recomendaciones:

    • Imprime las recomendaciones en un formato amigable y agrega la opción para ver más detalles de cada libro (por ejemplo, precio, descripción).

Etapa 5: Configuración de CI/CD en AWS con CodePipeline y CodeBuild ​

  1. Plantilla de CI/CD con CloudFormation:

    • Usa el archivo ci-cd-pipeline.yaml para configurar un pipeline en AWS que se active con cada cambio en CodeCommit.

  2. Configurar CodeBuild:

    • Define el archivo buildspec.yml en la carpeta .codebuild/ para las pruebas y el despliegue.
    • En el buildspec.yml, incluye comandos para instalar dependencias, ejecutar pruebas y desplegar el CLI en el entorno correspondiente.

  3. Ejecución del Pipeline:

    • Ejecuta el pipeline y verifica que el despliegue y pruebas se completen exitosamente.

Etapa 6: Despliegue en Entornos Dev y Prod ​

  1. Separación de Entornos:

    • Configura variables de entorno en CodePipeline para diferenciar entre dev y prod, tales como el endpoint y credenciales de RDS.

  2. Pruebas en Dev:

    • En el pipeline, configura una etapa de pruebas para el entorno de desarrollo (usando test_recommender.py).
    • Si las pruebas pasan, el pipeline automáticamente aprueba el despliegue a prod.

  3. Revisión en Prod:

    • Verifica que la versión desplegada en prod esté accesible y funcionando sin problemas.

Etapa 7: Pruebas y Validación del CLI ​

  1. Pruebas Unitarias en el CLI:

    • En test_cli.py, implementa pruebas que simulen la interacción del usuario y validen la respuesta del CLI.

  2. Pruebas del Motor de Recomendación:

    • En test_engine.py, agrega casos de prueba para verificar que el motor de recomendaciones devuelva resultados precisos.

  3. Ejecución de Pruebas Automáticas:

    • Ejecuta las pruebas con pytest desde CodeBuild como parte del pipeline, para validar cada cambio antes de su despliegue.

Etapa 8: Documentación y Mejoras ​

  1. Documentación en README.md:

    • Explica el funcionamiento del CLI, la configuración inicial del entorno, cómo ejecutar el CLI, y cómo personalizar las preferencias de lectura.

  2. Mejoras Futuras:

    • Incluye sugerencias para mejoras, como el uso de aprendizaje automático para recomendaciones más precisas o el soporte de nuevos géneros.

  3. Limpieza de Recursos:

    • Documenta cómo eliminar recursos en AWS, incluidos RDS y CodePipeline, para evitar cargos innecesarios.

Con esta estructura y etapas, el CLI de recomendaciones de libros estará listo y desplegado en AWS con control de versiones, pipeline CI/CD, y soporte para ambientes dev y prod.

En la Etapa 2: Configuración de AWS RDS para Almacenar el Dataset, configuraremos una base de datos en AWS RDS que almacenará la información del dataset de libros para que el servicio CLI pueda realizar consultas de manera eficiente. Utilizaremos CloudFormation para crear la infraestructura de base de datos de forma automatizada, permitiendo una gestión escalable y segura.

Etapa 2: Configuración de AWS RDS para Almacenar el Dataset ​

Paso 1: Configuración del Archivo CloudFormation para AWS RDS ​

  1. Crea el archivo rds.yaml en la carpeta infrastructure/templates/ y configura los detalles de RDS. Para este proyecto, usaremos Amazon RDS con MySQL o PostgreSQL, ya que ambos son populares, escalables y compatibles con consultas SQL para el dataset de libros.

Ejemplo de archivo rds.yaml para crear un clúster RDS MySQL en modo Multi-AZ:

yaml
Resources:
  BookRecommenderDBCluster:
    Type: AWS::RDS::DBInstance
    Properties:
      DBInstanceIdentifier: book-recommender-db
      DBInstanceClass: db.t3.micro
      Engine: mysql
      AllocatedStorage: 20
      MasterUsername: !Ref DBUsername
      MasterUserPassword: !Ref DBPassword
      DBName: bookdb
      BackupRetentionPeriod: 7
      MultiAZ: true
      VPCSecurityGroups:
        - sg-<security-group-id>    # Security Group previamente configurado para permitir el acceso al clúster EKS

Parameters:
  DBUsername:
    Type: String
    Description: "Nombre de usuario de la base de datos"
    Default: "admin"

  DBPassword:
    Type: String
    Description: "Contraseña de la base de datos"
    NoEcho: true

Nota: Ajusta el parámetro VPCSecurityGroups para incluir el ID de un grupo de seguridad que permita la conectividad desde el clúster de EKS o tu IP de desarrollo.

Paso 2: Crear el Clúster RDS en AWS ​

  1. Lanza el stack de CloudFormation usando el archivo rds.yaml:

    bash
    aws cloudformation create-stack --stack-name rds-stack --template-body file://infrastructure/templates/rds.yaml --capabilities CAPABILITY_NAMED_IAM

  2. Verifica el estado del stack en la consola de CloudFormation para asegurarte de que se haya creado correctamente. Una vez listo, obtén los detalles del clúster RDS desde la consola de RDS.

Paso 3: Configuración de Seguridad en AWS RDS ​

Para permitir el acceso a la base de datos desde el servicio CLI en Kubernetes, asegúrate de que la instancia de RDS tenga configurado el Security Group adecuado.

  1. Edita el Security Group asociado a RDS:

    • Permite el tráfico entrante desde las IPs de los nodos de EKS o desde una VPC Peering si es necesario.

  2. Obtén el endpoint de RDS desde la consola de RDS, ya que será necesario para configurar el archivo de conexión en el servicio CLI.

Paso 4: Configuración de Conexión a la Base de Datos en el Código ​

En el archivo connector.py dentro de src/db/, configura la conexión a la base de datos RDS utilizando los detalles obtenidos en los pasos anteriores.

Ejemplo de connector.py:

python
import mysql.connector
from mysql.connector import Error

def create_connection():
    try:
        connection = mysql.connector.connect(
            host="<RDS_ENDPOINT>",       # Endpoint de RDS obtenido de la consola
            database="bookdb",
            user="admin",
            password="<DB_PASSWORD>",    # Contraseña definida en el parámetro de CloudFormation
        )
        if connection.is_connected():
            print("Conexión exitosa a la base de datos")
        return connection
    except Error as e:
        print("Error al conectar con la base de datos", e)
        return None

Paso 5: Pruebas de Conexión a RDS ​

Antes de cargar el dataset, realiza pruebas de conexión a la base de datos para verificar que el acceso funcione correctamente desde el entorno de desarrollo.

  1. Ejecuta el siguiente comando en tu entorno local para probar la conexión:

    bash
    python -c 'from src.db.connector import create_connection; create_connection()'

  2. Verifica que el mensaje indique que la conexión fue exitosa. Si hay problemas, revisa las configuraciones del Security Group o la contraseña de conexión.

Paso 6: Documentación en README.md ​

Documenta en README.md el proceso de configuración de AWS RDS, incluyendo:

  • Creación de RDS usando el archivo rds.yaml en CloudFormation.
  • Configuración de Seguridad del Security Group para permitir el acceso desde el clúster EKS.
  • Pruebas de Conexión al clúster RDS usando el script de conexión en Python.

Ejemplo de documentación en README.md:

markdown
## Etapa 2: Configuración de AWS RDS para Almacenar el Dataset

Este proyecto utiliza **Amazon RDS** con MySQL como base de datos para almacenar y consultar el dataset de libros.

### Creación de la Base de Datos

1. En la carpeta `infrastructure/templates/`, configura el archivo `rds.yaml` para definir el clúster RDS.
2. Ejecuta el siguiente comando para crear el stack en AWS CloudFormation:
   ```bash
   aws cloudformation create-stack --stack-name rds-stack --template-body file://infrastructure/templates/rds.yaml --capabilities CAPABILITY_NAMED_IAM

Configuración de Seguridad ​

  • Configura el Security Group asociado a la instancia RDS para permitir acceso desde los nodos de EKS.
  • Obtén el endpoint de la base de datos desde la consola de RDS.

Pruebas de Conexión ​

  1. Configura los detalles de conexión en src/db/connector.py.
  2. Prueba la conexión a la base de datos:
    bash
    python -c 'from src.db.connector import create_connection; create_connection()'

Si la conexión es exitosa, la base de datos estará lista para recibir datos.

---

Con la base de datos configurada y accesible, estás listo para proceder a la **Etapa 3: Carga de Datos en la Base de Datos**, donde cargaremos el dataset de libros en RDS y lo prepararemos para el servicio de recomendaciones. 



Para completar la **Etapa 2**, incluiremos detalles adicionales para configurar completamente la base de datos en RDS, asegurando una conectividad robusta desde el servicio CLI y estableciendo un esquema SQL para almacenar los datos del dataset.

---

### Continuación de la Etapa 2: Configuración Completa de AWS RDS

#### Paso 7: Definición del Esquema de la Base de Datos

Para almacenar el dataset de libros en RDS, necesitas definir un esquema SQL que coincida con las columnas del archivo CSV. Basándonos en la estructura del dataset, crea una tabla en la base de datos.

1. **Definición del esquema de la tabla**:
   - Crea un archivo `schema.sql` en la carpeta `scripts/` para definir la estructura de la tabla `books` en RDS.

Ejemplo de `schema.sql`:

```sql
CREATE TABLE IF NOT EXISTS books (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255),
    authors VARCHAR(255),
    description TEXT,
    category VARCHAR(100),
    publisher VARCHAR(100),
    price_starting DECIMAL(10, 2),
    publish_month INT,
    publish_year INT
);

Este esquema corresponde a las columnas del dataset:

  • title: título del libro
  • authors: autores
  • description: descripción
  • category: categoría o género
  • publisher: editorial
  • price_starting: precio inicial
  • publish_month y publish_year: fecha de publicación
  1. Ejecución del archivo SQL en RDS:

    • Usa el script schema.sql para crear la tabla en RDS.

    • Desde la línea de comandos, conecta a la base de datos de RDS y ejecuta el archivo:

      bash
      mysql -h <RDS_ENDPOINT> -u admin -p bookdb < scripts/schema.sql

Paso 8: Configuración de Permisos y Seguridad Adicional en RDS ​

Para proteger la base de datos, asegúrate de que las configuraciones de seguridad están correctamente aplicadas.

  1. Configura las políticas de acceso de RDS:

    • En AWS IAM, crea una política de acceso personalizada para RDS, si es necesario, y así restringir las operaciones a las instancias y usuarios específicos que necesiten acceso.

  2. Pruebas de Conectividad con Roles y Seguridad:

    • Usa connector.py en el CLI para verificar que los permisos y configuraciones de seguridad sean correctos.
    • En caso de problemas de conexión, verifica las políticas en Security Groups o revisa las reglas de IAM.

Paso 9: Carga del Dataset en la Base de Datos ​

  1. Script de Carga de Datos:
    • Crea un script llamado load_data.py en scripts/ para cargar el dataset en la tabla books de RDS.
    • Este script leerá el archivo CSV, transformará los datos si es necesario y los insertará en RDS.

Ejemplo de load_data.py:

python
import pandas as pd
import mysql.connector
from src.db.connector import create_connection

def load_books_to_db(csv_file):
    # Cargar el dataset
    df = pd.read_csv(csv_file)
    connection = create_connection()

    if connection.is_connected():
        cursor = connection.cursor()
        for _, row in df.iterrows():
            cursor.execute("""
                INSERT INTO books (title, authors, description, category, publisher, price_starting, publish_month, publish_year)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
            """, (
                row['Title'],
                row['Authors'],
                row['Description'],
                row['Category'],
                row['Publisher'],
                row['Price Starting With ($)'],
                row['Publish Date (Month)'],
                row['Publish Date (Year)']
            ))
        connection.commit()
        cursor.close()
        connection.close()
        print("Datos cargados exitosamente en la base de datos")

if __name__ == "__main__":
    load_books_to_db("data/dataset.csv")

  1. Ejecución del Script de Carga de Datos:

    • Ejecuta el script para cargar el archivo CSV en RDS:

      bash
      python scripts/load_data.py

  2. Verificación de la Carga de Datos:

    • Conéctate a la base de datos y verifica que los datos estén presentes en la tabla books:

      sql
      SELECT COUNT(*) FROM books;

Paso 10: Documentación Completa en README.md ​

Actualiza el archivo README.md para incluir la configuración detallada de RDS, el esquema SQL y los pasos para cargar el dataset.

Ejemplo de documentación:

markdown
## Etapa 2: Configuración de AWS RDS para Almacenar el Dataset

### Creación de la Base de Datos en AWS RDS

1. En `infrastructure/templates/`, utiliza el archivo `rds.yaml` para definir el clúster RDS y ejecuta:
   ```bash
   aws cloudformation create-stack --stack-name rds-stack --template-body file://infrastructure/templates/rds.yaml --capabilities CAPABILITY_NAMED_IAM
  1. Asegúrate de que el Security Group permita el acceso desde el clúster de EKS o tu máquina local.

Configuración del Esquema de la Base de Datos ​

  1. Define el esquema SQL en scripts/schema.sql para crear la tabla books.
  2. Crea la tabla ejecutando el esquema SQL:
    bash
    mysql -h <RDS_ENDPOINT> -u admin -p bookdb < scripts/schema.sql

Carga de Datos ​

  1. Ejecuta el script de carga de datos:
    bash
    python scripts/load_data.py
  2. Verifica que los datos estén en la base de datos:
    sql
    SELECT COUNT(*) FROM books;

Ahora los datos están disponibles en la base de datos RDS y listos para ser utilizados en el servicio CLI.

Con estos pasos, la base de datos en AWS RDS está completamente configurada, el esquema está definido, y el dataset está cargado y listo para consultas. La siguiente sería la Etapa 3: Carga de Datos en la Base de Datos para continuar trabajando con los datos en el servicio CLI.

La Etapa 3: Carga de Datos en la Base de Datos implica cargar el dataset de libros en la base de datos RDS configurada en la etapa anterior. Este paso se asegurará de que los datos están disponibles y accesibles para consultas cuando el servicio CLI busque recomendaciones.

Etapa 3: Carga de Datos en la Base de Datos ​

Para cargar el dataset de libros en la tabla books de RDS, usaremos el script load_data.py. Este script realizará una carga masiva de datos desde el archivo CSV dataset.csv y los insertará en la base de datos de RDS.

Paso 1: Revisión del Script de Carga de Datos (load_data.py) ​

En el archivo load_data.py, creado en la carpeta scripts/, tenemos un proceso de carga de datos que lee el archivo CSV y convierte cada fila en una consulta INSERT para poblar la tabla books. El script usa la librería Pandas para manejar el dataset y mysql.connector para conectarse a la base de datos.

Ejemplo de load_data.py:

python
import pandas as pd
import mysql.connector
from src.db.connector import create_connection

def load_books_to_db(csv_file):
    # Cargar el dataset en un DataFrame de Pandas
    df = pd.read_csv(csv_file)
    
    # Conectar a la base de datos
    connection = create_connection()
    if connection.is_connected():
        cursor = connection.cursor()
        
        # Insertar cada fila en la base de datos
        for _, row in df.iterrows():
            cursor.execute("""
                INSERT INTO books (title, authors, description, category, publisher, price_starting, publish_month, publish_year)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
            """, (
                row['Title'],
                row['Authors'],
                row['Description'],
                row['Category'],
                row['Publisher'],
                row['Price Starting With ($)'],
                row['Publish Date (Month)'],
                row['Publish Date (Year)']
            ))
        
        # Confirmar la carga de datos
        connection.commit()
        cursor.close()
        connection.close()
        print("Datos cargados exitosamente en la base de datos.")

if __name__ == "__main__":
    load_books_to_db("data/dataset.csv")

Este script realiza las siguientes funciones:

  • Lee el archivo CSV dataset.csv con el dataset de libros y lo convierte en un DataFrame.
  • Abre una conexión a la base de datos RDS utilizando el archivo connector.py.
  • Itera sobre cada fila del DataFrame e inserta los datos en la tabla books.
  • Confirma la transacción y cierra la conexión.

Paso 2: Ejecución del Script de Carga de Datos ​

Para cargar los datos en RDS, asegúrate de que el archivo dataset.csv esté en la carpeta data/ y que la base de datos esté en línea y accesible.

  1. Ejecuta el script para cargar el dataset en RDS:

    bash
    python scripts/load_data.py

  2. Verifica la salida:

    • Si la carga es exitosa, deberías ver el mensaje: Datos cargados exitosamente en la base de datos.
    • En caso de errores, revisa las configuraciones en connector.py para confirmar la conectividad con RDS.

Paso 3: Verificación de la Carga de Datos ​

Una vez completada la carga, verifica que los datos hayan sido insertados correctamente en la tabla books en RDS.

  1. Conéctate a RDS utilizando MySQL y ejecuta una consulta para contar los registros en la tabla:

    sql
    SELECT COUNT(*) FROM books;

    Esta consulta debería devolver el número de registros cargados, aproximadamente 103,063 si se cargó el dataset completo.

  2. Ejecuta una consulta para revisar algunos registros y asegurarte de que los datos se han cargado correctamente:

    sql
    SELECT * FROM books LIMIT 10;

Paso 4: Documentación en README.md ​

Actualiza el archivo README.md con los pasos necesarios para ejecutar el script de carga y verificar los datos en RDS.

Ejemplo de documentación en README.md:

markdown
## Etapa 3: Carga de Datos en la Base de Datos

Para cargar el dataset de libros en la base de datos RDS, utiliza el script `load_data.py` que se encuentra en la carpeta `scripts/`.

### Ejecución del Script de Carga

1. Asegúrate de que el archivo `dataset.csv` esté en la carpeta `data/`.
2. Ejecuta el script de carga:
   ```bash
   python scripts/load_data.py

Al finalizar, debería aparecer el mensaje Datos cargados exitosamente en la base de datos.

Verificación de la Carga ​

  1. Conéctate a la base de datos RDS y ejecuta la consulta:
    sql
    SELECT COUNT(*) FROM books;
  2. Verifica algunos registros:
    sql
    SELECT * FROM books LIMIT 10;

Si los datos están presentes, la carga fue exitosa y el dataset está listo para su uso en el servicio CLI.

Con estos pasos, el dataset está completamente cargado y verificado en RDS, listo para que el servicio CLI realice consultas para recomendaciones de libros. La siguiente etapa será la Etapa 4: Implementación del Servicio CLI en Python, donde crearemos el servicio interactivo en línea de comandos para las recomendaciones. ¿Te gustaría que continúe con esta siguiente etapa?

En la Etapa 4: Implementación del Servicio CLI en Python, desarrollaremos un servicio de línea de comandos (CLI) que interactúe con el usuario para proporcionar recomendaciones de libros basadas en sus preferencias. Este CLI hará preguntas al usuario sobre sus gustos y realizará consultas en la base de datos RDS para ofrecer recomendaciones de libros en función de los criterios seleccionados.

Etapa 4: Implementación del Servicio CLI en Python ​

Paso 1: Diseño del Servicio CLI ​

En el archivo cli.py dentro de la carpeta src/, configuraremos el flujo principal del CLI. Este archivo proporcionará una interfaz de usuario que guiará al usuario a través de una serie de preguntas para identificar sus preferencias de lectura, como género, autor o año de publicación.

Ejemplo de cli.py:

python
import sys
from src.recommender.engine import get_recommendations

def main():
    print("=== Bienvenido al Servicio de Recomendación de Libros ===")
    print("Por favor, responde las siguientes preguntas para obtener recomendaciones personalizadas.\n")

    # Preguntar al usuario sus preferencias de lectura
    category = input("¿Qué género o categoría de libro prefieres? (Ejemplo: Ciencia Ficción, Historia, etc.): ")
    author = input("¿Algún autor favorito? (Presiona Enter para omitir): ")
    year = input("¿Algún año de publicación en particular? (Presiona Enter para omitir): ")

    # Obtener recomendaciones basadas en las respuestas
    recommendations = get_recommendations(category=category, author=author, year=year)

    # Mostrar las recomendaciones
    if recommendations:
        print("\n=== Recomendaciones de Libros ===")
        for book in recommendations:
            print(f"- {book['title']} de {book['authors']} (Publicado en {book['publish_year']})")
            print(f"  Categoría: {book['category']} | Precio: ${book['price_starting']}")
            print(f"  Descripción: {book['description']}\n")
    else:
        print("No se encontraron libros que coincidan con tus preferencias.")

if __name__ == "__main__":
    main()

Este archivo configura un flujo básico:

  • Solicita al usuario preferencias de lectura.
  • Llama a la función get_recommendations en el motor de recomendaciones, pasándole los criterios ingresados.
  • Imprime una lista de recomendaciones en función de los resultados devueltos.

Paso 2: Implementación del Motor de Recomendaciones en engine.py ​

En el archivo engine.py dentro de src/recommender/, implementaremos la función get_recommendations. Esta función conectará con la base de datos, aplicará filtros en función de los criterios proporcionados y devolverá los libros que coincidan.

Ejemplo de engine.py:

python
from src.db.connector import create_connection

def get_recommendations(category=None, author=None, year=None):
    connection = create_connection()
    if not connection:
        print("No se pudo conectar a la base de datos.")
        return []

    query = "SELECT title, authors, description, category, publisher, price_starting, publish_month, publish_year FROM books WHERE 1=1"
    params = []

    # Añadir filtros basados en las preferencias del usuario
    if category:
        query += " AND category = %s"
        params.append(category)
    if author:
        query += " AND authors LIKE %s"
        params.append(f"%{author}%")
    if year:
        query += " AND publish_year = %s"
        params.append(year)

    try:
        cursor = connection.cursor(dictionary=True)
        cursor.execute(query, tuple(params))
        recommendations = cursor.fetchall()
        return recommendations
    except Exception as e:
        print("Error al realizar la consulta:", e)
        return []
    finally:
        cursor.close()
        connection.close()

En este archivo:

  • get_recommendations construye una consulta SQL basada en los criterios proporcionados por el usuario.
  • Los parámetros se añaden a la consulta SQL solo si el usuario ha especificado un valor.
  • La función devuelve una lista de diccionarios que contienen información sobre los libros recomendados.

Paso 3: Ejecución y Pruebas del CLI ​

Una vez implementados cli.py y engine.py, realiza pruebas en la línea de comandos para verificar el funcionamiento del servicio CLI.

  1. Ejecuta el CLI para probar el flujo de preguntas y respuestas:

    bash
    python src/cli.py

  2. Sigue las indicaciones y responde a las preguntas para recibir recomendaciones de libros. Ejemplo de flujo:

    === Bienvenido al Servicio de Recomendación de Libros ===
¿Qué género o categoría de libro prefieres? (Ejemplo: Ciencia Ficción, Historia, etc.): Historia
¿Algún autor favorito? (Presiona Enter para omitir): 
¿Algún año de publicación en particular? (Presiona Enter para omitir): 2005

=== Recomendaciones de Libros ===
- Historia del Mundo de Juan Perez (Publicado en 2005)
  Categoría: Historia | Precio: $12.99
  Descripción: Un viaje a través de los momentos más relevantes de la historia.

  3. Si no se encuentran resultados, el CLI debería mostrar un mensaje adecuado, como "No se encontraron libros que coincidan con tus preferencias."

Paso 4: Manejo de Errores y Validación ​

Agrega manejo de errores para asegurarte de que el servicio funcione sin problemas y gestione de forma adecuada entradas inválidas o conexiones fallidas.

  • En engine.py, captura errores de conexión y consulta, e imprime un mensaje de error si no es posible realizar la consulta.
  • En cli.py, valida las entradas (por ejemplo, verifica que el año de publicación sea un número) y proporciona mensajes de error si la entrada es incorrecta.

Paso 5: Documentación en README.md ​

Actualiza el archivo README.md para explicar cómo utilizar el servicio CLI, incluyendo ejemplos de uso y detalles sobre las opciones disponibles para los usuarios.

Ejemplo de documentación en README.md:

markdown
## Etapa 4: Implementación del Servicio CLI en Python

El servicio de recomendaciones de libros es una interfaz de línea de comandos que permite a los usuarios obtener sugerencias de lectura basadas en sus preferencias.

### Uso del CLI

Para ejecutar el CLI, ejecuta el siguiente comando:

```bash
python src/cli.py

Opciones de Recomendación ​

El servicio CLI solicitará las siguientes preferencias:

  • Género o Categoría: Indica el tipo de libro (Ejemplo: "Ciencia Ficción", "Historia", etc.).
  • Autor Favorito: Si tienes algún autor específico, indícalo para obtener recomendaciones.
  • Año de Publicación: Puedes especificar un año para ver libros publicados en ese año.

Ejemplo de Uso ​

=== Bienvenido al Servicio de Recomendación de Libros ===
¿Qué género o categoría de libro prefieres? (Ejemplo: Ciencia Ficción, Historia, etc.): Historia
¿Algún autor favorito? (Presiona Enter para omitir): 
¿Algún año de publicación en particular? (Presiona Enter para omitir): 2005

=== Recomendaciones de Libros ===
- Historia del Mundo de Juan Perez (Publicado en 2005)
  Categoría: Historia | Precio: $12.99
  Descripción: Un viaje a través de los momentos más relevantes de la historia.

Manejo de Errores ​

El CLI manejará errores de conexión y entrada. Si no se encuentran coincidencias, mostrará un mensaje indicando que no se encontraron libros que coincidan con las preferencias.

Con el servicio CLI implementado, los usuarios pueden recibir recomendaciones personalizadas de libros desde la base de datos en RDS. En la siguiente Etapa 5, configuraremos un pipeline de CI/CD en AWS para automatizar las pruebas y el despliegue del CLI en los entornos de desarrollo y producción.

En la Etapa 5: Configuración de CI/CD en AWS con CodePipeline y CodeBuild, configuraremos un pipeline de CI/CD utilizando AWS CodePipeline y AWS CodeBuild para automatizar las pruebas y el despliegue del servicio CLI en los entornos dev y prod. Esto permitirá que cada cambio en el código pase por un flujo de integración continua que incluya pruebas y despliegue automatizado.

Etapa 5: Configuración de CI/CD en AWS con CodePipeline y CodeBuild ​

Paso 1: Creación de la Plantilla CloudFormation para CI/CD ​

Configura el archivo ci-cd-pipeline.yaml en la carpeta infrastructure/templates/. Esta plantilla definirá el pipeline de CI/CD, incluyendo los servicios de CodePipeline y CodeBuild. También configuraremos CodeCommit como fuente y definiremos las etapas de pruebas y despliegue en los entornos de dev y prod.

Ejemplo de ci-cd-pipeline.yaml:

yaml
Resources:
  # Repositorio CodeCommit (opcional si ya está configurado)
  BookRecommenderRepo:
    Type: AWS::CodeCommit::Repository
    Properties:
      RepositoryName: book-recommender-cli
      RepositoryDescription: "Repositorio para el servicio CLI de recomendación de libros"

  # Role para CodeBuild
  CodeBuildRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service: codebuild.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: CodeBuildPolicy
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: Allow
                Action:
                  - "s3:*"
                  - "logs:*"
                  - "codecommit:*"
                  - "rds:*"
                Resource: "*"

  # Proyecto CodeBuild para pruebas y despliegue
  CodeBuildProject:
    Type: AWS::CodeBuild::Project
    Properties:
      Name: book-recommender-build
      ServiceRole: !GetAtt CodeBuildRole.Arn
      Artifacts:
        Type: CODEPIPELINE
      Environment:
        ComputeType: BUILD_GENERAL1_SMALL
        Image: aws/codebuild/standard:5.0
        Type: LINUX_CONTAINER
      Source:
        Type: CODEPIPELINE
      SourceVersion: "main"
      EnvironmentVariables:
        - Name: ENV
          Value: "dev"
      BuildSpec: !Sub "buildspec.yml"

  # Definición del Pipeline de CodePipeline
  BookRecommenderPipeline:
    Type: AWS::CodePipeline::Pipeline
    Properties:
      Name: BookRecommenderPipeline
      RoleArn: !GetAtt CodeBuildRole.Arn
      Stages:
        - Name: Source
          Actions:
            - Name: SourceCodeCommit
              ActionTypeId:
                Category: Source
                Owner: AWS
                Provider: CodeCommit
                Version: "1"
              OutputArtifacts:
                - Name: SourceOutput
              Configuration:
                RepositoryName: book-recommender-cli
                BranchName: main
        - Name: Build
          Actions:
            - Name: BuildAction
              ActionTypeId:
                Category: Build
                Owner: AWS
                Provider: CodeBuild
                Version: "1"
              InputArtifacts:
                - Name: SourceOutput
              OutputArtifacts:
                - Name: BuildOutput
              Configuration:
                ProjectName: book-recommender-build
        - Name: Deploy
          Actions:
            - Name: DeployToDev
              ActionTypeId:
                Category: Deploy
                Owner: AWS
                Provider: CodeDeploy
                Version: "1"
              InputArtifacts:
                - Name: BuildOutput
              Configuration:
                ApplicationName: BookRecommenderCLI_Dev

Paso 2: Configuración del archivo buildspec.yml ​

El archivo buildspec.yml, ubicado en la raíz del proyecto, define los pasos que CodeBuild ejecutará, incluyendo la instalación de dependencias, ejecución de pruebas y despliegue.

Ejemplo de buildspec.yml:

yaml
version: 0.2

phases:
  install:
    runtime-versions:
      python: 3.8
    commands:
      - pip install -r requirements.txt

  pre_build:
    commands:
      - echo "Ejecutando pruebas de CLI"
      - pytest tests/

  build:
    commands:
      - echo "Empaquetando la aplicación para despliegue"
      - zip -r build-output.zip src/

artifacts:
  files:
    - build-output.zip

Este archivo contiene:

  • install: Instalación de dependencias.
  • pre_build: Ejecución de pruebas unitarias con pytest.
  • build: Empaquetado de la aplicación en un archivo ZIP para su despliegue.

Paso 3: Implementación de la Plantilla CloudFormation ​

  1. Ejecuta el archivo de CloudFormation para crear el pipeline de CI/CD:

    bash
    aws cloudformation create-stack --stack-name ci-cd-pipeline --template-body file://infrastructure/templates/ci-cd-pipeline.yaml --capabilities CAPABILITY_NAMED_IAM

  2. Verifica el estado del stack en la consola de CloudFormation para confirmar que se ha creado correctamente. Esto configurará un pipeline en CodePipeline que incluye las etapas de Source, Build y Deploy.

Paso 4: Pruebas del Pipeline de CI/CD ​

  1. Confirma la integración del pipeline haciendo un commit de prueba en el repositorio de CodeCommit. Este commit debería iniciar el pipeline de CodePipeline.

  2. Monitorea las etapas del pipeline:

    • En la consola de CodePipeline, observa cómo cada etapa progresa desde la fuente hasta la compilación.
    • Verifica que el pipeline ejecute las pruebas de manera exitosa.

  3. Revisión de Errores:

    • Si alguna etapa falla, consulta los logs en la consola de CloudWatch Logs o en la sección de logs de CodeBuild para identificar y solucionar problemas.

Paso 5: Configuración del Despliegue en Entornos Dev y Prod ​

Para diferenciar los entornos de dev y prod, puedes establecer variables de entorno y modificar el pipeline para que incluya una etapa de aprobación manual antes del despliegue en prod.

  1. Configuración de variables de entorno en CodePipeline:

    • Define una variable ENV con valores distintos para dev y prod en las configuraciones del pipeline.

  2. Aprobación manual para producción:

    • Agrega una acción de aprobación manual en el pipeline para el despliegue en prod.

  3. Validación final:

    • Revisa que los despliegues se realicen correctamente en ambos entornos y que el pipeline funcione de acuerdo con la configuración.

Paso 6: Documentación en README.md ​

Actualiza el archivo README.md con los detalles del pipeline CI/CD, explicando cómo se ejecuta, cómo monitorear las etapas y cómo configurar las variables de entorno.

Ejemplo de documentación en README.md:

markdown
## Etapa 5: Configuración de CI/CD en AWS con CodePipeline y CodeBuild

Este proyecto utiliza **AWS CodePipeline** y **AWS CodeBuild** para gestionar el pipeline de CI/CD.

### Creación del Pipeline

1. Configura el pipeline con la plantilla `ci-cd-pipeline.yaml`:
   ```bash
   aws cloudformation create-stack --stack-name ci-cd-pipeline --template-body file://infrastructure/templates/ci-cd-pipeline.yaml --capabilities CAPABILITY_NAMED_IAM
  1. CodePipeline ejecutará las siguientes etapas:
    • Source: Recupera el código desde CodeCommit.
    • Build: Ejecuta pruebas y empaqueta la aplicación para su despliegue.
    • Deploy: Despliega el CLI en los entornos dev y prod.

Ejecución del Pipeline ​

Haz un commit en el repositorio de CodeCommit para activar el pipeline. Monitorea el progreso en la consola de CodePipeline.

Variables de Entorno ​

El pipeline utiliza la variable ENV para diferenciar los entornos dev y prod. El despliegue en prod requiere aprobación manual.

Con el pipeline CI/CD configurado, cada commit activará el flujo de pruebas y despliegue, garantizando un proceso de integración y despliegue continuo para el servicio CLI. La siguiente etapa es la Etapa 6: Despliegue en Entornos Dev y Prod.

En la Etapa 6: Despliegue en Entornos Dev y Prod, configuraremos el pipeline para desplegar el servicio CLI en dos entornos separados: dev y prod. Esta etapa garantizará que las pruebas se ejecuten primero en el entorno de desarrollo, y luego se realice el despliegue en producción tras una aprobación manual.

Etapa 6: Despliegue en Entornos Dev y Prod ​

Paso 1: Separación de Variables y Configuración de Entornos ​

Para facilitar el despliegue en distintos entornos, configuraremos variables de entorno en el pipeline de CodePipeline. Estas variables definirán detalles específicos de cada entorno, como credenciales de base de datos, endpoint de RDS, y configuración específica para cada ambiente.

  1. Definir Variables en el Pipeline:
    • En la etapa de Build de CodeBuild, utiliza variables de entorno como ENV, DB_ENDPOINT_DEV, y DB_ENDPOINT_PROD.
    • Modifica buildspec.yml para que utilice estas variables según el valor de ENV.

Ejemplo de ajuste en buildspec.yml:

yaml
version: 0.2

phases:
  install:
    runtime-versions:
      python: 3.8
    commands:
      - pip install -r requirements.txt

  pre_build:
    commands:
      - echo "Ejecutando pruebas para el entorno $ENV"
      - pytest tests/

  build:
    commands:
      - echo "Empaquetando la aplicación para despliegue en $ENV"
      - zip -r build-output.zip src/
      
artifacts:
  files:
    - build-output.zip

En CodePipeline, define los valores de ENV como dev o prod en cada etapa de despliegue, asegurando que el entorno correcto se utiliza en el despliegue.

Paso 2: Configuración del Despliegue en el Entorno de Desarrollo (Dev) ​

  1. Configuración del Despliegue Automático en Dev:

    • Configura el pipeline para que cualquier commit en la rama principal realice un despliegue automático en dev.
    • En el archivo ci-cd-pipeline.yaml, define la configuración de despliegue para el entorno dev.

  2. Despliegue de Pruebas en Dev:

    • Asegúrate de que las pruebas se ejecuten en el entorno dev después de cada build exitoso, utilizando el endpoint y las configuraciones de RDS específicas para dev.

  3. Revisión de Logs y Verificación en Dev:

    • Monitorea el estado del despliegue en CodeBuild y verifica que el CLI se ejecute y funcione correctamente en el entorno dev.
    • Revisa los logs generados durante el despliegue en CloudWatch o en la consola de CodeBuild para asegurar que no hay errores.

Paso 3: Configuración de la Etapa de Aprobación Manual para Producción (Prod) ​

Para garantizar que el entorno de producción solo se actualice tras la aprobación manual, agregaremos una etapa de aprobación manual en el pipeline.

  1. Agregar Acción de Aprobación Manual:

    • En la plantilla ci-cd-pipeline.yaml, añade una etapa de Manual Approval antes de la etapa de despliegue en producción. Esto requerirá una aprobación manual en CodePipeline para continuar con el despliegue en prod.

    Ejemplo de configuración de la etapa de aprobación en ci-cd-pipeline.yaml:

    yaml
    - Name: Approval
  Actions:
    - Name: ManualApproval
      ActionTypeId:
        Category: Approval
        Owner: AWS
        Provider: Manual
        Version: "1"
      RunOrder: 1

  2. Notificaciones de Aprobación (Opcional):

    • Configura SNS o Amazon EventBridge para enviar una notificación (por ejemplo, por correo electrónico) cuando se requiera una aprobación manual.

Paso 4: Configuración del Despliegue en Producción (Prod) ​

  1. Despliegue en Prod tras la Aprobación:

    • Tras la aprobación manual, CodePipeline realizará el despliegue en el entorno de producción utilizando el endpoint y credenciales de RDS específicos de prod.

  2. Pruebas de Verificación en Prod:

    • Una vez desplegado, ejecuta el servicio CLI en el entorno prod y verifica que funcione sin problemas.
    • Realiza consultas y prueba distintas opciones en el CLI para confirmar que los datos en el entorno prod están accesibles y responden correctamente.

Paso 5: Documentación en README.md ​

Actualiza el archivo README.md para incluir instrucciones sobre el flujo de despliegue en dev y prod, junto con la configuración de la aprobación manual para producción.

Ejemplo de documentación en README.md:

markdown
## Etapa 6: Despliegue en Entornos Dev y Prod

Este pipeline CI/CD despliega el servicio CLI en dos entornos: **dev** y **prod**.

### Despliegue Automático en Dev

1. Cada commit en la rama principal realiza automáticamente un despliegue en **dev**.
2. Las pruebas se ejecutan en **dev** para garantizar que los cambios funcionan correctamente antes de aprobar el despliegue en **prod**.

### Aprobación Manual para Producción

1. Una vez completado el despliegue en dev, el pipeline requiere una **aprobación manual** para proceder al despliegue en producción.
2. Al recibir la notificación de aprobación, verifica el despliegue en dev y aprueba el despliegue en **prod** desde CodePipeline.

### Configuración de Variables de Entorno

El pipeline utiliza la variable `ENV` para diferenciar entre los entornos de **dev** y **prod**. Configura los valores específicos en CodePipeline para asegurar que cada entorno use sus propias credenciales y endpoints.

Con esta configuración, el despliegue del servicio CLI se ejecuta automáticamente en el entorno de desarrollo y, una vez aprobado, se despliega en producción. Esta configuración garantiza un flujo seguro y controlado, con una revisión manual antes de cada despliegue en producción.

La siguiente sería la Etapa 7: Pruebas y Validación del CLI, donde configuraremos y ejecutaremos pruebas adicionales para garantizar el correcto funcionamiento del servicio CLI.

En la Etapa 7: Pruebas y Validación del CLI, configuraremos un conjunto de pruebas unitarias y de integración para verificar que el servicio CLI funcione correctamente en los entornos de dev y prod. Esta etapa garantizará que los cambios de código y despliegues no introduzcan errores y que el servicio esté siempre en condiciones de operar correctamente.

Etapa 7: Pruebas y Validación del CLI ​

Paso 1: Configuración de Pruebas Unitarias para el CLI ​

Las pruebas unitarias se enfocan en verificar la funcionalidad de cada módulo individual en el servicio CLI, asegurando que cada función cumpla con su propósito de manera aislada.

  1. Crea el archivo test_cli.py en la carpeta tests/:
    • Este archivo incluirá pruebas unitarias para verificar que el CLI recibe y procesa las entradas del usuario correctamente.

Ejemplo de test_cli.py:

python
import pytest
from src.recommender.engine import get_recommendations

def test_get_recommendations_no_filters():
    recommendations = get_recommendations()
    assert recommendations is not None
    assert len(recommendations) > 0  # Verifica que hay resultados disponibles

def test_get_recommendations_by_category():
    category = "Historia"
    recommendations = get_recommendations(category=category)
    for book in recommendations:
        assert book['category'] == category

def test_get_recommendations_by_author():
    author = "Isaac Asimov"
    recommendations = get_recommendations(author=author)
    for book in recommendations:
        assert author.lower() in book['authors'].lower()

Estas pruebas aseguran que:

  • get_recommendations puede retornar recomendaciones cuando no se aplica ningún filtro.
  • Los filtros de categoría y autor funcionan correctamente.
  1. Ejecución de Pruebas Unitarias en Local:

    • Ejecuta las pruebas unitarias con pytest para confirmar que cada módulo funciona de manera aislada:

      bash
      pytest tests/test_cli.py

Paso 2: Configuración de Pruebas de Integración para el Motor de Recomendaciones ​

Las pruebas de integración verifican la funcionalidad completa del CLI con la base de datos RDS, confirmando que el servicio puede conectarse a RDS, realizar consultas y devolver los resultados correctamente.

  1. Crea el archivo test_engine.py en la carpeta tests/:
    • En este archivo, define pruebas para simular una conexión real con RDS y ejecutar consultas sobre los datos cargados.

Ejemplo de test_engine.py:

python
from src.recommender.engine import get_recommendations
import pytest

@pytest.mark.integration
def test_recommendation_engine_with_db():
    # Esta prueba verifica la conexión real con la base de datos y la ejecución de consultas
    recommendations = get_recommendations(category="Historia", year="2005")
    assert recommendations is not None
    assert len(recommendations) > 0

    # Verifica que cada recomendación esté en la categoría "Historia"
    for book in recommendations:
        assert book["category"] == "Historia"

  1. Ejecución de Pruebas de Integración:

    • Ejecuta las pruebas de integración en local con el siguiente comando:

      bash
      pytest -m integration tests/test_engine.py

    Estas pruebas deben ejecutarse en CodeBuild durante el pipeline de dev para confirmar la integridad de la aplicación antes de pasar al despliegue en prod.

Paso 3: Configuración de Pruebas Automatizadas en el Pipeline de CodePipeline ​

Para automatizar la ejecución de pruebas durante cada despliegue, asegúrate de que el pipeline de CI/CD incluya las pruebas unitarias y de integración.

  1. Definir los Marcadores en el archivo buildspec.yml:
    • En el buildspec.yml, configura los comandos de pruebas para que ejecuten las pruebas unitarias y de integración antes del despliegue en prod.

Ejemplo de configuración de buildspec.yml para pruebas:

yaml
version: 0.2

phases:
  install:
    runtime-versions:
      python: 3.8
    commands:
      - pip install -r requirements.txt

  pre_build:
    commands:
      - echo "Ejecutando pruebas unitarias"
      - pytest tests/test_cli.py
      - echo "Ejecutando pruebas de integración"
      - pytest -m integration tests/test_engine.py

  build:
    commands:
      - echo "Empaquetando la aplicación para despliegue en $ENV"
      - zip -r build-output.zip src/
      
artifacts:
  files:
    - build-output.zip
  1. Ejecución de Pruebas en el Pipeline:
    • CodeBuild ejecutará las pruebas automáticamente cada vez que se active el pipeline. Si alguna prueba falla, el pipeline se detendrá y mostrará los errores en la consola.

Paso 4: Validación y Monitoreo en Producción ​

Una vez que el despliegue en prod esté activo y todas las pruebas hayan pasado, realiza una última verificación manual en el entorno de producción.

  1. Ejecuta el CLI en Producción:

    • Corre el CLI en prod para confirmar que se conecta correctamente a la base de datos y proporciona recomendaciones en base a los datos reales.

  2. Revisión de Logs y Monitoreo:

    • Monitorea los logs en CloudWatch y verifica cualquier error o advertencia en los resultados.
    • Observa el rendimiento y los tiempos de respuesta del CLI en prod para garantizar una experiencia óptima para el usuario.

Paso 5: Documentación en README.md ​

Documenta el proceso de pruebas y validación en README.md, incluyendo cómo ejecutar las pruebas en local, su ejecución automatizada en el pipeline, y pasos de validación en producción.

Ejemplo de documentación en README.md:

markdown
## Etapa 7: Pruebas y Validación del CLI

### Pruebas Unitarias

Las pruebas unitarias verifican la funcionalidad de cada módulo de manera aislada. Para ejecutar estas pruebas:

```bash
pytest tests/test_cli.py

Pruebas de Integración ​

Las pruebas de integración aseguran que el servicio CLI pueda conectarse a la base de datos RDS y realizar consultas reales. Ejecuta estas pruebas en local con:

bash
pytest -m integration tests/test_engine.py

Ejecución Automática de Pruebas en CodePipeline ​

El pipeline de CodePipeline ejecuta automáticamente las pruebas unitarias y de integración en cada despliegue en dev y antes de desplegar en producción. Las configuraciones se encuentran en buildspec.yml.

Validación en Producción ​

  1. Ejecuta el CLI en prod para verificar que las consultas se realicen correctamente.
  2. Revisa los logs en CloudWatch para asegurarte de que no haya errores o advertencias.

Con esta configuración de pruebas, el servicio CLI pasa por un proceso riguroso de validación en el entorno de desarrollo antes de ser aprobado y desplegado en producción. Este enfoque asegura la calidad y confiabilidad del servicio en ambos entornos. La siguiente y última etapa será la Etapa 8: Documentación y Mejoras, en la que consolidaremos la documentación del proyecto y sugeriremos mejoras futuras.

En la Etapa 8: Documentación y Mejoras, consolidaremos la documentación completa del proyecto para garantizar que los desarrolladores y administradores puedan replicar, mantener y mejorar el servicio CLI. También sugeriremos mejoras futuras que puedan optimizar y escalar la funcionalidad del sistema de recomendaciones de libros.

Etapa 8: Documentación y Mejoras ​

Paso 1: Documentación Completa del Proyecto en README.md ​

El archivo README.md debe ser el documento principal que explique el propósito del proyecto, su estructura, cómo configurarlo, cómo desplegarlo y cómo probarlo. A continuación, se detalla cómo estructurar la documentación.

Ejemplo de Estructura para el Archivo README.md:

markdown
# Book Recommender CLI

Este proyecto es un servicio de línea de comandos (CLI) que ofrece recomendaciones de libros basadas en las preferencias del usuario. Utiliza un dataset de libros almacenado en AWS RDS, y está desplegado en AWS con un pipeline de CI/CD que facilita la integración y el despliegue en entornos de desarrollo y producción.

## Estructura del Proyecto

- **data/**: Contiene el archivo `dataset.csv` con el dataset de libros.
- **src/**: Código fuente del servicio CLI.
  - **cli.py**: Código principal del CLI.
  - **recommender/engine.py**: Motor de recomendaciones que realiza consultas en la base de datos.
  - **db/connector.py**: Conexión con la base de datos RDS.
- **infrastructure/**: Configuración de infraestructura en AWS usando CloudFormation.
  - **templates/rds.yaml**: Plantilla para desplegar AWS RDS.
  - **templates/ci-cd-pipeline.yaml**: Plantilla para configurar el pipeline CI/CD.
- **scripts/**: Scripts para cargar el dataset y ejecutar pruebas.
  - **load_data.py**: Script que carga el dataset de libros en la base de datos RDS.
  - **test_recommender.py**: Script de pruebas automatizadas del servicio CLI.
- **tests/**: Pruebas unitarias e integración.
- **.codebuild/**: Archivo `buildspec.yml` para configurar CodeBuild.

## Configuración Inicial

1. **Clona el Repositorio en CodeCommit**:
   ```bash
   git clone https://git-codecommit.<region>.amazonaws.com/v1/repos/book-recommender-cli

  1. Crea la Base de Datos en AWS RDS:

    • Usa rds.yaml en CloudFormation para desplegar RDS en AWS:
      bash
      aws cloudformation create-stack --stack-name rds-stack --template-body file://infrastructure/templates/rds.yaml --capabilities CAPABILITY_NAMED_IAM

  2. Carga el Dataset en RDS:

    • Ejecuta el script load_data.py:
      bash
      python scripts/load_data.py

Uso del CLI ​

Ejecuta el CLI con:

bash
python src/cli.py

El CLI solicitará las preferencias del usuario (género, autor, año) y devolverá recomendaciones de libros basadas en esos criterios.

Pruebas ​

Pruebas Unitarias ​

Ejecuta las pruebas unitarias para validar las funcionalidades individuales:

bash
pytest tests/test_cli.py

Pruebas de Integración ​

Para verificar que el CLI se conecta y consulta datos en RDS:

bash
pytest -m integration tests/test_engine.py

Ejecución Automática en CodePipeline ​

CodePipeline ejecuta pruebas unitarias e integración en cada commit antes del despliegue en prod.

Despliegue en Dev y Prod ​

El pipeline CI/CD en CodePipeline incluye:

  • Dev: Despliegue automático en cada commit.
  • Prod: Requiere aprobación manual tras pasar las pruebas en dev.

Mejoras Futuras ​

  1. Incorporación de Aprendizaje Automático: Implementar recomendaciones basadas en modelos de aprendizaje automático para sugerencias personalizadas.
  2. API RESTful: Convertir el CLI en una API que pueda ser consumida desde otras aplicaciones.
  3. Soporte de Recomendaciones Avanzadas: Incluir filtros adicionales y recomendaciones en función de las valoraciones de los usuarios.
  4. Optimización del Pipeline: Implementar pruebas de carga para garantizar que el servicio escala adecuadamente.
Este archivo `README.md` debe ofrecer una guía integral sobre el proyecto, cubriendo su propósito, instalación, uso, pruebas y despliegue.

#### Paso 2: Creación de un Documento de Guía Rápida para Administradores

Además del archivo `README.md`, puede ser útil crear una guía rápida en un documento aparte que describa cómo administrar el servicio en AWS. Este archivo puede llamarse `ADMIN_GUIDE.md` y debe incluir detalles sobre:

- Cómo acceder a los logs en CloudWatch.
- Procedimiento para revisar y aprobar el despliegue en producción.
- Solución de problemas comunes, como problemas de conexión con RDS o fallos en el pipeline.
- Procedimientos para escalar la base de datos o el servicio.

**Ejemplo de `ADMIN_GUIDE.md`**:

```markdown
# Guía Rápida para Administradores del Servicio CLI de Recomendación de Libros

Este documento describe los pasos de administración y solución de problemas comunes para el servicio de recomendaciones de libros en AWS.

## Logs y Monitoreo

- **Acceso a Logs**: Los logs generados durante el despliegue y ejecución de pruebas están disponibles en **AWS CloudWatch Logs**.
  - Accede a CloudWatch, selecciona el grupo de logs correspondiente a CodeBuild o CodePipeline y revisa los logs de ejecución.

## Aprobación de Despliegue en Producción

1. Ve a **AWS CodePipeline**.
2. Busca la etapa de aprobación manual en el pipeline `BookRecommenderPipeline`.
3. Revisa los resultados del despliegue en dev y aprueba manualmente el despliegue en prod si no hay errores.

## Solución de Problemas Comunes

### Error de Conexión a la Base de Datos

- Revisa el Security Group de RDS y asegúrate de que permite conexiones desde el entorno de despliegue.
- Verifica los logs en CodeBuild para identificar problemas específicos de conexión.

### Falla en el Pipeline de CodePipeline

- Si el pipeline falla en la etapa de pruebas, revisa los logs de CodeBuild para obtener detalles.
- Asegúrate de que las variables de entorno (`ENV`, `DB_ENDPOINT_DEV`, `DB_ENDPOINT_PROD`) estén configuradas correctamente.

## Escalabilidad y Optimización

- Para aumentar la capacidad de RDS, ajusta el tipo de instancia en la consola de RDS o en el archivo `rds.yaml` en CloudFormation.

Paso 3: Sugerencias de Mejoras Futuras ​

  1. Implementación de Algoritmos de Machine Learning:

    • Utilizar algoritmos de filtrado colaborativo o basados en contenido para mejorar la precisión de las recomendaciones y personalizar las sugerencias en función del comportamiento y las preferencias de los usuarios.

  2. API RESTful:

    • Convertir el CLI en una API REST que exponga endpoints para recibir y procesar solicitudes de recomendaciones desde aplicaciones web o móviles, permitiendo un alcance más amplio y mejor escalabilidad.

  3. Interfaz Gráfica de Usuario (GUI):

    • Crear una interfaz gráfica para el servicio, permitiendo a los usuarios buscar y recibir recomendaciones desde un navegador web o aplicación de escritorio.

  4. Sistema de Registro de Usuarios y Recomendaciones Personalizadas:

    • Implementar un sistema de autenticación de usuarios para almacenar preferencias y realizar recomendaciones personalizadas, rastreando las interacciones previas y ajustando las recomendaciones en función de los libros previamente consultados.

  5. Optimización del Pipeline CI/CD:

    • Agregar pruebas de carga para asegurar que el sistema funcione eficientemente bajo alta demanda.
    • Configurar métricas y alertas en AWS para monitorear el rendimiento y la disponibilidad del servicio.

Con esta documentación completa y las sugerencias de mejoras futuras, el proyecto queda listo para su implementación y mantenimiento en producción. La documentación asegura que otros desarrolladores y administradores puedan trabajar con facilidad en el proyecto, mientras que las mejoras proporcionan una hoja de ruta para expandir y optimizar el servicio CLI.

Este conjunto de etapas cubre el ciclo completo de diseño, implementación, pruebas, despliegue y mantenimiento de un servicio de recomendaciones de libros en AWS.