Beskrivning

I den tidigare artikeln gick vi igenom processen att bygga en maskininlärningsmodell för sentimentanalys som var inkapslad i en Flask-applikation. Denna Flask-applikation använder sentimentanalys för att kategorisera tweets som positiva eller negativa. Redo för implementering, hela projektet är versionsstyrt på GitHub. När vi går vidare kommer vi nu att gå igenom hur man använder Gunicorn och Nginx för att distribuera denna Flask-applikation på en molnserver, vilket säkerställer att maskininlärningsmodellen är skalbar och tillgänglig i en produktionsmiljö.

Du kan följa föregående artikel på Hur distribuerar man en maskininlärningsmodell med hjälp av Flask?

När vi fortsätter där vi slutade kommer vi att använda Gunicorn och NGINX för att distribuera denna Flask-applikation på en molnserver. Det här inlägget kommer att förklara att flytta en Flask-applikation som ursprungligen var värd lokalt för maskininlärning till molnet.

Steg inkluderar

• Konfigurera en AWS EC2-instans: Starta en AWS EC2-instans med Ubuntu som operativsystem. Konfigurera säkerhetsgrupper för att tillåta inkommande trafik.
• SSH till EC2-instansen: Använd SSH för att ansluta till din EC2-instans från din lokala macWeis. Vi kräver ett SSH-nyckelpar (offentligt och privat) för att ansluta till ditt lokala system.
• Distribuera kolvapplikation: Överför Flask-applikationsfilerna till EC2-instansen. Om modellen redan finns på Git Hub, klona den in i EC2 Ubuntu-instansen. Konfigurera sedan en virtuell miljö och installera de nödvändiga Python-paketen eller kravfilen i katalogen med hjälp av pip. Testa om Flask-applikationen körs korrekt i EC2-miljön.
• Installationsberoenden: Uppdatera paketlistorna för uppgraderingar och installera nödvändiga beroenden, såsom Python, pip och alla andra bibliotek som krävs av din Flask-applikation.
• Installera och konfigurera Gunicorn: Installera Gunicorn, en WSGI HTTP-server för Python-applikationer. Skapa en Gunicorn-tjänstfil för att hantera ansökningsprocessen. Starta och aktivera Gunicorn-tjänsten att köra i bakgrunden.
• Installera och konfigurera NGINX: Installera NGINX, en högpresterande webbserver, och omvänd proxy. Konfigurera NGINX för att vidarebefordra inkommande HTTP-förfrågningar till Gunicorn-servern. Ställ in serverblock (virtuella värdar) för din Flask-applikation.
• Konfigurera domännamn (valfritt): Om du har ett domännamn, konfigurera DNS-inställningarna så att de pekar på din EC2-instansens offentliga IP-adress. Om inte kan du komma åt din Flask-applikation direkt från den offentliga IP-adressen.
• Säkra applikationen: Aktivera HTTPS för säker kommunikation mellan klienter och servern. Skaffa ett SSL/TLS-certifikat (t.ex. Let's Encrypt) och konfigurera NGINX att använda det.
• Testa implementeringen: När allt är konfigurerat, testa din distribuerade Flask-applikation genom att komma åt den via en webbläsare eller skicka förfrågningar med cURL eller Postman.

Genom att följa dessa steg kommer vi att framgångsrikt distribuera din Flask-applikation för maskininlärning på en AWS EC2-instans, med Gunicorn som WSGI-server och NGINX som en omvänd proxyserver för att hantera inkommande förfrågningar effektivt och säkert.

Innan vi börjar praktiskt, låt oss förstå hur det går till.

Förstå kommunikationen: Flask, Gunicorn och Nginx

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

Kolv: Applikationens centrum

Flask är ett lättviktigt och flexibelt Python-webbramverk som tillhandahåller verktygen för att bygga webbapplikationer/tjänster. Det är grunden för din sentimentanalystjänst, som hanterar inkommande webbförfrågningar, bearbetar dem med din maskininlärningsmodell och returnerar analysresultaten. Flask fungerar som applikationslagret i vår stack.

Vi skapade redan Flask-applikationen i den tidigare artikeln. Och klona den med kommandot.

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

Flask ensam kan inte hantera flera förfrågningar samtidigt; det är då Gunicorn kommer in i bilden.

Gunicorn: Python WSGI HTTP-servern

Gunicorn fungerar som ett mellanliggande lager som samverkar med Flask. Det är en Python WSGI HTTP-server designad för UNIX-system, och erbjuder ett enkelt men effektivt sätt att distribuera Python-webbapplikationer. När du kör din Flask-app med Gunicorn skapar den en WSGI-server som kommunicerar med Flask-applikationen. Gunicorn hanterar flera arbetsprocesser för att hantera inkommande förfrågningar, fördela belastningen och öka förmågan att hantera samtidiga användare. Nej. Antalet arbetare och trådar beror på antalet kärnor i systemet, 2*Cores +1.

Tills du har multithreading finns det inget separat minnesutrymme. En enskild arbetare kan hantera flera förfrågningar från klienterna parallellt.

Varför krävs Gunicorn?

Av olika anledningar är Gunicorn, eller Green Unicorn, en avgörande komponent för att vara värd för Flask-applikationer. För det första kan Flasks inbyggda utvecklingsserver inte hantera flera förfrågningar samtidigt, vilket gör den olämplig för produktionsmiljöer. Dess pre-fork worker-modell möjliggör skalbarhet genom att köra många arbetsprocesser eller trådar, vilket tar emot ökad trafik effektivt. G unicorns lastbalansering fördelar förfrågningar jämnt, vilket förbättrar prestandan under tung belastning. I enlighet med WSGI-specifikationen integreras Gunicorn sömlöst med Flask och andra WSGI-kompatibla ramverk, vilket förenklar driftsättningen. Gunicorn tillhandahåller viktiga funktioner som samtidighet, skalbarhet, prestanda och kompatibilitet, vilket gör det oumbärligt för att distribuera Flask-applikationer i produktionen.

Nginx: The Frontline Reverse Proxy

Nginx är en kraftfull, högpresterande webbserver känd för sin stabilitet, enkla konfiguration och låga resursförbrukning. I vår distribution är Nginx konfigurerad som en omvänd proxy, som sitter framför Gunicorn. Den tar emot kundförfrågningar och vidarebefordrar dem till Gunicorn, som i sin tur kommunicerar med Flask-applikationen. Nginx är också ansvarig för att servera statiska filer, hantera SSL/TLS-kryptering och potentiellt lastbalansering om din applikation skalas till flera servrar.

Varför Nginx?

Förutom att tillhandahålla Dessutom utmärker sig NGINX i att hantera flera modeller eller applikationer samtidigt, tack vare dess robusta lastbalanseringsförmåga och buffringsmekanismer. Medan Gunicorn kan kämpa med hastigheten på att behandla flera förfrågningar, kan NGINX effektivt hantera denna arbetsbelastning genom att buffra förfrågningar, vilket säkerställer smidigare drift. Dessutom tillhandahåller NGINX viktiga funktioner som SSL-avslutning, token-autentisering och lastbalansering, vilket gör det oumbärligt för att säkra och optimera Flask-applikationer. För ytterligare skalbarhet och flexibilitet kan Docker eller Kubernetes integreras tillsammans med NGINX, vilket möjliggör dynamisk skalning och förenklad hantering av tjänster. Oavsett om det distribueras på AWS eller Kubernetes, förblir NGINX ett mångsidigt och kraftfullt verktyg för värd för Flask-applikationer i stor skala.

Förutsättningar

Innan du använder stegen för att distribuera din modell bör du förstå och ha följande.

AWS-konto: Du behöver ett AWS-konto för att komma åt EC2 och andra AWS-tjänster. Om du inte har ett konto kan du registrera dig för ett på AWS webbplats.

Om du vill att din app ska visas med ett namn måste du ha ett domännamn konfigurerat för att peka på din server. Du kan få en gratis på Freename. Vi behöver inte detta här eftersom vi kommer att använda den offentliga IP-adressen direkt.

Förståelse av WSGI-filspecifikationer och servrar, proxy och portar. Lite förståelse kommer också att hjälpa.

Distribuera maskininlärningsmodell med hjälp av Flask på AWS med Gunicorn och Nginx

STEG 1: Konfigurera en AWS EC2-instans

Starta en AWS EC2-instans med Ubuntu som operativsystem. En mikrotjänst skulle fungera alldeles utmärkt. Vi behåller instansens namn som sentiment_analysis_server. Du är fri att välja vad du gillar. Men kom ihåg att instansens tjänstval beror på skalan på applikationen du försöker vara värd för.

Skapa ett nyckelpar för att ansluta säkert till din EC2 via SSH. När du skapar en EC2-instans anger du ett nyckelpar, och motsvarande privata nyckelfil (.pem) används för att autentisera din SSH-anslutning till instansen. Använd ett nyckelpar av RSA-typ och följ stegen nedan.

1. Skapa nyckelpar: Klicka på knappen "Skapa nyckelpar" för att skapa nyckelparet.
2. Ladda ner privat nyckel: När nyckelparet har skapats kommer en privat nyckelfil (.pem) automatiskt att laddas ner till din lokala dator. Den här privata nyckelfilen autentiserar SSH-anslutningar till dina EC2-instanser.

Starta din instans med säkerhetskonfigurationer som tillåter port- och http-trafik. Efter att du har startat och anslutit till din instans, kopiera SSH-kommandot från den så att du kan lägga upp det på din lokala terminal för att komma åt instansen på distans. I följande bild är den grönmarkerade delen vad du behöver kopiera och klistra in i din lokala/terminal.

STEG 2: SSH till EC2-instansen

Öppna din dators terminal. Om din privata nyckelfil (.pem) finns i en katalog, måste du ange den fullständiga sökvägen till nyckelfilen när du använder SSH-kommandot för att ansluta till din EC2-instans. Så här kan du göra det:

Låt oss säga att din nyckel (.pem-fil) finns i Nedladdningar. Sedan måste du placera ditt SSH-kommando där. Så allt du behöver göra är att öppna din terminal, navigera till nedladdningskatalogen och klistra in ditt kommando där.

cd ~/Downloads

Klistra in ditt SSH-kommando, som kan se ut som exemplet: ssh -i "sentiment_analysiskey.pem" [e-postskyddad]

STEG 3: Installera de nödvändiga komponenterna från Ubuntu Repositories

Det första steget är att installera alla nödvändiga komponenter från Ubuntu-förråden. Detta inkluderar Python-komponenterna, som Pip kommer att hantera, och Python-pakethanteraren. Python-utvecklingsfilerna som krävs för att montera Gunicorn-komponenter kommer också att tillhandahållas. När du installerar paketen som gör att du kan skapa din Python-miljö måste du först uppdatera det lokala paketindexet.

sudo apt update 
sudp apt upgrade 

Installera sedan Python-pip-kommandot för att installera pip och den virtuella miljön.

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

Installera sedan net stat-paketet. Net-tools-paketet visar nätverksrelaterad information, såsom aktiva nätverksanslutningar, routingtabeller, gränssnittsstatistik, etc.

sudo apt installera net-tools

sudo apt install net-tools

netstat tuln #after installing run this command 

Den visar en lista över aktiva nätverksanslutningar och lyssningsportar på systemet:

Installera sedan brandväggspaketet: ufw (Okomplicerad brandvägg)-paketet är ett gränssnitt för att hantera iptables brandväggsregler på Ubuntu och andra Debian-baserade Linux-distributioner. Det ger ett förenklat gränssnitt för att konfigurera brandväggsregler, vilket gör det enklare att konfigurera grundläggande brandväggsskydd för ditt system

• sudo ufw aktivera: Aktiverar brandväggen.
• Sudo ufw tillåter /: Detta kommando tillåter inkommande anslutningar på en specifik port och protokoll (t.ex. sudo ufw tillåter 22/TCP att aktivera SSH-anslutningar).
• Sudo ufw status: Visar aktuell status och regler för brandväggen.

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 tillåter 5000: Detta tillåter inkommande anslutningar på port 5000. Som standard tillåter det både TCP- och UDP-trafik på denna port. Vi kommer att köra vår Flask-app på 5000, så Flask-appen som körs på port 5000 måste vara tillgänglig från nätverket.
2. Sudo ufw tillåter 22: Detta kommando aktiverar inkommande SSH-anslutningar på port 22. SSH används för fjärråtkomst till ditt system, och om du tillåter anslutningar på port 22 kan du ansluta till din server via SSH säkert. Det här är viktigt; du bör inte stänga av detta, eftersom du inte kommer att kunna komma åt din SSH på distans.

Steg 4: Distribuera Flask-applikationen och konfigurera applikationen

Deploy Flask Application: Överför Flask-applikationsfilerna till EC2-instansen. Om modellen redan finns på Git Hub, klona den in i EC2 Ubuntu-instansen. Konfigurera sedan en ny virtuell miljö och installera de nödvändiga Python-paketen eller kravfilen i katalogen med hjälp av pip. Sedan körs Test Flask-applikationen korrekt i EC2-miljön.

I vårt fall klonar vi ett git-förråd, som vi använde i den förra artikeln för att analysera känslan av en tweet.

Men först, se till att git är installerat. Om det är installerat, kör kommandot: 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 

Notera: När du klona förvaret kommer du inte att se någon app.py-fil; istället finns myproject.py närvarande, vilket vi kräver.

Det finns en befintlig virtuell miljö som vi skapade tidigare när vi skapade en Flask-app lokalt. Vi måste skapa en ny virtuell miljö för att undvika fel eller avvikelser. Den nya virtuella miljön heter "myprojectenv" och måste aktiveras.

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

Installera Python-biblioteken lagrade i requirements.txt

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

Testa och kör nu din Python Flask-applikation

python3 myproject.py

Genom att köra detta kan du se en utgång i terminalen så här:

För att se om det fungerar. Besök din servers IP-adress följt av:5000 i din webbläsare. I din webbläsare är din server-IP 5000, som http://server_pub_ip:5000. Låt oss säga att serverns IP är  23.124.09.133. Sen Lägg http://23.124.09.133:5000 

Steg 5: WSGI-fil

Skapa sedan en fil som kommer att fungera som startpunkt för din ansökan. Den här filen kommer att instruera Gunicorn-servern att interagera med applikationen.

skapa en wsgi.py-fil i mappen Flask_model_sentiment_analysis

nano ~/Flask_model_sentiment_analysis/wsgi.py 

I den här filen importerar du Flask-instansen från vår applikation, som vi döpte till myproject.py, och kör den sedan:

from myproject import app

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

Du kan också installera sudo apt och unicorn om det finns något fel.

Steg 6: Gunicorn-konfiguration

Låt oss börja med att konfigurera Gunicorn och binda wsgi-appen till port 5000

unicorn configure-kommandot startar en Gunicorn-server som lyssnar efter inkommande anslutningar på port 5000 från valfri IP-adress och serverar WSGI-applikationen med namnet app som definieras i filen wsgi.py.

gunicorn --bind 0.0.0.0:5000 wsgi:app

Produktion:

Kontrollera om det fungerar. Besök din servers IP-adress följt av:5000i din webbläsare: På din webbläsare är din server-IP 5000, som http://server_pub_ip:5000; låt oss säga att serverns IP är  23.124.09.133. Sen Lägg http://23.124.09.133:5000 

Det borde ge dig en utdata så här:

Om du får rätt svar, stoppa tjänsten; du kan trycka på ctrl+c och sedan avaktivera din virtuella miljö genom att ge kommandot. Skapa sedan system- och serviceenhetsfilen. Denna åtgärd gör det möjligt för Ubuntus init-system att automatiskt initiera Gunicorn och vara värd för Flask-applikationen vid serverstart.

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

Lägg till följande innehåll:

[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

• [Enhet]: Det här avsnittet specificerar metadata och beroenden för enheten.
• Beskrivning: Beskriver tjänsten.
• Efter = network.target: Det indikerar att den här enheten startar efter att nätverket är uppe, vilket säkerställer nätverksanslutning innan tjänsten startar.
• [Service]: Det här avsnittet definierar parametrarna för tjänsten.
• User=ubunit: Den anger vilket användarkonto tjänsten ska köras under.
• Group=www-data: Ställer in gruppen för tjänsten.
• WorkingDirectory: Anger arbetskatalogen för tjänsten.
• Environment=”PATH=/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin”: Denna variabel definierar tjänstens miljövariabler och ställer explicit in PATH-variabeln att inkludera den virtuella miljöns binära katalog.
• ExecStart: Anger kommandot för att starta tjänsten. I det här fallet startar det Gunicorn med specifika alternativ:
• –arbetare 3: Konfigurerar Gunicorn för att använda tre arbetsprocesser.
• –bind unix: mitt projekt.sock: Anger socketfilen genom vilken Gunicorn kommer att kommunicera med webbservern (t.ex. Nginx eller Apache).
• -m 007: Ställer in masken till 007, kontrollerar behörigheterna för filer skapade av Gunicorn.
• wsgi:app: Indikerar platsen för WSGI-applikationen som ska visas.
• [Installera]: Detta avsnitt definierar installationsinformation för enheten.
• WantedBy=multi-user.target: Anger målet som denna enhet ska installeras i. I det här fallet är den inställd på flera användare. Target, ett standardmål för användarsystem, indikerar att tjänsten ska starta automatiskt under systemstart.

Sammanfattningsvis ställer denna systemenhetsfil in Gunicorn för att tjäna en Flask-applikation med specifika konfigurationer och säkerställer att tjänsten startar automatiskt vid systemstart.

Dags att starta Gunicorn-tjänsten som du skapade och aktivera den så att den startar vid uppstart:

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

 Om kommandot motstår, använd det här för att ladda om "sudo systemctl daemon-reload,"

Om du har följt varje steg ska det inte finnas några fel; men om felet kvarstår, åtgärda felet. Det kan finnas ett fel i sökvägen eller miljön i tjänstefilen. Kontrollera noggrant

Steg 7: Installera och konfigurera NGINX

Gunicorn-applikationsservern är i drift och väntar på förfrågningar via socket-filen i projektkatalogen. Nu ska vi konfigurera Nginx för att rikta webbförfrågningar till denna socket genom att implementera mindre ändringar av dess konfigurationsfil. För detta måste vi installera nginx först

sudo apt install nginx

Börja med att generera en ny konfigurationsfil för serverblock i Nginx's webbplats-tillgängliga katalog. Namnge den här filen "projekt" för att inte bli förvirrad. Vi har använt namnet myproject.py tidigare

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

att lägga till innehållet till filen, som har Nginx-serverblockkonfiguration som säkerställer att inkommande HTTP-förfrågningar till den angivna serverns IP-adress vidarebefordras till Gunicorn-applikationsservern via Unix-socket-filen, vilket gör att Flask-applikationen kan hantera förfrågningarna. Spara filen och gå ut ur redigeraren.

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;
    }
}

• Server { … }: Detta block definierar en serverkonfiguration inom Nginx. Den kapslar in konfigurationsinställningarna för hantering av förfrågningar för en specifik server.
• Lyssna 80: Detta direktiv specificerar att Nginx ska lyssna efter inkommande HTTP-förfrågningar på port 80, standardporten för HTTP-trafik.
• servernamn 3.110.196.110: Detta direktiv anger serverns värdnamn eller IP-adress. I det här fallet är den inställd på 3.110.196.110, som bör ersättas med din servers offentliga IP-adress.
• Plats / { … }: Detta block definierar hur Nginx ska hantera förfrågningar för rotkatalogen / på servern.
• Inkludera proxy_params: Detta direktiv tillhandahåller konfigurationsinställningar från filen proxy_params. Dessa inställningar innehåller vanligtvis proxyrelaterade konfigurationer, såsom proxyhuvuden.
• proxy_pass http://unix:/home/ubuntu/Flask_model_sentiment_analysis/myproject.sock: Detta direktiv specificerar att Nginx ska vidarebefordra inkommande förfrågningar till den specificerade Unix-socketfilen som finns på /home/ubuntu/Flask_model_sentiment_analysis/myproject.sock. Det är här Gunicorn lyssnar på förfrågningar. Nginx kommer att fungera som en omvänd proxy, skicka förfrågningar till Gunicorn och returnera svaren till klienten.

Aktivera och testa nu för fel

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: Det här kommandot skapar en symbolisk länk som heter myproject i den webbplatsaktiverade katalogen, som pekar på konfigurationsfilen som finns i katalogen med webbplatser som är tillgängliga. Genom att göra detta aktiverar du serverblockkonfigurationen för ditt projekt.
• Sudo nginx -t: Detta kommando testar Nginx-konfigurationen för syntaxfel. Den kontrollerar om Nginx-konfigurationsfilerna, inklusive det nyligen aktiverade myproject-serverblocket, är korrekt skrivna och giltiga. Om det finns några fel kommer de att rapporteras under detta test.

Starta om nginx när vi har uppdaterat konfigurationerna

sudo systemctl restart nginx

uppdaterar brandväggen för nginx

sudo ufw allow 'Nginx Full'

Eftersom vi inte behöver 5000-porten kan vi inaktivera den med kommandot "sudo ufw delete allow 5000", men vi behöver inte inaktivera port 22.

Navigera nu till din servers domännamn (eller IP-adress) i din webbläsare, och du kommer att se resultatet:

Om du ser något fel som 502 gateway, måste du ändra vissa behörigheter. Använd kommandot

sudo chmod 755 /home/ubuntu

När du testar din server för applikationen bör du också använda http://….. och inte https, eftersom applikationen inte är säker.

Om det finns fel kan du kontrollera dem genom kommandon som:

Om du vill stoppa tjänsten kan du använda kommandot

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

Ytterligare steg för att säkra applikationen

Det finns ytterligare steg för att säkra applikationen.  

Aktivera HTTPS för säker kommunikation mellan klienter och servern. Skaffa ett SSL/TLS-certifikat (t.ex. Let's Encrypt) och konfigurera NGINX att använda det. Vi kan använda Certbot för att säkra applikationen.

För att säkra din webbserver med SSL/TLS med Certbot behöver du vanligtvis ett registrerat domännamn. Certbot kräver ett domännamn för att utfärda SSL-certifikat eftersom det verifierar domänägandet innan certifikatet utfärdas. Även om det är tekniskt möjligt att använda en offentlig IP-adress istället för ett domännamn, rekommenderas det inte av flera skäl. Ett är krav på certifikatutfärdare (CA): certifikatutfärdare (CA) som Let's Encrypt (som Certbot använder) har policyer på plats som kräver domänvalidering. De kommer inte att utfärda SSL-certifikat för IP-adresser.

Om du vill säkra det kan du använda sudo apt install python3-certbot-nginx och lära dig mer om det i dess dokumentation.

Slutsats

I den här artikeln skapade vi en grundläggande Flask-applikation i en virtuell Python-miljö. Vi genererade en WSGI-ingångspunkt, som möjliggör kompatibilitet med alla WSGI-kompatibla applikationsservrar, och konfigurerade sedan Gunicorn för att uppfylla denna roll. Därefter skapade vi en systemtjänstfil för att initiera applikationsservern automatiskt vid systemstart. Dessutom konstruerade du ett Nginx-serverblock som ansvarar för att dirigera webbklienttrafik till applikationsservern, effektivt vidarebefordra externa förfrågningar och skydda servertrafiken med Let's Encrypt-kryptering.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://www.analyticsvidhya.com/blog/2024/04/ml-using-flask-on-aws-gunicorn-nginx/