rancher pour la gestion de k8s sur une infrastructure On premise. Développe les bonnes pratiques

Rancher pour la gestion de Kubernetes sur une infrastructure On-Premise : Bonnes pratiques et implémentation

Dans un paysage technologique où la conteneurisation et l'orchestration deviennent des piliers de l'infrastructure moderne, Kubernetes (K8s) s'est imposé comme la solution de référence. Cependant, gérer un cluster Kubernetes en interne, sur une infrastructure on-premise, présente des défis uniques : complexité opérationnelle, sécurité renforcée, et besoin de haute disponibilité. C'est ici que Rancher entre en jeu.

Rancher, développé par SUSE, est une plateforme open source qui simplifie la gestion des clusters Kubernetes, qu'ils soient déployés dans le cloud, en local, ou en environnement hybride. Dans cet article, nous explorerons comment utiliser Rancher pour optimiser la gestion de Kubernetes sur une infrastructure on-premise, en mettant l'accent sur les bonnes pratiques DevOps. Nous aborderons les aspects techniques, les configurations recommandées, et les stratégies pour garantir une exploitation fluide et sécurisée.

Pourquoi choisir Rancher pour Kubernetes On-Premise ?

Avant de plonger dans les détails techniques, il est essentiel de comprendre pourquoi Rancher est un choix judicieux pour les environnements on-premise. Voici ses principaux atouts :

• Centralisation de la gestion : Rancher permet de gérer plusieurs clusters Kubernetes depuis une seule interface, simplifiant ainsi l'administration et la supervision.
• Simplification des opérations : Avec des fonctionnalités comme le déploiement automatisé de clusters, la gestion des utilisateurs, et l'intégration avec des outils CI/CD, Rancher réduit la charge opérationnelle.
• Sécurité renforcée : Rancher offre des mécanismes de sécurité intégrés, tels que la gestion des rôles et des permissions (RBAC), l'intégration avec des fournisseurs d'identité (LDAP, Active Directory), et le chiffrement des communications.
• Flexibilité : Rancher supporte une large gamme de distributions Kubernetes (RKE, RKE2, K3s) et peut être déployé sur des infrastructures hétérogènes.
• Communauté et support : En tant que projet open source soutenu par une communauté active et une entreprise (SUSE), Rancher bénéficie d'un écosystème riche et d'un support professionnel.

Architecture et déploiement de Rancher

Prérequis pour un déploiement On-Premise

Avant de déployer Rancher, il est crucial de préparer votre infrastructure. Voici les prérequis techniques :

• Infrastructure matérielle :
  • Pour un environnement de production, prévoyez au moins 3 nœuds pour le plan de contrôle (pour la haute disponibilité) et un nombre suffisant de nœuds workers.
  • Chaque nœud doit disposer de :
    • 4 vCPUs minimum (8 recommandés pour la production).
    • 8 Go de RAM minimum (16 Go recommandés).
    • 50 Go d'espace disque (SSD recommandé pour les performances).
• Système d'exploitation :
  • Rancher est compatible avec la plupart des distributions Linux (Ubuntu 20.04/22.04, RHEL/CentOS 7/8, SUSE Linux).
  • Assurez-vous que les nœuds sont à jour et configurés avec un accès SSH.
• Réseau :
  • Un réseau privé avec une bande passante suffisante (1 Gbps recommandé).
  • Les ports suivants doivent être ouverts :

    Port	Protocole	Description
    80	TCP	Accès HTTP à l'interface Rancher (redirigé vers 443).
    443	TCP	Accès HTTPS à l'interface Rancher.
    6443	TCP	Port Kubernetes API (pour les clusters gérés par Rancher).
    22	TCP	Accès SSH pour l'administration des nœuds.
    2379-2380	TCP	Communication etcd (pour les clusters RKE/RKE2).
    10250	TCP	Port kubelet (pour la communication avec les nœuds).

• Stockage :
  • Prévoyez un stockage persistant pour les données de Rancher et des applications. Les solutions comme Longhorn (intégré à Rancher) ou Ceph sont recommandées.
• DNS et certificats :
  • Configurez un nom de domaine (FQDN) pour accéder à l'interface Rancher (ex: rancher.votre-domaine.com).
  • Utilisez des certificats TLS valides (Let's Encrypt ou certificats internes) pour sécuriser les communications.

Déploiement de Rancher

Rancher peut être déployé de plusieurs manières, mais la méthode la plus courante pour un environnement on-premise est d'utiliser Docker ou RKE (Rancher Kubernetes Engine). Nous allons détailler les deux approches.

Option 1 : Déploiement avec Docker (pour les environnements de test ou petits déploiements)

Cette méthode est idéale pour les environnements de développement ou les petits déploiements. Voici les étapes :

1. Installer Docker sur le nœud où Rancher sera déployé :

   # Pour Ubuntu/Debian
   sudo apt-get update
   sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common
   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
   echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
   sudo apt-get update
   sudo apt-get install -y docker-ce docker-ce-cli containerd.io
   
   # Démarrer et activer Docker
   sudo systemctl enable docker
   sudo systemctl start docker

2. Lancer le conteneur Rancher :

   sudo docker run -d --restart=unless-stopped \
     -p 80:80 -p 443:443 \
     --privileged \
     rancher/rancher:latest

   Remarque : Pour un environnement de production, il est recommandé d'utiliser un certificat TLS personnalisé. Voici un exemple avec un certificat Let's Encrypt :

   sudo docker run -d --restart=unless-stopped \
     -p 80:80 -p 443:443 \
     -v /etc/letsencrypt/live/votre-domaine.com/fullchain.pem:/etc/rancher/ssl/cert.pem \
     -v /etc/letsencrypt/live/votre-domaine.com/privkey.pem:/etc/rancher/ssl/key.pem \
     --privileged \
     rancher/rancher:latest

3. Accéder à l'interface Rancher :
   • Ouvrez un navigateur et accédez à https://votre-domaine.com.
   • Suivez les instructions pour configurer le mot de passe admin et le nom du serveur.

Option 2 : Déploiement avec RKE (pour les environnements de production)

Pour les environnements de production, il est recommandé de déployer Rancher sur un cluster Kubernetes hautement disponible. Voici comment procéder :

1. Installer RKE :

   # Télécharger RKE
   wget https://github.com/rancher/rke/releases/download/v1.3.12/rke_linux-amd64
   chmod +x rke_linux-amd64
   sudo mv rke_linux-amd64 /usr/local/bin/rke

2. Configurer le cluster RKE :

   Créez un fichier cluster.yml pour définir la configuration du cluster. Voici un exemple minimal :

   nodes:
     - address: 192.168.1.10
       user: ubuntu
       role: [controlplane, etcd, worker]
       ssh_key_path: ~/.ssh/id_rsa
     - address: 192.168.1.11
       user: ubuntu
       role: [controlplane, etcd, worker]
       ssh_key_path: ~/.ssh/id_rsa
     - address: 192.168.1.12
       user: ubuntu
       role: [controlplane, etcd, worker]
       ssh_key_path: ~/.ssh/id_rsa
   
   services:
     etcd:
       snapshot: true
       creation: 6h
       retention: 24h
   
   network:
     plugin: canal

3. Déployer le cluster :

   rke up --config cluster.yml

   Une fois le cluster déployé, un fichier kube_config_cluster.yml sera généré. Ce fichier est nécessaire pour interagir avec le cluster.

4. Installer Rancher sur le cluster RKE :

   Utilisez Helm pour installer Rancher. Assurez-vous d'avoir Helm installé sur votre machine locale :

   # Ajouter le dépôt Helm de Rancher
   helm repo add rancher-latest https://releases.rancher.com/server-charts/latest
   
   # Créer un namespace pour Rancher
   kubectl create namespace cattle-system
   
   # Installer cert-manager (nécessaire pour les certificats TLS)
   kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.8.2/cert-manager.crds.yaml
   helm repo add jetstack https://charts.jetstack.io
   helm repo update
   helm install cert-manager jetstack/cert-manager \
     --namespace cert-manager \
     --create-namespace \
     --version v1.8.2
   
   # Installer Rancher
   helm install rancher rancher-latest/rancher \
     --namespace cattle-system \
     --set hostname=rancher.votre-domaine.com \
     --set bootstrapPassword=admin \
     --set replicas=3

   Remarque : Pour une installation avec des certificats personnalisés, utilisez les options --set privateCA=true et fournissez les certificats via des secrets Kubernetes.

5. Vérifier l'installation :

   kubectl -n cattle-system get pods

   Tous les pods doivent être en statut Running.

Bonnes pratiques pour la gestion de Kubernetes avec Rancher

Maintenant que Rancher est déployé, voyons comment l'utiliser efficacement pour gérer vos clusters Kubernetes on-premise. Voici les bonnes pratiques à suivre :

1. Gestion des clusters et haute disponibilité

• Déployer des clusters hautement disponibles :
  • Pour les clusters de production, utilisez au moins 3 nœuds pour le plan de contrôle (control plane) et 2 nœuds workers.
  • Activez l'option HA (Haute Disponibilité) lors de la création du cluster dans Rancher.
  • Utilisez RKE2 ou K3s pour des clusters légers et optimisés pour les environnements on-premise.
• Sauvegarder et restaurer les clusters :
  • Rancher intègre un outil de sauvegarde pour les clusters RKE. Configurez des sauvegardes régulières :

    # Exemple de configuration de sauvegarde dans cluster.yml
    services:
      etcd:
        snapshot: true
        creation: 6h
        retention: 24h

  • Pour restaurer un cluster, utilisez la commande suivante :

    rke etcd snapshot-restore --name  --config cluster.yml

  • Pour les clusters RKE2/K3s, utilisez les outils intégrés comme etcd-snapshot.

2. Sécurité et gestion des accès

• Configurer le RBAC (Role-Based Access Control) :
  • Rancher permet de définir des rôles et des permissions granulaires. Utilisez cette fonctionnalité pour restreindre l'accès aux ressources sensibles.
  • Créez des Global Roles pour les administrateurs et des Cluster Roles pour les équipes spécifiques.
  • Exemple de création d'un rôle personnalisé :

    # Utilisez l'API Rancher ou l'interface pour créer un rôle
    # Voici un exemple de définition YAML pour un rôle personnalisé
    apiVersion: management.cattle.io/v3
    kind: RoleTemplate
    metadata:
      name: dev-team-role
    rules:
    - apiGroups: [""]
      resources: ["pods", "services"]
      verbs: ["get", "list", "watch", "create", "update", "delete"]
    - apiGroups: ["apps"]
      resources: ["deployments"]
      verbs: ["get", "list", "watch", "create", "update"]

• Intégrer un fournisseur d'identité :
  • Rancher supporte l'intégration avec des fournisseurs d'identité comme LDAP, Active Directory, ou OAuth (Google, GitHub).
  • Pour configurer LDAP :
    1. Accédez à Global Settings > Security > Authentication.
    2. Sélectionnez LDAP et configurez les paramètres de connexion (serveur LDAP, port, DN de base, etc.).
    3. Testez la connexion et sauvegardez.
• Chiffrement des communications :
  • Assurez-vous que toutes les communications entre Rancher et les clusters Kubernetes sont chiffrées (TLS).
  • Utilisez des certificats valides pour l'interface Rancher et les clusters gérés.
  • Pour les environnements internes, utilisez une autorité de certification (CA) interne pour signer les certificats.
• Mises à jour et correctifs :
  • Gardez Rancher et les clusters Kubernetes à jour avec les dernières versions stables.
  • Planifiez les mises à jour pendant les fenêtres de maintenance pour minimiser l'impact sur les applications.
  • Utilisez la fonctionnalité Cluster Upgrades de Rancher pour mettre à jour les clusters de manière contrôlée.

3. Surveillance et journalisation

• Configurer la surveillance avec Prometheus et Grafana :
  • Rancher intègre Monitoring (basé sur Prometheus et Grafana) pour surveiller les clusters.
  • Activez la surveillance lors de la création du cluster ou via l'interface Rancher :
    1. Accédez au cluster dans Rancher.
    2. Allez dans Tools > Monitoring.
    3. Cliquez sur Enable Monitoring et configurez les paramètres (retention des données, alertes, etc.).
  • Personnalisez les tableaux de bord Grafana pour afficher les métriques pertinentes (CPU, mémoire, réseau, etc.).
• Centraliser les logs avec Elasticsearch, Fluentd et Kibana (EFK) :
  • Rancher supporte l'intégration avec des solutions de journalisation comme EFK ou Loki.
  • Pour déployer EFK :

    # Ajouter le dépôt Helm
    helm repo add elastic https://helm.elastic.co
    helm repo update
    
    # Installer Elasticsearch
    helm install elasticsearch elastic/elasticsearch \
      --namespace logging \
      --set replicas=1 \
      --set persistence.enabled=false
    
    # Installer Fluentd
    helm install fluentd elastic/fluentd \
      --namespace logging
    
    # Installer Kibana
    helm install kibana elastic/kibana \
      --namespace logging \
      --set service.type=NodePort

  • Configurez Rancher pour envoyer les logs vers Elasticsearch via l'interface ou en modifiant les paramètres du cluster.
• Configurer des alertes :
  • Utilisez Alertmanager (intégré à Prometheus) pour configurer des alertes en cas de problèmes (ex: nœud hors ligne, utilisation élevée du CPU).
  • Exemple de configuration d'une alerte pour un nœud hors ligne :

    groups:
    - name: node-alerts
      rules:
      - alert: NodeDown
        expr: up == 0
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Node {{ $labels.instance }} is down"
          description: "Node {{ $labels.instance }} has been down for more than 5 minutes."

4. Gestion des applications et CI/CD

• Déployer des applications avec Rancher Catalog :
  • Rancher propose un Catalog d'applications pré-packagées (Helm charts) pour simplifier les déploiements.
  • Pour déployer une application :
    1. Accédez au cluster dans Rancher.
    2. Allez dans Apps > Charts.
    3. Sélectionnez l'application (ex: Nginx, MySQL) et configurez les paramètres.
    4. Cliquez sur Launch pour déployer l'application.
• Intégrer Rancher avec des outils CI/CD :
  • Rancher peut être intégré avec des outils comme Jenkins, GitLab CI, ou GitHub Actions pour automatiser les déploiements.
  • Exemple d'intégration avec GitLab CI :

    # Fichier .gitlab-ci.yml
    stages:
      - deploy
    
    deploy_to_production:
      stage: deploy
      image: bitnami/kubectl:latest
      script:
        - kubectl config use-context 
        - kubectl apply -f k8s/deployment.yaml
      only:
        - main

  • Pour obtenir le kubeconfig du cluster Rancher :
    1. Accédez au cluster dans Rancher.
    2. Cliquez sur Kubeconfig File pour télécharger le fichier.
    3. Utilisez ce fichier dans votre outil CI/CD pour interagir avec le cluster.
• Gestion des secrets :
  • Utilisez Kubernetes Secrets pour gérer les informations sensibles (mots de passe, clés API).
  • Évitez de stocker des secrets en clair dans les fichiers de configuration. Utilisez plutôt des outils comme HashiCorp Vault ou AWS Secrets Manager.
  • Exemple de création d'un secret dans Rancher :

    # Via l'interface Rancher :
    # 1. Accédez au projet ou au namespace.
    # 2. Allez dans "Resources > Secrets".
    # 3. Cliquez sur "Add Secret" et remplissez les informations.
    
    # Via kubectl :
    kubectl create secret generic db-secret \
      --from-literal=username=admin \
      --from-literal=password='S3cr3tP@ss' \
      -n 

5. Optimisation des coûts et des ressources

• Dimensionner les clusters :
  • Utilisez les outils de surveillance pour identifier les goulots d'étranglement et ajuster la taille des clusters.
  • Mettez en place des politiques d'auto-scaling (Horizontal Pod Autoscaler, Cluster Autoscaler) pour optimiser l'utilisation des ressources.
  • Exemple de configuration HPA pour un déploiement :

    apiVersion: autoscaling/v2
    kind: HorizontalPodAutoscaler
    metadata:
      name: nginx-hpa
    spec:
      scaleTargetRef:
        apiVersion: apps/v1
        kind: Deployment
        name: nginx
      minReplicas: 2
      maxReplicas: 10
      metrics:
      - type: Resource
        resource:
          name: cpu
          target:
            type: Utilization
            averageUtilization: 50

• Gestion des coûts :
  • Pour les environnements on-premise, surveillez l'utilisation des ressources pour éviter le sur-provisionnement.
  • Utilisez des outils comme Kubecost pour analyser les coûts des clusters Kubernetes.
  • Exemple d'installation de Kubecost :

    helm repo add kubecost https://kubecost.github.io/cost-analyzer/
    helm install kubecost kubecost/cost-analyzer \
      --namespace kubecost --create-namespace \
      --set kubecostToken="votre_token"

Conclusion

Rancher est une solution puissante et flexible pour gérer des clusters Kubernetes sur une infrastructure on-premise. En suivant les bonnes pratiques présentées dans cet article, vous pouvez :

• Simplifier la gestion de vos clusters grâce à une interface centralisée.
• Renforcer la sécurité avec des mécanismes comme le RBAC et l'intégration des fournisseurs d'identité.
• Améliorer la résilience de vos applications avec des stratégies de haute disponibilité et de sauvegarde.
• Optimiser les coûts et les ressources grâce à une surveillance proactive et des outils d'auto-scaling.
• Automatiser les déploiements avec des intégrations CI/CD.

Que vous soyez une petite équipe ou une grande entreprise, Rancher offre les outils nécessaires pour exploiter pleinement le potentiel de Kubernetes dans un environnement on-premise. En adoptant une approche structurée et en suivant les bonnes pratiques DevOps, vous pouvez garantir une infrastructure stable, sécurisée et scalable.

Pour aller plus loin, nous vous recommandons de consulter la documentation officielle de Rancher et de participer aux discussions de la communauté pour rester à jour avec les dernières évolutions.