Docker è una soluzione gratuita e open-source per lo sviluppo, la distribuzione e la gestione di app in una virtualizzazione leggera a livello di sistema operativo. In questa guida, mostreremo come creare un'applicazione Python all'interno di un container Docker.
Prerequisiti
Per eseguire i passaggi illustrati in questa guida, avrai bisogno dei seguenti componenti:
-
Un sistema Linux. Dai un'occhiata a come 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 all'interno dello stesso ambiente, le cose possono rompersi (e lo faranno). Più programmi si aggiungono, più l'ambiente diventa instabile. Potrebbe non essere un grosso problema per l'utente medio. Tuttavia, quando si tratta di applicazioni mission-critical, le conseguenze possono essere gravi.
Più app vengono introdotte nel sistema, maggiore è la superficie di attacco. Una singola app compromessa può facilmente portare al collasso dell'intero sistema.
Per risolvere questi problemi, possiamo utilizzare i container Docker per il sandboxing a livello software:
-
Le app all'interno del container avranno un accesso limitato ai file.
-
Le app containerizzate non possono vedere altri processi in esecuzione nel sistema.
-
Al container può essere allocata 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.
Per dimostrarlo, creeremo un semplice server Python all'interno di un container Docker, trasformeremo il container in un'immagine e distribuiremo l'immagine all'interno di un ambiente di produzione fittizio.
Passo 1 – Configurazione del filesystem
Per ospitare il progetto, per prima cosa creeremo una directory dedicata:
|
1 |
mkdir -pv python-server-container/ |
|
1 |
cd !$ |
All'interno della directory, crea una sottodirectory src per memorizzare il nostro codice:
|
1 |
mkdir -pv src/ |
Passo 2 – Creazione del server Python
In questo passaggio, creeremo un semplice server HTTP in Python. Crea il file server.py:
|
1 |
touch server.py |
Apri il file in un editor di testo:
|
1 |
nano server.py |
Inserisci il seguente codice Python:
|
1 2 3 4 5 6 7 8 9 10 11 |
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,
-
Stiamo usando la HTTPServer classe e richiedendo un gestore 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 rimarrà in ascolto di qualsiasi connessione in entrata sulla porta 8080.
Ora verificheremo se il server funziona come previsto. Avvia il server:
|
1 |
python3 server.py |
Da un nuovo terminale, possiamo usare curl per inviare una richiesta al server:
|
1 |
curl -iv localhost:8080 |
In alternativa, puoi accedere al link in un browser web:
|
1 |
http://localhost:8080 |
Passo 3 – Creazione di un Dockerfile
Un Dockerfile contiene le istruzioni necessarie per generare un'immagine Docker. Le istruzioni nel file vengono seguite in modo sequenziale. Scopri di più su Dockerfile.
Crea un nuovo Dockerfile per il nostro progetto:
|
1 |
touch Dockerfile |
Ora inseriremo i codici necessari al suo interno. Apri il file in un editor di testo:
|
1 |
nano Dockerfile |
Inserisci il seguente codice:
|
1 2 3 4 5 6 7 8 9 |
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 FROM direttiva. Nel nostro caso, stiamo dichiarando Python come base dell'immagine Docker.
-
La ENV SRC_DIR direttiva specifica la posizione della directory del container.
-
La COPY direttiva copia i file dalla src directory che attualmente ospita il server Python.
-
La variabile PYTHONBUFFERED=1 specifica che Python stamperà e registrerà l'output direttamente su STDOUT. Altrimenti, i log non verrebbero inviati a nessun buffer.
-
La CMD direttiva specifica un comando predefinito da eseguire all'avvio del container. In questo caso, stiamo usando la direttiva per avviare il nostro server Python.
Passo 4 – Generazione dell'immagine Docker
Con il Dockerfile pronto, ora possiamo creare un'immagine. Esegui il seguente comando Docker per avviare il processo:
|
1 |
docker build . -t python_server |
Qui,
-
Il -t flag viene utilizzato per taggare la nostra immagine Docker come python_server.
-
Docker scaricherà tutti i componenti necessari e li unirà in un'immagine.
Passo 5 – Esecuzione dell'immagine
L'immagine è pronta per la distribuzione. Possiamo eseguirla usando il seguente comando:
|
1 |
docker run -p 8080:8080 python_server |
Qui, stiamo reindirizzando la porta 8080 dalla macchina locale all'immagine Docker usando il -p flag.
Possiamo facilmente verificare se il server è attivo e funzionante usando curl:
|
1 |
curl -iv localhost:8080 |
Passo 6 – Terminazione del server
Dal terminale, premi “Ctrl + C” per terminare il processo Docker:
Passo 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:
|
1 |
docker images |
Il nostro obiettivo è l'immagine Docker python_server che abbiamo appena creato. Il seguente comando la esporterà come archivio TAR:
|
1 |
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:
|
1 |
docker load < python_server.tar |
Considerazioni finali
In questa guida, abbiamo mostrato come creare un'immagine Docker da un'applicazione Python. Abbiamo creato un semplice webserver Python e ne abbiamo ricavato un'immagine Docker. L'immagine Docker può ora essere distribuita in qualsiasi ambiente garantendo un comportamento coerente.
Vuoi saperne di più su Docker? Dai un'occhiata alle 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 i container Docker su Ubuntu 20.04
Buona programmazione!
Commenti
Ancora nessun commento. Scrivi il primo.