# Connecter un Frontend à un Backend en utilisant les Services
LLMS index: [llms.txt](/llms.txt)
---
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 `hello` en 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 `LoadBalancer` pour 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, entrez kubectl version.
Cette tâche utilise les [Services avec des équilibreurs de charge externes](/docs/tasks/access-application-cluster/create-external-load-balancer/),
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](/docs/concepts/services-networking/service/#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 :
```shell
kubectl apply -f https://k8s.io/examples/service/access/backend-deployment.yaml
```
Affichez les informations du Deployment:
```shell
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:
Mounts:
Volumes:
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing True NewReplicaSetAvailable
OldReplicaSets:
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 :
```shell
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 :
```shell
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.
