Docker für Entwickler: Eine Einführung

Da sich die moderne Softwareentwicklung weiterentwickelt hat, haben sich auch die Werkzeuge weiterentwickelt, die Entwickler zum Erstellen, Testen und Bereitstellen ihrer Anwendungen verwenden. Unter diesen Werkzeugen sticht Docker als leistungsstarke Lösung hervor, die den Bereitstellungsprozess vereinfacht und gleichzeitig Konsistenz und Skalierbarkeit verbessert. Dieser Artikel soll ein tiefgreifendes Verständnis von Docker für Entwickler vermitteln und dabei die grundlegenden Konzepte, die Architektur, die Vorteile und die praktische Implementierung abdecken.

Was ist Docker?

Docker is an open-source platform that automates the deployment of applications within lightweight, portable containers. A container is a standalone, executable package that includes everything needed to run software, including code, libraries, runtime, and system tools. By using containers, developers can ensure that their applications run consistently across various environments, eliminating the dreaded "it works on my machine" problem.

Kernkonzepte

Bevor wir uns eingehender mit Docker befassen, ist es wichtig, einige grundlegende Konzepte zu verstehen:

1. Containers

Container kapseln Anwendungen und ihre Abhängigkeiten und ermöglichen es ihnen, unabhängig von der zugrunde liegenden Infrastruktur zu laufen. Im Gegensatz zu herkömmlichen virtuellen Maschinen (VMs) teilen Container den Host-OS-Kernel, was sie leichtgewichtig und schnell startbar macht.

2. Bilder

Ein Image ist eine schreibgeschützte Vorlage, die zur Erstellung von Containern verwendet wird. Es enthält den Anwendungscode, Bibliotheken und Abhängigkeiten. Docker-Images können in einer Registry (z. B. Docker Hub) gespeichert und mit anderen geteilt werden, was eine einfache Zusammenarbeit ermöglicht.

3. Dockerfile

Eine Dockerfile ist ein Skript, das eine Reihe von Anweisungen enthält, wie ein Docker-Image erstellt werden kann. Es ermöglicht Entwicklern, den Prozess der Image-Erstellung zu automatisieren, indem sie das Basis-Image, den Anwendungscode, Umgebungsvariablen und mehr angeben.

4. Docker-Daemon

Der Docker-Daemon (dockerd) ist ein Hintergrunddienst, der Docker-Container, -Images, -Netzwerke und -Volumes verwaltet. Er empfängt Docker-API-Anfragen und kann mit anderen Docker-Daemons kommunizieren.

5. Docker-CLI

Die Docker-Befehlszeilenschnittstelle (CLI) ermöglicht es Entwicklern, mit dem Docker-Daemon zu interagieren. Über verschiedene Befehle können Entwickler Container und Images erstellen, verwalten und orchestrieren.

6. Docker Compose

Docker Compose is a tool for defining and running multi-container applications. It uses YAML files to specify the services, networks, and volumes needed for an application, simplifying the orchestration of multiple containers.

Wie Docker funktioniertDocker ist eine Open-Source-Software, die es ermöglicht, Anwendungen in sogenannten Containern zu verpacken und auszuführen. Diese Container sind isolierte Umgebungen, die alle notwendigen Abhängigkeiten und Konfigurationen enthalten, um eine Anwendung auszuführen. Docker ermöglicht es Entwicklern, ihre Anwendungen schnell und einfach zu erstellen, zu testen und in der Produktion bereitzustellen.Docker funktioniert auf der Grundlage von Containervirtualisierung. Im Gegensatz zur herkömmlichen Virtualisierung, bei der ein vollständiges Betriebssystem auf einem Hypervisor ausgeführt wird, teilt Docker den Kernel des Host-Betriebssystems mit den Containern. Dies führt zu einer geringeren Ressourcennutzung und schnelleren Startzeiten.Docker verwendet eine Client-Server-Architektur. Der Docker-Client kommuniziert mit dem Docker-Daemon, der für den Aufbau, die Ausführung und die Verwaltung der Container verantwortlich ist. Der Docker-Client und der Daemon können auf demselben System laufen oder der Docker-Client kann mit einem entfernten Docker-Daemon verbunden sein.Docker verwendet Images, um Container zu erstellen. Ein Image ist eine schreibgeschützte Vorlage mit Anweisungen zum Erstellen eines Containers. Images werden in einer Registry gespeichert, wie zum Beispiel Docker Hub, und können von dort heruntergeladen werden. Wenn ein Container gestartet wird, erstellt Docker eine schreibbare Ebene über dem Image, die als Container-Schicht bezeichnet wird.Docker bietet auch die Möglichkeit, mehrere Container zu vernetzen und miteinander kommunizieren zu lassen. Dies ermöglicht die Erstellung komplexer Anwendungen, die aus mehreren Diensten bestehen, die jeweils in einem eigenen Container ausgeführt werden.Zusammenfassend lässt sich sagen, dass Docker eine leistungsstarke und flexible Plattform für die Containerisierung von Anwendungen bietet. Es ermöglicht Entwicklern, ihre Anwendungen schnell und einfach zu erstellen, zu testen und in der Produktion bereitzustellen, während es gleichzeitig eine effiziente Nutzung von Ressourcen und eine schnelle Startzeit gewährleistet.

Docker employs a client-server architecture. The Docker CLI acts as the client, sending commands to the Docker Daemon, which manages the lifecycle of containers and images. The following diagram illustrates this architecture:

+----------------+       +----------------+
| Docker Client   | ----> | Docker Daemon   |
| (CLI)          |       | (dockerd)      |
+----------------+       +----------------+

When a developer issues a command, like docker run, Der Docker-Daemon erstellt einen neuen Container aus dem angegebenen Image, weist Systemressourcen zu und startet die Anwendung.

Benefits of Using Docker

1. Consistency Across Environments

One of the most significant advantages of using Docker is the consistency it offers. Docker containers ensure that applications run the same way, regardless of the environment (development, testing, or production). This consistency reduces bugs and accelerates the development lifecycle.

2. Isolation

Docker bietet ein hohes Maß an Isolierung für Anwendungen. Jeder Container läuft in seiner eigenen Umgebung, sodass mehrere Anwendungen auf einem einzigen Host ohne gegenseitige Beeinträchtigung koexistieren können. Diese Isolierung minimiert das Risiko von Abhängigkeitskonflikten und erhöht die Sicherheit.

3. Ressourceneffizienz

Container sind im Vergleich zu herkömmlichen VMs leichtgewichtig. Sie teilen sich den Host-OS-Kernel, was bedeutet, dass sie weniger Ressourcen verbrauchen. Diese Effizienz führt zu schnelleren Startzeiten und reduziertem Overhead, wodurch Entwickler mehr Anwendungen auf derselben Hardware ausführen können.

4. Scalability

Docker erleichtert die horizontale Skalierung von Anwendungen. Entwickler können schnell zusätzliche Container erstellen, um erhöhten Datenverkehr zu bewältigen und sicherzustellen, dass Anwendungen auch unter Last reaktionsfähig bleiben. Diese Fähigkeit ist besonders vorteilhaft in Microservices-Architekturen.

5. Vereinfachte Bereitstellung

Mit Docker können Entwickler Anwendungen und ihre Abhängigkeiten in einer einzigen Einheit verpacken, die auf jedem System mit installiertem Docker einfach bereitgestellt werden kann. Diese Einfachheit reduziert die Komplexität der Bereitstellung und rationalisiert kontinuierliche Integrations- und Bereitstellungsprozesse (CI/CD).

6. Unterstützung für Microservices-Architektur

Docker ist ideal für die Microservices-Architektur geeignet, bei der Anwendungen in kleinere, unabhängige Dienste aufgeteilt werden. Jeder Microservice kann in seinem eigenen Container ausgeführt werden, wodurch Teams sie unabhängig voneinander entwickeln, testen und bereitstellen können.

Erste Schritte mit Docker

Um Docker zu verwenden, müssen Sie es auf Ihrem Entwicklungsrechner installieren. Befolgen Sie diese Schritte:

Step 1: Install Docker

1. Windows oder MacLaden Sie Docker Desktop von der Docker-Website und folgen Sie den Installationsanweisungen.

2. LinuxVerwenden Sie Ihren Paketmanager, um Docker zu installieren. Auf Ubuntu können Sie beispielsweise Folgendes ausführen:

   sudo apt-get update
   sudo apt-get install docker-ce docker-ce-cli containerd.io

Schritt 2: Überprüfen der Installation

Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:

docker --version

This command should display the installed Docker version.

Schritt 3: Führen Sie Ihren ersten Container ausNachdem Sie nun Docker Desktop installiert haben, können Sie einen Container ausführen. Öffnen Sie ein Terminalfenster und führen Sie den folgenden Befehl aus:``` docker run hello-world ```Der Befehl `docker run` erstellt einen Container aus einem bestimmten Image und startet ihn. In diesem Fall verwenden wir das Image `hello-world`, das ein einfaches "Hello from Docker!"-Programm enthält.Wenn Sie den Befehl ausführen, lädt Docker das Image `hello-world` herunter (falls es noch nicht auf Ihrem System vorhanden ist) und erstellt einen Container daraus. Der Container führt dann das Programm aus und gibt die Ausgabe auf der Konsole aus.Die Ausgabe sollte in etwa so aussehen:``` Hello from Docker! This message shows that your installation appears to be working correctly. ```Herzlichen Glückwunsch! Sie haben erfolgreich Ihren ersten Container mit Docker ausgeführt.

Sie können Ihre Docker-Installation testen, indem Sie einen einfachen Container ausführen. Führen Sie den folgenden Befehl aus:

docker run hello-world

Dieser Befehl holt die Hallo Welt Bild von Docker Hub und führt es in einem Container aus. Sie sollten eine Bestätigungsnachricht sehen, wenn alles korrekt funktioniert.

Schritt 4: Erstellen eines Docker-Images

Jetzt erstellen wir ein benutzerdefiniertes Docker-Image mithilfe einer Dockerfile. Erstellen Sie ein neues Verzeichnis für Ihr Projekt und navigieren Sie in dieses:

mkdir my-docker-app
cd my-docker-app

Erstelle eine Datei namens Dockerfile with the following contents (for a simple Node.js application):

# Use the official Node.js image as a base
FROM node:14

# Set the working directory
WORKDIR /usr/src/app

# Copy package.json and install dependencies
COPY package*.json ./
RUN npm install

# Copy the application code
COPY . .

# Expose the application port
EXPOSE 8080

# Command to run the application
CMD ["node", "app.js"]

Schritt 5: Erstellen des Bildes

Um das Docker-Image zu erstellen, führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus:

docker build -t my-node-app .

Dieser Befehl weist Docker an, ein Image mit dem Namen mein-knoten-app from the current directory (indicated by .).

Schritt 6: Ausführen des Containers

Nachdem Sie das Image erfolgreich erstellt haben, können Sie die Anwendung in einem Container ausführen:

docker run -p 8080:8080 my-node-app

Dieser Befehl ordnet den Port zu 8080 an Ihren Host an Port 8080 on the container, allowing you to access the application in your web browser at http://localhost:8080.

Schritt 7: Docker Compose für Multi-Container-AnwendungenIn diesem Schritt werden wir Docker Compose verwenden, um Multi-Container-Anwendungen zu verwalten. Docker Compose ist ein Tool, das es ermöglicht, mehrere Docker-Container als eine Anwendung zu definieren und zu verwalten.Um Docker Compose zu verwenden, müssen Sie zuerst eine YAML-Datei erstellen, die die Konfiguration Ihrer Anwendung definiert. Diese Datei wird als "docker-compose.yml" bezeichnet und enthält Informationen über die verschiedenen Container, die Ihre Anwendung ausmachen, sowie deren Konfiguration.Hier ist ein Beispiel für eine einfache docker-compose.yml-Datei:```yaml version: '3' services: web: build: . ports: - "5000:5000" volumes: - .:/code redis: image: redis ```In diesem Beispiel definieren wir zwei Dienste: "web" und "redis". Der "web"-Dienst wird aus dem aktuellen Verzeichnis gebaut und ist auf Port 5000 erreichbar. Der "redis"-Dienst verwendet das offizielle Redis-Image.Um die Anwendung mit Docker Compose zu starten, navigieren Sie zu dem Verzeichnis, in dem sich die docker-compose.yml-Datei befindet, und führen Sie den folgenden Befehl aus:```bash docker-compose up ```Dieser Befehl startet alle in der docker-compose.yml-Datei definierten Dienste. Sie können auch einzelne Dienste starten, indem Sie den Namen des Dienstes angeben:```bash docker-compose up web ```Um die Anwendung zu stoppen, verwenden Sie den folgenden Befehl:```bash docker-compose down ```Docker Compose bietet auch viele weitere Funktionen, wie z.B. das Skalieren von Diensten, das Anzeigen von Protokollen und das Ausführen von Befehlen in Containern. Weitere Informationen finden Sie in der offiziellen Docker Compose-Dokumentation.In diesem Schritt haben Sie gelernt, wie man Docker Compose verwendet, um Multi-Container-Anwendungen zu verwalten. Im nächsten Schritt werden wir uns mit der Orchestrierung von Docker-Containern mit Docker Swarm beschäftigen.

In realen Anwendungen müssen Sie oft mehrere Dienste ausführen. Zum Beispiel benötigt eine Webanwendung möglicherweise eine Datenbank. Docker Compose vereinfacht die Verwaltung dieser Dienste.

Erstelle eine Datei namens docker-compose.yml in your project directory with the following content:

version: '3'
dienste:
  webdienst:
    build: .
    ports:
      - "8080:8080"
  datenbank:
    image: mongo
    ports:
      - "27017:27017"

Diese Konfiguration definiert zwei Dienste. Netz and db. Die Netz Der Service wird aus dem aktuellen Verzeichnis erstellt, während der... db Der Dienst verwendet das offizielle MongoDB-Image.

To start your application, run:

docker-compose up

This command will build the Netz service and start both services. You can access your web application at http://localhost:8080 and the MongoDB instance at http://localhost:27017.

Managing Docker Containers and Images

Das Verständnis, wie man Docker-Container und -Images verwaltet, ist für Entwickler von entscheidender Bedeutung. Hier sind einige wesentliche Befehle:

List Running Containers

Um die aktuell laufenden Container anzuzeigen, verwenden Sie:

docker ps

Alle Container auflisten

Um alle Container anzuzeigen, einschließlich der gestoppten, führen Sie Folgendes aus:

docker ps -a

Beenden eines ContainersUm einen Container zu beenden, müssen Sie den Befehl `docker stop` verwenden. Der Befehl akzeptiert einen Container-Namen oder eine ID als Argument. Wenn Sie beispielsweise einen Container mit dem Namen "my_container" beenden möchten, können Sie den folgenden Befehl verwenden:``` docker stop my_container ```Wenn Sie die ID des Containers kennen, können Sie diese stattdessen verwenden. Zum Beispiel:``` docker stop 1234567890ab ```Wenn Sie mehrere Container beenden möchten, können Sie ihre Namen oder IDs durch Leerzeichen getrennt angeben. Zum Beispiel:``` docker stop my_container1 my_container2 1234567890ab ```Wenn Sie alle laufenden Container beenden möchten, können Sie den folgenden Befehl verwenden:``` docker stop $(docker ps -q) ```Dieser Befehl verwendet die `docker ps -q` Option, um eine Liste aller laufenden Container-IDs zu erhalten, und übergibt diese dann an den `docker stop` Befehl.

Um einen laufenden Container zu stoppen, verwenden Sie:

docker stop 

Entfernen eines Containers

Um einen gestoppten Container zu löschen, führen Sie den folgenden Befehl aus:

Docker-Container entfernen 

Docker-Images auflisten

Um alle verfügbaren Bilder auf Ihrem System anzuzeigen, verwenden Sie:

docker images

Bild entfernen

To remove an image, run:

docker Image entfernen 

Fazit

Docker ist ein echter Gewinn für Entwickler und bietet einen robusten und effizienten Weg zum Erstellen, Bereitstellen und Verwalten von Anwendungen. Seine Containerisierungstechnologie adressiert viele Herausforderungen in der modernen Softwareentwicklung, wie Umgebungskonsistenz, Ressourcenverwaltung und Bereitstellungskomplexität.

Indem Sie die Kernkonzepte von Docker verstehen und wissen, wie Sie es in Ihren Workflow integrieren, können Sie Ihren Entwicklungsprozess erheblich verbessern. Ob Sie als Einzelentwickler arbeiten oder Teil eines größeren Teams sind – die Nutzung von Docker kann zu besserer Zusammenarbeit, schnelleren Entwicklungszyklen und zuverlässigeren Anwendungen führen.

Wenn Sie Ihre Reise mit Docker fortsetzen, erkunden Sie erweiterte Funktionen wie Netzwerke, Volumes für persistente Speicherung und Orchestrierungstools wie Kubernetes. Die Möglichkeiten mit Docker sind grenzenlos, und seine Beherrschung wird Ihre Karriere als Entwickler zweifellos voranbringen.