Voici un guide étape par étape pour conteneuriser une application, déployer l'application conteneurisée sur Kubernetes, gérer l'accès, la mise à l'échelle, l'autoguérison, et sécuriser l'application:

1. Conteneurisation d'une application

1.1 Créez un Dockerfile

• Créez un fichier nommé Dockerfile dans le répertoire de votre application.

• Rédigez les instructions nécessaires pour conteneuriser votre application. Voici un exemple pour une application "Hello World" en Python Flask :

  # Utilisez une image de base de Python
  FROM python:3.9
  LABEL authors="wannasi_malika"
  
  # Set the working directory in the container
  WORKDIR /app
  
  # Copy the requirements file into the working directory
  COPY requirements.txt /app
  
  # Install the dependencies
  RUN pip install --no-cache-dir -r requirements.txt
  
  # Copy the current directory contents into the container at /app
  COPY . /app
  
  # Expose the port that the application will listen on
  EXPOSE 5000
  
  # Command to run the application
  CMD ["python", "app.py"]

1.2 Construisez l'image Docker

• Dans le terminal, accédez au répertoire contenant votre Dockerfile.

• Exécutez la commande suivante pour construire l'image Docker :

  docker build -t mon-app:latest .

1.3 Poussez l'image vers un registre de conteneurs

• Connectez-vous à votre registre de conteneurs (Docker Hub, Google Container Registry, etc.).

• Marquez l'image avec le nom de votre registre :

  docker tag mon-app:latest mon-registre/mon-app:latest

• Poussez l'image vers le registre :

  docker push mon-registre/mon-app:latest

2. Déploiement Kubernetes

2.1 Créez un fichier YAML pour le déploiement

• Créez un fichier YAML nommé deployment.yaml pour déployer l'application sur Kubernetes.

• Voici un exemple de contenu pour un déploiement :

  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: mon-app-deployment
  spec:
    replicas: 3  # Le nombre de pods à créer
    selector:
      matchLabels:
        app: mon-app
    template:
      metadata:
        labels:
          app: mon-app
      spec:
        containers:
        - name: mon-app
          image: mon-registre/mon-app:latest
          ports:
          - containerPort: 5000
          livenessProbe:
            httpGet:
              path: /health
              port: 5000
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /health
              port: 5000
            initialDelaySeconds: 10
            periodSeconds: 5

• Ce fichier spécifie que 3 répliques de l'application doivent être exécutées, avec des sondes de vivacité et de disponibilité.

2.2 Appliquez le déploiement

• Exécutez la commande suivante pour appliquer le déploiement sur votre cluster Kubernetes :

  kubectl apply -f deployment.yaml

3. Service et Ingress

3.1 Créez un service Kubernetes

• Créez un fichier YAML nommé service.yaml pour exposer l'application via un service de type LoadBalancer.

  apiVersion: v1
  kind: Service
  metadata:
    name: mon-app-service
  spec:
    selector:
      app: mon-app
    ports:
    - protocol: TCP
      port: 80
      targetPort: 5000
    type: LoadBalancer

• Appliquez le service avec la commande suivante :

  kubectl apply -f service.yaml

3.2 (Optionnel) Configurez un Ingress Controller

• Créez un fichier YAML nommé ingress.yaml pour gérer l'accès externe à l'application via un nom d'hôte défini.

  apiVersion: networking.k8s.io/v1
  kind: Ingress
  metadata:
    name: mon-app-ingress
  spec:
    rules:
    - host: mon-app.example.com
      http:
        paths:
        - path: /
          pathType: Prefix
          backend:
            service:
              name: mon-app-service
              port:
                number: 80

• Appliquez l'Ingress avec la commande suivante :

  kubectl apply -f ingress.yaml

4. Mise à l'échelle et autoguérison

4.1 Configurez Horizontal Pod Autoscaler (HPA)

• Créez un fichier YAML nommé hpa.yaml pour configurer l'auto-échelle du nombre de pods en fonction de l'utilisation de CPU ou de mémoire.

  apiVersion: autoscaling/v2beta1
  kind: HorizontalPodAutoscaler
  metadata:
    name: mon-app-hpa
  spec:
    scaleTargetRef:
      apiVersion: apps/v1
      kind: Deployment
      name: mon-app-deployment
    minReplicas: 2
    maxReplicas: 10
    metrics:
    - type: Resource
      resource:
        name: cpu
        targetAverageUtilization: 50

• Appliquez l'HPA avec la commande suivante :

  kubectl apply -f hpa.yaml

4.2 Démontrez les mécanismes d'autoguérison de Kubernetes

• Supprimez un pod manuellement :

  kubectl delete pod mon-app-deployment-<pod-id>

• Kubernetes lancera automatiquement un nouveau pod pour remplacer le pod supprimé.

5. Sécurité

5.1 Implémentez NetworkPolicy

• Créez un fichier YAML nommé networkpolicy.yaml pour restreindre le trafic vers les pods de l'application.

  apiVersion: networking.k8s.io/v1
  kind: NetworkPolicy
  metadata:
    name: mon-app-network-policy
    namespace: default
  spec:
    podSelector:
      matchLabels:
        app: mon-app
    policyTypes:
    - Ingress
    - Egress
    ingress:
    - from:
      - ipBlock:
          cidr: 10.0.0.0/16
          except:
          - 10.0.1.0/24
      ports:
      - protocol: TCP
        port: 5000

• Appliquez la NetworkPolicy avec la commande suivante :

  kubectl apply -f networkpolicy.yaml

6. Utilisez Helm pour simplifier le processus de déploiement

6.1 Créez un chart Helm

• Créez un répertoire pour votre chart Helm :

  mkdir mon-app-chart
  cd mon-app-chart

• Exécutez la commande suivante pour initialiser le chart Helm :

  helm create .

6.2 Modifiez le chart Helm

• Placez les fichiers YAML pour le déploiement, le service, l'HPA, et la NetworkPolicy dans le répertoire templates du chart Helm.
• Modifiez les valeurs par défaut dans le fichier values.yaml.

6.3 Déployez l'application avec Helm

• Exécutez la commande suivante pour déployer l'application à l'aide de Helm :

  helm install mon-app mon-app-chart

Avec ce guide étape par étape, vous pouvez conteneuriser votre application, la déployer sur Kubernetes, gérer l'accès, la mise à l'échelle et l'autoguérison, sécuriser votre application, et simplifier le processus de déploiement avec Helm.