Principes de base de Docker - Orchestration - Configurer et utiliser l'environnement Kubernetes sur la machine de développement

Conditions préalables

Téléchargez et installez Docker Desktop, voir l' introduction et l'installation pour plus de détails .
Terminez la conteneurisation de l'application dans la deuxième partie .
Assurez-vous que Kubernetes est activé dans votre Docker Desktop:
- Mac : cliquez sur l'icône Docker dans la barre de menus, accédez à Préférences et assurez-vous qu'il y a un voyant vert à côté de «Kubernetes».
- Windows : cliquez sur l'icône Docker dans la barre d'état système, accédez à Paramètres et assurez-vous qu'il y a un voyant vert à côté de «Kubernetes».
  Si Kubernetes n'est pas en cours d'exécution, suivez les instructions de la vue d' ensemble de l' orchestration de ce didacticiel pour terminer la configuration.

introduction

Maintenant que nous avons démontré que les différents composants de l'application s'exécutent en tant que conteneurs indépendants, nous pouvons désormais faire en sorte qu'ils soient gérés 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 qui dépassent les capacités du conteneur lui-même.

Afin de vérifier si notre application conteneurisée peut bien fonctionner sur Kubernetes, nous utiliserons l'environnement Kubernetes intégré de Docker Desktop sur la machine de développement pour déployer notre application, puis la remettre à un cluster Kubernetes complet dans l'environnement de production. sur. L'environnement Kubernetes créé par Docker Desktop est entièrement fonctionnel, ce qui signifie qu'il dispose de toutes les fonctionnalités Kubernetes dont votre application profitera sur un vrai cluster, et peut être facilement accessible via votre machine de développement.

Décrire l'application à l'aide de Kubernetes YAML

Tous les conteneurs de Kubernetes sont organisés sous forme de pods , qui sont des groupes de conteneurs au même emplacement partageant certaines ressources. De plus, dans les applications réelles, nous ne créons presque jamais de pods individuels; au lieu de cela, la plupart de nos charges de travail sont planifiées en tant que déploiements , qui sont des groupes évolutifs de pods qui sont automatiquement gérés par Kubernetes. Enfin, tous les objets Kubernetes peuvent et doivent être décrits dans un manifeste appelé fichier YAML Kubernetes . Ces fichiers YAML décrivent tous les composants et configurations d'une application Kubernetes et peuvent être utilisés pour créer et détruire facilement des applications dans n'importe quel environnement Kubernetes.

Vous avez écrit un fichier Kubernetes YAML très basique dans la section Présentation de l' orchestration de ce didacticiel . Maintenant, écrivons un fichier YAML un peu plus compliqué pour exécuter et gérer notre application de tableau d'affichage. Le contenu suivant dans un bb.yamlfichier nommé :
```
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: bulletinboard:1.0
---
apiVersion: v1
kind: Service
metadata:
  name: bb-entrypoint
  namespace: default
spec:
  type: NodePort
  selector:
    bb: web
  ports:
  - port: 8080
    targetPort: 8080
    nodePort: 30001
```
Dans ce fichier YAML Kubernetes, il y a deux objets à ---séparer:
- Un 部署(Deployment), décrivant un groupe de pods identiques qui peuvent être mis à l'échelle. Dans ce cas, vous obtiendrez une 副本(replica), c'est-à-dire une copie de votre pod, et le pod (dans la template:description de la clé) un seul conteneur, le conteneur basé sur le déroulement actuel de l'étape précédente dans bulletinboard:1.0le miroir.
- Un NodePortservice qui passera de la redirection de port 30001 sur votre hôte au port 8080 dans lequel il est acheminé vers les pods, vous permettant d'accéder à votre réseau à partir d'une application de tableau d'affichage.
Notez également que bien que Kubernetes YAML puisse sembler long et compliqué au début, il suit presque toujours le même modèle:
- apiVersion, Indiquant l'API Kubernetes qui analyse l'objet
- kindPour indiquer de quel type d'objet il s'agit
- metadataPour appliquer des choses comme des noms à des objets
- spec, Spécifiez tous les paramètres et configurations de l'objet

Déployer et vérifier l'application

Dans le terminal, accédez à votre bb.yamlposition créée et déployez l'application sur Kubernetes:
```
kubectl apply -f bb.yaml
```
Vous verrez la sortie ci-dessous, indiquant que l'objet Kubernetes a été créé avec succès:
```
deployment.apps/bb-demo created
service/bb-entrypoint created
```

Assurez-vous que tout est en ordre en listant le déploiement:

kubectl get deployments

Si tout se passe bien, votre déploiement doit être répertorié comme suit:

NAME      DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
bb-demo   1         1         1            1           48s

Cela signifie que "tous" les pods que vous avez demandés dans YAML sont opérationnels. Faites la même vérification pour votre service:

kubectl get services

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

En plus de la kubernetessortie par défaut du service, nous voyons également le bb-entrypointservice qui accepte le trafic sur le port 30001 / TCP.

Ouvrez un navigateur et visitez votre tableau d'affichage localhost:30001; vous verrez votre tableau d'affichage, tout comme lorsque nous l' exécutons en tant que conteneur autonome dans la deuxième partie du démarrage rapide de Docker .
Une fois satisfait, supprimez votre application:
```
kubectl delete -f bb.yaml
```

en conclusion

Jusqu'à présent, nous avons déployé avec succès notre application dans un environnement Kubernetes entièrement fonctionnel sur la machine de développement à l'aide de Docker Desktop. Nous n'avons pas beaucoup travaillé sur Kubernetes, mais maintenant la porte a été ouverte;
nous n'avons pas beaucoup travaillé sur Kubernetes, mais la porte a été ouverte; vous pouvez commencer à ajouter d'autres composants à votre application et profiter de toutes les fonctionnalités et les fonctions de Kubernetes sont sur votre propre machine.

Outre le déploiement sur Kubernetes, nous décrivons également l'application en tant que fichier YAML Kubernetes. Ce simple fichier texte contient tout ce dont nous avons besoin pour créer notre application en cours d'exécution. Nous pouvons l'enregistrer dans le contrôle de version et le partager avec des collègues, ce qui nous permet de distribuer facilement l'application à d'autres clusters (tels que les clusters de test et de production qui peuvent apparaître après l'environnement de développement).

Références Kubernetes

Pour plus de documentation sur tous les nouveaux objets Kubernetes utilisés dans cet article, veuillez consulter:

Document chinois Kubernetes: https://kubernetes.io/zh/docs/home/

Auteur:
Traducteur du site officiel de Docker : Technical Zemin
Editeur: Technical Verses
links: English text