Pour mettre en place un cluster Kubernetes avec deux serveurs sous Red Hat, il y a plusieurs étapes à suivre. Voici un guide général pour vous aider à le faire :
Prérequis :
- Deux serveurs sous Red Hat (ou CentOS, Oracle Linux, etc.) avec une connexion réseau entre eux.
- Accès root ou un utilisateur avec privilèges sudo sur les deux serveurs.
- Ports nécessaires ouverts pour la communication entre les nœuds du cluster (par exemple, ports pour API Server, etcd, kubelet, etc.).
- Swap désactivé (Kubernetes ne supporte pas le swap, donc il faut désactiver ou le configurer).
Étape 1 : Préparer les serveurs
- Désactiver le swap (si ce n’est pas déjà fait) sur les deux nœuds :
sudo swapoff -a
Pour désactiver le swap de façon permanente, commentez ou supprimez la ligne contenantswap
dans/etc/fstab
:sudo vi /etc/fstab
Et retirez la ligne correspondante au swap. - Mettre à jour le système (sur les deux serveurs) :
sudo yum update -y
- Configurer le firewall pour autoriser les connexions entre les nœuds Kubernetes. Par exemple, vous pouvez désactiver le firewall temporairement pour tester la connectivité :
sudo systemctl stop firewalld sudo systemctl disable firewalld
Ou bien, ouvrez les ports nécessaires pour Kubernetes si vous préférez laisser le firewall actif. - Installer des dépendances (sur les deux serveurs) : Kubernetes nécessite certaines dépendances comme
kubelet
,kubeadm
etkubectl
.- Ajouter le repository Kubernetes :
sudo cat <<EOF > /etc/yum.repos.d/kubernetes.repo
- Ajouter le repository Kubernetes :
[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
.
- 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). - 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
- 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).
- 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
- 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.
- Joindre le nœud worker : Par exemple :
sudo kubeadm join <adresse_du_master>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>
- 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.
- Vérifiez les nœuds :
kubectl get nodes
- Vérifiez les pods sur le nœud master et worker :
kubectl get pods --all-namespaces
É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.
Déployer Prometheus sur un cluster Kubernetes est une excellente manière de collecter des métriques pour surveiller la performance et la santé de votre cluster. Vous pouvez utiliser Helm, un gestionnaire de packages Kubernetes, ou déployer Prometheus manuellement avec des fichiers de configuration YAML. Voici un guide pour les deux méthodes.
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.
- 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.
- Ajouter le dépôt de chart Prometheus :
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
- 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.
- Créer un espace de noms (namespace) pour Prometheus (facultatif mais recommandé) :
kubectl create namespace prometheus
- 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.
- Vérifier les pods :
kubectl get pods --namespace prometheus
- Vérifier les services :
kubectl get svc --namespace prometheus
- 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 viahttp://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 :
- Port-forward pour Grafana :
kubectl port-forward svc/prometheus-grafana 3000:80 --namespace prometheus
- Accéder à Grafana : Ouvrez un navigateur et allez à
http://localhost:3000
. Par défaut, le nom d’utilisateur estadmin
et le mot de passe est égalementadmin
(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 :
- 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
- 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.