Dans l'article précédent Guide étape par étape pour déployer et gérer Kubernetes, nous avons couvert les fondamentaux de Kubernetes: son architecture, ses composants clés (tels que les pods, les déploiements et les services) et les principes généraux de déploiement et de gestion des clusters. Nous allons maintenant approfondir l'utilisation de Pods—les plus petites unités exécutables dans Kubernetes. Pour gérer efficacement leur communication et leur disponibilité, Kubernetes Usages Services, dont l’objectif général a été mentionné plus haut.
Dans cet article, nous explorerons les fonctionnalités des services à travers des exemples pratiques : leurs types (ClusterIP, NodePort, LoadBalancer), les configurations de manifeste YAML et les cas d'utilisation pour garantir une communication stable entre les composants de l'application.
Kubernetes Services revisités
Tout d’abord, rappelons ce que Kubernetes Services En bref, ce sont des objets qui fournissent un accès stable aux applications d'un cluster, même lorsque les pods changent dynamiquement. Plus précisément, Kubernetes Services constituent un mécanisme essentiel pour assurer une communication réseau stable entre les composants applicatifs dans un environnement de cluster en constante évolution. En termes simples, les services agissent comme « points d'entrée stables » à un groupe de Pods, même si ces derniers sont recréés, mis à l'échelle ou déplacés entre nœuds. Voici une illustration des principaux types de services dans K8s :
Problèmes traités par Kubernetes Les services
Depuis que les Pods sont dans Kubernetes sont éphémères (leurs adresses IP changent lors des redémarrages, des mises à l'échelle ou des mises à jour), ce qui crée des défis pour les composants d'application (par exemple, frontend et backend) qui nécessitent une méthode de communication stable.
Kubernetes Les services résolvent ces problèmes grâce aux actions suivantes :
- Identifiants fixes: Les services attribuent une adresse IP stable (ClusterIP), DNS nom ou IP externe, indépendant du cycle de vie des Pods.
- Load Balancing: Le trafic est automatiquement réparti entre les pods sélectionnés via des étiquettes (par exemple, « app : backend »).
- Mise à jour automatique: Les services suivent dynamiquement les modifications dans l'ensemble des pods via EndpointSlices, en mettant à jour la liste des instances disponibles.
Core Kubernetes Types de services avec exemples
ClusterIP : pour l'accès interne aux pods du cluster
Exemple de configuration :
simple-service.yaml
apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
selector:
app.kubernetes.io/name: MyApp
ports:
- protocol: TCP
port: 80
targetPort: 9376Commande pour créer le service :
kubectl apply -f simple-service.yamlVérification :
kubectl get services # Viewing ClusterIP
kubectl describe service/my-service # Details Service and EndpointsLoadBalancer est conçu pour un accès public via un équilibreur de charge cloud.
Exemple de configuration :
# nodeport-service.yaml
apiVersion: v1
kind: Service
metadata:
name: my-nodeport-service
spec:
type: NodePort
selector:
app.kubernetes.io/name: MyApp
ports:
- port: 80
targetPort: 9376
nodePort: 30007 # Optional (default: random port in range)
Commande pour créer le service :
kubectl apply -f nodeport-service.yamlAccès:
curl http://:30007 # replace with node IP ExternalName est conçu pour créer un lien vers une ressource externe via DNS CNAME.
Exemple de configuration :
# loadbalancer-service.yaml
apiVersion: v1
kind: Service
metadata:
name: my-loadbalancer
spec:
type: LoadBalancer
selector:
app.kubernetes.io/name: MyApp
ports:
- port: 80
targetPort: 9376Commande pour créer le service :
kubectl apply -f loadbalancer-service.yamlVérification de l'IP externe :
kubectl get service/my-loadbalancer -o wide # Viewing EXTERNAL-IPLe service sans tête (sans ClusterIP) est conçu pour un accès direct aux pods sans équilibrage de charge.
Exemple de configuration :
# externalname-service.yaml
apiVersion: v1
kind: Service
metadata:
name: external-db
spec:
type: ExternalName
externalName: my.database.example.comCommande pour créer le service :
kubectl apply -f externalname-service.yamlUsage:
D'autres pods peuvent accéder à « external-db » en tant que DNS Le nom
Le service sans tête (sans ClusterIP) est conçu pour un accès direct aux pods sans équilibrage de charge.
Exemple de configuration :
# headless-service.yaml
apiVersion: v1
kind: Service
metadata:
name: my-headless
spec:
clusterIP: None
selector:
app.kubernetes.io/name: MyApp
ports:
- port: 80
targetPort: 9376
Commande pour créer le service :
kubectl apply -f headless-service.yamlDNS vérification:
nslookup my-headless.default.svc.cluster.local # Returns the IPs of all PodsExemples supplémentaires :
La configuration du service multiport est conçue pour simplifier la configuration des applications nécessitant plusieurs ports.
Configuration:
# multi-port-service.yaml
apiVersion: v1
kind: Service
metadata:
name: my-multi-port
spec:
selector:
app.kubernetes.io/name: MyApp
ports:
- name: http
protocol: TCP
port: 80
targetPort: 8080
- name: metrics
protocol: TCP
port: 9090
targetPort: 9090Commande:
kubectl apply -f multi-port-service.yamlLa configuration du service sans sélecteur (EndpointSlices manuels) est utilisée pour s'intégrer aux ressources extérieures Kubernetes
Configuration du service :
# service-without-selector.yaml
apiVersion: v1
kind: Service
metadata:
name: my-external-service
spec:
ports:
- name: http
protocol: TCP
port: 80
targetPort: 9376
La configuration d'EndpointSlice est conçue pour une gestion flexible des points de terminaison (y compris les systèmes externes) :
Configuration:
# endpointslice.yaml
apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
name: my-service-1
labels:
kubernetes.io/service-name: my-external-service
addressType: IPv4
ports:
- name: http
protocol: TCP
port: 9376
endpoints:
- addresses: ["10.4.5.6"]
- addresses: ["10.1.2.3"]commandes:
kubectl apply -f service-without-selector.yamlkubectl apply -f endpointslice.yamlCommandes utiles :
L'affichage de tous les services permet d'afficher une liste de tous les services dans l'espace de noms actuel :
kubectl get servicesL'affichage des points de terminaison vise à afficher une liste de points de terminaison : les adresses IP et les ports des pods associés au service :
kubectl get endpointsDNS la vérification d'un service est destinée à vérifier DNS résolution du nom du service au sein d'un Pod :
kubectl exec -it -- nslookup La suppression d'un service vise à supprimer le service du cluster :
kubectl delete service/FAQ: Kubernetes Services
- Q1 : Qu'est-ce qu'un Kubernetes Un service?
A1 : Un Kubernetes Un service est une abstraction qui fournit un accès réseau stable à un ensemble de pods. Les services assurent une communication fiable entre les composants, même lorsque les pods sont recréés, mis à l'échelle ou déplacés entre les nœuds. - Q2 : Pourquoi les services sont-ils nécessaires dans Kubernetes?
A2 : Les pods sont éphémères, ce qui signifie que leurs adresses IP peuvent changer lors des redémarrages ou des mises à l'échelle. Les services résolvent ce problème en fournissant des adresses IP fixes. DNS noms ou adresses externes, ainsi que l'équilibrage de charge et les mises à jour automatiques des points de terminaison. - Q3 : Quels sont les principaux types de services dans Kubernetes?
A3 : Les types de noyaux comprennent :
ClusterIP - accès interne au cluster
NodePort - expose le service sur un port statique sur chaque nœud
LoadBalancer - s'intègre aux équilibreurs de charge des fournisseurs de cloud pour un accès externe
ExternalName - mappe un service à un service externe DNS Le nom
Service sans tête - accès direct au Pod sans équilibrage de charge - Q4 : Comment créer un Kubernetes Un service?
A4 : Les services sont définis dans les manifestes YAML et appliqués à l'aide de kubectl apply -f . Vous spécifiez le type, le sélecteur (étiquettes) et les ports pour configurer la manière dont le trafic est acheminé vers les pods. - Q5 : Un service peut-il avoir plusieurs ports ?
A5 : Oui. Les services multiports permettent d’exposer plusieurs ports à partir du même ensemble de pods, ce qui est utile pour les applications qui servent HTTP, des métriques et d’autres protocoles simultanément. - Q6 : Comment puis-je vérifier qu’un service fonctionne ?
A6 : Utilisez des commandes telles que kubectl get services pour répertorier les services, kubectl describe service/ pour afficher les détails et nslookup à l'intérieur d'un Pod pour vérifier DNS résolution. - Q7 : Que faire si j’ai besoin de connecter un service à des points de terminaison externes ?
A7 : Vous pouvez créer un service sans sélecteur et définir manuellement les points de terminaison via des objets EndpointSlice, permettant ainsi l'intégration avec des ressources extérieures au service. Kubernetes . - Q8 : Comment les services gèrent-ils l’équilibrage de charge ?
A8 : Les services répartissent automatiquement le trafic entrant entre les pods sélectionnés en fonction des étiquettes, garantissant une charge uniforme et une haute disponibilité au sein du cluster.
