Logo Zéphyrnet

Intelligence de données générative

Big Data

Déploiement d'un modèle d'apprentissage automatique à l'aide de Flask sur AWS avec Gunicorn et Nginx

Republié par Platon
Republié par Platon

Date :

Vues: 45

Introduction

Dans l'article précédent, nous avons parcouru le processus de création d'un modèle d'apprentissage automatique pour l'analyse des sentiments encapsulé dans une application Flask. Cette application Flask utilise l'analyse des sentiments pour classer les tweets comme positifs ou négatifs. Prêt à être mis en œuvre, le projet complet est contrôlé en version sur GitHub. Pour aller plus loin, nous allons maintenant expliquer comment utiliser Gunicorn et Nginx pour déployer cette application Flask sur un serveur cloud, garantissant que le modèle d'apprentissage automatique est évolutif et accessible dans un environnement de production.

Vous pouvez suivre l'article précédent sur Comment déployer un modèle d'apprentissage automatique à l'aide de Flask ?

Reprenant là où nous nous sommes arrêtés, nous utiliserons Gunicorn et NGINX pour déployer cette application Flask sur un serveur cloud. Cet article expliquera le déplacement d'une application Flask initialement hébergée localement pour le déploiement d'apprentissage automatique vers le cloud.

Déploiement d'un modèle d'apprentissage automatique à l'aide de Flask sur AWS avec Gunicorn et Nginx

Table des matières

Les étapes comprennent

  • Configurez une instance AWS EC2 : Lancez une instance AWS EC2 avec Ubuntu comme système d'exploitation. Configurez les groupes de sécurité pour autoriser le trafic entrant.
  • Connectez-vous en SSH à l'instance EC2 : Utilisez SSH pour vous connecter à votre instance EC2 depuis votre macWeis local. Nous avons besoin d'une paire de clés SSH (publique et privée) pour nous connecter à votre système local.
  • Déployer l'application Flask : Transférez les fichiers de l'application Flask vers l'instance EC2. Si le modèle est déjà sur Git Hub, clonez-le dans l'instance EC2 Ubuntu. Ensuite, configurez un environnement virtuel et installez les packages Python requis ou le fichier d'exigences dans le répertoire à l'aide de pip. Testez si l'application Flask s'exécute correctement dans l'environnement EC2.
  • Installer les dépendances : Mettez à jour les listes de packages pour les mises à niveau et installez les dépendances nécessaires, telles que Python, pip et toute autre bibliothèque requise par votre application Flask.
  • Installez et configurez Gunicorn : Installez Gunicorn, un serveur HTTP WSGI pour les applications Python. Créez un fichier de service Gunicorn pour gérer le processus de candidature. Démarrez et activez le service Gunicorn pour s'exécuter en arrière-plan.
  • Installez et configurez NGINX : Installez NGINX, un serveur Web hautes performances et un proxy inverse. Configurez NGINX pour transférer les requêtes HTTP entrantes vers le serveur Gunicorn. Configurez des blocs de serveur (hôtes virtuels) pour votre application Flask.
  • Configurer le nom de domaine (facultatif) : Si vous disposez d'un nom de domaine, configurez les paramètres DNS pour qu'ils pointent vers l'adresse IP publique de votre instance EC2. Sinon, vous pouvez accéder à votre application Flask directement depuis l'adresse IP publique.
  • Sécurisez l'application : Activez HTTPS pour une communication sécurisée entre les clients et le serveur. Obtenez un certificat SSL/TLS (par exemple, Let's Encrypt) et configurez NGINX pour l'utiliser.
  • Testez le déploiement : Une fois que tout est configuré, testez votre application Flask déployée en y accédant via un navigateur Web ou en envoyant des requêtes à l'aide de cURL ou Postman.

En suivant ces étapes, nous déploierons avec succès votre application Flask pour l'apprentissage automatique sur une instance AWS EC2, en utilisant Gunicorn comme serveur WSGI et NGINX comme serveur proxy inverse pour gérer les demandes entrantes de manière efficace et sécurisée.

Avant d'entrer dans le vif du sujet, comprenons comment cela se fait.

Comprendre la communication : Flask, Gunicorn et Nginx

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

Flask : le centre de l'application

Flask est un framework Web Python léger et flexible qui fournit les outils nécessaires pour créer des applications/services Web. Il constitue la base de votre service d'analyse des sentiments, gérant les requêtes Web entrantes, les traitant à l'aide de votre modèle d'apprentissage automatique et renvoyant les résultats de l'analyse. Flask fonctionne comme la couche d'application de notre pile.

Nous avons déjà créé l'application Flask dans l'article précédent. Et clonez-le à l'aide de la commande.

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

Flask seul ne peut pas gérer plusieurs requêtes à la fois ; c'est alors que Gunicorn entre en jeu.

Gunicorn : le serveur HTTP Python WSGI

Gunicorn agit comme une couche intermédiaire qui s'interface avec Flask. Il s'agit d'un serveur HTTP Python WSGI conçu pour les systèmes UNIX, offrant un moyen simple mais efficace de déployer des applications Web Python. Lorsque vous exécutez votre application Flask avec Gunicorn, cela crée un serveur WSGI qui communique avec l'application Flask. Gunicorn gère plusieurs processus de travail pour gérer les demandes entrantes, répartir la charge et augmenter la capacité à gérer les utilisateurs simultanés. Non. Le nombre de Workers et de threads dépend du nombre de cœurs du système, 2*Cores +1.

Jusqu'à ce que vous ayez le multithreading, il n'y a pas d'espace mémoire séparé. Un seul travailleur peut gérer plusieurs demandes des clients en parallèle.

Pourquoi Gunicorn est-il requis ?

Pour diverses raisons, Gunicorn, ou Green Unicorn, est un composant crucial dans l'hébergement des applications Flask. Premièrement, le serveur de développement intégré de Flask ne peut pas gérer plusieurs requêtes simultanément, ce qui le rend inadapté aux environnements de production. Son modèle de travail pré-fork permet l'évolutivité en exécutant de nombreux processus de travail ou threads, s'adaptant efficacement à l'augmentation du trafic. L'équilibrage de charge de G Unicorn répartit les requêtes de manière uniforme, améliorant ainsi les performances sous de lourdes charges. Conforme à la spécification WSGI, Gunicorn s'intègre de manière transparente à Flask et à d'autres frameworks compatibles WSGI, simplifiant ainsi le déploiement. Gunicorn fournit des fonctionnalités essentielles telles que la concurrence, l'évolutivité, les performances et la compatibilité, ce qui le rend indispensable pour le déploiement d'applications Flask en production.

Nginx : le proxy inverse de première ligne

Nginx est un serveur Web puissant et performant connu pour sa stabilité, sa configuration simple et sa faible consommation de ressources. Dans notre déploiement, Nginx est configuré comme un proxy inverse, assis devant Gunicorn. Il reçoit les demandes des clients et les transmet à Gunicorn, qui, à son tour, communique avec l'application Flask. Nginx est également responsable de la gestion des fichiers statiques, de la gestion du cryptage SSL/TLS et potentiellement de l'équilibrage de charge si votre application s'adapte à plusieurs serveurs.

Pourquoi Nginx ?

En plus de fournir de plus, NGINX excelle dans la gestion simultanée de plusieurs modèles ou applications, grâce à ses solides capacités d'équilibrage de charge et ses mécanismes de mise en mémoire tampon. Bien que Gunicorn puisse avoir du mal à gérer la vitesse de traitement de plusieurs requêtes, NGINX peut gérer efficacement cette charge de travail en mettant les requêtes en mémoire tampon, garantissant ainsi un fonctionnement plus fluide. De plus, NGINX fournit des fonctionnalités essentielles telles que la terminaison SSL, l'authentification par jeton et l'équilibrage de charge, ce qui le rend indispensable pour sécuriser et optimiser les applications Flask. Pour plus d'évolutivité et de flexibilité, Docker ou Kubernetes peuvent être intégrés à NGINX, permettant une mise à l'échelle dynamique et une gestion simplifiée des services. Qu'il soit déployé sur AWS ou Kubernetes, NGINX reste un outil polyvalent et puissant pour héberger des applications Flask à grande échelle.

Conditions préalables

Avant d'utiliser les étapes de déploiement de votre modèle, vous devez comprendre et comprendre les éléments suivants.

Compte AWS : Vous avez besoin d'un compte AWS pour accéder à EC2 et aux autres services AWS. Si vous n'avez pas de compte, vous pouvez en créer un sur le site Web AWS.

Si vous souhaitez que votre application apparaisse avec un nom, vous devez avoir un nom de domaine configuré pour pointer vers votre serveur. Vous pouvez en obtenir un gratuitement sur Freenom. Nous n’en avons pas besoin ici puisque nous utiliserons directement l’adresse IP publique.

Compréhension de la spécification des fichiers WSGI, des serveurs, du proxy et des ports. Un peu de compréhension aidera également.

Déploiement d'un modèle d'apprentissage automatique à l'aide de Flask sur AWS avec Gunicorn et Nginx

ÉTAPE 1 : Configurer une instance AWS EC2

Lancez une instance AWS EC2 avec Ubuntu comme système d'exploitation. Un micro-service fonctionnerait très bien. Nous conservons le nom de l'instance comme sentiment_analysis_server. Vous êtes libre de choisir ce que vous aimez. Mais n'oubliez pas que la sélection du service de l'instance dépend de la taille de l'application que vous essayez d'héberger.

Configurer une instance AWS EC2

Créez une paire de clés pour vous connecter en toute sécurité à votre EC2 via SSH. Lorsque vous créez une instance EC2, vous spécifiez une paire de clés et le fichier de clé privée correspondant (.pem) est utilisé pour authentifier votre connexion SSH à l'instance. Utilisez une paire de clés de type RSA et suivez les étapes ci-dessous.

  1. Créer une paire de clés : Cliquez sur le bouton « Créer une paire de clés » pour générer la paire de clés.
  2. Télécharger la clé privée : Une fois la paire de clés créée, un fichier de clé privée (.pem) sera automatiquement téléchargé sur votre ordinateur local. Ce fichier de clé privée authentifie les connexions SSH à vos instances EC2.
Configurer une instance AWS EC2

Lancez votre instance avec des configurations de sécurité qui autorisent le trafic de port et http. Après avoir lancé et connecté votre instance, copiez-y la commande SSH afin de pouvoir la publier sur votre terminal local pour accéder à l'instance à distance. Dans l'image suivante, la partie surlignée en vert correspond à ce que vous devez copier et coller dans votre local/terminal.

Se connecter à l'instance

ÉTAPE 2 : SSH dans l'instance EC2

Ouvrez le terminal de votre ordinateur. Si votre fichier de clé privée (.pem) se trouve dans un répertoire, vous devrez spécifier le chemin complet du fichier de clé lorsque vous utiliserez la commande SSH pour vous connecter à votre instance EC2. Voici comment procéder :

Disons que votre clé (fichier .pem) se trouve dans les téléchargements. Ensuite, vous devez y placer votre commande SSH. Ainsi, tout ce que vous avez à faire est d’ouvrir votre terminal, d’accéder au répertoire Téléchargements et d’y coller votre commande.

cd ~/Downloads

Collez maintenant votre commande SSH, qui pourrait ressembler à l'exemple : ssh -i "sentiment_analysiskey.pem" [email protected]

SSH dans l'instance EC2

ÉTAPE 3 : Installation des composants nécessaires à partir des référentiels Ubuntu

La première étape consiste à installer tous les composants nécessaires à partir des référentiels Ubuntu. Cela inclut les composants Python, que Pip gérera, et le gestionnaire de packages Python. Les fichiers de développement Python nécessaires à l'assemblage des composants Gunicorn seront également fournis. Lors de l'installation des packages qui vous permettent de créer votre environnement Python, vous devez d'abord mettre à jour l'index local des packages.

sudo apt update 
sudp apt upgrade

Ensuite, installez la commande Python-pip pour installer pip et l'environnement virtuel.

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

Ensuite, installez le package net stat. Le package net-tools affiche des informations relatives au réseau, telles que les connexions réseau actives, les tables de routage, les statistiques d'interface, etc.

sudo apt installer net-tools

sudo apt install net-tools

netstat tuln #after installing run this command

Il affiche une liste des connexions réseau actives et des ports d'écoute sur le système :

Installez ensuite le package pare-feu : le package ufw (Uncomplicated Firewall) est un frontal permettant de gérer les règles de pare-feu iptables sur Ubuntu et d'autres distributions Linux basées sur Debian. Il fournit une interface simplifiée pour configurer les règles de pare-feu, facilitant ainsi la configuration de la protection pare-feu essentielle pour votre système.

  • sudo ufw activer : Active le pare-feu.
  • Sudo ufw autoriser / : Cette commande autorise les connexions entrantes sur un port et un protocole spécifiques (par exemple, sudo ufw autorise 22/TCP à activer les connexions SSH).
  • Statut Sudo ufw : Affiche l'état actuel et les règles du pare-feu.
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 autorise 5000 : Cela autorise les connexions entrantes sur le port 5000. Par défaut, cela autorise le trafic TCP et UDP sur ce port. Nous exécuterons notre application Flask sur 5000, le service de l'application Flask exécuté sur le port 5000 doit donc être accessible depuis le réseau.
  2. Sudo ufw autorise 22 : Cette commande active les connexions SSH entrantes sur le port 22. SSH est utilisé pour l'accès à distance à votre système, et autoriser les connexions sur le port 22 vous permet de vous connecter à votre serveur via SSH en toute sécurité. C'est important; vous ne devez pas désactiver cette option, car vous ne pourrez pas accéder à votre SSH à distance.

Étape 4 : déployer l'application Flask et configurer l'application

Déployer l'application Flask : transférez les fichiers de l'application Flask vers l'instance EC2. Si le modèle est déjà sur Git Hub, clonez-le dans l'instance EC2 Ubuntu. Ensuite, configurez un nouvel environnement virtuel et installez les packages Python requis ou le fichier d'exigences dans le répertoire à l'aide de pip. Ensuite, l'application Test Flask s'exécute correctement dans l'environnement EC2.

Dans notre cas, nous clonons un référentiel git, que nous avons utilisé dans le dernier article pour analyser le sentiment d'un tweet.

Mais d’abord, assurez-vous que git est installé. S'il est installé, exécutez la commande : 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

Remarque: Lorsque vous clonez le référentiel, vous ne verrez aucun fichier app.py ; à la place, myproject.py est présent, ce dont nous avons besoin.

Il existe un environnement virtuel existant que nous avons créé précédemment lors de la création locale d'une application Flask. Nous devons créer un nouvel environnement virtuel pour éviter les erreurs ou les divergences. Le nouvel environnement virtuel s'appelle « myprojectenv » et doit être activé.

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

Installez les bibliothèques Python stockées dans Requirements.txt

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

Maintenant, testez et exécutez votre application Python Flask

python3 myproject.py

En exécutant ceci, vous pouvez voir une sortie dans le terminal comme celle-ci :

Pour voir si ça marche. Visitez l'adresse IP de votre serveur suivie de : 5000 dans votre navigateur Web. Sur votre navigateur Web, l'IP de votre serveur est 5000, comme http://server_pub_ip:5000. Disons que l'adresse IP du serveur est  23.124.09.133. Mettez ensuite http://23.124.09.133:5000 

Étape 5 : fichier WSGI

Créez ensuite un fichier qui servira de point d’entrée à votre candidature. Ce fichier demandera au serveur Gunicorn d'interagir avec l'application.

créez un fichier wsgi.py dans le dossier Flask_model_sentiment_analysis

nano ~/Flask_model_sentiment_analysis/wsgi.py

Dans ce fichier, importez l'instance Flask depuis notre application, que nous avons nommée myproject.py, puis exécutez-la :

from myproject import app

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

Vous pouvez également installer sudo apt et unicorn en cas d'erreur.

Étape 6 : Configuration de Gunicorn

Commençons par configurer Gunicorn et lier l'application wsgi au port 5000

La commande unicorn configure démarre un serveur Gunicorn qui écoute les connexions entrantes sur le port 5000 à partir de n'importe quelle adresse IP et sert l'application WSGI nommée app définie dans le fichier wsgi.py.

gunicorn --bind 0.0.0.0:5000 wsgi:app

Sortie :

Vérifiez si cela fonctionne. Visitez l'adresse IP de votre serveur suivie de : 5000 dans votre navigateur Web : Sur votre navigateur Web, l'IP de votre serveur est 5000, comme http://server_pub_ip:5000 ; disons que l'adresse IP du serveur est  23.124.09.133. Mettez ensuite http://23.124.09.133:5000 

Cela devrait vous donner un résultat comme celui-ci :

Si vous obtenez la bonne réponse, arrêtez le service ; vous pouvez appuyer sur ctrl+c puis désactiver votre environnement virtuel en donnant la commande. Ensuite, créez le fichier système et l’unité de service. Cette action permettra au système d'initialisation d'Ubuntu de lancer automatiquement Gunicorn et d'héberger l'application Flask au démarrage du serveur.

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

Ajoutez le contenu suivant :

[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
  • [Unité]: Cette section spécifie les métadonnées et les dépendances de l'unité.
  • Description: Décrit le service.
  • Après = network.target: Il indique que cette unité démarre une fois le réseau opérationnel, garantissant ainsi la connectivité réseau avant le démarrage du service.
  • [Un service]: Cette section définit les paramètres du service.
  • Utilisateur=unitéubu : Il spécifie le compte utilisateur sous lequel le service doit être exécuté.
  • Groupe=www-data : Définit le groupe pour le service.
  • Directeur de travail: Spécifie le répertoire de travail du service.
  • Environnement=”PATH=/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin” : Cette variable définit les variables d'environnement du service, en définissant explicitement la variable PATH pour inclure le répertoire binaire de l'environnement virtuel.
  • ExecStart : Spécifie la commande pour démarrer le service. Dans ce cas, Gunicorn démarre avec des options spécifiques :
  • –ouvriers 3 : Configure Gunicorn pour utiliser trois processus de travail.
  • –bind unix : mon projet.sock : Spécifie le fichier socket via lequel Gunicorn communiquera avec le serveur Web (par exemple, Nginx ou Apache).
  • -m 007 : Définit le masque sur 007, contrôlant les autorisations des fichiers créés par Gunicorn.
  • wsgi:application : Indique l'emplacement de l'application WSGI à servir.
  • [Installer]: Cette section définit les informations d'installation de l'unité.
  • WantedBy=multi-user.target : Spécifie la cible dans laquelle cette unité doit être installée. Dans ce cas, il est défini sur multi-utilisateur. Target, une cible standard pour les systèmes utilisateur, indique que le service doit démarrer automatiquement lors du démarrage du système.

En résumé, ce fichier d'unité système configure Gunicorn pour qu'il serve une application Flask avec des configurations spécifiques et garantit que le service démarre automatiquement au démarrage du système.

Il est temps de démarrer le service Gunicorn que vous avez créé et de l'activer pour qu'il démarre au démarrage :

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

 Si la commande résiste, utilisez-la pour recharger « sudo systemctl daemon-reload »

Si vous avez suivi chaque étape, il ne devrait y avoir aucune erreur ; cependant, si l'erreur persiste, résolvez-la. Il peut y avoir une erreur dans le chemin ou l'environnement dans le fichier de service. Vérifiez attentivement

Étape 7 : installer et configurer NGINX

Le serveur d'application Gunicorn est opérationnel et en attente de requêtes via le fichier socket dans le répertoire du projet. Nous allons maintenant configurer Nginx pour diriger les requêtes Web vers ce socket en implémentant des modifications mineures à son fichier de configuration. Pour cela, nous devons d'abord installer nginx

sudo apt install nginx

Commencez par générer un nouveau fichier de configuration de bloc de serveur dans le répertoire des sites disponibles de Nginx. Nommez ce fichier « projet » pour ne pas vous tromper. Nous avons déjà utilisé le nom myproject.py

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

pour ajouter le contenu au fichier, qui a une configuration de bloc de serveur Nginx garantissant que les requêtes HTTP entrantes vers l'adresse IP du serveur spécifiée sont transmises au serveur d'applications Gunicorn via le fichier de socket Unix, permettant à l'application Flask de gérer les requêtes. Enregistrez le fichier et sortez de l'éditeur.

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;
    }
}
  • Serveur { … } : Ce bloc définit une configuration de serveur dans Nginx. Il encapsule les paramètres de configuration pour gérer les demandes pour un serveur spécifique.
  • Écoutez 80 : Cette directive spécifie que Nginx doit écouter les requêtes HTTP entrantes sur le port 80, le port par défaut pour le trafic HTTP.
  • nom_serveur 3.110.196.110 : Cette directive définit le nom d'hôte ou l'adresse IP du serveur. Dans ce cas, il est défini sur 3.110.196.110, qui doit être remplacé par l'adresse IP publique de votre serveur.
  • Emplacement / { … } : Ce bloc définit comment Nginx doit gérer les requêtes pour le répertoire racine / du serveur.
  • Incluez proxy_params : Cette directive fournit les paramètres de configuration du fichier proxy_params. Ces paramètres contiennent généralement des configurations liées au proxy, telles que les en-têtes de proxy.
  • proxy_pass http://unix:/home/ubuntu/Flask_model_sentiment_analysis/myproject.sock : Cette directive spécifie que Nginx doit transmettre les requêtes entrantes au fichier de socket Unix spécifié situé dans /home/ubuntu/Flask_model_sentiment_analysis/myproject.sock. C'est ici que Gunicorn écoute les demandes. Nginx agira comme un proxy inverse, transmettant les requêtes à Gunicorn et renvoyant les réponses au client.

Maintenant, activez et testez les erreurs

sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled
sudo nginx -t
  • sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled: Cette commande crée un lien symbolique nommé myproject dans le répertoire sites-enabled, pointant vers le fichier de configuration situé dans le répertoire sites-available. En faisant cela, vous activez la configuration du bloc serveur pour votre projet.
  • Sudo nginx -t : Cette commande teste la configuration Nginx pour les erreurs de syntaxe. Il vérifie si les fichiers de configuration Nginx, y compris le bloc serveur myproject nouvellement activé, sont correctement écrits et valides. S'il y a des erreurs, elles seront signalées lors de ce test.

Redémarrez le nginx car nous avons mis à jour les configurations

sudo systemctl restart nginx

mise à jour du pare-feu pour nginx

sudo ufw allow 'Nginx Full'

Puisque nous n'avons pas besoin du port 5000, nous pouvons le désactiver à l'aide de la commande « sudo ufw delete allow 5000 », mais nous n'avons pas besoin de désactiver le port 22.

Accédez maintenant au nom de domaine (ou à l'adresse IP) de votre serveur dans votre navigateur Web et vous verrez le résultat :

Si vous voyez une erreur telle que la passerelle 502, vous devez modifier certaines autorisations. Utilisez la commande

sudo chmod 755 /home/ubuntu

De plus, lorsque vous testez votre serveur pour l'application, vous devez utiliser http://….. et non https, car l'application n'est pas sécurisée.

S'il y a des erreurs, vous pouvez les vérifier via des commandes telles que :

Étape 7 : installer et configurer NGINX

Si vous souhaitez arrêter le service, vous pouvez utiliser la commande

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

Autres étapes pour sécuriser l'application

Il existe d'autres étapes pour sécuriser l'application.  

Activez HTTPS pour une communication sécurisée entre les clients et le serveur. Obtenez un certificat SSL/TLS (par exemple, Let's Encrypt) et configurez NGINX pour l'utiliser. Nous pouvons utiliser Certbot pour sécuriser l'application.

Pour sécuriser votre serveur Web avec SSL/TLS à l'aide de Certbot, vous avez généralement besoin d'un nom de domaine enregistré. Certbot nécessite un nom de domaine pour émettre des certificats SSL, car il vérifie la propriété du domaine avant d'émettre le certificat. Bien qu'il soit techniquement possible d'utiliser une adresse IP publique au lieu d'un nom de domaine, cela n'est pas recommandé pour plusieurs raisons. L'une concerne les exigences de l'autorité de certification (CA) : les autorités de certification (CA) comme Let's Encrypt (que Certbot utilise) ont mis en place des politiques qui nécessitent une validation de domaine. Ils ne délivreront pas de certificats SSL pour les adresses IP.

Si vous souhaitez le sécuriser, vous pouvez utiliser sudo apt install python3-certbot-nginx et en savoir plus dans sa documentation.

Conclusion

Dans cet article, nous avons créé une application Flask de base dans un environnement virtuel Python. Nous avons généré un point d'entrée WSGI, permettant la compatibilité avec n'importe quel serveur d'applications compatible WSGI, puis configuré Gunicorn pour remplir ce rôle. Par la suite, nous avons créé un fichier de service système pour lancer automatiquement le serveur d'applications au démarrage du système. De plus, vous avez construit un bloc de serveur Nginx chargé de diriger le trafic du client Web vers le serveur d'applications, de transmettre efficacement les requêtes externes et de protéger le trafic du serveur avec le chiffrement Let's Encrypt.

spot_img

Dernières informations

spot_img

Copyright @ 2024 Platon Technologies Inc.