Commande Kubernetes Expose

Introduction

La commande expose dans Kubernetes est un outil simple mais puissant pour rendre un pod ou un déploiement accessible via un service réseau. Ce laboratoire (LabEx) vous guidera tout au long du processus de démarrage d'un cluster Kubernetes, de création d'un déploiement, de son exposition en tant que service et d'accès au service pour vérifier sa fonctionnalité. À la fin de ce laboratoire, vous aurez une compréhension claire de la manière d'exposer des déploiements et de travailler avec des services dans Kubernetes.

Démarrer Minikube

Pour exécuter Kubernetes localement, nous utilisons Minikube, qui configure un cluster Kubernetes mono - noeud. Avant de procéder à toute opération Kubernetes, assurez - vous que Minikube est démarré et en cours d'exécution.

Ouvrez un terminal et démarrez Minikube avec la commande suivante :
```
minikube start
```

Cela initialise le cluster. Si nécessaire, vous pouvez spécifier des limites de ressources en utilisant des options telles que --cpus et --memory pour garantir des ressources adéquates pour le cluster.

Vérifiez que Minikube est en cours d'exécution :
```
minikube status
```

Vous devriez voir que le cluster et ses composants sont en cours d'exécution avec succès.

Le démarrage de Minikube garantit que Kubernetes est prêt à gérer les déploiements et les services dans les étapes suivantes.

Créer un déploiement (deployment)

Dans Kubernetes, un déploiement (deployment) est un objet ressource qui garantit que votre application a le nombre souhaité de replicas en cours d'exécution à tout moment. Les déploiements gèrent les pods et aident à maintenir leur état dans le cluster. Dans cette étape, vous allez créer un déploiement exécutant le serveur web Nginx.

Utilisez la commande suivante pour créer un déploiement nommé hello - world en utilisant l'image nginx :
```
kubectl create deployment hello-world --image=nginx
```

Cette commande crée un déploiement avec un seul pod exécutant le serveur web Nginx. L'option --image spécifie l'image de conteneur à utiliser. Étant donné que le nombre de replicas n'est pas explicitement défini, Kubernetes créera un pod par défaut.

Vérifiez si le déploiement a été créé avec succès en exécutant :
```
kubectl get deployments
```

Cette commande répertorie tous les déploiements dans l'espace de noms actuel, affichant leur nom, le nombre de replicas souhaité et leur statut.

En créant ce déploiement, vous assurez que Kubernetes gère automatiquement la création et le redémarrage des pods pour maintenir l'état souhaité de l'application.

Explorer la commande kubectl expose

La commande kubectl expose est utilisée pour créer un nouveau service Kubernetes afin d'exposer une ressource existante, comme un pod, un déploiement (deployment) ou un contrôleur de réplication (replication controller). Elle simplifie les configurations réseau en créant automatiquement des services en fonction de la ressource fournie.

Exécutez la commande suivante pour afficher les options disponibles pour kubectl expose :

kubectl expose -h

Vous verrez la sortie suivante :

Expose a resource as a new Kubernetes service.

Looks up a deployment, service, replica set, replication controller or pod by name and uses the selector for that
resource as the selector for a new service on the specified port. A deployment or replica set will be exposed as a
service only if its selector is convertible to a selector that service supports, i.e. when the selector contains only
the matchLabels component. Note that if no port is specified via --port and the exposed resource has multiple ports, all
will be re-used by the new service. Also if no labels are specified, the new service will re-use the labels from the
resource it exposes.

Possible resources include (case insensitive):
  pod (po), service (svc), replicationcontroller (rc), deployment (deploy), replicaset (rs)

Examples:
  ## Create a service for a replicated nginx, which serves on port 80 and connects to the containers on port 8000
  kubectl expose rc nginx --port=80 --target-port=8000

  ## Create a service for a replication controller identified by type and name specified in "nginx-controller.yaml",
  which serves on port 80 and connects to the containers on port 8000
  kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000

  ## Create a service for a pod valid-pod, which serves on port 444 with the name "frontend"
  kubectl expose pod valid-pod --port=444 --name=frontend

  ## Create a second service based on the above service, exposing the container port 8443 as port 443 with the name
  "nginx-https"
  kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https

  ## Create a service for a replicated streaming application on port 4100 balancing UDP traffic and named 'video-stream'.
  kubectl expose rc streamer --port=4100 --protocol=UDP --name=video-stream

  ## Create a service for a replicated nginx using replica set, which serves on port 80 and connects to the containers on
  port 8000
  kubectl expose rs nginx --port=80 --target-port=8000

  ## Create a service for an nginx deployment, which serves on port 80 and connects to the containers on port 8000
  kubectl expose deployment nginx --port=80 --target-port=8000

Exposer le déploiement (deployment)

Pour rendre le déploiement accessible depuis l'extérieur du cluster Kubernetes, vous devez le exposer en tant que service. Un service dans Kubernetes agit comme un point d'accès réseau stable, même si les pods sous - jacents changent.

Exécutez la commande suivante pour créer un service de type NodePort nommé hello-service :
```
kubectl expose deployment hello-world --name=hello-service --port=80 --target-port=80 --type=NodePort
```
- L'option --port spécifie le port que le service exposera aux clients externes.
- L'option --target-port définit le port sur le conteneur où le service acheminera le trafic.
- L'option --type=NodePort rend le service accessible sur un port spécifique de chaque nœud du cluster.
Vérifiez que le service a été créé avec succès :
```
kubectl get services hello-service
```

Cette commande affiche les détails du service, y compris son type et le NodePort attribué.

Des services comme NodePort permettent aux clients externes d'interagir avec les pods dans le cluster Kubernetes en transférant les requêtes vers les ports de conteneur appropriés.

Récupérer les détails du service

Pour accéder au service exposé, vous avez besoin du NodePort attribué au service et de l'adresse IP interne d'un nœud du cluster. Ces détails permettent aux clients externes de se connecter à votre application.

Récupérez le NodePort attribué au hello-service en exécutant :

kubectl get service hello-service -o jsonpath='{.spec.ports[0].nodePort}'

Cette commande extrait la valeur du NodePort à partir de la définition du service.

Obtenez l'adresse IP interne de n'importe quel nœud du cluster en utilisant la commande suivante :
```
kubectl get nodes -o wide
```

Notez le champ INTERNAL - IP dans la sortie. Cette adresse IP représente l'adresse réseau privée du nœud.

Avec le NodePort et l'adresse IP interne, vous avez maintenant les détails nécessaires pour accéder au service depuis l'extérieur.

Accéder au service

Avec le NodePort et l'adresse IP du nœud, vous pouvez tester le service en utilisant un outil comme curl ou un navigateur web.

Remplacez <NODE_IP> et <NODE_PORT> par les valeurs récupérées à l'étape précédente, puis exécutez :
```
curl <NODE_IP>:<NODE_PORT>
```
Si tout est configuré correctement, vous devriez voir la page d'accueil par défaut de Nginx dans le terminal. Cette sortie confirme que le service est en cours d'exécution et accessible depuis l'extérieur.

<!doctype html>
<html>
  <head>
    <title>Welcome to nginx!</title>
    <style>
      html {
        color-scheme: light dark;
      }
      body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
      }
    </style>
  </head>
  <body>
    <h1>Welcome to nginx!</h1>
    <p>
      If you see this page, the nginx web server is successfully installed and
      working. Further configuration is required.
    </p>

    <p>
      For online documentation and support please refer to
      <a href="http://nginx.org/">nginx.org</a>.<br />
      Commercial support is available at
      <a href="http://nginx.com/">nginx.com</a>.
    </p>

    <p><em>Thank you for using nginx.</em></p>
  </body>
</html>

L'accès au service démontre comment Kubernetes gère le routage du trafic entre les clients et les ports de conteneur appropriés.

Nettoyer les ressources

Après avoir terminé le laboratoire, il est important de nettoyer les ressources que vous avez créées pour éviter une consommation inutile de ressources dans votre cluster Kubernetes.

Supprimez le hello-service en exécutant :
```
kubectl delete service hello-service
```
Supprimez le déploiement (deployment) hello-world avec la commande suivante :
```
kubectl delete deployment hello-world
```

Le nettoyage des ressources garantit que votre cluster reste dans un état propre, prêt pour de futures expériences.

Résumé

Dans ce laboratoire, vous avez appris à utiliser la commande expose dans Kubernetes pour créer un service de type NodePort. Vous avez exposé un déploiement (deployment) Nginx, y avez accédé via le NodePort et vérifié son fonctionnement. Cet exercice a démontré les concepts de base des services Kubernetes et la manière dont ils fournissent un accès réseau à vos charges de travail.