Wie man den docker compose alpha scale Befehl zum Skalieren von Diensten verwendet

Einführung

In diesem Lab lernen Sie, wie Sie den Befehl docker compose alpha scale verwenden, um Dienste in einem Docker Compose-Projekt zu skalieren. Wir beginnen mit der Vorbereitung eines einfachen Docker Compose-Projekts, das die Installation von Docker Compose, die Erstellung einer einfachen Webanwendung sowie die Definition des Dockerfiles und der Abhängigkeiten umfasst.

Nach dem Projektaufbau werden Sie untersuchen, wie Sie einen einzelnen Dienst mit docker compose alpha scale skalieren, mehrere Dienste gleichzeitig skalieren und einen Dienst skalieren, ohne dessen Abhängigkeiten zu starten. Diese praktische Übung demonstriert die Flexibilität und Leistungsfähigkeit des scale-Befehls zur Verwaltung der Anzahl laufender Instanzen Ihrer Dienste.

Skills Graph

Ein einfaches Docker Compose-Projekt vorbereiten

In diesem Schritt bereiten wir ein einfaches Docker Compose-Projekt vor. Da Docker Compose in der LabEx-Umgebung nicht vorinstalliert ist, werden wir es zunächst installieren. Anschließend erstellen wir eine einfache Webanwendung und eine Docker Compose-Datei, um sie zu definieren und auszuführen.

Zuerst installieren wir Docker Compose. Wir laden die Docker Compose-Binärdatei herunter und machen sie ausführbar.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Nun überprüfen wir die Installation, indem wir die Docker Compose-Version abfragen.

docker-compose --version

In der Ausgabe sollte die installierte Version von Docker Compose angezeigt werden.

Als Nächstes erstellen wir eine einfache Webanwendung. Wir verwenden eine grundlegende Python Flask-Anwendung. Erstellen Sie ein Verzeichnis für unser Projekt und wechseln Sie hinein.

mkdir my-web-app
cd my-web-app

Erstellen Sie im Verzeichnis my-web-app eine Datei namens app.py mit folgendem Inhalt:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, Docker Compose!'

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')

Dies ist eine einfache Flask-Anwendung, die "Hello, Docker Compose!" zurückgibt, wenn sie aufgerufen wird.

Nun benötigen wir ein Dockerfile, um ein Docker-Image für unsere Flask-Anwendung zu erstellen. Erstellen Sie im Verzeichnis my-web-app eine Datei namens Dockerfile mit folgendem Inhalt:

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt

COPY . .

EXPOSE 5000

CMD ["python", "app.py"]

Dieses Dockerfile verwendet ein schlankes Python 3.9-Image, legt das Arbeitsverzeichnis fest, kopiert und installiert Abhängigkeiten aus requirements.txt, kopiert den Anwendungscode, öffnet Port 5000 und gibt den Befehl zum Ausführen der Anwendung an.

Wir benötigen auch eine requirements.txt-Datei für die Flask-Abhängigkeit. Erstellen Sie im Verzeichnis my-web-app eine Datei namens requirements.txt mit folgendem Inhalt:

Flask==2.2.2

Schließlich erstellen wir eine docker-compose.yml-Datei, um unseren Dienst zu definieren. Erstellen Sie im Verzeichnis my-web-app eine Datei namens docker-compose.yml mit folgendem Inhalt:

version: "3.8"

services:
  web:
    build: .
    ports:
      - "5000:5000"

Diese docker-compose.yml-Datei definiert einen Dienst namens web. Sie weist Docker Compose an, das Image mit dem Dockerfile im aktuellen Verzeichnis (.) zu erstellen und Port 5000 auf dem Host mit Port 5000 im Container zu verbinden.

Nun bauen und starten wir den Dienst mit Docker Compose. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project/my-web-app befinden.

docker-compose up -d

Dieser Befehl erstellt das Image (falls noch nicht vorhanden), erstellt einen Container für den web-Dienst und startet ihn im Hintergrund (-d).

Sie können überprüfen, ob der Container läuft, indem Sie den Befehl docker ps verwenden.

docker ps

Sie sollten einen Container für den Dienst my-web-app-web-1 sehen, der läuft.

Um zu überprüfen, ob die Anwendung funktioniert, können Sie sie mit curl aufrufen.

curl http://localhost:5000

Sie sollten die Ausgabe "Hello, Docker Compose!" sehen.

Einen Dienst mit docker compose alpha scale skalieren

In diesem Schritt lernen wir, wie man einen Dienst mit dem Befehl docker compose alpha scale skaliert. Das Skalieren eines Dienstes bedeutet, die Anzahl der laufenden Instanzen (Container) für diesen Dienst zu erhöhen oder zu verringern. Dies ist nützlich, um erhöhte Last zu bewältigen oder für Hochverfügbarkeit.

Der Befehl docker compose alpha scale ermöglicht es Ihnen, die gewünschte Anzahl von Replikaten für einen bestimmten Dienst festzulegen. Das alpha-Subkommando zeigt an, dass dies eine neuere Funktion in Docker Compose ist.

Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project/my-web-app befinden, wo sich Ihre docker-compose.yml-Datei befindet.

Aktuell haben wir eine Instanz des web-Dienstes laufen. Wir können dies überprüfen, indem wir die laufenden Container auflisten und nach dem Dienstnamen filtern.

docker ps --filter "name=my-web-app-web"

Sie sollten nur einen Container in der Liste sehen.

Nun skalieren wir den web-Dienst auf 3 Instanzen. Wir verwenden den Befehl docker compose alpha scale gefolgt vom Dienstnamen und der gewünschten Anzahl von Replikaten.

docker compose alpha scale web=3

Dieser Befehl startet zwei neue Container für den web-Dienst, sodass insgesamt 3 Instanzen laufen.

Nach Ausführung des Befehls können Sie erneut die laufenden Container überprüfen, um die skalierten Instanzen zu sehen.

docker ps --filter "name=my-web-app-web"

Sie sollten nun drei Container in der Liste sehen, jeder mit einer unterschiedlichen Container-ID und Namen (z.B. my-web-app-web-1, my-web-app-web-2, my-web-app-web-3).

Der Befehl docker compose alpha scale ist eine praktische Möglichkeit, die Anzahl der Dienst-Replikate dynamisch anzupassen, ohne die docker-compose.yml-Datei zu ändern und docker compose up erneut auszuführen.

Um den Dienst wieder herunterzuskalieren, können Sie denselben Befehl mit einer kleineren Zahl verwenden. Zum Beispiel, um wieder auf 1 Instanz zu skalieren:

docker compose alpha scale web=1

Dies stoppt und entfernt die zusätzlichen Container, sodass nur eine Instanz läuft.

Lassen Sie uns für den nächsten Schritt wieder auf 3 Instanzen skalieren.

docker compose alpha scale web=3

Mehrere Dienste gleichzeitig skalieren

In diesem Schritt lernen wir, wie man mehrere Dienste gleichzeitig mit dem Befehl docker compose alpha scale skaliert. Dies ist nützlich, wenn Ihre Anwendung mehrere Dienste enthält, die gemeinsam skaliert werden müssen, um erhöhte Last zu bewältigen oder eine ausgewogene Architektur beizubehalten.

Um dies zu demonstrieren, fügen wir unserer docker-compose.yml-Datei einen weiteren einfachen Dienst hinzu. Wir erstellen einen einfachen Nginx-Dienst, der statische Inhalte bereitstellt.

Erstellen Sie zunächst ein Verzeichnis für die statischen Nginx-Inhalte.

mkdir static

Erstellen Sie im static-Verzeichnis eine einfache HTML-Datei namens index.html mit folgendem Inhalt:

<!doctype html>
<html>
  <head>
    <title>Static Content</title>
  </head>
  <body>
    <h1>Hello from Nginx!</h1>
  </body>
</html>

Aktualisieren wir nun die docker-compose.yml-Datei im Verzeichnis ~/project/my-web-app, um den Nginx-Dienst einzubinden. Öffnen Sie die docker-compose.yml-Datei mit nano.

nano docker-compose.yml

Fügen Sie folgende Dienstdefinition unterhalb des web-Dienstes hinzu:

nginx:
  image: nginx:latest
  ports:
    - "80:80"
  volumes:
    - ./static:/usr/share/nginx/html

Die aktualisierte docker-compose.yml-Datei sollte nun wie folgt aussehen:

version: "3.8"

services:
  web:
    build: .
    ports:
      - "5000:5000"

  nginx:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./static:/usr/share/nginx/html

Dies fügt einen nginx-Dienst hinzu, der das nginx:latest-Image verwendet, Port 80 auf dem Host mit Port 80 im Container verbindet und das ./static-Verzeichnis in das Nginx-Standard-Webverzeichnis (/usr/share/nginx/html) einbindet.

Speichern Sie die docker-compose.yml-Datei und beenden Sie nano (Strg+X, Y, Eingabe).

Starten wir nun den neuen Dienst. Da wir die docker-compose.yml-Datei geändert haben, müssen wir docker compose up erneut ausführen. Das Flag -d startet die Container im Hintergrundmodus.

docker compose up -d

Docker Compose erstellt und startet den nginx-Dienst. Der web-Dienst sollte bereits aus dem vorherigen Schritt laufen.

Sie können überprüfen, ob beide Dienste laufen, indem Sie docker ps verwenden.

docker ps

Sie sollten Container für my-web-app-web-1, my-web-app-web-2, my-web-app-web-3 und my-web-app-nginx-1 sehen.

Lassen Sie uns nun sowohl den web-Dienst auf 5 Instanzen als auch den nginx-Dienst auf 2 Instanzen gleichzeitig skalieren. Dies können wir tun, indem wir die Dienste und ihre gewünschten Replikatanzahlen im docker compose alpha scale-Befehl angeben.

docker compose alpha scale web=5 nginx=2

Dieser Befehl skaliert den web-Dienst auf 5 Instanzen und den nginx-Dienst auf 2 Instanzen.

Nach Ausführung des Befehls überprüfen Sie erneut die laufenden Container.

docker ps

Sie sollten nun 5 Container für den web-Dienst und 2 Container für den nginx-Dienst sehen.

Dies demonstriert, wie Sie mehrere Dienste mit einem einzigen docker compose alpha scale-Befehl skalieren können, was das Management der Skalierung Ihrer Anwendungskomponenten effizient macht.

Einen Dienst skalieren ohne Abhängigkeiten zu starten

In diesem Schritt untersuchen wir, wie man einen bestimmten Dienst mit docker compose alpha scale skaliert, ohne dessen Abhängigkeiten zu starten. Standardmäßig startet Docker Compose beim Skalieren eines Dienstes möglicherweise auch dessen Abhängigkeiten oder stellt sicher, dass diese laufen. Es gibt jedoch Szenarien, in denen Sie nur einen einzelnen Dienst skalieren möchten, ohne andere zu beeinflussen.

Um dies zu veranschaulichen, fügen wir unserem web-Dienst eine Abhängigkeit hinzu. Wir werden einen einfachen Datenbankdienst hinzufügen, obwohl wir für dieses Beispiel keine Datenbanklogik in unserer Webanwendung implementieren werden. Dies dient lediglich zur Demonstration des Abhängigkeitskonzepts.

Öffnen Sie die docker-compose.yml-Datei im Verzeichnis ~/project/my-web-app mit nano.

nano docker-compose.yml

Fügen Sie eine neue Dienstdefinition für eine Datenbank (z.B. ein einfaches postgres-Image) hinzu und ergänzen Sie den web-Dienst um einen depends_on-Abschnitt.

version: "3.8"

services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db

  nginx:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./static:/usr/share/nginx/html

  db:
    image: postgres:latest
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydatabase

Die aktualisierte docker-compose.yml-Datei enthält nun einen db-Dienst mit dem postgres:latest-Image, und der web-Dienst hat eine depends_on: - db-Zeile, die angibt, dass der web-Dienst vom db-Dienst abhängt.

Speichern Sie die docker-compose.yml-Datei und beenden Sie nano (Strg+X, Y, Eingabe).

Starten wir nun die Dienste mit der aktualisierten Konfiguration.

docker compose up -d

Docker Compose wird nun auch den db-Dienst erstellen und starten, da der web-Dienst davon abhängt.

Sie können überprüfen, ob alle Dienste laufen, indem Sie docker ps verwenden.

docker ps

Sie sollten Container für web, nginx und db sehen.

Angenommen, wir möchten nur den web-Dienst auf 4 Instanzen skalieren, ohne den db-Dienst zu starten oder zu beeinflussen (falls dieser nicht bereits läuft). Der Befehl docker compose alpha scale berücksichtigt standardmäßig Abhängigkeiten. Für dieses spezielle Szenario, in dem wir nur den angegebenen Dienst skalieren möchten, ist der Standardbefehl docker compose alpha scale jedoch ausreichend, da er sich primär auf den Ziel-Dienst konzentriert. Die depends_on-Beziehung betrifft hauptsächlich die Startreihenfolge bei Verwendung von docker compose up. Bei docker compose alpha scale liegt der Fokus auf der Anpassung der Instanzenanzahl für den angegebenen Dienst.

Skalieren wir den web-Dienst auf 4 Instanzen.

docker compose alpha scale web=4

Dieser Befehl skaliert den web-Dienst auf 4 Instanzen. Er startet den db-Dienst nicht explizit, falls dieser nicht läuft, aber da er durch den vorherigen docker compose up-Befehl gestartet wurde, bleibt er aktiv. Der entscheidende Punkt hier ist, dass docker compose alpha scale darauf ausgelegt ist, den angegebenen Dienst zu skalieren, ohne notwendigerweise das Starten seiner Abhängigkeiten auszulösen, falls diese nicht bereits laufen.

Überprüfen Sie die Anzahl der laufenden web-Dienst-Container.

docker ps --filter "name=my-web-app-web"

Sie sollten 4 Container für den web-Dienst sehen. Der db-Dienst-Container sollte ebenfalls noch laufen.

Dies demonstriert, dass sich docker compose alpha scale auf den Ziel-Dienst für die Skalierung konzentriert.

Beenden wir abschließend alle Dienste.

docker compose down

Dieser Befehl stoppt und entfernt alle Container, Netzwerke und Volumes, die von Docker Compose für dieses Projekt erstellt wurden.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man ein einfaches Docker Compose-Projekt vorbereitet. Dies umfasste die Installation von Docker Compose in der LabEx-Umgebung, die Überprüfung der Installation sowie die Erstellung einer einfachen Python Flask-Webanwendung. Wir haben außerdem eine Dockerfile erstellt, um ein Docker-Image für die Anwendung zu bauen, und eine requirements.txt-Datei, um die Abhängigkeiten der Anwendung aufzulisten. Diese anfängliche Einrichtung bildet die Grundlage für die Erkundung der Docker Compose-Funktionalitäten, wobei der Schwerpunkt in den folgenden Schritten speziell auf der Skalierung von Diensten liegt.