Déploiement d'applications avec Kubernetes

Kubernetes est devenu la plateforme de référence pour l'orchestration de conteneurs. Dans cet article, nous allons explorer les meilleures pratiques pour déployer vos applications.

Concepts fondamentaux

Pods

Un Pod est la plus petite unité déployable dans Kubernetes. Il peut contenir un ou plusieurs conteneurs qui partagent le même réseau et stockage.

apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  containers:
  - name: app
    image: nginx:1.20
    ports:
    - containerPort: 80

Deployments

Les Deployments gèrent les Pods et fournissent des fonctionnalités comme les mises à jour progressives.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: nginx:1.20
        ports:
        - containerPort: 80

Services et exposition

ClusterIP

Service par défaut pour la communication interne :

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
  - port: 80
    targetPort: 80

LoadBalancer

Pour exposer votre application à l'extérieur :

apiVersion: v1
kind: Service
metadata:
  name: my-app-loadbalancer
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
  - port: 80
    targetPort: 80

Configuration et secrets

🚨 Sécurité : Ne jamais stocker de secrets en dur dans vos images Docker ou manifestes Kubernetes.

ConfigMaps

Pour la configuration non sensible :

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_url: "postgresql://db:5432/myapp"
  debug: "false"

Secrets

Pour les données sensibles :

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  password: cGFzc3dvcmQ=  # base64 encoded

Meilleures pratiques

1. Ressources et limites

Toujours définir des requests et limits :

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

2. Health checks

Configurer les probes pour la santé de l'application :

livenessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10

readinessProbe:
  httpGet:
    path: /ready
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5

3. Stratégies de déploiement

Rolling Update (par défaut)

strategy:
  type: RollingUpdate
  rollingUpdate:
    maxUnavailable: 1
    maxSurge: 1

Blue-Green Deployment

Utilisation d'Argo Rollouts pour des déploiements avancés.

Monitoring et observabilité

Métriques avec Prometheus

apiVersion: v1
kind: Service
metadata:
  name: my-app-metrics
  annotations:
    prometheus.io/scrape: "true"
    prometheus.io/port: "8080"
    prometheus.io/path: "/metrics"
spec:
  selector:
    app: my-app
  ports:
  - port: 8080
    name: metrics

Logs centralisés

Configuration pour Fluentd ou Fluent Bit :

apiVersion: v1
kind: ConfigMap
metadata:
  name: fluent-bit-config
data:
  fluent-bit.conf: |
    [INPUT]
        Name tail
        Path /var/log/containers/*.log
        Parser docker
        Tag kube.*

Sécurité

Network Policies

Contrôler le trafic réseau entre Pods :

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

Pod Security Standards

apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 2000
  containers:
  - name: app
    image: nginx:1.20
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      capabilities:
        drop:
        - ALL

Conclusion

Le déploiement sur Kubernetes nécessite une bonne compréhension des concepts fondamentaux et l'application des meilleures pratiques. En suivant ces recommandations, vous pourrez déployer des applications robustes et sécurisées.

✅ Conseil : Commencez petit avec des applications simples avant de passer à des architectures complexes.

Dans le prochain article, nous verrons comment mettre en place un pipeline CI/CD avec GitLab et Kubernetes.