Erste Schritte: Deinen ersten Docker-Container ausführen

Docker has revolutionized the way developers create, deploy, and manage applications. By using containers, Docker allows developers to package applications with all their dependencies, ensuring that they run uniformly across various computing environments. In this article, we will guide you through the steps of running your first Docker container, diving deep into concepts, commands, and best practices that will set a solid foundation for your containerization journey.

Was ist Docker?

Bevor wir uns mit der Containerisierung befassen, lassen Sie uns klären, was Docker ist. Docker ist eine Open-Source-Plattform, die die Bereitstellung, Skalierung und Verwaltung von Anwendungen in containerisierten Umgebungen automatisiert. Ein Docker-Container kapselt eine Anwendung und ihre Abhängigkeiten, sodass sie nahtlos auf jedem System ausgeführt werden kann, auf dem Docker installiert ist.

Schlüsselkonzepte in Docker

Das Verstehen einiger grundlegender Docker-Konzepte ist entscheidend, bevor Sie Ihren ersten Container ausführen.

• Bilder: Docker images are read-only templates used to create containers. They contain everything needed to run an application, including code, runtime, libraries, and environment variables.

• Containers: A container is a runnable instance of an image. Containers are lightweight and designed to be ephemeral, meaning they can be created, started, stopped, and destroyed quickly.

• DockerfileEine Dockerfile ist ein Skript, das Anweisungen zum Erstellen eines Docker-Images enthält. Es definiert das Basis-Image, den Anwendungscode, Umgebungsvariablen und alle Abhängigkeiten.

• Docker Hub: Dies ist ein cloud-basierter Repository, in dem Docker-Images gespeichert und geteilt werden können. Es enthält eine umfangreiche Bibliothek offizieller Images, die mit minimalem Aufwand heruntergeladen und verwendet werden können.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

1. Docker InstalliertStellen Sie sicher, dass Docker auf Ihrem Computer installiert ist. Sie können den Installationsanweisungen für Ihr Betriebssystem auf der offizielle Docker-Dokumentation.

2. Command-Line Interface (CLI) Access: You will need to use a command-line interface like Terminal (macOS/Linux) or Command Prompt/PowerShell (Windows).

Schritt 1: Ziehen eines Docker-Images

The first step in running a Docker container is pulling (downloading) an image from Docker Hub. For this tutorial, we will use the official Hallo Welt image, which is a simple image designed for testing Docker installations.

Um das Image herunterzuladen, führen Sie den folgenden Befehl in Ihrem Terminal aus:

docker pull hello-world

Understanding the Command

• docker: This is the command-line tool for interacting with Docker.
• ziehen: This command instructs Docker to download the specified image from Docker Hub.
• Hallo Welt: This is the name of the image we want to pull.

Sobald das Image heruntergeladen wurde, sehen Sie eine Ausgabe, die bestätigt, dass das Image erfolgreich heruntergeladen wurde.

Schritt 2: Ausführen Ihres ersten ContainersNachdem Sie Docker installiert haben, können Sie nun Ihren ersten Container ausführen. Ein Container ist eine standardisierte Einheit von Software, die Code und alle Abhängigkeiten enthält, die benötigt werden, um eine Anwendung schnell und zuverlässig von einer Computing-Umgebung zur nächsten auszuführen.Um einen Container auszuführen, verwenden Sie den Befehl `docker run`. Hier ist ein einfaches Beispiel, um einen Container mit dem offiziellen Ubuntu-Image zu starten:``` docker run ubuntu ```Dieser Befehl lädt das Ubuntu-Image von Docker Hub (falls es nicht bereits lokal vorhanden ist) und startet einen Container basierend auf diesem Image. Da das Ubuntu-Image jedoch keine laufenden Prozesse enthält, wird der Container sofort beendet.Um einen interaktiven Container zu starten, können Sie die Optionen `-it` verwenden:``` docker run -it ubuntu ```Dieser Befehl startet einen interaktiven Container, in dem Sie eine Shell innerhalb des Containers ausführen können. Sie können nun Befehle innerhalb des Containers ausführen, als ob Sie auf einem Ubuntu-System arbeiten würden.Um einen Container im Hintergrund laufen zu lassen, können Sie die Option `-d` verwenden:``` docker run -d ubuntu sleep 1000 ```Dieser Befehl startet einen Container, der 1000 Sekunden schläft, und gibt die Container-ID zurück. Der Container läuft im Hintergrund weiter.Um eine Liste aller laufenden Container anzuzeigen, verwenden Sie den Befehl `docker ps`:``` docker ps ```Um eine Liste aller Container (einschließlich beendeter) anzuzeigen, verwenden Sie den Befehl `docker ps -a`:``` docker ps -a ```Um einen laufenden Container zu stoppen, verwenden Sie den Befehl `docker stop` gefolgt von der Container-ID oder dem Namen:``` docker stop ```Um einen beendeten Container zu entfernen, verwenden Sie den Befehl `docker rm` gefolgt von der Container-ID oder dem Namen:``` docker rm ```Mit diesen grundlegenden Befehlen können Sie Ihre ersten Schritte mit Docker-Containern machen. In den nächsten Schritten werden wir uns mit komplexeren Szenarien und fortgeschrittenen Funktionen von Docker beschäftigen.

Now that you have the Hallo Welt image, it’s time to run a container based on that image. Use the following command:

docker run hello-world

What Happens Here?

• laufen: This command creates and starts a container from the specified image. If the image isn’t available locally, Docker will try to pull it from Docker Hub.

When you run the command, you should see a message indicating that Docker is working correctly. The message includes information about the Docker installation and confirms that you have successfully run your first container.

Step 3: Understanding Container Lifecycle

Every Docker container has a lifecycle consisting of several states: created, running, paused, stopped, and removed. Understanding these states is crucial for managing containers effectively.

Container-Zustände

• Erstellt: Der Container wurde erstellt, läuft aber nicht.
• Laufen: The container is actively executing.
• Paused: The container is temporarily suspended.
• Stopped: The container has finished executing and is no longer running.
• Entfernt: Der Container wurde gelöscht.

You can check the status of your containers using:

docker ps -a

This command lists all containers, showing their IDs, names, status, and other essential information.

Step 4: Managing Containers

Stopping a Container

Um einen laufenden Container zu stoppen, verwenden Sie die docker stop command followed by the container ID or name. For example:

docker stop 

Entfernen eines Containers

Once you have stopped a container, you can remove it with the following command:

Docker-Container entfernen 

Schritt 5: Ausführen eines Containers mit benutzerdefinierten OptionenIn diesem Schritt werden wir einen Container mit benutzerdefinierten Optionen ausführen. Dies ermöglicht es uns, den Container nach unseren spezifischen Anforderungen zu konfigurieren.Um einen Container mit benutzerdefinierten Optionen auszuführen, verwenden wir den Befehl `docker run` gefolgt von verschiedenen Flags und Parametern. Hier sind einige der wichtigsten Optionen, die wir verwenden können:1. `-d`: Führt den Container im Hintergrund (detached mode) aus. 2. `-p`: Veröffentlicht einen Container-Port auf dem Host. 3. `-v`: Hängt ein Volume an den Container an. 4. `--name`: Gibt dem Container einen benutzerdefinierten Namen. 5. `--env`: Setzt Umgebungsvariablen im Container. 6. `--network`: Verbindet den Container mit einem bestimmten Netzwerk.Hier ist ein Beispielbefehl, der einen Container mit einigen benutzerdefinierten Optionen ausführt:``` docker run -d -p 8080:80 --name my-container -v /data:/app/data --env DB_HOST=localhost --network my-network my-image ```In diesem Beispiel:- `-d` führt den Container im Hintergrund aus. - `-p 8080:80` veröffentlicht Port 80 des Containers auf Port 8080 des Hosts. - `--name my-container` gibt dem Container den Namen "my-container". - `-v /data:/app/data` hängt das Verzeichnis `/data` des Hosts an das Verzeichnis `/app/data` des Containers an. - `--env DB_HOST=localhost` setzt die Umgebungsvariable `DB_HOST` auf "localhost". - `--network my-network` verbindet den Container mit dem Netzwerk "my-network". - `my-image` ist der Name des verwendeten Images.Sie können diese Optionen nach Ihren Bedürfnissen anpassen und weitere hinzufügen, um den Container genau so zu konfigurieren, wie Sie es wünschen.Denken Sie daran, dass Sie den Befehl `docker run --help` verwenden können, um eine vollständige Liste der verfügbaren Optionen und deren Beschreibungen anzuzeigen.

Während des Laufens Hallo Welt image is a good start, Docker allows you to customize the runtime behavior of containers using various options.

Interaktiven Container ausführen

You can run a container in interactive mode using the -it Flag. Dies ist besonders nützlich für Debugging oder wenn Sie mit einer Befehlszeilenschnittstelle innerhalb des Containers interagieren möchten. Zum Beispiel kann ein leichtgewichtiges Ubuntu-Container wie folgt ausgeführt werden:

docker run -it ubuntu

Understanding the Command

• -it: This flag combines two options: -ich (interaktiv) und -t (terminal), allowing you to interact with the container’s shell.
• ubuntu: Dies gibt das gewünschte Image an, in diesem Fall ein Ubuntu-Basis-Image.

After executing this command, you will be dropped into the shell of the Ubuntu container. You can run commands inside it just like you would on a regular Linux system.

Step 6: Creating Your Own Dockerfile

Now that you have a grasp of running containers, let’s delve into creating your own Docker image using a Dockerfile. This process allows you to customize your applications and their environments.

Erstellen einer einfachen Dockerfile-Datei

1. Verzeichnis erstellen: First, create a new directory for your project:

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

2. Create a Dockerfile: Create a file named Dockerfile in this directory and open it in your favorite text editor.

3. Anweisungen hinzufügenFügen Sie die folgenden Zeilen zu Ihrer Dockerfile hinzu:

   # Eine offizielle Node.js-Laufzeitumgebung als Basisimage verwenden
   FROM node:14
   
   # Arbeitsverzeichnis im Container festlegen
   WORKDIR /usr/src/app
   
   # package.json und package-lock.json kopieren
   COPY package*.json ./
   
   # Abhängigkeiten installieren
   RUN npm install
   
   # Rest des Anwendungscodes kopieren
   COPY . .
   
   # Anwendungsport freigeben
   EXPOSE 8080
   
   # Befehl zum Ausführen der Anwendung
   CMD ["node", "app.js"]

Explanation of the Dockerfile Instructions

• FROMLegt das zu verwendende Basis-Image fest. In diesem Fall verwenden wir das offizielle Node.js-Image.
• Arbeitsverzeichnis: Sets the working directory for any subsequent instructions.
• KOPIEKopiert Dateien von Ihrem lokalen Dateisystem in den Container.
• RUN: Executes a command in the container, in this case, installing Node.js dependencies.
• EXPOSE: Gibt den Port an, an dem der Container auf Verbindungen lauscht.
• CMD: Specifies the command that will run when the container starts.

Building Your Docker Image

Um Ihr Docker-Image aus der Dockerfile zu erstellen, wechseln Sie in Ihr Projektverzeichnis und führen Sie aus:

docker build -t my-node-app .

Understanding the Build Command

• bauen: This command tells Docker to create an image from the provided Dockerfile.
• -t meine-node-app: Markiert das Bild mit einem Namen (in diesem Fall, mein-knoten-app).
• .: Gibt das aktuelle Verzeichnis als Build-Kontext an, in dem Docker nach der Dockerfile und allen Dateien sucht, die es kopieren muss.

Ausführen Ihres benutzerdefinierten ImagesNachdem Sie Ihr benutzerdefiniertes Image erstellt haben, können Sie es ausführen, indem Sie den folgenden Befehl verwenden:``` docker run -d -p 80:80 my-custom-image ```In diesem Befehl:- `-d` gibt an, dass der Container im Hintergrund ausgeführt werden soll. - `-p 80:80` ordnet Port 80 des Containers an Port 80 des Hosts an. - `my-custom-image` ist der Name des Images, das Sie erstellt haben.Nachdem Sie diesen Befehl ausgeführt haben, wird Ihr benutzerdefiniertes Image als Container ausgeführt und ist über Port 80 des Hosts erreichbar.

Once the image is built, you can run it with the following command:

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

Explanation of the laufen Command

• -p 8080:8080: Maps port 8080 on your host to port 8080 on the container, allowing you to access the application via your browser or tools like curl.

Advanced Container Management

As you get more comfortable with Docker, you’ll likely want to explore more advanced features and commands that enhance container management.

Using Docker Compose

Docker Compose ist ein Werkzeug zur Definition und Ausführung von Multi-Container-Docker-Anwendungen. Sie definieren die Dienste, Netzwerke und Volumes Ihrer Anwendung in einer docker-compose.yml file, making it easier to manage complex applications.

Example Docker Compose File

Here’s a simple example of a docker-compose.yml file for a web application with a Node.js backend and a MongoDB database:

version: '3'
services:
  web:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - mongo
  mongo:
    image: mongo:latest
    ports:
      - "27017:27017"

Running Docker Compose

Um Ihre definierte Anwendung auszuführen docker-compose.yml, wechseln Sie zum Verzeichnis, das die Datei enthält, und führen Sie aus:

docker-compose up

Dieser Befehl erstellt automatisch Ihre Images (falls angegeben) und startet die definierten Dienste.

Best Practices für die Verwendung von DockerDocker ist eine leistungsstarke Plattform zur Containerisierung von Anwendungen, die es Entwicklern ermöglicht, Anwendungen in isolierten Umgebungen zu erstellen, bereitzustellen und auszuführen. Um das Beste aus Docker herauszuholen und eine effiziente und sichere Nutzung zu gewährleisten, ist es wichtig, bewährte Praktiken zu befolgen. Hier sind einige wichtige Best Practices für die Verwendung von Docker:1. Verwenden Sie offizielle Images: Beginnen Sie mit offiziellen Docker-Images aus dem Docker Hub. Diese Images sind getestet, sicher und werden regelmäßig aktualisiert.2. Halten Sie Ihre Images klein: Reduzieren Sie die Größe Ihrer Docker-Images, indem Sie unnötige Pakete und Abhängigkeiten entfernen. Verwenden Sie Multi-Stage-Builds, um die Größe weiter zu reduzieren.3. Nutzen Sie .dockerignore: Erstellen Sie eine .dockerignore-Datei, um Dateien und Verzeichnisse auszuschließen, die nicht für den Build-Prozess benötigt werden. Dies beschleunigt den Build-Prozess und reduziert die Größe des Images.4. Verwenden Sie spezifische Tags: Anstatt immer das neueste Tag zu verwenden, geben Sie spezifische Versionen von Images an. Dies gewährleistet Reproduzierbarkeit und vermeidet unerwartete Änderungen.5. Implementieren Sie Sicherheitsbest Practices: Scannen Sie Ihre Images regelmäßig auf Sicherheitslücken. Verwenden Sie nicht-root-Benutzer in Ihren Containern und implementieren Sie Netzwerkrichtlinien.6. Nutzen Sie Docker Compose für Multi-Container-Anwendungen: Docker Compose vereinfacht die Verwaltung von Multi-Container-Anwendungen und deren Abhängigkeiten.7. Implementieren Sie Health Checks: Fügen Sie Health Checks zu Ihren Containern hinzu, um deren Status zu überwachen und automatische Neustarts bei Fehlern zu ermöglichen.8. Verwenden Sie Volumes für persistente Daten: Speichern Sie wichtige Daten in Docker-Volumes anstatt im Container-Dateisystem, um Datenverlust bei Container-Neustarts zu vermeiden.9. Optimieren Sie den Build-Prozess: Nutzen Sie Layer-Caching und parallele Builds, um die Build-Zeiten zu verkürzen. Verwenden Sie .dockerignore, um unnötige Dateien auszuschließen.10. Implementieren Sie CI/CD-Pipelines: Integrieren Sie Docker in Ihre Continuous Integration und Continuous Deployment-Pipelines, um automatisierte Builds und Tests zu ermöglichen.11. Überwachen und protokollieren Sie Ihre Container: Verwenden Sie Tools wie Prometheus und Grafana zur Überwachung und ELK-Stack für die Protokollierung, um Einblicke in die Container-Leistung zu erhalten.12. Halten Sie Ihre Docker-Umgebung auf dem neuesten Stand: Aktualisieren Sie regelmäßig Docker Engine und Docker Compose, um von den neuesten Funktionen und Sicherheitspatches zu profitieren.13. Nutzen Sie Docker Swarm oder Kubernetes für die Orchestrierung: Für die Verwaltung von Multi-Container-Anwendungen in Produktionsumgebungen sind Orchestrierungswerkzeuge wie Docker Swarm oder Kubernetes unerlässlich.14. Implementieren Sie Resource Limits: Setzen Sie Ressourcenlimits für Ihre Container, um eine Überbeanspruchung von Systemressourcen zu vermeiden.15. Dokumentieren Sie Ihre Dockerfiles: Fügen Sie Kommentare zu Ihren Dockerfiles hinzu, um den Build-Prozess und die getroffenen Entscheidungen zu erklären.Indem Sie diese Best Practices befolgen, können Sie die Leistung, Sicherheit und Wartbarkeit Ihrer Docker-basierten Anwendungen erheblich verbessern. Denken Sie daran, dass die Docker-Ökosysteme sich ständig weiterentwickeln, daher ist es wichtig, auf dem Laufenden zu bleiben und Ihre Praktiken entsprechend anzupassen.

As you embark on your Docker journey, consider these best practices:

1. Bilder klein halten: Use lightweight base images and remove unnecessary files to reduce image size.

2. Use Multi-Stage Builds: If your application requires building from source code, consider using multi-stage builds to keep your final image clean.

3. Bilder mit Tags versehenMit dieser Funktion können Sie Bilder mit Tags versehen.: Always tag your images with version numbers to avoid confusion and ensure reproducibility.

4. Nutzen Sie Docker-Volumes: Verwenden Sie Volumes, um Daten zu speichern, die von Docker-Containern generiert und von ihnen verwendet werden. Dies hilft, die Datenintegrität bei Neustarts von Containern aufrechtzuerhalten.

5. Secure Your Containers: Implement security best practices like minimizing privileges, using the least privileged user, and regularly scanning images for vulnerabilities.

Fazit

Herzlichen Glückwunsch! Sie haben erfolgreich Ihren ersten Docker-Container ausgeführt und wertvolle Einblicke in die grundlegenden Konzepte und Funktionen von Docker gewonnen. Wenn Sie Docker weiter erkunden, denken Sie daran, dass Übung der Schlüssel ist. Experimentieren Sie mit verschiedenen Images, erstellen Sie Ihre eigenen Anwendungen und integrieren Sie Docker in Ihren Entwicklungsprozess.

Docker vereinfacht nicht nur die Bereitstellung von Anwendungen, sondern verbessert auch die Zusammenarbeit zwischen Entwicklungsteams. Mit dem Wissen, das Sie aus diesem Artikel gewonnen haben, sind Sie auf dem besten Weg, die Kunst der Containerisierung zu meistern. Viel Spaß beim Dockern!