Introduction
Le laboratoire précédent était axé sur les journaux (logs) et les événements. Bien qu'il s'agisse des premiers signaux à analyser, il est parfois nécessaire d'inspecter un conteneur en cours d'exécution ou d'accéder temporairement à un Service depuis votre terminal. Kubernetes propose deux outils courants pour cela : kubectl exec et kubectl port-forward.
Dans ce laboratoire, vous allez déployer une petite application web, utiliser kubectl exec pour inspecter les fichiers et les processus à l'intérieur d'un Pod, et utiliser kubectl port-forward pour ouvrir une connexion locale temporaire vers le Service. Le flux de travail est volontairement simple afin que vous puissiez vous concentrer sur les techniques de débogage plutôt que sur la complexité de l'application.
Préparer un espace de noms pour le débogage
Dans cette étape, vous allez préparer un espace de noms (namespace) propre pour pratiquer les commandes exec et port-forward.
Commencez dans /home/labex/project. Vous conserverez le manifeste de l'application dans ce répertoire.
mkdir -p /home/labex/project
cd /home/labex/project
Vérifiez que le serveur API Kubernetes est accessible. Si la machine virtuelle vient de démarrer et que le nœud n'est pas encore prêt, attendez quelques secondes et relancez la commande.
kubectl get nodes --request-timeout=5s
La sortie attendue inclut :
NAME STATUS ROLES AGE VERSION
labex-v135 Ready control-plane ... v1.35...
Attendez que le Pod réseau du cluster soit prêt. Le transfert de port utilise la connexion au serveur API, mais l'application nécessite toujours un Pod et un Service sains.
kubectl wait --namespace kube-system --for=condition=Ready pod -l k8s-app=calico-node --timeout=120s
Sortie attendue :
pod/calico-node-... condition met
Créez un espace de noms nommé ckad-prep-debug et définissez-le comme espace de noms actuel :
kubectl create namespace ckad-prep-debug
kubectl config set-context --current --namespace=ckad-prep-debug
Confirmez l'espace de noms actuel :
kubectl config view --minify --output 'jsonpath={..namespace}'; echo
Sortie attendue :
ckad-prep-debug
Déployer une petite application web
Dans cette étape, vous allez déployer une application simple à inspecter et à laquelle accéder.
Le Pod écrit un fichier index.html et exécute httpd de BusyBox sur le port 8080. Un Service nommé debug-web expose les Pods à l'intérieur du cluster sur le port 80. Le Service est inclus car kubectl port-forward peut cibler un Service tout comme un Pod.
Créez debug-web.yaml :
cat > debug-web.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: debug-web
spec:
replicas: 2
selector:
matchLabels:
app: debug-web
template:
metadata:
labels:
app: debug-web
spec:
terminationGracePeriodSeconds: 0
containers:
- name: web
image: busybox:1.36
command:
- /bin/sh
- -c
- |
mkdir -p /www
echo "debug-web-ready" > /www/index.html
httpd -f -p 8080 -h /www
ports:
- containerPort: 8080
readinessProbe:
httpGet:
path: /
port: 8080
initialDelaySeconds: 1
periodSeconds: 2
---
apiVersion: v1
kind: Service
metadata:
name: debug-web
spec:
selector:
app: debug-web
ports:
- port: 80
targetPort: 8080
EOF
Appliquez le manifeste et attendez le déploiement :
kubectl apply -f debug-web.yaml
kubectl rollout status deployment/debug-web --timeout=120s
La sortie attendue inclut :
deployment.apps/debug-web created
service/debug-web created
deployment "debug-web" successfully rolled out
Inspectez les Pods et le Service :
kubectl get pods -l app=debug-web
kubectl get service debug-web
La sortie attendue inclut deux Pods en cours d'exécution (Running) et un Service de type ClusterIP :
debug-web-... 1/1 Running
debug-web ClusterIP
Inspecter un conteneur en cours d'exécution avec exec
Dans cette étape, vous utiliserez kubectl exec pour exécuter des commandes à l'intérieur d'un Pod d'application.
kubectl exec est utile lorsque le Pod est en cours d'exécution mais que vous devez inspecter ce que le conteneur voit. Ce n'est pas un remplacement pour les journaux, et il ne doit pas être utilisé pour effectuer des correctifs manuels cachés lors d'un déploiement normal. Dans un flux de travail de débogage, il vous aide à confirmer les fichiers, les processus, l'environnement et le comportement du réseau local depuis l'intérieur du conteneur.
Stockez le nom d'un Pod dans une variable shell :
POD_NAME="$(kubectl get pods -l app=debug-web -o jsonpath='{.items[0].metadata.name}')"
echo "$POD_NAME"
La sortie attendue est le nom d'un Pod :
debug-web-...
Exécutez hostname à l'intérieur du conteneur. La sortie doit correspondre au nom du Pod, car Kubernetes définit le nom d'hôte du conteneur à partir du nom du Pod.
kubectl exec "$POD_NAME" -- hostname
Sortie attendue :
debug-web-...
Listez les processus en cours d'exécution à l'intérieur du conteneur :
kubectl exec "$POD_NAME" -- ps
La sortie attendue inclut le processus httpd :
PID USER TIME COMMAND
... root ... httpd -f -p 8080 -h /www
Lisez le fichier servi par le serveur web :
kubectl exec "$POD_NAME" -- cat /www/index.html
Sortie attendue :
debug-web-ready
Enfin, testez le serveur web depuis l'intérieur du même conteneur :
kubectl exec "$POD_NAME" -- wget -qO- http://127.0.0.1:8080
Sortie attendue :
debug-web-ready
Tester le Service avec le transfert de port
Dans cette étape, vous utiliserez kubectl port-forward pour accéder au Service depuis votre terminal.
Le transfert de port crée un tunnel temporaire entre un port local et un Pod ou un Service dans le cluster. C'est utile pour un débogage rapide car cela ne nécessite pas de modifier le type de Service, de créer un Ingress ou d'ouvrir un accès externe. Une commande kubectl port-forward lancée au premier plan continue de s'exécuter jusqu'à ce que vous l'arrêtiez ; ce laboratoire la lance donc en arrière-plan, la teste, puis l'arrête.
Lancez un transfert de port du port local 18080 vers le port 80 du Service. La sortie est écrite dans /tmp/debug-web-port-forward.log afin que le terminal reste utilisable.
kubectl port-forward service/debug-web 18080:80 > /tmp/debug-web-port-forward.log 2>&1 &
PF_PID=$!
sleep 3
cat /tmp/debug-web-port-forward.log
La sortie attendue inclut :
Forwarding from 127.0.0.1:18080 -> 8080
Envoyez une requête via le port local transféré :
wget -qO- http://127.0.0.1:18080
Sortie attendue :
debug-web-ready
Arrêtez le processus de transfert de port en arrière-plan. Ce nettoyage est important car, sinon, le port local resterait utilisé.
kill "$PF_PID"
wait "$PF_PID" 2>/dev/null || true
Confirmez que le journal du transfert de port a enregistré une connexion traitée :
cat /tmp/debug-web-port-forward.log
La sortie attendue inclut :
Handling connection for 18080
Résumé
Vous avez pratiqué deux outils de débogage essentiels. Vous avez utilisé kubectl exec pour inspecter le nom d'hôte, les processus, les fichiers et la réponse HTTP locale d'un conteneur en cours d'exécution. Vous avez également utilisé kubectl port-forward pour créer une connexion locale temporaire vers un Service de type ClusterIP, l'avez testée depuis le terminal et avez arrêté proprement le processus de transfert en arrière-plan.
