Qu’est-ce que le contrôleur Ingress et comment déployer Nginx Ingress Controller dans un cluster Kubernetes sur AWS à l’aide de Helm.

Avant de procéder à l’installation de Nginx Ingress Controller, voyons en bref ce qu’est Ingress et Ingress Controller. Cet article se concentre sur l’installation, il est supposé que tu connais toutes les conditions préalables à la mise en place de Nginx Ingress Controller dans le cluster Kubernetes.

Kubernetes Ingress

C’est un objet Kubernetes qui gère l’accès externe aux services du Cluster Kubernetes. Il expose les routes HTTP et HTTPS de l’extérieur du cluster Kubernetes aux services du cluster Kubernetes.

Contrôleur Ingress

Pour utiliser Ingress, tu dois avoir le contrôleur Ingress dans le cluster Kubernetes. Il ne fait pas partie du cluster Kubernetes comme les autres contrôleurs du cluster, il ne démarre pas automatiquement dans le cluster. Nous pouvons déployer un nombre quelconque de contrôleurs Ingress dans le cluster Kubernetes. Pour ce faire, nous devons annoter chaque ingress avec la ingress.class appropriée. Il existe de nombreux types de contrôleurs Ingress différents. Le contrôleur Ingress est un équilibreur de charge pour les environnements Kubernetes. Il est utilisé comme solution de gestion du trafic pour les environnements Kubernetes.

Dans cet article, nous allons voir l’installation du Nginx Ingress Controller à l’aide de Helm sur le cluster Kubernetes mis en place à l’aide de Kops. Pour connaître le Nginx Ingress Controller en détail, visite la documentation officielle ici.

Pré-requis

  1. Compte AWS ( Créer si tu n’en as pas).
  2. Kops 1.18.2 installé sur ta machine(Clique ici pour apprendre à créer un cluster Kubernetes à l’aide de Kops et en savoir plus).
  3. Helm v3.5.3 (Clique ici pour apprendre à installer Helm sur le serveur Ubuntu)
  4. Bucket S3 ( Clique ici pour apprendre à créer un Bucket S3 sur AWS).
  5. Nom de domaine (Clique ici pour apprendre à enregistrer un domaine sur AWS).
  6. Rôle IAM avec des droits d’administration (clique ici pour apprendre à créer un rôle IAM sur AWS).

Que ferons-nous ?

  1. Créer un cluster Kubernetes à l’aide de Kops
  2. Configurer le contrôleur d’entrée Nginx à l’aide de Helm
  3. Créer un Recordset dans Route53 pointant vers le LoadBalancer créé par le Nginx Ingress Controller
  4. Créer des fichiers de définition d’objets pour une application type
  5. Déploie un exemple d’application
  6. Déployer un objet Ingress

Créer un cluster Kubernetes à l’aide de Kops

Avant de procéder à la création du cluster, exporte les clés d’accès et secrètes de ton utilisateur AWS IAM à l’aide des commandes suivantes.

export AWS_ACCESS_KEY_ID=<your-aws-access-key-here> #Export AWS Access Key
export AWS_SECRET_ACCESS_KEY=<your-aws-secret-key-here> ##Export AWS Secret Key export
Now, export the KOPS_STATE_STORE variable with value as S3 bucket name on your terminal.
KOPS_STATE_STORE=s3://<s3-bucket-name>

Si tu crées un cluster pour la première fois à l’aide de Kops et que tu utilises le Bucket S3 spécifié ci-dessus pour stocker la configuration du cluster, tu ne devrais pas voir de clusters lorsque tu essaies d’obtenir des clusters à l’aide de la commande suivante.

kops get clusters

Visite la documentation indiquée dans les conditions préalables pour comprendre Kops en détail. Ici, pour créer un cluster Kubernetes, exécute la commande suivante en remplaçant les valeurs. Je ne vais pas entrer dans les détails ici.

kops create cluster --name <subdomain.domain.com> --state s3://<s3-bucket> --cloud aws --master-size t2.small --master-count 1 --master-zones us-east-1a --node-size t2.small --node-count 2 --zones us-east-1a,us-east-1b,us-east-1c

Commande Kops pour créer un cluster K8S

Tu peux voir quelques commandes dans la suggestion.

En dehors de la commande précédente

Cette fois, si tu essaies d’obtenir la configuration du cluster, tu verras le nom du cluster dans la sortie ainsi que Cloud et Zones.

Obtenir des clusters

Jusqu’à ce point, le cluster n’a pas été créé, exécute la commande suivante pour mettre à jour la configuration du cluster.

kops update cluster --name kops.devopslee.com

Dry run update cluster

Tu devras encore exécuter la commande ci-dessus avec l’option –yes pour que les ressources du cluster soient créées.

kops update cluster --name kops.devopslee.com --yes

Mets à jour le cluster pour créer des ressources cloud

Valide si le cluster est prêt ou non.

kops validate cluster --wait 10m

Val valider le cluster

Tu dois attendre un certain temps, le temps que le cluster devienne sain.

kops validate cluster --wait 10m

Validation réussie du cluster

Une fois que le cluster est sain, tu peux vérifier les pods par défaut dans tous les espaces de noms à l’aide de la commande suivante.

kubectl get pods -A

Vérifie les pods par défaut dans tous les espaces de noms

Configurer le contrôleur d’entrée Nginx à l’aide de Helm

Une fois que le cluster Kubernetes est prêt et en bonne santé, tu peux commencer à installer Nginx Ingress Controller à l’aide de Helm.

Avant de continuer, vérifie que tu as Helm v3.5.3.

Remarque : J’ai utilisé le binaire Helm présent à mon emplacement actuel, c’est pourquoi tu peux voir ./helm dans les captures d’écran.

helm version

Version casque

Ajoute le repo et installe le graphique Helm du contrôleur d’entrée Nginx à l’aide des commandes suivantes. Pour comprendre Helm, consulte la documentation mentionnée dans la section des conditions préalables.

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm install nginx-ingress ingress-nginx/ingress-nginx --set controller.publishService.enabled=true

Configurer le contrôleur d'entrée Nginx

Dans la capture d’écran ci-dessus, tu peux voir que la carte Helm a été installée.

Tu peux vérifier les ressources qui ont été créées dans le cadre du contrôleur d’entrée.

kubectl get pods
kubectl get deployment
kubectl get service

Objets créés par le contrôleur d'entrée

Dans la capture d’écran ci-dessus, tu peux voir que le service « nginx-ingress-ingress-nginx-controller » de type LoadBalancer a également été créé. Cela signifie qu’un LoadBalancer a été créé dans le compte AWS.

Crée un Recordset dans Route53 pointant vers le LoadBalancer créé par le Nginx Ingress Controller.

Va sur ton compte AWS dans la région où tu as créé ton Cluster Kubernetes. Vérifie le LoadBalancer et copie son nom DNS.

LoadBalancer créé par Ingress Controller

Maintenant, va sur Route53 et crée un seul enregistrement A dans la HostedZone.

Crée un RecordSet

Une fois que nous avons créé un enregistrement valide, l’enregistrement que nous avons créé sera utilisé pour acheminer le trafic vers le Cluster Kubernetes via le contrôleur d’entrée Nginx que nous avons créé. Dans ce cas, kops.devopslee.com acheminera le trafic vers les services du cluster Kubernetes via le Nginx Ingress Controller.

Créer des fichiers de définition d’objet pour un exemple d’application

Maintenant, créons des fichiers de définition d’objet pour déployer un exemple d’application. Nous allons déployer 3 applications en utilisant 3 Déploiements et 3 Services respectifs pour les déploiements. Nous allons ensuite créer une ressource Ingress avec un routage basé sur le chemin d’accès pour acheminer le trafic vers nos applications en utilisant kops.devopslee.com en fonction du chemin d’accès.

Crée 1-nginx-main-app.yaml pour l’application 1.

Lien Github : Clique ici pour copier le fichier depuis mon repo Github.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: nginx
  name: nginx-deploy-main
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx-main
  template:
    metadata:
      labels:
        run: nginx-main
    spec:
      containers:
      - image: nginx
        name: nginx


---
apiVersion: v1
kind: Service
metadata:
  name: nginx-deploy-main
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    run: nginx-main

Crée 2-nginx-green-app.yaml pour l’application 2.

Lien Github : Clique ici pour copier le fichier de mon dépôt Github.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: nginx
  name: nginx-deploy-green
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx-green
  template:
    metadata:
      labels:
        run: nginx-green
    spec:
      volumes:
      - name: webdata
        emptyDir: {}
      initContainers:
      - name: web-content
        image: busybox
        volumeMounts:
        - name: webdata
          mountPath: "/webdata"
        command: ["/bin/sh", "-c", 'echo "<h1>I am <font color=green>GREEN</font></h1>" > /webdata/index.html']
      containers:
      - image: nginx
        name: nginx
        volumeMounts:
        - name: webdata
          mountPath: "/usr/share/nginx/html"


---
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-deploy-green
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    run: nginx-green          

Crée 3-nginx-blue-app.yaml pour l’application 3

Lien Github : Clique ici pour copier le fichier de mon repo Github.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: nginx
  name: nginx-deploy-blue
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx-blue
  template:
    metadata:
      labels:
        run: nginx-blue
    spec:
      volumes:
      - name: webdata
        emptyDir: {}
      initContainers:
      - name: web-content
        image: busybox
        volumeMounts:
        - name: webdata
          mountPath: "/webdata"
        command: ["/bin/sh", "-c", 'echo "<h1>I am <font color=blue>BLUE</font></h1>" > /webdata/index.html']
      containers:
      - image: nginx
        name: nginx
        volumeMounts:
        - name: webdata
          mountPath: "/usr/share/nginx/html"


---
apiVersion: v1
kind: Service
metadata:
  name: nginx-deploy-blue
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    run: nginx-blue

Crée 4-ingress.yaml pour la création de règles Ingress basées sur les chemins.

Lien Github : Clique ici pour copier le fichier de mon repo Github.

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
  name: ingress-resource
spec:
  rules:
  - host: kops.devopslee.com
    http:
      paths:
      - path: /
        backend:
          serviceName: nginx-deploy-main
          servicePort: 80
      - path: /blue
        backend:
          serviceName: nginx-deploy-blue
          servicePort: 80
      - path: /green
        backend:
          serviceName: nginx-deploy-green
          servicePort: 80

Tu peux trouver tous ces fichiers sur mon repo Github ici.

Déploiement des applications d’exemple

Déployons les applications types une par une et vérifions leur état.

kubectl apply -f 1-nginx-main-app.yaml
kubectl apply -f 2-nginx-green-app.yaml
kubectl apply -f 3-nginx-blue-app.yaml
kubectl get deployments
kubectl get pods
kubectl get service

Déployer une application d'exemple

Déploie un objet Ingress

Il est maintenant temps de créer une ressource Ingress de routage basé sur le chemin. En même temps, vérifie les journaux du Pod Nginx.

kubectl logs nginx-ingress-ingress-nginx-controller-5c97c6b4d5-btvpl -f
kubectl apply -f 4-ingress.yaml

Crée une ressource Ingress et vérifie les journaux du pod nginx-ingress

Dès que la ressource Ingress est créée, tu peux voir que le Nginx a chargé sa configuration.

Et maintenant, 3 applications différentes sont prêtes à être consultées en utilisant le même nom d’hôte, c’est-à-dire kops.devopslee.com, sur des chemins différents.

Les URL des applications, dont le nom d’hôte est ici, seront différentes pour toi.

nginx-deploy-main est accessible sur kops.devopslee.com

nginx-deploy-green est accessible sur kops.devopslee.com/green et

nginx-deploy-blue est accessible sur kops.devopslee.com/blue

Vérifie la ressource d'entrée

Tu peux voir que l’on peut accéder à 3 applications différentes en utilisant le même nom d’hôte basé sur le chemin.

Accède aux applications

Conclusion

Dans cet article, nous avons vu les étapes pour créer un cluster Kubernetes à l’aide de Kops. Cet article s’est principalement concentré sur la configuration de Nginx Ingress Controller à l’aide de Helm et sur la création d’un routage basé sur le chemin à l’aide de la ressource Ingress. Nous avons déployé 3 exemples d’applications différentes et essayé d’y accéder en utilisant le même nom d’hôte et des chemins différents.

Vous aimerez aussi...