Tutorial su Docker e Kubernetes

introduzione

Docker è una piattaforma che semplifica la distribuzione del software consentendo di raggruppare un'applicazione con il suo ambiente di runtime in un singolo pacchetto chiamato contenitore. Ciò garantisce che l'applicazione venga eseguita allo stesso modo indipendentemente da dove viene distribuita.

Kubernetes (spesso abbreviato in K8s) è un sistema di orchestrazione di container open source. Viene utilizzato per automatizzare la distribuzione, il ridimensionamento e la gestione di applicazioni containerizzate, come quelle create con Docker.

Prerequisiti

• Comprensione di base dei comandi di Linux
• Docker installato sulla tua macchina. Segui la guida all'installazione di Docker per configurarlo.
• Kubernetes installato sulla tua macchina. Segui la guida ufficiale all'installazione di Kubernetes.

Passaggio 1: Docker: creazione di un'immagine

Innanzitutto, creiamo un semplice Dockerfile per un'app Node.js.

Crea una nuova directory sul tuo computer locale e naviga al suo interno.

mkdir my-node-app && cd my-node-app

Crea un file denominato Dockerfile.

touch Dockerfile

Apri il Dockerfile e aggiungi il seguente codice:

# Use an official Node.js runtime as the base image
 FROM node:14

 # Set the working directory in the container to /app
 WORKDIR /app

 # Copy package.json and package-lock.json to the working directory
 COPY package*.json./# Install the application dependencies
 RUN npm install

 # Copy the rest of your application's source code to the working directory
 COPY..

 # Make the container listen on port 8080 at runtime
 EXPOSE 8080

 # Define the command to run the app
 CMD [ "node", "server.js" ]

Crea l'immagine Docker utilizzando il comando docker build.

docker build -t my-node-app.

Passaggio 2: Docker: esecuzione di un contenitore

Una volta creata l'immagine, puoi eseguirla come contenitore utilizzando docker run.

docker run -p 8080:8080 -d my-node-app

Questo comando indica a Docker di eseguire un contenitore con l'immagine my-node-app, mappare la porta 8080 all'interno del contenitore Docker alla porta 8080 sul computer host ed eseguire il contenitore in background (modalità scollegata).

Fase 3: Kubernetes - Creazione di un deployment

Kubernetes gestisce i container Docker tramite oggetti come pod e deployment. Un pod è l'oggetto Kubernetes più piccolo e semplice. Rappresenta una singola istanza di un processo in esecuzione in un cluster e può contenere uno o più contenitori.

Crea un file denominato deployment.yaml con il seguente contenuto:

apiVersion: apps/v1
 kind: Deployment
 metadata:
 name: my-node-app
 spec:
 replicas: 3
 selector:
 matchLabels:
 app: my-node-app
 template:
 metadata:
 labels:
 app: my-node-app
 spec:
 containers:
 - name: my-node-app
 image: my-node-app:latest
 ports:
 - containerPort: 8080

Applica questo deployment al tuo cluster Kubernetes utilizzando il comando kubectl apply.

kubectl apply -f deployment.yaml

Questo deployment crea tre pod replicati che eseguono il container my-node-app. Se un pod si arresta, il deployment lo ricreerà automaticamente per mantenere un conteggio di tre.

Passaggio 4: Kubernetes: esporre la tua distribuzione

Una volta completata la distribuzione, potresti volerla esporre a Internet. In Kubernetes, puoi farlo utilizzando un servizio, che è un'astrazione che definisce un insieme di pod e una policy in base alla quale accedervi.

Crea un file denominato service.yaml con il seguente contenuto:

apiVersion: v1
 kind: Service
 metadata:
 name: my-node-app
 spec:
 selector:
 app: my-node-app
 ports:
 - protocol: TCP
 port: 80
 targetPort: 8080
 type: LoadBalancer

Applica questo servizio al tuo cluster Kubernetes utilizzando il comando kubectl apply.

kubectl apply -f service.yaml

Questo servizio espone la distribuzione my-node-app all'esterno del cluster. La tipologia "LoadBalancer" garantisce che il Servizio sia accessibile tramite un IP di rete dedicato sul cloud, se supportato dal proprio provider cloud.

Passaggio 5: Kubernetes: verifica della distribuzione e del servizio

Per verificare se la distribuzione funziona come previsto, eseguire il comando seguente:

kubectl get deployments

Dovresti vedere la distribuzione "my-node-app" con tre repliche.

Allo stesso modo, per verificare il servizio, utilizzare il seguente comando:

kubectl get services

Dovresti vedere il servizio "my-node-app" con un indirizzo IP esterno. Puoi utilizzare questo indirizzo IP per accedere alla tua applicazione da un browser web.

Conclusione

E questo è tutto! Questo è un esempio molto semplice, ma dovrebbe darti un'idea di come utilizzare Docker e Kubernetes per containerizzare un'applicazione e distribuirla in un cluster Kubernetes.