Cette page a été traduite par l'API Cloud Translation.

Déployer une application

Ce document explique comment déployer une application sur Google Distributed Cloud.

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

La procédure suivante permet de créer un objet 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 l'objet 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 formatés sur l'objet Déploiement, y compris les ReplicaSet :

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 :

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 à noter à propos du service dans cet exercice :
- Tous les pods comportant les étiquettes app: metrics et department: sales sont membres du service. Ces libellés sont attribués aux pods dans my-deployment.
- 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 disposer d'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 Dockerfile et le code source de l'application.
Créez le service sur votre cluster à l'aide de kubectl apply :
```
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 objet Service possède un clusterIP et une adresse IP externe. Il comporte également un nodePort, un port et un targetPort.

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

À titre d'exemple, prenons les 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 à l'adresse 192.168.1.13 sur le port TCP 80. La requête est acheminée vers votre équilibreur de charge, puis transmise à 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 attribue des ports de nœud aux services de type LoadBalancer. Ces allocations peuvent rapidement épuiser les ports de nœuds disponibles parmi les 2 768 attribués à votre cluster. Pour économiser des ports de nœud, désactivez l'allocation de ports de nœud 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'allouer des ports de nœud aux services LoadBalancer. Pour en savoir plus, consultez Désactiver l'allocation NodePort de l'équilibreur de charge dans la documentation 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

Supprimez votre service

Pour supprimer votre service :

Utilisez kubectl delete pour supprimer votre 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.

Supprimez votre objet Déploiement

Pour supprimer votre objet Déploiement

Utilisez kubectl delete pour supprimer votre votre objet 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.

Étape suivante

Créer un service et un objet Ingress

Déployer une application Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.