Introducción

En el artículo anterior, analizamos el proceso de creación de un modelo de aprendizaje automático para el análisis de sentimientos que se encapsuló en una aplicación Flask. Esta aplicación Flask utiliza análisis de sentimiento para clasificar los tweets como positivos o negativos. Listo para su implementación, el proyecto completo tiene control de versiones en GitHub. A continuación, veremos cómo utilizar Gunicorn y Nginx para implementar esta aplicación Flask en un servidor en la nube, garantizando que el modelo de aprendizaje automático sea escalable y accesible en un entorno de producción.

Puedes seguir el artículo anterior en ¿Cómo implementar un modelo de aprendizaje automático usando Flask?

Continuando donde lo dejamos, usaremos Gunicorn y NGINX para implementar esta aplicación Flask en un servidor en la nube. Esta publicación explicará cómo mover una aplicación Flask originalmente alojada localmente para la implementación del aprendizaje automático a la nube.

Los pasos incluyen

• Configure una instancia AWS EC2: Inicie una instancia de AWS EC2 con Ubuntu como sistema operativo. Configure grupos de seguridad para permitir el tráfico entrante.
• SSH en la instancia EC2: Utilice SSH para conectarse a su instancia EC2 desde su macWeis local. Requerimos un par de claves SSH (pública y privada) para conectarnos con su sistema local.
• Implementar la aplicación Flask: Transfiera los archivos de la aplicación Flask a la instancia EC2. Si el modelo ya está en Git Hub, clónelo en la instancia EC2 de Ubuntu. Luego, configure un entorno virtual e instale los paquetes de Python necesarios o el archivo de requisitos en el directorio usando pip. Pruebe si la aplicación Flask se ejecuta correctamente en el entorno EC2.
• Instalar dependencias: Actualice las listas de paquetes para obtener actualizaciones e instale las dependencias necesarias, como Python, pip y cualquier otra biblioteca requerida por su aplicación Flask.
• Instalar y configurar Gunicorn: Instale Gunicorn, un servidor HTTP WSGI para aplicaciones Python. Cree un archivo de servicio Gunicorn para gestionar el proceso de solicitud. Inicie y habilite el servicio Gunicorn para que se ejecute en segundo plano.
• Instalar y configurar NGINX: Instale NGINX, un servidor web de alto rendimiento y proxy inverso. Configure NGINX para reenviar solicitudes HTTP entrantes al servidor Gunicorn. Configure bloques de servidor (hosts virtuales) para su aplicación Flask.
• Configurar el nombre de dominio (opcional): Si tiene un nombre de dominio, configure los ajustes de DNS para que apunten a la dirección IP pública de su instancia EC2. De lo contrario, puede acceder a su aplicación Flask directamente desde la dirección IP pública.
• Asegure la aplicación: Habilite HTTPS para una comunicación segura entre los clientes y el servidor. Obtenga un certificado SSL/TLS (por ejemplo, Let's Encrypt) y configure NGINX para usarlo.
• Pruebe la implementación: Una vez que todo esté configurado, pruebe su aplicación Flask implementada accediendo a ella a través de un navegador web o enviando solicitudes usando cURL o Postman.

Siguiendo estos pasos, implementaremos con éxito su aplicación Flask para aprendizaje automático en una instancia AWS EC2, utilizando Gunicorn como servidor WSGI y NGINX como servidor proxy inverso para manejar las solicitudes entrantes de manera eficiente y segura.

Antes de pasar a la práctica, comprendamos cómo se hace.

Comprender la comunicación: Flask, Gunicorn y Nginx

             +-----------------------------+
             |           Client            |
             +-----------------------------+
                          |
                          |
             +------------v-------------+
             |        NGINX (Port 80)   |
             +------------+-------------+
                          |
                          |
             +------------v-------------+
             |       Gunicorn           |
             |     (WSGI Server)        |
             +------------+-------------+
                          |
                          |
             +------------v-------------+
             |   Flask Application      |
             |       (Python)           |
             +--------------------------+

Flask: el centro de la aplicación

Flask es un marco web Python ligero y flexible que proporciona las herramientas para crear aplicaciones/servicios web. Es la base de su servicio de análisis de sentimientos, maneja las solicitudes web entrantes, las procesa utilizando su modelo de aprendizaje automático y devuelve los resultados del análisis. Flask opera como la capa de aplicación en nuestra pila.

Ya creamos la aplicación Flask en el artículo anterior. Y clonarlo usando el comando.

https://github.com/Geek-shikha/Flask_model_sentiment_analysis.git

Flask por sí solo no puede manejar múltiples solicitudes a la vez; Ahí es cuando entra en juego Gunicorn.

Gunicorn: el servidor HTTP Python WSGI

Gunicorn actúa como una capa intermediaria que interactúa con Flask. Es un servidor HTTP Python WSGI diseñado para sistemas UNIX, que ofrece una forma simple pero eficiente de implementar aplicaciones web Python. Cuando ejecuta su aplicación Flask con Gunicorn, crea un servidor WSGI que se comunica con la aplicación Flask. Gunicorn gestiona múltiples procesos de trabajo para manejar solicitudes entrantes, distribuir la carga y aumentar la capacidad de manejar usuarios simultáneos. No. La cantidad de trabajadores y subprocesos depende de la cantidad de núcleos del sistema, 2*Núcleos +1.

Hasta que no tenga subprocesos múltiples, no hay espacio de memoria separado. Un solo trabajador puede manejar múltiples solicitudes de los clientes en paralelo.

¿Por qué se requiere Gunicorn?

Por varias razones, Gunicorn, o Green Unicorn, es un componente crucial para alojar aplicaciones Flask. En primer lugar, el servidor de desarrollo integrado de Flask no puede manejar múltiples solicitudes simultáneamente, lo que lo hace inadecuado para entornos de producción. Su modelo de trabajo previo a la bifurcación permite la escalabilidad al ejecutar numerosos procesos o subprocesos de trabajo, lo que se adapta al mayor tráfico de manera efectiva. El equilibrio de carga de G unicorn distribuye las solicitudes de manera uniforme, lo que mejora el rendimiento bajo cargas pesadas. Gunicorn, que cumple con la especificación WSGI, se integra perfectamente con Flask y otros marcos compatibles con WSGI, lo que simplifica la implementación. Gunicorn proporciona características esenciales como concurrencia, escalabilidad, rendimiento y compatibilidad, lo que lo hace indispensable para implementar aplicaciones Flask en producción.

Nginx: el proxy inverso de primera línea

Nginx es un servidor web potente y de alto rendimiento conocido por su estabilidad, configuración sencilla y bajo consumo de recursos. En nuestra implementación, Nginx está configurado como un proxy inverso, ubicado frente a Gunicorn. Recibe solicitudes de clientes y las reenvía a Gunicorn, quien, a su vez, se comunica con la aplicación Flask. Nginx también es responsable de servir archivos estáticos, manejar el cifrado SSL/TLS y, potencialmente, equilibrar la carga si su aplicación se escala a varios servidores.

¿Por qué Nginx?

Además de proporcionar Además, NGINX se destaca en el manejo de múltiples modelos o aplicaciones al mismo tiempo, gracias a sus sólidas capacidades de equilibrio de carga y mecanismos de almacenamiento en búfer. Si bien Gunicorn puede tener problemas con la velocidad de procesamiento de múltiples solicitudes, NGINX puede manejar esta carga de trabajo de manera eficiente almacenando en búfer las solicitudes, lo que garantiza un funcionamiento más fluido. Además, NGINX proporciona funciones esenciales como terminación SSL, autenticación de token y equilibrio de carga, lo que lo hace indispensable para proteger y optimizar las aplicaciones Flask. Para una mayor escalabilidad y flexibilidad, Docker o Kubernetes se pueden integrar junto con NGINX, lo que permite un escalamiento dinámico y una gestión simplificada de los servicios. Ya sea que se implemente en AWS o Kubernetes, NGINX sigue siendo una herramienta versátil y poderosa para alojar aplicaciones Flask a escala.

Requisitos previos

Antes de seguir los pasos para implementar su modelo, debe comprender y tener lo siguiente.

Cuenta de AWS: Necesita una cuenta de AWS para acceder a EC2 y otros servicios de AWS. Si no tiene una cuenta, puede registrarse para obtener una en el sitio web de AWS.

Si desea que su aplicación aparezca con un nombre, debe tener un nombre de dominio configurado para que apunte a su servidor. Puedes conseguir uno gratis en Freenom. No necesitamos esto aquí ya que usaremos la dirección IP pública directamente.

Comprensión de la especificación de archivos WSGI y de servidores, proxy y puertos. Un poco de comprensión también ayudará.

Implementación de un modelo de aprendizaje automático utilizando Flask en AWS con Gunicorn y Nginx

PASO 1: configurar una instancia AWS EC2

Inicie una instancia de AWS EC2 con Ubuntu como sistema operativo. Un microservicio funcionaría bien. Mantenemos el nombre de la instancia como sentiment_analysis_server. Eres libre de elegir lo que quieras. Pero recuerde, la selección de servicios de la instancia depende de la escala de la aplicación que intenta alojar.

Cree un par de claves para conectarse de forma segura con su EC2 a través de SSH. Cuando crea una instancia EC2, especifica un par de claves y el archivo de clave privada correspondiente (.pem) se utiliza para autenticar su conexión SSH a la instancia. Utilice un par de claves tipo RSA y siga los pasos a continuación.

1. Crear par de claves: Haga clic en el botón "Crear par de claves" para generar el par de claves.
2. Descargar clave privada: Una vez creado el par de claves, se descargará automáticamente un archivo de clave privada (.pem) en su máquina local. Este archivo de clave privada autentica las conexiones SSH a sus instancias EC2.

Inicie su instancia con configuraciones de seguridad que permitan el tráfico de puerto y http. Después de iniciar y conectarse a su instancia, copie el comando SSH para poder publicarlo en su terminal local para acceder a la instancia de forma remota. En la siguiente imagen, la parte resaltada en verde es lo que necesita copiar y pegar en su terminal/local.

PASO 2: SSH en la instancia EC2

Abre la terminal de tu computadora. Si su archivo de clave privada (.pem) se encuentra en un directorio, deberá especificar la ruta completa al archivo de clave cuando utilice el comando SSH para conectarse a su instancia EC2. Así es como puedes hacerlo:

Digamos que su clave (archivo .pem) está en Descargas. Luego, debes colocar tu comando SSH allí. Entonces, todo lo que necesita hacer es abrir su terminal, navegar hasta el directorio de Descargas y pegar su comando allí.

cd ~/Downloads

Ahora pegue su comando SSH, que podría verse como el ejemplo: ssh -i “sentiment_analysiskey.pem” GME@dhr-rgv.com

PASO 3: Instalar los componentes necesarios desde los repositorios de Ubuntu

El primer paso es instalar todos los componentes necesarios desde los repositorios de Ubuntu. Esto incluye los componentes de Python, que administrará Pip, y el administrador de paquetes de Python. También se proporcionarán los archivos de desarrollo de Python necesarios para ensamblar los componentes de Gunicorn. Al instalar los paquetes que le permiten crear su entorno Python, primero debe actualizar el índice del paquete local.

sudo apt update 
sudp apt upgrade 

Luego, instale el comando Python-pip para instalar pip y el entorno virtual.

sudo apt install python3-pip
sudo apt install python3-venv

Luego, instale el paquete net stat. El paquete net-tools muestra información relacionada con la red, como conexiones de red activas, tablas de enrutamiento, estadísticas de interfaz, etc.

sudo apt instalar herramientas de red

sudo apt install net-tools

netstat tuln #after installing run this command 

Muestra una lista de conexiones de red activas y puertos de escucha en el sistema:

Luego instale el paquete de firewall: el paquete ufw (Uncomplicated Firewall) es una interfaz para administrar las reglas de firewall de iptables en Ubuntu y otras distribuciones de Linux basadas en Debian. Proporciona una interfaz simplificada para configurar reglas de firewall, lo que facilita la configuración de la protección de firewall esencial para su sistema.

• habilitar sudo ufw: Habilita el firewall.
• Sudo ufw permitir /: Este comando permite conexiones entrantes en un puerto y protocolo específicos (por ejemplo, sudo ufw permite que 22/TCP habilite conexiones SSH).
• Estado de Sudoufw: Muestra el estado actual y las reglas del firewall.

sudo apt install ufw #
sudo ufw allow 22 #ssh access
sudo ufw allow 5000  #5000 port for flask app test 

sudo ufw status 

1. Sudo ufw permite 5000: Esto permite conexiones entrantes en el puerto 5000. De forma predeterminada, permite tráfico TCP y UDP en este puerto. Ejecutaremos nuestra aplicación Flask en 5000, por lo que se debe poder acceder al servicio de la aplicación Flask que se ejecuta en el puerto 5000 desde la red.
2. Sudo ufw permite 22: Este comando habilita conexiones SSH entrantes en el puerto 22. SSH se utiliza para el acceso remoto a su sistema y permitir conexiones en el puerto 22 le permite conectarse a su servidor a través de SSH de forma segura. Esto es importante; No debes desactivar esto, ya que no podrás acceder a tu SSH de forma remota.

Paso 4: implementar la aplicación Flask y configurar la aplicación

Implementar la aplicación Flask: transfiera los archivos de la aplicación Flask a la instancia EC2. Si el modelo ya está en Git Hub, clónelo en la instancia EC2 de Ubuntu. Luego, configure un nuevo entorno virtual e instale los paquetes de Python necesarios o el archivo de requisitos en el directorio usando pip. Luego, la aplicación Test Flask se ejecuta correctamente en el entorno EC2.

En nuestro caso, estamos clonando un repositorio git, que usamos en el último artículo para analizar el sentimiento de un tweet.

Pero primero, asegúrese de que git esté instalado. Si está instalado, ejecute el comando: git clone -b master –single-branch https://github.com/Geek-shikha/Flask_model_sentiment_analysis.git

git --version # if this exists you need not to sudo apt install git 
git clone -b master --single-branch 
https://github.com/Geek-shikha/Flask_model_sentiment_analysis.git #same line 

#after cloning the repository go tot the directory and list all the files 
cd Flask_model_sentiment_analysis
ls 

Nota: Cuando clones el repositorio, no verás ningún archivo app.py; en su lugar, myproject.py está presente, lo cual requerimos.

Existe un entorno virtual que creamos anteriormente al crear una aplicación Flask localmente. Necesitamos crear un nuevo entorno virtual para evitar errores o discrepancias. El nuevo entorno virtual se denomina “myprojectenv” y debe activarse.

python -m venv myprojectenv #virtual env named as myprojectenv
source myprojectenv/bin/activate #activate the virtual environment

Instale las bibliotecas de Python almacenadas en requisitos.txt

pip install -r requirements.txt #install the dependencies like flask, nltk etc.

Ahora prueba y ejecuta tu aplicación Python Flask

python3 myproject.py

Al ejecutar esto, puede ver una salida en la terminal como esta:

Para ver si está funcionando. Visite la dirección IP de su servidor seguida de: 5000 en su navegador web. En su navegador web, la IP de su servidor es 5000, como http://server_pub_ip:5000. Digamos que la IP del servidor es  23.124.09.133. Luego pon http://23.124.09.133:5000 

Paso 5: archivo WSGI

A continuación, cree un archivo que servirá como punto de entrada para su aplicación. Este archivo indicará al servidor Gunicorn que interactúe con la aplicación.

cree un archivo wsgi.py en la carpeta Flask_model_sentiment_analysis

nano ~/Flask_model_sentiment_analysis/wsgi.py 

En este archivo, importe la instancia de Flask desde nuestra aplicación, a la que llamamos myproject.py, y luego ejecútela:

from myproject import app

if __name__ == "__main__":
    app.run()

También puedes instalar Sudo apt y unicorn si hay algún error.

Paso 6: Configuración de Gunicorn

Comencemos configurando Gunicorn y vinculando la aplicación wsgi al puerto 5000.

El comando unicorn configure inicia un servidor Gunicorn que escucha las conexiones entrantes en el puerto 5000 desde cualquier dirección IP y sirve la aplicación WSGI denominada app definida en el archivo wsgi.py.

gunicorn --bind 0.0.0.0:5000 wsgi:app

Salida:

Compruebe si está funcionando. Visite la dirección IP de su servidor seguida de: 5000 en su navegador web: En su navegador web, la IP de su servidor es 5000, como http://server_pub_ip:5000; digamos que la IP del servidor es  23.124.09.133. Luego pon http://23.124.09.133:5000 

Debería darte un resultado como este:

Si obtiene la respuesta correcta, detenga el servicio; puede presionar ctrl+c y luego desactivar su entorno virtual dando el comando. Posteriormente, cree el archivo de la unidad de servicio y del sistema. Esta acción permitirá que el sistema de inicio de Ubuntu inicie automáticamente Gunicorn y aloje la aplicación Flask al iniciar el servidor.

sudo nano /etc/systemd/system/myproject.service

Añade el siguiente contenido:

[Unit]
Description=Gunicorn instance to serve myproject
After=network.target

[Service]
User=ubuntu
Group=www-data
WorkingDirectory=/home/ubuntu/Flask_model_sentiment_analysis
Environment="PATH=/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin"
ExecStart=/home/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin/gunicorn 
--workers 3 --bind unix:myproject.sock -m 007 w>
[Install]
WantedBy=multi-user.target

• [Unidad]: Esta sección especifica metadatos y dependencias para la unidad.
• Descripción: Describe el servicio.
• Después = network.target: Indica que esta unidad se inicia después de que la red esté activa, asegurando la conectividad de la red antes de que comience el servicio.
• [Servicio]: Esta sección define los parámetros del servicio.
• Usuario=ubuunidad: Especifica la cuenta de usuario bajo la cual se debe ejecutar el servicio.
• Grupo=www-datos: Establece el grupo para el servicio.
• Directorio de trabajo: Especifica el directorio de trabajo del servicio.
• Entorno=”PATH=/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin”: Esta variable define las variables de entorno del servicio, configurando explícitamente la variable PATH para incluir el directorio binario del entorno virtual.
• Inicio ejecutivo: Especifica el comando para iniciar el servicio. En este caso, inicia Gunicorn con opciones específicas:
• –trabajadores 3: Configura Gunicorn para utilizar tres procesos de trabajo.
• –bind unix: mi proyecto.sock: Especifica el archivo de socket a través del cual Gunicorn se comunicará con el servidor web (por ejemplo, Nginx o Apache).
• -m 007: Establece la máscara en 007, controlando los permisos de los archivos creados por Gunicorn.
• wsgi: aplicación: Indica la ubicación de la aplicación WSGI que se va a servir.
• [Instalar]: Esta sección define la información de instalación de la unidad.
• WantedBy=multiusuario.objetivo: Especifica el destino en el que se debe instalar esta unidad. En este caso, está configurado para multiusuario. Target, un objetivo estándar para los sistemas de los usuarios, indica que el servicio debe iniciarse automáticamente durante el inicio del sistema.

En resumen, este archivo de unidad del sistema configura Gunicorn para servir una aplicación Flask con configuraciones específicas y garantiza que el servicio se inicie automáticamente al iniciar el sistema.

Es hora de iniciar el servicio Gunicorn que creó y habilitarlo para que se inicie en el arranque:

sudo systemctl start myproject
sudo systemctl enable myproject
sudo systemctl status myproject#check the status of your service file for errors, ifany

 Si el comando se resiste, utilice esto para recargar "sudo systemctl daemon-reload".

Si has seguido cada paso, no debería haber errores; sin embargo, si el error persiste, resuélvalo. Puede haber un error en la ruta o el entorno del archivo de servicio. Verifique cuidadosamente

Paso 7: instalar y configurar NGINX

El servidor de aplicaciones Gunicorn está operativo y esperando solicitudes a través del archivo socket en el directorio del proyecto. Ahora, configuraremos Nginx para dirigir solicitudes web a este socket implementando modificaciones menores en su archivo de configuración. Para esto, primero necesitamos instalar nginx.

sudo apt install nginx

Comience generando un nuevo archivo de configuración de bloque de servidor dentro del directorio de sitios disponibles de Nginx. Nombra este archivo "proyecto" para no confundirte. Hemos estado usando el nombre myproject.py anteriormente.

sudo nano /etc/nginx/sites-available/myproject

para agregar el contenido al archivo, que tiene una configuración de bloque de servidor Nginx que garantiza que las solicitudes HTTP entrantes a la dirección IP del servidor especificada se reenvíen al servidor de aplicaciones Gunicorn a través del archivo de socket Unix, lo que permite que la aplicación Flask maneje las solicitudes. Guarde el archivo y salga del editor.

server {
    listen 80;
    server_name 3.110.196.110; #your server public ip 

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/ubuntu/Flask_model_sentiment_analysis/myproject.sock;
    }
}

• Servidor {...}: Este bloque define una configuración de servidor dentro de Nginx. Encapsula los ajustes de configuración para manejar solicitudes para un servidor específico.
• Escucha 80: Esta directiva especifica que Nginx debe escuchar las solicitudes HTTP entrantes en el puerto 80, el puerto predeterminado para el tráfico HTTP.
• nombre_servidor 3.110.196.110: Esta directiva establece el nombre de host o la dirección IP del servidor. En este caso, está configurado en 3.110.196.110, que debe reemplazarse con la dirección IP pública de su servidor.
• Localización / {…}: este bloque define cómo Nginx debe manejar las solicitudes para el directorio raíz / del servidor.
• Incluir proxy_params: Esta directiva proporciona ajustes de configuración del archivo proxy_params. Estas configuraciones normalmente contienen configuraciones relacionadas con el proxy, como encabezados de proxy.
• proxy_pass http://unix:/home/ubuntu/Flask_model_sentiment_analysis/myproject.sock: Esta directiva especifica que Nginx debe reenviar las solicitudes entrantes al archivo de socket Unix especificado ubicado en /home/ubuntu/Flask_model_sentiment_analysis/myproject.sock. Aquí es donde Gunicorn escucha las solicitudes. Nginx actuará como un proxy inverso, pasando solicitudes a Gunicorn y devolviendo las respuestas al cliente.

Ahora habilite y pruebe si hay errores.

sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled
sudo nginx -t

• sudo ln -s /etc/nginx/sites-available/miproyecto /etc/nginx/sites-enabled: Este comando crea un enlace simbólico llamado myproject en el directorio habilitado para sitios, que apunta al archivo de configuración ubicado en el directorio disponible para sitios. Al hacer esto, habilita la configuración del bloque del servidor para su proyecto.
• Sudo nginx -t: Este comando prueba la configuración de Nginx en busca de errores de sintaxis. Comprueba si los archivos de configuración de Nginx, incluido el bloque del servidor myproject recién habilitado, están escritos correctamente y son válidos. Si hay algún error, se informará durante esta prueba.

Reinicie el nginx ya que hemos actualizado las configuraciones.

sudo systemctl restart nginx

actualizando el firewall para nginx

sudo ufw allow 'Nginx Full'

Como no necesitamos el puerto 5000, podemos desactivarlo usando el comando "sudo ufw delete enable 5000", pero no necesitamos desactivar el puerto 22.

Ahora navegue hasta el nombre de dominio de su servidor (o dirección IP) en su navegador web y verá el resultado:

Si ve algún error como 502 gateway, debe cambiar algunos permisos. usa el comando

sudo chmod 755 /home/ubuntu

Además, cuando pruebe su servidor para la aplicación, debe usar http://….. y no https, ya que la aplicación no es segura.

Si hay errores, puedes verificarlos mediante comandos como:

Si desea detener el servicio, puede utilizar el comando

sudo systemctl stop nginx #stop the service 
sudo systemctl start nginx# to start the service 

Pasos adicionales para proteger la aplicación

Hay pasos adicionales para proteger la aplicación.  

Habilite HTTPS para una comunicación segura entre los clientes y el servidor. Obtenga un certificado SSL/TLS (por ejemplo, Let's Encrypt) y configure NGINX para usarlo. Podemos utilizar Certbot para proteger la aplicación.

Para proteger su servidor web con SSL/TLS usando Certbot, normalmente necesita un nombre de dominio registrado. Certbot requiere un nombre de dominio para emitir certificados SSL porque verifica la propiedad del dominio antes de emitir el certificado. Si bien es técnicamente posible utilizar una dirección IP pública en lugar de un nombre de dominio, no se recomienda por varias razones. Uno son los requisitos de la autoridad de certificación (CA): las autoridades de certificación (CA) como Let's Encrypt (que utiliza Certbot) tienen políticas implementadas que requieren validación de dominio. No emitirán certificados SSL para direcciones IP.

Si desea protegerlo, puede usar sudo apt install python3-certbot-nginx y obtener más información al respecto en su documentación.

Conclusión

En este artículo, creamos una aplicación Flask básica dentro de un entorno virtual Python. Generamos un punto de entrada WSGI, permitiendo la compatibilidad con cualquier servidor de aplicaciones compatible con WSGI, y luego configuramos Gunicorn para cumplir esta función. Posteriormente, creamos un archivo de servicio del sistema para iniciar el servidor de aplicaciones automáticamente al iniciar el sistema. Además, construyó un bloque de servidor Nginx responsable de dirigir el tráfico del cliente web al servidor de aplicaciones, reenviar solicitudes externas de manera efectiva y proteger el tráfico del servidor con el cifrado Let's Encrypt.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Fuente: https://www.analyticsvidhya.com/blog/2024/04/ml-using-flask-on-aws-gunicorn-nginx/