Erste Schritte

Docker-Schnellstartanleitung für Ultralytics

Ultralytics Docker images on Docker Hub

Diese Anleitung zeigt dir, wie du eine Docker-Umgebung für deine Ultralytics-Projekte einrichtest. Docker ist eine Plattform zum Entwickeln, Bereitstellen und Ausführen von Anwendungen in Containern. Dadurch wird sichergestellt, dass die Software unabhängig vom Bereitstellungsort gleich funktioniert.

Docker-Image-Version Docker-Downloads

Das lernst du#

  • Docker mit NVIDIA-Unterstützung einrichten
  • Ultralytics-Docker-Images installieren
  • Ultralytics in einem Docker-Container mit CPU- oder GPU-Unterstützung ausführen
  • Einen Anzeigeserver mit Docker verwenden, um Ultralytics-Erkennungsergebnisse anzuzeigen
  • Lokale Verzeichnisse in den Container einbinden


Ansehen: So legst du mit Docker los | Live-Demo zur Verwendung des Ultralytics-Python-Pakets in Docker 🎉

Voraussetzungen#

  • Stelle sicher, dass Docker auf deinem System installiert ist. Falls nicht, kannst du Docker von der Docker-Website herunterladen und installieren.
  • Für die GPU-Beschleunigung benötigst du eine NVIDIA-GPU und installierte NVIDIA-Treiber. Für CPU-Images ist keine NVIDIA-Hardware erforderlich.
  • Wenn du NVIDIA Jetson-Geräte verwendest, stelle sicher, dass die passende JetPack-Version installiert ist. Weitere Informationen findest du in der NVIDIA-Jetson-Anleitung.

Docker mit NVIDIA-Unterstützung einrichten (optional)#

Prüfe zunächst mit folgendem Befehl, ob die NVIDIA-Treiber ordnungsgemäß installiert sind:

nvidia-smi

NVIDIA Container Toolkit installieren#

Installiere das NVIDIA Container Toolkit, um GPU-Unterstützung in Docker-Containern zu aktivieren:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
  | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
    | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Aktualisiere die Paketlisten und installiere das NVIDIA Container Toolkit:

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

CDI-Geräte mit Docker überprüfen#

Führe nvidia-ctk cdi list aus, um sicherzustellen, dass die GPU-CDI-Geräte verfügbar sind (der Dienst nvidia-cdi-refresh des Toolkits erstellt und verwaltet die Spezifikation ab Toolkit-Version >= 1.18 automatisch):

nvidia-ctk cdi list

Es sollten Einträge wie nvidia.com/gpu=0 und nvidia.com/gpu=all angezeigt werden. Erkannte CDI-Geräte erscheinen auch in docker info.

Ultralytics-Docker-Images installieren#

Ultralytics veröffentlicht die folgenden Images auf Docker Hub. Jedes Image wird anhand des verlinkten Dockerfiles durch den Docker-Veröffentlichungsworkflow erstellt.

TagPlattform und ZweckQuelle
latestLinux AMD64 mit CUDA für GPU-Training und -InferenzDockerfile
latest-exportLinux AMD64 mit CUDA und Exportabhängigkeiten für Konvertierung und BenchmarkingDockerfile-export
latest-amdLinux AMD64 mit ROCm und MIGraphX für GPU-Training und -Inferenz mit AMD-GPUsDockerfile-amd
latest-pythonSchlankes Linux-AMD64-Python-3.14-Image für CPU-InferenzDockerfile-python
latest-python-exportLinux-AMD64-Python-3.13-CPU-Image mit ExportabhängigkeitenDockerfile-python-export
latest-cpuLinux-AMD64-CPU-Image mit Bash als StandardbefehlDockerfile-cpu
latest-jupyterLinux-AMD64-CPU-Image mit JupyterLab und Ultralytics-Tutorial-NotebooksDockerfile-jupyter
latest-arm64Linux-ARM64-Python-3.13-CPU-Image für Apple Silicon, Raspberry Pi und andere ARM64-SystemeDockerfile-arm64
latest-nvidia-arm64Linux ARM64 für DGX Spark (DGX OS) und PyTorch auf Thor (JetPack 7.1); das enthaltene TensorRT unterstützt JetPack nichtDockerfile-nvidia-arm64
latest-jetson-jetpack6Linux ARM64 für NVIDIA-Jetson-Geräte mit JetPack 6Dockerfile-jetson-jetpack6
latest-jetson-jetpack5Linux ARM64 für NVIDIA-Jetson-Geräte mit JetPack 5Dockerfile-jetson-jetpack5
latest-jetson-jetpack4Linux ARM64 für NVIDIA-Jetson-Geräte mit JetPack 4Dockerfile-jetson-jetpack4
latest-runnerLinux-AMD64-CUDA-Image für selbst gehostete GitHub-Actions-GPU-RunnerDockerfile-runner
latest-runner-cpuLinux-AMD64-Image für selbst gehostete GitHub-Actions-CPU-RunnerDockerfile-runner-cpu

Die AMD64-GPU-Images (latest, latest-export und latest-runner) verwenden PyTorch 2.15 und CUDA 13.2. Prüfe mit nvidia-smi die CUDA-Unterstützung des Hosttreibers, bevor du sie startest. Die Installation eines neueren Containers aktualisiert den Hosttreiber nicht. CUDA 13 stellt die Unterstützung ein für Maxwell-, Pascal- und Volta-GPUs, einschließlich Tesla P100 und V100.

Das NVIDIA-ARM64-Image verwendet NVIDIA PyTorch 26.10 mit CUDA 13.4 und TensorRT 11.4. Die PyTorch-Unterstützung für Thor umfasst jedoch nicht TensorRT: NVIDIA unterstützt TensorRT 11.4 nicht auf JetPack. Verwende für TensorRT-Exporte auf Jetson die unterstützte TensorRT-10.x-Laufzeitumgebung für deine JetPack-Version. Beachte die Plattformanforderungen im Jetson-Leitfaden oder im DGX-Spark-Leitfaden. Die Images für JetPack 4, 5 und 6 behalten ihre jeweils gerätespezifischen Software-Stacks bei.

Das Conda-Dockerfile steht für lokale Builds zur Verfügung. Die automatisierte Veröffentlichung von latest-conda ist deaktiviert, daher enthält dieser Registry-Tag diese Aktualisierungen nicht.

Die Python-, CPU-, Jupyter- und CPU-Runner-Images verwenden Python 3.14. Das Python-Export-Image verwendet das Basis-Image latest-python-3.13, das aus demselben Dockerfile-python mit --build-arg PYTHON_VERSION=3.13 erstellt wurde, da TensorFlow, CoreML und PaddlePaddle Python 3.14 noch nicht unterstützen.

Tags mit dem Präfix latest beziehen sich auf den zuletzt veröffentlichten Build des Hauptbranches. Bei Versionstags wird das Präfix latest durch eine Ultralytics-Version ersetzt, zum Beispiel durch VERSION, VERSION-cpu oder VERSION-jetson-jetpack6. Verwende einen Versionstag für eine reproduzierbare Umgebung.

So lädst du das neueste Image herunter:

# Pull the latest Ultralytics image from Docker Hub
sudo docker pull ultralytics/ultralytics:latest

Wenn du stattdessen selbst ein Image erstellen möchtest, klone das Repository und übergib das passende Dockerfile aus der obigen Tabelle. Verwende dabei das Repository-Stammverzeichnis als Build-Kontext:

# Build the CPU image locally from docker/Dockerfile-cpu
sudo docker build -t ultralytics/ultralytics:latest-cpu -f docker/Dockerfile-cpu .

Ultralytics in einem Docker-Container ausführen#

So führst du den Ultralytics-Docker-Container aus:

Nur die CPU verwenden#

# Run without GPU
sudo docker run -it --ipc=host ultralytics/ultralytics:latest-cpu

GPUs verwenden#

# Run with all GPUs
sudo docker run -it --ipc=host --device nvidia.com/gpu=all ultralytics/ultralytics:latest

# Run specifying which GPUs to use
sudo docker run -it --ipc=host --device nvidia.com/gpu=2 --device nvidia.com/gpu=3 ultralytics/ultralytics:latest

Das Flag -it weist ein Pseudo-TTY zu und hält die Standardeingabe geöffnet, sodass du mit dem Container interagieren kannst. Das Flag --ipc=host ermöglicht die gemeinsame Nutzung des IPC-Namensraums des Hosts, was für den Austausch von Speicher zwischen Prozessen erforderlich ist. Für NVIDIA-GPUs gewährt das Flag --device nvidia.com/gpu=... über CDI Zugriff. Für AMD-GPUs gewähren die Flags --device Zugriff auf den GPU-Kerneltreiber (/dev/kfd) und die Renderknoten für die Anzeige (/dev/dri).

CDI statt `--gpus all` verwenden

Unter Linux erfordern CDI-Geräteanforderungen Docker >= 28.2.0 (CDI standardmäßig aktiviert) und nvidia-container-toolkit >= 1.18 (automatische Erstellung der CDI-Spezifikation). Aktualisiere ältere Linux-Hosts, bevor du GPU-Container ausführst. Das ältere Flag --gpus all kann zum Verlust des GPU-Zugriffs (Failed to initialize NVML: Unknown Error) führen, wenn der Host systemd während regulärer Paketaktualisierungen neu lädt (nvidia-container-toolkit#48). CDI---device-Anforderungen nehmen die Gerätenodes in die Containerkonfiguration auf. So bleibt der GPU-Zugriff bei lang laufenden Containern wie Trainingsprozessen oder CI-Runnern auch nach einem Neuladen erhalten.

Die GPU-Unterstützung von Docker Desktop unter Windows verwendet derzeit --gpus all mit dem WSL-2-Backend, da NVIDIA-CDI-Geräte dort nicht verfügbar sind. Windows verwendet kein Linux-systemd, daher tritt der oben beschriebene Fehler beim Neuladen des Daemons dort nicht auf.

Hinweis zum Zugriff auf Dateien#

Um im Container auf Dateien deines lokalen Rechners zuzugreifen, kannst du Docker-Volumes verwenden:

# Mount a local directory into the container
sudo docker run -it --ipc=host --device nvidia.com/gpu=all -v /path/on/host:/path/in/container ultralytics/ultralytics:latest

Ersetze /path/on/host durch den Verzeichnispfad auf deinem lokalen Rechner und /path/in/container durch den gewünschten Pfad im Docker-Container.

Trainingsergebnisse dauerhaft speichern#

Trainingsergebnisse werden standardmäßig im Container unter /ultralytics/runs/<task>/<name>/ gespeichert. Ohne ein eingebundenes Hostverzeichnis gehen die Ergebnisse verloren, wenn der Container entfernt wird.

So speicherst du Trainingsergebnisse dauerhaft:

# Recommended: mount workspace and specify project path
sudo docker run --rm -it -v "$(pwd)":/w -w /w ultralytics/ultralytics:latest \
  yolo train model=yolo26n.pt data=coco8.yaml project=/w/runs

Dadurch werden alle Trainingsergebnisse unter ./runs auf deinem Host-Rechner gespeichert.

Grafische Benutzeroberflächen (GUI) in einem Docker-Container ausführen#

Hochgradig experimentell – Nutzung auf eigenes Risiko

Die folgenden Anweisungen sind experimentell. Das Freigeben eines X11-Sockets für einen Docker-Container birgt potenzielle Sicherheitsrisiken. Daher wird empfohlen, diese Lösung nur in einer kontrollierten Umgebung zu testen.

Docker wird hauptsächlich verwendet, um Hintergrundanwendungen und CLI-Programme in Containern auszuführen, kann aber auch grafische Programme ausführen. In der Linux-Welt übernehmen zwei wichtige Grafikserver die grafische Anzeige: X11 (auch als X Window System bekannt) und Wayland. Bevor du loslegst, musst du unbedingt herausfinden, welchen Grafikserver du derzeit verwendest. Führe dazu diesen Befehl aus:

env | grep -E -i 'x11|xorg|wayland'

Die Einrichtung und Konfiguration eines X11- oder Wayland-Anzeigeservers ist nicht Gegenstand dieser Anleitung. Wenn der obige Befehl keine Ausgabe liefert, musst du zunächst einen der beiden Server auf deinem System zum Laufen bringen, bevor du fortfährst.

Einen Docker-Container mit grafischer Oberfläche ausführen#

Beispiel
GPUs verwenden

Wenn du GPUs verwendest, kannst du das Flag --device nvidia.com/gpu=all zum Befehl hinzufügen.

Wenn du X11 verwendest, kannst du mit dem folgenden Befehl dem Docker-Container den Zugriff auf den X11-Socket erlauben:

xhost +local:docker && docker run -e DISPLAY=$DISPLAY \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  -v ~/.Xauthority:/root/.Xauthority \
  -it --ipc=host ultralytics/ultralytics:latest

Dieser Befehl setzt die Umgebungsvariable DISPLAY auf die Anzeige des Hosts, bindet den X11-Socket ein und ordnet die Datei .Xauthority dem Container zu. Mit dem Befehl xhost +local:docker erhält der Docker-Container Zugriff auf den X11-Server.

Docker mit grafischer Oberfläche verwenden#

Ultralytics-Images werden mit einer headless-Version von OpenCV ausgeliefert. Installiere daher zuerst die Version mit grafischer Benutzeroberfläche von OpenCV und die zugehörigen Systembibliotheken im Container:

apt-get update && apt-get install -y --no-install-recommends libgl1 libglib2.0-0 libsm6
pip uninstall -y opencv-python-headless && pip install opencv-python

Jetzt kannst du grafische Anwendungen in deinem Docker-Container anzeigen. Zum Beispiel kannst du den folgenden CLI-Befehl ausführen, um die Vorhersagen eines YOLO26-Modells zu visualisieren:

yolo predict model=yolo26n.pt show=True
Testen

Eine einfache Möglichkeit zu prüfen, ob die Docker-Gruppe Zugriff auf den X11-Server hat, besteht darin, einen Container mit einem GUI-Programm wie xclock oder xeyes auszuführen. Alternativ kannst du diese Programme auch im Ultralytics-Docker-Container installieren, um den Zugriff auf den X11-Server deines GNU/Linux-Anzeigeservers zu testen. Falls Probleme auftreten, kannst du die Umgebungsvariable -e QT_DEBUG_PLUGINS=1 setzen. Dadurch wird die Ausgabe von Debugging-Informationen aktiviert, die bei der Fehlersuche helfen.

Wenn du mit der Docker-GUI fertig bist#

Zugriff widerrufen

Vergiss in beiden Fällen nicht, der Docker-Gruppe den Zugriff zu entziehen, wenn du fertig bist.

xhost -local:docker
Möchtest du Bildergebnisse direkt im Terminal anzeigen?

Unter Linux und macOS kannst du mit dem Protokoll sixel Bildergebnisse im integrierten VSCode-Terminal anzeigen.

Jetzt kannst du Ultralytics mit Docker verwenden. Wenn du die Ultralytics-Webanwendung selbst hosten möchtest, findest du weitere Informationen in der Anleitung zur lokalen Bereitstellung der Plattform.

Häufig gestellte Fragen#

  • Um Ultralytics mit Docker einzurichten, stelle zunächst sicher, dass Docker auf deinem System installiert ist. Wenn du eine NVIDIA-GPU hast, installiere das NVIDIA Container Toolkit, um die GPU-Unterstützung zu aktivieren. Lade anschließend mit folgendem Befehl das neueste Ultralytics-Docker-Image von Docker Hub herunter:

    sudo docker pull ultralytics/ultralytics:latest
  • Die Verwendung von Ultralytics-Docker-Images sorgt für eine einheitliche Umgebung auf verschiedenen Rechnern, da dieselbe Software und dieselben Abhängigkeiten bereitgestellt werden. Das ist besonders nützlich für die Zusammenarbeit in Teams, die Ausführung von Modellen auf unterschiedlicher Hardware und die reproduzierbare Bereitstellung von Modellen. Verwende latest für allgemeines Training mit NVIDIA-GPUs oder wähle das Image, das zu deiner JetPack-Version für ein NVIDIA-Jetson-Gerät passt.

  • Stelle zunächst sicher, dass das NVIDIA Container Toolkit installiert und konfiguriert ist. Führe Ultralytics YOLO dann mit dem folgenden Befehl mit GPU-Unterstützung aus:

    sudo docker run -it --ipc=host --device nvidia.com/gpu=all ultralytics/ultralytics:latest # all GPUs

    Mit diesem Befehl richtest du einen Docker-Container mit GPU-Zugriff ein. Du kannst den Zugriff auf bestimmte GPUs beschränken oder stattdessen AMD ROCm verwenden.

  • Um YOLO-Vorhersagen mit einer grafischen Oberfläche in einem Docker-Container zu visualisieren, musst du Docker den Zugriff auf deinen Anzeigeserver erlauben. Für Systeme mit X11 lautet der Befehl:

    xhost +local:docker && docker run -e DISPLAY=$DISPLAY \
      -v /tmp/.X11-unix:/tmp/.X11-unix \
      -v ~/.Xauthority:/root/.Xauthority \
      -it --ipc=host ultralytics/ultralytics:latest

    Verwende für Systeme mit Wayland folgenden Befehl:

    xhost +local:docker && docker run -e DISPLAY=$DISPLAY \
      -v $XDG_RUNTIME_DIR/$WAYLAND_DISPLAY:/tmp/$WAYLAND_DISPLAY \
      --net=host -it --ipc=host ultralytics/ultralytics:latest

    Installiere im Container die Version von OpenCV mit grafischer Benutzeroberfläche, bevor du show=True verwendest, wie im Abschnitt Grafische Benutzeroberflächen (GUI) in einem Docker-Container ausführen beschrieben.

  • Ja, du kannst lokale Verzeichnisse mit dem Flag -v in den Ultralytics-Docker-Container einbinden:

    sudo docker run -it --ipc=host --device nvidia.com/gpu=all -v /path/on/host:/path/in/container ultralytics/ultralytics:latest

    Ersetze /path/on/host durch das Verzeichnis auf deinem lokalen Rechner und /path/in/container durch den gewünschten Pfad im Container. So kannst du im Container mit deinen lokalen Dateien arbeiten. Weitere Informationen findest du im Abschnitt Hinweis zur Dateizugänglichkeit.

Kommentare14

Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.

  1. Letícia Rama

    Hello,

    Is this workflow suitable for other YOLO families, such as YOLO26?

    1. Glenn JocherUltralytics

      Yes, the same workflow supports YOLO26 and other model families available in the ultralytics package—use an up-to-date official image and specify the appropriate weights, such as model=yolo26n.pt. See the Docker Quickstart Guide for current image options, and feel free to drop any follow-up questions here so the Ultralytics team can help.

      1
  2. HellaPinotGitHub

    Hello! I have been testing running yolov8 inside a container, things seem to work well however after a somewhat random amount of time the inference hangs with no error output.

    I know the container hasn't crashed as I am reading events from a processing queue and I can see new partitions are being allocated on another thread.

    I'm running two models one after the other (different sizes and detection classes), so I'm wondering if this could be the root of the issue? At no point would they be running at the same time.

    I believe it is happening exactly when I call predict. Its hard to debug as again it happens very randomly and there is not output from the container, it seems like there might be an infinite loop somewhere thats stopping it from continuing.

    Curious if anything like this has been encountered before?

    1. Glenn JocherUltralytics

      Hello! 👋

      It sounds like a tricky issue, especially since it occurs randomly. Here are a few suggestions that might help you isolate or resolve the problem:

      1. Logging and Monitoring: Enhance the logging within your container. Consider logging the input sizes and other relevant data before the prediction call, and make sure you're logging any exceptions that could be silently caught.

      2. Resource Checks: Ensure that there are no resource starvation issues, such as GPU memory not being freed up properly. Tools like nvidia-smi can help monitor GPU usage.

      3. Sequential Model Loading: Although the models are run sequentially and not in parallel, it could be beneficial to explicitly clear the memory after each model's predictions are done. This can be done by deleting model objects and calling torch.cuda.empty_cache() if you are using PyTorch.

      4. Hardware Testing: Run your container pointing the inference to CPU only for a time to see if the problem persists. This could help determine if the issue is related to GPU computation or not.

      5. Reproducibility Tactic: Since the issue is sporadic, try to determine if there’s a specific type of input or specific conditions under which this occurs more frequently.

      If these suggestions don't help, please provide more details or code snippets, and I’d be happy to dive deeper into this!

      Let me know how it goes!

  3. HWKevinhwkGitHub

    I want to install ultralytics using docker on top of NVIDIA TX2, is there a detailed procedure? The reason for this question is that after entering the command nvidia-smi in the TX2 terminal, the output is command not found, and I'm worried that the steps in the document above are not applicable to TX2.

    1. Paula DerrengerUltralytics(bearbeitet)

      @HWKevinhwk hey there! 🚀 Setting up Ultralytics on NVIDIA TX2 with Docker can be a bit tricky if nvidia-smi is missing, but no worries.

      For NVIDIA Jetson platforms like TX2, nvidia-smi is typically not available, and you'll use tegrastats instead to monitor the GPU. The Jetson TX2 is supported on JetPack 4, so install JetPack 4 first, as it includes the NVIDIA drivers and libraries needed for GPU acceleration. Jetson devices use the Docker integration provided through JetPack with --runtime=nvidia rather than --gpus all. Then pull and run the Ultralytics Docker image for JetPack 4:

      t=ultralytics/ultralytics:latest-jetson-jetpack4
      sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t

      See the NVIDIA Jetson guide for details. If you encounter any specific issues, feel free to drop them here. Happy detecting! 🎉

    2. HWKevinhwkGitHub

      Is there a detailed tutorial on deploying yolov8 on jetson TX2 using docker? I am pulling images docker pull ultralytics/ultralytics:latest-jetson terminal will downloading pause, long time pulling images unsuccessful, repeated attempts still so, any solution please?

    3. Paula DerrengerUltralytics(bearbeitet)

      @HWKevinhwk hey there! 😊

      It sounds like you're facing issues with the Docker image pull for the Jetson TX2. This might be due to network issues or Docker Hub delays, or to using a tag that does not exist.

      Here's a simplified breakdown to get you started on the TX2 using Docker:

      1. Ensure JetPack is installed: The TX2 is supported on JetPack 4, which includes the GPU drivers necessary for Docker integration with the Jetson GPU.

      2. Install Docker:

        sudo apt-get install docker.io
      3. NVIDIA runtime support (JetPack should handle this): nvidia-smi doesn't work on Jetson, so verify the nvidia runtime with docker info | grep -i runtime.

      4. Pull the Docker image for Jetson. Pulling large Docker images can be challenging on slower networks:

        sudo docker pull ultralytics/ultralytics:latest-jetson-jetpack4

        If you keep facing issues while pulling the image, try restarting your Docker service or check your network settings. Sometimes, using a different network can help too!

      5. Run the Image:

        sudo docker run -it --ipc=host --runtime=nvidia ultralytics/ultralytics:latest-jetson-jetpack4

      This should set you on the right path to running Ultralytics YOLO on your Jetson TX2. If the problem persists, it might be worth checking Docker's log or discussing this issue further with your network admin or on Docker forums! 😄

      Happy coding! 🚀

  4. Peter-codingGitHub

    Hey! I trained a YOLOv8 model on my local computer. I have the best.pt file, and I can use it in CLI (conda) for predict. I want to make a python app, which uses this best.pt file, and I want to containerize it. Is it possible to write the full python app (it is just a few lines of code, which runs the detection, then writes the detection result to a database), then containerize it, and able to use it anywhere? Thank you! :D

    1. Paula DerrengerUltralytics

      Hey there! 😊

      Absolutely, you can absolutely containerize your Python app that uses the best.pt model! Here's a quick guide:

      1. Create Your Python App: Just like you mentioned, write your Python code that performs the detection and interacts with the database.

      2. Dockerize Your Application:

        • Dockerfile: Create a Dockerfile in your project directory. Here's a simple example that uses Ultralytics' Docker image as a base:

          FROM ultralytics/ultralytics:latest
          WORKDIR /app
          COPY . /app
          RUN pip install -r requirements.txt  # Assuming you have a requirements.txt
          CMD ["python", "your_script.py"]
        • Build Your Docker Image: Run the following command in your project directory:

          sudo docker build -t your-app-name .
        • Run Your Container: To run your container, especially if you're planning to use GPU, you might want to specify --gpus all:

          sudo docker run -it --ipc=host --gpus all your-app-name

          For accessing local files, consider mounting a volume as described in the Docker Quickstart Guide.

      3. Deployment: With your Docker image built, you can now deploy and run it anywhere that Docker is supported. If using a GPU, ensure the host machine supports NVIDIA GPUs and has the necessary drivers and Docker configured correctly.

      That's it! You should be able to use your model within a containerized app now. If you hit any snags, double-check the Docker Quickstart Guide for Ultralytics for more details. Happy coding! 😄

  5. udayzee05GitHub

    DEPRECATION NOTICE The nvidia-docker wrapper is no longer supported, and the NVIDIA Container Toolkit has been extended to allow users to configure Docker to use the NVIDIA Container Runtime. For further instructions, see the NVIDIA Container Toolkit documentation and specifically the install guide.22 Jan 2024

    1. Paula DerrengerUltralytics(bearbeitet)

      Hey there! 👋 Thanks for bringing up the deprecation notice regarding the nvidia-docker wrapper. You're right; use the NVIDIA Container Toolkit for GPU support in Docker containers. Here's how to set it up on Ubuntu/Debian, as described in our Docker Quickstart Guide:

      # Add the NVIDIA Container Toolkit repository
      curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
        && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
        | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
          | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
      
      # Install the NVIDIA Container Toolkit
      sudo apt-get update
      sudo apt-get install -y nvidia-container-toolkit

      And to verify that the GPU devices are available to Docker:

      nvidia-ctk cdi list

      This should list entries such as nvidia.com/gpu=all, indicating that your Docker setup can leverage GPU acceleration. 🚀

      For more detailed instructions and tips on using Ultralytics with Docker, including mounting local directories and running containers, check out our Docker Quickstart Guide. Happy coding!