Kubernetes : Un univers très très très …. vaste
Dans l’univers des DevOps / SRE et autres Platform Engineering, Kubernetes est plébiscité comme le standard incontournable pour l’orchestration des conteneurs. Pourtant, pour de nombreux padawan, plonger dans cet écosystème revient à explorer la bordure extérieure où chaque parsecs parcouru peut vous entraîner dans la gueule géante d’un exogorth. Entre les fichiers YAML, aussi énigmatique que le jargon des pillards Tusken et la multitude d’acronymes à déchiffrer, Kubernetes peut rapidement devenir un véritable casse-tête, même pour les Kaminoans les plus avisés.
Le problème principal ?
Kubernetes n’est pas simplement un outil. C’est le moteur d’un écosystème complexe, et comme tout grand pouvoir, il implique de grandes responsabilités. Que ce soit pour la gestion des multiples configurations, les montées de version, la sécurité, ou encore la scalabilité, Kubernetes exige une maîtrise technique rigoureuse. Pour de nombreuses équipes DevOps et SRE, gérer quotidiennement ces aspects peut devenir un véritable défi.
La solution : Werf, votre copilote de confiance
Imaginez-vous Han Solo aux commandes du Faucon Millenium, sans son fidèle copilote Chewbacca. Aussi talentueux soit-il, piloter seul dans l’espace serait une mission périlleuse. C’est exactement ce que représente Werf ! C’est le Chewbacca de vos déploiements Kubernetes, toujours là pour vous épauler. Grâce à Werf, chaque commande de build et de déploiement devient aussi simple que de passer en vitesse lumière avec un générateur Hyperdrive T-14.
Un nouvel espoir
Si déployer une application sur Kubernetes vous semble aussi intimidant que de piloter un Faucon Millenium dans un champ d’astéroïdes, rassurez-vous, vous n’êtes pas seul. Même les DevOps les plus aguerris peuvent parfois y laisser des plumes.
Mais que diriez-vous de maîtriser cette Force et de devenir un véritable DevOps Master?
Prêts à maîtriser Kubernetes ? Alors attachez vos ceintures, et que la Force soit avec vous !
Werf se distingue par sa capacité à automatiser et simplifier les processus de build et de déploiement, deux aspects essentiels pour bien utiliser Kubernetes. Il est particulièrement puissant s’il est utilisé sur une solution comme Kontainers que j’utilise quotidiennement.
Gérez vos images Docker en toute tranquillité
Werf se charge de tout ce qui concerne le build des images Docker. Avec un seul fichier Dockerfile et une simple commande, vous pouvez orchestrer l’ensemble de votre processus de build. Fini la manipulation de scripts complexes ou la reconstruction complète à chaque modification : le système de cache intelligent des conteneurs sur lequel s’appuie Werf veille à ce que seuls les éléments modifiés soient reconstruits, vous permettant ainsi de gagner un temps précieux.
Le processus est fluide et prévisible, sans mauvaises surprises. Que vous soyez en phase de développement ou prêt à déployer en production, Werf simplifie ces étapes pour que vous puissiez vous concentrer sur l’essentiel :
Installation de Werf sur Linux et macOS
L’installation de Werf est rapide et simple, que vous soyez sous Linux ou macOS. Voici comment procéder.
La commande suivante télécharge et installe automatiquement Werf sur une distribution Linux, en vous évitant toute configuration manuelle compliquée.
curl -L https://werf.io/install.sh | bash
Sur macOS, vous pouvez installer Werf en utilisant Homebrew, le célèbre gestionnaire de paquets populaire pour macOS.
brew install werf
Construire une application Go et HTMX avec Werf
Maintenant que Werf est installé, voyons comment l’utiliser pour construire une application composée d’un backend en Go et d’un frontend en HTMX. Supposons que vous ayez deux répertoires distincts : un pour l’application backend et un autre pour l’interface utilisateur.
1. Structure du projet
Voici un exemple de structure de projet pour cette application :
/my-app
│
├── backend/
│ ├── main.go # Fichiers Go pour le backend
│ └── Dockerfile # Dockerfile pour le backend
│
├── frontend/
│ ├── index.html # Fichier HTML principal avec HTMX
│ ├── static/ # Dossier pour les fichiers statiques
│ └── Dockerfile # Dockerfile pour le frontend
│
└── werf.yaml # Fichier de configuration Werf
2. Dockerfile pour le backend Go (multi-stage build)
Le multi-stage build permet de construire l’application Go dans une première étape, puis de copier uniquement l’exécutable dans une image plus légère pour la production. Cela réduit la taille de l’image finale ainsi que la surface d’attaque.
Voici le contenu du Dockerfile pour Go :
# Étape 1 : Build de l'application Go
FROM golang:1.22-alpine3.20 AS builder
# Répertoire de travail pour la compilation
WORKDIR /app
# Copier les fichiers Go dans le conteneur
COPY go.mod ./
COPY go.sum ./
RUN go mod download
COPY main.go ./
# Compiler l'application Go
RUN go build -o main .
# Étape 2 : Image de production
FROM alpine:3.20
# Répertoire de travail pour la production
WORKDIR /app
# Copier l'exécutable depuis l'étape de build
COPY --from=builder /app/main .
# Exposer le port de l'application
EXPOSE 8080
# Commande pour exécuter l'application
CMD ["./main"]
3. Dockerfile pour le frontend HTMX
Pour déployer le frontend basé sur HTMX, nous allons utiliser un serveur NGINX basé sur alpine afin de servir les fichiers statiques.
Voici un exemple de Dockerfile adapté :
# Utilisation d'une image NGINX légère
FROM nginx:1.27-alpine3.20
# Copier les fichiers HTML et statiques dans le conteneur
COPY ./static /usr/share/nginx/html/static
COPY ./index.html /usr/share/nginx/html
# Exposer le port pour NGINX
EXPOSE 80
4. Fichier werf.yaml
Le fichier werf.yaml est le cœur de la configuration avec Werf. Il définit les images Docker à construire et les étapes de déploiement. Voici un exemple basique de configuration pour ce projet incluant un backend et un frontend :
configVersion: 1
project: padawan-trainer
---
image: backend
dockerfile: ./backend/Dockerfile
---
image: frontend
dockerfile: ./frontend/Dockerfile
Définition :
- configVersion : Version de la configuration de Werf.
- project : Nom du projet, ici padawan-trainer.
- images : les noms des images de conteneur qui seront utilisés par Werf pour identifier le backend et le frontend.
- dockerfile : le chemin relatif pour accéder aux fichiers de définition des conteneurs
Documentation de Werf v1.2
Documentation de Werf v2
5. Build et push des images Docker
Nous arrivons à la dernière étape de ce premier article ! Construire les images Docker pour le backend et le frontend de votre application en une seul commande.
werf build --repo ttl.sh/padawan-trainer --dev
Cette commande va construire et envoyer vos images vers le repo Docker spécifié (dans notre cas : ttl.sh qui est un repo temporaire parfait pour notre exemple) en vous assurant que vos changements sont correctement pris en compte pour un futur déploiement.
Conclusion
Bravo ! Vous avez survécu à ce premier article, vous êtes officiellement un padawan prometteur. Vous avez découvert comment Werf peut simplifier la création d’images Docker, en rendant le processus extrêmement simple.
Mais ce n’est que le début ! Dans un prochain article sur notre blog, nous allons approfondir l’utilisation de Werf pour le déploiement d’applications Kubernetes grâce à Helm. Nous verrons comment Helm et Werf se complètent pour automatiser et simplifier vos déploiements, en mettant en place un processus robuste et fiable.
