Gérez vos conteneurs avec crictl

Mise à jour : 22/01/2025

crictl est un outil en ligne de commande conçu pour interagir directement avec les runtimes CRI (Container Runtime Interface) comme containerd ou CRI-O. Dans les environnements modernes, notamment ceux basés sur Kubernetes, il permet de gérer, déboguer et inspecter les conteneurs et leurs sandboxes, sans dépendre de solutions comme Docker. Simple, rapide et efficace, crictl est une boîte à outils incontournable pour tout administrateur système ou ingénieur DevOps.

Comment est né crictl ?

Pour comprendre l’origine de crictl, il faut revenir quelques années en arrière, au moment où Kubernetes a commencé à évoluer et à redéfinir son architecture interne. À cette époque, Docker était le moteur de conteneurs par défaut utilisé par Kubernetes pour orchestrer les conteneurs. Cependant, cette dépendance a soulevé plusieurs limitations techniques.

En 2016, les développeurs de Kubernetes ont introduit la CRI (Container Runtime Interface) dans l’objectif de découpler le moteur de conteneurs du reste de la plateforme Kubernetes. L’idée était de standardiser les interactions entre Kubernetes et les runtimes de conteneurs afin de permettre à plusieurs moteurs, et pas seulement Docker, de fonctionner avec Kubernetes.

Ainsi, des runtimes comme containerd (issu de Docker) ou CRI-O (conçu spécifiquement pour Kubernetes) ont vu le jour, chacun respectant les spécifications de la CRI. Cela a permis aux utilisateurs de choisir le moteur qui correspondait le mieux à leurs besoins en termes de performances, de fonctionnalités ou de compatibilité.

Avec cette transition vers un système basé sur la CRI, un besoin s’est rapidement fait sentir : il manquait un outil générique pour interagir avec ces nouveaux runtimes compatibles CRI. Docker CLI (l’outil en ligne de commande de Docker) ne fonctionnait pas encore containerd ou CRI-O, ce qui compliquait la gestion et le débogage des conteneurs dans ces environnements.

C’est dans ce contexte que crictl a été créé par la communauté Kubernetes. L’objectif était simple : fournir un outil universel capable de communiquer avec n’importe quel runtime compatible CRI, tout en offrant des fonctionnalités similaires à celles du Docker CLI.

Au fil du temps, Kubernetes a officiellement abandonné son support direct de Docker en tant que moteur de conteneurs (décision annoncée avec Kubernetes 1.20, publiée en décembre 2020). À partir de là, containerd et CRI-O sont devenus les solutions privilégiées pour exécuter des conteneurs dans Kubernetes.

Cette évolution a consolidé l’importance de crictl, qui est désormais l’outil standard pour interagir avec ces runtimes. Que vous utilisiez containerd ou CRI-O, crictl vous offre une interface simple pour gérer vos conteneurs, inspecter les pods, consulter les logs et déboguer vos applications.

Outil	Rôle principal	Exemple d’utilisation
Docker	Moteur de conteneurs complet et CLI intégrée	Développement local ou déploiement non-K8s
CRI	Interface pour connecter Kubernetes aux runtimes	Norme pour les runtimes comme containerd, CRI-O
crictl	Outil CLI pour interagir avec un runtime CRI	Déboguer un cluster Kubernetes

Alors que Docker était historiquement utilisé comme moteur principal par Kubernetes, la CRI a permis de s’émanciper et de choisir d’autres solutions comme containerd ou CRI-O. crictl, quant à lui, est l’outil standard pour interagir avec ces runtimes.

Qu’est-ce qu’un runtime de conteneur ?

Un runtime de conteneur est le logiciel responsable de l’exécution des conteneurs sur une machine. Il gère les tâches comme :

Le démarrage et l’arrêt des conteneurs.
La gestion des images conteneurisées.
L’allocation des ressources (CPU, mémoire, etc.).

Voici les principaux runtimes compatibles avec la CRI :

containerd :
- Anciennement une composante de Docker, il est devenu un projet autonome.
- Léger, performant et conçu pour les environnements Kubernetes.
CRI-O :
- Un runtime développé spécifiquement pour Kubernetes.
- Minimaliste, il n’embarque que les fonctionnalités nécessaires à Kubernetes.

En bref, un runtime agit comme l’intermédiaire entre les conteneurs et l’infrastructure sous-jacente.

Installation de crictl

Pour utiliser crictl avec un runtime CRI comme containerd, il est important d’effectuer une installation propre et de bien configurer votre environnement.

La méthode la plus simple consiste à télécharger l’exécutable précompilé depuis le dépôt GitHub officiel. Voici les étapes détaillées :

Téléchargez le binaire de crictl correspondant à votre système : Commencez par définir la version de crictl que vous souhaitez installer (vous pouvez vérifier la dernière version disponible sur la page GitHub de cri-tools ↗) :
Terminal window
```
VERSION="v1.32.0" # Remplacez par la version souhaitée
curl -LO https://github.com/kubernetes-sigs/cri-tools/releases/download/$VERSION/crictl-$VERSION-linux-amd64.tar.gz
```
Décompressez l’archive et placez l’exécutable dans un répertoire accessible :
Terminal window
```
sudo tar -C /usr/local/bin -xzf crictl-$VERSION-linux-amd64.tar.gz
```
Vérifiez l’installation : Une fois l’installation terminée, assurez-vous que crictl fonctionne correctement en affichant sa version :
Terminal window
```
crictl --version
```

Configurer crictl

Pour que crictl fonctionne, il doit savoir à quel runtime se connecter. Par défaut, il se connecte au socket /run/containerd/containerd.sock, mais si vous utilisez un autre socket ou runtime, il faut le préciser dans le fichier de configuration /etc/crictl.yaml.

Créer ou modifier le fichier de configuration : Utilisez votre éditeur préféré pour créer ou modifier le fichier /etc/crictl.yaml :
Terminal window
```
sudo nano /etc/crictl.yaml
```

Ajoutez-y les paramètres suivants pour containerd :

runtime-endpoint: unix:///run/containerd/containerd.sock
image-endpoint: unix:///run/containerd/containerd.sock
timeout: 10
debug: false

Testez la configuration : Une fois configuré, vérifiez que crictl peut se connecter à votre runtime :
Terminal window
```
crictl info
```

Configurer containerd pour activer CRI (si nécessaire)

Si vous utilisez containerd, il est possible que le plugin CRI soit désactivé par défaut, ce qui empêche crictl de fonctionner correctement. Voici comment activer CRI dans containerd :

Vérifiez si containerd est installé : Si containerd n’est pas encore installé, installez-le avec la commande suivante (pour Debian/Ubuntu) :
Terminal window
```
sudo apt update
sudo apt install -y containerd.io
```
Modifier la configuration de containerd : Le fichier de configuration de containerd se trouve ici : /etc/containerd/config.toml. Si ce fichier n’existe pas, générez une configuration par défaut :
Terminal window
```
sudo containerd config default > /etc/containerd/config.toml
```
Activer le plugin CRI : Ouvrez le fichier /etc/containerd/config.toml avec un éditeur :
Terminal window
```
sudo nano /etc/containerd/config.toml
```
Recherchez la ligne suivante :
```
disabled_plugins = ["cri"]
```
Commentez ou supprimez cette ligne pour activer le support CRI :
```
# disabled_plugins = ["cri"]
```
Redémarrez containerd pour appliquer les modifications :
Terminal window
```
sudo systemctl restart containerd
```
Testez la connexion avec crictl : Une fois containerd configuré, exécutez la commande suivante pour vous assurer que tout fonctionne :
Terminal window
```
sudo crictl info
```

Fonctionnement de la CLI crictl

crictl offre une interface en ligne de commande (CLI) pour interagir avec les runtimes compatibles avec la CRI. Son fonctionnement repose sur des commandes spécifiques permettant de gérer, déboguer et inspecter les conteneurs, les pods et les images. Passons en revue ses principales commandes et leur utilité.

Les commandes de crictl suivent une structure simple :

crictl [options générales] commande [options de la commande] [arguments...]

Par exemple, pour lister tous les conteneurs :

sudo -i
crictl ps

Gestion des images

Avec crictl, vous pouvez également gérer les images conteneurisées :

Lister les images disponibles :
Terminal window
```
crictl images
```
Télécharger une image depuis un registre :
Terminal window
```
crictl pull <image_name>
```
Supprimer une image :
Terminal window
```
crictl rmi <image_name>
```

Gestions des conteneurs avec crictl

Les commandes liées aux conteneurs permettent de créer, démarrer, arrêter ou inspecter des conteneurs en toute simplicité :

Lister les conteneurs :
Terminal window
```
crictl ps
```
Ajoutez l’option -a pour inclure les conteneurs arrêtés :
Terminal window
```
crictl ps -a
```
Inspecter un conteneur :
Terminal window
```
crictl inspect <container_id>
```

Démarrer et arrêter des conteneurs :

crictl start <container_id>
crictl stop <container_id>

Supprimer un conteneur :
Terminal window
```
crictl rm <container_id>
```

Debugging et inspection

Pour identifier des problèmes dans vos conteneurs ou pods, crictl fournit des commandes d’inspection et de debugging puissantes :

Afficher les logs d’un conteneur :
Terminal window
```
crictl logs <container_id>
```
Exécuter une commande dans un conteneur en cours d’exécution :
Terminal window
```
crictl exec -i -t <container_id> <command>
```
Par exemple, pour lister le contenu d’un conteneur :
Terminal window
```
crictl exec -i -t <container_id> ls
```

Pour surveiller les performances, crictl peut fournir des statistiques sur les ressources utilisées par les conteneurs :

crictl stats

Gestion des pods avec crictl

Dans l’écosystème Kubernetes, les pods sont l’unité de base pour exécuter des conteneurs. Un pod peut contenir un ou plusieurs conteneurs partageant un réseau, un espace de stockage et une configuration. Avec crictl, vous pouvez gérer et inspecter ces pods directement, sans passer par Kubernetes. Voici comment faire.

Créer un pod :

Pour créer un pod avec crictl, vous devez fournir un fichier de configuration JSON ou YAML. Voici un exemple simple au format JSON :

Fichier pod-config.json :

{
  "metadata": {
    "name": "example-pod",
    "namespace": "default",
    "attempt": 1,
    "uid": "unique-pod-id"
  },
  "log_directory": "/tmp",
  "linux": {}
}

Ensuite, créez le pod avec :

crictl runp pod-config.json

Lister les pods :

Pour afficher tous les pods gérés par votre runtime :

crictl pods

La sortie affiche des informations utiles, comme l’identifiant du pod, son état, son nom, son namespace et le nombre de tentatives de création.

Inspecter un pod :

Si vous avez besoin de détails sur un pod spécifique (par exemple, sa configuration, ses conteneurs associés, ou ses journaux), utilisez :

crictl inspectp <pod_id>

Cette commande retourne un résultat au format JSON ou YAML contenant :

Les métadonnées du pod.
Les conteneurs associés.
Les configurations réseau et stockage.
Supprimer un pod :

Pour supprimer un pod spécifique et libérer ses ressources, utilisez :

crictl rmp <pod_id>

Si le pod contient des conteneurs en cours d’exécution, vous devrez d’abord les arrêter ou les supprimer avant de pouvoir supprimer le pod.

Déboguer un pod :

Pour déboguer un pod, commencez par vérifier ses logs et ceux de ses conteneurs associés :

Afficher les logs d’un pod :
Terminal window
```
crictl logs <pod_id>
```
Note : Cette commande cible les logs des conteneurs du pod.
Inspecter ses conteneurs associés : Listez les conteneurs du pod en question avec :
Terminal window
```
crictl ps --pod <pod_id>
```
Afficher des statistiques sur les conteneurs du pod :
Terminal window
```
crictl statsp
```
Cette commande fournit des informations sur l’utilisation des ressources (CPU, mémoire, etc.) par les conteneurs du pod.

Intégration de crictl avec Kubernetes

crictl est un outil précieux pour interagir directement avec les runtimes CRI dans un cluster Kubernetes. Bien qu’il fonctionne indépendamment de Kubernetes, il est souvent utilisé pour déboguer, inspecter et gérer les conteneurs et pods au sein d’un cluster Kubernetes. Explorons les cas pratiques et les étapes pour l’utiliser efficacement.

Pourquoi utiliser crictl avec Kubernetes ?

Même si Kubernetes offre ses propres commandes (kubectl), crictl présente certains avantages :

Accès direct au runtime : Permet de contourner Kubernetes pour diagnostiquer des problèmes spécifiques.
Débogage au niveau bas : Utile lorsque le kubelet ou d’autres composants Kubernetes ne fonctionnent pas correctement.
Gestion des conteneurs hors Kubernetes : Fournit des informations détaillées sur les conteneurs sans passer par l’orchestrateur.

Pour que crictl fonctionne avec Kubernetes, assurez-vous que le kubelet est configuré pour utiliser un runtime compatible avec la CRI. Vous pouvez vérifier cela dans le fichier de configuration du kubelet, généralement situé dans /var/lib/kubelet/config.yaml :

containerRuntime: remote
containerRuntimeEndpoint: unix:///run/containerd/containerd.sock

Le chemin défini dans containerRuntimeEndpoint doit correspondre à celui configuré dans /etc/crictl.yaml.

Conclusion

crictl peut devenir un outil incontournable pour gérer les conteneurs et sandboxes dans des environnements utilisant un runtime CRI. Que ce soit pour diagnostiquer un problème dans un cluster Kubernetes, gérer des pods ou inspecter des conteneurs de manière indépendante, il offre une interface simple et efficace. Sa légèreté et son intégration directe avec les runtimes containerd et CRI-O en font un atout précieux.