Entrée au moyen de Contour

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 Contour.

Ce didacticiel explique comment déployer le contrôleur d'entrée Contour pour acheminer le trafic externe vers des services au sein d'un cluster TKG. Contour est un projet Open Source auquel VMware contribue.

Conditions préalables

Consultez la ressource Entrée dans la documentation Kubernetes.
Vérifiez le contrôleur d'entrée Contour.
Provisionnez un cluster TKG.
Connectez-vous au cluster TKG.

Procédure

Créez un ClusterRoleBinding permettant aux comptes de service de gérer toutes les ressources du cluster.
```
kubectl create clusterrolebinding default-tkg-admin-privileged-binding 
--clusterrole=psp:vmware-system-privileged --group=system:authenticated
```
Note : Si une sécurité renforcée est requise, utilisez une liaison RoleBinding sur l'espace de noms projectcontour. Reportez-vous à la section Appliquer la stratégie de sécurité de l'espace par défaut aux clusters de TKG.
Créer un espace de noms appelé projectcontour.
Il s'agit de l'espace de noms par défaut pour le déploiement du contrôleur d'entrée Contour
```
kubectl create ns projectcontour
```
Téléchargez le dernier fichier YAML du contrôleur d'entrée Contour : Déploiement d'entrée Contour.
Ouvrez le fichier contour.yaml à l'aide d'un éditeur de texte.
Commentez les deux lignes suivantes en ajoutant le symbole # au début de chaque ligne :
Ligne 1632 :
```
# service.beta.kubernetes.io/aws-load-balancer-backend-protocol: tcp
```
Ligne 1634 :
```
# externalTrafficPolicy: Local
```
Déployez Contour en appliquant le fichier contour.yaml.
```
kubectl apply -f contour.yaml
```

Vérifiez que le contrôleur d'entrée Contour et le service d'équilibrage de charge Envoy sont déployés.

kubectl get services -n projectcontour

NAME      TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)                      AGE
contour   ClusterIP      198.63.146.166   <none>          8001/TCP                     120m
envoy     LoadBalancer   198.48.52.47     192.168.123.5   80:30501/TCP,443:30173/TCP   120m

Vérifiez que les espaces Contour et Envoy sont en cours d'exécution.

kubectl get pods -n projectcontour

NAME                       READY   STATUS      RESTARTS   AGE
contour-7966d6cdbf-skqfl   1/1     Running     1          21h
contour-7966d6cdbf-vc8c7   1/1     Running     1          21h
contour-certgen-77m2n      0/1     Completed   0          21h
envoy-fsltp                1/1     Running     0          20h

Exécutez une commande ping sur l'équilibrage de charge à l'aide de l'adresse IP externe.

ping 192.168.123.5

PING 192.168.123.5 (192.168.123.5) 56(84) bytes of data.
64 bytes from 192.168.123.5: icmp_seq=1 ttl=62 time=3.50 ms

Créez une ressource d'entrée nommée ingress-nihao.yaml.

Créez le fichier YAML.

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: ingress-nihao
spec:
  rules:
  - http:
      paths:
      - path: /nihao
        backend:
          serviceName: nihao
          servicePort: 80

Appliquez le fichier YAML.

kubectl apply -f ingress-nihao.yaml

Vérifiez que la ressource d'entrée est créée.

kubectl get ingress

L'adresse IP externe de l'équilibrage de charge envoyé ( 192.168.123.5 dans cet exemple) est utilisée par l'objet d'entrée.

NAME            CLASS    HOSTS   ADDRESS         PORTS   AGE
ingress-nihao   <none>   *       192.168.123.5     80      17s

Déployez un service de test avec une application principale.

Créez le fichier YAML suivant nommé ingress-nihao-test.yaml

kind: Service
apiVersion: v1
metadata:
  name: nihao
spec:
  selector:
    app: nihao
    tier: backend
  ports:
  - protocol: TCP
    port: 80
    targetPort: http
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nihao
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nihao
      tier: backend
      track: stable
  template:
    metadata:
      labels:
        app: nihao
        tier: backend
        track: stable
    spec:
      containers:
        - name: nihao
          image: "gcr.io/google-samples/hello-go-gke:1.0"
          ports:
            - name: http
              containerPort: 80

Appliquez le fichier YAML.

kubectl apply -f ingress-nihao-test.yaml

Vérifiez que le service nihao est créé.

kubectl get services

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
nihao        ClusterIP   10.14.21.22     <none>        80/TCP     15s

Vérifiez que le déploiement du serveur principal est créé.

kubectl get deployments

NAME    READY   UP-TO-DATE   AVAILABLE   AGE
nihao   3/3     3            3           2m25s

Vérifiez que les espaces principaux existent.

kubectl get pods

NAME                     READY   STATUS    RESTARTS   AGE
nihao-8646584495-9nm8x   1/1     Running   0          106s
nihao-8646584495-vscm5   1/1     Running   0          106s
nihao-8646584495-zcsdq   1/1     Running   0          106s

Obtenez l'adresse IP publique de l'équilibreur de charge utilisé par le contrôleur d'entrée Contour.

kubectl get ingress

NAME            CLASS    HOSTS   ADDRESS         PORTS   AGE
ingress-nihao   <none>   *       10.19.14.76     80      13m

À l'aide d'un navigateur, accédez à l'adresse IP publique et incluez le chemin d'entrée.
```
http://10.19.14.76/nihao
```
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.