कुबेरनेट्स एक ओपन-सोर्स कंटेनर ऑर्केस्ट्रेशन प्लेटफॉर्म है जो कंटेनरीकृत (containerized) एप्लिकेशन की तैनाती, स्केलिंग और प्रबंधन को स्वचालित करता है। यह वितरित सिस्टम के प्रबंधन के लिए एक मजबूत और लचीला ढांचा प्रदान करता है और व्यक्तिगत कंटेनरों के प्रबंधन की जटिलता को दूर करता है, जिससे डेवलपर्स एप्लिकेशन बनाने और शिप करने पर ध्यान केंद्रित कर सकते हैं।

Kubernetes est une plateforme d'orchestration de conteneurs open-source qui automatise le déploiement, le dimensionnement et la gestion des applications conteneurisées. Elle offre un cadre robuste et flexible pour gérer les systèmes distribués et abstrait la complexité de la gestion des conteneurs individuels, permettant aux développeurs de se concentrer sur la construction et la livraison d'applications.

कुबेरनेट्स, जिसे अक्सर K8s के रूप में संक्षिप्त किया जाता है, कंटेनरीकृत एप्लिकेशन को बड़े पैमाने पर प्रबंधित और ऑर्केस्ट्रेट करने की आवश्यकता से उभरा। इसे मूल रूप से गूगल द्वारा विकसित किया गया था और 2014 में ओपन-सोर्स किया गया था। यह प्रोजेक्ट तेजी से लोकप्रिय हुआ और अब इसे क्लाउड नेटिव कंप्यूटिंग फाउंडेशन (CNCF) द्वारा बनाए रखा जाता है, जिसमें दुनिया भर के डेवलपर्स के एक जीवंत समुदाय का योगदान है।

Kubernetes, souvent abrégé K8s, est né de la nécessité de gérer et d'orchestrer des applications conteneurisées à grande échelle. Il a été initialement développé par Google et publié en open source en 2014. Le projet a rapidement gagné en popularité et est maintenant maintenu par la Cloud Native Computing Foundation (CNCF), avec des contributions d'une communauté dynamique de développeurs du monde entier.

कंट्रोल प्लेन कुबेरनेट्स के मस्तिष्क के रूप में

कंट्रोल प्लेन के घटक:

• etcd: क्लस्टर स्थिति को संग्रहीत करने के लिए वितरित की-वैल्यू स्टोर
• kube-apiserver: कुबेरनेट्स एपीआई को उजागर करता है और एपीआई अनुरोधों को संभालता है
• kube-controller-manager: वांछित क्लस्टर स्थिति बनाए रखने के लिए विभिन्न कंट्रोलर्स का प्रबंधन करता है
• kube-scheduler: संसाधन आवश्यकताओं और बाधाओं के आधार पर उपलब्ध नोड्स को पॉड्स आवंटित करता है

Le Plan de Contrôle, en tant que cerveau de Kubernetes

Composants du Plan de Contrôle :

• etcd : Base de donnees de clés-valeurs distribué pour stocker l'état du cluster
• kube-apiserver : Expose l'API Kubernetes et gère les requêtes API
• kube-controller-manager : Gère divers contrôleurs pour maintenir l'état souhaité du cluster
• kube-scheduler : Attribue des Pods aux machines(nodes) disponibles en fonction des besoins en ressources et des contraintes

नोड्स कुबेरनेट्स क्लस्टर में वर्कर मशीनों के रूप में एक नोड के घटक:

• kubelet: एजेंट जो प्रत्येक नोड पर चलता है और पॉड्स का प्रबंधन करता है
• kube-proxy: सेवाओं के लिए नेटवर्क रूटिंग और लोड बैलेंसिंग को संभालता है
• कंटेनर रनटाइम: कंटेनरों को चलाने के लिए जिम्मेदार सॉफ्टवेयर (जैसे, डॉकर, containerd)

Machines de travail dans un cluster Kubernetes Composants d'un nœud :

• kubelet : Agent qui s'exécute sur chaque nœud et gère les Pods
• kube-proxy : Gère le routage réseau et l'équilibrage de charge pour les Services
• Runtime de conteneurs : Logiciel responsable de l'exécution des conteneurs (par exemple, Docker, containerd)

कंटेनरीकृत वातावरण में नेटवर्किंग चुनौतियां एक पॉड के भीतर कंटेनर-से-कंटेनर संचार

क्लस्टर नेटवर्किंग:

• पॉड नेटवर्क: नोड्स के बीच पॉड्स के संचार के लिए नेटवर्क ओवरले
• सर्विस नेटवर्क: लोड बैलेंसिंग और सर्विस डिस्कवरी के लिए वर्चुअल आईपी पते
• Ingress: क्लस्टर के भीतर सेवाओं के लिए बाहरी ट्रैफ़िक को रूट करता है

Défis de mise en réseau dans les environnements conteneurisés Communication entre conteneurs au sein d'un Pod

Réseau du cluster : Réseau Pod : Superposition réseau pour la communication entre les Pods sur les différents nœuds Réseau Service : Adresses IP virtuelles pour l'équilibrage de charge et la découverte de services Ingress : Renvoie le trafic externe vers les Services à l'intérieur du cluster

कुबेरनेट्स में, एक नोड एक भौतिक या आभासी मशीन है जो कंटेनर चलाती है। यह कार्यों को निष्पादित करने और वास्तविक वर्कलोड चलाने के लिए जिम्मेदार एक वर्कर मशीन है। कुबेरनेट्स क्लस्टर के भीतर प्रत्येक नोड में आवश्यक घटक स्थापित होते हैं, जैसे कंटेनर रनटाइम (जैसे, डॉकर), kubelet (जो एपीआई सर्वर के साथ इंटरैक्ट करता है), और kube-proxy (नेटवर्किंग के लिए)।

क्लस्टर नोड्स का एक समूह है जो कुबेरनेट्स वातावरण बनाने के लिए एक साथ काम करता है। क्लस्टर उच्च उपलब्धता, लोड बैलेंसिंग और स्केलेबिलिटी को सक्षम करते हैं। वे एक मास्टर नोड से बने होते हैं, जो क्लस्टर को नियंत्रित करता है, और कई वर्कर नोड्स से जो कंटेनरों को होस्ट करते हैं।

Dans Kubernetes, un nœud est une machine physique ou virtuelle qui exécute des conteneurs. C'est une machine de travail chargée d'exécuter des tâches et d'exécuter les charges de travail réelles. Chaque nœud au sein d'un cluster Kubernetes dispose des composants nécessaires installés, tels que le runtime de conteneurs (par exemple, Docker), le kubelet (qui interagit avec le serveur API) et le kube-proxy (pour la mise en réseau).

Un cluster est un groupe de nœuds qui travaillent ensemble pour former un environnement Kubernetes. Les clusters permettent une haute disponibilité, l'équilibrage de charge et la scalabilité. Ils se composent d'un nœud maître, qui contrôle le cluster, et de plusieurs nœuds de travail qui hébergent les conteneurs.

एक पॉड कुबेरनेट्स में सबसे छोटी तैनाती योग्य इकाई है। यह एक या अधिक कंटेनरों के एक तार्किक समूह का प्रतिनिधित्व करता है जो एक ही नेटवर्क नेमस्पेस, आईपी पता और स्टोरेज संसाधनों को साझा करते हैं। एक पॉड के भीतर के कंटेनर एक ही स्थान पर और एक साथ शेड्यूल किए जाते हैं, जिससे वे localhost का उपयोग करके एक-दूसरे के साथ संचार कर सकते हैं। पॉड्स एप्लिकेशन के लिए एक अलग निष्पादन वातावरण प्रदान करते हैं, और उन्हें आसानी से दोहराया और स्केल किया जा सकता है। दूसरी ओर, कंटेनर हल्के, स्टैंडअलोन निष्पादन योग्य पैकेज हैं जो एप्लिकेशन कोड, निर्भरता और रनटाइम वातावरण को समाहित करते हैं। कंटेनर कंटेनर छवियों से बनाए जाते हैं, जो केवल-पढ़ने योग्य टेम्प्लेट होते हैं जिनमें एप्लिकेशन चलाने के लिए आवश्यक सब कुछ होता है। कुबेरनेट्स पॉड्स के भीतर कंटेनरों को शुरू करने और प्रबंधित करने के लिए कंटेनर रनटाइम (जैसे डॉकर) का उपयोग करता है।

Un pod est l'unité de déploiement la plus petite dans Kubernetes. Il représente un groupe logique d'un ou plusieurs conteneurs qui partagent le même espace de réseau, la même adresse IP et les mêmes ressources de stockage. Les conteneurs à l'intérieur d'un pod sont co-localisés et co-planifiés, ce qui leur permet de communiquer entre eux en utilisant localhost. Les pods fournissent un environnement d'exécution isolé pour les applications et peuvent être facilement répliqués et mis à l'échelle. Les conteneurs, en revanche, sont des packages exécutables autonomes et légers qui encapsulent le code de l'application, les dépendances et les environnements d'exécution. Les conteneurs sont créés à partir d'images de conteneurs, qui sont des modèles en lecture seule contenant tout ce qui est nécessaire pour exécuter une application. Kubernetes utilise des runtimes de conteneurs (comme Docker) pour démarrer et gérer les conteneurs à l'intérieur des pods.

डिप्लॉयमेंट कुबेरनेट्स संसाधन हैं जो पॉड्स और उनके संबंधित रेप्लिका सेट के घोषणात्मक प्रबंधन को सक्षम करते हैं। एक डिप्लॉयमेंट एप्लिकेशन की वांछित स्थिति को परिभाषित करता है, जिसमें पॉड की रेप्लिका (प्रतियों) की संख्या शामिल है जो चलनी चाहिए।

Les déploiements sont des ressources Kubernetes qui permettent la gestion déclarative des pods et de leurs ensembles de réplicas associés. Un déploiement définit l'état souhaité de l'application, y compris le nombre de réplicas (copies) du pod qui doivent être en cours d'exécution.

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

रेप्लिका सेट यह सुनिश्चित करते हैं कि पॉड रेप्लिका की वांछित संख्या हमेशा बनी रहे। वे परिभाषित डिप्लॉयमेंट कॉन्फ़िगरेशन के आधार पर पॉड्स बनाने और स्केल करने के लिए जिम्मेदार हैं। रेप्लिका सेट पॉड्स के स्वास्थ्य की निगरानी करते हैं और वांछित स्थिति बनाए रखने के लिए विफल या समाप्त हो चुके पॉड्स को स्वचालित रूप से बदल सकते हैं।

डिप्लॉयमेंट और रेप्लिका सेट एप्लिकेशन डिप्लॉयमेंट के प्रबंधन के लिए महत्वपूर्ण क्षमताएं प्रदान करते हैं, जो रोलिंग अपडेट, रोलबैक और स्केलिंग संचालन की अनुमति देते हैं। वे उच्च उपलब्धता, दोष सहिष्णुता (fault tolerance) और एप्लिकेशन जीवनचक्र के आसान प्रबंधन को सुनिश्चित करते हैं।

Les Replica Sets garantissent que le nombre souhaité de répliques de pods est toujours maintenu. Ils sont responsables de la création et de la mise à l'échelle des pods en fonction de la configuration de déploiement définie. Les Replica Sets surveillent l'état de santé des pods et peuvent remplacer automatiquement les pods défaillants ou terminés pour maintenir l'état souhaité.

Les déploiements et les Replica Sets offrent des fonctionnalités importantes pour la gestion des déploiements d'applications, permettant des mises à jour progressives, des réversions et des opérations de mise à l'échelle. Ils garantissent une haute disponibilité, une tolérance aux pannes et une gestion facile des cycles de vie des applications.

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: frontend
  labels:
    app: guestbook
    tier: frontend
spec:
  # modify replicas according to your case
  replicas: 3
  selector:
    matchLabels:
      tier: frontend
  template:
    metadata:
      labels:
        tier: frontend
    spec:
      containers:
      - name: php-redis
        image: gcr.io/google_samples/gb-frontend:v3

कुबेरनेट्स में सेवाएं पॉड्स के एक सेट तक पहुँचने के लिए एक स्थिर एंडपॉइंट प्रदान करती हैं। वे सर्विस डिस्कवरी और लोड बैलेंसिंग को सक्षम बनाती हैं, जिससे क्लाइंट्स को व्यक्तिगत पॉड्स के सटीक आईपी पते या पोर्ट जानने की आवश्यकता के बिना एप्लिकेशन तक पहुँचने की अनुमति मिलती है।

Les services dans Kubernetes fournissent un point de terminaison stable pour accéder à un ensemble de pods. Ils permettent la découverte de services et l'équilibrage de charge, permettant aux clients d'accéder à l'application sans avoir besoin de connaître les adresses IP ou les ports exacts des pods individuels.

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app.kubernetes.io/name: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376

लोड बैलेंसिंग यह सुनिश्चित करती है कि क्लाइंट अनुरोध उपलब्ध पॉड्स पर समान रूप से वितरित किए जाएं, जिससे एप्लिकेशन का प्रदर्शन और उपलब्धता में सुधार हो। यह एप्लिकेशन की क्षैतिज स्केलिंग और ट्रैफ़िक स्पाइक्स को निर्बाध रूप से संभालने में सक्षम बनाता है।

कुबेरनेट्स विभिन्न प्रकार की सेवाएं प्रदान करता है, जिनमें ClusterIP, NodePort और LoadBalancer शामिल हैं। ClusterIP सेवाएं क्लस्टर के भीतर आंतरिक नेटवर्क एक्सेस प्रदान करती हैं, जबकि NodePort सेवाएं एप्लिकेशन को प्रत्येक नोड पर एक स्थिर पोर्ट पर उजागर करती हैं। LoadBalancer सेवाओं का उपयोग आमतौर पर क्लाउड वातावरण में एप्लिकेशन को बाहरी रूप से उजागर करने और स्वचालित रूप से लोड बैलेंसर का प्रावधान करने के लिए किया जाता है।

L'équilibrage de charge garantit que les demandes des clients sont réparties de manière équitable entre les pods disponibles, améliorant ainsi les performances et la disponibilité de l'application. Il permet le dimensionnement horizontal de l'application et la gestion transparente des pics de trafic.

Kubernetes propose différents types de services, notamment ClusterIP, NodePort et LoadBalancer. Les services ClusterIP permettent un accès réseau interne au sein du cluster, tandis que les services NodePort exposent l'application sur un port statique sur chaque nœud. Les services LoadBalancer sont généralement utilisés dans les environnements cloud pour exposer l'application de manière externe et provisionner automatiquement un équilibrage de charge.

Ingress क्लस्टर के बाहर से क्लस्टर के भीतर की सेवाओं के लिए HTTP और HTTPS रूट को उजागर करता है। ट्रैफ़िक रूटिंग को Ingress संसाधन पर परिभाषित नियमों द्वारा नियंत्रित किया जाता है।

Ingress expose les routes HTTP et HTTPS depuis l'extérieur du cluster vers les services à l'intérieur du cluster. La circulation est contrôlée par des règles définies sur la ressource Ingress.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: minimal-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx-example
  rules:
  - http:
      paths:
      - path: /testpath
        pathType: Prefix
        backend:
          service:
            name: test
            port:
              number: 80

# install minikue
brew install minikube

# set docker as engine
minikube config set driver docker

# start minikube
minikube start --driver=docker

# run the below command:
# Note: To access kubernetese, one uses the kubectl command. this command is telling kubernetese( or minikube in our case )
# to deploy the 'deployment' located on the url below.

kubectl apply -f https://raw.githubusercontent.com/istio/istio/ \
release-1.17/samples/bookinfo/platform/kube/bookinfo.yaml

# wait a few second and check that the nodes and services are up
kubectl get pods

# check services-you should see all the services up 1/1
kubectl get services

# enable the ingress addon for minikube
minikube addons enable ingress

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: bookinfo-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
    - host: localhost
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
                service:
                name: productpage
                port:
                  number: 9080

kubectl apply -f docker-orchestra-swarm-k8s/k8s/booking-info-ingress.yaml

# Open a seperate terminal and run the following command
minikube tunnel

minikube delete --all