Zephyrnet-logo

Generativ dataintelligens

Store data

Distribuere maskinlæringsmodell ved å bruke Flask på AWS med Gunicorn og Nginx

Publisert av Platon
Publisert av Platon

Dato:

Visninger: 51

Introduksjon

I den forrige artikkelen gikk vi gjennom prosessen med å bygge en maskinlæringsmodell for sentimentanalyse som ble innkapslet i en Flask-applikasjon. Denne Flask-applikasjonen bruker sentimentanalyse for å kategorisere tweets som positive eller negative. Klart for implementering, hele prosjektet er versjonskontrollert på GitHub. Når vi går videre, vil vi nå gå gjennom hvordan du bruker Gunicorn og Nginx til å distribuere denne Flask-applikasjonen på en skyserver, og sikrer at maskinlæringsmodellen er skalerbar og tilgjengelig i et produksjonsmiljø.

Du kan følge forrige artikkel på Hvordan distribuere en maskinlæringsmodell ved hjelp av Flask?

Når vi fortsetter der vi slapp, vil vi bruke Gunicorn og NGINX til å distribuere denne Flask-applikasjonen på en skyserver. Dette innlegget vil forklare flytting av en Flask-applikasjon som opprinnelig var lokalt vert for maskinlæringsdistribusjon til skyen.

Utplassering av maskinlæringsmodell ved hjelp av Flask på AWS med Gunicorn og Nginx

Innholdsfortegnelse

Trinn inkluderer

  • Sett opp en AWS EC2-instans: Start en AWS EC2-instans med Ubuntu som operativsystem. Konfigurer sikkerhetsgrupper for å tillate innkommende trafikk.
  • SSH inn i EC2-forekomsten: Bruk SSH for å koble til din EC2-instans fra din lokale macWeis. Vi krever et SSH-nøkkelpar (offentlig og privat) for å koble til ditt lokale system.
  • Distribuer Flask Application: Overfør Flask-applikasjonsfilene til EC2-forekomsten. Hvis modellen allerede er på Git Hub, klone den inn i EC2 Ubuntu-forekomsten. Sett deretter opp et virtuelt miljø og installer de nødvendige Python-pakkene eller kravfilen i katalogen ved hjelp av pip. Test om Flask-applikasjonen kjører riktig i EC2-miljøet.
  • Installasjonsavhengigheter: Oppdater pakkelistene for oppgraderinger og installer nødvendige avhengigheter, for eksempel Python, pip og andre biblioteker som kreves av din Flask-applikasjon.
  • Installer og konfigurer Gunicorn: Installer Gunicorn, en WSGI HTTP-server for Python-applikasjoner. Opprett en Gunicorn-tjenestefil for å administrere søknadsprosessen. Start og aktiver Gunicorn-tjenesten til å kjøre i bakgrunnen.
  • Installer og konfigurer NGINX: Installer NGINX, en høyytelses webserver, og omvendt proxy. Konfigurer NGINX til å videresende innkommende HTTP-forespørsler til Gunicorn-serveren. Sett opp serverblokker (virtuelle verter) for din Flask-applikasjon.
  • Konfigurer domenenavn (valgfritt): Hvis du har et domenenavn, konfigurer DNS-innstillingene til å peke til EC2-forekomstens offentlige IP-adresse. Hvis ikke, kan du få tilgang til Flask-applikasjonen din direkte fra den offentlige IP-adressen.
  • Sikre applikasjonen: Aktiver HTTPS for sikker kommunikasjon mellom klienter og serveren. Skaff et SSL/TLS-sertifikat (f.eks. Let's Encrypt) og konfigurer NGINX til å bruke det.
  • Test implementeringen: Når alt er konfigurert, test din distribuerte Flask-applikasjon ved å få tilgang til den via en nettleser eller sende forespørsler ved hjelp av cURL eller Postman.

Ved å følge disse trinnene vil vi implementere Flask-applikasjonen din for maskinlæring på en AWS EC2-instans, ved å bruke Gunicorn som WSGI-server og NGINX som en omvendt proxy-server for å håndtere innkommende forespørsler effektivt og sikkert.

Før du begynner med hands-on, la oss forstå hvordan det gjøres.

Forstå kommunikasjonen: Flask, Gunicorn og Nginx

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

Flaske: Senteret for applikasjonen

Flask er et lett og fleksibelt Python-nettrammeverk som gir verktøyene for å bygge nettapplikasjoner/tjenester. Det er grunnlaget for sentimentanalysetjenesten din, som håndterer innkommende nettforespørsler, behandler dem ved hjelp av maskinlæringsmodellen din og returnerer analyseresultatene. Flask fungerer som påføringslaget i stabelen vår.

Vi har allerede laget Flask-applikasjonen i forrige artikkel. Og klone den ved å bruke kommandoen.

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

Flask alene kan ikke håndtere flere forespørsler om gangen; det er da Gunicorn kommer inn i bildet.

Gunicorn: Python WSGI HTTP-serveren

Gunicorn fungerer som et mellomlag som har grensesnitt med Flask. Det er en Python WSGI HTTP-server designet for UNIX-systemer, og tilbyr en enkel, men effektiv måte å distribuere Python-webapplikasjoner på. Når du kjører Flask-appen din med Gunicorn, oppretter den en WSGI-server som kommuniserer med Flask-applikasjonen. Gunicorn administrerer flere arbeidsprosesser for å håndtere innkommende forespørsler, fordele belastningen og øke muligheten til å håndtere samtidige brukere. Nei. Antall arbeidere og tråder avhenger av antall kjerner i systemet, 2*Kjerner +1.

Inntil du har multithreading, er det ingen separat minneplass. En enkelt arbeider kan håndtere flere forespørsler fra klientene parallelt.

Hvorfor er Gunicorn påkrevd?

Av ulike grunner er Gunicorn, eller Green Unicorn, en avgjørende komponent i hosting av Flask-applikasjoner. For det første kan ikke Flasks innebygde utviklingsserver håndtere flere forespørsler samtidig, noe som gjør den uegnet for produksjonsmiljøer. Dens pre-fork worker-modell muliggjør skalerbarhet ved å kjøre en rekke arbeidsprosesser eller tråder, og imøtekomme økt trafikk effektivt. G unicorns lastbalansering fordeler forespørsler jevnt, og forbedrer ytelsen under tung belastning. I samsvar med WSGI-spesifikasjonen integreres Gunicorn sømløst med Flask og andre WSGI-kompatible rammeverk, noe som forenkler distribusjonen. Gunicorn gir viktige funksjoner som samtidighet, skalerbarhet, ytelse og kompatibilitet, noe som gjør det uunnværlig for å distribuere Flask-applikasjoner i produksjon.

Nginx: Frontline Reverse Proxy

Nginx er en kraftig nettserver med høy ytelse kjent for sin stabilitet, enkle konfigurasjon og lave ressursforbruk. I vår distribusjon er Nginx konfigurert som en omvendt proxy, som sitter foran Gunicorn. Den mottar klientforespørsler og videresender dem til Gunicorn, som igjen kommuniserer med Flask-applikasjonen. Nginx er også ansvarlig for å betjene statiske filer, håndtere SSL/TLS-kryptering og potensielt lastbalansering hvis applikasjonen din skaleres til flere servere.

Hvorfor Nginx?

Bortsett fra å tilby Dessuten utmerker NGINX seg i å håndtere flere modeller eller applikasjoner samtidig, takket være sine robuste lastbalanseringsevner og buffermekanismer. Mens Gunicorn kan slite med hastigheten på å behandle flere forespørsler, kan NGINX effektivt håndtere denne arbeidsbelastningen ved å bufre forespørsler, og sikre jevnere drift. I tillegg gir NGINX viktige funksjoner som SSL-terminering, token-autentisering og lastbalansering, noe som gjør det uunnværlig for å sikre og optimalisere Flask-applikasjoner. For ytterligere skalerbarhet og fleksibilitet kan Docker eller Kubernetes integreres sammen med NGINX, noe som muliggjør dynamisk skalering og forenklet administrasjon av tjenester. Enten den er distribuert på AWS eller Kubernetes, er NGINX fortsatt et allsidig og kraftig verktøy for hosting av Flask-applikasjoner i stor skala.

Forutsetninger

Før du bruker trinnene for å distribuere modellen din, bør du forstå og ha følgende.

AWS-konto: Du trenger en AWS-konto for å få tilgang til EC2 og andre AWS-tjenester. Hvis du ikke har en konto, kan du registrere deg for en på AWS-nettstedet.

Hvis du vil at appen din skal vises med et navn, må du ha et domenenavn konfigurert til å peke til serveren din. Du kan få en gratis på Freenom. Vi trenger ikke dette her siden vi vil bruke den offentlige IP-adressen direkte.

Forståelse av WSGI-filspesifikasjoner og servere, proxy og porter. Litt forståelse vil også hjelpe.

Distribuere maskinlæringsmodell ved å bruke Flask på AWS med Gunicorn og Nginx

TRINN 1: Sett opp en AWS EC2-instans

Start en AWS EC2-instans med Ubuntu som operativsystem. En mikrotjeneste ville fungere helt fint. Vi beholder forekomstens navn som sentiment_analysis_server. Du står fritt til å velge hva du liker. Men husk at forekomstens tjenestevalg avhenger av skalaen til applikasjonen du prøver å være vert for.

Sett opp en AWS EC2-instans

Lag et nøkkelpar for å koble sikkert til din EC2 gjennom SSH. Når du oppretter en EC2-forekomst, spesifiserer du et nøkkelpar, og den tilsvarende private nøkkelfilen (.pem) brukes til å autentisere din SSH-forbindelse til forekomsten. Bruk et nøkkelpar av RSA-typen og følg trinnene nedenfor.

  1. Opprett nøkkelpar: Klikk på "Opprett nøkkelpar"-knappen for å generere nøkkelparet.
  2. Last ned privat nøkkel: Når nøkkelparet er opprettet, vil en privat nøkkelfil (.pem) automatisk lastes ned til din lokale maskin. Denne private nøkkelfilen autentiserer SSH-tilkoblinger til EC2-forekomstene dine.
Sett opp en AWS EC2-instans

Start forekomsten din med sikkerhetskonfigurasjoner som tillater port- og http-trafikk. Etter å ha startet og koblet til instansen din, kopier SSH-kommandoen fra den slik at du kan legge den ut på din lokale terminal for å få tilgang til instansen eksternt. I det følgende bildet er den grønne uthevede delen det du trenger for å kopiere og lime inn i din lokale/terminal.

Koble til forekomst

TRINN 2: SSH inn i EC2-forekomsten

Åpne datamaskinens terminal. Hvis din private nøkkelfil (.pem) ligger i en katalog, må du spesifisere hele banen til nøkkelfilen når du bruker SSH-kommandoen for å koble til EC2-forekomsten. Slik kan du gjøre det:

La oss si at nøkkelen (.pem-fil) er i Nedlastinger. Deretter må du plassere SSH-kommandoen din der. Så alt du trenger å gjøre er å åpne terminalen din, naviger til nedlastingskatalogen og lim inn kommandoen din der.

cd ~/Downloads

Lim inn SSH-kommandoen din, som kan se ut som eksempelet: ssh -i "sentiment_analysiskey.pem" [e-postbeskyttet]

SSH inn i EC2-instansen

TRINN 3: Installere de nødvendige komponentene fra Ubuntu Repositories

Det første trinnet er å installere alle nødvendige komponenter fra Ubuntu-depotene. Dette inkluderer Python-komponentene, som Pip skal administrere, og Python-pakkebehandleren. Python-utviklingsfilene som kreves for å sette sammen Gunicorn-komponenter vil også bli levert. Når du installerer pakkene som lar deg lage ditt Python-miljø, må du først oppdatere den lokale pakkeindeksen.

sudo apt update 
sudp apt upgrade

Installer deretter Python-pip-kommandoen for å installere pip og det virtuelle miljøet.

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

Installer deretter net stat-pakken. Nettools-pakken viser nettverksrelatert informasjon, for eksempel aktive nettverkstilkoblinger, rutingtabeller, grensesnittstatistikk, etc.

sudo apt installer nettools

sudo apt install net-tools

netstat tuln #after installing run this command

Den viser en liste over aktive nettverkstilkoblinger og lytteporter på systemet:

Installer deretter brannmurpakken: ufw (Ucomplicated Firewall)-pakken er en front-end for å administrere iptables brannmurregler på Ubuntu og andre Debian-baserte Linux-distribusjoner. Det gir et forenklet grensesnitt for å konfigurere brannmurregler, noe som gjør det enklere å sette opp viktig brannmurbeskyttelse for systemet ditt

  • sudo ufw aktiver: Aktiverer brannmuren.
  • Sudo ufw tillat /: Denne kommandoen tillater innkommende tilkoblinger på en spesifikk port og protokoll (f.eks. tillater sudo ufw 22/TCP å aktivere SSH-tilkoblinger).
  • Sudo ufw status: Viser gjeldende status og regler for brannmuren.
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 tillat 5000: Dette tillater innkommende tilkoblinger på port 5000. Som standard tillater det både TCP- og UDP-trafikk på denne porten. Vi skal kjøre Flask-appen vår på 5000, så Flask-appen som kjører på port 5000 må være tilgjengelig fra nettverket.
  2. Sudo ufw tillat 22: Denne kommandoen aktiverer innkommende SSH-tilkoblinger på port 22. SSH brukes for ekstern tilgang til systemet ditt, og ved å tillate tilkoblinger på port 22 kan du koble til serveren din via SSH sikkert. Dette er viktig; du bør ikke slå av dette, siden du ikke kan få tilgang til SSH-en din eksternt.

Trinn 4: Distribuer Flask-applikasjonen og konfigurer applikasjonen

Distribuer Flask Application: Overfør Flask-applikasjonsfilene til EC2-forekomsten. Hvis modellen allerede er på Git Hub, klone den inn i EC2 Ubuntu-forekomsten. Sett deretter opp et nytt virtuelt miljø og installer de nødvendige Python-pakkene eller kravfilen i katalogen ved hjelp av pip. Deretter kjører Test Flask-applikasjonen riktig i EC2-miljøet.

I vårt tilfelle kloner vi et git-depot, som vi brukte i den siste artikkelen for å analysere sentimentet til en tweet.

Men først, sørg for at git er installert. Hvis det er installert, kjør kommandoen: 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

OBS: Når du kloner depotet, vil du ikke se noen app.py-fil; i stedet er myproject.py til stede, noe vi krever.

Det er et eksisterende virtuelt miljø som vi opprettet tidligere mens vi opprettet en Flask-app lokalt. Vi må lage et nytt virtuelt miljø for å unngå feil eller avvik. Det nye virtuelle miljøet heter "myprojectenv" og må aktiveres.

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

Installer Python-bibliotekene som er lagret i requirements.txt

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

Test og kjør Python Flask-applikasjonen din

python3 myproject.py

Ved å kjøre dette kan du se en utgang i terminalen slik:

For å se om det fungerer. Besøk serverens IP-adresse etterfulgt av:5000 i nettleseren din. På nettleseren din er serverens IP 5000, som http://server_pub_ip:5000. La oss si at serverens IP er  23.124.09.133. Sett deretter http://23.124.09.133:5000 

Trinn 5: WSGI-fil

Deretter oppretter du en fil som vil fungere som inngangspunkt for applikasjonen din. Denne filen vil instruere Gunicorn-serveren til å samhandle med applikasjonen.

opprett en wsgi.py-fil i mappen Flask_model_sentiment_analysis

nano ~/Flask_model_sentiment_analysis/wsgi.py

I denne filen importerer du Flask-forekomsten fra applikasjonen vår, som vi kalte myproject.py, og kjør den deretter:

from myproject import app

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

Du kan også installere sudo apt og unicorn hvis det er noen feil.

Trinn 6: Gunicorn-konfigurasjon

La oss begynne med å konfigurere Gunicorn og binde wsgi-appen til port 5000

unicorn configure-kommandoen starter en Gunicorn-server som lytter etter innkommende tilkoblinger på port 5000 fra en hvilken som helst IP-adresse og betjener WSGI-applikasjonen med navnet app definert i wsgi.py-filen.

gunicorn --bind 0.0.0.0:5000 wsgi:app

Utgang:

Sjekk om det fungerer. Besøk serverens IP-adresse etterfulgt av:5000i nettleseren din: På nettleseren din er serverens IP-adresse 5000, som http://server_pub_ip:5000; la oss si at serverens IP er  23.124.09.133. Sett deretter http://23.124.09.133:5000 

Det bør gi deg en utgang som dette:

Hvis du får riktig svar, stopp tjenesten; du kan trykke ctrl+c og deretter deaktivere ditt virtuelle miljø ved å gi kommandoen. Deretter oppretter du system- og tjenesteenhetsfilen. Denne handlingen vil gjøre det mulig for Ubuntus init-system å automatisk starte Gunicorn og være vert for Flask-applikasjonen ved serveroppstart.

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

Legg til følgende innhold:

[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]: Denne delen spesifiserer metadata og avhengigheter for enheten.
  • Beskrivelse: Beskriver tjenesten.
  • Etter = network.target: Det indikerer at denne enheten starter etter at nettverket er oppe, og sikrer nettverkstilkobling før tjenesten starter.
  • [Service]: Denne delen definerer parametrene for tjenesten.
  • Bruker=ubuunit: Den spesifiserer brukerkontoen som tjenesten skal kjøres under.
  • Group=www-data: Angir gruppen for tjenesten.
  • WorkingDirectory: Angir arbeidskatalogen for tjenesten.
  • Environment=”PATH=/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin”: Denne variabelen definerer tjenestens miljøvariabler, og angir eksplisitt PATH-variabelen til å inkludere det virtuelle miljøets binære katalog.
  • ExecStart: Angir kommandoen for å starte tjenesten. I dette tilfellet starter det Gunicorn med spesifikke alternativer:
  • –arbeidere 3: Konfigurerer Gunicorn til å bruke tre arbeidsprosesser.
  • –bind unix: mitt prosjekt.sokk: Spesifiserer socket-filen som Gunicorn vil kommunisere med webserveren gjennom (f.eks. Nginx eller Apache).
  • -m 007: Setter masken til 007, kontrollerer tillatelsene til filer opprettet av Gunicorn.
  • wsgi:app: Indikerer plasseringen til WSGI-applikasjonen som skal betjenes.
  • [Installere]: Denne delen definerer installasjonsinformasjon for enheten.
  • WantedBy=multi-user.target: Angir målet som denne enheten skal installeres i. I dette tilfellet er den satt til multi-user. Target, et standardmål for brukersystemer, indikerer at tjenesten skal starte automatisk under systemoppstart.

Oppsummert setter denne systemenhetsfilen opp Gunicorn til å betjene en Flask-applikasjon med spesifikke konfigurasjoner og sikrer at tjenesten starter automatisk ved systemoppstart.

På tide å starte Gunicorn-tjenesten du opprettet og aktivere den slik at den starter ved oppstart:

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

 Hvis kommandoen motstår, bruk denne til å laste "sudo systemctl daemon-reload" på nytt.

Hvis du har fulgt hvert trinn, skal det ikke være noen feil; men hvis feilen vedvarer, løs feilen. Det kan være en feil i banen eller miljøet i tjenestefilen. Sjekk nøye

Trinn 7: Installer og konfigurer NGINX

Gunicorn-applikasjonsserveren er i drift og venter på forespørsler via socket-filen i prosjektkatalogen. Nå skal vi konfigurere Nginx til å sende nettforespørsler til denne kontakten ved å implementere mindre endringer i konfigurasjonsfilen. For dette må vi installere nginx først

sudo apt install nginx

Start med å generere en ny konfigurasjonsfil for serverblokker i Nginx sin nettsted-tilgjengelige katalog. Gi denne filen navnet "prosjekt" for ikke å bli forvirret. Vi har brukt navnet myproject.py tidligere

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

å legge til innholdet til filen, som har Nginx-serverblokkkonfigurasjon som sikrer at innkommende HTTP-forespørsler til den spesifiserte serverens IP-adresse videresendes til Gunicorn-applikasjonsserveren via Unix-socket-filen, slik at Flask-applikasjonen kan håndtere forespørslene. Lagre filen og gå ut av redigeringsprogrammet.

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 { … }: Denne blokken definerer en serverkonfigurasjon i Nginx. Den innkapsler konfigurasjonsinnstillingene for håndtering av forespørsler for en bestemt server.
  • Hør 80: Dette direktivet spesifiserer at Nginx skal lytte etter innkommende HTTP-forespørsler på port 80, standardporten for HTTP-trafikk.
  • server_name 3.110.196.110: Dette direktivet angir serverens vertsnavn eller IP-adresse. I dette tilfellet er den satt til 3.110.196.110, som bør erstattes med serverens offentlige IP-adresse.
  • Plassering / { … }: Denne blokken definerer hvordan Nginx skal håndtere forespørsler for rotkatalogen / til serveren.
  • Inkluder proxy_params: Dette direktivet gir konfigurasjonsinnstillinger fra proxy_params-filen. Disse innstillingene inneholder vanligvis proxy-relaterte konfigurasjoner, for eksempel proxy-overskrifter.
  • proxy_pass http://unix:/home/ubuntu/Flask_model_sentiment_analysis/myproject.sock: Dette direktivet spesifiserer at Nginx skal videresende innkommende forespørsler til den spesifiserte Unix-socket-filen som ligger på /home/ubuntu/Flask_model_sentiment_analysis/myproject.sock. Det er her Gunicorn lytter til forespørsler. Nginx vil fungere som en omvendt proxy, sende forespørsler til Gunicorn og returnere svarene til klienten.

Aktiver nå og test for feil

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: Denne kommandoen oppretter en symbolsk lenke kalt myproject i den nettstedaktiverte katalogen, og peker til konfigurasjonsfilen som ligger i katalogen for nettsteder som er tilgjengelige. Ved å gjøre dette aktiverer du serverblokkkonfigurasjonen for prosjektet ditt.
  • Sudo nginx -t: Denne kommandoen tester Nginx-konfigurasjonen for syntaksfeil. Den sjekker om Nginx-konfigurasjonsfilene, inkludert den nylig aktiverte myproject-serverblokken, er korrekt skrevet og gyldige. Hvis det er noen feil, vil de bli rapportert under denne testen.

Start nginx på nytt ettersom vi har oppdatert konfigurasjonene

sudo systemctl restart nginx

oppdatering av brannmuren for nginx

sudo ufw allow 'Nginx Full'

Siden vi ikke trenger 5000-porten, kan vi deaktivere den ved å bruke kommandoen "sudo ufw delete allow 5000", men vi trenger ikke deaktivere port 22.

Naviger nå til serverens domenenavn (eller IP-adressen) i nettleseren din, og du vil se utdata:

Hvis du ser en feil som 502 gateway, må du endre noen tillatelser. Bruk kommandoen

sudo chmod 755 /home/ubuntu

Når du tester serveren din for applikasjonen, bør du også bruke http://….. og ikke https, siden applikasjonen ikke er sikret.

Hvis det er feil, kan du sjekke dem gjennom kommandoer som:

Trinn 7: Installer og konfigurer NGINX

Hvis du vil stoppe tjenesten, kan du bruke kommandoen

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

Ytterligere trinn for å sikre applikasjonen

Det er ytterligere trinn for å sikre applikasjonen.  

Aktiver HTTPS for sikker kommunikasjon mellom klienter og serveren. Skaff et SSL/TLS-sertifikat (f.eks. Let's Encrypt) og konfigurer NGINX til å bruke det. Vi kan bruke Certbot for å sikre applikasjonen.

For å sikre webserveren din med SSL/TLS ved hjelp av Certbot trenger du vanligvis et registrert domenenavn. Certbot krever et domenenavn for å utstede SSL-sertifikater fordi det bekrefter domeneeierskap før utstedelse av sertifikatet. Selv om det er teknisk mulig å bruke en offentlig IP-adresse i stedet for et domenenavn, anbefales det ikke av flere grunner. Det ene er Certificate Authority (CA)-krav: Certificate Authority (CAer) som Let's Encrypt (som Certbot bruker) har retningslinjer på plass som krever domenevalidering. De vil ikke utstede SSL-sertifikater for IP-adresser.

Hvis du vil sikre det, kan du bruke sudo apt install python3-certbot-nginx og lære mer om det i dokumentasjonen.

konklusjonen

I denne artikkelen opprettet vi en grunnleggende Flask-applikasjon i et virtuelt Python-miljø. Vi genererte et WSGI-inngangspunkt, som muliggjorde kompatibilitet med alle WSGI-kompatible applikasjonsservere, og konfigurerte deretter Gunicorn til å oppfylle denne rollen. Deretter laget vi en systemtjenestefil for å starte applikasjonsserveren automatisk ved systemoppstart. I tillegg konstruerte du en Nginx-serverblokk som er ansvarlig for å dirigere nettklienttrafikk til applikasjonsserveren, effektivt videresende eksterne forespørsler og sikre servertrafikk med Let's Encrypt-kryptering.

spot_img

Siste etterretning

spot_img

Copyright @ 2024 Plato Technologies Inc.