Exemple : Configuration d'un contrôleur de trafic entrant Nginx dans une grappe

Composants du contrôleur de trafic entrant

Le contrôleur de trafic entrant se compose des éléments suivants :

• Un déploiement de contrôleur de trafic entrant nommé ingress-nginx-controller. Ce déploiement déploie une image qui contient le fichier binaire pour le contrôleur de trafic entrant et Nginx. Le fichier binaire manipule et recharge le fichier de configuration /etc/nginx/nginx.conf lors de la création d'un contrôleur de trafic entrant dans Kubernetes. Les services en amont de Nginx pointent vers les services correspondant aux sélecteurs spécifiés.
• Un service de contrôleur de trafic entrant nommé ingress-nginx-controller. Le service présente le déploiement du contrôleur de trafic entrant en tant que service de type LoadBalancer. Comme Kubernetes Engine utilise un fournisseur d'intégration Oracle Cloud Infrastructure/cloud, un équilibreur de charge est créé de manière dynamique avec les bons noeuds configurés en tant que jeu dorsal.

Composants de la dorsale

La dorsale hello-world se compose des éléments suivants :

• Un déploiement dorsal nommé docker-hello-world. Ce déploiement gère les routes par défaut pour les vérifications d'état et les réponses 404. Pour ce faire, il utilise une image hello-world prédéfinie qui dessert les routes minimales requises pour une dorsale par défaut.
• Un service dorsal nommé docker-hello-world-svc. Ce service expose le déploiement dorsal pour consommation par le déploiement du contrôleur de trafic entrant.

Création de règles d'accès pour le contrôleur de trafic entrant

1. Si vous ne l'avez pas encore fait, suivez les étapes pour configurer le fichier de configuration kubeconfig de la grappe et (s'il y a lieu) définissez la variable d'environnement KUBECONFIG pour qu'elle pointe vers le fichier. Notez que vous devez configurer votre propre fichier kubeconfig. Vous ne pouvez pas accéder à une grappe à l'aide d'un fichier kubeconfig configuré par un autre utilisateur. Voir Configuration de l'accès aux grappes.
2. Si votre utilisateur Oracle Cloud Infrastructure est un administrateur de location, ignorez l'étape suivante et passez directement à Déploiement du contrôleur de trafic entrant et des ressources associées.

3. Si votre utilisateur Oracle Cloud Infrastructure n'est pas un administrateur de location, dans une fenêtre de terminal, accordez-lui le rôle de grappe RBAC Kubernetes cluster-admin dans la grappe en entrant :

   kubectl create clusterrolebinding <my-cluster-admin-binding> --clusterrole=cluster-admin --user=<user-OCID>

   où :

   • <my-cluster-admin-binding> est une chaîne de votre choix à utiliser en tant que nom de la liaison entre l'utilisateur et le rôle de grappe RBAC Kubernetes cluster-admin. Par exemple, jdoe_clst_adm
   • <user-OCID> est l'OCID de l'utilisateur (obtenu à partir de la console ). Par exemple, ocid1.user.oc1..aaaaa...zutq (abrégé pour plus de lisibilité).

   Par exemple :

   kubectl create clusterrolebinding jdoe_clst_adm --clusterrole=cluster-admin --user=ocid1.user.oc1..aaaaa...zutq

Déploiement du contrôleur de trafic entrant et des ressources associées

La façon de déployer le contrôleur de trafic entrant et les ressources associées (y compris les rôles et les liaisons RBAC Kubernetes et le service de contrôleur de trafic entrant ingress-nginx-controller de type LoadBalancer) dépend du déploiement dans une grappe avec des noeuds gérés/autogérés ou dans une grappe avec des noeuds virtuels :

• Noeuds gérés et noeuds autogérés

  Pour déployer le contrôleur de trafic entrant Nginx, exécutez la commande suivante :

  kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v<vnum>/deploy/static/provider/cloud/deploy.yaml

  où <vnum> est le numéro de version de la dernière version du script de déploiement du contrôleur de trafic entrant ingress-nginx-controller. Par exemple, au moment de l'écriture, la dernière version du script a le numéro de version 1.1.3, donc la commande à exécuter est :

  kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.3/deploy/static/provider/cloud/deploy.yaml

  Pour connaître le numéro de version de la dernière version du script, consultez la documentation sur kubernetes/ingress-nginx sur GitHub.

• Noeuds virtuels

  Sur les noeuds virtuels, vous devez modifier le manifeste de déploiement du contrôleur de trafic entrant et commenter les contextes de sécurité fsgroup, allowprivilegeEscalation et capabilities. Pour un exemple de manifeste de déploiement modifié, voir https://github.com/oracle-devrel/oci-oke-virtual-nodes/tree/main/ingress-nginx.

  Pour déployer le contrôleur de trafic entrant Nginx en fonction de ce manifeste modifié, exécutez la commande suivante :

  kubectl apply -f https://raw.githubusercontent.com/oracle-devrel/oci-oke-virtual-nodes/main/ingress-nginx/deploy.yaml

Vérification de l'exécution du service du contrôleur de trafic entrant ingress-nginx-controller en tant que service d'équilibreur de charge

1. Consultez la liste des services en cours d'exécution en entrant :

   kubectl get svc -n ingress-nginx

   La sortie de la commande ci-dessus montre les services en cours d'exécution :

   
   NAME                       TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)                       AGE
   ingress-nginx-controller   LoadBalancer   10.96.229.38   <pending>      80:30756/TCP,443:30118/TCP    1h
   

   L'adresse EXTERNAL-IP du service du contrôleur de trafic entrant ingress-nginx-controller apparaît comme <pending> jusqu'à la création complète de l'équilibreur de charge dans Oracle Cloud Infrastructure.

2. Exécutez de nouveau la commande kubectl get svc jusqu'à ce qu'une adresse IP EXTERNAL s'affiche pour le service du contrôleur de trafic entrant ingress-nginx-controller :

   kubectl get svc -n ingress-nginx
   

   La sortie de la commande ci-dessus montre la valeur EXTERNAL-IP du service de contrôleur entrant ingress-nginx-controller :

   
   NAME                       TYPE           CLUSTER-IP     EXTERNAL-IP       PORT(S)                       AGE
   ingress-nginx-controller   LoadBalancer   10.96.229.38   129.146.214.219   80:30756/TCP,443:30118/TCP    1h

Création de la clé secrète TLS

Une clé secrète TLS est utilisée pour la terminaison SSL sur le contrôleur de trafic entrant.

1. Générez une nouvelle clé dans un fichier. Par exemple, en entrant :

   openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/CN=nginxsvc/O=nginxsvc"

   Pour générer la clé secrète pour cet exemple, un certificat auto-signé est utilisé. Cette méthode est acceptable pour les tests mais, pour la production, utilisez un certificat signé par une autorité de certification.

   Note
   
   Sous Windows, vous devrez peut-être remplacer "/CN=nginxsvc/O=nginxsvc" par "//CN=nginxsvc\O=nginxsvc". Par exemple, cela s'impose si vous exécutez la commande openssl à partir d'un interpréteur de commandes Git Bash.

2. Créez la clé secrète TLS en entrant :

   kubectl create secret tls tls-secret --key tls.key --cert tls.crt

Création de la définition du service docker-hello-world

1. Créez le fichier hello-world-ingress.yaml contenant le code suivant. Ce code utilise une image hello-world Docker Hub disponible au public. Vous pouvez la remplacer par une image de votre choix pouvant être exécutée de la même manière.

   
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: docker-hello-world
     labels:
       app: docker-hello-world
   spec:
     selector:
       matchLabels:
         app: docker-hello-world
     replicas: 3
     template:
       metadata:
         labels:
           app: docker-hello-world
       spec:
         containers:
         - name: docker-hello-world
           image: scottsbaldwin/docker-hello-world:latest
           ports:
           - containerPort: 80
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: docker-hello-world-svc
   spec:
     selector:
       app: docker-hello-world
     ports:
       - port: 8088
         targetPort: 80
     type: ClusterIP
   

   Notez que le type du service docker-hello-world est ClusterIP, et non LoadBalancer, car ce service sera mandaté par le service du contrôleur de trafic entrant ingress-nginx-controller. Le service docker-hello-world n'a pas besoin d'être accessible directement au public. L'accès public sera routé depuis l'équilibreur de charge vers le contrôleur de trafic entrant, et depuis ce dernier vers le service en amont.

2. Créez le nouveau déploiement et le service hello-world sur les noeuds de la grappe en exécutant la commande suivante :

   kubectl create -f hello-world-ingress.yaml

Création de la ressource de trafic entrant

1. Créez le fichier ingress.yaml et ajoutez-y le code suivant :

   
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: hello-world-ing
     annotations:
       kubernetes.io/ingress.class: "nginx"
   spec:
     tls:
     - secretName: tls-secret
     rules:
     - http:
         paths:
           - path: /
             pathType: Prefix
             backend:
               service:
                 name: docker-hello-world-svc
                 port:
                   number: 8088
   

   Notez que l'exemple YAML ci-dessus fonctionne avec les grappes exécutant Kubernetes version 1.19.x et ultérieure.

2. Créez la ressource en entrant :

   kubectl create -f ingress.yaml

Obtention de l'adresse IP externe de l'équilibreur de charge

Pour vérifier que le service ingress-nginx-controller s'exécute en tant que service LoadBalancer, obtenez son adresse IP externe en entrant :

kubectl get svc --all-namespaces

La sortie de la commande ci-dessus montre les services en cours d'exécution :

NAMESPACE       NAME                          TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)                      AGE
default         docker-hello-world-svc      ClusterIP      10.96.83.247    <none>           8088/TCP                     16s
default         kubernetes                  ClusterIP      10.96.0.1       <none>           443/TCP                      1h
ingress-nginx   ingress-nginx-controller    LoadBalancer   10.96.229.38    129.146.214.219  80:30756/TCP,443:30118/TCP   5m			
kube-system     kube-dns                    ClusterIP      10.96.5.5       <none>           53/UDP,53/TCP                1h

Envoi de demandes cURL à l'équilibreur de charge

1. Utilisez l'adresse IP externe du service ingress-nginx-controller (par exemple, 129.146.214.219) pour exécuter une demande HTTP en entrant :

   curl -I http://129.146.214.219
   

   Exemple de sortie de la commande ci-dessus :

   HTTP/1.1 301 Moved Permanently
   Via: 1.1 10.68.69.10 (McAfee Web Gateway 7.6.2.10.0.23236)
   Date: Thu, 07 Sep 2017 15:20:16 GMT
   Server: nginx/1.13.2
   Location: https://129.146.214.219/
   Content-Type: text/html
   Content-Length: 185
   Proxy-Connection: Keep-Alive
   Strict-Transport-Security: max-age=15724800; includeSubDomains;
   

   La sortie présente une redirection 301 et un en-tête Location qui suggèrent que le trafic HTTP soit redirigé vers HTTPS.

2. Exécutez cURL sur l'URL HTTPS ou ajoutez l'option -L pour suivre automatiquement l'en-tête Location. L'option -k indique à cURL de ne pas vérifier les certificats SSL. Par exemple, en entrant :

   curl -ikL http://129.146.214.219

   Exemple de sortie de la commande ci-dessus :

   HTTP/1.1 301 Moved Permanently
   Via: 1.1 10.68.69.10 (McAfee Web Gateway 7.6.2.10.0.23236)
   Date: Thu, 07 Sep 2017 15:22:29 GMT
   Server: nginx/1.13.2
   Location: https://129.146.214.219/
   Content-Type: text/html
   Content-Length: 185
   Proxy-Connection: Keep-Alive
   Strict-Transport-Security: max-age=15724800; includeSubDomains;
   
   HTTP/1.0 200 Connection established
   
   HTTP/1.1 200 OK
   Server: nginx/1.13.2
   Date: Thu, 07 Sep 2017 15:22:30 GMT
   Content-Type: text/html
   Content-Length: 71
   Connection: keep-alive
   Last-Modified: Thu, 07 Sep 2017 15:17:24 GMT
   ETag: "59b16304-47"
   Accept-Ranges: bytes
   Strict-Transport-Security: max-age=15724800; includeSubDomains;
   
   <h1>Hello webhook world from: docker-hello-world-1732906117-0ztkm</h1>
   

   La dernière ligne de la sortie affiche le code HTML retourné par le pod dont le nom d'hôte est docker-hello-world-1732906117-0ztkm.

3. Envoyez plusieurs fois la demande cURL pour voir le nom d'hôte changer dans la sortie HTML, ce qui montre que la charge est en cours d'équilibrage :

   $ curl -k https://129.146.214.219
   
   <h1>Hello webhook world from: docker-hello-world-1732906117-6115l</h1>
   
   $ curl -k https://129.146.214.219
   
   <h1>Hello webhook world from: docker-hello-world-1732906117-7r89v</h1>
   
   $ curl -k https://129.146.214.219
   
   <h1>Hello webhook world from: docker-hello-world-1732906117-0ztkm</h1>

Inspection de nginx.conf

Le déploiement du contrôleur de trafic entrant ingress-nginx-controller manipule le fichier nginx.conf du pod dans lequel il s'exécute.

1. Trouvez le nom du pod qui exécute le déploiement du contrôleur entrant ingress-nginx-controller en entrant :

   kubectl get po -n ingress-nginx
   

   La sortie de la commande ci-dessus indique le nom du pod qui exécute le déploiement du contrôleur entrant ingress-nginx-controller :

   
   NAME                                       READY     STATUS    RESTARTS   AGE
   ingress-nginx-controller-110676328-h86xg   1/1       Running   0          1h
   

2. Utilisez le nom du pod qui exécute le déploiement du contrôleur entrant ingress-nginx-controller pour afficher le contenu de nginx.conf en entrant la commande kubectl exec suivante :

   kubectl exec -n ingress-nginx -it ingress-nginx-controller-110676328-h86xg -- cat /etc/nginx/nginx.conf
   

3. Recherchez proxy_pass dans la sortie. Vous trouverez une occurrence pour la dorsale par défaut et une autre semblable à la suivante :

   proxy_pass http://upstream_balancer;
   

   Cela montre que Nginx mandate les demandes à un service en amont nommé upstream_balancer.

4. Localisez la définition du service en amont dans la sortie. Elle se présente comme suit :

   upstream upstream_balancer {
                   server 0.0.0.1:1234; # placeholder
   
                   balancer_by_lua_block {
                           tcp_udp_balancer.balance()
                   }
           }
   
   

   Le service en amont utilise Lua pour la transmission au moyen d'un mandataire.

Suppression de l'exemple de contrôleur de trafic entrant

1. Exécutez la commande suivante pour supprimer l'exemple de contrôleur de trafic entrant que vous avez créé précédemment :

   kubectl delete -f <deployment-script-location>

   où <deployment-script-location> est l'emplacement du script de déploiement que vous avez utilisé précédemment pour créer l'exemple de contrôleur de trafic entrant.

   Par exemple :

   kubectl delete -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.3/deploy/static/provider/cloud/deploy.yaml