Skip to content

Latest commit

 

History

History
272 lines (207 loc) · 6.89 KB

README.md

File metadata and controls

272 lines (207 loc) · 6.89 KB
Raw

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.