Bild von Autor | Ideogramm

# Einführung

Docker hat vereinfacht, wie wir Anwendungen entwickeln, versenden und ausführen, indem wir konsistente Umgebungen in verschiedenen Systemen bereitstellen. Diese Konsistenz enthält jedoch einen Kompromiss: Debugging wird für Anfänger täuschend komplex, wenn Ihre Anwendungen-einschließlich Python-Anwendungen-in Docker-Containern ausgeführt werden.

Für diejenigen, die neu in Docker sind, kann das Debuggen von Python -Anwendungen das Gefühl haben, ein Auto mit geschweißtem Kapuzen zu reparieren. Sie wissen, dass etwas nicht stimmt, aber Sie können nicht genau sehen, was drinnen passiert.

In diesem Anfänger-freundlichen Tutorial wird Ihnen beigebracht, wie Sie mit dem Debuggen von Python in Docker beginnen können.

# Warum ist Debugg in Docker anders?

Bevor wir eintauchen, verstehen wir, warum Docker das Debuggen schwierig macht. Wenn Sie Python lokal auf Ihrer Maschine ausführen, können Sie:

• Siehe sofort Fehlermeldungen
• Bearbeiten Sie Dateien und führen Sie sie erneut aus
• Verwenden Sie Ihre bevorzugten Debugging -Instruments
• Überprüfen Sie, welche Dateien vorhanden sind und was sich darin befindet

Aber wenn Python in einem Docker -Container läuft, ist es oft schwieriger und weniger direkt, besonders wenn Sie Anfänger sind. Der Container verfügt über ein eigenes Dateisystem, seine eigene Umgebung und seine eigenen laufenden Prozesse.

# Einrichten unseres Beispiels

Beginnen wir mit einem einfachen Python -Programm mit einem Fehler. Mach dir noch keine Sorgen um Docker. Lassen Sie uns zunächst verstehen, womit wir arbeiten.

Erstellen Sie eine Datei aufgerufen app.py:

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

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

if __name__ == "__main__":
    foremost()

Wenn Sie dies normalerweise mit laufen lassen python3 app.pySie werden sehen, dass es die Summe korrekt berechnet, aber dann mit einem „Teilung nach Null“ -Fehler abstürzt. Einfach zu erkennen und zu reparieren, oder?

Lassen Sie uns nun sehen, was passiert, wenn diese einfache Anwendung in einem Docker -Container ausgeführt wird.

# Erstellen Sie Ihren ersten Docker -Container

Wir müssen Docker sagen, wie er unser Python -Programm verpackt. Erstellen Sie eine Datei namens „Dockerfile“:

FROM python:3.11-slim

WORKDIR /app

COPY app.py .

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

Lassen Sie mich jede Zeile erklären:

• FROM python:3.11-slim fordert Docker auf, mit einem vorgefertigten Linux-System zu beginnen, dessen bereits Python installiert hat
• WORKDIR /app Erstellt im Container einen „/App“ -Fordner und legt ihn als Arbeitsverzeichnis fest
• COPY app.py . kopiert Ihre app.py Datei von Ihrem Laptop in den Ordner „/App“ im Container
• CMD ("python3", "app.py") Sagt Docker, welchen Befehl zum Ausführen des Containers erledigt werden soll

Lassen Sie uns nun diesen Behälter bauen und durchführen:

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

Sie werden die Ausgabe einschließlich des Fehlers sehen, aber dann stoppt der Container und verlässt. Dadurch werden Sie herausfinden, was im isolierten Behälter schief gelaufen ist.

# 1. Ausführen einer interaktiven Debugging -Sitzung

Die erste Debugging -Fähigkeit, die Sie benötigen, besteht darin, zu lernen, wie Sie in einen laufenden Container einsteigen und potenzielle Probleme überprüfen können.

Anstatt Ihr Python -Programm sofort auszuführen, starten wir den Container und erhalten Sie eine Eingabeaufforderung darin:

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

Lassen Sie mich diese neuen Flaggen aufschlüsseln:

• -i bedeutet „interaktiv“ – es hält den Eingabestream geöffnet, sodass Sie Befehle eingeben können
• -t verteilt ein „pseudo-tty“-im Grunde genommen das Terminal ordnungsgemäß funktioniert
• /bin/bash Überschreibt den normalen Befehl und gibt Ihnen stattdessen eine Bash -Shell

Nachdem Sie ein Terminal im Container haben, können Sie Befehle wie SO ausführen:

# See what listing you are in
pwd

# Record information within the present listing
ls -la

# Have a look at your Python file
cat app.py

# Run your Python program
python3 app.py

Sie werden auch den Fehler sehen:

root@fd1d0355b9e2:/app# python3 app.py
Including 1, whole is now 1
Including 2, whole is now 3
Including 3, whole is now 6
Including 4, whole is now 10
Including 5, whole is now 15
Last outcome: 15
Traceback (most up-to-date name final):
  File "/app/app.py", line 18, in 
    foremost()
  File "/app/app.py", line 14, in foremost
    division_result = 10 / 0
                      ~~~^~~
ZeroDivisionError: division by zero

Jetzt können Sie:

• Bearbeiten Sie die Datei hier im Container (obwohl Sie zuerst einen Editor installieren müssen)
• Erforschen Sie die Umgebung, um zu verstehen, was anders ist
• Testen Sie kleine Code -Teile interaktiv

Beheben Sie die Abteilung durch Nullfehler (möglicherweise `10 / 0` auf` 10 / 2`), speichern Sie die Datei und führen Sie sie erneut aus.

Das Downside ist behoben. Wenn Sie den Container verlassen, verlieren Sie jedoch den Überblick über die von Ihnen vorgenommenen Änderungen. Dies bringt uns zu unserer nächsten Technik.

# 2. Volumenmontage für Reside -Änderungen

Wäre es nicht schön, wenn Sie Dateien auf Ihrem Laptop bearbeiten und diese Änderungen automatisch im Container angezeigt werden könnten? Genau das macht die Volumenmontage.

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

Der neue Teil hier ist -v $(pwd):/app:

• $(pwd) gibt den aktuellen Verzeichnispfad aus.
• :/app ordnet Ihr aktuelles Verzeichnis auf /app im Behälter.
• Jede Datei, die Sie auf Ihrem Laptop ändern, ändert sich sofort im Container.

Jetzt können Sie:

1. Bearbeiten app.py Auf Ihrem Laptop mit Ihrem bevorzugten Editor
2. Im Behälter laufen python3 app.py Um Ihre Änderungen zu testen
3. Bearbeiten und testen Sie weiter, bis es funktioniert

Hier ist eine Beispielausgabe, nachdem der Divisor auf 2 geändert wurde:

root@3790528635bc:/app# python3 app.py
Including 1, whole is now 1
Including 2, whole is now 3
Including 3, whole is now 6
Including 4, whole is now 10
Including 5, whole is now 15
Last outcome: 15
Division outcome: 5.0

Dies ist nützlich, da Sie Ihre vertraute Bearbeitungsumgebung auf Ihrem Laptop und genau dieselbe Umgebung auch im Container verwenden können.

# 3.. Verbinden Sie einen entfernten Debugger aus Ihrer IDE

Wenn Sie eine integrierte Entwicklungsumgebung (ID) verwenden, wie Vs Code oder PycharmSie können den Debugger Ihrer IDE tatsächlich direkt an den Code anschließen, der in einem Docker -Container ausgeführt wird. Dies gibt Ihnen die volle Kraft der Debugging -Instruments Ihrer Ideen.

Bearbeiten Sie Ihre „Dockerfile“. SO:

FROM python:3.11-slim

WORKDIR /app

# Set up the distant debugging library
RUN pip set up debugpy

COPY app.py .

# Expose the port that the debugger will use
EXPOSE 5678

# Begin this system with debugger assist
CMD ("python3", "-m", "debugpy", "--listen", "0.0.0.0:5678", "--wait-for-client", "app.py")

Was das tut:

• pip set up debugpy Installiert Microsoft Debugpy Bibliothek.
• EXPOSE 5678 teilt Docker mit, dass unser Container Port 5678 verwendet.
• Der CMD Startet unser Programm über den Debugger und hört Port 5678 für eine Verbindung an. Es sind keine Änderungen an Ihrem Python -Code erforderlich.

Bauen und führen Sie den Container aus:

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

Der -p 5678:5678 Karten Sie Port 5678 vom Inneren des Containers zu Port 5678 auf Ihrem Laptop.

Jetzt im VS -Code können Sie eine Debug -Konfiguration einrichten (in .vscode/launch.json) um eine Verbindung zum Behälter herzustellen:

{
    "model": "0.2.0",
    "configurations": (
        {
            "title": "Python: Distant Connect",
            "sort": "python",
            "request": "connect",
            "join": {
                "host": "localhost",
                "port": 5678
            }
        }
    )
}

Wenn Sie mit dem Debuggen im VS -Code beginnen, wird eine Verbindung zu Ihrem Container hergestellt und Sie können Breakpoints festlegen, Variablen inspizieren und Code durchführen, genau wie Sie es mit lokalem Code tun würden.

# Häufige Debugging -Probleme und -Lösungen

„Mein Programm funktioniert auf meinem Laptop, aber nicht in Docker“

Dies bedeutet normalerweise, dass es einen Unterschied in der Umwelt gibt. Überprüfen:

• Python -Versionsunterschiede.
• Fehlende Abhängigkeiten.
• Verschiedene Dateipfade.
• Umgebungsvariablen.
• Dateiberechtigungen.

„Ich kann meine Druckaussagen nicht sehen“

• Verwenden python -u Um die Ausgabepufferung zu vermeiden.
• Stellen Sie sicher, dass Sie mit laufen -it Wenn Sie eine interaktive Ausgabe wünschen.
• Überprüfen Sie, ob Ihr Programm tatsächlich wie beabsichtigt ausgeführt wird (vielleicht austritt es früh).

„Meine Änderungen werden nicht angezeigt“

• Stellen Sie sicher, dass Sie Volumenmontage verwenden (-v).
• Überprüfen Sie, ob Sie die richtige Datei bearbeiten.
• Überprüfen Sie, ob die Datei in den Container kopiert wird.

„Der Container verlässt sofort“

• Rennen mit /bin/bash Um den Zustand des Behälters zu inspizieren.
• Überprüfen Sie die Fehlermeldungen mit docker logs container_name.
• Stellen Sie sicher, dass Ihre CMD in der Dockerfile ist korrekt.

# Abschluss

Sie haben jetzt ein grundlegendes Toolkit für das Debuggen von Python in Docker:

1. Interaktive Schalen (docker run -it ... /bin/bash) zum Erkunden und schnellen Korrekturen
2. Volumenmontage (-v $(pwd):/app) zur Bearbeitung in Ihrem lokalen Dateisystem
3. Distant -Debugging für die Nutzung der vollständigen Fähigkeiten Ihrer IDE

Danach können Sie versuchen, Docker Compose für die Verwaltung komplexer Anwendungen zu verwenden. Beginnen Sie vorerst mit diesen einfachen Techniken. Die meisten Debugging -Probleme können gelöst werden, indem Sie in den Container einsteigen und herumstochern.

Der Schlüssel ist, methodisch zu sein: Verstehen Sie, was passieren sollte, finden Sie heraus, was tatsächlich passiert, und schließen Sie dann die Lücke zwischen den beiden. Joyful Debugging!

Bala Priya c ist ein Entwickler und technischer Schriftsteller aus Indien. Sie arbeitet gern an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessensgebiete und Fachgebiete umfassen DevOps, Information Science und natürliche Sprachverarbeitung. Sie liest gerne, schreibt, codieren und Kaffee! Derzeit arbeitet sie daran, ihr Wissen mit der Entwicklergemeinschaft zu lernen und zu teilen, indem sie Tutorials, Anleitungen, Meinungsstücke und vieles mehr autorisiert. Bala erstellt auch ansprechende Ressourcenübersichten und Codierungs -Tutorials.

Bild von Autor | Leinwand

# Einführung

Traditionelles Debuggen mit print() Oder Protokollierung funktioniert, aber es ist langsam und klobig mit LLMs. Phoenix bietet eine Zeitleisteansicht aller Schritt-, Aufforderungs- und Antwortinspektion, Fehlererkennung mit Wiederholungen, Sichtbarkeit in Latenz und Kosten sowie ein vollständiges visuelles Verständnis Ihrer App. Phoenix von Arize AI ist ein leistungsstarkes Open-Supply-Beobachtungs- und -verfolgungswerkzeug, das speziell für LLM-Anwendungen entwickelt wurde. Es hilft Ihnen, alles in Ihren LLM -Pipelines visuell zu überwachen, zu debuggen und zu verfolgen. In diesem Artikel gehen wir durch das, was Phoenix tut und warum es wichtig ist, wie man Phoenix Schritt für Schritt in Langchain integriert und wie man Spuren in der UI von Phoenix visualisiert.

# Was ist Phoenix?

Phoenix ist ein Open-Supply-Beobachtbarkeits- und Debugging-Instrument für Großsprachmodellanwendungen. Es erfasst detaillierte Telemetriedaten aus Ihren LLM -Workflows, einschließlich Eingabeaufforderungen, Antworten, Latenz, Fehlern und Werkzeugen, und präsentiert diese Informationen in einem intuitiven interaktiven Dashboard. Mit Phoenix können Entwickler zutiefst verstehen, wie sich ihre LLM -Pipelines im System verhalten, Probleme mit schnellen Ausgaben identifizieren und debuggen, Leistungs Engpässe analysieren, mit Token und zugehörigen Kosten überwachen und alle Fehler/Wiederholungslogik während der Ausführungsphase verfolgen. Es unterstützt konsistente Integrationen mit beliebten Frameworks wie Langchain und Llamaindex und bietet auch OpenTelemetry -Unterstützung für maßgeschneiderte Setups.

# Schritt-für-Schritt-Setup

// 1. Installieren der erforderlichen Bibliotheken

Stellen Sie sicher, dass Sie Python 3.8+ haben und die Abhängigkeiten installieren:

pip set up arize-phoenix langchain langchain-together openinference-instrumentation-langchain langchain-community

// 2. Starten Sie Phoenix

Fügen Sie diese Zeile hinzu, um das Phoenix -Dashboard zu starten:

import phoenix as px
px.launch_app()

Dies startet ein lokales Armaturenbrett bei http: // localhost: 6006.

// 3.. Erstellen der Langchain -Pipeline mit Phoenix -Rückruf

Lassen Sie uns Phoenix anhand eines Anwendungsfalls verstehen. Wir bauen einen einfachen Langchain-Chatbot. Jetzt wollen wir:

• Debuggen, wenn die Eingabeaufforderung funktioniert
• Überwachen Sie, wie lange das Modell dauert, um zu reagieren
• Verfolgen Sie die Einlaufstruktur, die Modellverwendung und die Ausgänge
• Sehen Sie all dies visuell an, anstatt alles manuell zu protokollieren

// Schritt 1: Starten Sie das Phoenix -Dashboard im Hintergrund

import threading
import phoenix as px

# Launch Phoenix app regionally (entry at http://localhost:6006)
def run_phoenix():
    px.launch_app()

threading.Thread(goal=run_phoenix, daemon=True).begin()

// Schritt 2: Registrieren Sie Phoenix mit Opentelemetry & Instrument Langchain

from phoenix.otel import register
from openinference.instrumentation.langchain import LangChainInstrumentor

# Register OpenTelemetry tracer
tracer_provider = register()

# Instrument LangChain with Phoenix
LangChainInstrumentor().instrument(tracer_provider=tracer_provider)

// Schritt 3: Initialisieren Sie die LLM (zusammen API)

from langchain_together import Collectively

llm = Collectively(
    mannequin="meta-llama/Llama-3-8b-chat-hf",
    temperature=0.7,
    max_tokens=256,
    together_api_key="your-api-key",  # Change along with your precise API key
)

Bitte vergessen Sie nicht, den „Your-api-Key“ durch Ihren tatsächlichen zusammen.ai-API-Schlüssel zu ersetzen. Sie können es mit diesem erhalten Hyperlink.

// Schritt 4: Definieren Sie die Eingabeaufforderung Vorlage

from langchain.prompts import ChatPromptTemplate

immediate = ChatPromptTemplate.from_messages((
    ("system", "You're a useful assistant."),
    ("human", "{query}"),
))

// Schritt 5: Kombinieren Sie Eingabeaufforderung und Modell in eine Kette

// Schritt 6: Stellen Sie mehrere Fragen und drucken Antworten

questions = (
    "What's the capital of France?",
    "Who found gravity?",
    "Give me a motivational quote about perseverance.",
    "Clarify photosynthesis in a single sentence.",
    "What's the pace of sunshine?",
)

print("Phoenix working at http://localhost:6006n")

for q in questions:
    print(f" Query: {q}")
    response = chain.invoke({"query": q})
    print(" Reply:", response, "n")

// Schritt 7: Halten Sie die App für die Überwachung am Leben

strive:
    whereas True:
        go
besides KeyboardInterrupt:
    print(" Exiting.")

# Verständnis von Phoenix -Spuren und Metriken

Bevor wir die Ausgabe sehen, sollten wir zuerst Phoenix -Metriken verstehen. Sie müssen zuerst verstehen, welche Spuren und Spans sind:
Verfolgen: Jede Spur stellt einen vollständigen Lauf Ihrer LLM -Pipeline dar. Zum Beispiel wie jede Frage wie „Was ist die Hauptstadt Frankreichs?“ erzeugt eine neue Spur.
Spannweiten: Jede Spur ist von mehreren Spannweiten gemischt, die jeweils eine Stufe in Ihrer Kette darstellen:

• ChatpromptTemplate.Format: Eingabeaufforderung Formatierung
• Togetherll.invoke: LLM Name
• Alle benutzerdefinierten Komponenten, die Sie hinzufügen

Metriken professional Spur gezeigt

Jetzt besuchen Sie http: // localhost: 6006 Um das Phoenix -Dashboard anzuzeigen. Sie werden so etwas sehen wie:

Öffnen Sie die erste Spur, um seine Particulars anzuzeigen.

# Einpacken

Um es abzuschließen, macht es Arize Phoenix unglaublich einfach, Ihre LLM -Anwendungen zu debuggen, zu verfolgen und zu überwachen. Sie müssen nicht erraten, was schief gelaufen ist oder durch Protokolle graben. Alles ist genau richtig: Aufforderungen, Antworten, Timings und mehr. Es hilft Ihnen, Probleme zu erkennen, die Leistung zu verstehen und einfach bessere KI -Erlebnisse mit viel weniger Stress aufzubauen.

Kanwal Mehreen ist ein Ingenieur für maschinelles Lernen und technischer Schriftsteller mit einer tiefgreifenden Leidenschaft für die Datenwissenschaft und die Schnittstelle von KI mit Medizin. Sie hat das eBook „Produktivität mit Chatgpt maximieren“. Als Google -Era -Gelehrte 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie wird auch als Teradata -Vielfalt in Tech Scholar, MITACS Globalink Analysis Scholar und Harvard Wecode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter der Veränderung, nachdem er Femcodes gegründet hat, um Frauen in STEM -Bereichen zu stärken.