Qu'est-ce qu'Ingress Controller et comment déployer Nginx Ingress Controller dans Kubernetes Cluster sur AWS à l'aide de Helm

Avant de procéder à l'installation du Nginx Ingress Controller, voyons en bref ce qu'est Ingress et Ingress Controller. Cet article se concentre sur la configuration, il est supposé que vous connaissez toutes les conditions préalables à la configuration du contrôleur d'entrée Nginx dans le cluster Kubernetes.

Entrée Kubernetes

Il s'agit d'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 au sein du cluster Kubernetes.

Contrôleur d'entrée

Pour utiliser Ingress, vous devez disposer du 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 n'importe quel nombre de contrôleurs d'entrée dans le cluster Kubernetes. Pour ce faire, nous devons annoter chaque entrée avec la classe d'entrée appropriée. Il existe de nombreux types de contrôleurs d'entrée disponibles. Ingress Controller est un LoadBalancer pour les environnements Kubernetes. Il est utilisé comme solution de gestion du trafic pour les environnements Kubernetes.

Dans cet article, nous verrons l'installation du contrôleur d'entrée Nginx à l'aide de Helm sur le cluster Kubernetes configuré à l'aide de Kops. Pour en savoir plus sur Nginx Ingress Controller, visitez la documentation officielle ici.

Pré-requis

1. Compte AWS (créez-le si vous n'en avez pas).
2. Kops 1.18.2 installé sur votre machine (Cliquez ici pour apprendre à créer un cluster Kubernetes à l'aide de Kops et en savoir plus.)
3. Helm v3.5.3 (Cliquez ici pour apprendre à installer Helm sur Ubuntu Server)
4. Compartiment S3 (Cliquez ici pour apprendre à créer un compartiment S3 sur AWS).
5. Nom de domaine (Cliquez ici pour apprendre à enregistrer un domaine sur AWS).
6. Rôle IAM avec autorisations d'administrateur (Cliquez ici pour apprendre à créer un rôle IAM sur AWS).

Qu'allons-nous faire ?

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 jeu d'enregistrements dans Route53 pointant vers le LoadBalancer créé par le contrôleur d'entrée Nginx
4. Créer des fichiers de définition d'objet pour un exemple d'application
5. Déployer 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, exportez votre accès utilisateur AWS IAM et vos clés secrètes à 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 vous créez un cluster pour la première fois à l'aide de Kops et que vous utilisez le compartiment S3 spécifié ci-dessus pour stocker la configuration du cluster, vous ne devriez voir aucun cluster lorsque vous essayez d'obtenir des clusters à l'aide de la commande suivante.

kops get clusters

Consultez la documentation spécifiée dans les prérequis pour comprendre Kops en détail. Ici, pour créer un cluster Kubernetes, exécutez la commande suivante en remplaçant les valeurs. Je n'entrerai pas 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

Vous pouvez voir quelques commandes dans la suggestion.

Maintenant, cette fois si vous essayez d'obtenir la configuration du cluster, vous verrez le nom du cluster dans la sortie avec Cloud et Zones.

Jusqu'à présent, le cluster n'a pas été créé, exécutez la commande suivante pour mettre à jour la configuration du cluster.

kops update cluster --name kops.devopslee.com

Vous devrez toujours exécuter la commande ci-dessus avec --yes comme option afin que les ressources du cluster soient créées.

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

Validez si le cluster est prêt ou non.

kops validate cluster --wait 10m

Vous devez attendre un certain temps pendant que le cluster redevient sain.

kops validate cluster --wait 10m

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

kubectl get pods -A

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

Une fois que le cluster Kubernetes est prêt et sain, vous pouvez installer Nginx Ingress Controller à l'aide de Helm.

Avant de continuer, vérifiez que vous disposez de Helm v3.5.3.

Remarque :J'ai utilisé le binaire Helm présent à mon emplacement actuel, vous pouvez donc voir ./helm dans les captures d'écran.

helm version

Ajoutez le référentiel et installez le graphique Nginx Ingress Controller Helm à l'aide des commandes suivantes. Pour comprendre Helm, reportez-vous à la documentation mentionnée dans la section des prérequis.

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

Dans la capture d'écran ci-dessus, vous pouvez voir que la charte Helm a été installée.

Vous pouvez 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

Dans la capture d'écran ci-dessus, vous pouvez 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éer un jeu d'enregistrements dans Route53 pointant vers le LoadBalancer créé par Nginx Ingress Contrôleur

Accédez à votre compte AWS dans la région où vous avez créé votre cluster Kubernetes. Vérifiez le LoadBalancer et copiez son nom DNS.

Maintenant, allez sur Route53 et créez un seul enregistrement A dans la HostedZone.

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 contrôleur d'entrée Nginx.

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

Créons maintenant des fichiers de définition d'objet pour déployer un exemple d'application. Nous déploierons 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 pour acheminer le trafic vers nos applications à l'aide kops.devopslee.com en fonction du chemin.

Créez 1-nginx-main-app.yaml pour l'application 1.

Lien Github : Cliquez ici pour copier le fichier depuis mon dépôt 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éez 2-nginx-green-app.yaml pour l'application 2.

Lien Github : Cliquez ici pour copier le fichier depuis mon référentiel 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éez 3-nginx-blue-app.yaml pour l'application 3

Lien Github : Cliquez ici pour copier le fichier depuis mon référentiel 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éez 4-ingress.yaml pour créer des règles d'entrée basées sur le chemin.

Lien Github : Cliquez ici pour copier le fichier depuis mon référentiel 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

Vous pouvez trouver tous ces fichiers sur mon dépôt Github ici.

Déployer des exemples d'applications

Déployons des exemples d'applications un par un et vérifions leur statut.

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 un objet d'entrée

Il est maintenant temps de créer une ressource d'entrée de routage basée sur le chemin. En même temps, vérifiez les journaux du pod Nginx.

kubectl logs nginx-ingress-ingress-nginx-controller-5c97c6b4d5-btvpl -f

kubectl apply -f 4-ingress.yaml

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

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

URL des applications, le nom d'hôte ici sera différent pour vous.

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

Vous pouvez voir que 3 applications différentes sont accessibles en utilisant le même nom d'hôte en fonction du chemin.

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.