Connecter un Frontend à un Backend en utilisant les Services
Cette tâche montre comment créer un microservice frontend et un microservice backend. Le backend renvoie un message de salutations à chaque requête. Le frontend expose le backend en utilisant Nginx et un Service Kubernetes.
Objectifs
- Créer et exécuter un microservice backend
helloen utilisant un Déploiement. - Utiliser un Service pour envoyer du trafic vers les multiples réplicas du microservice backend.
- Créer et exécuter un microservice frontend
nginx, en utilisant également un Deployment. - Configurer le microservice frontend pour envoyer du trafic vers le microservice backend.
- Utiliser un Service de type
LoadBalancerpour exposer le microservice frontend en dehors du cluster.
Pré-requis
Vous devez disposer d'un cluster Kubernetes et l'outil de ligne de commande kubectl doit être configuré pour communiquer avec votre cluster. Si vous ne possédez pas déjà de cluster, vous pouvez en créer un en utilisant Minikube, ou vous pouvez utiliser l'un de ces environnements Kubernetes:
Pour consulter la version, entrezkubectl version.Cette tâche utilise les Services avec des équilibreurs de charge externes, qui nécessitent un environnement spécifique. Si votre environnement ne prend pas en charge cette fonction, vous pouvez utiliser un Service de type NodePort à la place.
Création du backend à l'aide d'un Deployment
Le backend est un simple microservice de salutations. Voici le fichier de configuration pour le Deployment backend :
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: backend
spec:
selector:
matchLabels:
app: hello
tier: backend
track: stable
replicas: 3
template:
metadata:
labels:
app: hello
tier: backend
track: stable
spec:
containers:
- name: hello
image: "gcr.io/google-samples/hello-go-gke:1.0"
ports:
- name: http
containerPort: 80
...Créez le Deployment backend :
kubectl apply -f https://k8s.io/examples/service/access/backend-deployment.yaml
Affichez les informations du Deployment:
kubectl describe deployment backend
Le retour sera similaire à celui-ci:
Name: backend
Namespace: default
CreationTimestamp: Mon, 24 Oct 2016 14:21:02 -0700
Labels: app=hello
tier=backend
track=stable
Annotations: deployment.kubernetes.io/revision=1
Selector: app=hello,tier=backend,track=stable
Replicas: 3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType: RollingUpdate
MinReadySeconds: 0
RollingUpdateStrategy: 1 max unavailable, 1 max surge
Pod Template:
Labels: app=hello
tier=backend
track=stable
Containers:
hello:
Image: "gcr.io/google-samples/hello-go-gke:1.0"
Port: 80/TCP
Environment: <none>
Mounts: <none>
Volumes: <none>
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing True NewReplicaSetAvailable
OldReplicaSets: <none>
NewReplicaSet: hello-3621623197 (3/3 replicas created)
Events:
...
Création du Service hello
La solution pour envoyer des requêtes d'un frontend vers un backend est le Service backend.
Un Service crée une adresse IP persistante et un enregistrement DNS afin que le microservice backend puisse toujours être joignable.
Un Service utilise des sélecteurs pour trouver les Pods vers lesquels acheminer le trafic.
Tout d'abord, explorez le fichier de configuration du Service :
---
apiVersion: v1
kind: Service
metadata:
name: hello
spec:
selector:
app: hello
tier: backend
ports:
- protocol: TCP
port: 80
targetPort: http
...Dans le fichier de configuration, vous pouvez voir que le Service,
nommé hello, achemine le trafic vers les Pods ayant les labels app: hello et tier: backend.
Créez le Service backend :
kubectl apply -f https://k8s.io/examples/service/access/backend-service.yaml
À ce stade, vous avez un Deployment backend exécutant trois réplicas de votre application hello,
et un Service capable d'acheminer le trafic vers celles-ci.
Cependant, ce service n'est ni disponible, ni résolvable en dehors du cluster.
Création du frontend
Maintenant que votre backend est opérationnel, vous pouvez créer un frontend accessible en dehors du cluster, qui se connecte au backend en acheminant les requêtes vers celui-ci.
Le frontend envoie des requêtes aux Pods du backend en utilisant le nom DNS attribué au Service backend.
Le nom DNS est hello, qui est la valeur du champ name
dans le fichier de configuration examples/service/access/backend-service.yaml.
Les Pods du frontend Deployment exécutent une image nginx
configurée pour acheminer les requêtes vers le Service backend hello.
Voici le fichier de configuration nginx :
# The identifier Backend is internal to nginx, and used to name this specific upstream
upstream Backend {
# hello is the internal DNS name used by the backend Service inside Kubernetes
server hello;
}
server {
listen 80;
location / {
# The following statement will proxy traffic to the upstream named Backend
proxy_pass http://Backend;
}
}
Comme pour le backend, le frontend dispose d'un Deployment et d'un Service.
Une différence importante à noter entre les services backend et frontend est que
le Service frontend est configuré avec un type: LoadBalancer, ce qui signifie que le Service utilise
un équilibreur de charge provisionné par votre fournisseur de cloud et sera accessible depuis l'extérieur du cluster.
---
apiVersion: v1
kind: Service
metadata:
name: frontend
spec:
selector:
app: hello
tier: frontend
ports:
- protocol: "TCP"
port: 80
targetPort: 80
type: LoadBalancer
...---
apiVersion: apps/v1
kind: Deployment
metadata:
name: frontend
spec:
selector:
matchLabels:
app: hello
tier: frontend
track: stable
replicas: 1
template:
metadata:
labels:
app: hello
tier: frontend
track: stable
spec:
containers:
- name: nginx
image: "gcr.io/google-samples/hello-frontend:1.0"
lifecycle:
preStop:
exec:
command: ["/usr/sbin/nginx","-s","quit"]
...Créez le Deployment et le Service frontend :
kubectl apply -f https://k8s.io/examples/service/access/frontend-deployment.yaml
kubectl apply -f https://k8s.io/examples/service/access/frontend-service.yaml
Le retour valide la création des deux ressources:
deployment.apps/frontend created
service/frontend created
Note:
La configuration de nginx est présente dans l'image du container. Une meilleure approche serait d'utiliser une ConfigMap, afin de pouvoir changer la configuration plus facilement.Interagir avec le Service frontend
Une fois que vous avez créé un Service de type LoadBalancer, vous pouvez utiliser cette commande pour trouver l'IP externe :
kubectl get service frontend --watch
Cela affiche la configuration du Service frontend et surveille les changements.
Initialement, l'IP externe est indiquée comme <pending> :
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
frontend LoadBalancer 10.51.252.116 <pending> 80/TCP 10s
Dès qu'une IP externe est attribuée, cependant,
la configuration est mise à jour pour inclure la nouvelle IP sous l'en-tête EXTERNAL-IP :
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
frontend LoadBalancer 10.51.252.116 XXX.XXX.XXX.XXX 80/TCP 1m
Cette IP peut maintenant être utilisée pour interagir avec le service frontend depuis l'extérieur du cluster.
Envoyer du trafic via le frontend
Le frontend et le backend sont maintenant connectés. Vous pouvez accéder à l'endpoint en utilisant la commande curl sur l'IP externe de votre Service frontend.
curl http://${EXTERNAL_IP} # à remplacer par l'ip externe affichée précédemment
Le résultat affiche le message généré par le backend :
{"message":"Hello"}
Cleanup
Pour supprimer les Services, saisissez cette commande :
kubectl delete services frontend backend
Pour supprimer les Deployments, les ReplicaSets et les Pods qui exécutent les applications backend et frontend, saisissez cette commande :
kubectl delete deployment frontend backend
A suivre
- En savoir plus sur les Services
- En savoir plus sur les ConfigMaps
- En savoir plus sur le DNS pour les Services et les Pods