Se hai familiarità con Docker, probabilmente sai che puoi creare un'immagine Docker personalizzata utilizzando Dockerfile. Ho scritto in dettaglio.
Come creare un'immagine Docker personalizzata con Dockerfile [molto semplice] Il vero potere di Docker sta nel modificare l'immagine Docker di base in base alle tue esigenze. Con ciò, puoi distribuire facilmente e rapidamente un ambiente Linux personalizzato eseguendo un contenitore da quell'immagine della finestra mobile personalizzata.
Manuale LinuxAvimanyu Bandyopadhyay 
In questo tutorial, ti mostrerò come seguire la stessa idea ma solo per le applicazioni Python. Questo sarà utile sia per gli utenti che per gli sviluppatori.
Userò un'immagine Python minima. Dopo aver modificato e rivisto quell'immagine, non dovrai più preoccuparti di installare la tua applicazione Python su diversi sistemi operativi. Sarai in grado di eseguire immediatamente la tua applicazione Python con Docker ogni singola volta. Quindi, puoi dire addio a quei problemi di installazione basati su host!
Creazione di un'immagine docker per la tua applicazione Python
Userò Miniconda qui. Miniconda è un programma di installazione minimo gratuito per conda e ti offre una piccola versione bootstrap di Anaconda con solo le necessità essenziali di cui hai bisogno per eseguire applicazioni Python.
Perché Miniconda?
C'è più di un motivo:
Quando installi Miniconda su un host, non stai effettivamente utilizzando la versione Python fornita dal gestore di pacchetti del sistema operativo. Miniconda si installa in una posizione separata con il proprio ambiente Python. Quindi, questo ti fornisce un ulteriore livello di isolamento quando viene eseguito su un contenitore Docker.
Grazie a quanto sopra, ottieni anche un altro vantaggio:poiché stai usando conda che Miniconda ha installato, puoi utilizzare questo strumento per modificare la versione Python pertinente della tua applicazione come e quando necessario. Questo è di grande aiuto per gli sviluppatori di applicazioni basate, ad esempio, su versioni diverse di Python 3:potrebbero essere anche versioni 3.6, 3.7, 3.8, 3.9 o precedenti.
Ad esempio, se per impostazione predefinita stai utilizzando Python 3.9 ma la tua applicazione Python richiede Python 3.7 a causa di dipendenze rilevanti, cosa faresti?
Qui è dove conda posso aiutarti. Con esso, puoi eseguire conda install python=3.7 per modificare la versione di Python richiesta installandola con tutte le dipendenze necessarie.
- Miniconda ti permette di installare sia le applicazioni Python 2 che Python 3. Sebbene Python 2 sia ufficialmente morto, puoi comunque testare le vecchie applicazioni su questo ambiente senza dover controllare la tua nuova porta Python 3 con 2to3.
- Ci sono anche molti casi d'uso in cui un'applicazione Python in esecuzione su Miniconda cerca dipendenze lato host non Python (ad esempio
g++). È allora che la potenza combinata di Miniconda e Docker diventa un'ottima soluzione! - Ho dimenticato di dire che puoi anche creare e attivare i tuoi ambienti di applicazioni Python con
conda? Isolamento di nuovo! - In qualsiasi momento, hai sempre la possibilità di passare dalla versione Python predefinita del contenitore Docker a quella di Miniconda. Questo ti dà maggiore flessibilità poiché puoi sempre ricostruire una nuova immagine con la modifica ogni volta che vuoi.
Quindi, andiamo ora avanti con la creazione della nuova immagine dell'applicazione Python con Miniconda e Docker!
Prerequisito
Se non l'hai già fatto, installa Docker su Ubuntu o qualsiasi distribuzione Linux che stai utilizzando. Assicurati di aggiungerti al gruppo Docker in modo da poter eseguire Docker senza sudo. Avrai bisogno di una connessione Internet attiva per scaricare l'immagine Docker di base.
Per un'applicazione Python di esempio, sto usando un semplice "Hello World!" esempio denominato python-app.py per aiutarti a capire più facilmente come eseguirlo tramite Miniconda su Docker.
Un'applicazione Python a tutti gli effetti che utilizza diverse librerie Python trarrebbe grande vantaggio dalla stessa procedura, soprattutto a causa delle varie disposizioni sulle dipendenze di Miniconda.
Passaggio 1:ottieni l'immagine Docker [opzionale]
Ho scelto Python Slim in questo esempio invece di Alpine Linux. Quest'ultimo è davvero piccolo ma può influire notevolmente sulle prestazioni quando si tratta di eseguire applicazioni. Tuttavia, Python Slim ha una dimensione di circa 40 MB, basato su Debian Buster e Python 3.9.1.
Questo passaggio è facoltativo. L'ho incluso per mostrare che puoi confrontarlo con l'immagine dell'applicazione Python personalizzata come nel precedente tutorial di Dockerfile.
Estrai l'ultima immagine della finestra mobile di Python Slim usando docker pull comando:
docker pull python:slim
Passaggio 2:crea Dockerfile con la personalizzazione necessaria
Ora creiamo un nuovo file vuoto chiamato Dockerfile usando il comando touch. Ma prima crea una directory per la tua app Docker.
mkdir python-docker
cd python-docker
touch DockerfileAllegherò il Dockerfile completo di seguito dopo aver finito di spiegare i passaggi all'interno del processo di creazione dell'immagine tramite una procedura dettagliata del file.
Ecco come iniziare e procedere con la costruzione dell'immagine:
Prepara l'immagine di base
Aggiorna gli ultimi pacchetti predefiniti utilizzando Python Slim come immagine di base.
FROM python:slim
RUN apt-get update && apt-get -y upgrade \
Installa le dipendenze del pacchetto non Python
Installa qualsiasi dipendenza non Python per la tua app Python (ad esempio g++ e qualsiasi altro secondo la vostra esigenza).
&& apt-get install -y --no-install-recommends \
git \
wget \
g++ \
gcc \
ca-certificates \
&& rm -rf /var/lib/apt/lists/*
Git e Wget possono essere molto utili quando si recuperano applicazioni Python da diversi repository e URL. Infine, ripulisci un po' di spazio con rm -rf /var/lib/apt/lists/* per ridurre al minimo la dimensione dell'immagine Docker finale.
Installa Miniconda
Dopo l'installazione, Miniconda aggiorna .bashrc per passare alla propria versione di Python.
ENV PATH="/root/miniconda3/bin:${PATH}"
ARG PATH="/root/miniconda3/bin:${PATH}"
RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \
&& mkdir /root/.conda \
&& bash Miniconda3-latest-Linux-x86_64.sh -b \
&& rm -f Miniconda3-latest-Linux-x86_64.sh \
Qui viene impostata una variabile di ambiente all'interno del percorso di sistema del contenitore. ENV è pensato per i contenitori che eseguirai sull'immagine e su ARG è pensato per i contenitori intermedi che vengono creati durante la creazione per la prima volta.
Quindi, la differenza tra ENV e ARG le istruzioni nel blocco di codice sopra è che quest'ultimo è disponibile solo durante la creazione dell'immagine. Dai un'occhiata a questa bellissima spiegazione qui.
Con wget , scarica l'ultima versione di Miniconda dal repository ufficiale di Anaconda. Dopo aver creato la directory di configurazione essenziale, installala e infine rimuovi il programma di installazione.
Configura Miniconda in Bash Shell
Dopo aver installato Miniconda, mostra il suo numero di versione per conferma e inizializzalo sulla shell Bash per il contenitore . La seconda riga aggiorna il tuo .bashrc predefinito file:
&& echo "Running $(conda --version)" && \
conda init bash && \
Ricarica Bash con le nuove modifiche
Ricarica Bash affinché il sistema di compilazione Docker passi alla versione Python di Miniconda anziché a quella di Debian (l'immagine del sistema operativo di base).
. /root/.bashrc && \
Inoltre, aggiorna gli attuali pacchetti Miniconda in bundle per impostazione predefinita.
conda update conda && \
Prepara un ambiente Conda per la tua app
Crea e attiva un ambiente Conda separato per la tua applicazione Python.
conda create -n python-app && \
conda activate python-app && \
Installa la versione di Python pertinente di cui hai bisogno per la tua app. Supponendo che la tua applicazione sia basata su Python 3.6, imposta questa versione all'interno del nuovo ambiente virtuale insieme a Pip, che è anche molto utile quando gestisci le applicazioni Python.
conda install python=3.6 pip && \
Installa la tua applicazione Python
A seconda di come utilizzi la tua app, puoi:
io. Installalo con pip che utilizza convenzionalmente il setup.py file disponibile nel tuo repository. È lo stesso strumento discusso in precedenza, ma qui lo sto usando invece tramite Conda.
git clone replace-me-with-repo-url
cd repo-name
pip install -e .
ii. ..o eseguilo direttamente con python comando:
git clone replace-me-with-repo-url
cd repo-name
python python-app.py
Nella demo Dockerfile, userò "Hello World!" esempio per semplificare la comprensione di come eseguirlo direttamente avviando un contenitore o all'interno della sua shell bash con Docker. Quindi, diciamo che sto usando il 2° modo:
echo 'print("Hello World!")' > python-app.py
Quindi ora che ho incluso la riga sopra, un file chiamato python-app.py viene creato che dovrebbe generare il messaggio Hello World ogni volta che lo esegui con il comando python python-app.py .
Aggiorna il file .bashrc per la tua app come fa Miniconda:
Il programma di installazione di Miniconda aggiorna automaticamente il file .bashrc dopo aver eseguito conda init bash come mostrato in precedenza. Puoi fare lo stesso anche per la tua applicazione Python. Ogni volta che esegui il contenitore bash, l'ambiente verrà attivato e puoi anche utilizzare il nome dell'applicazione Python come comando per eseguirlo. Qui ho usato il nome come python-app :
RUN echo 'conda activate python-app \n\
alias python-app="python python-app.py"' >> /root/.bashrc
Prepara l'app per l'esecuzione finale
Infine, creo un punto di ingresso e assegno il comando che ti consentirà di eseguirlo ogni volta che esegui un contenitore basato su questa immagine:
ENTRYPOINT [ "/bin/bash", "-l", "-c" ]
CMD ["python python-app.py"]
File Docker completo
Puoi usare un editor come Vim o Nano o usare il cat comando per aggiungere le righe sopra discusse al Dockerfile.
FROM python:slim
RUN apt-get update && apt-get -y upgrade \
&& apt-get install -y --no-install-recommends \
git \
wget \
g++ \
ca-certificates \
&& rm -rf /var/lib/apt/lists/*
ENV PATH="/root/miniconda3/bin:${PATH}"
ARG PATH="/root/miniconda3/bin:${PATH}"
RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \
&& mkdir /root/.conda \
&& bash Miniconda3-latest-Linux-x86_64.sh -b \
&& rm -f Miniconda3-latest-Linux-x86_64.sh \
&& echo "Running $(conda --version)" && \
conda init bash && \
. /root/.bashrc && \
conda update conda && \
conda create -n python-app && \
conda activate python-app && \
conda install python=3.6 pip && \
echo 'print("Hello World!")' > python-app.py
RUN echo 'conda activate python-app \n\
alias python-app="python python-app.py"' >> /root/.bashrc
ENTRYPOINT [ "/bin/bash", "-l", "-c" ]
CMD ["python python-app.py"]
Quando provi la tua app, sostituisci echo 'print("Hello World!")' > python-app.py riga sopra con uno dei due modi descritti in Installa la tua applicazione Python sezione precedente.
Passaggio 3:crea l'immagine dell'applicazione Python con Dockerfile
Come forse già saprai, il comando per creare l'immagine Docker modificata dal Dockerfile è simile a:
docker build -t python-app PATH_to_Dockerfile
Con il tag -t, specifichi il nome dell'immagine Docker della tua app. L'ho impostato come python-app nel comando di esempio sopra.
Considerando che il Dockerfile si trova nella tua directory corrente, puoi creare la nuova immagine Docker della tua applicazione Python in questo modo:
docker build -t python-app .
[email protected]:~/python-docker$ docker build -t python-app .
Sending build context to Docker daemon 2.56kB
Step 1/8 : FROM python:slim
---> 677f7ac99e48
Step 2/8 : RUN apt-get update && apt-get -y upgrade && apt-get install -y --no-install-recommends git wget g++ ca-certificates && rm -rf /var/lib/apt/lists/*
---> Using cache
---> 15ee9c47c83b
Step 3/8 : ENV PATH="/root/miniconda3/bin:${PATH}"
---> Using cache
---> cfd5ed6b5ec9
Step 4/8 : ARG PATH="/root/miniconda3/bin:${PATH}"
---> Using cache
---> e70d06b5ff10
Step 5/8 : RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && mkdir /root/.conda && bash Miniconda3-latest-Linux-x86_64.sh -b && rm -f Miniconda3-latest-Linux-x86_64.sh && echo "Running $(conda --version)" && conda init bash && . /root/.bashrc && conda update conda && conda create -n python-app && conda activate python-app && conda install python=3.6 pip && echo 'print("Hello World!")' > python-app.py
---> Using cache
---> 8a7957a6abb2
Step 6/8 : RUN echo 'conda activate python-app \nalias python-app="python python-app.py"' >> /root/.bashrc
---> Running in e3193e93b631
Removing intermediate container e3193e93b631
---> 948f45eb6024
Step 7/8 : ENTRYPOINT [ "/bin/bash", "-l", "-c" ]
---> Running in 621624951dcf
Removing intermediate container 621624951dcf
---> 6e8824889502
Step 8/8 : CMD ["python python-app.py"]
---> Running in dc97f9d0d8fe
Removing intermediate container dc97f9d0d8fe
---> 01bae0a9903c
Successfully built 01bae0a9903c
Successfully tagged python-app:latest
L'output di cui sopra si basa sui dati memorizzati nella cache, ma quando lo esegui per la prima volta, ci vorrebbe del tempo e produrrebbe un output di registro molto più lungo.
Ora, verifichiamo che l'immagine Docker modificata abbia l'app di esempio installata eseguendo un container da essa:
docker run python-app[email protected]:~/python-docker$ docker run python-app
Hello World!Quindi, tramite Docker e Miniconda, ora puoi eseguire il programma direttamente senza bisogno di alcuna installazione preventiva! D'ora in poi, tutto ciò di cui hai bisogno è l'immagine.
Ora accediamo alla shell bash all'interno di questo contenitore:
docker run -ti python-app bash[email protected]:~/python-docker$ docker run -ti python-app bash
(python-app) [email protected]:/#
Come puoi vedere, ora sei all'interno dell'ambiente attivato da Conda che hai creato in precedenza tramite Dockerfile. Il -ti flag viene utilizzato per creare un terminale interattivo per te. Ora puoi in alternativa utilizzare il comando a cui hai aliasato per eseguire l'app:
(python-app) [email protected]:/# python-app
Hello World!
Confermiamo anche che stai effettivamente utilizzando la versione Python di Miniconda e non la versione Python predefinita:
(python-app) [email protected]:/# python --version
Python 3.6.12 :: Anaconda, Inc.
Come ho detto prima, Miniconda è una versione miniaturizzata di Anaconda.
Una volta impostato tutto, puoi eseguire il push della tua immagine finale su Docker Hub se ospiti un'applicazione Python open source su GitHub, GitLab, Gitea, Bitbucket o qualsiasi altro repository.
Esci dal container digitando exit nel terminale. Arresta il contenitore, rimuovi il contenitore e rimuovi le immagini Docker (se lo desideri) per liberare spazio su disco.
Congratulazioni! Hai appena imparato a creare la tua immagine Docker personale per la tua applicazione Python.
Ti è stato utile?
Quindi vedi, Miniconda non solo ti aiuta a rendere la tua applicazione più flessibile e a prova di futuro a livello di utente, ma rende anche molto più semplice il ruolo dello sviluppatore.
Pensa a quanto sarebbe conveniente configurarlo con PyCharm! Installi Miniconda e la tua applicazione Python come faresti su un sistema host, ma poiché la crei e la salvi come immagine Docker, diventa un processo una tantum!
Se vuoi, puoi sperimentare i diversi esempi mostrati in questo tutorial precedente invece di "Hello World!" esempio che ho usato in questo.
Spero questo sia di aiuto! Se hai domande o suggerimenti, lascia un commento qui sotto.