Ricerca nel sito web

Dockerizzazione dell'applicazione Flask utilizzando Docker su Debian 10


Su questa pagina

  1. Prerequisiti
  2. Per iniziare
  3. Installa le dipendenze richieste
  4. Installa Docker
  5. Imposta la struttura della directory del pallone
  6. Configura Docker per distribuire Flask
  7. Distribuisci file modello
  8. Conclusione

Docker è uno strumento open source progettato per semplificare la creazione, la distribuzione e l'esecuzione di applicazioni utilizzando i contenitori. Un contenitore è un pacchetto software che impacchetta il codice e tutte le sue dipendenze in modo che l'applicazione venga eseguita in modo rapido e affidabile da un ambiente informatico all'altro.

Flask è un popolare framework web Python. È classificato come microframework perché non richiede strumenti o librerie particolari. Rispetto ad altri framework è leggero e altamente strutturato.

In questo tutorial, spiegheremo come distribuire l'applicazione Flask con Docker sul server Debian 10.

Prerequisiti

  • Un server che esegue Debian 10.
  • Una password di root è configurata sul tuo server.

Iniziare

Prima di iniziare, è una buona idea aggiornare il pacchetto di sistema all'ultima versione. Puoi aggiornare tutti i pacchetti con il seguente comando:

apt-get update -y
apt-get upgrade -y

Una volta aggiornati tutti i pacchetti, riavvia il sistema per applicare le modifiche.

Installa le dipendenze richieste

Successivamente, dovrai installare il server Web Nginx e altre dipendenze nel tuo sistema. Puoi installarli tutti usando il seguente comando:

apt-get install nginx apt-transport-https ca-certificates curl gnupg2 software-properties-common curl -y

Una volta installati tutti i pacchetti, puoi procedere al passaggio successivo.

Installa Docker

Per impostazione predefinita, l'ultima versione di Docker non è disponibile nel repository Debian 10. Quindi è una buona idea installarlo dal repository ufficiale di Docker.

Innanzitutto, scarica e aggiungi la chiave GPG con il seguente comando:

wget https://download.docker.com/linux/debian/gpg apt-key add gpg

Successivamente, aggiungi il repository Docker con il seguente comando:

add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian buster stable"

Successivamente, aggiorna il repository e installa Docker con il seguente comando:

apt-get update -y
apt-get install docker-ce -y

Una volta completata correttamente l'installazione, verificare lo stato del Docker con il seguente comando:

systemctl status docker

Dovresti ottenere il seguente output:

? docker.service - Docker Application Container Engine
   Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
   Active: active (running) since Sun 2020-04-19 06:26:25 UTC; 1min 8s ago
     Docs: https://docs.docker.com
 Main PID: 8883 (dockerd)
    Tasks: 10
   Memory: 46.6M
   CGroup: /system.slice/docker.service
           ??8883 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.413828757Z" level=warning msg="Your kernel does not support swap memory limit
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.413876690Z" level=warning msg="Your kernel does not support cgroup rt period"
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.413889604Z" level=warning msg="Your kernel does not support cgroup rt runtime
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.414115814Z" level=info msg="Loading containers: start."
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.788332166Z" level=info msg="Default bridge (docker0) is assigned with an IP a
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.972022325Z" level=info msg="Loading containers: done."
Apr 19 06:26:25 debian10 dockerd[8883]: time="2020-04-19T06:26:25.010940205Z" level=info msg="Docker daemon" commit=afacb8b7f0 graphdriver(s)=o
Apr 19 06:26:25 debian10 dockerd[8883]: time="2020-04-19T06:26:25.011145541Z" level=info msg="Daemon has completed initialization"
Apr 19 06:26:25 debian10 systemd[1]: Started Docker Application Container Engine.
Apr 19 06:26:25 debian10 dockerd[8883]: time="2020-04-19T06:26:25.074603639Z" level=info msg="API listen on /var/run/docker.sock"

A questo punto, Docker è installato e funzionante. Ora puoi procedere al passaggio successivo.

Imposta la struttura della directory del pallone

Successivamente, dovrai creare una struttura di directory per contenere la tua applicazione Flask.

Creiamo una directory chiamata flask all'interno della directory /var/www/:

mkdir -p /var/www/flask

Successivamente, modifica la directory in un pallone e crea la struttura di directory per il pallone:

cd /var/www/flask
mkdir -p app/static
mkdir -p app/templates

La directory statica viene utilizzata per archiviare immagini, CSS e file JavaScript mentre la directory dei modelli viene utilizzata per archiviare i modelli HTML per il progetto.

Successivamente, dovrai creare un file __init__.py all'interno della directory dell'app:

nano app/__init__.py

Aggiungi i seguenti contenuti per creare un'istanza di Flask e importa la logica dal file views.py:

from flask import Flask
app = Flask(__name__)
from app import views

Salva e chiudi il file, quindi crea il file views.py nella directory dell'app.

nano app/views.py

Aggiungi le seguenti righe

from app import app
@app.route('/')
def home():
   return "hello world!"

Salva e chiudi il file quindi crea il file uwsgi.ini con il seguente comando:

nano uwsgi.ini

Questo file conterrà le configurazioni uWSGI per la nostra applicazione come mostrato di seguito:

[uwsgi]
module = main
callable = app
master = true

Salva e chiudi il file quando hai finito. uWSGI è un'opzione di distribuzione per Nginx che è sia un protocollo che un server delle applicazioni.

Successivamente, dovrai creare il file main.py per importare l'istanza Flask denominata app dal pacchetto dell'applicazione. Puoi crearlo con il seguente comando:

nano main.py

Aggiungi la seguente riga:

from app import app

Salva e chiudi il file quando hai finito. Quindi, crea un file requirements.txt per specificare le dipendenze che il gestore pacchetti pip installerà nella tua distribuzione Docker:

nano requirements.txt

Aggiungi la seguente riga che corrisponde all'ultima versione di Flask:

Flask==1.1.2

Salva e chiudi il file quando hai finito.

A questo punto, la tua applicazione Flask è stata configurata correttamente. Ora puoi procedere al passaggio successivo.

Configura Docker per distribuire Flask

Successivamente, sarà necessario creare un Dockerfile per creare e distribuire un'applicazione in flask.

Innanzitutto, crea un Dockerfile con il seguente comando:

cd /var/www/flask
nano Dockerfile

Aggiungi le seguenti righe:

FROM tiangolo/uwsgi-nginx-flask:python3.6-alpine3.7
RUN apk --update add bash nano
ENV STATIC_URL /static
ENV STATIC_PATH /var/www/app/static
COPY ./requirements.txt /var/www/requirements.txt
RUN pip install -r /var/www/requirements.txt

Salva e chiudi il file quando hai finito. Successivamente, crea uno script start.sh per creare un'immagine dal Dockerfile e creare un contenitore dall'immagine Docker risultante.

nano start.sh

Aggiungi la seguente riga:

#!/bin/bash
app="docker.test"
docker build -t ${app} .
docker run -d -p 56733:80 \
  --name=${app} \
  -v $PWD:/app ${app}

Salva e chiudi il file quando hai finito.

Nota: assicurarsi che la porta 56733 sia libera e utilizzabile.

Infine, esegui lo script usando il seguente comando:

bash start.sh

Questo creerà l'immagine Docker e costruirà un contenitore dall'immagine risultante come mostrato di seguito:

Sending build context to Docker daemon  9.728kB
Step 1/6 : FROM tiangolo/uwsgi-nginx-flask:python3.6-alpine3.7
python3.6-alpine3.7: Pulling from tiangolo/uwsgi-nginx-flask
48ecbb6b270e: Pull complete 
692f29ee68fa: Pull complete 
f75fc7ac1098: Pull complete 
c30e40bb471c: Pull complete 
Successfully built f5de17e1ce82
Successfully tagged docker.test:latest
22cd2bd23c9190cf2900fa1d7c55e4765a266e68c74dc1e6858872e9ebe7bdcd

Ora puoi elencare i contenitori in esecuzione con il seguente comando:

docker ps

Dovresti ottenere il seguente output:

CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS              PORTS                            NAMES
22cd2bd23c91        docker.test         "/entrypoint.sh /sta…"   About a minute ago   Up About a minute   443/tcp, 0.0.0.0:56733->80/tcp   docker.test

Puoi anche verificare il contenitore Docker visitando l'URL http://your-server-ip:56733. Dovresti vedere la seguente schermata:

Distribuisci file modello

Puoi anche distribuire file modello per servire contenuto statico e dinamico. Puoi creare un modello di home page per la tua applicazione con il seguente comando:

nano app/templates/home.html

Aggiungi i seguenti codici:

<!doctype html>

<html lang="en-us">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="x-ua-compatible" content="ie=edge">
    <title>Welcome Flask</title>
  </head>

  <body>
    <h1>Home Page</h1>
    <p>This is the home page of our flask application.</p>
  </body>
</html>

Salva e chiudi il file quando hai finito. Successivamente, dovrai modificare il file views.py per servire il file appena creato:

nano app/views.py

Aggiorna il file come mostrato di seguito:

from flask import render_template

from app import app

@app.route('/')
def home():
   return "hello world!"

@app.route('/template')
def template():
    return render_template('home.html')

Salva e chiudi il file. Quindi, dovrai riavviare i contenitori Docker per applicare le modifiche.

Puoi riavviare il contenitore Docker denominato docker.test con il seguente comando:

docker stop docker.test
docker start docker.test

Ora, apri il tuo browser web e digita l'URL http://your-server-ip:56733/template. Dovresti vedere il modello appena creato nella schermata seguente:

Conclusione

Congratulazioni! hai distribuito con successo un'applicazione Flask con Docker sul server Debian 10. È ora possibile replicare l'applicazione su diversi server con una riconfigurazione minima. Non esitate a chiedermi se avete domande.