Docker Compose Plugin Fehler beheben: Anleitung & Lösungen

Einführung

In diesem Lab lernen Sie, wie Sie den häufigen Fehler "unable to locate package docker-compose-plugin" beheben können, der bei der Arbeit mit Docker Compose auftritt. Docker Compose ist ein essentielles Werkzeug zum Definieren und Ausführen von Multi-Container-Docker-Anwendungen, aber Benutzer stoßen oft auf Installationsprobleme. Dieses Lab führt Sie durch das Verständnis des Problems und die Implementierung einer Schritt-für-Schritt-Lösung, um Docker Compose auf Ihrem Ubuntu 22.04-System korrekt zum Laufen zu bringen.

Docker Compose und den Fehler verstehen

Bevor wir den Fehler beheben, wollen wir verstehen, was Docker Compose ist und warum dieser Fehler auftritt.

Was ist Docker Compose?

Docker Compose ist ein Werkzeug zum Definieren und Ausführen von Multi-Container-Docker-Anwendungen. Mit Compose verwenden Sie eine YAML-Datei, um die Services, Netzwerke und Volumes Ihrer Anwendung zu konfigurieren. Anschließend erstellen und starten Sie mit einem einzigen Befehl alle Services aus Ihrer Konfiguration.

Docker Compose ist besonders nützlich für:

Entwicklungsumgebungen
Automatisierte Tests
Einzelhost-Deployments

Der Fehler "Unable to Locate Package"

Wenn Sie versuchen, Docker Compose mit dem Befehl zu installieren:

sudo apt-get install docker-compose-plugin

können Sie auf diesen Fehler stoßen:

Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
E: Unable to locate package docker-compose-plugin

Dieser Fehler tritt auf, weil sich der Paketname geändert hat oder das Paket-Repository in Ihrem System nicht richtig konfiguriert ist.

Überprüfen Ihrer aktuellen Docker-Installation

Lassen Sie uns zunächst überprüfen, ob Docker korrekt installiert ist. Führen Sie aus:

docker --version

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Docker version 20.10.21, build baeda1f

Dies bestätigt, dass Docker installiert ist. Überprüfen wir nun, ob Sie bereits eine Version von Docker Compose installiert haben:

docker compose version

Wenn Sie einen "command not found"-Fehler erhalten, bestätigt dies, dass Docker Compose noch nicht installiert ist:

docker: 'compose' is not a docker command.

Nachdem wir das Problem verstanden haben, fahren wir im nächsten Schritt mit der Behebung fort.

Docker Compose installieren

Nachdem wir bestätigt haben, dass Docker installiert ist, aber Docker Compose fehlt, installieren wir Docker Compose jetzt korrekt. Es gibt zwei Hauptmethoden, um Docker Compose auf Ubuntu 22.04 zu installieren:

Verwendung des Docker Compose Plugins für die Docker CLI
Verwendung der eigenständigen Docker Compose Binärdatei

Gehen wir mit der ersten Methode vor, die der empfohlene Ansatz für die Docker Engine Version 20.10.21 ist.

Paketlisten aktualisieren

Stellen Sie zunächst sicher, dass Ihre Paketlisten auf dem neuesten Stand sind:

sudo apt-get update

Sie sollten eine Ausgabe sehen, die zeigt, dass die Paketlisten aktualisiert werden:

Hit:1 http://archive.ubuntu.com/ubuntu jammy InRelease
Get:2 http://security.ubuntu.com/ubuntu jammy-security InRelease [110 kB]
...
Reading package lists... Done

Docker Compose Plugin installieren

In Ubuntu 22.04 müssen wir das Docker Compose Plugin aus dem offiziellen Docker-Repository installieren. Zuerst stellen wir sicher, dass wir die notwendigen Voraussetzungen haben:

sudo apt-get install -y ca-certificates curl gnupg

Fügen Sie nun den offiziellen GPG-Schlüssel von Docker hinzu:

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

Fügen Sie das Repository zu den Apt-Quellen hinzu:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisieren Sie die Paketdatenbank mit Docker-Paketen:

sudo apt-get update

Installieren Sie nun das Docker Compose Plugin:

sudo apt-get install -y docker-compose-plugin

Sie sollten sehen, wie die Installation erfolgreich verläuft:

Reading package lists... Done
Building dependency tree... Done
...
Setting up docker-compose-plugin (2.6.0~ubuntu-1~22.04.1) ...
Processing triggers for man-db (2.10.2-1) ...

Überprüfen wir, ob Docker Compose jetzt installiert ist:

docker compose version

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Docker Compose version v2.6.0

Nun haben Sie das Docker Compose Plugin für die Docker CLI erfolgreich installiert.

Docker Compose testen

Nachdem wir Docker Compose erfolgreich installiert haben, erstellen wir ein einfaches Projekt, um zu testen, ob es korrekt funktioniert.

Ein Projektverzeichnis erstellen

Erstellen wir zunächst ein Verzeichnis für unser Testprojekt:

mkdir -p ~/project/docker-compose-test
cd ~/project/docker-compose-test

Eine Docker Compose Konfigurationsdatei erstellen

Erstellen wir nun eine einfache docker-compose.yml-Datei mit dem Editor nano:

nano docker-compose.yml

Fügen Sie der Datei den folgenden Inhalt hinzu:

version: "3"
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html

Diese Konfiguration definiert einen einfachen Webserver unter Verwendung des Nginx-Images. Sie mappt Port 8080 auf Ihrem Host auf Port 80 im Container und mountet ein lokales Verzeichnis, um HTML-Inhalte bereitzustellen.

Speichern Sie die Datei, indem Sie Strg+O, dann Enter drücken, und beenden Sie nano mit Strg+X.

HTML-Inhalt erstellen

Erstellen wir ein Verzeichnis für unseren HTML-Inhalt und eine einfache HTML-Datei:

mkdir -p html
nano html/index.html

Fügen Sie der HTML-Datei den folgenden Inhalt hinzu:

<!DOCTYPE html>
<html>
  <head>
    <title>Docker Compose Test</title>
  </head>
  <body>
    <h1>Hello from Docker Compose!</h1>
    <p>If you can see this, your Docker Compose setup is working correctly.</p>
  </body>
</html>

Speichern Sie die Datei und beenden Sie nano.

Die Docker Compose Anwendung starten

Starten wir nun unsere Docker Compose Anwendung:

docker compose up -d

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[+] Running 2/2
 ⠿ Network docker-compose-test_default  Created
 ⠿ Container docker-compose-test-web-1  Started

Dies zeigt an, dass Docker Compose ein Netzwerk erstellt und den Nginx-Container gestartet hat.

Überprüfen, ob die Anwendung läuft

Überprüfen wir, ob unser Container läuft:

docker compose ps

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

NAME                       COMMAND                  SERVICE             STATUS              PORTS
docker-compose-test-web-1  "/docker-entrypoint.…"   web                 running             0.0.0.0:8080->80/tcp

Senden wir nun eine Anfrage an den Webserver, um zu überprüfen, ob er unseren Inhalt bereitstellt:

curl http://localhost:8080

Sie sollten den von uns erstellten HTML-Inhalt sehen:

<!DOCTYPE html>
<html>
  <head>
    <title>Docker Compose Test</title>
  </head>
  <body>
    <h1>Hello from Docker Compose!</h1>
    <p>If you can see this, your Docker Compose setup is working correctly.</p>
  </body>
</html>

Großartig! Sie haben erfolgreich eine Docker Compose Anwendung erstellt und ausgeführt.

Die Docker Compose Anwendung stoppen

Um die von Docker Compose erstellten Container, Netzwerke und Volumes zu stoppen und zu entfernen, führen Sie aus:

docker compose down

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[+] Running 2/2
 ⠿ Container docker-compose-test-web-1  Removed
 ⠿ Network docker-compose-test_default  Removed

Dies bestätigt, dass Docker Compose die von ihm erstellten Ressourcen bereinigt hat.

Gängige Docker Compose Befehle verstehen

Nachdem Sie Docker Compose zum Laufen gebracht haben, wollen wir uns einige gängige Befehle und Konfigurationen ansehen, die Sie in Ihren Projekten verwenden werden.

Wesentliche Docker Compose Befehle

Hier sind die am häufigsten verwendeten Docker Compose Befehle:

Dienste starten:
```
docker compose up -d
```
Das Flag -d führt Container im Hintergrund aus (detached mode).
Dienste stoppen:
```
docker compose stop
```
Dies stoppt die Container, ohne sie zu entfernen.
Dienste stoppen und entfernen:
```
docker compose down
```
Dies stoppt Container und entfernt Container, Netzwerke, Volumes und Images, die durch up erstellt wurden.
Logs anzeigen:
```
docker compose logs
```
Um Logs in Echtzeit zu verfolgen, fügen Sie das Flag -f hinzu:
```
docker compose logs -f
```
Container auflisten:
```
docker compose ps
```
Dies zeigt den Status Ihrer Docker Compose Dienste an.
Befehle innerhalb von Containern ausführen:
```
docker compose exec <service-name> <command>
```
Um beispielsweise eine Shell im Webdienst auszuführen:
```
docker compose exec web bash
```

Erstellen einer komplexeren Docker Compose Konfiguration

Erstellen wir eine komplexere Docker Compose Konfiguration, die mehrere Dienste enthält. Erstellen Sie ein neues Verzeichnis für dieses Beispiel:

mkdir -p ~/project/complex-compose
cd ~/project/complex-compose

Erstellen Sie eine docker-compose.yml-Datei:

nano docker-compose.yml

Fügen Sie den folgenden Inhalt hinzu:

version: "3"

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./nginx/html:/usr/share/nginx/html
    depends_on:
      - app
    networks:
      - frontend
      - backend

  app:
    image: node:14-alpine
    working_dir: /app
    volumes:
      - ./app:/app
    command: "node server.js"
    environment:
      - NODE_ENV=production
      - DB_HOST=db
      - DB_PORT=5432
    depends_on:
      - db
    networks:
      - backend

  db:
    image: postgres:13-alpine
    environment:
      - POSTGRES_USER=myuser
      - POSTGRES_PASSWORD=mypassword
      - POSTGRES_DB=mydb
    volumes:
      - db-data:/var/lib/postgresql/data
    networks:
      - backend

networks:
  frontend:
  backend:

volumes:
  db-data:

Speichern Sie die Datei und beenden Sie nano.

Diese Konfiguration definiert drei Dienste:

Einen Webserver (nginx)
Eine Backend-Anwendung (Node.js)
Eine Datenbank (PostgreSQL)

Sie definiert auch Netzwerke, um den Datenverkehr zu isolieren, und ein Volume für die dauerhafte Speicherung der Datenbank.

Verzeichnisse und Dateien für die komplexe Konfiguration erstellen

Erstellen wir die notwendigen Verzeichnisse und Dateien:

mkdir -p nginx/html app

Erstellen Sie eine einfache HTML-Datei:

nano nginx/html/index.html

Fügen Sie den folgenden Inhalt hinzu:

<!DOCTYPE html>
<html>
  <head>
    <title>Complex Docker Compose Example</title>
  </head>
  <body>
    <h1>Complex Docker Compose Example</h1>
    <p>
      This page is served by Nginx, and the application is powered by Node.js
      with PostgreSQL.
    </p>
  </body>
</html>

Speichern Sie die Datei und beenden Sie nano.

Erstellen Sie einen einfachen Node.js-Server:

nano app/server.js

Fügen Sie den folgenden Inhalt hinzu:

const http = require("http");

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader("Content-Type", "text/plain");
  res.end("Hello from Node.js server!\n");
});

const port = 3000;
server.listen(port, () => {
  console.log(`Server running on port ${port}`);
  console.log(
    `Database connection info: ${process.env.DB_HOST}:${process.env.DB_PORT}`
  );
});

Speichern Sie die Datei und beenden Sie nano.

Dieses Setup ist komplexer und repräsentiert eine reale Anwendungsarchitektur, aber wir werden es in diesem Lab nicht starten, da es mehr Einrichtung erfordern würde.

Docker Compose Best Practices

Hier sind einige Best Practices, die Sie bei der Verwendung von Docker Compose befolgen sollten:

Verwenden Sie Umgebungsvariablen: Speichern Sie sensible Informationen wie Passwörter in Umgebungsvariablen oder .env-Dateien.
Definieren Sie Neustartrichtlinien: Legen Sie für Produktionsumgebungen Neustartrichtlinien fest:
```
services:
  web:
    restart: always
```
Verwenden Sie spezifische Image-Tags: Vermeiden Sie die Verwendung von latest in der Produktion, da dies zu unerwarteten Änderungen führen kann.
Konfigurationen organisieren: Teilen Sie für komplexe Setups Ihre Konfiguration in mehrere Dateien auf, indem Sie das Muster docker-compose.override.yml verwenden.

Ressourcenbeschränkungen festlegen: Verhindern Sie die Erschöpfung der Containerressourcen:

services:
  web:
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 512M

Durch die Befolgung dieser Best Practices erstellen Sie besser wartbare und robustere Docker Compose Konfigurationen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie den Fehler "unable to locate package docker-compose-plugin" erfolgreich beheben können, indem Sie:

Verstanden haben, was Docker Compose ist, und den Fehler diagnostiziert haben
Docker Compose korrekt installiert haben, indem Sie das offizielle Docker Repository hinzugefügt haben
Eine einfache Docker Compose Anwendung erstellt und getestet haben
Komplexere Docker Compose Konfigurationen und Best Practices erkundet haben

Sie verfügen jetzt über eine funktionierende Docker Compose Installation und das Wissen, sie zur Verwaltung von Docker-Anwendungen mit mehreren Containern zu verwenden. Diese Grundlage wird wertvoll sein, wenn Sie in Zukunft komplexere containerisierte Lösungen erstellen.

Die Fähigkeiten, die Sie erworben haben, umfassen:

Fehlerbehebung bei Paketinstallationsproblemen in Ubuntu
Arbeiten mit Docker Repositories
Erstellen und Ausführen von Docker Compose Konfigurationen
Verwalten von containerisierten Anwendungen mit Docker Compose

Diese Fähigkeiten sind für moderne Anwendungsentwicklungs- und -bereitstellungsworkflows unerlässlich.

So beheben Sie den Fehler "Unable to Locate Docker Compose Plugin"

Einführung

Docker Compose und den Fehler verstehen

Was ist Docker Compose?

Der Fehler "Unable to Locate Package"

Überprüfen Ihrer aktuellen Docker-Installation

Docker Compose installieren

Paketlisten aktualisieren

Docker Compose Plugin installieren

Docker Compose testen

Ein Projektverzeichnis erstellen

Eine Docker Compose Konfigurationsdatei erstellen

HTML-Inhalt erstellen

Die Docker Compose Anwendung starten

Überprüfen, ob die Anwendung läuft

Die Docker Compose Anwendung stoppen

Gängige Docker Compose Befehle verstehen

Wesentliche Docker Compose Befehle

Erstellen einer komplexeren Docker Compose Konfiguration

Verzeichnisse und Dateien für die komplexe Konfiguration erstellen

Docker Compose Best Practices

Zusammenfassung