Kata Containers

Kata Containers est un runtime de conteneurs qui isole les workloads dans des machines virtuelles légères plutôt que de partager le kernel hôte via des namespaces Linux. Né de la fusion d'Intel Clear Containers et de Hyper.sh runV (2017), il est conforme aux standards OCI et CRI, ce qui le rend transparent pour Kubernetes. L'isolation opère au niveau du pod : tous les conteneurs d'un même pod partagent la même VM légère.

Idéal pour : clusters multi-tenant hébergeant des workloads inconnus ou non fiables, SaaS exécutant du code client arbitraire, environnements réglementés exigeant une isolation hardware entre tenants.

Pré-requis matériel : Kata Containers nécessite KVM. Sur bare-metal c'est disponible par défaut. Sur VM, la virtualisation imbriquée (nested virtualization) doit être activée (AWS nitro instances, GCE, Azure D-series avec expose_nested_virt...). Sans KVM, Kata ne fonctionne pas.

Informations essentielles

Origine : Open Infrastructure Foundation (fusion Intel + Hyper.sh, 2017)  ·  Licence : Apache 2.0  ·  Architectures : x86_64, ARM64 (selon l'hyperviseur)

Liens : Site officiel  ·  Documentation  ·  GitHub  ·  Releases

Support : Releases régulières maintenues par la communauté Open Infrastructure Foundation. Kata 3.x (agent réécrit en Rust) est la branche active.

Architecture

Hyperviseurs disponibles

L'isolation est par pod, pas par conteneur. Deux conteneurs dans le même pod partagent la même VM légère - ce qui correspond à la sémantique des pods Kubernetes (réseau partagé, volumes locaux partagés).

Installation

Méthode recommandée (binaires officiels)

# Télécharger et installer kata-containers
export KATA_VERSION=$(curl -s https://api.github.com/repos/kata-containers/kata-containers/releases/latest | grep '"tag_name"' | cut -d'"' -f4)
curl -LO https://github.com/kata-containers/kata-containers/releases/download/${KATA_VERSION}/kata-static-${KATA_VERSION}-amd64.tar.xz

sudo tar -xvf kata-static-${KATA_VERSION}-amd64.tar.xz -C /

# Vérifier l'installation
kata-runtime kata-check
# "System is capable of running Kata Containers" = OK

Vérifier la compatibilité KVM

# Prérequis : KVM disponible
ls -la /dev/kvm

# Si absent sur une VM (nested virt non activée) :
# AWS : utiliser des instances .metal ou activer l'attribut nested virtualization
# GCE : activer vmx flag à la création de l'instance
# VMware : activer "Expose hardware-assisted virtualization to guest OS"

Intégration avec containerd

1. Configurer containerd

# /etc/containerd/config.toml
# Ajouter le runtime Kata
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata]
  runtime_type = "io.containerd.kata.v2"

sudo systemctl restart containerd

2. Créer la RuntimeClass Kubernetes

# runtimeclass-kata.yaml
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: kata
handler: kata

kubectl apply -f runtimeclass-kata.yaml

3. Utiliser Kata dans un pod

apiVersion: v1
kind: Pod
metadata:
  name: nginx-kata
spec:
  runtimeClassName: kata
  containers:
  - name: nginx
    image: nginx:alpine

kubectl apply -f pod.yaml

# Vérifier que Kata est actif (la VM tourne bien)
kubectl exec nginx-kata -- uname -r
# La version du kernel affichée sera celle du guest Kata, pas de l'hôte

Intégration avec CRI-O

# /etc/crio/crio.conf.d/10-kata.conf
[crio.runtime.runtimes.kata]
  runtime_path = "/usr/local/bin/containerd-shim-kata-v2"
  runtime_type = "vm"
  runtime_root = "/run/oci/kata"

# RuntimeClass Kubernetes
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: kata
handler: kata

Configuration avancée

Changer d'hyperviseur (Cloud Hypervisor)

# /etc/kata-containers/configuration.toml
[hypervisor.clh]
path = "/usr/local/bin/cloud-hypervisor"

# Dans containerd config.toml, pointer vers la config Kata
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata-clh]
  runtime_type = "io.containerd.kata-clh.v2"

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata-clh.options]
  ConfigPath = "/etc/kata-containers/configuration-clh.toml"

Ressources de la VM

# /etc/kata-containers/configuration.toml
[hypervisor.qemu]
# CPU et RAM alloués à la VM pour chaque pod
default_vcpus = 1
default_memory = 2048  # MB

# Activer le hot-plug CPU/RAM (adaptatif selon workload)
cpu_features = "hotplug"
enable_mem_prealloc = false

Mise à jour

# Réinstaller depuis les binaires officiels
export KATA_VERSION=<nouvelle-version>
curl -LO https://github.com/kata-containers/kata-containers/releases/download/${KATA_VERSION}/kata-static-${KATA_VERSION}-amd64.tar.xz
sudo tar -xvf kata-static-${KATA_VERSION}-amd64.tar.xz -C /

sudo systemctl restart containerd

# Vérifier
kata-runtime --version

Troubleshooting

kata-check échoue

kata-runtime kata-check
# "ERRO[...] CPU does not support virtualization"
# -> KVM non disponible sur ce nœud (pas de /dev/kvm)

# Vérifier les capacités CPU
grep -E '(vmx|svm)' /proc/cpuinfo
# vmx = Intel VT-x, svm = AMD-V

Pod en erreur (OCI runtime error)

kubectl describe pod <nom>
# Event: "Failed to create containerd task ... kata"

# Logs containerd
sudo journalctl -u containerd -n 50 | grep kata

# Test direct kata
kata-runtime --log-level debug kata-check

Latence de démarrage élevée

# QEMU prend ~500ms-1s pour démarrer une VM
# Utiliser Firecracker pour des démarrages plus rapides (~100ms)
# Ou activer le "VM pre-warming" (Kata 3.x experimental)
kata-runtime --version

Commandes utiles

# Vérifier la compatibilité système
kata-runtime kata-check

# Version
kata-runtime --version

# Lister les pods actifs sous Kata (via containerd)
sudo crictl pods --runtime-class kata

# RuntimeClasses disponibles
kubectl get runtimeclass

# Vérifier quel nœud a Kata installé (via label ou test pod)
kubectl get nodes -o wide

Ressources

• Site officiel : https://katacontainers.io
• Documentation : https://docs.katacontainers.io
• GitHub : https://github.com/kata-containers/kata-containers
• Architecture (doc officielle) : https://github.com/kata-containers/kata-containers/tree/main/docs/design
• Comparaison hyperviseurs : https://github.com/kata-containers/kata-containers/blob/main/docs/hypervisors.md