Saltar a contenido

Scripts de GenericSuite para el desarrollo del backend

GenericSuite Scripts (backend version) es un conjunto de características para mejorar el proceso de desarrollo de la API en Python.

Este repositorio contiene los scripts de backend necesarios para construir y desplegar APIs creadas por GenericSuite (versión backend) y GenericSuite AI (versión backend).

Características

  • Despliegue en AWS: Despliegue a AWS como función Lambda con API Gateway usando SAM (AWS Serverless Application Model).
  • Entorno de Desarrollo Local: ejecutándose con http o https, con o sin Docker.
  • Servidor DNS Local: para permitir el acceso API seguro a través de https con un nombre de dominio como app.exampleapp.local y permitir el acceso desde otros dispositivos localmente (p. ej. smartphones) para probar tu App.
  • Certificados SSL autofirmados: para permitir que los entornos de desarrollo frontend y backend locales funcionen sobre conexiones https seguras.
  • Gestión común de configuración JSON: para añadir el submódulo de Git con los directorios de configuración JSON comunes.
  • Contenedor de base de datos local de Docker: utilizado por el sitio de pruebas y permite tener un entorno de desarrollo local offline.

Requisitos previos

Empezando

Para empezar con los Scripts de GenericSuite (versión backend), sigue estos pasos:

Iniciar tu proyecto

Consulta la guía de Inicio rápido de The GenericSuite para más detalles.

Instalar los Scripts del Backend de GenericSuite

npm init

npm install -D genericsuite-be-scripts

Preparar el Makefile

Copia la plantilla Makefile desde node_modules/genericsuite-be-scripts:

cp node_modules/genericsuite-be-scripts/Makefile ./Makefile

AWS SAM

Preparar las plantillas de AWS/SAM

Crea los directorios del proyecto scripts/aws_big_lambda y scripts/aws y copia las plantillas:

make init_sam

O...

bash node_modules/genericsuite-be-scripts/scripts/aws_big_lambda/init_sam.sh


Si vas a desarrollar con el framework Chalice:

Crea el directorio .chalice y copia la plantilla .chalice/config-example.json:

make init_chalice

O...

bash node_modules/genericsuite-be-scripts/scripts/aws/init_chalice.sh


Personalizar plantillas SAM

Si necesitas realizar alguna personalización en el samconfig.toml:

Edita el archivo template-samconfig.toml:

vi scripts/aws_big_lambda/template-samconfig.toml
# o
# code scripts/aws_big_lambda/template-samconfig.toml

Verifica si se necesita alguna personalización.

NOTA: El script de despliegue big_lambdas_manager.sh reemplazará APP_NAME_LOWERCASE_placeholder por el nombre de la aplicación definido en la variable APP_NAME en el archivo .env.


Agregar nuevos Endpoints a la Plantilla SAM

Cuando necesites añadir nuevos endpoints a tu App:

Edita el template-sam.yml:

vi scripts/aws_big_lambda/template-sam.yml
# o
# code scripts/aws_big_lambda/template-sam.yml

En este archivo es donde se definen los endpoints, así como otros elementos de despliegue de SAM como las variables de entorno utilizadas por la función Lambda de AWS. Puedes añadir nuevos endpoints o personalizarlo según lo necesario.

Hay un template de definición de endpoints en el archivo node_modules/genericsuite-be-scripts/scripts/aws_big_lambda/template-sam-endpoint-entry.yml.

Ten cuidado con los elementos que terminan en _placeholder porque son reemplazados por el script de despliegue big_lambdas_manager.sh con los valores correspondientes.


Añadir nuevas Variables de Entorno

Si necesitas añadir variables de entorno adicionales a tu App:

Edita el archivo update_additional_envvars.sh:

vi scripts/aws/update_additional_envvars.sh
# o
# code scripts/aws/update_additional_envvars.sh

Añade tus sustituciones de variables de entorno adicionales en scripts/aws/update_additional_envvars.sh como:

perl -i -pe"s|ENVVAR_NAME_placeholder|${ENVVAR_NAME}|g" "${CONFIG_FILE}"

... reemplazando "ENVVAR_NAME" por el nombre de la variable de entorno

Añade las variables de entorno adicionales al archivo .env:

ENVVAR_NAME=ENVVAR_VALUE

... reemplazando "ENVVAR_NAME" por el nombre de la variable de entorno y ENVVAR_VALUE por su valor.

Añade las variables de entorno adicionales al archivo scripts/aws_big_lambda/template-sam.yml, en la sección APIHandler > Properties > Environment > Variables. Por ejemplo.

      .
      .
   APIHandler:
         .
         .
      Properties:
            .
            .
         Environment:
         Variables:
            ENVVAR_NAME: ENVVAR_VALUE
                  .
                  .

... reemplazando "ENVVAR_NAME" por el nombre de la variable de entorno y ENVVAR_VALUE por su valor.

Si usas el framework Chalice, añade las variables de entorno adicionales al archivo .chalice/config-example.json en la sección principal environment_variables. Por ejemplo.

{ "version": "2.0", . . "environment_variables": { . . "ENVVAR_NAME": "ENVVAR_NAME_placeholder" }, "stages": { . . ... reemplazando "ENVVAR_NAME" por el nombre de la variable de entorno (en ambos lugares).

Uso

Iniciar Servidor de Desarrollo

Para iniciar el servidor de desarrollo para la etapa dev y un contenedor local de MongoDB en Docker:

make run

Para iniciar el servidor de desarrollo para la etapa qa y MongoDB Atlas:

make run_qa

Cuando haya cambios en las dependencias o en el archivo .env, reinicia el servidor de desarrollo local:

make restart_qa

Crear usuario Super Admin

Para crear el usuario inicial de Super Administrador para entornos locales, de pruebas y de producción:

make create-supad

Desplegar QA

Para realizar un despliegue QA como AWS Lambda Function y AWS API Gateway:

make deploy_qa

Para vincular la API del backend al dominio de la App:

  • Ve a Route 53.
  • Haz clic en la Zona correspondiente al dominio de la App.
  • Haz clic en 'Create Record'.
  • Introduce el subdominio: 'api-qa', 'api-staging', 'api-demo' o 'api' (para producción).
  • Activa 'alias'.
  • En 'Route traffic to' selecciona la opción 'Alias to API Gateway API'.
  • En 'Choose region' selecciona la región de la App.
  • En 'Choose endpoint' selecciona el correspondiente a la App.
  • Haz clic en 'Create Records'.

Instalar dependencias

  • Instalar las categorías de paquetes predeterminadas desde pyproject.toml o Pipfile.
    Dependiendo del gestor de paquetes configurado, ejecutará uv install, poetry install o pipenv install.
    Referencia: https://pipenv.pypa.io/en/latest/commands.html#install
make install
  • Instalar tanto las categorías de desarrollo como predeterminadas desde pyproject.toml o Pipfile.
    Dependiendo del gestor de paquetes configurado, ejecutará uv install --dev, poetry install --dev o pipenv install --dev.
    Referencia: https://pipenv.pypa.io/en/latest/commands.html#install
make install_dev
  • Instalar desde el archivo .lock e ignorar completamente la información del Pipfile.
    Dependiendo del gestor de paquetes configurado, ejecutará uv install --locked, poetry install --locked o pipenv install --ignore-pipfile.
make locked_install
  • Instalar tanto desarrollo como predeterminadas desde el archivo .lock e ignorar completamente la información de pyproject.toml o Pipfile.
    Dependiendo del gestor de paquetes configurado, ejecutará uv install --dev --locked, poetry install --dev --locked o pipenv install --dev --ignore-pipfile.
make locked_dev
  • Recrear el archivo .lock.
    Dependiendo del gestor de paquetes configurado, ejecutará uv lock, poetry lock o pipenv lock.
make lock
  • Generar el archivo requirements.txt.
    Ejecuta sh scripts/aws/run_aws.sh pipfile.
make requirements
  • Instalación limpia.
    Alias que ejecuta make clean_rm y make install.
make fresh

Limpieza

  • Alias para ejecutar make clean_rm, make clean_temp_dir, y make clean_logs.
make clean
  • Eliminar un entorno virtual creado por "pipenv run".
    Ejecuta pipenv --rm.
make clean_rm
  • Limpiar logs (en el directorio /logs).
    Ejecuta el script scripts/clean_logs.sh.
make clean_logs
  • Limpiar logs, caché y archivos temporales.
    Ejecuta sh scripts/aws/run_aws.sh clean.
make clean_temp_dir

Utilidades CLI

make install_tools
  • Mostrar puertos en uso.
    Ejecuta sh scripts/run_lsof.sh.
make lsof

Pruebas Automatizadas

  • Iniciar el contenedor de la base de datos local y ejecutar las pruebas.
    Ejecuta sh scripts/run_app_tests.sh.
make test
  • Ejecutar la prueba sin iniciar el contenedor de base de datos local.
    Ejecuta sh scripts/aws/run_tests.sh.
make test_only

Linting

  • Ejecutar Prospector.
    Ejecuta pipenv run prospector.
make lint
  • Ejecutar MyPy.
    Ejecuta pipenv run mypy ..
make types
  • Ejecutar Coverage.
    Ejecuta pipenv run coverage run -m unittest discover tests y pipenv run coverage report.
make coverage

make format
  • Ejecutar Yapf (en modo "imprimir la diff para el código fijo") y PyCodeStyle.
    Ejecuta pipenv run yapf --diff *.py **/*.py **/**/*.py y pycodestyle.
make format_check

Comandos de Desarrollo

  • Realizar un Lint completo, verificación de tipos, pruebas unitarias e de integración, verificación de formato y estilo antes de implementaciones.
    Alias para ejecutar make lint, make types, make tests, make format_check, y make pycodestyle.
make qa
  • Iniciar el contenedor de la base de datos local (utilizado para pruebas y ejecución en la etapa dev).
    Ejecuta sh scripts/local_db/run_local_db_docker.sh run.
make local-db-up

NOTAS:

Stack local de MongoDB:

Usa mongodb://root:example@mongo:27017/ como URL para conectarte a la base de datos MongoDb local.

Usa http://localhost:8081 para acceder a la UI de Admin de MongoDb.
Usa usuario: admin y contraseña: pass como credenciales para acceder a la UI de Admin.

Stack local de DynamoDB:

El puerto de la base de datos es 8000.
* dynamodb.endpoint = 'http://127.0.0.1:8000'
* dynamodb.endpoint = 'http://dynamodb-local:8000'

Usa http://localhost:8095 para acceder a la UI de DynamoDB Manager.
Configúralo para conectarse a DynamoDB local:

[Agregar conexión]
* Alias: Local
* Endpoint: http://127.0.0.1:8000
* Región: us-east-1
* Access Key: test
* Secret Key: test

Stack local de Postgres:

El puerto de la base de datos es 5432.
Usa "postgresql://user:pass@postgres-local:5432/db" como URL para conectarte a la base de datos Postgres local.

Usa http://localhost:8080 para acceder a la UI de pgAdmin.
Usa usuario: "admin@admin.com" y contraseña: "admin" para acceder a la UI de pgAdmin.

Stack local de MySQL:

Usa http://localhost:8082 para acceder a la UI de phpMyAdmin.
Usa usuario: "root" y contraseña: "pass" como credenciales para acceder a la UI de phpMyAdmin.

El puerto de la base de datos es 3306.
Usa "mysql://root:pass@mysql-local:3306/db" como URL para conectarte a la base de datos MySQL local.

Stack local de Supabase:

No hay implementación local para Supabase.

Para más información sobre la pila de bases de datos locales, consulta el archivo local_db_stack.yml.

  • Mostrar logs de la base de datos local en Docker.
    Ejecuta sh scripts/local_db/run_local_db_docker.sh logs
make local-db-logs
  • Detener el contenedor de la base de datos local en Docker.
    Ejecuta sh scripts/local_db/run_local_db_docker.sh down
make local-db-down
  • Respaldar una base de datos mongoDB.
    Ejecuta sh scripts/mongo/db_mongo_backup.sh ${STAGE} ${BACKUP_DIR}
make mongo_backup

Ej.: 

STAGE=qa BACKUP_DIR=./dumps make mongo_backup
  • Restaurar una base de datos mongoDB.
    Ejecuta sh scripts/mongo/db_mongo_restore.sh ${STAGE} ${RESTORE_DIR}
make mongo_restore

Ej.: 

STAGE=qa RESTORE_DIR=./dumps/bkp-mongodb-[exampleapp]_[stage]-[date]_[time].zip make mongo_restore

Comandos específicos de Chalice

  • Establecer parámetros en .chalice/config.json como la etapa de producción.
    Ejecuta sh scripts/aws/set_chalice_cnf.sh prod.
make config
  • Establecer parámetros en .chalice/config.json sin una etapa específica.
    Ejecuta sh scripts/aws/set_chalice_cnf.sh.
make config_dev
  • Establecer parámetros en .chalice/config.json como la etapa de Desarrollo.
    Ejecuta sh scripts/aws/set_chalice_cnf.sh local_db_docker.
make config_local
  • Establecer parámetros en .chalice/config.json como la etapa de QA con reemplazo de variables CORS específico, para permitir usar la base de datos en vivo de QA desde el entorno de desarrollo local.
    Ejecuta sh scripts/aws/set_chalice_cnf.sh qa.
    Referencias:
  • APP_CORS_ORIGIN_QA_CLOUD y APP_CORS_ORIGIN_QA_LOCAL en el archivo .env.example.
make config_qa
  • Establecer parámetros en .chalice/config.json para preparar el despliegue de QA.
    Ejecuta sh scripts/aws/set_chalice_cnf.sh qa deploy,
make config_qa_for_deployment
  • Establecer parámetros en .chalice/config.json como la etapa de Staging.
    Ejecuta sh scripts/aws/set_chalice_cnf.sh staging.
make config_staging
  • Crear la pila de AWS vía Chalice.
    Ejecuta sh scripts/aws/run_aws.sh create_stack.
make build
  • Generar el requirements.txt.
    Ejecuta sh scripts/aws/run_aws.sh pipfile.
make build_local
  • Describir la pila de AWS con el comando Chalice.
    Ejecuta sh scripts/aws/run_aws.sh describe_stack.
make build_check
  • Alias para ejecutar make unbuild_qa.
make unbuild
  • Eliminar la App QA de Chalice.
    Ejecuta sh scripts/aws/run_aws.sh delete_app qa.
make unbuild_qa
  • Eliminar la App de Staging de Chalice.
    Ejecuta sh scripts/aws/run_aws.sh delete_app staging
make unbuild_staging
  • Eliminar la pila de AWS creada por Chalice.
    Ejecuta sh scripts/aws/run_aws.sh delete_stack
make delete_stack

AWS S3

Crear los Buckets de AWS S3 para diferentes entornos y otras utilidades de AWS.

  • Crear bucket S3 para desarrollo.
    Ejecuta sh scripts/aws/create_chatbot_s3_bucket.sh dev.
make create_s3_bucket_dev

  • NOTAS:

    • Los scripts create_s3_bucket_* también permiten crear o reasignar la Política del Bucket S3.

    • Si recibes el mensaje AWS_S3_CHATBOT_ATTACHMENTS_CREATION is not set to 1, configura esa variable de entorno o ejecuta el script de esta manera:

      bash AWS_S3_CHATBOT_ATTACHMENTS_CREATION=1 make create_s3_bucket_dev

  • Crear bucket S3 para QA.
    Ejecuta sh scripts/aws/create_chatbot_s3_bucket.sh qa.

make create_s3_bucket_qa
  • Crear bucket S3 para Staging.
    Ejecuta sh scripts/aws/create_chatbot_s3_bucket.sh staging.
make create_s3_bucket_staging
  • Crear los buckets S3 de Producción.
    Ejecuta sh scripts/aws/create_chatbot_s3_bucket.sh prod.
make create_s3_bucket_prod

DynamoDB

  • Generar definiciones de tablas DynamoDB

Para despliegue CF (CloudFormation):

Lee todas las definiciones de tablas desde el directorio de configuración JSON y genera un archivo que se puede usar como plantilla de AWS CloudFormation.

make generate_cf_dynamodb

Para despliegue SAM (Serverless Application Model):

Lee todas las definiciones de tablas desde el directorio de configuración JSON y genera un archivo de plantilla que puede insertarse en el archivo SAM template.yml.

make generate_sam_dynamodb
  • Crear una configuración predeterminada de AWS config en ${HOME}/.aws/config.
    Ejecuta sh scripts/aws/create_aws_config.sh.
make create_aws_config

Bases de datos SQL

Postgres

make generate_postgres_dev_sql

Genera el archivo SQL de Postgres para crear las tablas para cualquier entorno.

make create_postgres_dev_tables

Crea las tablas de Postgres para cualquier entorno.

make generate_cf_postgres

Genera la plantilla de CloudFormation de Postgres para crear las tablas en AWS RDS.

make deploy_postgres

Despliega las tablas de Postgres en AWS RDS.

MySQL

make generate_mysql_dev_sql

Genera el archivo SQL de MySQL para crear las tablas para cualquier entorno.

make create_mysql_dev_tables

Crea las tablas de MySQL para cualquier entorno.

make generate_cf_mysql

Genera la plantilla de CloudFormation de MySQL para crear las tablas en AWS RDS.

make deploy_mysql

Despliega las tablas de MySQL en AWS RDS.

Secrets

  • Generar una nueva semilla para el enmascaramiento de URLs de almacenamiento

Para asignar la variable de entorno STORAGE_URL_SEED.

make generate_seed

Despliegue

Despliegue AWS Serverless

Realiza el despliegue de la aplicación con AWS Lambda Functions y API Gateway, usando SAM (Serverless Application Model).

  • Desplegar la App en QA.
    Ejecuta make create_s3_bucket_qa, sh scripts/aws_big_lambda/big_lambdas_manager.sh sam_deploy qa
make deploy_qa
  • Probar localmente el API Gateway y la función AWS Lambda, usando SAM local. Ejecuta sam build para revisar posibles problemas con paquetes y dependencias, y luego sam run local.
    Ejecuta make create_s3_bucket_qa, sh scripts/aws_big_lambda/aws_big_lambda/big_lambdas_manager.sh sam_run_local qa
make deploy_run_local_qa

NOTA: establece la variable de entorno SAM_BUILD_CONTAINER=1 en .env para forzar sam build --use-container --debug.

  • Validar las plantillas de despliegue SAM en QA.
    Ejecuta make create_s3_bucket_qa, sh scripts/aws_big_lambda/big_lambdas_manager.sh sam_validate qa
make deploy_validate_qa
  • Crear solamente el paquete de despliegue QA.
    Útil para revisar el tamaño del paquete y probar la imagen con un contenedor local de Docker.
    Ejecuta make create_s3_bucket_qa, sh scripts/aws_big_lambda/big_lambdas_manager.sh package qa.
make deploy_package_qa
  • Desplegar la App en Staging.
    Ejecuta make create_s3_bucket_staging, sh scripts/aws_big_lambda/big_lambdas_manager.sh sam_deploy staging 
make deploy_staging
  • Desplegar la App en Demo.
    Ejecuta make create_s3_bucket_demo, sh scripts/aws_big_lambda/big_lambdas_manager.sh sam_deploy demo 
make deploy_demo
  • Desplegar la App en Producción.
    Ejecuta make create_s3_bucket_prod, sh scripts/aws_big_lambda/big_lambdas_manager.sh sam_deploy prod
make deploy_prod
  • Alias para ejecutar make deploy_qa.
make deploy
  • Previsualizar el comportamiento de los entornos live QA/Staging/Prod.
    Ejecuta el script bash scripts/build_prod_test.sh.
# Ejecutar la prueba
make test-run-build

# Restaurar el entorno después de la prueba
make test-run-build-restore

AWS secrets

  • Gestionar secretos de AWS. Ejecuta: sh scripts/aws_secrets/aws_secrets_manager.sh
make aws_secrets

Opciones:

ACTION: run (crear los secretos), destroy (destruir los secretos), describe (describir los secretos)

STAGE: dev, qa, staging, demo, prod

TARGET: kms (gestionar las claves KMS), secrets (gestionar los secretos).

ENGINE: localstack (usar LocalStack como backend), aws (usar AWS como backend). Por defecto es aws

AWS_DEPLOYMENT_TYPE: usado para establecer la variable de entorno APP_HOST_NAME. Las opciones son: lambda (aplicación desplegada como AWS Lambda), fargate (aplicación desplegada como AWS Fargate), ec2 (aplicación desplegada como AWS EC2). Por defecto es lambda.

KMS_KEY_ALIAS: alias para la clave KMS. Por defecto es genericsuite-key.

CICD_MODE: 0 (modo detallado), 1 (menos detallado, más adecuado para CI/CD). Por defecto es 0

TMP_BUILD_DIR: directorio de trabajo temporal. Por defecto es /tmp/${APP_NAME_LOWERCASE}_aws_secrets_tmp

DEBUG: 1 (habilitar modo de depuración), 0 (deshabilitar depuración). Por defecto es 1

Uso:

# Crear las claves KMS en QA en la nube de AWS
ACTION=run STAGE=qa TARGET=kms make aws_secrets

# Crear las claves KMS en QA usando LocalStack
ACTION=run STAGE=qa TARGET=kms ENGINE=localstack make aws_secrets

# Crear los secretos en QA en la nube de AWS
ACTION=run STAGE=qa TARGET=secrets make aws_secrets

Despliegue AWS EC2

Realiza el despliegue de la aplicación con instancias AWS EC2, ALB (Elastic Load Balancer), ECR (Elastic Container Registry), AWS Secrets Manager y CloudFormation.

  • Preparar la imagen ECR para una etapa dada (p. ej. QA, staging, Demo, Prod).
    Ejecuta sh scripts/aws_ec2_elb/run-fastapi-ecr-creation.sh
make deploy_ecr_creation

Uso:

ECR_IMAGE_TAG="0.0.16" STAGE=qa make deploy_ecr_creation
  • Gestiona despliegues EC2 en las diferentes etapas (p. ej. QA, staging, Demo, Prod).
    Ejecuta sh scripts/aws_ec2_elb/run-ec2-cloud-deploy.sh
make deploy_ec2

Opciones:

ACTION: run (realizar el despliegue), destroy (destruir el despliegue)

STAGE: dev, qa, staging, demo, prod

TARGET: ec2 (desplegar ALB + instancia EC2), domain (desplegar el dominio asociado al ALB).

ECR_DOCKER_IMAGE_TAG: Etiqueta de la imagen Docker en el repositorio ECR

ENGINE: localstack (usar LocalStack como backend), aws (usar AWS como backend). Por defecto aws

CICD_MODE: 0 (modo detallado), 1 (menos detallado, más adecuado para CI/CD). Por defecto 0

TMP_WORKING_DIR: directorio de trabajo temporal. Por defecto /tmp

DEBUG: 1 (habilitar modo de depuración), 0 (deshabilitar). Por defecto 1

Uso:

# Realizar el despliegue de ALB (Elastic Load Balancer) + instancia EC2 en la nube AWS en vivo
ACTION=run STAGE=qa TARGET=ec2 ECR_DOCKER_IMAGE_TAG=0.0.16 make deploy_ec2

# Realizar el despliegue del Dominio en la nube AWS en vivo
ACTION=run STAGE=qa TARGET=domain ECR_DOCKER_IMAGE_TAG=0.1.16 make deploy_ec2

# Destruir el despliegue de ALB + instancia EC2 en la nube AWS
ACTION=destroy STAGE=qa TARGET=ec2 ECR_DOCKER_IMAGE_TAG=0.0.16 make deploy_ec2

# Realizar el despliegue del Dominio en la nube AWS local
ACTION=run STAGE=qa TARGET=domain ECR_DOCKER_IMAGE_TAG=0.1.16 ENGINE=localstack make deploy_ec2

# Realizar el despliegue de la instancia EC2 en la nube AWS local (ALB no puede simularse localmente)
ACTION=run STAGE=qa TARGET=ec2 ECR_DOCKER_IMAGE_TAG=0.0.16 ENGINE=localstack make deploy_ec2

Despliegue DynamoDB de AWS

  • Gestiona despliegues DynamoDB en las diferentes etapas (p. ej. QA, staging, Demo, Prod).
    Ejecuta sh scripts/aws_dynamodb/run-dynamodb-deploy.sh.
make deploy_dynamodb

Opciones:

ACTION: run (desplegar), destroy (destruir el despliegue), describe (describir las tablas DynamoDB), list_tables (listar todas las tablas DynamoDB).

STAGE: dev, qa, staging, demo, prod

TARGET: dynamodb (desplegar la tabla DynamoDB).

ENGINE: localstack (usar LocalStack como backend), aws (usar AWS como backend). Por defecto aws

CICD_MODE: 0 (modo detallado), 1 (menos detallado, más adecuado para CI/CD). Por defecto 0

TMP_BUILD_DIR: directorio de trabajo temporal. Por defecto /tmp/${APP_NAME_LOWERCASE}_dynamodb_tmp

DEBUG: 1 (habilitar modo de depuración), 0 (deshabilitar). Por defecto 1

Uso:

# Desplegar DynamoDB en la nube AWS local
ACTION=run STAGE=qa TARGET=dynamodb ENGINE=localstack make deploy_dynamodb

# Desplegar DynamoDB en la nube AWS en vivo
ACTION=run STAGE=qa TARGET=dynamodb make deploy_dynamodb

Comandos de Aplicación Específicos

  • Ejecutar la App localmente usando la base de datos de desarrollo, pidiendo ejecutarla sobre http o https.
    Ejecuta make config_qa, make clean_logs, y sh scripts/aws/run_aws.sh run_local. [???]
make run
  • Ejecutar la App localmente usando la base de datos de QA, pidiendo ejecutarla sobre http o https.
    Ejecuta make config_qa, make clean_logs, y sh scripts/aws/run_aws.sh run_local qa.
make run_qa
  • Ejecuta make config_qa, make clean_logs, y sh scripts/secure_local_server/run.sh "down" "" Detén y destruye el contenedor local Docker de la App (para cualquier entorno en ejecución).
make down_qa
  • Reiniciar el contenedor local Docker de la App que se ejecuta en QA.
    Ejecuta make config_qa, make clean_logs, sh scripts/secure_local_server/run.sh "down" "" y sh scripts/aws/run_aws.sh run_local qa.
make restart_qa
  • Ejecutar la App localmente usando la base de datos de desarrollo (en un contenedor Docker local), pidiendo ejecutarla sobre http o https.
    Ejecuta make config_local, make clean_logs, sh scripts/aws/run_aws.sh run_local dev. [???]
make run_local_docker
  • Ejecutar chalice local --port $PORT --stage PROD
    Ejecuta make config, make clean_logs, sh scripts/aws/run_aws.sh run.
make run_prod
  • Vincular las bibliotecas GenericSuite al proyecto.
    Enlaza simbólicamente las bibliotecas GenericSuite LOCAL (repos con el código fuente) para tener un recargado en caliente sin necesidad de ejecutar "pipenv update" cada vez que cambie el código fuente de las bibliotecas.
    Ejecuta sh scripts/link_gs_libs_for_dev.sh
make link_gs_libs

NOTA: establece la variable de entorno BASE_DEVELOPMENT_PATH en el archivo .env para indicar la ruta base de las bibliotecas GenericSuite (ruta al directorio padre de las repos genericsuite-be*) .

# Consulta "genericsuite-be-scripts/scripts/link_gs_libs_for_dev.sh"
# BASE_DEVELOPMENT_PATH="/Users/username/base_path_to_genericsuite_repos"

Configuración JSON común

  • Añadir el Submódulo de Git con los directorios de configuración JSON comunes.
    Ejecuta sh scripts/add_github_submodules.sh.
make add_submodules

Servidor DNS Local

  • Iniciar el Servidor DNS Local.
    Ejecuta sh scripts/dns/run_local_dns.sh
make local_dns
  • Ejecuta sh scripts/dns/run_local_dns.sh restart para reiniciar el Servidor DNS Local.
make local_dns_restart
  • Reiniciar y reconstruir la configuración del Servidor DNS Local cuando la IP local o cualquier parámetro DNS haya cambiado.
    Ejecuta sh scripts/dns/run_local_dns.sh rebuild
make local_dns_rebuild
  • Detener y destruir el Servidor DNS Local.
    Ejecuta sh scripts/dns/run_local_dns.sh down.
make local_dns_down
  • Probar el Servidor DNS Local.
    Ejecuta sh scripts/dns/run_local_dns.sh test.
make local_dns_test

Certificados SSL autofirmados

  • Crear los certificados SSL locales autofirmados (requeridos para ejecutar el frontend y backend de desarrollo local sobre https).
    Ejecuta sh scripts/local_ssl_certs_creation.sh.
make create_ssl_certs_only
  • Copiar los certificados SSL locales autofirmados al directorio/frontend del repositorio local.
    Ejecuta sh scripts/local_ssl_certs_copy.sh.
make copy_ssl_certs
  • Alias para ejecutar make create_ssl_certs_only y make copy_ssl_certs.
make create_ssl_certs

NOTA: Para generar certificados SSL autofirmados, se recomienda usar mkcert, pero si prefieres usar office-addin-dev-certs, también es compatible. Instálalo con:

npm install -D office-addin-dev-certs

Scripts de NPM

  • Actualizar el archivo package.json con la versión y todos los demás parámetros excepto dependencias.
    Ejecuta npm install --package-lock-only.
make npm_lock
  • Probar la publicación a NPMJS sin publicarlo realmente.
    Ejecuta sh scripts/npm_publish.sh pre-publish.
make pre-publish
  • Publicar el paquete de scripts a NPMJS.
    Ejecuta sh scripts/npm_publish.sh publish.
    Requisitos:
  • Cuenta NpmJS.
make publish

Scripts de PyPi

  • Construir el directorio 'dist' necesario para la publicación en PyPi.
    Ejecuta poetry lock --no-update, rm -rf dist y python3 -m build.
    Requisitos:
  • poetry.
make pypi-build
  • Publicación de prueba en PyPi.
    Ejecuta make pypi-build, y python3 -m twine upload --repository testpypi dist/*.
    Requisitos:
  • twine.
  • Cuenta TestPypi.
make pypi-publish-test
  • Publicación en PyPi de producción
    Ejecuta make pypi-build, y python3 -m twine upload dist/*.
    Requisitos:
  • twine.
  • Cuenta PyPi.
make pypi-publish

Solución de problemas

  • Si obtienes el error Warning: Python >=3.9,<4.0 was not found on your system... haciendo make install:
make install

... y la respuesta es como:

pipenv install
Warning: Python >=3.9,<4.0 was not found on your system...

You can specify specific versions of Python with:
$ pipenv --python path/to/python
make: *** [install] Error 1

Solución con estos comandos:

# Establecer la versión de Python del proyecto con pyenv
pyenv local 3.12

# Establecer la ruta de Python con pipenv
pipenv --python ${HOME}/.pyenv/shims/python

Y repetir make install

  • Si obtienes la advertencia This version of npm is compatible with lockfileVersion@1... al hacer make install:
npm install

... y la respuesta es como:

npm WARN read-shrinkwrap
This version of npm is compatible with lockfileVersion@1,
but package-lock.json was generated for lockfileVersion@3.
I'll try to do my best with it!

Es porque estás usando una versión antigua de Node. Para solucionarlo:

nvm use 20

Y repetir make install

# Archivo .env del frontend:
APP_LOCAL_DOMAIN_NAME=localhost

# Archivo .env del backend:
APP_CORS_ORIGIN_QA_LOCAL=http://localhost:3000

Y ejecuta make run tanto el frontend como el backend con la opción http.

  1. Para hacer que ambos usen el DNS local y https, cambia estas variables en el archivo .env:
# Archivo .env del frontend:
APP_LOCAL_DOMAIN_NAME=app.exampleapp.local

# Archivo .env del backend:
APP_CORS_ORIGIN_QA_LOCAL=https://app.exampleapp.local:3000

NOTA: reemplaza exampleapp por el nombre de tu App, todo en minúsculas.

Y ejecuta make run tanto el frontend como el backend con la opción https.

  • Si el Servidor DNS Local parece inaccesible o no funciona:

Reinicia el servidor backend local:

make local_dns_restart

Si la IP local cambia, asegúrate de: 1) Ejecutar make local_dns_rebuild.

2) Copiar la dirección IP informada por el comando anterior.
Ej.:
Local DNS domain 'app.exampleapp.local' is pointing to IP address '192.168.1.158'.

3) Ejecutar make restart_qa

4) Añadir la dirección IP a los Servidores DNS en la configuración de Red de tu ordenador (Network > DNS servers). La nueva IP de DNS debe ser la primera en la lista.

5) Reiniciar la conexión de red WiFi o LAN del ordenador.

Licencia

GenericSuite es un software de código abierto licenciado bajo la licencia MIT.

Créditos

Este proyecto es desarrollado y mantenido por Carlos Ramirez. Para más información o para contribuir al proyecto, visita Los Scripts de GenericSuite (versión backend) en GitHub.

¡Feliz codificación!