Dans Kubernetes, l'Ingress permet aux utilisateurs externes et aux applications client d'accéder aux services HTTP. Ingress est basé sur deux composants :

  1. Ingress Resource est un ensemble de règles pour que le trafic entrant atteigne les services. Ce sont des règles de couche 7 (L7) qui permettent aux noms d'hôte (et éventuellement aux chemins d'accès) d'être dirigés vers des services spécifiques dans Kubernetes.
  2. Le second composant est le contrôleur d’ingress qui agit sur les règles définies par la ressource d’entrée, généralement via un load-balancer HTTP ou L7. Il est essentiel que les deux éléments soient correctement configurés pour acheminer le trafic d'un client externe vers un service Kubernetes.

Nginx-Ingress-on-GCP---Fig-01

Dans cet article nous allons configurer un ingress controller basé sur Nginx sur un cluster GKE monté par nos soins. L'obectif sera alors de comparer l'utilisation de cet ingress avec une solution comme Traefik sur GKE, le tout via Helm, le package manager de Kubernetes.

Rappel des pré-requis :

  • Un ordinateur, si possible un Mac
  • Google SDK installé,
  • Un compte google cloud console
  • Un projet configuré

Installation

Ce didacticiel explique comment configurer un déploiement dans Kubernetes avec une ressource Ingress utilisant NGINX comme contrôleur de trafic pour acheminer/équilibrer le trafic des clients externes vers le déploiement. Ce tutoriel explique comment accomplir les tâches suivantes:

  • Créer un déploiement Kubernetes
  • Déployer le contrôleur NGINX Ingress via Helm
  • Configurer un objet Ingress Resource pour le déploiement
  • Monitorer le tout

On commence par initialiser le projet :

gcloud init

Puis on poursuit avec le choix de la zone géographique :

gcloud config set compute/zone europe-west3-a

Puis on crée le cluster :

gcloud container clusters create nginx-tutorial --num-nodes=2

Installer Helm dans Cloud Shell

Vous pouvez installer le client de Helm dans le terminal en utilisant ces commandes:

curl -o get_helm.sh https://raw.githubusercontent.com/kubernetes/helm/master/scripts/get
chmod +x get_helm.sh
./get_helm.sh

Installation de Tiller avec RBAC activé

À partir de Kubernetes v1.8 +, RBAC est activé par défaut. Avant d'installer le tiller, nous devons nous assurer que le bon ServiceAccount et le ClusterRoleBinding sont configurés pour le service du tiller. Cela permet à Tiller d’installer des services dans le namespace par défaut. Exécutez la commande suivante pour installer Helm côté serveur sur le cluster Kubernetes sur lequel RBAC est activé.

kubectl create serviceaccount --namespace kube-system tiller
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
kubectl patch deploy --namespace kube-system tiller-deploy -p '{"spec":{"template":{"spec":{"serviceAccount":"tiller"}}}}'      
helm init --service-account tiller --upgrade

Vérifions l’exécution de tiller en recherchant le déploiement tiller_deploy dans le namespace kube-system. Exécutez la commande suivante:

kubectl get deployements -n kube-system

Voici le résultat :

NAME                    DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
event-exporter-v0.1.7   1         1         1            1           13m
heapster-v1.4.3         1         1         1            1           13m
kube-dns                2         2         2            2           13m
kube-dns-autoscaler     1         1         1            1           13m
kubernetes-dashboard    1         1         1            1           13m
l7-default-backend      1         1         1            1           13m
tiller-deploy           1         1         1            1           4m

Déployer une application dans Kubernetes Engine

Vous pouvez déployer une application Web simple à partir du catalogue Google Cloud. Vous utilisez cette application comme backend pour Ingress.

Depuis le Cloud Shell, exécutez la commande suivante:

kubectl run hello-app --image = gcr.io/google-samples/hello-app: 1.0 --port = 8080
Deployment "hello-app" create

Exposez le déploiement hello-app en tant que service en exécutant la commande suivante:

kubectl expose deployment hello-app

service "hello-app" exposed

Déploiement du contrôleur NGINX Ingress via Helm

La plate-forme Kubernetes permet aux administrateurs d’apporter leurs propres ingress controller au lieu d’utiliser l’offre intégrée du fournisseur de cloud.

Le contrôleur NGINX, déployé en tant que service, doit être exposé pour un accès externe. Cela se fait en utilisant le type de service: LoadBalancer sur le service du contrôleur NGINX. Sur Kubernetes Engine, cela crée un équilibreur de charge Google Cloud Network (TCP/IP) avec le service du contrôleur NGINX en tant que serveur principal. Google Cloud crée également les règles de pare-feu appropriées dans le VPC du service pour autoriser le trafic Web HTTP(S) vers l'adresse IP frontale de l'équilibreur de charge. Voici un flux de base de la solution d'entrée NGINX sur Kubernetes Engine.

NGINX Ingress Controller sur Kubernetes Engine

Nginx-Ingress-on-GCP---Fig-02-1

Déployer NGINX Ingress Controller avec RBAC activé

Si RBAC est activé sur votre cluster Kubernetes, à partir du Cloud Shell, déployez un déploiement et un service du contrôleur NGINX en exécutant la commande suivante:

helm install --name nginx-ingress stable/nginx-ingress --set rbac.create=true

Pour vérifier le déploiement :

MBP-de-admin:~ admin$ kubectl get service nginx-ingress-controller
NAME                       TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)                      AGE
nginx-ingress-controller   LoadBalancer   10.31.240.122   35.242.225.192   80:30586/TCP,443:31276/TCP   2d

Ou plus globalement :

kubectl get svc 

nginx-ingress-default-backend   ClusterIP      10.31.250.227   <none>           80/TCP                       2d

Notez le deuxième service, nginx-ingress-default-backend. Le backend par défaut est un service qui gère tous les chemins d'URL et tous les hôtes que le contrôleur NGINX ne comprend pas (c'est-à-dire toutes les requêtes qui ne sont pas mappées avec une ressource Ingress). Le backend par défaut expose deux URL:

/healthz qui renvoie 200
/ qui retourne 404

Configurez Ingress Resource pour utiliser NGINX Ingress Controller

Permet de créer un fichier YAML Ingress Resource simple qui utilise le NGINX Ingress Controller et dont une règle de chemin est définie en tapant les commandes suivantes:

touch ingress-resource.yaml
nano ingress-resource.yaml

Copiez le contenu de ingress-resource.yaml dans l'éditeur, puis appuyez sur Ctrl-X, puis appuyez sur y, puis appuyez sur Entrée pour enregistrer le fichier.

Le kind: Ingress impose qu’il s’agisse d’un objet Ingress Resource. Cette ressource d'entrée définit une règle L7 entrante pour path/hello afin de servir hello-app sur le port 8080.

Depuis le Cloud Shell, exécutez la commande suivante:

kubectl apply -f ingress-resource.yaml

Vérifiez que la ressource d'ingress a été créée. Veuillez noter que l'adresse IP de la ressource d'entrée ne sera pas définie immédiatement (attendez quelques instants que le champ ADRESSE soit rempli):

kubectl get ingress ingress-resource
NAME               HOSTS     ADDRESS   PORTS     AGE
ingress-resource   *                   80     

Test Ingress et backend par défaut

Vous devriez maintenant pouvoir accéder à l'application Web en allant à l'adresse IP EXTERNE/hello du contrôleur d'entrée NGINX (à partir de la sortie du kubectl get service nginx-ingress-controller ci-dessus).

Depuis le Cloud Shell, exécutez la commande suivante:

Résultat en web à l'adresse IP du master cluster/hello :

Capture-d-e-cran-2018-08-23-a--14.28.16

Depuis le terminal :

MBP-de-admin:~ admin$ curl http://35.242.225.192/hello
Hello, world!
Version: 1.0.0
Hostname: hello-app-7f66f95b44-r8nfv

Pour vérifier si le service backend par défaut fonctionne correctement, accédez à tout chemin d'accès (autre que le chemin /hello défini dans la ressource Ingress) et assurez-vous de recevoir un message 404. Par exemple:

http://ipexterneducontrolleringress/test

Capture-d-e-cran-2018-08-26-a--11.20.49

Nettoyage du cluster

A partir du Cloud Shell, exécutez les commandes suivantes:

Supprimez l'objet ressource d'ingress

kubectl delete -f ingress-resource.yaml

Supprimez le chart d'Helm NGINX Ingress.

helm del - purge nginx-ingress
release "nginx-ingress" delete

Supprimer l'application

kubectl delete service hello-app
kubectl delete deployment hello-app
service "hello-app" deleted
deployment "hello-app" deleted

Supprimez le cluster Kubernetes Engine en exécutant la commande suivante:

gcloud container clusters delete nginx-tutorial
The following clusters will be deleted.
 - [nginx-tutorial] in [us-central1-f]

    Do you want to continue (Y/n)?  y

    Deleting cluster nginx-tutorial...done.
    Deleted [https://container.googleapis.com/v1/projects/ameer-1/zones/us-central1-f/clusters/nginx-tutorial]

Supprimez le fichier ingress_resource.yaml en exécutant la commande suivante:

rm ingress-resource.yaml

Conclusion

Voici comment monter rapidement un ingress controller sur un cluster Kubernetes hébergé dans le cloud Google (GKE), have fun :)