Utilisation de la passerelle Envoy pour mettre en oeuvre l'API de passerelle Kubernetes

Découvrez comment configurer la passerelle Envoy pour prendre en charge l'API de passerelle Kubernetes dans les grappes que vous créez à l'aide du moteur Kubernetes (OKE).

L'API de passerelle Kubernetes (API de passerelle) est la norme de nouvelle génération pour la gestion du trafic entrant et réseau dans les grappes Kubernetes, qui succède à l'API de trafic entrant. Pour plus d'informations sur l'API de passerelle, voir API de passerelle dans la documentation sur Kubernetes et la documentation sur l'API de passerelle.

Envoy Gateway est une mise en oeuvre à code source libre de l'API Gateway qui gère le mandataire Envoy en tant que plan de données. Il offre un moyen standard et conforme de gérer le trafic entrant sans dépendre des CRD propres au fournisseur.

En déployant la passerelle Envoy, vous pouvez l'utiliser comme contrôleur sous-jacent pour gérer Gateway, HTTPRoute et d'autres ressources d'API de passerelle.

Le déploiement de la passerelle Envoy comprend plusieurs composants qui fonctionnent ensemble :

Les CRD d'API de passerelle étendent l'API Kubernetes avec de nouveaux types de ressource tels que Gateway et HTTPRoute, ce qui permet la gestion déclarative du trafic entrant.
Le contrôleur du service de passerelle Envoy agit comme plan de contrôle, surveillant les ressources d'API du service de passerelle et les traduisant en configuration détaillée pour le plan de données.
Les pods mandataires Envoy forment le plan de données, en gérant le trafic réseau conformément aux politiques et aux routes définies par les ressources de passerelle.
L'intégration de l'équilibreur de charge de réseau OCI garantit que le trafic externe est correctement acheminé vers les applications au moyen des noeuds mandataires Envoy.

Préalables

Avant de configurer la passerelle Envoy pour prendre en charge l'API de passerelle Kubernetes :

Vous devez avoir un accès kubectl à la grappe créée par Kubernetes Engine.
L'ordinateur à partir duquel vous accédez à la grappe doit disposer de l'interface de ligne de commande Helm (v3.0 ou ultérieure).
Vous devez disposer de privilèges d'administrateur de grappe pour installer des définitions de ressource personnalisée (CRD) et des contrôleurs.

Configuration de la passerelle Envoy en tant que contrôleur d'API de passerelle

Étapes de haut niveau pour configurer la passerelle Envoy

À un niveau général, les étapes de configuration de la passerelle Envoy pour servir de contrôleur d'API de passerelle sont les suivantes :

Étape 1 : Installer les CRD d'API de passerelle
Étape 2 : Installer la passerelle Envoy
Étape 3 : Configurer l'intégration de l'équilibreur de charge de réseau OCI
Étape 4 : Créer un fichier GatewayClass
Étape 5 : Créer une passerelle
Étape 6 : déployer un exemple d'application
Étape 7 : Créer un fichier HTTPRoute
Étape 8 : Vérifier la connectivité

Étape 1 : Installer les CRD d'API de passerelle

Les définitions de ressources personnalisées d'API de passerelle ne sont pas installées par défaut dans les grappes que vous créez à l'aide de Kubernetes Engine. Avant d'utiliser la passerelle Envoy en tant que contrôleur d'API de passerelle, vous devez installer les CRD.

Installez les CRD de canal standard (v1.2.0) en entrant :

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.2.0/standard-install.yaml

Vérifiez que le CRD est installé en entrant :

kubectl get crd gateways.gateway.networking.k8s.io

Vérifiez que le CRD est répertorié dans la sortie.

Étape 2 : Installer la passerelle Envoy

Utilisez Helm pour installer le contrôleur de passerelle Envoy.

Installez le graphique dans l'espace de noms envoy-gateway-system en entrant :

helm install eg oci://docker.io/envoyproxy/gateway-helm --version v1.6.3 -n envoy-gateway-system --create-namespace

Attendez que le contrôleur de la passerelle Envoy soit prêt en entrant :

kubectl wait --namespace envoy-gateway-system \
  --for=condition=ready pod \
  --selector=control-plane=envoy-gateway \
  --timeout=90s

Étape 3 : Configurer l'intégration de l'équilibreur de charge de réseau OCI

Créez une ressource personnalisée EnvoyProxy pour injecter les annotations OCI nécessaires dans Service que la passerelle Envoy crée.

Créez un fichier nommé oci-envoy-proxy.yaml avec le contenu suivant :

apiVersion: gateway.envoyproxy.io/v1alpha1
kind: EnvoyProxy
metadata:
  name: oci-flexible-proxy
  namespace: envoy-gateway-system
spec:
  provider:
    type: Kubernetes
    kubernetes:
      envoyService:
        annotations:
          oci.oraclecloud.com/load-balancer-type: "nlb"

Créez la ressource personnalisée EnvoyProxy en entrant :
```
kubectl apply -f oci-envoy-proxy.yaml
```

Étape 4 : Créer un fichier GatewayClass

Créez une valeur GatewayClass qui indique au contrôleur d'utiliser la valeur EnvoyProxy que vous avez créée.

Créez un fichier nommé oci-gateway-class.yaml avec le contenu suivant :

apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: oci-gateway-class
spec:
  controllerName: gateway.envoyproxy.io/gatewayclass-controller
  parametersRef:
    group: gateway.envoyproxy.io
    kind: EnvoyProxy
    name: oci-flexible-proxy
    namespace: envoy-gateway-system

Créez GatewayClass en entrant :

kubectl apply -f oci-gateway-class.yaml

Étape 5 : Créer une passerelle

Créez la ressource Gateway, qui déclenche la création de l'équilibreur de charge de réseau OCI.

Créez un fichier nommé my-gateway.yaml avec le contenu suivant :

apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: my-envoy-gateway
  namespace: default
spec:
  gatewayClassName: oci-gateway-class
  listeners:
  - name: http
    protocol: HTTP
    port: 80
    allowedRoutes:
      namespaces:
        from: Same

Créez Gateway en entrant :
```
kubectl apply -f my-gateway.yaml
```
Obtenez l'adresse IP externe en entrant :
```
kubectl get gateway my-envoy-gateway -n default
```
OCI peut prendre quelques minutes pour provisionner l'équilibreur de charge.

Attendez que la colonne PROGRAMMED contienne True et qu'une adresse IP apparaisse dans la colonne ADDRESS.

Étape 6 : déployer un exemple d'application

Testez la passerelle en déployant un service d'écho simple.

Créez un fichier nommé echo-app.yaml avec le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-app
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: echo
  template:
    metadata:
      labels:
        app: echo
    spec:
      containers:
      - name: echo
        image: ealen/echo-server:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: echo-service
  namespace: default
spec:
  selector:
    app: echo
  ports:
  - port: 80
    targetPort: 80

Créez l'exemple d'application en entrant :
```
kubectl apply -f echo-app.yaml
```

Étape 7 : Créer un fichier HTTPRoute

Créez un HTTPRoute pour diriger le trafic de Gateway vers l'application.

Créez un fichier nommé echo-route.yaml avec le contenu suivant :

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: echo-route
  namespace: default
spec:
  parentRefs:
  - name: my-envoy-gateway
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /
    backendRefs:
    - name: echo-service
      port: 80

Créez HTTPRoute en entrant :
```
kubectl apply -f echo-route.yaml
```

Étape 8 : Vérifier la connectivité

Vérifiez la connectivité en envoyant une demande à l'adresse IP externe de Gateway.

Extrayez l'adresse IP publique de la passerelle et enregistrez-la en tant que variable d'environnement en entrant :
```
export GATEWAY_IP=$(kubectl get gateway my-envoy-gateway -o jsonpath='{.status.addresses[0].value}')
```
Utilisez curl pour envoyer une demande à l'adresse IP externe de la passerelle en entrant :
```
curl -i http://$GATEWAY_IP/
```
Confirmez que vous recevez une réponse 200 OK, ainsi qu'un corps JSON qui affiche les détails de la demande (en-têtes, hôte, etc.).

(Facultatif) Nettoyer

Vous pouvez éventuellement supprimer les ressources que vous avez créées dans cette rubrique en entrant :

kubectl delete -f echo-route.yaml

kubectl delete -f echo-app.yaml

kubectl delete -f my-gateway.yaml

kubectl delete -f oci-gateway-class.yaml

kubectl delete -f oci-envoy-proxy.yaml

helm uninstall eg -n envoy-gateway-system

Si vous n'avez plus besoin de l'API de passerelle sur cette grappe, vous pouvez supprimer les CRD en entrant :

kubectl delete -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.2.0/standard-install.yaml

Documentation sur Oracle Cloud Infrastructure