Hallo, Gast
Du musst dich registrieren bevor du auf unserer Seite Beiträge schreiben kannst.

Benutzername
  

Passwort
  





Durchsuche Foren

(Erweiterte Suche)

Foren-Statistiken
» Mitglieder: 1
» Neuestes Mitglied: Joopi
» Foren-Themen: 533
» Foren-Beiträge: 766

Komplettstatistiken

Benutzer Online
Momentan sind 15 Benutzer online
» 0 Mitglieder
» 9 Gäste
AhrefsBot, Bing, Bytespider, Crawl, DotBot, bot

Aktive Themen
Sunday - 14:00 CDT: Light...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
Vor 11 Stunden
» Antworten: 0
» Ansichten: 1
Sunday - 09:00 CDT: Mist,...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
Gestern, 05:30
» Antworten: 0
» Ansichten: 3
Saturday - 18:00 CDT: Lig...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
Gestern, 03:27
» Antworten: 0
» Ansichten: 14
Saturday - 08:00 CDT: Not...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
25-10-2025, 05:22
» Antworten: 0
» Ansichten: 14
Friday - 20:00 CDT: Not a...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
25-10-2025, 05:02
» Antworten: 0
» Ansichten: 13
Friday - 12:00 CDT: Not a...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
24-10-2025, 08:42
» Antworten: 0
» Ansichten: 15
Thursday - 23:00 CDT: Not...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
24-10-2025, 07:30
» Antworten: 0
» Ansichten: 26
Thursday - 13:00 CDT: Not...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
23-10-2025, 09:32
» Antworten: 0
» Ansichten: 22
Thursday - 06:00 CDT: Not...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
23-10-2025, 02:09
» Antworten: 0
» Ansichten: 29
Wednesday - 16:00 CDT: No...
Forum: Wetter in Little Rock
Letzter Beitrag: Joopi
23-10-2025, 01:24
» Antworten: 0
» Ansichten: 27

 
  Saturday - 14:00 CST: Not available, 17°C (63°F)
Geschrieben von: Joopi - 23-11-2024, 11:43 - Forum: Wetter in Little Rock - Keine Antworten

Saturday - 14:00 CST: Not available, 17°C (63°F)

Temperature: 17°C (63°F), Wind Direction: Northerly, Wind Speed: 0mph, Humidity: 36%, Pressure: 1019mb, Falling, Visibility: Good


https://www.bbc.co.uk/weather/

Drucke diesen Beitrag

  Saturday - 13:00 CST: Not available, 16°C (61°F)
Geschrieben von: Joopi - 23-11-2024, 10:38 - Forum: Wetter in Little Rock - Keine Antworten

Saturday - 13:00 CST: Not available, 16°C (61°F)

Temperature: 16°C (61°F), Wind Direction: Northerly, Wind Speed: 0mph, Humidity: 39%, Pressure: 1020mb, Falling, Visibility: Good


https://www.bbc.co.uk/weather/

Drucke diesen Beitrag

  Docker neues handling 20221105
Geschrieben von: Joopi - 23-11-2024, 09:57 - Forum: Docker - Keine Antworten

Neue Erkenntnisse

Heute, am 05.11.2022, habe ich mich wieder intensiver mit Docker und dessen Möglichkeiten für mich befasst.

Im Moment möchte ich hier nur einige Befehl hineinkopieren, die wichtig sind.

In dem Docker-Projektordner kann der Container so gestartet werden, dass man ein Volume erstellt, welche Daten vom Host im Container zur Verfügung stellt.
Es können naütrlich auch Ordner als Volumes zur Verfügung gestellt werden, die außerhalb des Projektordners liegen. Dann muss er eingebunden werden wie im zweiten Befehl.

Code:
docker run -it --name ubuntu -v "$(pwd):/home" ubuntu:22.04 bash

oder

Code:
docker run -it --name ubuntu -v "/media/django/webserver/dockerdaten/ubuntu2204:/home" ubuntu:22.04 bash

Ein Container, der nur einen Service zur Verfügung stellt, wie z.B. ein Webserver, sollte detached gestartet werden. Dadurch wird die Konsole wieder frei und wird nicht durch den laufenden Container blockiert. Der Webserver muss ja nur im Hintergrund laufen.

Hinweis:

Ein Container sollte nur immer einen Prozess abbilden. Wird ein CMS und eine MySQL-Datenbank benötigt, sind zwei Container erforderlich.
Diese Container können dann über eine Datei mit dem Namen docker-compose.yaml zusammengeführt werden. Die Startreihenfolge wird durch die Abhängigkeit des einen Prozess vom anderen Prozess bestimmt. Aber es laufen zwei Container!

Wenn ich in einen laufenden Container einsteigen möchte, der im detached-Modus läuft, so muss sich folgenden Befehl absetzen:

Code:
docker attach <container>

demnach

Code:
docker attach 80da9e62d78e

Temporärer Befehl

Code:
docker run -it --name meinubuntu --network meinnetwork -v meinvolume:/home ubuntu:22.04 bash

Update am 07.11.2022

Heute habe ich verstanden, dass gestoppte Container nicht nutzlos sind, sondern über

Code:
docker start --attach container-id

wieder genutzt werden können.

Man soll zwar in Containern nicht produktiv arbeiten, aber bei entsprechender Vorsicht können in den Containern Arbeitsstände *dauerhaft* zur Verfügung gestellt werden.

Das sind 15 Dockerbefehle, die man im Alltag gebrauchen kann

Docker-Befehle

Optionen

Beim run-Befehl wird die Option -it angegeben. Diese Option steht für:
  • -i = interaktiver Modus
  • -t = Shell als Standardinput-Gerät

Wenn beim run-Befehl die Option -d angegebenn wird, so wird der Container als *dameon* gestartet und kann grundsätzlich nicht zu sehen. Will man in einem Hintergrundcontainer etwas tun, so muss mit
  • docker exec (docker exec –it {container} {command})
  • docker attach (docker attach {container})

in den Container verzweigt werden.

Drucke diesen Beitrag

  Docker handling compose
Geschrieben von: Joopi - 23-11-2024, 09:55 - Forum: Docker - Keine Antworten

Infos zum Handling von Docker-Compose

Wenn das Docker-Compose-File genutzt wird, entfallen einige Aktionen auf der Konsole. Das Stoppen und Löschen von Containern ist nicht notwendig.

Zum Schluss bleibt im Grunde genommen nur das Image übrig, welches beim neuerlichen Start von Docker-Compose wieder genutzt wird.

Damit Docker-Compose (separat zu installieren) arbeiten kann, muss im Dockerdatenordner diese Datei liegen (andere Dateinamen sind nicht möglich):

Zitat:docker-compose.yaml

Der Start erfolgt so als detached Ausführung:

Code:
docker-compose up -d

oder

Code:
docker-compse -f dateiname.yaml up -d

Das Stoppen erfolgt so:

Code:
docker-compose stop

Das Herunterfahren erfolgt so:

Code:
docker-compose down

Sobald Docker-Compose heruntergefahren ist, werden die Container und Netzwerkverbindungen scheinbar beendet und gelöscht.

Das ist der Ablauf in der Konsole, um meine vorherige Behauptung zu untermauern:

Code:
user@user:/media/django/webserver/dockerdaten$ sudo docker-compose down
Removing dockerdaten_meinghost_1 ... done
Removing network dockerdaten_default
user@user:/media/django/webserver/dockerdaten$ sudo docker ps -a
CONTAINER ID  IMAGE    COMMAND  CREATED  STATUS    PORTS    NAMES
user@user:/media/django/webserver/dockerdaten$ sudo docker container ls -a
CONTAINER ID  IMAGE    COMMAND  CREATED  STATUS    PORTS    NAMES
user@user:/media/django/webserver/dockerdaten$ sudo docker image ls
REPOSITORY  TAG      IMAGE ID      CREATED        SIZE
ghost        4        b05a58075ef6  19 hours ago  448MB

Drucke diesen Beitrag

  Docker images Nutzung
Geschrieben von: Joopi - 23-11-2024, 09:54 - Forum: Docker - Keine Antworten

Hinweise zur Nutzung von Docker Images

CouchBase

CouchBase auf Docker Hub

Step - 1: Run Couchbase Server docker container

Code:
docker run -d --name db -p 8091-8094:8091-8094 -p 11210:11210 couchbase

Step - 2: Next, visit http://localhost:8091 on the host machine to see the Web Console to start Couchbase Server setup.


CouchDB

CouchDB auf Docker Hub

Code:
user@user:~$ sudo docker run -d --name my-couchdb couchdb:latest
ead0a152cfefc65ef3921534134b94d7a72cdea59dd876e231f10b5e6ac16de9


MongoDB

MongoDB auf Docker Hub

Code:
sudo docker run --name mymongo -d mongo:5.0.2-focal
eb6ed078e31adca5550c4a242033aa147c29c4bcd7c0b70e8a46cd1b6b919d25

Die für MongoDB gültigen TAG sind hier:

Supported tags and respective Dockerfile links


Ghost

Ghost - free blogging plattform

Code:
sudo docker run -d --name myghost ghost
06b77297a1e2fb0871aef98139127ea559e74c764d971e7ac00033a50129ddfe

Will man Zugang im Browser haben, dann ist folgender Befehl erforderlich:

Code:
sudo docker run -d --name some-ghost -e url=http://localhost:3001 -p 3001:2368 ghost

Im Browser ist dann das einzugeben: http://localhost:3001

und für den Adminzugang ist das einzugeben: http://localhost:3001/ghost

Container löschen und neu erstellen

Sobald der Container beendet ist, kann er gelöscht werden, da man nur mit einem neuen run-Befehl den Container später über den gewünschten Port im Browser ansprechen kann. Daher ist es wichtig, dass Anwenderdaten nicht im Container, sondern in einem Volumen gespeichert werden.

Das ist der Ablauf, um einen laufenden Container zu beenden und dann wieder später nutzbar zu machen:

Code:
user@user:~$ sudo docker stop meinghost
[sudo] Passwort für django:
meinghost
user@user:~$ sudo docker container rm meinghost
meinghost
user@user:~$ sudo docker run -d --name meinghost -e url=http://localhost:3001 -p 3001:2368 -v /media/django/webserver/dockerdaten/ghost:/var/lib/ghost/content ghost
7cb325446ab4ab7476dfe274b3a90dc5dca7ee281f4b3d66ed3583f6e56b3171

Im Standard nutzt Ghost SQLite als Datenbank. Die Einbindung von MySQL ist aber auch möglich und auf der Ghost-Dockerseite beschrieben.


Golang

golang Official Image Go (golang) is a general purpose, higher-level, imperative programming language.

Es ist wohl ein DockerFile notwendig, um dieses Image im Container laufen lassen zu können.

Drucke diesen Beitrag

  Docker img installieren
Geschrieben von: Joopi - 23-11-2024, 09:53 - Forum: Docker - Keine Antworten

Sammlung von Docker IMG

Die Docker-Grundlagen

Docker Grundlagen
Wie funktionieren Docker Container?

Achtung:
Docker IMG haben nur Leserechte.

Will man mit Docker arbeiten und Daten verändern, müssen die Container ran. Darin kann man arbeiten.

Ein Container entsteht immer aus einem Image. Es beinhaltet alle Komponenten, um eine Anwendung plattformunabhängig auszuführen.


Eine Bash ausführen in einem Container:

Code:
sudo docker run -it ubuntu bash

Drucke diesen Beitrag

  Docker Eigene Daten
Geschrieben von: Joopi - 23-11-2024, 09:52 - Forum: Docker - Keine Antworten

Eigene Daten in Docker-Container erstellen und speichern

Ich habe versucht herauszufinden, ob man Daten in einem Docker-Container erstellen und speichen kann. Und ob diese Daten später noch vorhanden sind, wenn der Container gestoppt (nicht gelöscht) wurde.

Dazu habe ich mir ein Ubuntu als Betriebssystem heruntergeladen und via apt-get ein Upate und ein Upgrade gemacht. Das war notwendig, um danach den Editor nano zu installieren.

Zwar hatte ich eine Datei im Home-Verzeichnis via touch erstellt, jedoch hatte ich keinen Zugriff auf einen Editor. Komisch eigentlich.

Mit nano konnte ich die erstellte Datei dann ganz normal bearbeiten und speichern.

Dann habe ich dne Container mit exit verlassen und mit stop den Container gestoppt.

Und dann habe ich mit start den Container wieder gestartet und mich mit exec wieder in den Container eingeloggt.

Die vorher erstellte Datei und der Inhalt waren vorhanden. Somit kann man die Container durchaus produktiv nutzen. Es muss aber Möglichkeiten geben, wie man eine Sicherung der Daten außerhalb des Containers anlegen kann. Ich meine dieses im Heise-Tutorial gesehen zu haben.


Mit Docker habe ich nun den ganzen Abend probiert und habe mit CouchBase eine NoSQL-Datenbank im Container laufen. Das ist nicht schlecht. Leider kann ich MongoDB nicht starten, da ich mit dem TAG nicht klarkomme. Das muss ich morgen mal ausprobieren.

Drucke diesen Beitrag

  Docker Infos Heise-Tutorial
Geschrieben von: Joopi - 23-11-2024, 09:50 - Forum: Docker - Keine Antworten

Infos aus dem 6-teiligen Heise-Tutorial

Erstellung eines Volums.

Volums sind dafür da, um eigene Daten aufzunehmen. Damit diese nicht direkt in einen Container erfasst werden, legt man unter /usr/share zum jeweiligen Programm, z.B. nginx, ein Volume an.

Die Syntax wäre in diesem Beispiel wie folgt:

Code:
sudo docker run --name my-nginx -v /some/content:/usr/share/nginx/html:ro -d nginx

some-nginx = Name des Containers
-v = ein Volume anhängen und deklarieren
-d = Dienst läuft im Hintergrund
nginx = Image
ro = read only

Hinweis:
In einem Dockercontainer sind nur die wichtigsten Pakete enthalten. Will man eine Textdatei erstellen, aber ein Editor ist nicht verfügbar, kann man pragmatisch folgendes machen:

Code:
echo "Hallo Docker!" > index.html

Damit erstellt man eine Datei, die dann verwendet werden kann. Will man künftig mehr in dem Container machen, empfiehlt es sich, einen Editor zu installieren (und daraus dann ein eigenes Build zu machen). Das wird so aber nicht empfohlen (?). Insgesamt ist das der denkbar schlechteste Weg.

Fazit:
Mit docker exec in einen Container zu gehen und dort Daten zu bearbeiten ist nicht gut und sollte so nicht gemacht werden.

Die Anwendungsdaten werden im Container nicht gespeichert. Sobald der Container beendet wird, sind die Daten weg. Daher müssen Volumes angelegt werden, die die Anwendungsdaten speichern udn vorhalten.

Um ein Volume zu erzeugen, ist folgender Befehl notwendig:

Code:
sudo docker volume create

Dieser Befehl erzeugt einen langen Name aus Zufallszahlen/-ziffern. Man kann den Volumennamen auch vorgeben:

Code:
sudo docker volume create html

Mit dem ls-Befehl kann ich mir die vorhandenen Volumes anzeigen lassen:

Code:
sudo docker volume ls

Das läuft analog zu den Images und den Containern.

Um nun das erzeugte Volume mit dem Namen html in den nginx-Container zu bringen, wird eine zweite Instanz aufgemacht und ein weiterer Port eröffnet (nicht zwingend erforderlich, nur zur Demonstration):

Code:
sudo docker run --name myvol-nginx -p 8081:80 -v html:/usr/share/nginx/html:ro -d nginx

ro heißt readonly.

Das erzeugte Volume liegt hier:

Zitat:/var/lib/docker/volumes

Dieses Verzeichnis kann ein Normaluser, selbst wenn er in der Gruppe docker ist, nicht sehen (sudo -s)

WICHTIG:
Selbst wenn der Container zerstört wird, bleibt das Volume erhalten. Wichtig ist dann dabei, dass das Verzeichnis /usr/lib/docker gesichert wird, wenn in diesem Verzeichnis Nutzer- und  Anwendungsdaten für die weitere Verarbeitung gespeichert werden, also produktiv genutzt werden.

Die Volumes müssen nicht unbedingt im Docker-Verzeichnis liegen, sondern können an jeder beliebigen Stelle gespeichert werden. Dazu wäre dann z.B. dem Volume HTML das Verzeichnis voranzustellen (Beispiel): /home/django/dockervolume/HTML

Die Prozesse, die innerhalb der Container laufen, müssen allerdings die Berechtigungen auf dieses Verzeichnis haben.


Docker und Netzwerke

Docker erzeugt ein eigenes Netzwerk: docker0

Code:
ifconfig docker0

Docker hat verschiedene Netzwerke, die man sich so anzeigen lassen kann:

Code:
docker network ls

Beispiel, wie zwei Container kommunizieren.

Ein Blogsystem auf Basis WordPress-Blogsystem
  • Container mit Webserver und WordPress
  • Container mit Datenbank MySQL / MariaDB

Container für Datenbank:

Code:
docker run --name test-mysql -e MYSQL_ROOT_PASSWWORD=meinpasswort -e MYSQL_DATABASE=wordpress -e MYSQL_USER=wp -e MYSQL_PASSWORD=meinpasswort -d mysql:5.7

Container für WordPress / Webserver

Code:
docker run --name wordpress --link test-mysql:test-mysql -p 8082:80 -d wordpress

Hinweis:

Zitat:--link anstelle von --name

Dieser Part "test-mysql:test-mysql" bedeutet, dass der Container test-mysql auch als test-mysql angesprochen werden. Soll dieser Name dann anders lauten, müsste er angegeben werden (z.B. test-mysql:test-worpress).

Hinweis:
Docker hat einen eigenen DNS-Server laufen.

Für das obige Beispiel würde im Browser, da wir mit WordPress arbeiten wollen, folgendes einzugebenn sein:

Zitat:localhost:8082

Sodann würde die Installation von WordPress erfolgen.

Die Daten von WordPress werden in der Datenbank abgespeichert. WordPress und die Datenbank sind in zwei Containern aufgeteilt. Um mit den eingegebenen Daten weiter arbeiten zu können, müssten die Daten in ein Volume übertragen werden

Wie das geht, weiß ich noch nicht!

Wenn z.B.  WordPress vom Rest der Welt trennen möchte, dann kann das über ein eigenes Docker-Netzwerk erfolgen. Das sieht dann so aus:

Code:
docker network create --driver bridge test-bridge

Prüfen, ob das Netzwerk angelegt ist bzw. welche vorhanden sind, kann man mit:

Code:
docker network ls

Dieses neue Network kann man an den Run-Befehl für mysql hängen:

Code:
docker run --name test-mysql --network=test-bridge -e MYSQL_ROOT_PASSWWORD=meinpasswort -e MYSQL_DATABASE=wordpress -e MYSQL_USER=wp -e MYSQL_PASSWORD=meinpasswort -d mysql:5.7

Hinweis:

Es gibt den inspect-Befehl. Dieser kann auf das Netzwerk angewandt werden. Um das neue Netzwerk zu inspizieren, ist folgendes notwendig:

Code:
docker network inspect test-bridge

Man kann also in das Netzwerk "hineinschauen".


Wie kann man Docker vereinfachen?

Contaner mit Compose einrichten

Mehrere Container nebeneinander betreiben.

Docker-Compose ist ein Python-Script (offizell von Docke unterstützt), mit dem vereinfacht mehrere Container aufgebaut und miteinander verbunden werden können.

Ein Compose-File ist wie folgt strukturiert (Beispiel MySQL-Container)

Zitat:version: '3'

services:
    db:
        image: mysql:5.7
        volumes:
            - ./data/db/:/var/lib/mysql
        restart: always
        ports:
            - "3306:3306"
        environment:
            MYSQ_ROOT_PASSWORD: secret123root

Die Inhalte sind quasi die gleichen wie in einem run-Befehl.

Die Aussage ist, dass selbst, wenn nur ein Container laufen soll, eine Compose-File nützlich ist.

Der data-Ordner des Volume liegt in dem Ordner, aus dem das Compose-File aufgerufen wird. Der Punkt weist auf die relative Lage hin. Hat mein einen eigenen Bereich auf der lokalen Festplatte eingerichtet, ruft man das File eben von dort aus auf.

Für das Beispiel aus dem Netzwerkabschnitt (WordPress und MySQL) sieht das Compose-File wie folgt aus:

Zitat:version: '3'

services:
    db:
        image: mysql:5.7
        volumes:
            - ./data/db/:/var/lib/mysql
        restart: always
        ports:
            - "3306:3306"
        environment:
            MYSQL_ROOT_PASSWORD: secret123root
            MYSQL_DATABASE: wordpress
            MYSQL_USER: wordpress
            MYSQL_PASSWORD: 12345wordpress54321
           
    wordpress:
        depends_on:
            - db
        image: wordpress:latest
        ports:
            - "80:80"
        restart: always
        environment:
            WORDPRESS_DB_HOST: db:3306
            WORDPRESS_DB_USER: wordpress
            WORDPRESS_DB_PASSWORD: 12345wordpress54321
        working_dir: /var/www/html
        volumes:
            - ./data/wordpress:/var/www/html/wp-content
       
        portainer:
            image: portainer/portainer
            restart: always
            ports:
                mehr sehe ich nicht, scheint ein volume zu sein, ist wohl eine grafische Oberfläche gedacht, also nicht in der Konsole wichtig.

So wird die yml-Datei, in der das Compose-File abgespeichert wurde, ausgeführt:

Code:
docker-compose up
  • up = starten
  • stop = stoppen
  • down = herunterfahren (Container werden dabei sofort gelöscht)

Damit wird wohl alles an Compose-Files gestartet.

Die Ausführung dieses Befehl ist sichtbar, da die Option -d nicht mit angegeben worden ist.

Ansonsten könnte man bei der Sichtbarkeit die einzelnen Aktionen sehen, die ausgeführt würde. Es gibt dann wohl, sobald der Datanbankserver oben ist mit der Installation von Wordpress im Browser.

Hinweis:
In einer yml-Datei ist die Einrückungstiefe immer 2 Leerzeichen. Man kann auch Tabs verwenden, aber zwei Leerzeichen sind wohl Standard.

Um z.B. auf der Shell in die Container mit dem exec-Befehl einzusteigen, kann folgender Befehl genutzt werden:

Code:
docker-compose excec db sh

Damit ist man im Container anstelle des komplexen Befehlaufrufes aus den Anfängen.


Die grafische Oberfläche für Docker

Portainer ist eine bekannte grafische Oberfläche

Sofern im Compose-File der Portainer integriert ist, kann man in der Adressezeile des Browsers über den Port 9000 die Webseite erreichen.

Zitat:localhost:9000

Ich unterstelle derweil, dass das möglich ist, denn in dem Beispiel bei Heise wird mittlerweile eine echte Domain genutzt. Sollte aber auch mit localhost funktionieren.


Zertifikate erstellen

Die Anwendungen, die man in Docker erstellt, kann man sind Internet bringen. Man muss dafür aber vieles beachten, um die Sicherheit zu gewährleisten. Mit Zertifikaten kann man das erreichen.

Eine Grundlage ist z.B. Watchtower (wird niht mehr entwickelt, es gibt was neues) und gehört zu vorherigen Compose-File.

Watchtower ein Image, welches sich um die Aktualisierung von Images kümmert, was durch Docker selber nicht geleistet wird.

Code:
watchtower:
  image: v2tec/watchtower
  volumes:
    - /var/run/docker.sock:/var/run/docker.sock
  command: --interval 30

Um von außen auf die Anwendung schauen zu können, wird folgendes benötigt (Revers-Server/Proxy oder so ähnlich)

Für das nachfolgende Beispiel muss der WordPress-Container angepasst werden, da diese keine Ports mehr freigeben darf (wird weiter unten mit 80 und 443 gemacht):

Code:
wordpress:
        depends_on:
            - db
        image: wordpress:php7.1
        restart: always
        environment:
            WORDPRESS_DB_HOST: db:3306
            WORDPRESS_DB_USER: wordpress
            WORDPRESS_DB_PASSWORD: 12345wordpress54321
            LETSENCRYPT_HOST: mlsjam.leipsieb.de
            LETSENCRYPT_EMAIL: mls@ct.de
            VIRTUAL_HOST: mlsjam.leipsieb.de
            VIRTUAL_PORT: 80
        working_dir: /var/www/html
        volumes:
            - ./data/wordpress:/var/www/html/wp-content

Ob das auch auf localhost läuft, weiß ich derzeit nicht.

Code:
nginxproxy:
  image: jweilder/nginx-proxy
  restart: unless-stopped
  volumes:
    - ./data/certs:/etc/nginx/certs
    - ./conf:/etc/nginx/conf.d
    - ./dhparam:/etc/nginx/dhparam
    - ./data/vhosts:/etc/nginx/vhost.d
    - ./data/html:/usr/share/nginx.html
    - /var/run/docker.sock:/tmp/docker.sock
  ports:
    - 80:80
    - 443:443
  labels:
    - "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy"
   
nginxproxy_comp:
  image: jrcs/letsencrypt_nginx_proxy_companion
  restart: unless_stopped
  depends_on:
    - nginxproxy
  volumes:
    - ./data/certs:/etc/bginx/certs:rw
    - ./conf:/etc/nginx/conf.d
    - ./dhparam:/etc/nginx/dhparam
    - ./data/vhosts:/etc/nginx/vhost.d
    - ./data/html:/usr/share/nginx.html
    - /var/run/docker.sock:/tmp/docker.sock:ro


In meinen Tests hatte ich mehrere Male die Probleme, dass die Ports z.B. 8080 oder 8081 als belegt gekennzeichnet wurden.

Um herauszufinden, welche Anwendungen die Ports belegen, natürlich können das auch laufende Container sein, ist folgender Befehl hilfereich:

Code:
sudo lsof -i -P -n | grep 8080

Das Ergebnis sieht so aus:

   

Somit ist für mich klar, dass ich den Port 8081 nehme.

Wie ich mit den Ports überhaupt umgehen muss, weiß ich selber noch nicht, wenn es sich um Webanwendungen handelt.

Drucke diesen Beitrag

  Docker installieren
Geschrieben von: Joopi - 23-11-2024, 09:49 - Forum: Docker - Keine Antworten

Docker über Repository installieren für Focal

Auf dieser Webseite habe ich die Installationsanleitung für Docker aus den Repositories für Ubuntu Focal gefunden:

Docker installation on Ubuntu Install via repository

Und hier kommt die Anleitung als Kopie der Webseite.


Docker installation on Ubuntu

Install via repository

Docker installation process on Ubuntu is practically the same as on Debian.

1. Update the distro and install necessary packages:

Code:
$ sudo apt update
$ sudo apt install apt-transport-https ca-certificates curl gnupg-agent software-properties-common

2. Second step is to add Docker GPG key for Docker

Code:
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

3. Verify the key fingerprint:

Code:
$ sudo apt-key fingerprint 0EBFCD88

4. Add the repository:

Code:
$ sudo add-apt-repository  "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

5. Install Docker:

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

6. Start and enable the Docker:

Code:
$ sudo systemctl start docker
$ sudo systemctl enable docker

7.  Test Docker also with the hello container

Code:
$ sudo docker run hello-world


Da Docker das IMG nicht findet, kommt erst eine Fehlermeldung, dann aber, wenn der Download erfolgreich war, die Meldung, dass alles gut ist. Sieht dann in der Konsole so aus:

Code:
user@user:/$ sudo docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
b8dfde127a29: Pull complete
Digest: sha256:0fe98d7debd9049c50b597ef1f85b7c1e8cc81f59c8d623fcb2250e8bec85b38
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/

For more examples and ideas, visit:
https://docs.docker.com/get-started/

Hello from Docker!** ist die richtige Meldung zum IMG.

Drucke diesen Beitrag

  Docker nutzen
Geschrieben von: Joopi - 23-11-2024, 09:45 - Forum: Docker - Keine Antworten

So wird Docker genutzt

Mal wieder ein guter Link:
Entfernen von Docker-Images, -Containern und -Volumen

oder hier:

Docker run reference

Sobald Docker komplett incl. Engine installiert ist, kann Docker auch genutzt werden. Um Docker zu nutzen, muss man die Image-Namen wissen.  Diese sind z.B. auf dem Docker Hub zu finden.

Docker-Image herunterladen

Code:
sudo docker pull golang

Um zu prüfen, welche Images heruntergeladen worden sind, gilt folgender Befehl:

Code:
sudo docker ps -a
[sudo] Passwort für user:
CONTAINER ID  IMAGE        COMMAND    CREATED        STATUS                    PORTS    NAMES
3b4a2640dd52  golang        "bash"    19 hours ago  Exited (0) 19 hours ago            mystifying_wu
0ee81db39223  ubuntu        "bash"    21 hours ago  Exited (0) 21 hours ago            stupefied_buck
e5afa06d8d02  hello-world  "/hello"  21 hours ago  Exited (0) 21 hours ago            mystifying_bell

Um zu prüfen, welche Container laufen, ist die Option **-a** wegzulassen:

Code:
sudo docker ps
CONTAINER ID  IMAGE    COMMAND  CREATED  STATUS    PORTS    NAMES

Da noch kein Container gestartet wurde, wird auch noch nichts angezeigt, was an Containern läuft.

Mit dem folgenden Befehl wird ein Container aus dem vorher heruntergeladenen Image erstellt und gestartet:

Hier wäre der Dienst im Hintergrund und läuft vor sich hin (detached)

Code:
sudo docker run -d -it --name myneuesdocker golang

oder

Hier wäre der Dienst interaktiv und benutzbar (tached)

Code:
sudo docker run -it --name myneuesdocker golang
0b2cb8ecefe8dbabb95a2078419a8585dc5b224693809a1560fff8321c429f0e

Hinweis

Wenn der run-Befehl ausgeführt wird, dann wird z.B. hinten nach dem Imagenamen ein Befehl angehängt, der dann ausgeführt werden soll. Wenn nichts angegeben wird, wird der Standardprozess gestartet.

Beispiel

Ubuntu - der Aufruf des Images zur Erstellung des Container kann mit ... ubuntu bash ... enden, damit nach dem Start des Containers sofort eine Bash vorhanden ist.

Es wird eine lange ID ausgegeben, wobei die ersten 12 Stellen wohl später die ID für die laufen  Container darstellen.

Um zu prüfen, ob der Container läuft, ist wieder folgender Befehl abzusetzen:

Code:
sudo docker ps
CONTAINER ID  IMAGE    COMMAND  CREATED              STATUS              PORTS    NAMES
0b2cb8ecefe8  golang    "bash"    About a minute ago  Up About a minute            myneuesdocker

Nun wird gezeigt, welche Container laufen. In diesem Falle ist es nur der Golang-Container.

Was der Name myneuesdocker, den ich selber kreiert habe, zu bedeuten hat, weiß ich noch nicht.

Ich weiß auch noch nicht, wo Docker den Pull-Download ablegt und wo der Container wirklich liegt. Denn eigentlich müsste mindestens eine Datei zu finden sein. In Linux wird alles in Dateien erledigt.

Um mit dem Container arbeiten zu können, ist folgender Befehl notwendig:

sudo docker exec -it myneuesdocker bash
root@0b2cb8ecefe8:/go#

In diesem Falle landet man als root in einem Bash-Terminal und kann loslegen.

Um zu prüfen, welche Ordner bzw. Dateien nun zur Verfügung stehen, ist nur der **ls**-Befehl notwendig:

root@0b2cb8ecefe8:/go# ls
bin  src

Die Ausgabe ist sehr minimalistisch, da nur die notwendigen Abhängigkeiten erfüllt werden. Das ist eben der große Vorteil von Docker mit den Containern gegenüber den Virtualisierungstools.

Um den Container zu verlassen, ist nur dies erforderlich:

Code:
root@0b2cb8ecefe8:/go# exit
exit
user@user:~$

Damit ist man wieder auf der eigenen Maschine unterwegs und nicht mehr im Container. Der Container läuft aber noch und ist somit jederzeit wieder zu betreten.

Um einen Container mit dem Host, also dem eigenen Computer zu verbinden, ist beim Aufruf von run der Port mitzugeben:

Code:
sudo docker run -d -t -p 80:80 --name myneuesdocker golang

Dieser Aufruf wurde auf dem Kanal von NetworkChuck in Verbindung mit einem anderen Betriebssystem genutzt. Ob das mit meinem Beispiel auch so geht, weiß ich nicht. Aber man kann Container mit dem eigenen Betriebssystem verbinden.

In dem Beispiel hat er in dem Container seine Trainingswebseite in einem Browser aufgerufen.

Um einen Container zu beenden, ist folgender Befehl notwendig:

Code:
user@user:~$ sudo docker stop myneuesdocker
myneuesdocker

Wenn man prüfen will, ob das Stoppen durchgeführt wurde, hilft wieder:

Code:
user@user:~$ sudo docker ps
CONTAINER ID  IMAGE    COMMAND  CREATED  STATUS    PORTS    NAMES

Sollte man den Container nochmal benutzen müssen, kann man ihn wieder starten:

Code:
user@user:~$ sudo docker start myneuesdocker
myneuesdocker

Die Prüfung zeigt, dass der Container wieder gestartet ist:

Code:
user@user:~$ sudo docker ps
CONTAINER ID  IMAGE    COMMAND  CREATED          STATUS          PORTS    NAMES
0b2cb8ecefe8  golang    "bash"    54 minutes ago  Up 25 seconds            myneuesdocker

Dieses Start und Stop ist nicht mit dem **run**-Befehl zu verwechseln, denn damit wurde das Image gestartet. Der Container wurde dann separat in einem nächsten Schritt gestartet (docker exec ...)

Je nach dem mit welcher Computerausstattung man unterwegs ist, muss man die Ressourcen im Auge behalten. Auch dafür ist gesorgt und mit folgendem Befehl kann man die Speicherauslastung prüfen:

Code:
sudo docker stats

Die Ausgabe dieses Befehls zeigt die Auslastung von CPU, RAM usw.
Da nur ein Container läuft, ist die Ausgabe relativ knapp:

   

Code:
CONTAINER ID  NAME            CPU %    MEM USAGE / LIMIT  MEM %    NET I/O      BLOCK I/O  PIDS
0b2cb8ecefe8  myneuesdocker  0.00%    824KiB / 62.73GiB  0.00%    12.2kB / 0B  0B / 0B    1



Das Management von Images und Containern ist nicht unbedingt einfach. Über folgenden Befehl kann man sich die Hilfe anzeigen lassen:

Code:
docker --help

Will man zu einzelnen Kommandos etwas wissen, muss der Befehl so aussehen:

Code:
docker system --help

Damit werden dann weitere Hilfen angezeigt, was man eben machen kann.

Im Laufe der Zeit werden sich vielleicht einige Images und Container ansammeln, die man nicht mehr haben will oder gebrauchen kann/möchte.

Um herauszufinden, welche Images vorhanden sind, ist dieser Befehl notwendig:

Code:
sudo docker images -a
REPOSITORY    TAG      IMAGE ID      CREATED        SIZE
golang        latest    0821480a2b48  10 days ago    862MB
ubuntu        latest    1318b700e415  2 weeks ago    72.8MB
hello-world  latest    d1165f221234  5 months ago  13.3kB

Dieser Befehl ist nicht mit der ps-Option zu verwechseln, die Container betrifft.

Diese Auflistung kann dazu verwendet werden, dass Images, die nicht mehr gewünscht sind, entfernt werden (es können mehrere Images angegeben werden):

Code:
user@user:~$ sudo docker rmi hello-world
Error response from daemon: conflict: unable to remove repository reference "hello-world" (must force) - container e5afa06d8d02 is using its referenced image d1165f221234

Der Löschbefehl wurde nicht akzeptiert. Verstanden habe ich das bislang noch nicht.



Exkurs

Das habe ich hier gefunden Docker error cannot delete docker container, conflict: unable to remove repository reference

Code:
docker container ls -a
docker image ls
docker container rm <container_id>
docker image rm <image_id>

Mit dem ersten Befehl werden alle Container gelistet.
Mit dem zweiten Befehl werden alle Images gelistet.
Diese Befehle sind notwendig, um die ID von Container und Images herauszufinden. Anscheinend müssen erst die Container entsorgt werden, bevor die Images gelöscht werden können.



Nun wird zunächst ein Container (Hello-World aus der Installation) gelöscht:

Code:
user@user:~$ sudo docker container rm e5afa06d8d02
e5afa06d8d02

Hiermit wird dann geprüft, ob der Container weg ist:

Code:
user@user:~$ sudo docker container ls -a
CONTAINER ID  IMAGE    COMMAND  CREATED        STATUS                    PORTS    NAMES
0b2cb8ecefe8  golang    "bash"    2 hours ago    Up 41 minutes                      myneuesdocker
3b4a2640dd52  golang    "bash"    20 hours ago  Exited (0) 20 hours ago            mystifying_wu
0ee81db39223  ubuntu    "bash"    23 hours ago  Exited (0) 23 hours ago            stupefied_buck

Sobald der Container gelöscht ist, kann auch das Images gelöscht werden:

Code:
django@django:~$ sudo docker image rm d1165f221234
Untagged: hello-world:latest
Untagged: hello-world@sha256:0fe98d7debd9049c50b597ef1f85b7c1e8cc81f59c8d623fcb2250e8bec85b38
Deleted: sha256:d1165f2212346b2bab48cb01c1e39ee8ad1be46b87873d9ca7a4e434980a7726
Deleted: sha256:f22b99068db93900abe17f7f5e09ec775c2826ecfe9db961fea68293744144bd

Und hier die Prüfung der vorhandenen Images:

Code:
user@user:~$ sudo docker image ls
REPOSITORY  TAG      IMAGE ID      CREATED      SIZE
golang      latest    0821480a2b48  10 days ago  862MB
ubuntu      latest    1318b700e415  2 weeks ago  72.8MB

Das Image wurde tatsächlich gelöscht.



Es gibt auch eine radikale Methode, um verwaiste Container zu entsorgen. Da muss man schon ein bisschen aufpassen, um nicht zu viel zu entsorgen:

Code:
docker system prune -a
WARNING! This will remove:

all stopped containers
all networks not used by at least one container
all unused images
all build cache




Aus der Webseite zum Entfernen von Containern

Entfernen von Containern

Entfernen von einem oder mehreren spezifischen Containern

Verwenden Sie den Befehl docker ps mit dem Flag -a, um den Namen oder die ID der Container zu finden, die Sie entfernen möchten.

Auflisten:

Code:
docker ps -a

Entfernen:

Code:
docker rm ID_or_Name ID_or_Name

Entfernen eines Containers beim Beenden

Falls Sie bei der Erstellung eines Containers wissen, dass Sie ihn nicht behalten möchten, wenn Sie damit fertig sind, können Sie `docker run --rm` ausführen, um ihn beim Beenden automatisch zu löschen.

Ausführen und entfernen:

Code:
docker run --rm image_name

Entfernen aller beendeten Container

Sie können Container mit `docker ps -a` finden und anhand ihres Status filtern: erstellt, wird neu gestartet, wird ausgeführt, angehalten oder beendet. Zum Überprüfen der Liste der beendeten Container verwenden Sie das Flag `-f`, um anhand des Status zu filtern. Wenn Sie wissen, dass Sie diese Container entfernen möchten, nutzen Sie `-q`, um die IDs an den Befehl `docker rm` zu übergeben.

Auflisten:

Code:
docker ps -a -f status=exited


Entfernen:

Code:
docker rm $(docker ps -a -f status=exited -q)




Löschen aller unbenutzten oder unreferenzierten Images, Container, Volumen und Netzwerke

Docker bietet einen einzelnen Befehl zur Bereinigung beliebiger Ressourcen – Images, Container, Volumen und Netzwerke –, die unreferenziert (also nicht mit einem Container verknüpft) sind:

Code:
docker system prune

Um auch angehaltene Container und alle nicht verwendeten Images zu entfernen (nicht nur unreferenzierte Images), fügen Sie dem Befehl das Flag `-a` hinzu:

Code:
docker system prune -a

Entfernen von Docker-Images

Entfernen von einem oder mehreren spezifischen Images

Verwenden Sie den Befehl `docker images` mit dem Flag `-a`, um die ID der Images zu finden, die Sie entfernen möchten. Dadurch wird Ihnen jedes Image angezeigt, einschließlich dazwischenliegender Image-Ebenen. Wenn Sie die Images gefunden haben, die Sie löschen möchten, können Sie ihre ID oder ihr Tag `docker rmi` übergeben:

Auflisten:

Code:
docker images -a


Entfernen:

Code:
docker rmi Image Image

Entfernen von unreferenzierten Images

Docker-Images bestehen aus mehreren Ebenen. Unreferenzierte Images sind Ebenen, die keine Beziehung zu getaggten Images haben. Sie dienen keinem Zweck mehr und verbrauchen Festplattenspeicher. Sie lassen sich finden, indem Sie das Filter-Flag (`-f`) mit dem Wert `dangling=true` zum Befehl `docker images` hinzufügen. Wenn Sie sicher sind, dass Sie sie löschen möchten, können Sie den Befehl `docker images purge` verwenden:

Anmerkung:

Wenn Sie ein Image erstellen, ohne es mit einem Tag zu versehen, wird das Image in der Liste der unreferenzierten Images angezeigt, da es keine Zuordnung zu einem getaggten Image aufweist. Sie können diese Situation vermeiden, indem Sie beim Erstellen ein Tag angeben; außerdem können Sie Images mit dem Befehl docker tag im Nachhinein mit einem Tag versehen. 

Auflisten:

Code:
docker images -f dangling=true

Entfernen:

Code:
docker images purge

Entfernen von Images gemäß einem Muster

Sie können alle Images finden, die mit einem Muster übereinstimmen, indem Sie eine Kombination aus docker images und grep nutzen. Wenn Sie damit zufrieden sind, können Sie sie durch awk löschen, um die IDs an `docker rmi` zu übergeben. Beachten Sie, dass diese Dienstprogramme nicht von Docker bereitgestellt werden und nicht unbedingt für alle Systeme verfügbar sind:

Auflisten:

Code:
docker images -a |  grep "pattern"

Entfernen:

Code:
docker images -a | grep "pattern" | awk '{print $3}' | xargs docker rmi

Alle Images entfernen

Alle Docker-Images in einem System können aufgelistet werden, indem Sie dem Befehl docker images -a hinzufügen. Wenn Sie sicher sind, dass Sie alle löschen möchten, können Sie das Flag -q hinzufügen, um die Image-ID an docker rmi zu übergeben:

Auflisten:

Code:
docker images -a

Entfernen:

Code:
docker rmi $(docker images -a -q)




Noch eine Hilfe, sollte man mehrere Container laufen haben:

If you want to cleanup docker images and containers

CAUTION: this will flush everything

stop all containers

Code:
docker stop $(docker ps -a -q)

remove all containers

Code:
docker rm $(docker ps -a -q)

remove all images

Code:
docker rmi -f $(docker images -a -q)




Wo liegen die Docker-Images?

Mit folgendem Befehl kann man die Docker-Infos ermitteln:

Code:
sudo docker info

Die Ausgabe länger und die Antwort auf die Frage im letzten Teil der Ausgabe zu sehen:


Code:
user@user:~$ sudo docker info
Client:
Context:    default
Debug Mode: false
Plugins:
  app: Docker App (Docker Inc., v0.9.1-beta3)
  buildx: Build with BuildKit (Docker Inc., v0.6.1-docker)
  scan: Docker Scan (Docker Inc., v0.8.0)

Server:
Containers: 0
  Running: 0
  Paused: 0
  Stopped: 0
Images: 0
Server Version: 20.10.8
Storage Driver: overlay2
  Backing Filesystem: extfs
  Supports d_type: true
  Native Overlay Diff: true
  userxattr: false
Logging Driver: json-file
Cgroup Driver: cgroupfs
Cgroup Version: 1
Plugins:
  Volume: local
  Network: bridge host ipvlan macvlan null overlay
  Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
Swarm: inactive
Runtimes: io.containerd.runc.v2 io.containerd.runtime.v1.linux runc
Default Runtime: runc
Init Binary: docker-init
containerd version: e25210fe30a0a703442421b0f60afac609f950a3
runc version: v1.0.1-0-g4144b63
init version: de40ad0
Security Options:
  apparmor
  seccomp
  Profile: default
Kernel Version: 5.11.0-25-generic
Operating System: Ubuntu 20.04.2 LTS
OSType: linux
Architecture: x86_64
CPUs: 16
Total Memory: 62.73GiB
Name: django
ID: RTKL:M23W:E6CV:JO3K:YVNJ:GXXS:I5XO:3UU3:R654:KJQX:AXYO:L43R
Docker Root Dir: /var/lib/docker
Debug Mode: false
Registry: https://index.docker.io/v1/
Labels:
Experimental: false
Insecure Registries:
  127.0.0.0/8
Live Restore Enabled: false

Der docker-root-ordner liegt hier:

Zitat:/var/lib/docker

docker ist ein Ordner, der mit einem Schloss versehen ist:

   

Die Images und Container werden in diesem Pfad abgespeichert, aber nicht namtlich erkennbar, sondern mit SHA256-Codenamen. Somit sind diese Dateien außerhalb der Einflussnahme durch den User, also durch mich. Ich kann nur das Management betreiben. So sieht der Ordner im Midnight-Commander aus:

   

Somit kann ich nun am 16.08.2021 in das echte Handling von Docker einsteigen.

Docker kann nur Serversoftware verarbeiten. Grafische Oberflächen kann Docker nicht darstellen und war auch nicht Sinn und Zweck für die Entwicklung dieses Tools. Die möglichen Betriebssystem, die in Docker laufen, sind also immer nur die Serverversionen, nie die Desktop-Versionen.

Damit der Normaluser mit Docker arbeiten kann, ist er zur Gruppe Docker hinzuzufügen:

Code:
sudo usermod -aG docker django


Nach einer Neuanmeldung ist die Gruppenzuordnung aktiv.

Exkurs

Im Normalfall wird erst der Pull-Befehl und dann der Run-Befehl ausgeführt. Man kann aber auch direkt den Run-Befehl ausführen. Wird das Images nicht gefunden, wird es heruntergeladen. Also wird der Pull-Befeh implizit ausgeführt.



Die Option -d im Run-Befehl sorgt dafür, dass der Container im Hintergrund läuft.

Die Option -p 8080:80 sorgt dafür, dass man innerhalb des Container einen nach außen geöffneten Port zur Verfügung hat. Bei Webserver, die später im Webbrowser ausgeführt werden, oder bei anderen Webanwendungen (z.B. Ghost) ist das notwendig. Im Browser wäre anzugeben: localhost:8080

Die wichtigsten Befehle nochmal zusammengefasst:
  • docker pull imagename
  • docker ps
  • docker ps -a (zeigt auch laufende Container)
  • docker run -d -t --name **platzname** imagename
  • docker exec -it **platzname** bash oder sh (wo der Container laufen soll)
  • exit (aus Container aussteigen)
  • docker stop **platzname** (Container stoppen)
  • docker start **platzname** (Container starten)
  • docker info
  • docker stats
  • docker --help
  • docker command --help
  • docker images -a
  • docker container ls -a
  • docker image ls
  • docker volume ls
  • docker container rm ID-Container oder Name
  • docker image rm ID-Image oder Name
  • docker system prune -a (mit Vorsicht, alles alle Container, die unbenutzt sind.
  • docker run --rm image_name (Vorsicht: beim Beenden wird der Container direkt wieder gelöscht)



Eigene Daten sollte man nicht in den Container kopieren, sondern via Volumes bereitstellen, die dann vom Container genutzt werden. Da ist z.B. für einen Webserver gut, der in einem Container läuft und die HTML-Seiten liegen dann im Volume.



Zwar läuft z.B. ein Webserver in einem Container, aber gleichzeitig wird er auch vom Host, also vom eigenen Computer erkannt. Mit folgendem Befehl kann man prüfen, ob z.B. nginx ausgeführt wird, der in eiinem Container läuft:

Code:
ps axu | grep nginx

Drucke diesen Beitrag