Webserver-Bereitstellung mit Docker

Einführung

Docker ist eine weit verbreitete Containerisierungsplattform, die die Bereitstellung und Verwaltung von Anwendungen vereinfacht. In diesem Tutorial lernen Sie, wie Sie einen Webserver mithilfe von Docker bereitstellen, die Vorteile der Containerisierung kennenlernen und eine Docker-Entwicklungsumgebung einrichten.

Docker verstehen

Was ist Docker?

Docker ist eine Open-Source-Plattform, die Entwicklern ermöglicht, Anwendungen in einer containerisierten Umgebung zu erstellen, bereitzustellen und auszuführen. Container sind leichte, eigenständige und ausführbare Pakete, die alles enthalten, was zum Ausführen einer Anwendung benötigt wird, einschließlich Code, Laufzeitumgebung, Systemtools und Bibliotheken. Docker bietet eine konsistente und zuverlässige Methode zum Packen und Verteilen von Anwendungen, was die Entwicklung, das Testen und die Bereitstellung von Software vereinfacht.

Vorteile der Verwendung von Docker

Konsistente Umgebungen: Docker-Container stellen sicher, dass Anwendungen unabhängig von der zugrunde liegenden Infrastruktur auf dieselbe Weise ausgeführt werden, wodurch eine konsistente und zuverlässige Entwicklungs- und Bereitstellungsumgebung entsteht.
Erhöhte Effizienz: Docker-Container sind leichtgewichtig und können schnell gestartet und gestoppt werden, was eine effizientere Nutzung der Systemressourcen im Vergleich zu traditionellen virtuellen Maschinen ermöglicht.
Verbesserte Skalierbarkeit: Docker erleichtert die Skalierung von Anwendungen nach Bedarf, indem mehrere Container erstellt und verwaltet werden.
Verbesserte Portabilität: Docker-Container können einfach auf verschiedenen Plattformen und in verschiedenen Umgebungen geteilt und bereitgestellt werden, was den Transport von Anwendungen zwischen Entwicklung, Tests und Produktion vereinfacht.

Docker-Architektur

Die Docker-Architektur besteht aus folgenden Hauptkomponenten:

Docker Client: Die Benutzeroberfläche, die Ihnen den Zugriff auf den Docker-Daemon ermöglicht.
Docker Daemon: Der Hintergrundprozess, der Docker-Objekte wie Images, Container, Netzwerke und Volumes verwaltet.
Docker Images: Unveränderliche Dateien, die den Code, die Laufzeitumgebung, Systemtools, Bibliotheken und Abhängigkeiten enthalten, die zum Ausführen einer Anwendung erforderlich sind.
Docker Container: Ausführbare Instanzen von Docker-Images, die isoliert sind und ihren eigenen Dateisystem, Netzwerk und Prozessraum haben.
Docker Registry: Ein Repository zum Speichern und Verteilen von Docker-Images.

graph TD
    A[Docker Client] --> B[Docker Daemon]
    B --> C[Docker Images]
    B --> D[Docker Container]
    B --> E[Docker Registry]

Erste Schritte mit Docker

Um mit Docker zu beginnen, müssen Sie den Docker-Engine auf Ihrem System installieren. Der Installationsvorgang variiert je nach Betriebssystem, aber die Anweisungen finden Sie in der Regel auf der offiziellen Docker-Website.

Sobald Docker installiert ist, können Sie es verwenden, um Ihre Anwendungen zu erstellen und auszuführen. Hier ist ein einfaches Beispiel für die Ausführung eines Nginx-Webservers mit Docker:

## Das Nginx-Image aus dem Docker-Registry ziehen
docker pull nginx

## Den Nginx-Container starten
docker run -d -p 80:80 --name my-nginx nginx

Dieser Befehl zieht das Nginx-Image aus dem Docker-Registry und startet dann einen neuen Container basierend auf diesem Image, wobei Port 80 des Hosts auf Port 80 im Container gemappt wird.

Einrichten einer Docker-Entwicklungsumgebung

Docker installieren

Um eine Docker-Entwicklungsumgebung einzurichten, müssen Sie zuerst die Docker Engine auf Ihrem System installieren. Hier ist die Vorgehensweise unter Ubuntu 22.04:

## Aktualisierung des Paketindex
sudo apt-get update

## Installation der Pakete, um HTTPS-Repositories für apt zuzulassen
sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

## Hinzufügen des offiziellen Docker GPG-Schlüssels
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

## Einrichten des Docker Repositorys
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

## Installation von Docker Engine, containerd und Docker Compose
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Konfiguration von Docker für die Entwicklung

Nach der Installation von Docker können Sie es für Ihre Entwicklungsumgebung konfigurieren. Hier sind einige gängige Konfigurationen:

Volumen-Mounts: Mounten Sie Verzeichnisse von Ihrem Host-System in den Docker-Container, um Dateien und Daten freizugeben.
Netzwerke: Konfigurieren Sie Docker-Netzwerke, damit Container miteinander und mit dem Host-System kommunizieren können.
Umgebungsvariablen: Übergeben Sie Umgebungsvariablen an den Docker-Container, um die Anwendung zu konfigurieren.
Build-Argumente: Übergeben Sie Build-Zeit-Argumente an den Docker-Build-Prozess, um das Image anzupassen.

Hier ist ein Beispiel für eine Docker Compose-Datei, die diese Konfigurationen demonstriert:

version: "3"
services:
  web:
    build:
      context: .
      args:
        - ENV=development
    ports:
      - 8080:80
    volumes:
      - ./app:/var/www/html
    environment:
      - DB_HOST=database
  database:
    image: mysql:5.7
    volumes:
      - db-data:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=secret
volumes:
  db-data:

Diese Docker Compose-Datei richtet einen Webdienst und einen Datenbankdienst ein, mit folgenden Konfigurationen:

Der Webdienst wird aus einer lokalen Dockerfile erstellt, mit dem Build-Argument ENV=development.
Der Webdienst mountt das Verzeichnis ./app vom Host auf das Verzeichnis /var/www/html im Container, sodass Sie den Anwendungscode direkt auf dem Host bearbeiten können.
Der Webdienst und der Datenbankdienst sind über ein Netzwerk verbunden, und der Webdienst kann auf die Datenbank über die Umgebungsvariable DB_HOST zugreifen.
Der Datenbankdienst verwendet ein benanntes Volumen db-data, um die Datenbankdaten zu speichern.

Verwalten von Docker Containern

Sobald Ihre Entwicklungsumgebung eingerichtet ist, können Sie Docker-Befehle verwenden, um Ihre Container zu verwalten. Hier sind einige gängige Befehle:

docker run: Starten eines neuen Containers
docker stop: Stoppen eines laufenden Containers
docker rm: Löschen eines Containers
docker logs: Anzeigen der Logs eines Containers
docker exec: Ausführen eines Befehls innerhalb eines laufenden Containers

Um beispielsweise den Webdienst aus der obigen Docker Compose-Datei zu starten, können Sie Folgendes ausführen:

docker-compose up -d web

Dies startet den Webdienst im detachierten Modus, sodass Sie die Konsole weiter verwenden können.

Bereitstellung eines Webservers mit Docker

Erstellen einer Dockerfile

Um einen Webserver mit Docker bereitzustellen, müssen Sie zuerst eine Dockerfile erstellen. Eine Dockerfile ist eine Textdatei, die die Anweisungen zum Erstellen eines Docker-Images enthält. Hier ist ein Beispiel für eine Dockerfile für einen einfachen Nginx-Webserver:

## Verwenden Sie das offizielle Nginx-Image als Basis-Image
FROM nginx:latest

## Kopieren Sie die Standard-Nginx-Konfigurationsdatei
COPY default.conf /etc/nginx/conf.d/default.conf

## Kopieren Sie den Webanwendungscode in den Container
COPY app/ /usr/share/nginx/html/

## Exponieren Sie Port 80 für HTTP-Verkehr
EXPOSE 80

## Starten Sie den Nginx-Server
CMD ["nginx", "-g", "daemon off;"]

Diese Dockerfile:

Verwendet das offizielle Nginx-Image als Basis-Image.
Kopiert die Standard-Nginx-Konfigurationsdatei in den Container.
Kopiert den Webanwendungscode in das Webroot-Verzeichnis des Containers.
Exponiert Port 80 für HTTP-Verkehr.
Startet den Nginx-Server.

Erstellen und Ausführen des Docker-Images

Sobald Sie die Dockerfile haben, können Sie das Docker-Image mit dem Befehl docker build erstellen:

## Erstellen Sie das Docker-Image
docker build -t my-nginx-server .

Dieser Befehl erstellt das Docker-Image mit dem Tag my-nginx-server mithilfe der Dockerfile im aktuellen Verzeichnis.

Nachdem das Image erstellt wurde, können Sie einen Container basierend auf dem Image mit dem Befehl docker run ausführen:

## Führen Sie den Docker-Container aus
docker run -d -p 80:80 --name my-nginx-server my-nginx-server

Dieser Befehl:

Führt den Container im detachierten Modus (-d) aus.
Mapt Port 80 auf dem Host auf Port 80 im Container (-p 80:80).
Weist dem Container den Namen my-nginx-server zu.
Verwendet das my-nginx-server-Image, um den Container zu erstellen.

Skalierung und Lastverteilung

Um Ihren Webserver zu skalieren, können Sie mehrere Instanzen des Docker-Containers ausführen und einen Load Balancer verwenden, um den Datenverkehr auf die Instanzen zu verteilen. Hier ist ein Beispiel dafür, wie Sie dies mit Docker Compose tun können:

version: "3"
services:
  web:
    build: .
    ports:
      - 80:80
    deploy:
      replicas: 3
  load-balancer:
    image: nginx:latest
    ports:
      - 8080:80
    depends_on:
      - web
    configs:
      - source: nginx-config
        target: /etc/nginx/conf.d/default.conf
configs:
  nginx-config:
    file: ./nginx.conf

Diese Docker Compose-Datei:

Erstellt den Dienst web mithilfe der Dockerfile im aktuellen Verzeichnis.
Bereitstellt drei Replikate des Dienstes web.
Führt einen Nginx-Loadbalancer-Dienst aus, der auf Port 8080 lauscht und den Datenverkehr an die Instanzen des Dienstes web weiterleitet.
Mountt eine benutzerdefinierte Nginx-Konfigurationsdatei in den Loadbalancer-Container.

Durch die Verwendung von Docker Compose und Lastverteilung können Sie Ihren Webserver einfach skalieren und hohe Verfügbarkeit und Fehlertoleranz gewährleisten.

Zusammenfassung

Am Ende dieses Tutorials verfügen Sie über ein fundiertes Verständnis von Docker und wie Sie es verwenden, um einen Webserver bereitzustellen. Sie lernen, eine Docker-Entwicklungsumgebung einzurichten, einen Docker-Container für Ihren Webserver zu erstellen und den Bereitstellungsprozess zu verwalten. Dieses Wissen ermöglicht es Ihnen, die Leistungsfähigkeit von Docker für Ihre Webanwendungsentwicklung und -bereitstellung zu nutzen.