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 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, 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

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

Dernière modification June 20, 2024 at 12:44 PM PST: Sync changest from andygol/k8s-website (36d05bc8a1)