Mise-En-Place: Simplifiez la Gestion de vos Environnements et Tâches

Mise à jour : 12/01/2025

Vous connaissez ce moment où, dans une discussion technique, quelqu’un mentionne un outil qui semble résoudre tous vos petits tracas de développeur ? C’est exactement ce qui m’est arrivé récemment. J’expliquais à quel point jongler entre asdf, direnv et des solutions pour gérer les secrets pouvait être frustrant. Et là, une suggestion inattendue : “Tu devrais essayer mise-en-place.”

Intrigué, je suis allé voir ce que cet outil avait dans le ventre. mise-en-place, c’est un gestionnaire d’environnements et de tâches qui se targue de combiner les meilleures fonctionnalités de plusieurs outils, tout en apportant sa propre touche de modernité et de simplicité. Mais est-ce vraiment la solution ultime pour les développeurs ?

Pour la suite je vais nommer mise-en-place simplement Mise, car c’est le nom de la CLI.

Entre promesses de rapidité, sécurité renforcée, et une gestion hyper-intuitive des environnements, j’avoue que ma curiosité était piquée. Dans ce guide, je vous emmène découvrir ce que Mise a réellement à offrir – et peut-être, comme moi, vous allez vous laisser séduire. 🚀

Historique de Mise

Mise n’est pas arrivée de nulle part. Cet outil est le fruit d’une réflexion sur les défis modernes du développement, où la diversité des environnements, des versions d’outils, et des workflows complexes pousse à chercher des solutions toujours plus intégrées. À mon avis, c’est une réponse naturelle à des frustrations partagées par beaucoup de développeurs.

L’histoire commence avec des outils comme asdf, célèbre pour la gestion des versions de langages et frameworks, ou direnv, pratique pour automatiser la configuration des environnements. Cependant, chacun de ces outils avait ses limites : une configuration fastidieuse, des performances parfois en retrait, et des fonctionnalités cloisonnées.

C’est dans ce contexte qu’est née l’idée de Mise : unifier les capacités de ces outils tout en proposant une expérience utilisateur plus fluide et sécurisée. Inspiré par les forces des solutions existantes, mais avec l’ambition de les surpasser, Mise s’est aussi démarqué par l’intégration de fonctionnalités comme la gestion des secrets et une compatibilité avec des standards comme .tool-versions.

Derrière cet outil, une vision : réduire la complexité pour que les développeurs puissent se concentrer sur ce qui compte vraiment, c’est-à-dire écrire du code. Aujourd’hui, Mise gagne en popularité dans la communauté, et pour cause : il semble taillé pour répondre aux besoins des développeurs modernes.

Fonctionnalités principales

En explorant Mise, ce qui m’a frappé, c’est à quel point ses fonctionnalités semblent avoir été pensées pour résoudre les problèmes réels des développeurs. Voici un aperçu des points forts qui, à mon avis, rendent cet outil indispensable.

Gestion des versions d’outils : Avec Mise, jongler entre différentes versions de Node.js, Python, ou Terraform devient un jeu d’enfant. Vous pouvez configurer une version spécifique par projet grâce au fichier mise.toml ou à des fichiers standards comme .tool-versions. Par exemple, une simple commande suffit pour basculer :

mise use node@18

C’est rapide, efficace, et surtout intégré directement à votre workflow. 2. Configuration des environnements : Mise permet de définir des environnements spécifiques (développement, production, CI/CD). Chaque environnement peut avoir sa propre configuration via des fichiers comme mise.development.toml ou mise.production.toml. Encore mieux : il détecte automatiquement quel fichier utiliser en fonction de votre répertoire ou des variables d’environnement. 3. Automatisation des tâches : Envie de centraliser vos scripts dans un seul outil ? Mise intègre un système de gestion de tâches qui simplifie l’exécution de commandes répétitives. Déclarez vos tâches directement dans le fichier mise.toml, et exécutez-les avec :

mise run build

Fini les longues commandes tapées à la main !

Sécurité avancée : Contrairement à certains outils, Mise met un point d’honneur à sécuriser vos environnements et vos secrets. Il inclut des vérifications comme la signature GPG pour valider les sources des plugins, ou encore l’intégration de solutions de gestion des secrets.
Performance optimisée : Un des aspects qui m’a bluffé, c’est la rapidité de Mise. Les temps de chargement et d’exécution sont réduits au minimum, même avec des configurations complexes. On gagne un temps précieux à chaque interaction.

Installation de Mise

Installer Mise est un jeu d’enfant grâce aux nombreuses options proposées pour s’adapter à différents systèmes d’exploitation. Voici un guide pour les principales méthodes, que vous soyez sur Linux, macOS ou Windows.

Utilisation des gestionnaires de paquets sur Linux

Pour les distributions Linux, Mise est disponible via les gestionnaires de paquets suivants :

Alpine Linux : Installez directement depuis le dépôt communautaire avec :
Terminal window
```
apk add mise
```

Ubuntu/Debian :

sudo apt update -y && sudo apt install -y gpg sudo wget curl
sudo install -dm 755 /etc/apt/keyrings
wget -qO - https://mise.jdx.dev/gpg-key.pub | gpg --dearmor | sudo tee /etc/apt/keyrings/mise-archive-keyring.gpg 1> /dev/null
echo "deb [signed-by=/etc/apt/keyrings/mise-archive-keyring.gpg arch=amd64] https://mise.jdx.dev/deb stable main" | sudo tee /etc/apt/sources.list.d/mise.list
sudo apt update
sudo apt install -y mise

Fedora/RHEL :

dnf install -y dnf-plugins-core
dnf config-manager --add-repo https://mise.jdx.dev/rpm/mise.repo
dnf install -y mise

macOS

Pour les utilisateurs de macOS, Mise est disponible via Homebrew :

brew install mise

Windows

Enfin, pour les utilisateurs de Windows, Mise est disponible via Scoop :

scoop bucket add extra
scoop install mise

Installation manuelle avec un script

Pour ceux qui préfèrent ne pas dépendre d’un gestionnaire de paquets, vous pouvez utiliser le script d’installation :

curl https://mise.run | sh

Pour plus de contrôle, vous pouvez définir des options comme le chemin d’installation ou une version spécifique :

curl https://mise.run | MISE_INSTALL_PATH=/usr/local/bin/mise sh

Configuration de Mise

Une fois Mise installé, la configuration est l’étape clé pour tirer pleinement parti de ses fonctionnalités. Avec son fichier central mise.toml et ses options intuitives, la mise en place est rapide et efficace. Voici comment procéder.

Créer le fichier mise.toml

Le fichier mise.toml est le cœur de votre configuration. Placez-le à la racine de votre projet pour qu’il soit détecté automatiquement. Voici un exemple de base :

[tools]
node = "18"
python = "3.11"
terraform = "1.5"

[tasks]
build = "npm run build"
test = "pytest"

Ce fichier déclare :

Les versions des outils nécessaires.
Les tâches automatisées que vous pouvez exécuter avec la commande mise run.

Configurer les environnements

Mise prend en charge des environnements spécifiques grâce à des fichiers comme mise.development.toml ou mise.production.toml. Par exemple :

[tools]
node = "18"

[settings]
debug = true

Pour activer un environnement spécifique, utilisez la variable d’environnement MISE_ENV :

MISE_ENV=development mise run start

Activer Mise dans le shell

Pour que Mise soit disponible à chaque ouverture de terminal, ajoutez cette ligne à votre fichier de configuration shell (.bashrc, .zshrc, etc.) :

eval "$(mise activate bash)"

Cela garantit que vos outils et environnements sont correctement chargés.

Personnaliser les paramètres

Mise propose plusieurs options de configuration dans son fichier mise.toml :

Chemins personnalisés :
```
[settings]
bin_path = "/custom/path"
```
Scripts globaux : Rendez des tâches accessibles dans tous vos projets en les définissant dans ~/.mise.toml.

Gérer les fichiers locaux

Les fichiers locaux, comme mise.local.toml, permettent de stocker des configurations spécifiques à votre machine (non versionnées) :

# Exemple d’ajout au .gitignore
echo "mise.local.toml" >> .gitignore

Déboguer vos configurations

Pour vérifier que tout est correctement configuré, utilisez :

mise doctor

Cette commande affiche les fichiers actifs et leurs paramètres.

Avec ces configurations en place, vous êtes prêt à exploiter tout le potentiel de Mise. Dans le prochain chapitre, nous verrons comment utiliser les tâches pour simplifier vos workflows au quotidien. 🚀

Utilisation des variables d’environnement

Mise facilite la gestion des clés d’accès comme des Access Keys (AK) et Secret Keys (SK) dans différents environnements. Voici comment configurer vos variables pour des environnements distincts comme dev et prod.

Utilisez des fichiers spécifiques à chaque environnement comme mise.dev.toml et mise.prod.toml pour définir vos clés. Exemple :

Fichier mise.dev.toml :

[env]
AK = "DEV1234567890"
SK = "DEV0987654321"
ENDPOINT = "https://dev.example.com"

Fichier mise.prod.toml :

[env]
AK = "PROD1234567890"
SK = "PROD0987654321"
ENDPOINT = "https://prod.example.com"

Vous pouvez activer ces environnements en définissant la variable MISE_ENV :

MISE_ENV=dev mise run start
MISE_ENV=prod mise run deploy

Sécurisation des clés sensibles

Pour protéger vos clés, activez la redaction afin qu’elles ne soient pas affichées dans les journaux ou sorties de debug :

[env]
AK = { value = "DEV1234567890", redact = true }
SK = { value = "DEV0987654321", redact = true }

Ainsi, même si vous exécutez des commandes mise run avec des sorties détaillées, vos clés resteront confidentielles.

Gestion des Tâches avec Mise

L’une des fonctionnalités les plus pratiques de Mise est son système intégré de gestion des tâches. Plus besoin de scripts dispersés ou de Makefiles complexes : vous pouvez centraliser toutes vos tâches directement dans le fichier mise.toml.

Les tâches se configurent dans une section [tasks]. Voici un exemple simple :

[tasks]
build = "npm run build"
test = "pytest tests/"
deploy = "bash ./scripts/deploy.sh"

Chaque tâche est associée à une commande que vous pouvez exécuter en utilisant :

mise run <nom_de_la_tâche>

Exemple :

mise run build
mise run test

Les tâches peuvent tirer parti des variables définies dans la section [env]. Par exemple :

[env]
APP_ENV = "production"

[tasks]
start = "echo Starting app in {{env.APP_ENV}} mode && npm start"

En exécutant la tâche start, vous verrez :

Starting app in production mode

Pour afficher la liste des tâches définies dans mise.toml, utilisez :

mise tasks

Pour plus d’informations sur les taches consultez la documentation officielle ↗.

Utilisation de Mise avec Python

Mise est parfaitement adapté à la gestion de projets Python, notamment grâce à son intégration avec des outils comme virtualenv. Voici comment organiser un projet Python efficacement avec Mise.

Un fichier mise.toml de base pour un projet Python pourrait ressembler à ceci :

min_version = "2024.9.5"

[env]
# Utiliser le nom du projet dérivé du répertoire courant
PROJECT_NAME = "{{ config_root | basename }}"

# Activation automatique de l'environnement virtuel
_.python.venv = { path = ".venv", create = true }

[tools]
python = "{{ get_env(name='PYTHON_VERSION', default='3.11') }}"
ruff = "latest"

[tasks.install]
description = "Installer les dépendances"
alias = "i"
run = "uv pip install -r requirements.txt"

[tasks.run]
description = "Lancer l'application"
run = "python app.py"

[tasks.test]
description = "Exécuter les tests"
run = "pytest tests/"

[tasks.lint]
description = "Analyser le code"
run = "ruff src/"

[tasks.info]
description = "Afficher les informations du projet"
run = '''
echo "Projet : $PROJECT_NAME"
echo "Environnement virtuel : $VIRTUAL_ENV"
'''

Virtualenv Automatique :
- La clé _.python.venv configure automatiquement un environnement virtuel dans le répertoire .venv et le crée s’il n’existe pas.
Version Python Dynamique :
- La version Python est obtenue à partir de la variable d’environnement PYTHON_VERSION ou par défaut 3.11.

Avec la configuration ci-dessus, vous pouvez utiliser les commandes suivantes pour gérer votre projet :

Installer les dépendances :
Terminal window
```
mise run install
```
Alias court :
Terminal window
```
mise run i
```
Lancer l’application :
Terminal window
```
mise run run
```
Exécuter les tests :
Terminal window
```
mise run test
```
Analyser le code avec Ruff :
Terminal window
```
mise run lint
```
Afficher les informations du projet :
Terminal window
```
mise run info
```
Avantages de cette Approche
- Centralisation : Toutes les tâches Python courantes sont définies dans un seul fichier.
- Flexibilité : Vous pouvez facilement changer la version de Python ou ajouter de nouveaux outils comme black ou mypy.
- Automatisation : La gestion de l’environnement virtuel est entièrement automatisée, évitant les erreurs courantes.

Avec cette configuration, Mise devient un outil puissant pour gérer vos projets Python tout en simplifiant vos workflows. Vous pouvez l’adapter à vos besoins spécifiques en ajoutant d’autres tâches ou outils selon vos projets. 🚀

Gestion des Secrets avec Mise

Mise propose une gestion intégrée des secrets pour manipuler en toute sécurité des informations sensibles, comme des clés d’accès ou des identifiants. Cette fonctionnalité repose sur des fichiers chiffrés gérés par des outils comme sops. Voici comment l’utiliser efficacement.

Les secrets peuvent être stockés dans des fichiers au format .json, .yaml, ou .toml. Par exemple, un fichier .env.json pourrait contenir :

{
  "AWS_ACCESS_KEY_ID": "AKIAIOSFODNN7EXAMPLE",
  "AWS_SECRET_ACCESS_KEY": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
}

Ces fichiers peuvent être importés dans une configuration Mise grâce à la directive suivante dans mise.toml :

[env]
_.file = ".env.json"

Pour sécuriser vos fichiers contenant des secrets, vous pouvez utiliser sops. Voici les étapes pour configurer et chiffrer un fichier :

Installer sops et age :
Terminal window
```
mise use -g sops
mise use -g age
```
Générer une clé avec age :
Terminal window
```
age-keygen -o ~/.config/mise/age.txt
```
Notez la clé publique affichée pour l’utiliser dans les étapes suivantes.
Chiffrer le fichier .env.json :
Terminal window
```
sops encrypt -i --age "<public_key>" .env.json
```
Le fichier sera remplacé par une version chiffrée, qui est sécurisée pour être commitée dans votre dépôt.
Décrypter ou modifier le fichier :
- Déchiffrer :
  Terminal window
```
sops decrypt -i .env.json
```
- Modifier en toute sécurité :
  Terminal window
```
sops edit .env.json
```

Pour que Mise puisse décrypter le fichier, assurez-vous que la clé privée est disponible en configurant l’environnement :

export MISE_SOPS_AGE_KEY_FILE=~/.config/mise/age.txt

Pour visualiser les variables d’environnement décryptées, exécutez :

mise env

Exemple de sortie :

export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

Avec cette approche, vous pouvez gérer vos secrets en toute sécurité, tout en les intégrant facilement dans vos configurations Mise. Cela vous permet de garder vos clés et identifiants hors de votre code source, tout en les rendant facilement accessibles à vos tâches et scripts. 🚀

Conclusion

Après avoir exploré Mise, je dois dire que je suis vraiment ravi d’avoir trouvé un outil capable de remplacer à la fois asdf et direnv, tout en offrant en prime une gestion sécurisée des secrets grâce à sops. La simplicité d’utilisation, la centralisation des configurations, et les fonctionnalités avancées comme les tâches et la gestion des environnements rendent Mise indispensable pour un développeur moderne.

Je suis convaincu que cet outil va transformer ma façon de gérer mes projets. Mais, soyons honnêtes, je pense qu’il reste encore beaucoup à découvrir. Mise regorge de possibilités, et ce guide n’en est qu’une introduction. Au fil de mes expériences, je compte bien compléter ce guide avec des astuces, des cas pratiques, et des intégrations encore plus poussées.

En attendant, si vous cherchez un moyen de simplifier vos workflows tout en sécurisant vos projets, je vous encourage fortement à essayer Mise. Vous pourriez bien être aussi conquis que moi. 🚀