Débogage de Python dans Docker: un tutoriel pour les débutants

Image de l’auteur | Idéogramme

# Introduction

Docker a simplifié la façon dont nous développons, expédions et exécutons des applications en fournissant des environnements cohérents sur différents systèmes. Cependant, cette cohérence s’accompagne d’un compromis: le débogage devient trompeusement complexe pour les débutants lorsque vos applications – y compris les applications Python – fonctionnent à l’intérieur des conteneurs Docker.

Pour les nouveaux à Docker, les applications Python déboguent peuvent avoir l’impression d’essayer de réparer une voiture avec la fermeture soudée du capot. Vous savez que quelque chose ne va pas, mais vous ne pouvez pas vraiment voir ce qui se passe à l’intérieur.

Ce tutoriel pour les débutants vous apprendra à commencer par le débogage de Python dans Docker.

# Pourquoi le débogage dans Docker est-il différent?

Avant de plonger, comprenons pourquoi Docker rend le débogage délicat. Lorsque vous utilisez Python localement sur votre machine, vous pouvez:

• Voir les messages d’erreur immédiatement
• Modifier les fichiers et les exécuter à nouveau
• Utilisez vos outils de débogage préférés
• Vérifiez quels fichiers existent et ce qu’il y a

Mais lorsque Python fonctionne à l’intérieur d’un conteneur Docker, il est souvent plus délicat et moins direct, surtout si vous êtes un débutant. Le conteneur a son propre système de fichiers, son propre environnement et ses propres processus de fonctionnement.

# Configuration de notre exemple

Commençons par un simple programme Python qui a un bug. Ne vous inquiétez pas encore pour Docker; Comprenons d’abord avec quoi nous travaillons.

Créer un fichier appelé app.py:

def calculate_sum(numbers):
    total = 0
    for num in numbers:
        total += num
        print(f"Adding {num}, total is now {total}")
    return total

def main():
    numbers = (1, 2, 3, 4, 5)
    result = calculate_sum(numbers)
    print(f"Final result: {result}")
    
    # This line will cause our program to crash!
    division_result = 10 / 0
    print(f"Division result: {division_result}")

if __name__ == "__main__":
    main()

Si vous exécutez cela normalement avec python3 app.pyvous verrez qu’il calcule correctement la somme, mais se bloque ensuite avec une erreur « Division par zéro ». Facile à repérer et à réparer, non?

Voyons maintenant ce qui se passe lorsque cette application simple s’exécute dans un conteneur Docker.

# Créer votre premier conteneur Docker

Nous devons dire à Docker comment emballer notre programme Python. Créer un fichier appelé `dockerfile ‘:

FROM python:3.11-slim

WORKDIR /app

COPY app.py .

CMD ("python3", "app.py")

Permettez-moi d’expliquer chaque ligne:

• FROM python:3.11-slim dit à Docker de commencer avec un système Linux pré-fait qui a déjà installé Python
• WORKDIR /app Crée un dossier `/ app` à l’intérieur du conteneur et le définit comme le répertoire de travail
• COPY app.py . copie votre app.py fichier de votre ordinateur dans le dossier `/ app` à l’intérieur du conteneur
• CMD ("python3", "app.py") dit à docker quelle commande à exécuter lorsque le conteneur démarre

Maintenant, construisons et exécutons ce conteneur:

docker build -t my-python-app .
docker run my-python-app

Vous verrez la sortie, y compris l’erreur, mais le conteneur s’arrête et sort. Cela vous laisse pour comprendre ce qui n’a pas fonctionné à l’intérieur du récipient isolé.

# 1. Exécution d’une session de débogage interactive

La première compétence de débogage dont vous avez besoin est d’apprendre à pénétrer dans un conteneur en cours d’exécution et à vérifier les problèmes potentiels.

Au lieu d’exécuter immédiatement votre programme Python, commençons le conteneur et obtenons une invite de commande à l’intérieur:

docker run -it my-python-app /bin/bash

Permettez-moi de briser ces nouveaux drapeaux:

• -i signifie « interactif » – il maintient le flux d’entrée ouvert afin que vous puissiez taper des commandes
• -t alloue un « pseudo-tty » – en gros, cela fait fonctionner correctement le terminal
• /bin/bash remplace la commande normale et vous donne une coquille bash à la place

Maintenant que vous avez un terminal à l’intérieur du conteneur, vous pouvez exécuter des commandes comme tel:

# See what directory you're in
pwd

# List files in the current directory
ls -la

# Look at your Python file
cat app.py

# Run your Python program
python3 app.py

Vous verrez également l’erreur:

root@fd1d0355b9e2:/app# python3 app.py
Adding 1, total is now 1
Adding 2, total is now 3
Adding 3, total is now 6
Adding 4, total is now 10
Adding 5, total is now 15
Final result: 15
Traceback (most recent call last):
  File "/app/app.py", line 18, in 
    main()
  File "/app/app.py", line 14, in main
    division_result = 10 / 0
                      ~~~^~~
ZeroDivisionError: division by zero

Maintenant, vous pouvez:

• Modifiez le fichier ici dans le conteneur (bien que vous devrez d’abord installer un éditeur)
• Explorez l’environnement pour comprendre ce qui est différent
• Tester de petits morceaux de code de manière interactive

Corrigez la division par zéro erreur (peut-être changer `10/0` en` 10/2`), enregistrez le fichier et exécutez-le à nouveau.

Le problème est résolu. Cependant, lorsque vous quittez le conteneur, vous perdez la trace des modifications que vous avez apportées. Cela nous amène à notre prochaine technique.

# 2. Utilisation de montage de volume pour les modifications en direct

Ne serait-il pas bien si vous pouviez modifier des fichiers sur votre ordinateur et que ces modifications apparaissent automatiquement dans le conteneur? C’est exactement ce que fait le montage en volume.

docker run -it -v $(pwd):/app my-python-app /bin/bash

La nouvelle partie ici est -v $(pwd):/app:

• $(pwd) Sorte le chemin du répertoire actuel.
• :/app Carte votre répertoire actuel pour /app à l’intérieur du conteneur.
• Tout fichier que vous modifiez sur votre ordinateur change immédiatement à l’intérieur du conteneur.

Maintenant, vous pouvez:

1. Modifier app.py sur votre ordinateur en utilisant votre éditeur préféré
2. À l’intérieur du conteneur, courez python3 app.py Pour tester vos modifications
3. Continuez à éditer et à tester jusqu’à ce que cela fonctionne

Voici un exemple de sortie après avoir changé le diviseur en 2:

root@3790528635bc:/app# python3 app.py
Adding 1, total is now 1
Adding 2, total is now 3
Adding 3, total is now 6
Adding 4, total is now 10
Adding 5, total is now 15
Final result: 15
Division result: 5.0

Ceci est utile car vous pouvez également utiliser votre environnement d’édition familier sur votre ordinateur et exactement le même environnement à l’intérieur du conteneur.

# 3. Connexion d’un débogueur à distance de votre IDE

Si vous utilisez un environnement de développement intégré (IDE) comme VS Code ou Pycharmevous pouvez réellement connecter directement le débogueur de votre IDE au code exécutant dans un conteneur Docker. Cela vous donne la pleine puissance des outils de débogage de votre IDE.

Modifiez votre `dockerfile ‘comme ainsi:

FROM python:3.11-slim

WORKDIR /app

# Install the remote debugging library
RUN pip install debugpy

COPY app.py .

# Expose the port that the debugger will use
EXPOSE 5678

# Start the program with debugger support
CMD ("python3", "-m", "debugpy", "--listen", "0.0.0.0:5678", "--wait-for-client", "app.py")

Ce que cela fait:

• pip install debugpy Installe Microsoft débogue bibliothèque.
• EXPOSE 5678 dit à Docker que notre conteneur utilisera le port 5678.
• Le CMD Commence notre programme via le débogueur, écoutant sur le port 5678 pour une connexion. Aucune modification de votre code Python n’est nécessaire.

Construisez et exécutez le conteneur:

docker build -t my-python-app .
docker run -p 5678:5678 my-python-app

Le -p 5678:5678 Carte le port 5678 de l’intérieur du conteneur au port 5678 sur votre ordinateur.

Maintenant dans le code vs, vous pouvez configurer une configuration de débogage (en .vscode/launch.json) pour se connecter au conteneur:

{
    "version": "0.2.0",
    "configurations": (
        {
            "name": "Python: Remote Attach",
            "type": "python",
            "request": "attach",
            "connect": {
                "host": "localhost",
                "port": 5678
            }
        }
    )
}

Lorsque vous commencez à déboguer dans VS Code, il se connectera à votre conteneur et vous pouvez définir des points d’arrêt, inspecter les variables et parcourir le code comme vous le feriez avec le code local.

# Problèmes et solutions de débogage communs

⚠️ « Mon programme fonctionne sur mon ordinateur mais pas dans Docker »

Cela signifie généralement qu’il y a une différence dans l’environnement. Vérifier:

• Différences de version Python.
• Dépendances manquantes.
• Différents chemins de fichier.
• Variables d’environnement.
• Permissions de fichiers.

⚠️ « Je ne vois pas mes déclarations d’impression »

• Utiliser python -u Pour éviter la mise en mémoire tampon de sortie.
• Assurez-vous que vous courez avec -it Si vous voulez une sortie interactive.
• Vérifiez si votre programme fonctionne réellement comme prévu (peut-être qu’il sort tôt).

⚠️ « Mes changements ne se présentent pas »

• Assurez-vous que vous utilisez le montage en volume (-v).
• Vérifiez que vous modifiez le bon fichier.
• Vérifiez que le fichier est copié dans le conteneur.

⚠️ « Le conteneur sort immédiatement »

• Courir avec /bin/bash pour inspecter l’état du conteneur.
• Vérifiez les messages d’erreur avec docker logs container_name.
• Assurez-vous que votre CMD dans le dockerfile est correct.

# Conclusion

Vous avez maintenant une boîte à outils de base pour déboguer Python dans Docker:

1. Coquilles interactives (docker run -it ... /bin/bash) pour l’exploration et les correctifs rapides
2. Montage de volume (-v $(pwd):/app) pour l’édition dans votre système de fichiers local
3. Débogage à distance pour l’utilisation des capacités complètes de votre IDE

Après cela, vous pouvez essayer d’utiliser Docker Compose pour gérer des applications complexes. Pour l’instant, commencez par ces techniques simples. La plupart des problèmes de débogage peuvent être résolus simplement en pénétrant dans le conteneur et en poussant.

La clé est d’être méthodique: comprendre ce qui devrait se passer, découvrir ce qui se passe réellement, puis combler l’écart entre les deux. Joyeux débogage!

Bala Priya C est développeur et écrivain technique d’Inde. Elle aime travailler à l’intersection des mathématiques, de la programmation, de la science des données et de la création de contenu. Ses domaines d’intérêt et d’expertise incluent DevOps, la science des données et le traitement du langage naturel. Elle aime lire, écrire, coder et café! Actuellement, elle travaille sur l’apprentissage et le partage de ses connaissances avec la communauté des développeurs en créant des tutoriels, des guides pratiques, des pièces d’opinion, etc. Bala crée également des aperçus de ressources engageants et des tutoriels de codage.