Une ressource d'entrée Kubernetes qui fournit le routage HTTP ou HTTPS depuis l'extérieur du cluster vers un ou plusieurs services au sein du cluster. Les clusters TKG prennent en charge l'entrée via des contrôleurs tiers, tels que Nginx.

Ce didacticiel explique comment déployer le service d'entrée Kubernetes basé sur NGINX pour router le trafic externe vers des services dans votre cluster Tanzu Kubernetes. Un service d'entrée nécessite un contrôleur d'entrée. Nous installons le contrôleur d'entrée NGINX à l'aide de Helm. Helm est un gestionnaire de modules pour Kubernetes.

Note : Il existe plusieurs façons d'accomplir cette tâche. Les étapes ci-dessous fournissent une approche. D'autres approches peuvent être plus adaptées à votre environnement spécifique.

Conditions préalables

  • Consultez la ressource Entrée dans la documentation Kubernetes.
  • Consultez la documentation du contrôleur d'entrée Nginx.
  • Provisionnez un cluster TKG.
  • Activez la stratégie de sécurité de l'espace si nécessaire.
  • Connectez-vous au cluster TKG.

Procédure

  1. Installez Helm en vous référant à la documentation.
  2. Installez le contrôleur d'entrée NGINX à l'aide de Helm.
    helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
    helm install ingress-nginx ingress-nginx/ingress-nginx
  3. Vérifiez que le contrôleur d'entrée Nginx est déployé en tant que service de type LoadBalancer.
    kubectl get services
    NAME                                 TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)                      AGE
    ingress-nginx-controller             LoadBalancer   10.16.18.20    10.19.14.76   80:30635/TCP,443:30873/TCP   59m
    ingress-nginx-controller-admission   ClusterIP      10.87.41.25    <none>        443/TCP                      59m
    
  4. Exécutez une commande ping sur l'équilibrage de charge à l'aide de l'adresse IP externe.
    ping 10.19.14.76
    Pinging 10.19.14.76 with 32 bytes of data:
    Reply from 10.19.14.76: bytes=32 time<1ms TTL=62
    Reply from 10.19.14.76: bytes=32 time=1ms TTL=62
    
  5. Vérifiez que le contrôleur d'entrée Nginx est en cours d'exécution.
    kubectl get pods
    NAME                                        READY   STATUS    RESTARTS   AGE
    ingress-nginx-controller-7c6c46898c-v6blt   1/1     Running   0          76m
  6. Créez une ressource d'entrée avec une règle d'entrée et un chemin d'accès nommé ingress-hello.yaml.
    apiVersion: networking.k8s.io/v1beta1
    kind: Ingress
    metadata:
      name: ingress-hello
    spec:
      rules:
      - http:
          paths:
          - path: /hello
            backend:
              serviceName: hello
              servicePort: 80
    
    Attention : La version networking.k8s.io/v1beta1 de l'API Kubernetes est obsolète à partir de Kubernetes v1.22 et versions ultérieures. La nouvelle API à utiliser est networking.k8s.io/v1, et elle implique plusieurs modifications de manifeste qui sont documentées ici https://kubernetes.io/docs/reference/using-api/deprecation-guide/.
  7. Déployez la ressource ingress-hello.
    kubectl apply -f ingress-hello.yaml
    ingress.networking.k8s.io/ingress-hello created
  8. Vérifiez que la ressource d'entrée est déployée.
    Notez que l'adresse IP est mappée à l'adresse IP externe du contrôleur d'entrée.
    kubectl get ingress
    NAME            CLASS    HOSTS   ADDRESS         PORTS   AGE
    ingress-hello   <none>   *       10.19.14.76     80      51m
  9. Créez une application de test hello et un service nommé ingress-hello-test.yaml.
    kind: Service
    apiVersion: v1
    metadata:
      name: hello
    spec:
      selector:
        app: hello
        tier: backend
      ports:
      - protocol: TCP
        port: 80
        targetPort: http
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: hello
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: hello
          tier: backend
          track: stable
      template:
        metadata:
          labels:
            app: hello
            tier: backend
            track: stable
        spec:
          containers:
            - name: hello
              image: "gcr.io/google-samples/hello-go-gke:1.0"
              ports:
                - name: http
                  containerPort: 80
    
  10. Déployez la ressource ingress-hello-test.
    kubectl apply -f ingress-hello-test.yaml
    service/hello created
    deployment.apps/hello created
  11. Vérifiez que le déploiement d'hello est disponible.
    kubectl get deployments
    NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
    hello                      3/3     3            3           4m59s
    ingress-nginx-controller   1/1     1            1           3h39m
    
  12. Obtenez l'adresse IP publique de l'équilibrage de charge utilisé par le contrôleur d'entrée Nginx.
    kubectl get ingress
    NAME            CLASS    HOSTS   ADDRESS         PORTS   AGE
    ingress-hello   <none>   *       10.19.14.76     80      13m
  13. À l'aide d'un navigateur, accédez à l'adresse IP publique et incluez le chemin d'entrée.
    http://10.19.14.76/hello
    Le message « hello » est renvoyé.
    {"message":"Hello"}

Résultats

L'application dorsale qui a pour environnement frontal le service exécuté à l'intérieur du cluster est accessible en externe au moyen du navigateur via le contrôleur d'entrée en utilisant l'adresse IP externe de l'équilibrage de charge.