Déployer sur Kubernetes

Table des matières

Prérequis

Téléchargez et installez Docker Desktop comme décrit dans Obtenir Docker.
Suivez la conteneurisation d'une application dans la Partie 2.
Assurez-vous que Kubernetes est activé dans Docker Desktop : Si Kubernetes n'est pas en cours d'exécution, suivez les instructions dans Orchestration pour terminer sa configuration.

Maintenant que vous avez démontré que les composants individuels de votre application fonctionnent comme des conteneurs autonomes, il est temps de les faire gérer par un orchestrateur comme Kubernetes. Kubernetes fournit de nombreux outils pour la mise à l'échelle, la mise en réseau, la sécurisation et la maintenance de vos applications conteneurisées, bien au-delà des capacités des conteneurs eux-mêmes.

Afin de valider que votre application conteneurisée fonctionne bien sur Kubernetes, vous utiliserez l'environnement Kubernetes intégré de Docker Desktop directement sur votre machine de développement pour déployer votre application, avant de la transmettre pour qu'elle s'exécute sur un cluster Kubernetes complet en production. L'environnement Kubernetes créé par Docker Desktop est complet, ce qui signifie qu'il dispose de toutes les fonctionnalités Kubernetes dont votre application bénéficiera sur un vrai cluster, accessibles depuis le confort de votre machine de développement.

Décrire les applications à l'aide de YAML Kubernetes

Tous les conteneurs dans Kubernetes sont planifiés en tant que pods, qui sont des groupes de conteneurs colocalisés qui partagent certaines ressources. De plus, dans une application réaliste, vous ne créez presque jamais de pods individuels. Au lieu de cela, la plupart de vos charges de travail sont planifiées en tant que déploiements, qui sont des groupes de pods évolutifs maintenus automatiquement par Kubernetes. Enfin, tous les objets Kubernetes peuvent et doivent être décrits dans des manifestes appelés fichiers YAML Kubernetes. Ces fichiers YAML décrivent tous les composants et configurations de votre application Kubernetes, et peuvent être utilisés pour créer et détruire votre application dans n'importe quel environnement Kubernetes.

Vous avez déjà écrit un fichier YAML Kubernetes de base dans la partie de présentation de l'orchestration de ce tutoriel. Maintenant, vous pouvez écrire un fichier YAML légèrement plus sophistiqué pour exécuter et gérer votre application de tâches, l'image de conteneur getting-started créée dans la Partie 2 du tutoriel de démarrage rapide. Placez ce qui suit dans un fichier appelé bb.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: bb-demo
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      bb: web
  template:
    metadata:
      labels:
        bb: web
    spec:
      containers:
        - name: bb-site
          image: getting-started
          imagePullPolicy: Never
---
apiVersion: v1
kind: Service
metadata:
  name: bb-entrypoint
  namespace: default
spec:
  type: NodePort
  selector:
    bb: web
  ports:
    - port: 3000
      targetPort: 3000
      nodePort: 30001

Dans ce fichier YAML Kubernetes, il y a deux objets, séparés par --- :

Un Déploiement, décrivant un groupe évolutif de pods identiques. Dans ce cas, vous n'obtiendrez qu'une seule réplique, ou copie de votre pod, et ce pod (qui est décrit sous la clé template:) ne contient qu'un seul conteneur, basé sur votre image getting-started de l'étape précédente de ce tutoriel.
Un service NodePort, qui acheminera le trafic du port 30001 sur votre hôte vers le port 3000 à l'intérieur des pods vers lesquels il achemine, vous permettant d'atteindre votre application de tâches depuis le réseau.

De plus, remarquez que bien que le YAML Kubernetes puisse paraître long et compliqué au premier abord, il suit presque toujours le même schéma :

apiVersion, qui indique l'API Kubernetes qui analyse cet objet
kind indiquant de quel type d'objet il s'agit
Quelques metadata appliquant des choses comme des noms à vos objets
spec spécifiant tous les paramètres et configurations de votre objet.

Déployer et vérifier votre application

Dans un terminal, naviguez jusqu'à l'endroit où vous avez créé bb.yaml et déployez votre application sur Kubernetes :
$ kubectl apply -f bb.yaml
Vous devriez voir une sortie qui ressemble à ce qui suit, indiquant que vos objets Kubernetes ont été créés avec succès :
deployment.apps/bb-demo created service/bb-entrypoint created

Assurez-vous que tout a fonctionné en listant vos déploiements :

$ kubectl get deployments

si tout va bien, votre déploiement devrait être listé comme suit :

NAME      READY   UP-TO-DATE   AVAILABLE   AGE
bb-demo   1/1     1            1           40s

Cela indique que tous les pods que vous avez demandés dans votre YAML sont en cours d'exécution. Faites la même vérification pour vos services :

$ kubectl get services

NAME            TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
bb-entrypoint   NodePort    10.106.145.116   <none>        3000:30001/TCP   53s
kubernetes      ClusterIP   10.96.0.1        <none>        443/TCP          138d

En plus du service kubernetes par défaut, nous voyons notre service bb-entrypoint, acceptant le trafic sur le port 30001/TCP.

Ouvrez un navigateur et visitez votre application de tâches à localhost:30001. Vous devriez voir votre application de tâches, la même que lorsque vous l'avez exécutée en tant que conteneur autonome dans la Partie 2 du tutoriel.
Une fois satisfait, détruisez votre application :
$ kubectl delete -f bb.yaml

Conclusion

À ce stade, vous avez utilisé avec succès Docker Desktop pour déployer votre application dans un environnement Kubernetes complet sur votre machine de développement. Vous pouvez maintenant ajouter d'autres composants à votre application et profiter de toutes les fonctionnalités et de la puissance de Kubernetes, directement sur votre propre machine.

En plus du déploiement sur Kubernetes, vous avez également décrit votre application sous forme de fichier YAML Kubernetes. Ce simple fichier texte contient tout ce dont vous avez besoin pour créer votre application dans un état de fonctionnement. Vous pouvez l'enregistrer dans un système de contrôle de version et le partager avec vos collègues. Cela vous permet de distribuer vos applications à d'autres clusters (comme les clusters de test et de production qui viennent probablement après vos environnements de développement).

Références Kubernetes

Une documentation plus approfondie pour tous les nouveaux objets Kubernetes utilisés dans cet article est disponible ici :