GUIDA Approfondiamo DOCKER, con Dockerfile e Docker-compose

Skills07 · 27 Agosto 2024

Questa guida tende ad estendere ciò che il collega @ilfe98 ha già scritto precedentemente qui: https://forum.tomshw.it/threads/installazione-ed-utilizzo-di-docker.890283/

Vuole semplicemente estendere i concetti già spiegati precedentemente ed andare nel dettaglio delle varie procedure.

Ritorniamo ad un concetto base, che cos è Docker?

Docker è una piattaforma di container software progettata per lo sviluppo, la spedizione e l'esecuzione di applicazioni sfruttando la tecnologia dei container.

Non voglio soffermarmi sulle cose illustrate precedentemente altrimenti rischiamo di essere rindondanti e poco efficaci.

L'efficacia di Docker sta nel fatto che è possibile Buildare il tuo applicativo su qualsiasi piattaforma, e il vantaggio sta appunto in quanto non avviene ciò che vi elenco ora:

Deploy su VM personale

Spesso e volentieri con questa casistica quando si parla di sviluppo software, significa avere in casa propria (o in un datacenter) un host fisico (server) con il suo Sistema operativo, dove spesso e volentieri viene installato l'hypervisor e vengono create macchine virtuali 1, 2 o n in base alle proprie esigenze.
Ogni VM contiene il suo sistema operativo, e a sua volta vengono installate le librerie dell'applicativo che si vuole eseguire su tale VM.
Questo comporta un dispendio enorme, pensiamo ad una macchina Linux che non è in grado per forza di cose di eseguire e distribuire un'applicativo .net, questo quindi comporta nel nostro hypervisor l'avere una VM windows per far girare l'applicativo che vogliamo distribuire, e magari mettere le due VM a parlarsi. Docker nasce per l'appunto per sveltire questo procedimento che crea nel 2024 non pochi problemi (visto anche le risorse sempre in aumento).

Usare Docker permette di snellire questo processo, ma come facciamo a buildare con Docker un applicativo qualsiasi? e soprattutto come posso testarlo in localhost? e come posso far si di pushare una versione del mio applicativo online?

Partiamo con ordine per spiegare in successione tutto quello che ci serve.

Buildare applicativo personale con Docker
Per Buildare con Docker il proprio applicativo occorre creare nella root del proprio progetto un file chiamato Dockerfile, dove al suo interno vengono specificate le istruzioni per buildare il Docker come deve essere.
Facciamo l'esempio di un mio applicativo Python nel quale non voglio installare sulla mia macchina tutte le sue librerie per poter girare, ma vorrei comunque testarlo.

YAML:

# Use an official Python 3.10 runtime as a parent image
FROM python:3.10-slim

# Set the working directory in the container
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install pip and upgrade it to avoid conflicts
RUN pip install --upgrade pip

# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Make port 5000 available to the world outside this container
EXPOSE 5000

# Define environment variable for Flask
ENV FLASK_APP=app.py

# Run Flask on container startup
CMD ["flask", "run", "--host=0.0.0.0"]

Il codice in questione permette di creare un container per distribuire un'applicazione Flask in Python, ma analizziamolo nel dettaglio:
- alla prima riga viene definito che immagine deve essere creata ed in questo caso è Python3.10
- alla seconda riga viene definita la path dove si deve operare in questo caso /app (spesso e volentieri il path è questo)
- alla terza riga viene definito che file deve contenere app e in questo caso copia tutto il contenuto del mio progetto
- alla quarta riga fa un update del Pip (componente python per installare le librerie)
- alla quinta riga fa l'install di tutte le dipendenze che servono al progetto python per essere eseguito, il file requirements.txt serve a quello
- alla sesta riga, essendo un'applicazione in flask espone la porta 5000 che è colei che espone la pagina web o il servizio flask
- la riga sette definisce una variabile env dove gli si dice a flask qual è il suo main file da eseguire
- la riga 8 definisce il comando di avvio di del Container.

Questa serie di Comandi builderà un Docker Container che sarà a disposizione sul vostro Docker Desktop e vi permetterà di effettuare le prove del vostro applicativo.
Ovviamente in caso di errori, il Container non si builda e non sarà possibile startarlo.
Questo è molto comodo perchè cosi permette di non dover installare librerie sulla propria macchina, ma si potrà comunque eseguire l'applicativo in un ambiente pulito ed isolato.

E se volessi installare il mio Container Docker su un'altra macchina come posso fare?
Nel caso di sviluppatori si potrebbe clonare la repository del vostro codice sorgente e ricompiare il docker tramite dockerfile.

Ma Docker mette a disposizione un altro strumento chiamato DockerHub. E un portale dove è possibile caricare le proprie immagini Docker. Con l'account Free si possono caricare n docker images in maniera pubblica e una sola in maniera privata. Con la licenza invece si potranno caricare n images private.

Quindi per fare questo procedimento basta eseguire questo set di istruzioni:

Codice:

docker build -t <nomeimmaginedocker> .

docker login (permette di connetterti al tuo DockerHub)

docker tag <nomeimmaginedocker> dockerhubaccount/<nomeimmaginedocker>:version_name

docker push dockerhubaccount/<nomeimmaginedocker>:version_name

Con queste istruzioni caricherai sul tuo account dockerhub la tua immagine docker con il numero di versione che preferisci.
Ma come la si può installare allora sulla mia macchina?

Seguendo questo set di istruzioni

Codice:

ssh christian@1111.1111.1111.1111 (nel mio caso è ssh, ma potrebbe essere in altro modo)
use your password
docker login
docker pull dockerhubaccount/<nomeimmaginedocker>:version_name
docker stop <nomeimmaginedocker>
docker rm <nomeimmaginedocker>
docker run -d --name <nomeimmaginedocker> dockerhubaccount/<nomeimmaginedocker>:version_name
docker ps

Il comando Docker PS permetterà di vedere l'esecuzione del vostro container in caso di avvenuto successo.

Ultimo ma non ultimo è possibile combinare un immagine Docker con piu servizi, ad esempio la mia applicazione con un database??
Assolutamente si, è possibile farlo, usando in accoppiata il Dockerfile con il file Docker-compose.
Nella mia casistica di un altro applicativo ho effettuato quanto segue:

Codice:

# Use an official Maven image with OpenJDK as a parent image
FROM maven:3.8.4-openjdk-17 AS build

# Set the working directory to /app
WORKDIR /app

# Copy the Maven project file
COPY pom.xml .

# Copy the entire project
COPY . .

# Run Maven to build the application
RUN mvn clean package

# Debug: List contents of the target directory
RUN ls -la /app/target/

# Use a minimal JRE image for the final image
FROM openjdk:17-slim

# Set the working directory to /app
WORKDIR /app

# Copy the JAR file from the build stage to the final image
COPY --from=build /app/target/backend-0.0.1-SNAPSHOT.jar ./backend-0.0.1-SNAPSHOT..jar


# Expose the port on which the Spring Boot app will run
EXPOSE 8080

# Set the default command to run your application
CMD ["java", "-jar", "backend-0.0.1-SNAPSHOT..jar"]

In questo caso builda un applicativo Backend in Java Spring boot con Java 17 e Maven. Ma io vorrei in un unico Docker container anche il db MongoDB con cui questo backend deve parlare e quindi tramite il docker compose:

Codice:

version: '3.8'

services:
  mongodb:
    image: mongo:6.0
    container_name: my-mongo-db
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: root.1234
      MONGO_INITDB_DATABASE: miodb
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db
    networks:
      - app-network

  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: my-java-app
    environment:
      SPRING_DATA_MONGODB_DATABASE: miodb
      SPRING_DATA_MONGODB_HOST: mongodb
      SPRING_DATA_MONGODB_PORT: 27017
    ports:
      - "8080:8080"
    depends_on:
      - mongodb
    networks:
      - app-network

volumes:
  mongo_data:

networks:
  app-network:

Docker Compose serve, per l’appunto, a gestire in modo immediato i propri container. I suoi comandi infatti consentono di:

avviare, fermare, e riavviare le applicazioni istanziate;
vedere lo stato dei servizi in esecuzione;
consultare lo stream dei log dei servizi in esecuzione;
eseguire comandi all’interno dei container

e altro.

In pratica, senza l’adozione di Docker Compose ogni qual volta è necessario mettere in esecuzione un container, è necessario conoscerne il comando ed eseguirlo.

Usando Docker Compose affiancato a Docker, ogni qual volta si ha necessità di aggiungere un container al proprio “stack” è sufficiente aggiungere una porzione di codice di configurazione ad esso relativa al proprio file docker-compose.yaml, il quale consentirà a Docker Compose di “conoscere” le caratteristiche del nuovo container (oltre a quelli già presenti) e quindi consentirne una rapida e pratica gestione.

Nel mio caso ho potuto creare un container unico che contiene l'immagine del mio backend e l'immagine del mio database.

Perché si usa?

Per praticità.
Immaginiamo banalmente di dover amministrare un certo numero di container: volendo istanziare tutte le componenti necessarie in un sistema di media complessità, potremmo arrivare a definirne anche una decina.

Va da sé che per ognuno sarebbe necessario segnarsi da parte il corretto comando di esecuzione (in base ai tanti parametri diversi di ognuno) per eseguirlo nuovamente ogni qual volta sia necessario cancellare e ricreare il container (per esempio, in caso di aggiornamento dell’immagine per sopravvenuto aggiornamento dell’applicazione).

Per ulteriori informazioni o dettagli vi invito a leggere la documentazione ufficiale, in questo caso la guida è solo introduttiva sui comandi base per far partire un proprio docker container.