Exécuter des conteneurs Docker dans Kubernetes

Docker a révolutionné la manière dont les applications sont conçues, empaquetées et déployées. Cependant, à mesure que les applications gagnent en taille et en complexité, la gestion de multiples conteneurs Docker peut devenir une tâche ardue. C'est là qu'intervient Kubernetes. Kubernetes, une plateforme d'orchestration open source, fournit des outils puissants pour gérer des applications conteneurisées à grande échelle. Dans cet article, nous explorerons comment exécuter des conteneurs Docker au sein d'un cluster Kubernetes, en abordant les concepts essentiels, les configurations et les bonnes pratiques.

Comprendre les bases

Avant de plonger dans l'exécution de conteneurs Docker dans Kubernetes, il est essentiel de comprendre certains concepts fondamentaux.

Qu'est-ce que Docker ?

Docker est une plateforme qui permet aux développeurs d'automatiser le déploiement d'applications dans des conteneurs légers et portables. Les conteneurs regroupent l'application et toutes ses dépendances, garantissant ainsi qu'elle fonctionne de manière cohérente dans différents environnements.

Qu'est-ce que Kubernetes ?

Kubernetes (souvent abrégé en K8s) est une plateforme d'orchestration de conteneurs conçue pour automatiser le déploiement, la mise à l'échelle et la gestion des applications conteneurisées. Elle abstrait l'infrastructure sous-jacente, ce qui facilite la gestion de grands clusters de conteneurs.

Why Use Kubernetes with Docker?

While Docker provides the ability to run containers on a single host, Kubernetes allows you to manage clusters of Docker containers across multiple hosts. It provides features such as:

• Scaling: Mettez automatiquement à l'échelle votre application vers le haut ou vers le bas en fonction de la demande.
• Équilibrage de charge: Distribute traffic to ensure a high availability of applications.
• Self-HealingRemplacer automatiquement les conteneurs défaillants et les replanifier sur des nœuds sains.
• Service DiscoveryDétecter automatiquement les conteneurs et gérer leurs échanges.

Setting Up Your Environment

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

1. Kubernetes ClusterVous pouvez configurer un cluster Kubernetes local à l'aide d'outils comme Minikube ou Kind, ou utiliser des solutions gérées dans le cloud comme Google Kubernetes Engine (GKE), Amazon EKS ou Azure AKS.
2. Docker installéAssurez-vous que Docker est installé sur votre machine pour construire des images Docker.
3. kubectlInstaller kubectl, the command-line tool for interacting with your Kubernetes cluster.

Installation de Minikube

Pour le développement local, vous pourriez utiliser Minikube. Voici un guide de configuration rapide :

1. Installer Minikube: Follow the installation instructions for your operating system from the Documentation Minikube.
2. Start Minikube:

   minikube start

3. Verify the Installation:

   kubectl get nodes

Building a Docker Image

Une fois votre environnement configuré, vous pouvez créer une image Docker pour votre application. Voici un exemple d'une application Node.js simple.

Step 1: Create a Simple Node.js Application

Create a directory called myapp et ajoutez les fichiers suivants :

app.js:

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

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

app.listen(PORT, () => {
    console.log(`Le serveur est en cours d'exécution sur http://localhost:${PORT}`);
});

package.json:

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

Étape 2 : Créer un Dockerfile

Créez un fichier nommé Dockerfile in the myapp répertoire :

# Use the official Node.js image.
FROM node:14

# Set the working directory.
WORKDIR /usr/src/app

# Copy package.json and install dependencies.
COPY package.json ./
RUN npm install

# Copy the rest of the application code.
COPY . .

# Expose the application port.
EXPOSE 3000

# Start the application.
CMD ["node", "app.js"]

Étape 3 : Construire l'image Docker

Naviguez vers le myapp directory and build your Docker image:

docker build -t myapp:1.0 .

Étape 4 : Exécuter l'image Docker localement (facultatif)

You can test your Docker image locally before deploying it to Kubernetes:

docker run -p 3000:3000 myapp:1.0

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

Deploying to Kubernetes

Maintenant que vous avez construit votre image Docker, il est temps de la déployer sur Kubernetes.

Étape 1 : Créer un déploiement Kubernetes

Un déploiement Kubernetes gère un ensemble de réplicas de votre application. Pour créer un déploiement, vous pouvez utiliser la commande suivante : deployment.yaml file.

deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: déploiement-de-mon-application
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mon-application
  template:
    metadata:
      labels:
        app: mon-application
    spec:
      containers:
      - name: mon-application
        image: mon-application:1.0
        ports:
        - containerPort: 3000

Étape 2 : Appliquez le déploiement

Use kubectl to apply the deployment configuration:

kubectl apply -f deployment.yaml

Étape 3 : Vérifier le déploiement

Vérifiez l'état de votre déploiement et de vos pods :

kubectl get deployments
kubectl get pods

Étape 4 : Exposer le déploiement

To make your application accessible from outside the cluster, you can expose it using a Service. Create a service.yaml file:

service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  type: NodePort
  selector:
    app: myapp
  ports:
    - port: 3000
      targetPort: 3000
      nodePort: 30001

Apply the service configuration:

kubectl apply -f service.yaml

Étape 5 : Accédez à votre application

Pour accéder à votre application, vous pouvez visiter :

http://:30001

Pour obtenir l'adresse IP de Minikube :

minikube ip

Mise à l'échelle et mise à jour des déploiements

Mise à l'échelle de l'application

Kubernetes permet de mettre facilement votre application à l'échelle, à la hausse ou à la baisse. Vous pouvez modifier directement le nombre souhaité de réplicas dans le déploiement :

kubectl scale deployment myapp-deployment --replicas=5

You can also update the deployment with a new image version:

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

Rolling Updates

Kubernetes prend en charge les mises à jour continues, ce qui vous permet de mettre à jour vos applications avec un temps d'arrêt minimal. Vous pouvez mettre à jour vos deployment.yaml fichier avec une nouvelle version de l'image et l'appliquer à nouveau.

Rollbacks

Si un problème survient lors de votre déploiement, Kubernetes vous permet de revenir à une version précédente :

kubectl rollout undo deployment/myapp-deployment

Monitoring and Logging

La surveillance et la journalisation sont essentielles dans les environnements de production. Kubernetes offre plusieurs moyens de surveiller et de journaliser vos applications :

Serveur de métriques

You can deploy the Kubernetes Metrics Server to collect resource metrics from the kubelets. This helps in horizontal pod autoscaling.

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

Journalisation

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.

En utilisant kubectl logs

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

kubectl logs 

Meilleures pratiques

Utiliser les demandes et limites de ressources

Définissez les demandes et limites de CPU et de mémoire pour vos conteneurs afin de garantir le bon fonctionnement de votre application et d'optimiser l'allocation des ressources :

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

Mettre en place des contrôles de santé

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

Organize your Kubernetes resources using namespaces, especially for larger applications, to avoid resource conflicts and facilitate resource management.

Version Control Your Kubernetes Manifests

Stockez vos manifests Kubernetes dans un système de contrôle de version (comme Git) pour faciliter la collaboration et le suivi des modifications.

Conclusion

Exécuter des conteneurs Docker dans Kubernetes offre une solution robuste pour gérer des applications conteneurisées à grande échelle. Avec des fonctionnalités telles que l'auto-réparation, la mise à l'échelle et la découverte de services, Kubernetes fournit une plateforme puissante pour déployer et gérer vos applications. En suivant les pratiques décrites dans cet article, vous pouvez créer des déploiements efficaces, évolutifs et maintenables dans Kubernetes. Au fur et à mesure de votre parcours avec Kubernetes, envisagez d'explorer des outils et intégrations supplémentaires qui peuvent améliorer encore vos capacités d'orchestration de conteneurs.