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
- Compte AWS (créez-le si vous n'en avez pas).
- 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.)
- Helm v3.5.3 (Cliquez ici pour apprendre à installer Helm sur Ubuntu Server)
- Compartiment S3 (Cliquez ici pour apprendre à créer un compartiment S3 sur AWS).
- Nom de domaine (Cliquez ici pour apprendre à enregistrer un domaine sur AWS).
- Rôle IAM avec autorisations d'administrateur (Cliquez ici pour apprendre à créer un rôle IAM sur AWS).
Qu'allons-nous faire ?
- Créer un cluster Kubernetes à l'aide de Kops
- Configurer le contrôleur d'entrée Nginx à l'aide de Helm
- Créer un jeu d'enregistrements dans Route53 pointant vers le LoadBalancer créé par le contrôleur d'entrée Nginx
- Créer des fichiers de définition d'objet pour un exemple d'application
- Déployer un exemple d'application
- 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.