Déployer une application

Ce document explique comment déployer une application sur GKE sur une solution Bare Metal.

Avant de commencer

Pour déployer une charge de travail, vous devez disposer d'un cluster d'utilisateur, hybride ou autonome capable d'exécuter des charges de travail.

Créer un déploiement

Les étapes suivantes permettent de créer un déploiement sur votre cluster:

Copiez le fichier manifeste suivant dans un fichier nommé my-deployment.yaml :

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"

Créez le déploiement à l'aide de kubectl apply:
```
kubectl apply -f my-deployment.yaml --kubeconfig CLUSTER_KUBECONFIG
```
Remplacez CLUSTER_KUBECONFIG par le chemin d'accès au fichier kubeconfig de votre cluster.
Obtenez des informations de base sur votre déploiement pour vérifier qu'il a bien été créé:
```
kubectl get deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG
```
Le résultat indique que l'objet Déploiement comporte trois pods tous disponibles :
```
NAME            READY   UP-TO-DATE   AVAILABLE   AGE
my-deployment   3/3     3            3           27s
```

Répertoriez les pods dans votre objet Déploiement :

kubectl get pods --kubeconfig CLUSTER_KUBECONFIG

Le résultat indique que votre objet Déploiement comporte trois pods en cours d'exécution :

NAME                             READY   STATUS    RESTARTS   AGE
my-deployment-869f65669b-5259x   1/1     Running   0          34s
my-deployment-869f65669b-9xfrs   1/1     Running   0          34s
my-deployment-869f65669b-wn4ft   1/1     Running   0          34s

Obtenez des informations détaillées sur votre objet Déploiement :

kubectl get deployment my-deployment --output yaml --kubeconfig CLUSTER_KUBECONFIG

Le résultat fournit des détails sur les spécifications et l'état de l'objet Déploiement :

apiVersion: apps/v1
kind: Deployment
metadata:
  ...
  generation: 1
  name: my-deployment
  namespace: default
  ...
spec:
  ...
  replicas: 3
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: metrics
      department: sales
  ...
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
        imagePullPolicy: IfNotPresent
        name: hello
        resources: {}
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
status:
  availableReplicas: 3
  conditions:
  - lastTransitionTime: "2023-06-29T16:17:17Z"
    lastUpdateTime: "2023-06-29T16:17:17Z"
    message: Deployment has minimum availability.
    reason: MinimumReplicasAvailable
    status: "True"
    type: Available
  - lastTransitionTime: "2023-06-29T16:17:12Z"
    lastUpdateTime: "2023-06-29T16:17:17Z"
    message: ReplicaSet "my-deployment-869f65669b" has successfully progressed.
    reason: NewReplicaSetAvailable
    status: "True"
    type: Progressing
  observedGeneration: 1
  readyReplicas: 3
  replicas: 3
  updatedReplicas: 3

Décrivez votre objet Déploiement :

kubectl describe deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG

Le résultat affiche des détails bien mis en forme sur le déploiement, y compris le ReplicaSet associé:

Name:                   my-deployment
Namespace:              default
CreationTimestamp:      Thu, 29 Jun 2023 16:17:12 +0000
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=metrics,department=sales
Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=metrics
          department=sales
  Containers:
  hello:
    Image:        us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
    Port:         <none>
    Host Port:    <none>
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   my-deployment-869f65669b (3/3 replicas created)
Events:
  Type    Reason             Age    From                   Message
  ----    ------             ----   ----                   -------
  Normal  ScalingReplicaSet  6m50s  deployment-controller  Scaled up replica set my-deployment-869f65669b to 3

Créer un service de type `LoadBalancer`

Une façon d'exposer votre objet Déploiement à des clients extérieurs à votre cluster consiste à créer un objet Service Kubernetes de type LoadBalancer.

Pour créer un service de type LoadBalancer, procédez comme suit:

Copiez le fichier manifeste suivant dans un fichier nommé my-service.yaml :
```
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: metrics
    department: sales
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
```
Voici les points importants à comprendre à propos du service au cours de cet exercice:
- Tous les pods comportant les étiquettes app: metrics et department: sales sont membres du service. Les pods de my-deployment sont associés à ces étiquettes.
- Lorsqu'un client envoie une requête au service sur le port TCP 80, la requête est transmise à un pod membre sur le port TCP 8080.
- Chaque pod membre doit avoir un conteneur qui écoute sur le port TCP 8080.
Par défaut, le conteneur hello-app écoute sur le port TCP 8080. Vous pouvez voir ce paramètre de port en consultant le fichier Dockerfile et le code source de l'application.
Utilisez kubectl apply pour créer le service sur votre cluster:
```
kubectl apply -f my-service.yaml --kubeconfig CLUSTER_KUBECONFIG
```
Remplacez CLUSTER_KUBECONFIG par le chemin d'accès au fichier kubeconfig de votre cluster.
Affichez votre service :
```
kubectl get service my-service --output yaml --kubeconfig CLUSTER_KUBECONFIG
```
Le résultat ressemble à ce qui suit :
```
apiVersion: v1
kind: Service
metadata:
  ...
  name: my-service
  namespace: default
  ...
spec:
  allocateLoadBalancerNodePorts: true
  clusterIP: 10.96.2.165
  clusterIPs:
  - 10.96.2.165
  externalTrafficPolicy: Cluster
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 31565
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: metrics
    department: sales
  sessionAffinity: None
  type: LoadBalancer
status:
  loadBalancer:
    ingress:
    - ip: 192.168.1.13
```
Dans le résultat précédent, vous pouvez voir que votre service dispose d'un clusterIP et d'une adresse IP externe. Il comporte également un nodePort, un port et un targetPort.

La clusterIP n'est pas pertinente pour cet exercice. L'adresse IP externe (status.loadBalancer.ingress.ip) provient de la plage d'adresses que vous avez spécifiée lors de la définition des pools d'adresses de l'équilibreur de charge (spec.loadBalancer.addressPools) dans le fichier de configuration du cluster.

Prenons l'exemple des valeurs affichées dans le résultat précédent pour votre service:
- Adresse IP externe: 192.168.1.13
- port : 80
- nodePort : 31565
- targetPort : 8080
Un client envoie une requête à 192.168.1.13 sur le port TCP 80. La requête est acheminée vers votre équilibreur de charge, puis transférée à un pod membre sur le port TCP 8080.
Appelez votre service :
```
curl INGRESS_IP_ADDRESS
```
Remplacez INGRESS_IP_ADDRESS par l'adresse IP d'entrée dans la section status du service que vous avez récupérée à l'étape précédente (status.loadBalancer.ingress).

Le résultat affiche un message Hello, world! :
```
Hello, world!
Version: 2.0.0
Hostname: my-deployment-869f65669b-wn4ft
```

Limites de ports LoadBalancer

Le type LoadBalancer est une extension du type NodePort. Ainsi, un service de type LoadBalancer a une adresse IP de cluster ainsi qu'une ou plusieurs valeurs nodePort. Par défaut, Kubernetes alloue des ports de nœud aux services de type LoadBalancer. Ces allocations peuvent rapidement épuiser les ports de nœud disponibles parmi les 2 768 alloués à votre cluster. Pour enregistrer les ports des nœuds, désactivez l'allocation de ports des nœuds de l'équilibreur de charge en définissant le champ allocateLoadBalancerNodePorts sur false dans la spécification du service LoadBalancer. Ce paramètre empêche Kubernetes d'attribuer des ports de nœud aux services LoadBalancer. Pour en savoir plus, consultez la section Désactiver l'allocation NodePort de l'équilibreur de charge dans la documentation de Kubernetes.

Voici un fichier manifeste permettant de créer un service qui n'utilise aucun port de nœud:

apiVersion: v1
kind: Service
metadata:
  name: service-does-not-use-nodeports
spec:
  selector:
    app: my-app
  type: LoadBalancer
  ports:
  - port: 8000
  # Set allocateLoadBalancerNodePorts to false
  allocateLoadBalancerNodePorts: false

Supprimer votre service

Pour supprimer votre service:

Utilisez kubectl delete pour supprimer l'objet Service de votre cluster:
```
kubectl delete service my-service --kubeconfig CLUSTER_KUBECONFIG
```
Vérifiez que votre service a été supprimé :
```
kubectl get services --kubeconfig CLUSTER_KUBECONFIG
```
Le résultat n'affiche plus my-service.

Supprimer votre déploiement

Pour supprimer votre déploiement, procédez comme suit:

Utilisez kubectl delete pour supprimer le déploiement de votre cluster:
```
kubectl delete deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG
```
Vérifiez que votre objet Déploiement a bien été supprimé :
```
kubectl get deployments --kubeconfig CLUSTER_KUBECONFIG
```
Le résultat n'affiche plus my-deployment.

Étapes suivantes

Créer un service et un objet Ingress