Aller au contenu
DevSecOps Logo DevSecOps
Docs
Blog

Conda : gestion d'env. & paquets Python

Mise à jour :

Logo Conda, gestionnaire d'environnements et de paquets multiplateforme

Vous êtes-vous déjà retrouvé dans cette situation : votre code fonctionne parfaitement sur votre machine, mais refuse obstinément de s’exécuter ailleurs ? Les fameux conflits de versions, les dépendances incompatibles et les configurations impossibles à reproduire sont le cauchemar de tout développeur. Conda résout ces problèmes en offrant un gestionnaire de paquets et d’environnements multiplateforme qui garantit la reproductibilité de vos configurations, quel que soit le système d’exploitation.

Qu’est-ce que Conda ?

Conda est donc un gestionnaire de paquets et un outil de gestion d’environnements virtuels. Développé initialement pour la distribution Anaconda, il est aujourd’hui utilisé bien au-delà du monde Python. Son rôle principal est de simplifier la gestion des dépendances et de garantir des environnements reproductibles sur différents systèmes d’exploitation.

En pratique, Conda vous permet de :

  • créer des environnements isolés pour chaque projet,
  • installer des paquets provenant de plusieurs canaux (channels),
  • résoudre automatiquement les conflits de versions,
  • exporter et partager vos environnements via un simple fichier YAML.

Grâce à cette approche, les administrateurs systèmes et les développeurs évitent les “dependency hell” — ces conflits de versions qui rendent un projet instable ou impossible à exécuter ailleurs.

Historique et philosophie de Conda

Conda a été créé par Continuum Analytics (aujourd’hui Anaconda Inc.) pour répondre à un besoin important : gérer des bibliothèques scientifiques complexes comme NumPy, SciPy ou Pandas, qui dépendent souvent de compilations natives.

Les outils classiques comme pip ou virtualenv, voir uv, ne suffisaient pas, car ils ne gèrent que les paquets Python. Conda, lui, traite tous types de dépendances, qu’elles soient Python, C/C++, R, ou autres.

Cette conception universelle fait de Conda un gestionnaire agnostique au langage, idéal pour les environnements data science, DevOps ou CI/CD où plusieurs langages et bibliothèques interagissent.

Conda vs autres gestionnaires de paquets

Contrairement à pip, qui installe uniquement des modules Python à partir de PyPI ↗, Conda télécharge des paquets précompilés depuis des canaux comme conda-forge ↗. Cela réduit considérablement les erreurs de compilation et accélère l’installation.

FonctionnalitéCondapip + venv
Gère les paquets non PythonOuiNon
Crée des environnements isolésOuiOui
Résout les dépendances globalementOuiNon
Fichiers d’environnement reproductibles (.yml)OuiNon
Compatible multi-langagesOuiNon

Ainsi, Conda devient un outil de référence dès qu’un projet implique plusieurs dépendances système ou doit être déployé sur des environnements variés.

Cas d’usage typiques

Conda est particulièrement adapté pour :

  • Projets data science : Jupyter, TensorFlow, PyTorch
  • Pipelines DevOps : environnements reproductibles en CI/CD
  • Développement multi-langage : Python, R, bibliothèques C/C++
  • Infrastructure Cloud et automatisation avec Ansible

Concepts importants de Conda

Avant de passer à la pratique, il est essentiel de comprendre trois concepts fondamentaux qui constituent le cœur de Conda : les environnements isolés, les canaux de distribution et la gestion automatique des dépendances.

Comprendre les environnements isolés

Un environnement Conda est un espace de travail isolé contenant ses propres paquets, dépendances et version de Python. Chaque projet peut ainsi fonctionner sans interférer avec les autres, ce qui évite les erreurs de compatibilité ou de mise à jour accidentelle.

Avantage clé : cette isolation garantit la reproductibilité des projets et facilite leur déploiement dans des chaînes CI/CD.

Les canaux (channels)

Les canaux sont les sources à partir desquelles Conda télécharge les paquets. Chaque canal contient des versions spécifiques de bibliothèques compilées pour différents systèmes d’exploitation et architectures.

Les canaux les plus utilisés :

CanalDescriptionLien
defaultsCanal officiel d’Anacondarepo.anaconda.com ↗
conda-forgeCommunautaire, très actif et completconda-forge.org ↗
biocondaSpécialisé dans la bioinformatiquebioconda.github.io ↗

Gestion des dépendances

Lorsqu’un paquet est installé, Conda résout automatiquement les dépendances nécessaires. Il télécharge toutes les bibliothèques compatibles en fonction du système et de la version de Python.

Les différents outils : Conda, Mamba et Micromamba

Conda n’est pas le seul outil dans son écosystème. Deux alternatives populaires, Mamba et Micromamba, offrent des performances améliorées tout en restant compatibles avec les environnements Conda.

Voici un tableau comparatif des trois outils :

CritèreCondaMambaMicromamba
Vitesse résolutionLente (SAT solver Python)10-100x plus rapideTrès rapide (C++)
Taille installation~500MB (Miniconda)~500MB + Conda~15MB (binaire autonome)
Cas d’usage principalDébutants, compatibilitéRemplacement directCI/CD, Docker
Environnement baseOui (requis)Oui (hérité de Conda)Non (optionnel)
Compatibilité100% référence100% avec Conda99% (quelques commandes diff.)
InstallationSimpleconda install mambaBinaire unique
Multi-OSOuiOuiOui
RecommandationFormationUsage quotidienProduction/CI

Le choix entre Conda, Mamba et Micromamba dépend de vos besoins spécifiques :

  • Conda est idéal pour les débutants ou ceux qui privilégient la compatibilité maximale avec l’écosystème existant.
  • Mamba convient parfaitement à ceux qui recherchent une alternative performante, sans changer leurs habitudes.
  • Micromamba est parfait pour les environnements légers, les pipelines CI/CD et les conteneurs Docker, où la taille et la rapidité sont cruciales.

Dans le cadre de ce guide, nous utiliserons principalement Conda pour sa simplicité et son adoption généralisée. Cependant, les concepts et commandes présentés sont largement applicables à Mamba et Micromamba.

Installer Conda sur Linux, macOS et Windows

Voici comment installer et configurer Conda sur votre système.

Installation selon le système d’exploitation

Linux

Téléchargez et exécutez le script d’installation depuis le site officiel :

Terminal window
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh

Suivez les instructions, puis rechargez le shell :

Terminal window
source ~/.bashrc

Vérifiez l’installation :

Terminal window
conda --version

macOS

Téléchargez l’installateur depuis docs.conda.io ↗ puis exécutez :

Terminal window
bash Miniconda3-latest-MacOSX-x86_64.sh

Sur Apple Silicon (M1/M2/M3/M4), privilégiez Miniforge :

Terminal window
curl -L -O https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-MacOSX-arm64.sh
bash Miniforge3-MacOSX-arm64.sh

Windows

Téléchargez l’exécutable .exe depuis conda.io ↗ et suivez l’assistant graphique. Ensuite, ouvrez Anaconda Prompt ou PowerShell et vérifiez :

Terminal window
conda --version

Configuration initiale

Après installation, quelques réglages de base assurent une expérience fluide :

1. Mise à jour de Conda

Terminal window
conda update conda

2. Configuration .condarc optimale

Le fichier .condarc configure le comportement global de Conda. Plutôt que d’éditer manuellement .condarc, vous pouvez configurer Conda via ces commandes :

Terminal window
# Configuration recommandée par commandes
conda config --add channels conda-forge
conda config --set channel_priority strict
conda config --set show_channel_urls true
conda config --set auto_activate false

Vous pouvez vérifier la configuration finale avec :

Terminal window
# Vérifier que la configuration est bien appliquée
conda config --show channels
conda config --show channel_priority
conda config --show auto_activate

Maintenant que Conda installé et configuré, vous pouvez commencer à créer vos environnements isolés et à installer des paquets depuis différents canaux.

Premier projet avec Conda

À la fin du chapitre, vous aurez :

  • un environnement isolé myapi-dev (zéro paquet dans base),
  • un fichier environment.yml versionné et appliqué,
  • un micro-projet Python qui tourne et un test qui passe,
  • les commandes quotidiennes pour lister/mettre à jour/nettoyer.

Voici l’arborescence du projet à la fin des étapes :

myapi/
├─ src/
│  └─ app.py
├─ tests/
│  └─ test_app.py
├─ environment.yml
├─ .condarc
├─ .gitignore
└─ README.md

Étape 1 — Initialisation du projet

Commençons par créer la structure de base du projet et initialiser un dépôt Git :

Terminal window
mkdir -p myapi/src myapi/tests && cd myapi
git init
printf "__pycache__/\n*.lock\n.conda/\n" > .gitignore

Ensuite, configurez Conda pour le projet :

Terminal window
# Configuration recommandée pour le projet
conda config --add channels conda-forge
conda config --set channel_priority strict
conda config --set show_channel_urls true

Étape 2 — Création de l’environnement

Créons maintenant l’environnement myapi-dev avec les paquets nécessaires :

Terminal window
# Créer l'environnement avec tous les paquets nécessaires
conda create -n myapi-dev python=3.11 flask==3.1.1 uvicorn pytest requests -c conda-forge


# Activer l'environnement
conda activate myapi-dev

Pourquoi nommer l’environnement myapi-dev et non juste dev ? Pour éviter les conflits avec d’autres projets sur la même machine. En effet tous les environnements Conda sont stockés dans le même répertoire, donc des noms d’environnement uniques sont essentiels.

Étape 3 — Code minimal de l’API

Nous créons un fichier src/app.py avec une API Flask minimale :

Terminal window
cat > src/app.py <<'PY'
from flask import Flask, jsonify
app = Flask(__name__)


@app.get("/health")
def health():
    return jsonify(status="ok")


if __name__ == "__main__":
    # Lancement local
    app.run(host="0.0.0.0", port=8000)
PY

Étape 4 — Test unitaire

Ajoutons un test unitaire simple dans tests/test_app.py :

Terminal window
# Créer un test simple directement avec echo
echo 'def test_smoke():
    assert 1 + 1 == 2' > tests/test_app.py


# Exécuter les tests avec pytest
pytest

Étape 5 — Lancer l’app

On valide le bon fonctionnement de l’API en lançant l’application :

Terminal window
python src/app.py

Vous pouvez vérifier que l’API fonctionne en accédant à http://localhost:8000/health. Vous devriez voir une réponse JSON :

{"status":"ok"}

Mettre à jour les dépendances

Pour mettre à jour les dépendances de votre environnement vous avez deux options.

  • Si vous souhaitez mettre à jour un paquet spécifique à une version spécifique, utilisez la commande suivante :

    Terminal window
    conda install -n myapi-dev flask==3.1.1

  • Sinon, pour mettre à jour la dernière version disponible d’un paquet, utilisez :

    Terminal window
    conda update -n myapi-dev flask

Etape 6 — Supprimer un environnement

Nous sommes arrivés à la fin de notre mini-projet. Il est temps de nettoyer en supprimant les environnements devenus inutiles.

Terminal window
# Désactiver l'environnement s'il est actif
conda deactivate


# Lister les environnements restants pour vérifier
conda env list


# Supprimer complètement l'environnement
conda env remove -n myapi-test


# Ou supprimer plusieurs environnements d'un coup
conda env remove -n myapi-test -n myapi-prod

Conclusion

Conda est bien plus qu’un simple gestionnaire de paquets : c’est un outil d’infrastructure logicielle, pensé pour la reproductibilité, la portabilité et la cohérence des environnements dans les chaînes DevOps, Data Science et CI/CD.

Grâce à ce guide, vous disposez désormais de toutes les clés pour :

  • créer des environnements isolés,
  • gérer efficacement vos dépendances,
  • et garantir la reproductibilité de vos projets à grande échelle.

Dans de futurs chapitres, nous explorerons des cas d’usage avancés, des intégrations avec des outils de CI/CD comme GitHub Actions et GitLab CI, ainsi que des stratégies de déploiement dans le cloud.

Plus d’infos

Pour approfondir vos connaissances sur Conda, il est essentiel de consulter les ressources officielles, régulièrement mises à jour :