Containerizzare un'app Python usando Docker

Docker è una soluzione gratuita e open-source per sviluppare, distribuire e gestire app in una virtualizzazione leggera a livello di sistema operativo. In questa guida, mostreremo come creare un'app Python all'interno di un container Docker.

Prerequisiti

Per eseguire i passaggi illustrati in questa guida, avrai bisogno dei seguenti componenti:

• Un sistema Linux. Consulta la guida per configurare il tuo VPS Ubuntu su CloudSigma.

• L'ultima versione di Docker installata e configurata. Scopri di più su come installare Docker su Ubuntu.

Container Docker

Quando si eseguono vari programmi nello stesso ambiente, le cose possono rompersi, e lo faranno. Più programmi aggiungi, più l'ambiente diventa instabile. Per gli utenti comuni potrebbe non essere un grosso problema. Tuttavia, quando si tratta di applicazioni mission-critical, le conseguenze possono essere gravi.

Più app vengono introdotte nel sistema, maggiore diventa la superficie di attacco. Una singola app compromessa può facilmente portare al collasso dell'intero sistema.

Per risolvere questi problemi, possiamo usare i container Docker per il sandboxing a livello software:

• Le app all'interno del container avranno accesso limitato ai file.

• Le app containerizzate non possono vedere altri processi in esecuzione nel sistema.

• Al container può essere assegnata una quantità specifica di risorse hardware.

• Le porte di rete di un container non sono esposte all'esterno.

• Packaging coerente di quasi tutto tra ambienti locali e di produzione.

A scopo dimostrativo, costruiremo un semplice server Python all'interno di un container Docker, trasformeremo il container in un'immagine e distribuiremo l'immagine in un ambiente di produzione fittizio.

Passaggio 1 – Configurazione del filesystem

Per ospitare il progetto, per prima cosa creeremo una directory dedicata:

mkdir -pv python-server-container/

cd !$

All'interno della directory, crea una sottodirectory src per archiviare il nostro codice:

mkdir -pv src/

Passaggio 2 – Creazione del server Python

In questo passaggio, creeremo un semplice server HTTP in Python. Crea il file server.py:

touch server.py

Aprilo in un editor di testo:

nano server.py

Inserisci il seguente codice Python:

from http.server import HTTPServer, SimpleHTTPRequestHandler

def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler):
    """server entrypoint"""
    server_address = ("0.0.0.0", 8080)
    httpd = server_class(server_address, handler_class)
    print("starting server...")
    httpd.serve_forever()

if __name__ == "__main__":
    run()

Qui:

• Usiamo la classe HTTPServer e richiediamo un handler dalla libreria standard di Python, mantenendo il programma semplice.

• La funzione run avvia un'istanza di HTTPserver.

• Come suggeriscono gli argomenti di server_address, il server ascolterà qualsiasi connessione in ingresso sulla porta 8080.

Ora verificheremo se il server funziona come previsto. Avvia il server:

python3 server.py

Da un nuovo terminale, possiamo usare curl per inviare una richiesta al server:

curl -iv localhost:8080

In alternativa, puoi accedere al link in un browser web:

http://localhost:8080

Passaggio 3 – Creazione di un Dockerfile

Un Dockerfile contiene le istruzioni necessarie per generare un'immagine Docker. Le istruzioni nel file vengono seguite in sequenza. Scopri di più su Dockerfile.

Crea un nuovo Dockerfile per il nostro progetto:

touch Dockerfile

Ora inseriremo al suo interno il codice necessario. Aprilo in un editor di testo:

nano Dockerfile

Inserisci il seguente codice:

FROM python:latest

ENV SRC_DIR /usr/bin/src/test_server/src
COPY src/* ${SRC_DIR}/
WORKDIR ${SRC_DIR}

ENV PYTHONUNBUFFERED=1

CMD ["python", "server.py"]

Qui:

• Qualsiasi Dockerfile deve iniziare con la direttiva FROM. Nel nostro caso, dichiariamo Python come base dell'immagine Docker.

• La direttiva ENV SRC_DIR specifica la posizione della directory del container.

• La direttiva COPY copia i file dalla directory src che attualmente ospita il server Python.

• La variabile PYTHONBUFFERED=1 specifica che Python stamperà e registrerà l'output direttamente su STDOUT. In caso contrario, i log non verrebbero inviati ad alcun buffer.

• La direttiva CMD specifica un comando predefinito da eseguire quando si avvia il container. In questo caso, usiamo la direttiva per avviare il nostro server Python.

Passaggio 4 – Generazione dell'immagine Docker

Con il Dockerfile pronto, ora possiamo creare un'immagine. Esegui il seguente comando Docker per avviare il processo:

docker build . -t python_server

Qui:

• Il flag -t viene usato per assegnare alla nostra immagine Docker il tag python_server.

• Docker scaricherà tutti i componenti necessari e li combinerà in un'immagine.

Passaggio 5 – Esecuzione dell'immagine

L'immagine è pronta per la distribuzione. Possiamo eseguirla usando il seguente comando:

docker run -p 8080:8080 python_server

Qui inoltriamo la porta 8080 dalla macchina locale all'immagine Docker usando il flag -p.

Possiamo verificare facilmente se il server è attivo e in esecuzione usando curl:

curl -iv localhost:8080

Passaggio 6 – Terminazione del server

Dal terminale, premi “Ctrl + C” per terminare il processo Docker:

Passaggio 7 – Esportazione e importazione dell'immagine Docker

Ora abbiamo un'immagine Docker funzionante che ospita il nostro server Python. Con l'aiuto delle funzionalità di esportazione e importazione di Docker, possiamo migrarla su qualsiasi altro sistema.

Per prima cosa, controlla l'elenco delle immagini Docker nel sistema corrente:

docker images

Il nostro obiettivo è l'immagine Docker python_server appena creata. Il seguente comando la esporterà come archivio TAR:

docker save python_server:latest > python_server.tar

Dopo aver trasferito il file python_server.tar sulla macchina di destinazione, usa il seguente comando per importare l'immagine Docker:

docker load < python_server.tar

Considerazioni finali

In questa guida, abbiamo mostrato come creare un'immagine Docker a partire da un'applicazione Python. Abbiamo creato un semplice web server Python e da esso abbiamo generato un'immagine Docker. Ora l'immagine Docker può essere distribuita in qualsiasi ambiente garantendo un comportamento coerente.

Ti interessa saperne di più su Docker? Consulta le seguenti guide:

• Creare e distribuire un'applicazione Flask con Docker su Ubuntu 20.04

• Come proteggere e scalare un'applicazione Django con Docker, Nginx e Let’s Encrypt

• Come distribuire WordPress con container Docker su Ubuntu 20.04

• Condivisione dei dati tra container Docker

Buon computing!