Running Docker Containers in Kubernetes

Docker ha rivoluzionato il modo in cui le applicazioni vengono costruite, impacchettate e distribuite. Tuttavia, man mano che le applicazioni crescono in dimensioni e complessità, gestire più container Docker può diventare un compito arduo. È qui che entra in gioco Kubernetes. Kubernetes, una piattaforma di orchestrazione open-source, fornisce potenti strumenti per gestire applicazioni containerizzate su larga scala. In questo articolo, esploreremo come eseguire container Docker all'interno di un cluster Kubernetes, coprendo i concetti essenziali, le configurazioni e le migliori pratiche.

Capire le Basi

Prima di addentrarsi nell'eseguire container Docker in Kubernetes, è fondamentale comprendere alcuni concetti fondamentali.

Cos'è Docker?

Docker è una piattaforma che consente agli sviluppatori di automatizzare la distribuzione di applicazioni all'interno di contenitori leggeri e portatili. I contenitori impacchettano l'applicazione e tutte le sue dipendenze, garantendo che funzioni in modo coerente in vari ambienti.

What is Kubernetes?

Kubernetes (spesso abbreviato come K8s) è una piattaforma di orchestrazione dei container progettata per automatizzare la distribuzione, il ridimensionamento e la gestione delle applicazioni containerizzate. Essa astrae l'infrastruttura sottostante, rendendo più semplice la gestione di grandi cluster di container.

Why Use Kubernetes with Docker?

Mentre Docker fornisce la capacità di eseguire contenitori su un singolo host, Kubernetes ti permette di gestire cluster di contenitori Docker su più host. Fornisce funzionalità come:

• Scaling: Automatically scale your application up or down based on demand.
• Load BalancingDistribuire il traffico per garantire un'elevata disponibilità delle applicazioni.
• Auto-guarigione: Automatically replace failed containers and reschedule them on healthy nodes.
• Scoperta del servizio: Automatically discover containers and manage their communications.

Configurazione dell'ambiente

Before running Docker containers in Kubernetes, ensure that you have the following prerequisites:

1. Kubernetes Cluster: You can set up a local Kubernetes cluster using tools like Minikube or Kind, or use cloud-managed solutions like Google Kubernetes Engine (GKE), Amazon EKS, or Azure AKS.
2. Docker InstalledAssicurati che Docker sia installato sul tuo computer per creare immagini Docker.
3. kubectlInstallare kubectl, lo strumento da riga di comando per interagire con il tuo cluster Kubernetes.

Installare Minikube

For local development, you might want to use Minikube. Here’s a quick setup guide:

1. Install Minikube: Follow the installation instructions for your operating system from the Minikube documentation.
2. Avvia Minikube:

   minikube start

3. Verifica l'installazione:

   kubectl get nodes

Creare un'immagine Docker

Once your environment is set up, you can create a Docker image for your application. Here’s an example of a simple Node.js application.

Passaggio 1: Creare una Semplice Applicazione Node.js

Crea una directory chiamata myapp and add the following files:

app.js:

const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
    res.send('Ciao, Kubernetes con Docker!');
});

app.listen(PORT, () => {
    console.log(`Il server è in esecuzione su http://localhost:${PORT}`);
});

package.json:

{
  "name": "miapp",
  "version": "1.0.0",
  "main": "app.js",
  "dependencies": {
    "express": "^4.17.1"
  }
}

Passo 2: Creare un Dockerfile

Create a file named Dockerfile in myapp directory:

# Utilizza l'immagine ufficiale di Node.js.
FROM node:14

# Imposta la directory di lavoro.
WORKDIR /usr/src/app

# Copia package.json e installa le dipendenze.
COPY package.json ./
RUN npm install

# Copia il resto del codice dell'applicazione.
COPY . .

# Esponi la porta dell'applicazione.
EXPOSE 3000

# Avvia l'applicazione.
CMD ["node", "app.js"]

Step 3: Build the Docker Image

Vai a myapp directory e crea la tua immagine Docker:

docker build -t myapp:1.0 .

Passaggio 4: eseguire l'immagine Docker localmente (facoltativo)

Puoi testare la tua immagine Docker localmente prima di distribuirla su Kubernetes:

docker run -p 3000:3000 myapp:1.0

Visit http://localhost:3000 in your browser to see the application running.

Distribuendo su Kubernetes

Ora che hai creato la tua immagine Docker, è il momento di distribuirlo su Kubernetes.

Passaggio 1: Creare una distribuzione Kubernetes

Una distribuzione Kubernetes gestisce un insieme di repliche della tua applicazione. Per creare una distribuzione, puoi utilizzare il seguente file di distribuzione.yaml file.

file di distribuzione.yaml:

apiVersion: apps/v1
kind: Distribuzione
metadata:
  name: myapp-deployment
spec:
  repliche: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        ports:
        - containerPort: 3000

Fase 2: Applicare la Distribuzione

Utilizzo kubectl per applicare la configurazione di distribuzione:

kubectl apply -f deployment.yaml

Step 3: Verify the Deployment

Controlla lo stato del tuo deployment e dei pod:

kubectl ottieni deployments
kubectl ottieni pods

Step 4: Esposizione della Deploy

Per rendere la tua applicazione accessibile dall'esterno al cluster, puoi esporla utilizzando un Servizio. Crea un service.yaml file:

service.yaml:

apiVersion: v1
kind: Service
metadata:
  nome: myapp-service
spec:
  tipo: NodePort
  selector:
    app: myapp
  ports:
    - porta: 3000
      targetPort: 3000
      nodePort: 30001

Applica la configurazione del servizio:

kubectl apply -f service.yaml

Step 5: Access Your Application

To access your application, you can visit:

http://:30001

Per ottenere l'indirizzo IP di Minikube:

minikube ip

Scaling and Updating Deployments

Scaling the Application

Kubernetes makes it easy to scale your application up or down. You can change the desired number of replicas directly in the deployment:

kubectl scale deployment myapp-deployment --replicas=5

Puoi anche aggiornare il deployment con una nuova versione dell'immagine:

kubectl set image deployment/myapp-deployment myapp=myapp:2.0

Rolling Updates

Kubernetes supports rolling updates, allowing you to update your applications with minimal downtime. You can update your file di distribuzione.yaml file con una nuova versione dell'immagine e riapplicarla.

Rollbacks

If something goes wrong with your deployment, Kubernetes allows you to rollback to a previous version:

kubectl rollout undo deployment/myapp-deployment

Monitoraggio e Registrazione

Il monitoraggio e il logging sono fondamentali negli ambienti di produzione. Kubernetes fornisce diversi modi per monitorare e registrare le tue applicazioni:

Server delle metriche

Puoi deployare il server metriche Kubernetes per raccogliere metriche risorse dai kubelets. Ciò aiuta nella scalabilità automatica orizzontale dei pod.

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Logging

Kubernetes does not provide built-in logging but integrates with various logging solutions like Fluentd, Logstash, and Elasticsearch. You can use these tools to aggregate logs from your containers.

Usando kubectl logs

To view logs from a specific pod, you can use:

kubectl logs 

Best Practices

Utilizzare le richieste e i limiti delle risorse

Define CPU and memory requests and limits for your containers to ensure that your application runs smoothly and to optimize resource allocation:

resources:
  requests:
    memory: "64Mi"
    cpu: "250m"
  limits:
    memory: "128Mi"
    cpu: "500m"

Implementare i controlli di salute

Implement readiness and liveness probes to ensure that your applications are healthy:

readinessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 5
  periodSeconds: 10

livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 15
  periodSeconds: 20

Use Namespaces

Organizza le tue risorse Kubernetes utilizzando gli spazi dei nomi, in particolare per le applicazioni di grandi dimensioni, per evitare conflitti di risorse e semplificare la gestione delle risorse.

Version Control Your Kubernetes Manifests

Store your Kubernetes manifests in a version control system (like Git) for easier collaboration and change tracking.

Conclusione

Eseguire container Docker in Kubernetes offre una soluzione robusta per gestire applicazioni containerizzate su larga scala. Con funzionalità come auto-riparazione, scalabilità e scoperta dei servizi, Kubernetes fornisce una piattaforma potente per distribuire e gestire le tue applicazioni. Seguendo le pratiche descritte in questo articolo, puoi creare distribuzioni efficienti, scalabili e mantenibili in Kubernetes. Mentre prosegui il tuo percorso con Kubernetes, valuta di esplorare strumenti e integrazioni aggiuntivi che possano migliorare ulteriormente le tue capacità di orchestrazione dei container.