Pourquoi l’orchestration des conteneurs est-elle importante ?

Dans cette unité, vous pouvez suivre l’équipe Tailspin pendant qu’elle explore les stratégies pour mettre en œuvre une nouvelle directive de la direction. L’équipe examine comment Kubernetes peut aider à passer à une architecture de microservices.

L’avenir est plus petit

Les choses s'améliorent chez Tailspin. Lors d'un récent séminaire de direction, Andy a présenté les récents succès de son équipe avec Azure DevOps, lesquels ont été bien accueillis. Andy a également présenté une démonstration du projet de preuve de concept récent de l’équipe à l’aide de conteneurs Docker. Ces démonstrations ont conduit à une série de conversations productives sur l’avenir technique de l’organisation. Le lendemain, Andy revient à partager les nouvelles avec l’équipe web Space Game.

Andy: Les choses se sont vraiment bien passées à ma présentation hors site hier. La direction est impressionnée par le travail que nous avons fait jusqu’à présent et nous a donné une affectation spéciale.

Tim: Uh oh. J'ai assez d'expérience pour voir un piège comme celui-là venir de loin.

Andy: Non, c’est une grande opportunité pour nous. La gestion a aimé notre démonstration de conteneur Docker et nous souhaite explorer l’adoption d’une architecture de microservices.

Amita : Microservices ? Comme les applications pour téléphones et montres ?

Andy : Non, les microservices sont des applications classiques, comme notre application web. La principale différence est que au lieu de créer et de déployer une application monolithique unique, nous refactorisons tous les composants qui seraient mieux gérés et gérés en tant que services autonomes. Nous créons ensuite ces services pour qu’ils soient bons à ce qu’ils font et les déploient pour fonctionner indépendamment.

Tim : Je ne suis pas sûr que j’aime le son de ça. Je gère déjà un grand nombre de services dans nos environnements. Je ne sais pas si je veux plus sur mon assiette.

Andy : C’est une préoccupation compréhensible. Heureusement, il existe d’excellents outils pour gérer une multitude de conteneurs dans un environnement donné. Nous avons été sollicités pour expérimenter une solution multiconteneur pour notre application web orchestrée à l’aide de Kubernetes. Ils veulent également savoir comment cela aura un impact sur notre processus DevOps.

Mara : J’ai lu sur Kubernetes. Azure dispose d’une excellente prise en charge par le biais d’Azure Kubernetes Service, et je sais qu’il existe une prise en charge du pipeline pour celle-ci dans Azure DevOps.

Amita : Ce processus semble être complexe. Comment cela aura-t-il un impact sur les tests ?

Mara : Ce ne devrait pas être un changement important. Kubernetes offre un moyen pour nous de déployer sur différents espaces de noms. Cela nous permet de partitionner nos déploiements afin que nous puissions disposer d’environnements entiers dédiés aux tests et à la production. Et étant donné qu’ils s’exécutent tous dans le même cluster et utilisent les mêmes conteneurs, l’expérience de test doit offrir ce que nous attendons de voir en production.

Amita : Sera-t-il difficile de savoir où se trouve chaque environnement ?

Mara : Non, nous pouvons utiliser des environnements Azure DevOps pour ce faire. Vous serez en mesure de savoir où se trouve chaque service et comment il s’y trouve à l’aide du portail. Tout est automatisé par le biais du pipeline. Il n’y aura donc rien à suivre manuellement. La seule préoccupation que j’ai aujourd’hui est l’impact qu’elle aura sur notre expérience de développement pour construire cela.

Andy : La bonne nouvelle est que l’impact est minimal. En supposant que nos projets sont configurés pour créer des conteneurs Docker, il nous suffit de déployer sur Kubernetes certains fichiers manifestes qui décrivent les services et leurs déploiements.

Mara : vous avez pensé à ce que nous allons refactoriser en tant que deuxième conteneur ? Je sais qu’il y a eu plusieurs équipes qui nous demandent de rendre notre classement disponible via une API web.

Andy : Je suis un pas devant toi. J’ai dépliqué le projet Docker hier soir et refactorisé la fonctionnalité de données du classement dans son propre microservice. Cela nous laisse avec un conteneur pour le site web et un autre pour une API de classement. Les deux conteneurs sont configurés pour avoir leurs propres points de terminaison publics que nous pouvons partager avec toute personne qui souhaite utiliser le site ou l’API, quelle que soit la pile technologique utilisée par son application. Si la charge augmente considérablement pour l'une des deux, nous pouvons ajuster la taille de ses conteneurs de manière indépendante.

Mara : Ce projet semble génial ! Commençons à mettre à jour le pipeline de mise en production.

Présentation de Kubernetes

Kubernetes est une plateforme d’orchestration de conteneurs open source permettant d’automatiser le déploiement, la mise à l’échelle et la gestion des applications conteneurisées. Il fournit une infrastructure permettant d’exécuter des systèmes distribués de manière déclarative et réactive et peut exécuter des conteneurs sur plusieurs hôtes, en fournissant une utilisation efficace des ressources et une fiabilité accrue.

L’équipe Tailspin a sélectionné Kubernetes pour ce scénario, car elle répond à tous ses besoins :

• Complexité des déploiements à plusieurs conteneurs : Kubernetes est conçu, d’abord et avant tout, pour automatiser les processus liés au déploiement et à la maintenance des déploiements de conteneurs.

• Cohérence entre les environnements et les étapes : tout comme les conteneurs garantissent un déploiement cohérent pour les applications qu’ils contiennent, Kubernetes garantit un déploiement cohérent pour les conteneurs qu’un cluster gère.

• Prise en charge d’Azure DevOps : Azure DevOps offre une prise en charge de première classe pour l’utilisation de Kubernetes.

• Facilité de développement : l’impact de Kubernetes sur un projet source est comparable à celui de l’ajout de la prise en charge docker, qui est minimale et limitée à la configuration déclarative.

L’adoption de Kubernetes simplifie considérablement le processus d’adoption d’une architecture de microservices qui utilise plusieurs conteneurs Docker.