Glossary Archive - Seite 17 von 37

Glossar

Dämon
Docker AUFS
Docker BTRFS
Docker Build ArgsBuild Args are used to pass build-time variables to the Docker build process. They are defined in the Dockerfile using the `ARG` instruction and can be used to customize the build process or provide values for environment variables.Here's an example of how to use Build Args in a Dockerfile:```dockerfile FROM ubuntu:latestARG MY_VARRUN echo "The value of MY_VAR is: $MY_VAR" ```In this example, we define a Build Arg called `MY_VAR` using the `ARG` instruction. We can then use this variable in the `RUN` instruction to print its value.To pass a value for the Build Arg when building the Docker image, we use the `--build-arg` flag with the `docker build` command:```bash docker build --build-arg MY_VAR=my_value -t my_image . ```In this command, we pass the value `my_value` for the `MY_VAR` Build Arg. The resulting Docker image will have the value of `MY_VAR` set to `my_value`.Build Args can be useful in various scenarios, such as:1. Passing configuration values to the build process. 2. Customizing the build process based on different environments (e.g., development, staging, production). 3. Providing secrets or sensitive information during the build process (although it's recommended to use Docker secrets or environment variables for this purpose).It's important to note that Build Args are only available during the build process and are not persisted in the final Docker image. If you need to use the values in the running container, you should use environment variables instead.Build Args provide a flexible way to customize the Docker build process and pass values to the build instructions. They can be used in combination with other Dockerfile instructions to create dynamic and configurable Docker images.
Docker-Build-Cache
Docker Build Context
Docker Build Export
Docker Build Import
Docker-Build-Geheimnisse
Docker Buildx
Docker-Cache
Docker CLI Plugin
Docker Cloud
Docker Community Edition
Docker Compose
Docker-Compose-Erstellung
Docker Compose Build –no-cache
Docker Compose Build-Argumente
Docker Compose Buildx
Docker Compose Caching
Docker Compose Kompatibilitätsmatrix
Docker Compose Config
Docker Compose Config – Bild-Digests auflösen
Docker Compose Config –services
Docker Compose Config –volumes
Docker Compose Config Management
Docker-Compose-Konfigurationen
Docker Compose Abhängigkeiten
Docker Compose herunterfahren
Docker Compose Down –remove-orphans
Docker Compose Down –rmi
Docker Compose Down –volumes
Docker Compose Environment Files
Docker Compose Umgebungsvariablen
Docker Compose Exec
Docker Compose Exec –userDocker Compose ist ein leistungsstarkes Tool zur Definition und Ausführung von Multi-Container-Anwendungen. Mit Docker Compose können Sie Ihre Anwendungen in isolierten Umgebungen ausführen und verwalten. Eine der nützlichen Funktionen von Docker Compose ist die Möglichkeit, Befehle in laufenden Containern auszuführen. In diesem Artikel werden wir uns auf die Verwendung von "docker-compose exec" mit der Option "--user" konzentrieren.Die Option "--user" ermöglicht es Ihnen, den Benutzernamen oder die Benutzer-ID anzugeben, unter der der Befehl im Container ausgeführt werden soll. Dies ist besonders nützlich, wenn Sie bestimmte Berechtigungen oder Zugriffsrechte für den ausgeführten Befehl benötigen.Hier ist ein Beispiel für die Verwendung von "docker-compose exec --user":``` docker-compose exec --user ```In diesem Beispiel ersetzen Sie `` durch den gewünschten Benutzernamen oder die Benutzer-ID, `` durch den Namen des Dienstes, in dem der Befehl ausgeführt werden soll, und `` durch den eigentlichen Befehl, den Sie ausführen möchten.Angenommen, Sie haben einen Docker Compose Dienst namens "web" und möchten einen Befehl als Benutzer "www-data" ausführen. Sie können den folgenden Befehl verwenden:``` docker-compose exec --user www-data web ls -la ```In diesem Beispiel wird der Befehl "ls -la" im "web" Dienst als Benutzer "www-data" ausgeführt. Dadurch erhalten Sie eine Liste der Dateien und Verzeichnisse im Container mit den entsprechenden Berechtigungen des Benutzers "www-data".Die Verwendung der Option "--user" mit "docker-compose exec" bietet Ihnen die Flexibilität, Befehle mit den gewünschten Berechtigungen auszuführen. Dies ist besonders nützlich, wenn Sie auf bestimmte Ressourcen oder Dateien im Container zugreifen müssen, die spezifische Benutzerrechte erfordern.Es ist wichtig zu beachten, dass der angegebene Benutzername oder die Benutzer-ID im Container existieren muss. Andernfalls wird der Befehl möglicherweise nicht erfolgreich ausgeführt.Zusammenfassend lässt sich sagen, dass die Option "--user" in Kombination mit "docker-compose exec" eine leistungsstarke Möglichkeit bietet, Befehle in laufenden Containern mit den gewünschten Berechtigungen auszuführen. Durch die Angabe des Benutzernamens oder der Benutzer-ID können Sie sicherstellen, dass der Befehl mit den entsprechenden Rechten ausgeführt wird.
Docker Compose Ausführen --arbeitsverzeichnis
Externe Docker Compose-NetzwerkeIn diesem Artikel erfahren Sie, wie Sie externe Docker Compose-Netzwerke erstellen und verwenden können. Externe Netzwerke sind nützlich, wenn Sie mehrere Docker Compose-Dateien haben, die auf dasselbe Netzwerk zugreifen müssen.Erstellen eines externen NetzwerksUm ein externes Netzwerk zu erstellen, verwenden Sie den folgenden Befehl:``` docker network create ```Ersetzen Sie `` durch den gewünschten Namen für Ihr Netzwerk.Verwenden eines externen Netzwerks in Docker ComposeUm ein externes Netzwerk in einer Docker Compose-Datei zu verwenden, fügen Sie den folgenden Abschnitt hinzu:``` networks: default: external: name: ```Ersetzen Sie `` durch den Namen des externen Netzwerks, das Sie erstellt haben.BeispielAngenommen, Sie haben zwei Docker Compose-Dateien, `docker-compose.yml` und `docker-compose2.yml`, die auf dasselbe Netzwerk zugreifen müssen. Sie können ein externes Netzwerk namens `my-network` erstellen und es in beiden Dateien verwenden:``` # docker-compose.yml version: '3' services: web: image: nginx ports: - "80:80" networks: default: external: name: my-network# docker-compose2.yml version: '3' services: db: image: mysql environment: MYSQL_ROOT_PASSWORD: password networks: default: external: name: my-network ```In diesem Beispiel können der `web`-Service in `docker-compose.yml` und der `db`-Service in `docker-compose2.yml` über das externe Netzwerk `my-network` miteinander kommunizieren.FazitExterne Docker Compose-Netzwerke sind eine leistungsstarke Funktion, die es Ihnen ermöglicht, mehrere Docker Compose-Dateien auf dasselbe Netzwerk zugreifen zu lassen. Dies kann nützlich sein, wenn Sie komplexe Anwendungen mit mehreren Diensten haben, die miteinander kommunizieren müssen.
Docker Compose Externe Volumes
Docker Compose Datei
Docker Compose Help
Docker Compose Kill
Docker Compose Labels
Docker-Compose-Protokolle
Docker Compose Logs –follow
Docker Compose Netzwerk
Docker Compose Networking
Docker Compose Networks
Docker-Compose-Überschreibung
Docker Compose Override-Datei
Docker Compose Override Files
Docker Compose Profile
Docker Compose Project
Docker Compose PSDocker Compose ist ein Tool zur Definition und Ausführung von Multi-Container-Anwendungen. Mit Docker Compose können Sie eine YAML-Datei verwenden, um die Dienste Ihrer Anwendung zu konfigurieren. Anschließend können Sie mit einem einzigen Befehl alle Dienste erstellen und starten.Der Befehl `docker-compose ps` wird verwendet, um den Status der Dienste anzuzeigen, die von Docker Compose verwaltet werden. Er zeigt eine Liste aller laufenden Container und deren Status an.Hier ist ein Beispiel für die Ausgabe des Befehls `docker-compose ps`:``` Name Command State Ports ------------------------------------------------------------------- myapp_db_1 docker-entrypoint... Up 0.0.0.0:5432->5432/tcp myapp_web_1 python manage.py ... Up 0.0.0.0:8000->8000/tcp ```In diesem Beispiel sehen Sie zwei Dienste: `myapp_db_1` und `myapp_web_1`. Beide sind im Zustand "Up", was bedeutet, dass sie laufen. Die Ports zeigen an, welche Ports auf dem Host an die Container weitergeleitet werden.Der Befehl `docker-compose ps` ist nützlich, um schnell den Status Ihrer Dienste zu überprüfen und sicherzustellen, dass alles wie erwartet läuft.
Docker Compose PullDer Befehl `docker-compose pull` wird verwendet, um die Images für die Services in einer Docker Compose-Datei herunterzuladen. Dies ist nützlich, um sicherzustellen, dass die neuesten Versionen der Images verfügbar sind, bevor Sie Ihre Anwendung starten oder neu aufbauen.Hier ist die grundlegende Syntax für den Befehl:``` docker-compose pull [OPTIONEN] [SERVICE...] ```- `[OPTIONEN]` sind optionale Flags, die das Verhalten des Befehls ändern können. - `[SERVICE...]` ist eine optionale Liste von Services, für die Sie die Images herunterladen möchten. Wenn Sie keine Services angeben, werden die Images für alle Services in der Compose-Datei heruntergeladen.Hier sind einige der häufig verwendeten Optionen:- `--ignore-pull-failures`: Ignoriert Fehler beim Herunterladen von Images. - `--parallel`: Lädt Images parallel herunter, um den Prozess zu beschleunigen. - `--quiet`: Zeigt keine Fortschrittsinformationen an.Beispiel:``` docker-compose pull ```Dieser Befehl lädt die Images für alle Services in der Compose-Datei herunter.``` docker-compose pull web db ```Dieser Befehl lädt nur die Images für die Services "web" und "db" herunter.``` docker-compose pull --parallel ```Dieser Befehl lädt die Images für alle Services parallel herunter, was den Prozess beschleunigen kann.Denken Sie daran, dass `docker-compose pull` nur die Images herunterlädt, aber keine Container erstellt oder startet. Um Ihre Anwendung mit den heruntergeladenen Images zu starten, können Sie `docker-compose up` verwenden.
Docker Compose Pull –ignore-pull-failures
Docker Compose Pull –parallel
Docker Compose Push
Docker Compose Entfernen
Docker Compose Neustart
Docker Compose Restart Service
Docker Compose RunDocker Compose ist ein Tool, das es ermöglicht, mehrere Docker-Container als Einheit zu definieren und zu verwalten. Es verwendet eine YAML-Datei, um die Konfiguration der Container zu beschreiben, einschließlich der verwendeten Images, der Netzwerkeinstellungen, der Umgebungsvariablen und der Verknüpfungen zwischen den Containern.Um Docker Compose zu verwenden, müssen Sie zunächst eine YAML-Datei erstellen, die die Konfiguration Ihrer Container beschreibt. Diese Datei wird normalerweise "docker-compose.yml" genannt und sollte im Stammverzeichnis Ihres Projekts gespeichert werden.Hier ist ein Beispiel für eine einfache docker-compose.yml-Datei:```yaml version: '3' services: web: image: nginx:latest ports: - "80:80" volumes: - ./html:/usr/share/nginx/html db: image: mysql:latest environment: MYSQL_ROOT_PASSWORD: example ```In diesem Beispiel definieren wir zwei Dienste: "web" und "db". Der "web"-Dienst verwendet das neueste Nginx-Image und bindet Port 80 des Containers an Port 80 des Hosts. Außerdem wird ein Volume eingebunden, das den Inhalt des "html"-Verzeichnisses im Stammverzeichnis des Projekts in das Nginx-Verzeichnis für statische Dateien kopiert. Der "db"-Dienst verwendet das neueste MySQL-Image und setzt das Root-Passwort auf "example".Um die Container mit Docker Compose zu starten, navigieren Sie zum Verzeichnis, das die docker-compose.yml-Datei enthält, und führen Sie den folgenden Befehl aus:``` docker-compose up ```Dieser Befehl startet alle in der docker-compose.yml-Datei definierten Container. Wenn Sie die Container im Hintergrund starten möchten, können Sie den Parameter "-d" hinzufügen:``` docker-compose up -d ```Um die Container zu stoppen, verwenden Sie den folgenden Befehl:``` docker-compose down ```Docker Compose bietet auch viele weitere Befehle und Optionen, um die Container zu verwalten. Zum Beispiel können Sie mit "docker-compose ps" eine Liste der laufenden Container anzeigen, mit "docker-compose logs" die Logs der Container anzeigen und mit "docker-compose exec" Befehle in den Containern ausführen.Zusammenfassend lässt sich sagen, dass Docker Compose ein leistungsstarkes Tool ist, um mehrere Docker-Container als Einheit zu verwalten. Es vereinfacht die Konfiguration und Verwaltung von Multi-Container-Anwendungen erheblich und ist ein unverzichtbares Werkzeug für jeden Docker-Entwickler.
Docker Compose Run –entrypoint
Docker Compose Run –rmDocker Compose ist ein leistungsstarkes Tool zur Definition und Ausführung von Multi-Container-Anwendungen. Es ermöglicht Entwicklern, ihre Anwendungen und deren Abhängigkeiten in einer einzigen Datei zu definieren und mit einem einzigen Befehl zu starten. In diesem Artikel werden wir uns auf die Verwendung des Befehls `docker-compose run --rm` konzentrieren.Der Befehl `docker-compose run` wird verwendet, um einen einmaligen Dienst zu starten, der in der Docker Compose-Konfigurationsdatei definiert ist. Der `--rm`-Flag ist eine Option, die dem Befehl hinzugefügt werden kann, um den Container nach Beendigung des Dienstes automatisch zu entfernen. Dies ist besonders nützlich, wenn man einen Dienst nur für einen bestimmten Zweck starten möchte, wie zum Beispiel zum Ausführen von Tests oder zum Ausführen eines einmaligen Befehls.Hier ist ein Beispiel für die Verwendung von `docker-compose run --rm`:```bash docker-compose run --rm my_service my_command ```In diesem Beispiel wird der Dienst `my_service` gestartet und der Befehl `my_command` wird innerhalb des Containers ausgeführt. Nach Abschluss des Befehls wird der Container automatisch entfernt.Es ist wichtig zu beachten, dass der `--rm`-Flag nur für den Dienst gilt, der mit dem `run`-Befehl gestartet wird. Andere Dienste, die in der Docker Compose-Konfigurationsdatei definiert sind, werden nicht automatisch entfernt.Zusammenfassend lässt sich sagen, dass der Befehl `docker-compose run --rm` eine nützliche Option ist, um einmalige Dienste zu starten und automatisch zu bereinigen. Es hilft dabei, die Umgebung sauber zu halten und Ressourcen effizient zu nutzen.
Docker Compose Skalierung
Geheimnisverwaltung mit Docker ComposeDocker Compose ist ein leistungsstarkes Tool zur Definition und Ausführung von Multi-Container-Anwendungen. Es ermöglicht Ihnen, Ihre Anwendungsdienste in einer einzigen Datei zu definieren und mit einem einzigen Befehl alles zu starten oder zu stoppen. Ein wichtiger Aspekt bei der Verwendung von Docker Compose ist die Verwaltung von Geheimnissen, wie Passwörtern, API-Schlüsseln oder anderen sensiblen Informationen.In diesem Artikel werden wir uns mit der Geheimnisverwaltung in Docker Compose beschäftigen und verschiedene Ansätze zur sicheren Handhabung von Geheimnissen untersuchen.1. UmgebungsvariablenEine einfache Möglichkeit, Geheimnisse in Docker Compose zu verwalten, ist die Verwendung von Umgebungsvariablen. Sie können Geheimnisse als Umgebungsvariablen in Ihrer docker-compose.yml-Datei definieren und dann in Ihren Diensten referenzieren.Hier ist ein Beispiel:```yaml services: web: image: my-web-app environment: - DB_PASSWORD=${DB_PASSWORD} ```In diesem Beispiel wird das Geheimnis DB_PASSWORD als Umgebungsvariable definiert und kann dann in Ihrem Anwendungscode referenziert werden.2. .env-DateienEine weitere Möglichkeit, Geheimnisse in Docker Compose zu verwalten, ist die Verwendung von .env-Dateien. Sie können eine .env-Datei erstellen, die Ihre Geheimnisse enthält, und dann in Ihrer docker-compose.yml-Datei darauf verweisen.Hier ist ein Beispiel:```yaml services: web: image: my-web-app env_file: - .env ```In diesem Beispiel wird die .env-Datei als Umgebungsvariablenquelle für den web-Dienst definiert. Die .env-Datei könnte dann Geheimnisse wie folgt enthalten:``` DB_PASSWORD=mysecretpassword API_KEY=1234567890 ```3. Docker SecretsWenn Sie Docker Swarm verwenden, können Sie auch Docker Secrets nutzen, um Geheimnisse sicher zu verwalten. Docker Secrets ermöglichen es Ihnen, sensible Daten sicher in Ihrem Swarm-Cluster zu speichern und zu verwalten.Hier ist ein Beispiel:```yaml services: web: image: my-web-app secrets: - db_password - api_keysecrets: db_password: external: true api_key: external: true ```In diesem Beispiel werden zwei Geheimnisse, db_password und api_key, als externe Geheimnisse definiert. Sie müssen diese Geheimnisse vor dem Starten Ihrer Anwendung erstellen.4. Drittanbieter-ToolsEs gibt auch verschiedene Drittanbieter-Tools, die Ihnen bei der Verwaltung von Geheimnissen in Docker Compose helfen können. Einige beliebte Optionen sind:- HashiCorp Vault: Ein Tool zur sicheren Verwaltung von Geheimnissen und sensiblen Daten. - AWS Secrets Manager: Ein verwalteter Dienst von Amazon Web Services zur sicheren Speicherung und Verwaltung von Geheimnissen. - Azure Key Vault: Ein verwalteter Dienst von Microsoft Azure zur sicheren Speicherung und Verwaltung von Geheimnissen.Diese Tools bieten erweiterte Funktionen zur Geheimnisverwaltung und können in Ihre Docker Compose-Umgebung integriert werden.FazitDie Verwaltung von Geheimnissen ist ein wichtiger Aspekt bei der Verwendung von Docker Compose. In diesem Artikel haben wir verschiedene Ansätze zur sicheren Handhabung von Geheimnissen untersucht, einschließlich der Verwendung von Umgebungsvariablen, .env-Dateien, Docker Secrets und Drittanbieter-Tools. Je nach Ihren Anforderungen und der Komplexität Ihrer Anwendung können Sie den Ansatz wählen, der am besten zu Ihnen passt.
Docker Compose Geheimnisse
Docker Compose Service
Docker Compose Service Log
Docker Compose Service ScaleDocker Compose ist ein Tool zur Definition und Ausführung von Multi-Container-Anwendungen. Es ermöglicht die Verwaltung von Docker-Containern in einer einzigen Datei, der sogenannten docker-compose.yml. Eine der nützlichen Funktionen von Docker Compose ist die Möglichkeit, die Anzahl der Instanzen eines bestimmten Dienstes zu skalieren.Die Skalierung eines Dienstes in Docker Compose erfolgt mit dem Befehl `docker-compose scale`. Dieser Befehl ermöglicht es, die Anzahl der laufenden Container für einen bestimmten Dienst zu erhöhen oder zu verringern. Dies ist besonders nützlich, wenn Sie die Last auf Ihre Anwendung verteilen oder die Ressourcennutzung optimieren möchten.Um einen Dienst zu skalieren, verwenden Sie den folgenden Befehl:``` docker-compose scale = ```Ersetzen Sie `` durch den Namen des Dienstes, den Sie skalieren möchten, und `` durch die gewünschte Anzahl der Instanzen.Zum Beispiel, wenn Sie einen Dienst namens "web" haben und diesen auf 5 Instanzen skalieren möchten, verwenden Sie den folgenden Befehl:``` docker-compose scale web=5 ```Docker Compose erstellt dann 5 Instanzen des "web"-Dienstes und verteilt die Last auf diese Instanzen.Es ist wichtig zu beachten, dass nicht alle Dienste in Docker Compose skaliert werden können. Einige Dienste, wie z.B. Datenbanken, können möglicherweise nicht skaliert werden, da sie auf eine bestimmte Anzahl von Instanzen beschränkt sind oder spezielle Konfigurationen erfordern.Zusammenfassend lässt sich sagen, dass die Skalierung von Diensten in Docker Compose eine leistungsstarke Funktion ist, die es ermöglicht, die Anzahl der Instanzen eines bestimmten Dienstes zu erhöhen oder zu verringern. Dies kann dazu beitragen, die Last auf Ihre Anwendung zu verteilen und die Ressourcennutzung zu optimieren.
Docker Compose Starten
Docker Compose Stop
Docker Compose Stopp --timeout
Docker Compose Dienst stoppen
Docker Compose Up
Docker Compose Up –build
Docker Compose up --detach
Docker Compose Version
Docker Compose Version Compatibility
Docker-Compose-Volume
Docker Compose Volumes
Docker-Konfigurationsverwaltung
Docker-Container anhängen
Docker Container Commit
Docker Container CP
Docker Container Diff
Docker Container ExecDocker Container Exec is a command used to execute commands inside a running Docker container. It allows you to interact with the container's file system and run processes within the container's environment.Syntax: ``` docker exec [OPTIONS] CONTAINER COMMAND [ARG...] ```Options: - `-d, --detach`: Run the command in the background - `-i, --interactive`: Keep STDIN open even if not attached - `-t, --tty`: Allocate a pseudo-TTY - `-u, --user`: Username or UID (format: [:]) - `-w, --workdir`: Working directory inside the containerExamples: 1. Execute a command in a running container: ``` docker exec my_container ls -la ```2. Start an interactive bash shell in a container: ``` docker exec -it my_container bash ```3. Run a command as a specific user: ``` docker exec -u 1000 my_container whoami ```4. Execute a command in a specific working directory: ``` docker exec -w /app my_container pwd ```5. Run a command in the background: ``` docker exec -d my_container sleep 1000 ```Docker Container Exec is useful for debugging, inspecting, or modifying the state of a running container without stopping it. It provides a way to interact with the container's environment and perform various tasks as needed.
Docker Container Export
Docker-Container-Import
Docker Container InspectThe `docker container inspect` command provides detailed information about a container. This command is useful for troubleshooting and understanding the configuration and state of a container.### Basic UsageTo inspect a container, use the following command:```bash docker container inspect ```Replace `` with the name or ID of the container you want to inspect.### Example```bash docker container inspect my_container ```This will output a JSON object containing detailed information about the container, including its configuration, state, and network settings.### Filtering OutputYou can filter the output to display specific information. For example, to get the IP address of the container, you can use the `--format` flag:```bash docker container inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' my_container ```This will output the IP address of the container.### Common Use Cases1. **Checking Container Status**: To see if a container is running, use:```bash docker container inspect --format='{{.State.Status}}' my_container ```2. **Viewing Environment Variables**: To see the environment variables set for a container, use:```bash docker container inspect --format='{{.Config.Env}}' my_container ```3. **Checking Mount Points**: To see the mount points of a container, use:```bash docker container inspect --format='{{.Mounts}}' my_container ```### ConclusionThe `docker container inspect` command is a powerful tool for gaining insights into the configuration and state of Docker containers. By using the `--format` flag, you can extract specific information that is relevant to your needs.
Docker Container Kill
Docker-Container-Protokolle
Docker Container LS
Docker Container anhalten
Docker Container umbenennen
Docker-Container-Neustart
Docker Container RM
Docker Container Run
Docker-Container starten
Docker Container Statistiken
Docker-Container stoppen
Docker-Container-Top
Docker-Container fortsetzenBeschreibung Der Befehl docker unpause wird verwendet, um alle Prozesse innerhalb eines angehaltenen Containers fortzusetzen. Wenn ein Container angehalten wird, werden alle seine Prozesse eingefroren, und der Container verbraucht keine CPU-Ressourcen. Mit diesem Befehl können Sie den Container wieder in seinen normalen Zustand versetzen.Verwendung docker unpause [Optionen] CONTAINER [CONTAINER...]Optionen - -h, --help: Zeigt eine Zusammenfassung der Befehlsoptionen an.Beispiele 1. Einen Container fortsetzen: docker unpause my_container2. Mehrere Container fortsetzen: docker unpause container1 container2 container3Verwandte Befehle - docker-pause(1): Hält alle Prozesse innerhalb eines Containers an. - docker-attach(1): Hängt an einen laufenden Container an. - docker-exec(1): Führt einen Befehl in einem laufenden Container aus. - docker-ps(1): Listet Container auf. - docker-stats(1): Zeigt den Ressourcenverbrauch von Containern in Echtzeit an.Fehlerbehebung - Wenn der Container nicht existiert oder bereits läuft, gibt der Befehl eine Fehlermeldung aus. - Stellen Sie sicher, dass Sie die richtige Container-ID oder den Namen verwenden.Zusätzliche Hinweise - Der Befehl unpause wirkt sich nur auf angehaltene Container aus. Wenn ein Container bereits läuft, hat der Befehl keine Auswirkungen. - Sie können den Status eines Containers mit dem Befehl docker ps -a überprüfen, um zu sehen, ob er angehalten ist.
Docker Container Update
Docker Container Warten
Docker Content Trust
Docker Context
Docker Datacenter
Docker Desktop
Docker Device Mapper
Docker-Engine
Docker Engine – Community
Docker Engine – Enterprise
Docker Enterprise Edition
Docker GC (Garbage Collection)
Docker Graph Driver
Docker Hub
Docker Hub Automated Builds
Docker Hub Official Images
Docker Hub Organizations
Docker Hub Persönliches Zugriffstoken
Docker Hub Private Repositories
Docker Hub Rate Limits
Docker Hub Registry
Docker Hub-Repositories
Docker Hub Verified Publisher
Docker Hub Webhooks
Docker-Image-Erstellung
Docker-Image-Digest
Docker-Image-Verlauf
Docker-Image inspizieren
Docker-Image laden
Docker Image LS
Docker-Image-Metadaten
Docker-Image-Bereinigung
Docker Image Pull
Docker Image Push
Docker Image RM
Docker-Image speichern
Docker-Image-Tag
Docker Log Driver
Docker Machine
Docker Network
Docker Network Connect
Docker Network Create
Docker Network Disconnect
Docker Network Inspect
Docker Network RM
Docker-Knoten
Docker-Knoten herabstufen
Docker Node Inspect
Docker Node List
Docker-Knoten hochstufen
Docker Node.js Prozessstatus
Docker Node RM
Docker-Node-Update
Docker Notary
Docker Overlay2
Docker-Plugin
Docker Prune
Docker Registry
Docker Neustartrichtlinien
Docker-Geheimnisverwaltung
Docker-Dienst
Docker-Dienst erstellen
Docker Service Inspect
Docker-Dienst-Protokolle
Docker Service PS
Docker Service RM
Docker-Dienst-Rückrollen
Docker Service Scale
Docker Service Update
Docker-Stack
Docker-Stack-Bereitstellung
Docker Stack Down
Docker Stack LS
Docker Stack PS
Docker Stack RMVerwenden Sie den Befehl `docker stack rm`, um einen oder mehrere Stapel zu entfernen. Der Befehl muss auf einem Swarm-Manager ausgeführt werden. Wenn Sie einen Stapel entfernen, werden alle nicht von einem anderen Stapel verwendeten Dienste, Netzwerke und Volumes entfernt.```bash $ docker stack rm myapp ```Sie können auch mehrere Stapel entfernen:```bash $ docker stack rm myapp myapp2 myapp3 ```Wenn Sie einen Stapel entfernen, werden alle nicht von einem anderen Stapel verwendeten Dienste, Netzwerke und Volumes entfernt. Wenn ein Dienst von einem anderen Stapel verwendet wird, wird er nicht entfernt. Wenn ein Netzwerk oder Volume von einem Dienst eines anderen Stapels verwendet wird, wird es nicht entfernt.
Docker Stack Rollback
Docker Stack Services
Docker Stack UpIn this chapter, we will learn how to use Docker Stack to deploy and manage multi-container applications. Docker Stack is a tool that allows you to define and run multi-container applications using Docker Compose files. It provides a way to manage the lifecycle of your application, including scaling, updating, and rolling back changes.To get started with Docker Stack, you need to have Docker installed on your system. You can download and install Docker from the official Docker website. Once you have Docker installed, you can use the following command to check if it is working correctly:``` docker --version ```If Docker is installed correctly, you should see the version number of Docker displayed on the screen.Now, let's create a simple Docker Compose file to define our multi-container application. Create a new file called `docker-compose.yml` and add the following content:```yaml version: '3' services: web: image: nginx ports: - "80:80" db: image: mysql environment: MYSQL_ROOT_PASSWORD: password ```In this example, we have defined two services: `web` and `db`. The `web` service uses the `nginx` image and exposes port 80. The `db` service uses the `mysql` image and sets the `MYSQL_ROOT_PASSWORD` environment variable to `password`.To deploy this application using Docker Stack, you can use the following command:``` docker stack deploy -c docker-compose.yml myapp ```This command will create a new stack called `myapp` and deploy the services defined in the `docker-compose.yml` file. You can check the status of the stack using the following command:``` docker stack services myapp ```This command will display the status of all the services in the `myapp` stack. You can also check the logs of a specific service using the following command:``` docker service logs myapp_web ```This command will display the logs of the `web` service in the `myapp` stack.To scale a service, you can use the following command:``` docker service scale myapp_web=3 ```This command will scale the `web` service in the `myapp` stack to 3 replicas.To update a service, you can use the following command:``` docker service update --image nginx:latest myapp_web ```This command will update the `web` service in the `myapp` stack to use the latest version of the `nginx` image.To roll back a service to a previous version, you can use the following command:``` docker service rollback myapp_web ```This command will roll back the `web` service in the `myapp` stack to the previous version.In conclusion, Docker Stack is a powerful tool that allows you to define and manage multi-container applications using Docker Compose files. It provides a way to manage the lifecycle of your application, including scaling, updating, and rolling back changes. With Docker Stack, you can easily deploy and manage complex applications with ease.
Docker Stack UpdateTo update a Docker stack, you can use the `docker stack deploy` command with the updated Compose file. This command will update the running services in the stack to match the new configuration.Here's an example of how to update a stack:```bash docker stack deploy -c docker-compose.yml my_stack ```In this example, `docker-compose.yml` is the updated Compose file, and `my_stack` is the name of the stack you want to update.When you run this command, Docker will compare the current state of the stack with the new configuration in the Compose file. It will then update the running services to match the new configuration, creating new containers if necessary and removing old ones.Note that when you update a stack, Docker will perform a rolling update by default. This means that it will update the services one by one, rather than all at once. This helps to ensure that your application remains available during the update process.You can also specify additional options when updating a stack, such as the number of replicas for each service or the update order. For more information, see the Docker documentation on `docker stack deploy`.
Docker Storage Driver
Docker Swarm
Docker Swarm CA
Docker Swarm initialisieren
Docker Swarm Inspect
Docker Swarm Join
Docker Swarm Verlassen
Docker Swarm Mode
Docker Swarm UnlockIn Docker Swarm, the concept of "unlocking" refers to the process of decrypting and accessing the encrypted data stored in the swarm. This is necessary when a manager node is restarted or when a new manager node joins the swarm.When a swarm is initialized, Docker generates a unique encryption key that is used to encrypt the raft logs and other sensitive data. This key is stored in the swarm's key-value store, which is encrypted at rest. To access this data, the swarm must be "unlocked" using the encryption key.To unlock a swarm, you need to provide the encryption key that was generated during swarm initialization. This key is typically stored in a secure location and should be kept confidential. If you don't have the encryption key, you won't be able to unlock the swarm and access its data.Here's how you can unlock a swarm:1. On the manager node, run the following command to unlock the swarm:``` docker swarm unlock ```2. When prompted, enter the encryption key that was generated during swarm initialization.3. If the key is correct, the swarm will be unlocked and you will be able to access its data.It's important to note that unlocking a swarm is a one-time process. Once the swarm is unlocked, it remains unlocked until the next time the manager node is restarted or a new manager node joins the swarm.In summary, unlocking a Docker Swarm is a crucial step in accessing the encrypted data stored in the swarm. It requires the encryption key that was generated during swarm initialization and should be done with caution to ensure the security of the swarm.
Docker Swarm Entsperrschlüssel
Docker-Tag
Docker-Aufgabe
Docker Toolbox
Docker Trusted Registry
Docker Universelle Steuerungsebene
Docker Volume
Docker Volume Erstellen
Docker Volume Inspect
Docker Volume LS
Docker Volume Prune
Docker Volume RM
Docker ZFS
Dockerfile
Dockerfile –add-host
Dockerfile –allow
Dockerfile –build-arg
Dockerfile –build-context
Dockerfile –cache-alerts
Dockerfile –cache-analysis
Dockerfile –cache-analytics
Dockerfile –cache-backup
Dockerfile –cache-boundaries
Dockerfile-Cache-Konfiguration
Dockerfile –cache-deployment
Dockerfile –cache-diagnostics
Dockerfile –cache-distribution
Dockerfile –cache-downgrade
Dockerfile –cache-eviction
Dockerfile –cache-fragmentation
Dockerfile –cache-fromIn diesem Artikel werden wir uns mit dem Befehl "Dockerfile –cache-from" befassen. Dieser Befehl ist ein nützliches Werkzeug für Entwickler, die Docker-Images erstellen und optimieren möchten. Lassen Sie uns einen genaueren Blick darauf werfen.Der "Dockerfile –cache-from" Befehl ermöglicht es Ihnen, den Build-Prozess eines Docker-Images zu beschleunigen, indem er die Verwendung von Cache-Schichten ermöglicht. Wenn Sie ein Docker-Image erstellen, werden verschiedene Schichten erstellt, die die verschiedenen Schritte des Build-Prozesses darstellen. Jede Schicht enthält die Änderungen, die in diesem Schritt vorgenommen wurden.Normalerweise erstellt Docker beim Erstellen eines Images jede Schicht von Grund auf neu, auch wenn sich die vorherigen Schichten nicht geändert haben. Dies kann zu längeren Build-Zeiten führen, insbesondere wenn Sie häufig Änderungen an Ihrem Dockerfile vornehmen.Mit dem "Dockerfile –cache-from" Befehl können Sie jedoch angeben, dass Docker eine bereits vorhandene Schicht als Cache verwenden soll. Dies bedeutet, dass Docker die bereits erstellten Schichten wiederverwenden kann, anstatt sie erneut zu erstellen. Dadurch wird der Build-Prozess erheblich beschleunigt.Um den "Dockerfile –cache-from" Befehl zu verwenden, müssen Sie zuerst ein Docker-Image erstellen und es in einer Registry speichern. Anschließend können Sie beim Erstellen eines neuen Images den Befehl mit dem Namen des bereits vorhandenen Images angeben. Docker wird dann versuchen, die Schichten dieses Images als Cache zu verwenden.Es ist wichtig zu beachten, dass der "Dockerfile –cache-from" Befehl nur funktioniert, wenn die Schichten des bereits vorhandenen Images mit den Schichten des neuen Images kompatibel sind. Wenn sich die Anweisungen im Dockerfile geändert haben oder neue Anweisungen hinzugefügt wurden, kann der Cache möglicherweise nicht verwendet werden.Zusammenfassend lässt sich sagen, dass der "Dockerfile –cache-from" Befehl eine nützliche Funktion ist, um den Build-Prozess von Docker-Images zu optimieren. Durch die Verwendung von Cache-Schichten können Entwickler Zeit sparen und die Effizienz ihrer Builds verbessern. Es ist jedoch wichtig, sicherzustellen, dass die Schichten des bereits vorhandenen Images mit den Schichten des neuen Images kompatibel sind, um den Cache effektiv nutzen zu können.
Dockerfile – Cache-Treffer-Fehler
Dockerfile --cache-id
Dockerfile – Cache-Grenzen
Dockerfile –cache-location
Dockerfile –cache-logging
Dockerfile –cache-maintenance
Dockerfile-Cache-Management
Dockerfile –cache-metrics
Dockerfile – Cache-Migration
Dockerfile –cache-monitoring
Dockerfile – Cache-Einhängung
Dockerfile –cache-node
Dockerfile –Cache-Benachrichtigungen
Dockerfile – Cache-Optimierung
Dockerfile – Cache-Overhead
Dockerfile –cache-performance
Dockerfile –cache-policies
Dockerfile –cache-policy
Dockerfile –cache-replication
Dockerfile –cache-restore
Dockerfile –cache-sharding
Dockerfile –cache-storage
Dockerfile-Cache-Strategie
Dockerfile –cache-thresholds
Dockerfile – Cache-Ziel
Dockerfile –cache-triggers
Dockerfile –cache-update
Dockerfile –cache-upgrade
Dockerfile-Cache-Nutzung
Dockerfile –compress
Dockerfile –cpu-period
Dockerfile --CPU-Kontingent
Dockerfile –cpu-shares
Dockerfile –cpuset-cpus
Dockerfile –cpuset-memsDie Option `--cpuset-mems` in einem Dockerfile wird verwendet, um die Speicherknoten (Memory Nodes) festzulegen, auf denen ein Container ausgeführt werden soll. Dies ist besonders nützlich in Systemen mit Non-Uniform Memory Access (NUMA), bei denen verschiedene Prozessoren unterschiedlich schnell auf verschiedene Speicherbereiche zugreifen können.Syntax: ``` --cpuset-mems="" ```Beispiel: ``` --cpuset-mems="0,1" ```In diesem Beispiel wird der Container auf die Speicherknoten 0 und 1 beschränkt.Hinweis: Die Verwendung von `--cpuset-mems` erfordert möglicherweise erhöhte Berechtigungen und sollte mit Vorsicht verwendet werden, da sie die Leistung und das Verhalten des Containers beeinflussen kann.
Dockerfile – Umgebungsdatei
Dockerfile –export-cache
Dockerfile –export-cache-key
Dockerfile –exported-artifacts
Dockerfile –force-rm
Dockerfile –from
Dockerfile –iidfile
Dockerfile –import-cache
Dockerfile –import-cache-key
Dockerfile –labelMit dem LABEL-Befehl können Sie Metadaten in Form von Schlüssel-Wert-Paaren zu einem Image hinzufügen. Ein Beispiel für die Verwendung des LABEL-Befehls ist:LABEL version="1.0" LABEL description="A sample Dockerfile" LABEL maintainer="John Doe "Sie können auch mehrere Schlüssel-Wert-Paare in einem LABEL-Befehl angeben, indem Sie sie durch Leerzeichen trennen:LABEL version="1.0" description="A sample Dockerfile" maintainer="John Doe "Die Metadaten, die mit dem LABEL-Befehl hinzugefügt werden, können später mit dem docker inspect-Befehl angezeigt werden.
Dockerfile –label-file
Dockerfile –memory
Dockerfile –metadata
Dockerfile –metadata-file
Dockerfile –networkIn Docker können Sie mit dem Schlüsselwort `–network` das Netzwerk angeben, das beim Erstellen eines Containers verwendet werden soll. Dies ermöglicht es Ihnen, den Container mit einem bestimmten Netzwerk zu verbinden und die Kommunikation mit anderen Containern oder externen Netzwerken zu steuern.Hier ist ein Beispiel für die Verwendung von `–network` in einer Dockerfile:```dockerfile FROM ubuntu:latest# Installiere notwendige Pakete RUN apt-get update && apt-get install -y \ curl \ wget# Setze das Netzwerk für den Container ENV NETWORK mynetwork# Starte den Container mit dem angegebenen Netzwerk CMD ["–network", "$NETWORK"] ```In diesem Beispiel wird ein Ubuntu-Container erstellt und das Netzwerk `mynetwork` wird als Umgebungsvariable gesetzt. Beim Starten des Containers wird das Netzwerk `mynetwork` verwendet.Sie können auch mehrere Netzwerke angeben, indem Sie sie durch Kommas trennen:```dockerfile FROM ubuntu:latest# Installiere notwendige Pakete RUN apt-get update && apt-get install -y \ curl \ wget# Setze die Netzwerke für den Container ENV NETWORKS mynetwork1,mynetwork2# Starte den Container mit den angegebenen Netzwerken CMD ["–network", "$NETWORKS"] ```In diesem Fall wird der Container mit den Netzwerken `mynetwork1` und `mynetwork2` verbunden.Es ist wichtig zu beachten, dass das angegebene Netzwerk bereits existieren muss, bevor Sie den Container erstellen. Sie können Netzwerke mit dem Befehl `docker network create` erstellen.Ich hoffe, das hilft Ihnen weiter!
Dockerfile –ohne Cache
Dockerfile –no-cache-id
Dockerfile –output
Dockerfile –platform
Dockerfile – Fortschritt
Dockerfile – Herkunftsnachweis
Dockerfile –Provenienzdatei
Dockerfile –pullIn Dockerfiles können Sie das Schlüsselwort `pull` verwenden, um ein bestimmtes Image aus einem Registry zu ziehen. Dies ist nützlich, wenn Sie ein bestimmtes Image verwenden möchten, das nicht im lokalen Cache vorhanden ist. Hier ist ein Beispiel:```dockerfile FROM ubuntu:latest RUN apt-get update && apt-get install -y \ python3 \ python3-pip ```In diesem Beispiel wird das neueste Ubuntu-Image aus dem Docker Hub gezogen und als Basis für das Dockerfile verwendet. Anschließend werden Python 3 und pip installiert.Sie können auch ein bestimmtes Tag eines Images angeben, indem Sie den Tag-Namen nach dem Image-Namen angeben:```dockerfile FROM ubuntu:18.04 RUN apt-get update && apt-get install -y \ python3 \ python3-pip ```In diesem Beispiel wird das Ubuntu-Image mit dem Tag `18.04` gezogen.Wenn Sie ein Image aus einem privaten Registry ziehen möchten, müssen Sie sich zuerst bei diesem Registry authentifizieren. Dies können Sie tun, indem Sie den Befehl `docker login` verwenden:```bash docker login registry.example.com ```Anschließend können Sie das Image aus dem privaten Registry ziehen, indem Sie den Registry-Namen vor dem Image-Namen angeben:```dockerfile FROM registry.example.com/my-image:latest RUN apt-get update && apt-get install -y \ python3 \ python3-pip ```In diesem Beispiel wird das Image `my-image` mit dem Tag `latest` aus dem privaten Registry `registry.example.com` gezogen.
Dockerfile –quiet
Dockerfile –rm
Dockerfile –rootfs
Dockerfile –secret
Dockerfile –security-optIn einer Dockerfile können Sie die Option `--security-opt` verwenden, um Sicherheitseinstellungen für den Container festzulegen. Diese Option ermöglicht es Ihnen, verschiedene Sicherheitsparameter zu konfigurieren, die das Verhalten des Containers beeinflussen.Hier sind einige Beispiele für die Verwendung von `--security-opt` in einer Dockerfile:1. **Seccomp-Profil festlegen:** ```dockerfile FROM ubuntu:latest RUN echo "Seccomp-Profil wird festgelegt" SECURITY OPT seccomp=unconfined ```2. **AppArmor-Profil festlegen:** ```dockerfile FROM ubuntu:latest RUN echo "AppArmor-Profil wird festgelegt" SECURITY OPT apparmor=docker-default ```3. **Capabilities einschränken:** ```dockerfile FROM ubuntu:latest RUN echo "Capabilities werden eingeschränkt" SECURITY OPT no-new-privileges:true ```4. **Read-Only Root Filesystem:** ```dockerfile FROM ubuntu:latest RUN echo "Read-Only Root Filesystem wird aktiviert" SECURITY OPT ro-rootfs:true ```5. **Seccomp und AppArmor kombinieren:** ```dockerfile FROM ubuntu:latest RUN echo "Seccomp und AppArmor werden kombiniert" SECURITY OPT seccomp=unconfined SECURITY OPT apparmor=docker-default ```Diese Beispiele zeigen, wie Sie die `--security-opt` Option in einer Dockerfile verwenden können, um die Sicherheitseinstellungen für Ihren Container zu konfigurieren. Beachten Sie, dass die genauen Optionen und deren Syntax je nach Docker-Version und Betriebssystem variieren können.
Dockerfile –shm-size
Dockerfile –squash
Dockerfile –ssh
Dockerfile –tag
Dockerfile – Ziel
Dockerfile –timestamp
Dockerfile – zu
Dockerfile –ulimit
Dockerfile ADD
Dockerfile-Argument
Dockerfile Befehl
Dockerfile KOMMENTAR
Dockerfile COPY
Dockerfile ENTRYPOINT
Dockerfile ENV
Dockerfile EXPOSE
Dockerfile FROMDas `FROM` Anweisung initialisiert einen neuen Build-Stage und legt das Basis-Image für nachfolgende Anweisungen fest. Ein gültiger Dockerfile beginnt mit einer `FROM` Anweisung. Das Image kann jeder gültige Image sein – es ist besonders einfach, ein offizielles Image als Basis zu verwenden.Das `FROM` kann mehrmals in ein und demselben Dockerfile vorkommen, um mehrere Images zu erstellen oder als Abhängigkeit für eine Stage zu verwenden. Einfach den Namen des erstellten Images notieren, das durch die Anweisung `docker build --target ` erstellt wurde.Optional kann das Argument `AS name` direkt nach `FROM` angegeben werden. Der Name kann in nachfolgenden `FROM` und `COPY --from=` Anweisungen verwendet werden, um das Quell-Image des Namens zu referenzieren, einschließlich der auf dieses Image aufbauenden Stages.`FROM` unterstützt Optionen, die die Art des gepufferten Images beeinflussen.`ARG` ist die einzige Anweisung, die vor `FROM` im Dockerfile stehen kann. Siehe unten für `FROM` Anweisungen, die `ARG` Variablen verwenden.FROM [--platform=] [AS ]oderFROM [--platform=] [:] [AS ]oderFROM [--platform=] [@] [AS ]--platform optional auf Plattformen wie Docker for Mac/Windows, um die Plattform des Quell-Images anzugeben, z. B. linux/amd64, linux/arm64 oder windows/amd64. Standardmäßig wird die aktuelle Build-Plattform verwendet. Weitere Informationen finden Sie unter Multiplattform-Tags.Das Tag oder Digest-Werte sind optional. Wenn Sie nichts angeben, wird standardmäßig das Tag `latest` verwendet. Wenn das gewählte Tag nicht im Repository vorhanden ist, gibt der Client einen Fehler zurück.FROM kann mit der Option `--platform` verwendet werden, um die Plattform des Quell-Images anzugeben. Das bedeutet, dass das folgende Beispiel das `node:12-alpine` Image für die Plattform `linux/amd64` verwendet, unabhängig davon, welche Plattform für den Build verwendet wird:FROM --platform=linux/amd64 node:12-alpineARG und FROM`ARG` ist die einzige Anweisung, die vor `FROM` im Dockerfile stehen kann. Das `FROM` Anweisung unterstützt Variablen, die mit `ARG` deklariert wurden – die einzige Anweisung, die vor `FROM` stehen kann.FROM busybox ARG vers FROM ubuntu:$vers RUN echo $versJede `ARG` Anweisung hat einen Build-Phase-Bereich und ist nach dem `FROM` im Build nicht verfügbar. Verwenden Sie eine `ARG` Anweisung und `ARG` Anweisungen ohne ein Wert, um ein Standard zu verwenden, bevor Sie die erste `FROM` verwenden. Ein Beispiel:ARG VERSION=latest FROM busybox:$VERSION ARG VERSION RUN echo $VERSION > image_versionDas vorherige Beispiel gibt die Anweisung, die Standardversion auf `latest` zu setzen, erlaubt aber die Möglichkeit, die Version durch den Befehl `docker build --build-arg VERSION=1.2.3` zu überschreiben.
Dockerfile HEALTHCHECK
Dockerfile LABEL
Dockerfile MAINTAINER
Dockerfile MULTI-STAGE
Dockerfile ONBUILD
Dockerfile AUSFÜHREN
Dockerfile SHELL
Dockerfile STOPSIGNAL
Dockerfile SYNTAX
Dockerfile TARGET
Benutzer
Dockerfile VOLUME
Arbeitsverzeichnis

Entrypoint
UMGEBUNG
EXPOSE

Gesundheitscheck
HEALTHCHECK
Host-Netzwerk
Host-Netzwerk-Treiber

Bild
Ebenen
IPAM (IP-Adressen-Management)

Kubernetes

ETIKETT
Lastenausgleich

MacVLAN-Netzwerktreiber
Manager-Knoten
Multi-Stage Build

Netzwerk
Node
Kein Netzwerktreiber

Orchestrierung
Overlay-Netzwerk
Overlay Network-Treiber

Hafen
Privates Register

Registry
Repository
RUN

Skalierung
Geheimnis
Dienstleistung
Stack

Aufgabe

Lautstärke

Arbeitsverzeichnis
Worker-Knoten

YAML

Glossar

Schnelllinks

Kategorien