Faut-il utiliser Kubernetes ? La réponse, en bref, dépend. Mais laissez-moi vous accompagner dans mon cheminement vers la compréhension de Kubernetes, et peut-être que cela vous aidera à trouver votre propre réponse.
J'ai écrit un livre entier pour vous guider sur le chemin de Kubernetes (obtenez la version préliminaire du MEAP de Manning ici). Mais avant de parler du livre, parlons un peu du déploiement de logiciels et de mon parcours.
Il y a près de vingt ans, je me suis lancé pour la première fois dans le déploiement d'un logiciel sur l'internet afin de publier mon premier site web. À l'époque, je ne savais même pas par où commencer. Quelques amis de la famille ont eu la gentillesse de me donner quelques conseils :
a suggéré l'entrepreneur :
"Ce livre sur Dreamweaver et HTML vous permettra de ne pas dépenser un centime pour créer votre premier site web".
L'administrateur système et le développeur ont adopté une approche différente :
"Laissez-moi vous installer un serveur FTP pour héberger votre site web ; je ne vous recommande pas d'apprendre à gérer des serveurs".
Ces deux personnes m'ont permis d'arriver là où je suis aujourd'hui, mais l'une d'entre elles a involontairement retardé mon apprentissage pendant longtemps. Pouvez-vous deviner qui ?
En repensant à mes débuts, il apparaît clairement que les connaissances fondamentales et l'apprentissage par l'expérience pratique ont joué un rôle crucial dans mon parcours. Les conseils de l'entrepreneur m'ont poussé à me plonger dans le développement web, tandis que les conseils de l'administrateur système m'ont appris la valeur des outils qui pouvaient simplifier des tâches complexes.
Cependant, une leçon clé qui a émergé au fil du temps est l'importance de comprendre les principes fondamentaux, même lorsque l'on utilise des outils de haut niveau. Cette expérience d'apprentissage précoce a été la genèse de mon intérêt pour Kubernetes, une technologie qui allait avoir un impact significatif sur ma trajectoire professionnelle. Pour comprendre Kubernetes, comme tout autre outil, il faut maîtriser la technologie sous-jacente.
Kubernetes est-il complexe ? Oui. Est-il parfait ? Non. Est-il adapté à toutes les situations ? Non. Mais la question de savoir si vous devez ou non utiliser Kubernetes se résume souvent à votre compréhension de la technologie sous-jacente qui rend Kubernetes si puissant et à la façon dont vous pouvez l'utiliser pour gérer et protéger vos logiciels.
Pour ceux qui se demandent "Qu'est-ce que Kubernetes ?" ou qui ne sont peut-être pas encore familiers avec le terme "Docker" (au-delà du type de pantalon) et son association avec les conteneurs, permettez-moi de vous expliquer.
Les applications évoluent constamment, chaque composant, de la base de données au langage de programmation, publiant fréquemment de nouvelles versions. Le suivi de plusieurs versions de chaque application et de nombreuses itérations de composants tiers peut devenir pénible à gérer, en particulier lorsqu'il s'agit de versions plus anciennes ou héritées qui ne bénéficient pas d'un support général. Même les versions prises en charge des logiciels comportent de nombreuses dépendances au niveau du système et de l'installation par des tiers, ce qui peut compliquer l'exécution du logiciel, sans parler de son utilisation en tant que composant de votre application.
Avec le temps, tous les logiciels finissent par devenir obsolètes et sont remplacés par des versions plus récentes. Le défi consiste à faire fonctionner les anciens logiciels lorsque c'est nécessaire. Même des changements apparemment minimes dans les logiciels peuvent avoir un impact considérable sur les applications modernes. Par exemple, Python 2.7 (par rapport à la version la plus récente Python 3.11) était intégré à Mac OS X d'Apple. Python 2.7 avait une syntaxe étrange pour la sortie de texte vers la ligne de commande : `print "this thing" ` au lieu de la version plus logique de `print("this thing")` qui se trouve dans les versions plus récentes de Python. Ce seul élément de syntaxe peut casser toute une application Python à cause de parenthèses manquantes.
Bien que l'utilisation d'anciennes versions de logiciels puisse s'avérer peu pratique, il existe certainement des situations dans lesquelles il est nécessaire d'utiliser des logiciels plus anciens. Mais comment ?
Nous pourrions passer du temps à trouver une pièce de matériel ou une image VM datant d'un moment précis qui nous permettrait d'exécuter un vieux logiciel. Nous pouvons aussi nous tourner vers les conteneurs, un concept lancé par Docker. Les conteneurs sont des applications autonomes emballées avec leurs dépendances que nous pouvons modifier à notre guise. Leur unique argument de vente est leur capacité à passer d'un système à l'autre de manière transparente.
Voici un exemple de fichier Docker qui utilise Python 2.7 comme élément de base d'un conteneur :
```dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
``````dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
```Ce fichier Docker indique à Docker ce qui est nécessaire pour construire ce nouveau conteneur avec le code qui existe sur notre machine locale et le chemin local sous `/src`. Les Dockerfiles peuvent être beaucoup plus compliqués, mais cet exemple montre à quel point l'utilisation de Docker peut être simple.
Pour construire et exécuter cette application conteneurisée, c'est aussi simple que cela :
```bash
docker build -f Dockerfile -t hello-python:v1 .
docker run hello-python -p 8000:8000
```Sans la conteneurisation, nous devrions installer Python 2.7 directement sur une machine, ce qui n'est presque jamais simple. Docker et d'autres conteneurs peuvent rendre nos applications portables, et vous pouvez remplacer Python 2.7 dans cet exemple par presque n'importe quel langage ou outil open-source.
Cependant, le problème se pose lorsque l'on veut mettre à jour une application conteneurisée, surtout en production. Localement, la mise à jour d'un conteneur est simple. On arrête l'exécution du conteneur, on le reconstruit, puis on l'exécute à nouveau. En production, cependant, la mise à jour d'un conteneur peut être effectuée de la même manière, mais nous courons le risque d'un arrêt majeur si la construction échoue.
C'est là qu'intervient Kubernetes. Kubernetes aide à gérer l'acheminement du trafic vers des conteneurs spécifiques et supervise le nombre de conteneurs en cours d'exécution à un moment donné. Si un conteneur tombe en panne, Kubernetes facilite le retour aux versions précédentes avec un minimum de temps d'arrêt, voire aucun.
La configuration pour déployer un conteneur sur Kubernetes s'appelle un manifeste. Voici un exemple de manifeste relativement simple :
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-py-deploy
spec:
replicas: 3
selector:
matchLabels:
app: hello-py-deploy
template:
metadata:
labels:
app: hello-py-deploy
spec:
containers:
- name: hello-py-container
image: jmitchel3/hello-python:v1
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: hello-py-service
spec:
type: LoadBalancer
ports:
- name: http
port: 80
targetPort: 8080
protocol: TCP
selector:
app: hello-py-deploy
```Dans l'exemple ci-dessus, le manifeste Kubernetes formaté en yaml prévoit deux ressources : un service d'équilibrage de charge et un déploiement. L'équilibreur de charge permet d'acheminer le trafic vers notre déploiement. Via `replicas : 3`, de notre conteneur déclaré `hello-python:v1`, notre déploiement exécute 3 versions.
Maintenant, lorsque nous voulons mettre à jour la version déployée, nous pouvons simplement changer `hello-python:v1` en `hello-python:v2` et Kubernetes mettra gracieusement à jour notre application. Et si quelque chose se passe mal, il reviendra à `hello-py-deploy:v1`. Kubernetes rend ce processus indolore et facile à gérer. Les manifestes peuvent facilement être contrôlés par version avec git, ce qui nous permet d'être très granulaires avec nos capacités de retour en arrière. Kubernetes fait partie intégrante du déploiement car il fournit un cadre pour l'automatisation, la mise à l'échelle et la gestion des applications conteneurisées, garantissant la résilience et l'efficacité du système dans nos paysages logiciels de plus en plus complexes.
J'ai voulu passer en revue quelques-unes des méthodes qui m'ont permis de découvrir comment Kubernetes pouvait simplifier le déploiement de mes applications. Pour tirer le meilleur parti de Kubernetes, il m'a fallu plusieurs étapes, mais le voyage en valait la peine. Dans Road to Kubernetes, nous ferons un voyage pour déployer des applications à l'aide de diverses technologies qu'il est important de comprendre avant de se lancer dans Kubernetes et d'autres pratiques de déploiement modernes.
Dans Road to Kubernetes, nous verrons comment :
- Gérer des dépôts git sur des plateformes auto-hébergées ou en nuage.
- Déployer les applications Python et Node.js via des VM basées sur le cloud avec git
- Automatiser la configuration et le déploiement des machines virtuelles avec Ansible
- Conteneuriser et déployer des applications avec Docker et Docker Compose
- Exécuter des conteneurs directement sur des machines virtuelles sans orchestration
- Pousser et héberger des conteneurs avec le registre DockerHub
- Déployer des applications conteneurisées sur Kubernetes
- Mettre en œuvre des applications publiques et privées sur Kubernetes.
- Configurer les équilibreurs de charge pour le trafic HTTP et HTTPs
- Utiliser les techniques CI/CD avec Github Actions et l'alternative open-source de Nectos
- et plus encore !
Le déploiement est le test ultime de votre logiciel. Road to Kubernetes condense quinze années d'apprentissage du déploiement en un guide accessible et pratique. Il vous emmène du déploiement de logiciels à partir de zéro jusqu'à la mise en œuvre de la puissance de Kubernetes. Vous apprendrez des pratiques de déploiement durables que vous pouvez utiliser avec n'importe quel langage et n'importe quel type d'application web, comment créer des applications portables qui peuvent passer d'une option de déploiement à l'autre et d'un fournisseur de cloud à l'autre, et vous verrez à quel point il est possible d'utiliser Kubernetes pour des projets de n'importe quelle taille.
Pour commencer à comprendre Kubernetes, obtenez la version préliminaire du MEAP de Manning ici.
Commentaires