Créer un service et un objet Ingress

Ce document explique comment créer un objet Ingress Kubernetes dans un cluster utilisateur, hybride ou autonome pour Google Distributed Cloud. Un objet Ingress est associé à un ou plusieurs objets Service, chacun étant associé à un ensemble de pods.

Créer un déploiement

Pour créer un déploiement, procédez comme suit :

1. Créez un fichier manifeste de déploiement :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: hello-deployment
   spec:
     selector:
       matchLabels:
         greeting: hello
     replicas: 3
     template:
       metadata:
         labels:
           greeting: hello
       spec:
         containers:
         - name: hello-world
           image: "gcr.io/google-samples/hello-app:2.0"
           env:
           - name: "PORT"
             value: "50000"
         - name: hello-kubernetes
           image: "gcr.io/google-samples/node-hello:1.0"
           env:
           - name: "PORT"
             value: "8080"
   

   Pour les besoins de cet exercice, voici les points importants à comprendre concernant le fichier manifeste de déploiement :

   • Chaque pod appartenant au déploiement possède l'étiquette greeting: hello.

   • Chaque pod possède deux conteneurs.

   • Les champs env spécifient que les conteneurs hello-app écoutent sur le port TCP 50000 et que les conteneurs node-hello écoutent sur le port TCP 8080. Pour hello-app, vous pouvez examiner l'effet de la variable d'environnement PORT en consultant le code source.

2. Copiez le fichier manifeste dans un fichier nommé hello-deployment.yaml.

3. Créez le déploiement :

   kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f hello-deployment.yaml
   

   Remplacez CLUSTER_KUBECONFIG par le nom du fichier kubeconfig de votre cluster.

Exposer votre déploiement avec un service

Pour fournir aux clients un moyen stable d'envoyer des requêtes aux pods de votre déploiement, créez un service :

1. Créez un fichier manifeste Service qui expose votre déploiement aux clients de votre cluster :

   apiVersion: v1
   kind: Service
   metadata:
     name: hello-service
   spec:
     type: ClusterIP
     selector:
       greeting: hello
     ports:
     - name: world-port
       protocol: TCP
       port: 60000
       targetPort: 50000
     - name: kubernetes-port
       protocol: TCP
       port: 60001
       targetPort: 8080
   

2. Copiez le fichier manifeste dans un fichier nommé hello-service.yaml.

3. Créez le service en exécutant la commande suivante :

   kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f hello-service.yaml
   

   Remplacez CLUSTER_KUBECONFIG par le nom du fichier kubeconfig de votre cluster.

4. Consultez le Service :

   kubectl --kubeconfig CLUSTER_KUBECONFIG get service hello-service --output yaml
   

   La sortie affiche la valeur clusterIP qui a été attribuée au service. Exemple :

   apiVersion: v1
   kind: Service
   metadata:
     annotations:
       ...
   spec:
     clusterIP: 10.96.14.249
     clusterIPs:
     - 10.96.14.249
     ipFamilies:
     - IPv4
     ipFamilyPolicy: SingleStack
     ports:
     - name: world-port
       port: 60000
       protocol: TCP
       targetPort: 50000
     - name: kubernetes-port
       port: 60001
       protocol: TCP
       targetPort: 8080
     selector:
       greeting: hello
     sessionAffinity: None
     type: ClusterIP
   status:
     loadBalancer: {}
   

   Dans la sortie précédente, le champ ports est un tableau d'objets ServicePort : l'un est nommé world-port et l'autre kubernetes-port. Pour en savoir plus sur les champs de service, consultez ServiceSpec dans la documentation Kubernetes.

   Voici comment un client peut appeler le service :

   • À l'aide de world-port : un client s'exécutant sur l'un des nœuds de cluster envoie une requête au clusterIP sur le port (par exemple, 10.96.14.249:60000). Le contrôleur d'entrée transfère la requête à un pod membre sur targetPort (par exemple, POD_IP_ADDRESS:50000, où POD_IP_ADDRESS est l'adresse IP d'un pod membre).

   • À l'aide de kubernetes-port : un client s'exécutant sur l'un des nœuds de cluster envoie une requête au clusterIP sur le port (10.96.14.249:60001). Le contrôleur d'entrée transmet la requête à un pod membre sur targetPort (POD_IP_ADDRESS:8080).

Composants d'Ingress

Voici quelques-uns des composants de cluster liés à l'entrée :

Remarque : Les composants Istio préinstallés sur Google Distributed Cloud ne sont compatibles qu'avec l'entrée. Ces composants ne sont pas destinés à fournir des fonctionnalités générales de maillage de services. Pour plus d'informations sur la configuration d'un maillage de services entièrement fonctionnel, consultez la page Installation dans la documentation d'Istio ou Configurer un maillage multicluster en dehors deGoogle Cloud dans la documentation de Cloud Service Mesh.

• Le déploiement istio-ingress. Il s'agit du proxy d'entrée. Le proxy d'entrée transfère le trafic vers les services internes conformément aux règles spécifiées dans un objet Ingress.

• Le service istio-ingress. Ce service expose le déploiement istio-ingress.

• Le déploiement istiod. Il s'agit du contrôleur d'entrée. Le contrôleur d'entrée surveille la création des objets Ingress et configure le proxy d'entrée en conséquence.

Tous ces composants Istio internes au cluster sont installés dans l'espace de noms gke-system. Cet espace de noms n'entre pas en conflit avec une installation Istio/Cloud Service Mesh complète.

Créer un objet Ingress

Pour créer une Ingress, procédez comme suit :

1. Créez un fichier manifeste Ingress :

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: my-ingress
   spec:
     rules:
     - http:
         paths:
         - path: /greet-the-world
           pathType: Exact
           backend:
             service:
               name: hello-service
               port:
                 number: 60000
         - path: /greet-kubernetes
           pathType: Exact
           backend:
             service:
               name: hello-service
               port:
                 number: 60001
   

2. Copiez le fichier manifeste dans un fichier nommé my-ingress.yaml.

3. Créez l'entrée :

   kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f my-ingress.yaml
   

Lorsque vous créez un cluster d'utilisateur, vous spécifiez une valeur pour loadbalancer.ingressVIP dans le fichier de configuration du cluster. Cette adresse IP est configurée sur l'équilibreur de charge du cluster. Lorsque vous créez une entrée, celle-ci reçoit la même adresse IP virtuelle que son adresse IP externe.

Lorsqu'un client envoie une requête à votre adresse IP virtuelle d'entrée de cluster d'utilisateur, la requête est acheminée vers votre équilibreur de charge. L'équilibreur de charge utilise le service istio-ingress pour transférer la requête au proxy d'entrée qui s'exécute dans votre cluster d'utilisateur. Le proxy d'entrée transfère la requête à différents backends en fonction du chemin d'accès dans l'URL de la requête.

Chemin d'accès /greet-the-world

Dans votre fichier manifeste d'entrée, vous pouvez trouver une règle indiquant que le chemin d'accès /greet-the-world est associé à serviceName: hello-service et servicePort: 60000. Rappelez-vous que 60000 est la valeur port dans la section world-port de votre service hello-service.

- name: world-port
    port: 60000
    protocol: TCP
    targetPort: 50000

Le service d'entrée transfère la requête à l'adresse clusterIP:50000. La requête est ensuite transmise à l'un des pods membres du service hello-service. Le conteneur qui écoute sur le port 50000 dans ce pod affiche le message Hello World!.

Chemin d'accès /greet-kubernetes

Dans votre fichier manifeste d'entrée, vous pouvez trouver une règle indiquant que le chemin d'accès /greet-kubernetes est associé à serviceName: hello-service et servicePort: 60001. Rappelez-vous que 60001 est la valeur port dans le champ kubernetes-port de votre service hello-service.

- name: kubernetes-port
    port: 60001
    protocol: TCP
    targetPort: 8080

Le service d'entrée transfère la requête à l'adresse clusterIP: 8080. La requête est ensuite transmise à l'un des pods membres du service hello-service. Le conteneur qui écoute sur le port 8080 dans ce pod affiche le message Hello Kubernetes!.

Tester l'objet Ingress

1. Testez l'entrée à l'aide du chemin d'accès /greet-the-world :

   curl CLUSTER_INGRESS_VIP/greet-the-world
   

   Remplacez CLUSTER_INGRESS_VIP par l'adresse IP externe de l'objet Ingress.

   Le résultat affiche un message Hello, world! :

   Hello, world!
   Version: 2.0.0
   Hostname: ...
   

2. Testez l'entrée à l'aide du chemin d'accès /greet-kubernetes :

   curl CLUSTER_INGRESS_VIP/greet-kubernetes
   

   Le résultat affiche un message Hello, Kubernetes! :

   Hello Kubernetes!
   

Désactiver Ingress groupée

La fonctionnalité d'entrée fournie avec Google Distributed Cloud n'est compatible qu'avec les fonctionnalités d'entrée. Vous pouvez choisir de l'intégrer à Istio ou à Cloud Service Mesh. Ces produits offrent les avantages supplémentaires d'un maillage de services entièrement fonctionnel, tels que le protocole TLS mutuel (mTLS), la possibilité de gérer l'authentification entre les services et l'observabilité des charges de travail. Si vous intégrez Istio ou Cloud Service Mesh, nous vous recommandons de désactiver la fonctionnalité Ingress groupée.

Vous pouvez activer ou désactiver Ingress groupé avec le champ spec.clusterNetwork.bundledIngress dans le fichier de configuration de votre cluster. Ce champ n'est disponible que pour les clusters de version 1.13.0 et ultérieures. Le champ bundledIngress est défini par défaut sur true et n'est pas présent dans le fichier de configuration de cluster généré. Ce champ est modifiable et peut être modifié lorsque vous créez ou mettez à jour un cluster de version 1.13.0 ou ultérieure.

• Pour désactiver la fonctionnalité Ingress groupée, ajoutez le champ bundledIngress à la section clusterNetwork du fichier de configuration de votre cluster et définissez sa valeur sur "false", comme indiqué dans l'exemple suivant :

  apiVersion: v1
  kind: Namespace
  metadata:
    name: cluster-hybrid-basic
  ---
  apiVersion: baremetal.cluster.gke.io/v1
  kind: Cluster
  metadata:
    name: hybrid-basic
    namespace: cluster-hybrid-basic
  spec:
    type: hybrid
    profile: default
    anthosBareMetalVersion: 1.13.0
    gkeConnect:
      projectID: project-fleet
    controlPlane:
      nodePoolSpec:
        nodes:
        - address: 10.200.0.2
    clusterNetwork:
      bundledIngress: false
      pods:
        cidrBlocks:
        - 192.168.0.0/16
      services:
        cidrBlocks:
        - 10.96.0.0/20
  ...
  

Configurer HTTPS pour l'objet Ingress

Si vous souhaitez accepter les requêtes HTTPS de vos clients, le proxy d'entrée doit disposer d'un certificat pour justifier son identité auprès de vos clients. Ce proxy doit également disposer d'une clé privée pour effectuer le handshake HTTPS.

L'exemple suivant utilise ces entités :

• Proxy d'Ingress : participe au handshake HTTPS, puis transfère les paquets aux pods membres du service hello-service.

• Domaine du service hello-service : altostrat.com dans l'exemple d'organisation

Procédez comme suit :

1. Créez un certificat racine et une clé privée. Cet exemple utilise une autorité de certification racine root.ca.example.com dans l'exemple d'organisation de l'autorité de certification racine.

   openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj \
       '/O=Root CA Example Inc./CN=root.ca.example.com' -keyout root-ca.key \
       -out root-ca.crt
   

2. Créez une requête de signature de certificat :

    openssl req -out server.csr -newkey rsa:2048 -nodes -keyout server.key -subj \
        "/CN=altostrat.com/O=Example Org"
   

3. Créez un certificat de diffusion pour le proxy d'entrée.

   openssl x509 -req -days 365 -CA root-ca.crt -CAkey root-ca.key -set_serial 0 \
       -in server.csr -out server.crt
   

   Vous avez à présent créé les certificats et les clés suivants :

   • root-ca.crt : certificat de l'autorité de certification racine
   • root-ca.key : clé privée de l'autorité de certification racine
   • server.crt : certificat de diffusion pour le proxy d'entrée
   • server.key : clé privée du proxy d'entrée

4. Créez un secret Kubernetes contenant le certificat de diffusion et la clé.

   kubectl create secret tls example-server-creds --key=server.key --cert=server.crt \
       --namespace gke-system
   

   Le secret obtenu est nommé example-server-creds.

   Remarque : Les secrets TLS doivent être définis dans l'espace de noms gke-system.

Créer un déploiement et un service

Si vous avez créé un déploiement et un service dans la partie HTTP de ce guide, conservez-les. Si ce n'est pas le cas, créez-les maintenant en suivant les étapes décrites pour HTTP.

Créer un objet Ingress

La création d'un objet Ingress pour HTTPS est semblable à la création d'un objet Ingress pour HTTP, mais la spécification Ingress pour HTTPS inclut une section tls qui spécifie l'hôte et un code secret. L'élément hosts de la section tls doit correspondre explicitement à l'élément host de la section rules.

Avertissement : Ne créez pas plusieurs ressources Ingress pour le même hôte. Lorsque vous utilisez les composants Ingress groupés, vous êtes limité à une seule ressource personnalisée Ingress pour un hôte donné.

Si votre service de backend se trouve dans un espace de noms distinct, vous devez créer un service de type ExternalName dans le même espace de noms que l'entrée Ingress pour acheminer le trafic vers le service de backend.

Les étapes générales de création d'un Ingress pour HTTPS ou HTTP sont les mêmes, à l'exception de ce que vous configurez dans le fichier manifeste :

1. Si vous avez déjà créé un objet Ingress dans la partie HTTP de ce document, supprimez-le avant de continuer.

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress
   

2. Pour gérer le trafic du service que vous avez créé précédemment, créez un fichier manifeste Ingress doté d'une section tls :

   La configuration tls permet d'activer le protocole HTTPS entre les clients et le proxy d'entrée.

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: my-ingress-2
   spec:
     tls:
     - hosts:
       - altostrat.com
       secretName: example-server-creds
     rules:
     - host: altostrat.com
       http:
         paths:
         - path: /greet-the-world
           pathType: Exact
           backend:
             service:
               name: hello-service
               port:
                 number: 60000
         - path: /greet-kubernetes
           pathType: Exact
           backend:
             service:
               name: hello-service
               port:
                 number: 60001
   

3. Enregistrez le fichier manifeste dans un fichier nommé my-ingress-2.yaml et créez l&#Ingress :

   kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f my-ingress-2.yaml
   

4. Vérifiez que l&#Ingress a été créée et qu'elle fonctionne correctement en effectuant les tests suivants :

   • Testez le chemin /greet-the-world :

     curl -v --resolve altostrat.com:443:CLUSTER_INGRESS_VIP \
         https://altostrat.com/greet-the-world \
         --cacert root-ca.crt
     

     Sortie :

     Hello, world!
     Version: 2.0.0
     Hostname: hello-deployment-5ff7f68854-wqzp7
     

   • Testez le chemin /greet-kubernetes :

     curl -v --resolve altostrat.com:443:CLUSTER_INGRESS_VIP \
         https://altostrat.com/greet-kubernetes --cacert root-ca.crt
     

     Sortie :

     Hello Kubernetes!
     

Créer un service LoadBalancer

Un service de type LoadBalancer est une autre façon d'exposer vos charges de travail en dehors de votre cluster. Pour obtenir des instructions et un exemple de création d'un service de type LoadBalancer, consultez Créer un service de type LoadBalancer dans Déployer une application.

Nettoyer

1. Supprimez l'entrée :

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress INGRESS_NAME
   

   Remplacez INGRESS_NAME par le nom de l'objet Ingress, par exemple my-ingress ou my-ingress-2.

2. Supprimez le service :

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete service hello-service
   

3. Supprimez le déploiement :

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete deployment hello-deployment
   

4. Supprimez votre service LoadBalancer :

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete service service-does-not-use-nodeports