Prérequis :

  1. Deux serveurs sous Red Hat (ou CentOS, Oracle Linux, etc.) avec une connexion réseau entre eux.
  2. Accès root ou un utilisateur avec privilèges sudo sur les deux serveurs.
  3. Ports nécessaires ouverts pour la communication entre les nœuds du cluster (par exemple, ports pour API Server, etcd, kubelet, etc.).
  4. Swap désactivé (Kubernetes ne supporte pas le swap, donc il faut désactiver ou le configurer).

Étape 1 : Préparer les serveurs

[kubernetes]

name=Kubernetes baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64 enabled=1 gpgcheck=1 gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg EOF

Installer kubeadm, kubelet et kubectl :

sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes

Activer et démarrer le kubelet :

sudo systemctl enable --now kubelet

Étape 2 : Initialiser le cluster sur le nœud principal (Master)

Sur le nœud principal (master), vous allez initialiser le cluster avec kubeadm.

  1. Initialiser le cluster Kubernetes : sudo kubeadm init --pod-network-cidr=10.244.0.0/16 Cette commande va initialiser le master et vous donner un token et une commande pour joindre le nœud worker au cluster (gardez ces informations précieuses).
  2. Configurer kubectl pour l’utilisateur root : Après l’initialisation, vous devez configurer kubectl pour qu’il puisse se connecter au cluster. Cela se fait en copiant le fichier de configuration vers votre dossier d’utilisateur : mkdir -p $HOME/.kube sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config sudo chown $(id -u):$(id -g) $HOME/.kube/config
  3. Vérifier l’état du cluster : Vous pouvez vérifier que le cluster fonctionne correctement en exécutant : kubectl get nodes

Étape 3 : Installer un réseau de pod

Avant de pouvoir ajouter des nœuds de travail (workers), vous devez installer un réseau de pods (par exemple, Flannel ou Calico).

  1. Installer Flannel (ou un autre réseau de pods) : Par exemple, pour Flannel : kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
  2. Vérifier les pods : Vérifiez que les pods nécessaires sont en cours d’exécution : kubectl get pods --all-namespaces

Étape 4 : Ajouter un nœud worker au cluster

Sur le nœud worker (l’autre serveur), exécutez la commande kubeadm join fournie à la fin de l’initialisation du nœud master.

  1. Joindre le nœud worker : Par exemple : sudo kubeadm join <adresse_du_master>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>
  2. Vérifier l’état du nœud : Sur le nœud master, vérifiez que le nœud worker est bien ajouté : kubectl get nodes

Étape 5 : Vérifier le cluster

Une fois que le nœud worker est ajouté, vérifiez à nouveau l’état du cluster et des pods pour vous assurer que tout fonctionne correctement.

Étape 6 : (Optionnel) Déployer une application

Une fois que le cluster est opérationnel, vous pouvez déployer une application pour tester le fonctionnement du cluster Kubernetes. Par exemple, vous pouvez déployer un simple pod :

kubectl run nginx --image=nginx --replicas=2 --port=80

Et exposer le service :

kubectl expose pod nginx --type=LoadBalancer --name=nginx-service

Conclusion

Avec ces étapes, vous avez mis en place un cluster Kubernetes de base avec un nœud master et un nœud worker. Vous pouvez maintenant commencer à déployer des applications, configurer des services, et gérer vos containers sur le cluster.

Méthode 1 : Déployer Prometheus avec Helm (Méthode recommandée)

Étape 1 : Installer Helm

Si vous n’avez pas encore installé Helm, vous devez d’abord le faire sur votre machine locale ou sur le nœud master.

  1. Installer Helm : Sur un système basé sur Linux : curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash Vous pouvez vérifier si Helm est correctement installé avec : helm version

Étape 2 : Ajouter le dépôt de chart de Prometheus

Helm utilise des « charts » pour déployer des applications Kubernetes. Prometheus a un chart officiel maintenu par Prometheus Community.

  1. Ajouter le dépôt de chart Prometheus : helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
  2. Mettre à jour les charts : helm repo update

Étape 3 : Installer Prometheus avec Helm

Vous pouvez maintenant déployer Prometheus sur votre cluster Kubernetes avec Helm.

  1. Créer un espace de noms (namespace) pour Prometheus (facultatif mais recommandé) : kubectl create namespace prometheus
  2. Installer Prometheus avec Helm : Utilisez la commande suivante pour installer Prometheus dans le namespace prometheus : helm install prometheus prometheus-community/kube-prometheus-stack --namespace prometheus Cette commande déploie Prometheus, Grafana (pour visualiser les métriques) et d’autres composants nécessaires à la surveillance.

Étape 4 : Vérifier l’installation

Une fois que l’installation est terminée, vous pouvez vérifier que les pods et services sont bien déployés.

  1. Vérifier les pods : kubectl get pods --namespace prometheus
  2. Vérifier les services : kubectl get svc --namespace prometheus
  3. Vérifier que Prometheus fonctionne : Accédez à l’interface web de Prometheus en exposant le service via un port local : kubectl port-forward svc/prometheus-kube-prometheus-prometheus 9090:9090 --namespace prometheus Vous pourrez maintenant accéder à Prometheus via http://localhost:9090.

Étape 5 : Accéder à Grafana

Grafana est également déployé avec Prometheus. Pour l’accès, vous pouvez utiliser une méthode de port forwarding similaire :

  1. Port-forward pour Grafana : kubectl port-forward svc/prometheus-grafana 3000:80 --namespace prometheus
  2. Accéder à Grafana : Ouvrez un navigateur et allez à http://localhost:3000. Par défaut, le nom d’utilisateur est admin et le mot de passe est également admin (vous pouvez le modifier après la première connexion).

Étape 6 : Ajouter des dashboards Grafana

Une fois dans Grafana, vous pouvez importer des dashboards prêts à l’emploi pour Prometheus. Par exemple, vous pouvez importer le dashboard Prometheus 2.0 Overview avec l’ID 1860 depuis la galerie de dashboards Grafana.

Méthode 2 : Déployer Prometheus Manuellement avec des fichiers YAML

Si vous préférez déployer Prometheus manuellement sans Helm, vous pouvez utiliser des fichiers YAML pour créer les ressources nécessaires. Voici un guide de base pour déployer Prometheus de cette manière.

Étape 1 : Créer un namespace pour Prometheus

Créez un espace de noms dédié à Prometheus :

kubectl create namespace prometheus

Étape 2 : Déployer les ressources de Prometheus

Téléchargez ou créez les fichiers YAML pour Prometheus. Voici un exemple de fichiers pour déployer Prometheus :

  1. Déployer Prometheus (StatefulSet) : Créez un fichier prometheus-deployment.yaml pour le StatefulSet de Prometheus : apiVersion: apps/v1 kind: StatefulSet metadata: name: prometheus namespace: prometheus spec: serviceName: "prometheus" replicas: 1 selector: matchLabels: app: prometheus template: metadata: labels: app: prometheus spec: containers: - name: prometheus image: prom/prometheus:v2.26.0 ports: - containerPort: 9090 volumeMounts: - name: prometheus-config mountPath: /etc/prometheus volumeClaimTemplates: - metadata: name: prometheus-config spec: accessModes: ["ReadWriteOnce"] resources: requests: storage: 1Gi
  2. Déployer le service Prometheus : Créez un fichier prometheus-service.yaml pour exposer Prometheus via un service : apiVersion: v1 kind: Service metadata: name: prometheus namespace: prometheus spec: ports: - port: 9090 targetPort: 9090 selector: app: prometheus

Étape 3 : Appliquer les fichiers YAML

Appliquez les fichiers YAML pour déployer Prometheus sur votre cluster Kubernetes :

kubectl apply -f prometheus-deployment.yaml
kubectl apply -f prometheus-service.yaml

Étape 4 : Accéder à Prometheus

Comme dans la méthode Helm, vous pouvez utiliser kubectl port-forward pour accéder à Prometheus :

kubectl port-forward svc/prometheus 9090:9090 --namespace prometheus

Allez ensuite à http://localhost:9090 pour accéder à l’interface de Prometheus.

Conclusion

Déployer Prometheus sur Kubernetes peut se faire de manière assez simple avec Helm, ou manuellement avec des fichiers YAML. La méthode avec Helm est généralement préférée car elle est plus rapide et gère plus facilement les mises à jour et la configuration des ressources.