Premier Pod Kubernetes : creer, inspecter et supprimer avec kubectl run, describe et delete

Comment creer un premier Pod Kubernetes, l’inspecter avec kubectl describe, puis le supprimer proprement avec kubectl delete ? A partir du depot kubernetes-tutorials-new-version et de la video Kubernetes 009 - Premiers Pods : kubectl run, describe, delete, ce chapitre pose le cycle minimal pour debuter sur les Pods avant de passer aux manifests YAML.

TL;DR

• Un Pod est la plus petite unite deployable dans Kubernetes.
• kubectl run permet de lancer rapidement un Pod pour apprendre, tester ou debugger.
• kubectl describe sert a lire l’etat detaille d’un Pod, ses evenements et sa configuration.
• kubectl delete ferme la boucle en supprimant proprement la ressource.
• Le depot montre aussi des variantes utiles avec --command, --overrides et un Pod de debug interactif.
• La suite logique du parcours est 010-pods-manifests, ou le meme apprentissage bascule vers des manifests YAML.

En une phrase : un Pod Kubernetes est la plus petite unite deployable du cluster, et ce chapitre montre comment le creer, l’observer et le supprimer avec les commandes kubectl les plus utiles pour debuter.

La video de reference

La video canonique de ce chapitre est https://www.youtube.com/watch?v=ElVwAByDkf4.

Elle appartient a la playlist Kubernetes v2 : formation et tutoriels pour debuter.

Le titre YouTube est explicite : Kubernetes 009 - Premiers Pods : kubectl run, describe, delete. Dans le README.md du depot, cette meme video est referencee comme l’episode 10 de la phase fondations, avec un resume centre sur la creation, l’inspection et la gestion pratique des Pods.

Pod Kubernetes : definition simple

Un Pod est l’objet de base que Kubernetes deploie et pilote. En pratique, c’est une enveloppe qui contient un ou plusieurs conteneurs, un reseau partage, et eventuellement des volumes partages.

• L’image contient votre application empaquetee.
• Le conteneur est l’execution de cette image.
• Le Pod est l’unite que Kubernetes schedule, observe et redemarre.

Definition courte a retenir : un Pod Kubernetes est l’unite que le scheduler place sur un noeud pour executer une application conteneurisee.

Pourquoi apprendre les Pods avant les manifests YAML ?

Quand on commence Kubernetes, on peut facilement se perdre entre la theorie de l’architecture, les fichiers YAML parfois trop verbeux pour une premiere approche, et les objets Kubernetes qui se ressemblent au debut.

Le chapitre 009-kubectl-run-first-pods tranche ce probleme de facon pragmatique. Le fichier 009-kubectl-run-first-pods/notes pose un cycle d’apprentissage tres court :

1. lancer un Pod
2. le supprimer
3. modifier la commande executee
4. tester un comportement de redemarrage
5. ouvrir un Pod jetable de debug

Comment fonctionne un premier Pod Kubernetes ?

1. kubectl envoie une demande au serveur d’API Kubernetes.
2. Kubernetes enregistre l’objet Pod voulu.
3. Le scheduler choisit un noeud si le Pod peut etre place.
4. Le kubelet du noeud lance les conteneurs via le runtime.
5. Vous observez ensuite le resultat avec kubectl get, kubectl describe, kubectl logs ou kubectl exec.

L’interet du triptyque run / describe / delete, c’est justement de rendre visible ce cycle sans encore introduire Deployments, ReplicaSets ou controllers plus haut niveau.

Quelles commandes kubectl retenir pour debuter ?

Commande	Role	Ce qu’elle vous apprend
kubectl run nginx --image=nginx	Cree un premier Pod	Le lien entre image et Pod
kubectl delete pods nginx	Supprime le Pod	Le cycle de vie minimal d’une ressource
kubectl run nginx --image=nginx --command -- sleep 10s	Remplace le point d’entree	La difference entre image et commande lancee
kubectl run nginx --image=nginx -- sleep 10s	Passe des arguments	La nuance entre commande et arguments
kubectl run debug -ti --image=debian -- bash	Lance un shell jetable	L’usage du Pod comme outil de debug

Exemple minimal :

kubectl run nginx --image=nginx
kubectl describe pod nginx
kubectl delete pod nginx

A quoi sert kubectl describe sur un Pod ?

kubectl get pods donne une vue rapide. kubectl describe pod nginx donne le detail exploitable :

• le noeud cible
• l’image utilisee
• l’adresse IP du Pod
• les conditions du Pod
• les evenements recents, souvent decisifs pour diagnostiquer un souci de pull, de scheduling ou de crash

Notions et concepts a retenir sur les Pods Kubernetes

kubectl run sert surtout a apprendre, tester, depanner

La documentation officielle de kubectl run le positionne comme une commande pour creer et lancer une image dans un Pod. C’est tres pratique pour verifier vite qu’une image demarre, tester une commande courte, lancer un conteneur temporaire ou ouvrir un shell dans un environnement jetable.

L’image n’est pas toute l’histoire

kubectl run nginx --image=nginx --command -- sleep 10s
kubectl run nginx --image=nginx -- sleep 10s

Ces deux variantes montrent qu’il faut aussi comprendre la commande finale executee, les arguments transmis et le comportement du processus principal.

Un Pod est un objet API modifiable

kubectl run nginx --image=nginx --overrides='{ "spec": {"restartPolicy": "OnFailure"}}' --command -- sleep 10s

Cette commande montre qu’un Pod est un objet Kubernetes avec une spec complete, pas juste une image lancee rapidement.

Le Pod de debug est un usage tres concret

kubectl run debug -ti --image=debian -- bash

Ce cas d’usage est tres pratique pour tester DNS, reseau, connectivite ou commandes systeme depuis le cluster.

kubectl run ou manifest YAML ?

Le chapitre suivant du depot, 010-pods-manifests, montre la transition vers le declaratif :

kubectl run nginx --image=nginx --dry-run=client -o yaml
kubectl create deployment nginx --image=nginx --dry-run=client -o yaml

Approche	Quand l’utiliser	Avantage	Limite
kubectl run	apprentissage, test, debug	tres rapide	peu relisible si la commande grossit
manifest YAML	demo stable, revision Git, reproduction	versionnable et clair	un peu plus verbeux au debut

Comment creer un Pod nginx en demo rapide ?

kubectl run nginx --image=nginx
kubectl get pods
kubectl describe pod nginx
kubectl delete pod nginx

Pour voir la transition vers le declaratif :

kubectl run nginx --image=nginx --dry-run=client -o yaml

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
    - containerPort: 80

Quand utiliser un Pod seul ?

Utilisez un Pod seul pour apprendre, tester, debugger ou observer le comportement d’une image. Pour une application qui doit durer, etre replicaable ou versionnee proprement, passez a un Deployment ou a un manifest declare dans Git.

Liens utiles

• Depot principal
• README du depot
• Chapitre 009
• Chapitre 010
• Exemple YAML du chapitre 010
• Documentation kubectl run
• Documentation kubectl describe
• Documentation kubectl delete
• Documentation officielle sur les Pods
• Video YouTube
• Playlist YouTube

FAQ

Un Pod, c’est pareil qu’un conteneur ?

Non. Un Pod est l’unite geree par Kubernetes. Il contient un ou plusieurs conteneurs, avec un reseau et des ressources partagees.

kubectl run cree-t-il un Deployment ?

Dans la documentation actuelle, kubectl run cree et lance une image dans un Pod. Si vous voulez un objet plus haut niveau, il faut utiliser une autre commande ou un manifest adapte.

A quoi sert kubectl describe si kubectl get pods existe deja ?

kubectl get pods donne une vue rapide. kubectl describe donne le detail exploitable : image, noeud, conditions, evenements et messages utiles pour le diagnostic.

Pourquoi la commande –overrides est-elle interessante dans ce chapitre ?

Parce qu’elle montre qu’un Pod est un objet API avec une spec complete, pas juste une image lancee par une commande simplifiee.

Quelle est la suite logique apres ce chapitre ?

Le depot enchaine naturellement avec 010-pods-manifests, ou vous generez puis ecrivez un manifest YAML. C’est la bonne etape pour passer d’un test rapide a une definition plus propre et versionnable.

Conclusion

Ce chapitre Kubernetes sur les premiers Pods fait exactement ce qu’il doit faire : il reduit l’entree dans Kubernetes a un cycle tres court, tres concret, et tres utile.

Le depot sert ici de colonne vertebrale factuelle :

• README.md positionne l’episode dans la progression globale
• 009-kubectl-run-first-pods/notes montre les commandes minimales et leurs variantes utiles
• 010-pods-manifests/notes et 010-pods-manifests/1-pod.yml ouvrent la porte vers le declaratif

La video, elle, donne le bon angle pedagogique : partir de kubectl run, apprendre a observer avec describe, puis fermer proprement la boucle avec delete.

Pour un debutant, c’est exactement le bon ordre.