Exposer des applications à l'aide de services

Autopilot Standard

---

Vous trouverez sur cette page la procédure à suivre pour créer des services Kubernetes dans un cluster Google Kubernetes Engine (GKE). Vous pouvez utiliser un service pour regrouper un ensemble de points de terminaison de pods dans une seule ressource. Vous pouvez configurer différents types d'accès à ce regroupement.

Ce document comporte plusieurs exercices. Dans chaque exercice, vous exposez les pods lors de la création d'un service. Vous envoyez ensuite une requête HTTP au service.

Qui doit utiliser ce document ?

Nous vous recommandons de planifier et de concevoir votre configuration Ingress avec les architectes réseau, les ingénieurs réseau et les administrateurs réseau de votre organisation, ou une autre équipe responsable de la définition, de la mise en œuvre et de la maintenance de l'architecture réseau.

Configuration GKE par défaut

Par défaut, vous obtenez une adresse IP de cluster stable que les clients du cluster peuvent utiliser afin de contacter les pods du service. Un client envoie une requête à l'adresse IP stable, et la requête est acheminée vers l'un des pods du service.

Il existe cinq types de services :

• ClusterIP (par défaut)
• NodePort
• LoadBalancer
• ExternalName
• Headless

Par défaut, les clusters Autopilot sont publics. Si vous choisissez un cluster Autopilot privé, vous devez configurer Cloud NAT pour établir des connexions Internet sortantes, par exemple pour extraire des images de DockerHub.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

• Activez l'API Google Kubernetes Engine.
Activer l'API Google Kubernetes Engine
• Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
  Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

• Créer un cluster GKE

Créer un service de type ClusterIP

Dans cette section, vous allez créer un service de type ClusterIP. Un ClusterIP est un type de service dans lequel Kubernetes crée une adresse IP stable accessible à partir des nœuds du cluster. Pour en savoir plus, consultez ClusterIP.

kubectl apply

Voici un fichier manifeste pour un objet Deployment : Un déploiement est une instance qui crée trois instances répliquées contenant le dernier modèle de pod.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  selector:
    matchLabels:
      app: metrics
      department: sales
  replicas: 3
  template:
    metadata:
      labels:
        app: metrics
        department: sales
    spec:
      containers:
      - name: hello
        image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"

Copiez le fichier manifeste dans un fichier nommé my-deployment.yaml, puis créez le déploiement :

kubectl apply -f my-deployment.yaml

Vérifiez que trois pods sont en cours d'exécution :

kubectl get pods

Le résultat affiche trois pods en cours d'exécution :

NAME                            READY   STATUS    RESTARTS   AGE
my-deployment-dbd86c8c4-h5wsf   1/1     Running   0          7s
my-deployment-dbd86c8c4-qfw22   1/1     Running   0          7s
my-deployment-dbd86c8c4-wt4s6   1/1     Running   0          7s

Voici le fichier manifeste d'un service de type ClusterIP :

apiVersion: v1
kind: Service
metadata:
  name: my-cip-service
spec:
  type: ClusterIP
  # Uncomment the below line to create a Headless Service
  # clusterIP: None
  selector:
    app: metrics
    department: sales
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

Le service contient un sélecteur qui spécifie deux libellés :

• app: metrics
• department: sales

Chaque pod du déploiement que vous venez de créer comporte ces deux libellés. Les pods du déploiement deviendront donc des membres de ce service.

Copiez le fichier manifeste dans un fichier nommé my-cip-service.yaml, puis créez le service :

kubectl apply -f my-cip-service.yaml

Attendez quelques minutes que Kubernetes attribue une adresse interne stable au service, puis affichez ce dernier :

kubectl get service my-cip-service --output yaml

Le résultat affiche une valeur pour clusterIP :

spec:
  clusterIP: 10.59.241.241

Notez la valeur de clusterIP. Elle vous servira un peu plus tard.

Console

Créez un objet Deployment. Un déploiement est une instance qui crée trois instances répliquées contenant le dernier modèle de pod.

1. Accédez à la page Charges de travail dans la console Google Cloud.

   Accéder à la page Charges de travail

2. Cliquez sur Déployer.

3. Sous Spécifier un conteneur, sélectionnez Image existante du conteneur.

4. Dans le champ Chemin de l'image, saisissez us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0

5. Cliquez sur OK, puis sur Continuer.

6. Sous Configuration, dans le champ Nom de l'application, saisissez my-deployment.

7. Sous Libellés, créez les libellés suivants :

   • Clé : app et Valeur : metrics
   • Clé : department et Valeur : sales

8. Sous Cluster, choisissez le cluster dans lequel vous souhaitez créer le déploiement.

9. Cliquez sur Déployer.

10. Lorsque votre déploiement est prêt, la page Informations sur le déploiement s'affiche. Sous Pods gérés, vous pouvez voir que votre déploiement comporte un ou plusieurs pods en cours d'exécution.

Créez un service pour exposer votre Deployment. Un déploiement est une instance qui crée trois instances répliquées contenant le dernier modèle de pod.

1. Sur la page Informations sur le déploiement, cliquez sur Actions > Exposer.

2. Dans la boîte de dialogue Exposer, sous Mappage de port, définissez les valeurs suivantes :

   • Port : 80
   • Port cible : 8080
   • Protocole : TCP

3. Dans la liste déroulante Type de service, sélectionnez Adresse IP de cluster.

4. Cliquez sur Exposer.

5. Lorsque votre service est prêt, la page Informations sur le service s'ouvre, avec toutes les informations relatives à votre service. Sous Adresse IP de cluster, notez l'adresse IP que Kubernetes a attribuée à votre service. Il s'agit de l'adresse IP qui peut permettre aux clients internes d'appeler le service.

La création d'un service sans adresse IP de cluster n'est pas disponible via la console.

Accéder au service

Chacun de vos pods membres dispose d'un conteneur d'écoute sur le port TCP 8080. Dans la section suivante, vous n'allez pas faire écouter les conteneurs sur le port 8080. Toutefois, vous pouvez voir que hello-app écoute sur le port 8080 en consultant le Dockerfile et le code source de l'application.

Répertoriez vos pods en cours d'exécution :

kubectl get pods

Dans le résultat, copiez l'un des noms de pods commençant par my-deployment.

NAME                            READY   STATUS    RESTARTS   AGE
my-deployment-dbd86c8c4-h5wsf   1/1     Running   0          2m51s

Obtenez une interface système dans l'un de vos conteneurs en cours d'exécution :

kubectl exec -it POD_NAME -- sh

Remplacez POD_NAME par le nom de l'un des pods dans my-deployment.

Dans votre interface système, installez curl :

apk add --no-cache curl

Dans le conteneur, envoyez une requête à votre service via votre adresse IP de cluster et le port 80. Notez que 80 correspond à la valeur du champ port de votre service. C'est le port que vous utilisez en tant que client du service.

curl CLUSTER_IP:80

Remplacez CLUSTER_IP par la valeur de clusterIP dans votre service.

Vous devez savoir à l'avance que chacun de vos pods membres dispose d'un conteneur qui écoute sur le port TCP 8080. Dans cet exercice, vous n'avez rien fait de spécial pour que les conteneurs écoutent sur le port 8080. Vous pouvez voir que hello-app écoute sur le port 8080 en consultant le Dockerfile et le code source de l'application.

La réponse affiche le résultat de hello-app :

Hello, world!
Version: 2.0.0
Hostname: my-deployment-dbd86c8c4-h5wsf

Pour quitter l'interface système de votre conteneur, saisissez exit.

Votre requête est transférée à l'un des pods membres sur le port TCP 80, qui correspond à la valeur du champ targetPort.

Créer un service de type NodePort

Dans cette section, vous allez créer un service de type NodePort. Un NodePort est un type de service, où Kubernetes vous attribue une valeur de port statique. Le service NodePort est accessible à l'aide de l'adresse IP de n'importe quel nœud avec la valeur nodePort. Pour en savoir plus, consultez NodePort.

kubectl apply

Voici un fichier manifeste pour un objet Deployment : Un déploiement est une instance qui crée trois instances répliquées contenant le dernier modèle de pod.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment-50000
spec:
  selector:
    matchLabels:
      app: metrics
      department: engineering
  replicas: 3
  template:
    metadata:
      labels:
        app: metrics
        department: engineering
    spec:
      containers:
      - name: hello
        image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50000"

Examinons l'objet env dans le fichier manifeste. L'objet env spécifie que la variable d'environnement PORT du conteneur en cours d'exécution aura une valeur de 50000. L'application hello-app écoute sur le port spécifié par la variable d'environnement PORT. Dans cet exercice, vous indiquez donc au conteneur d'écouter sur le port 50000.

Copiez le fichier manifeste dans un fichier nommé my-deployment-50000.yaml, puis créez le déploiement :

kubectl apply -f my-deployment-50000.yaml

Vérifiez que trois pods sont en cours d'exécution :

kubectl get pods

Voici le fichier manifeste d'un service de type NodePort :

apiVersion: v1
kind: Service
metadata:
  name: my-np-service
spec:
  type: NodePort
  selector:
    app: metrics
    department: engineering
  ports:
  - protocol: TCP
    port: 80
    targetPort: 50000

Copiez le fichier manifeste dans un fichier nommé my-np-service.yaml, puis créez le service :

kubectl apply -f my-np-service.yaml

Consultez le Service :

kubectl get service my-np-service --output yaml

Le résultat affiche la valeur nodePort :

...
  spec:
    ...
    ports:
    - nodePort: 30876
      port: 80
      protocol: TCP
      targetPort: 50000
    selector:
      app: metrics
      department: engineering
    sessionAffinity: None
    type: NodePort
...

Créez une règle de pare-feu pour autoriser le trafic TCP sur le port de votre nœud :

gcloud compute firewall-rules create test-node-port \
    --allow tcp:NODE_PORT

Remplacez NODE_PORT par la valeur du champ nodePort de votre service.

Console

Créez un objet Deployment. Un déploiement est une instance qui crée trois instances répliquées contenant le dernier modèle de pod.

1. Accédez à la page Charges de travail dans la console Google Cloud.

   Accéder à la page Charges de travail

2. Cliquez sur Déployer.

3. Sous Spécifier un conteneur, sélectionnez Image existante du conteneur.

4. Dans le champ Chemin de l'image, saisissez us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0.

5. Cliquez sur Ajouter une variable d'environnement.

6. Pour Clé, saisissez PORT, et pour Valeur, saisissez 50000.

7. Cliquez sur OK, puis sur Continuer.

8. Sous Configuration, dans le champ Nom de l'application, saisissez my-deployment-50000.

9. Sous Libellés, créez les libellés suivants :

   • Clé : app et Valeur : metrics
   • Clé : department et Valeur : engineering

10. Sous Cluster, choisissez le cluster dans lequel vous souhaitez créer le déploiement.

11. Cliquez sur Déployer.

12. Lorsque votre déploiement est prêt, la page Informations sur le déploiement s'affiche. Sous Pods gérés, vous pouvez voir que votre déploiement comporte un ou plusieurs pods en cours d'exécution.

Créez un service pour exposer votre Deployment :

1. Sur la page Informations sur le déploiement, cliquez sur Actions > Exposer.

2. Dans la boîte de dialogue Exposer, sous Mappage de port, définissez les valeurs suivantes :

   • Port : 80
   • Port cible : 50000
   • Protocole : TCP

3. Dans la liste déroulante Type de service, sélectionnez Port du nœud.

4. Cliquez sur Exposer.

5. Lorsque votre service est prêt, la page Informations sur le service s'ouvre, avec toutes les informations relatives à votre service. Sous Ports, notez le port de nœud que Kubernetes a attribué à votre service.

Créer une règle de pare-feu pour le port de nœud :

1. Accédez à la page Stratégies de pare-feu de la console Google Cloud.

   Accéder à la page "Stratégies de pare-feu"

2. Cliquez sur Créer une règle de pare-feu.

3. Dans le champ Nom, saisissez test-node-port.

4. Dans la liste déroulante Cibles, sélectionnez Toutes les instances du réseau.

5. Dans le champ Plages IPv4 sources, saisissez 0.0.0.0/0.

6. Dans Protocoles et ports, sélectionnez Protocoles et ports spécifiés.

7. Cochez la case tcp, puis saisissez la valeur de port de nœud que vous avez notée.

8. Cliquez sur Créer.

Obtenir une adresse IP de nœud

Recherchez l'adresse IP externe de l'un de vos nœuds :

kubectl get nodes --output wide

Le résultat ressemble à ce qui suit :

NAME          STATUS    ROLES     AGE    VERSION        EXTERNAL-IP
gke-svc-...   Ready     none      1h     v1.9.7-gke.6   203.0.113.1

Tous les clusters n'ont pas d'adresses IP externes pour les nœuds. C'est le cas des nœuds des clusters privés par exemple.

Accéder au service

Dans la barre d'adresse de votre navigateur, saisissez les informations suivantes :

NODE_IP_ADDRESS:NODE_PORT

Remplacez les éléments suivants :

• NODE_IP_ADDRESS : l'adresse IP externe de l'un de vos nœuds trouvé lors de la création du service lors de la tâche précédente.
• NODE_PORT : valeur du port de votre nœud.

Le résultat ressemble à ce qui suit :

Hello, world!
Version: 2.0.0
Hostname: my-deployment-50000-6fb75d85c9-g8c4f

Réussite : Vous avez accédé à votre nœud à l'aide d'une adresse IP externe et d'un port de nœud statique.

Créer un service de type LoadBalancer

Dans cette section, vous allez créer un service de type LoadBalancer. Un service LoadBalancer est un type de service dans lequel un contrôleur GKE provisionne et configure un équilibreur de charge réseau passthrough externe. Pour en savoir plus, consultez LoadBalancer.

kubectl apply

Voici le fichier manifeste d'un déploiement :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment-50001
spec:
  selector:
    matchLabels:
      app: products
      department: sales
  replicas: 3
  template:
    metadata:
      labels:
        app: products
        department: sales
    spec:
      containers:
      - name: hello
        image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50001"

Vous remarquerez que les conteneurs de ce déploiement écoutent sur le port 50001.

Copiez le fichier manifeste dans un fichier nommé my-deployment-50001.yaml, puis créez le déploiement :

kubectl apply -f my-deployment-50001.yaml

Vérifiez que trois pods sont en cours d'exécution :

kubectl get pods

Voici le fichier manifeste d'un service de type LoadBalancer :

apiVersion: v1
kind: Service
metadata:
  name: my-lb-service
spec:
  type: LoadBalancer
  selector:
    app: products
    department: sales
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50001

Copiez le fichier manifeste dans un fichier nommé my-lb-service.yaml,, puis créez le service :

kubectl apply -f my-lb-service.yaml

Attendez quelques minutes que le contrôleur configure l'équilibreur de charge réseau passthrough externe et génère une adresse IP stable.

Consultez le Service :

kubectl get service my-lb-service --output yaml

Le résultat affiche une adresse IP externe stable sous loadBalancer:ingress :

...
spec:
  ...
  ports:
  - ...
    port: 60000
    protocol: TCP
    targetPort: 50001
  selector:
    app: products
    department: sales
  sessionAffinity: None
  type: LoadBalancer
status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.10

Console

Créez un objet Deployment. Un déploiement est une instance qui crée trois instances répliquées contenant le dernier modèle de pod.

1. Accédez à la page Charges de travail dans la console Google Cloud.

   Accéder à la page Charges de travail

2. Cliquez sur Déployer.

3. Sous Spécifier un conteneur, sélectionnez Image existante du conteneur.

4. Dans le champ Chemin de l'image, saisissez us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0.

5. Cliquez sur Ajouter une variable d'environnement.

6. Pour Clé, saisissez PORT, et pour Valeur, saisissez 50001.

7. Cliquez sur OK, puis sur Continuer.

8. Sous Configuration, dans le champ Nom de l'application, saisissez my-deployment-50001.

9. Sous Libellés, créez les libellés suivants :

   • Clé : app et Valeur : products
   • Clé : department et Valeur : sales

10. Sous Cluster, choisissez le cluster dans lequel vous souhaitez créer le déploiement.

11. Cliquez sur Déployer.

12. Lorsque votre déploiement est prêt, la page Informations sur le déploiement s'affiche. Sous Pods gérés, vous pouvez voir que votre déploiement comporte un ou plusieurs pods en cours d'exécution.

Créer un service pour exposer le déploiement

1. Sur la page Informations sur le déploiement, cliquez sur Actions > Exposer.

2. Dans la boîte de dialogue Exposer, sous Mappage de port, définissez les valeurs suivantes :

   • Port : 60000
   • Port cible : 50001
   • Protocole : TCP

3. Dans la liste déroulante Type de service, sélectionnez Équilibreur de charge.

4. Cliquez sur Exposer.

5. Lorsque votre service est prêt, la page Informations sur le service s'ouvre, avec toutes les informations relatives à votre service. Sous Équilibreur de charge, notez l'adresse IP externe de l'équilibreur de charge.

Accéder au service

Attendez quelques minutes que GKE configure l'équilibreur de charge.

Dans la barre d'adresse de votre navigateur, saisissez les informations suivantes :

LOAD_BALANCER_ADDRESS:60000

Remplacez LOAD_BALANCER_ADDRESS par l'adresse IP externe de votre équilibreur de charge.

La réponse affiche le résultat de hello-app :

Hello, world!
Version: 2.0.0
Hostname: my-deployment-50001-68bb7dfb4b-prvct

Réussite : vous avez accédé aux nœuds à l'aide d'un équilibreur de charge. Notez que la valeur de port dans un service est arbitraire. L'exemple précédent le prouve en utilisant une valeur de port de 60000. Vous pouvez maintenant en savoir plus sur les types de services LoadBalancer disponibles, tels que

Créer un service de type ExternalName

Dans cette section, vous allez créer un service de type ExternalName. Un service de type ExternalName fournit un alias interne à un nom DNS externe. Les clients internes effectuent des requêtes à l'aide du nom DNS interne, qui sont redirigées vers le nom externe. Pour en savoir plus, consultez ExternalName.

Voici le fichier manifeste d'un service de type ExternalName :

apiVersion: v1
kind: Service
metadata:
  name: my-xn-service
spec:
  type: ExternalName
  externalName: example.com

Dans l'exemple précédent, le nom DNS est my-xn-service.default.svc.cluster.local. Lorsqu'un client interne envoie une requête à my-xn-service.default.svc.cluster.local, celle-ci est redirigée vers example.com.

Créer un service à l'aide de kubectl expose

La commande kubectl expose constitue une alternative à l'écriture d'un fichier manifeste de service pour exposer un déploiement. Saisissez cette commande pour exposer my-deployment, présenté plus tôt dans ce document:

kubectl expose deployment my-deployment --name my-cip-service \
    --type ClusterIP --protocol TCP --port 80 --target-port 8080

Pour exposer my-deployment-50000, évoqué précédemment dans ce document, vous pouvez saisir la commande suivante :

kubectl expose deployment my-deployment-50000 --name my-np-service \
    --type NodePort --protocol TCP --port 80 --target-port 50000

Pour exposer my-deployment-50001, évoqué précédemment dans ce document, vous pouvez saisir la commande suivante :

kubectl expose deployment my-deployment-50001 --name my-lb-service \
    --type LoadBalancer --port 60000 --target-port 50001

Effectuer un nettoyage

Après avoir terminé les exercices de cette page, procédez comme suit pour supprimer les ressources afin d'éviter que des frais inutiles ne vous soient facturés sur votre compte :

kubectl apply

Supprimer les services

kubectl delete services my-cip-service my-np-service my-lb-service

Supprimer les déploiements

kubectl delete deployments my-deployment my-deployment-50000 my-deployment-50001

Supprimer la règle de pare-feu

gcloud compute firewall-rules delete test-node-port

Console

Supprimer les services

1. Accédez à la page Services de la console Google Cloud.

   Accéder aux services

2. Sélectionnez les services que vous avez créés dans le cadre de cet exercice, puis cliquez sur Supprimer.

3. Lorsque vous êtes invité à confirmer votre choix, cliquez sur Supprimer.

Supprimer les déploiements

1. Accédez à la page Charges de travail dans la console Google Cloud.

   Accéder à la page Charges de travail

2. Sélectionnez les déploiements que vous avez créés dans cet exercice, puis cliquez sur Supprimer.

3. Lorsque vous êtes invité à confirmer l'opération, cochez la case Supprimer les autoscalers horizontaux de pods associés aux déploiements sélectionnés, puis cliquez sur Supprimer.

Supprimer la règle de pare-feu

1. Accédez à la page Stratégies de pare-feu de la console Google Cloud.

   Accéder à la page "Stratégies de pare-feu"

2. Cochez la case test-node-port, puis cliquez sur Supprimer.

3. Lorsque vous êtes invité à confirmer votre choix, cliquez sur Supprimer.

Bravo ! Vous avez appris les principes de base des services Kubernetes. Vous pouvez maintenant apprendre à contrôler les accès et à gérer le trafic dans votre cluster. Pour en savoir plus, consultez la section Mise en réseau à l'extérieur du cluster.

Étapes suivantes

• Pour en savoir plus sur le concept de service et découvrir les différents types de services, consultez la page Service.
• Services
• StatefulSets
• Entrée
• Équilibrage de charge HTTP avec un objet Entrée