{"id":2174,"date":"2023-09-10T07:50:31","date_gmt":"2023-09-10T05:50:31","guid":{"rendered":"https:\/\/linux-bibel.at\/?p=2174"},"modified":"2023-09-10T07:50:34","modified_gmt":"2023-09-10T05:50:34","slug":"docker-anwendungen-und-systeme-unter-linux-virtualisieren-isolieren","status":"publish","type":"post","link":"https:\/\/linux-bibel.at\/index.php\/2023\/09\/10\/docker-anwendungen-und-systeme-unter-linux-virtualisieren-isolieren\/","title":{"rendered":"Docker – Anwendungen und Systeme unter Linux virtualisieren \/ isolieren"},"content":{"rendered":"\n

VMWare, VirtualBox und Qemu haben dieselbe Eigenschaft: Sie benötigen Leistung von den Prozessoren. Einerseits benötigt schon die Software, die Hardware virtualisiert, Kraft, andererseits das darauf laufende Betriebssystem<\/a> – im Grunde laufen hier dann zwei Betriebssystem<\/a>e und die Software zur Virtualisierung<\/a>.<\/p>\n\n\n\n

In gewissen Fällen kann hier die Software Docker<\/a> helfen – hier läuft im Grunde genommen kein zweites Betriebssystem<\/a>. Der Gast, also das virtualisierte System, nutzt nämlich den Kernel des real installierten Systems. Das hat natürlich auch Nachteile: Da der Kernel des real installierten Systems genutzt wird, lässt sich nur ein verwan<\/a>dtes System virtualisieren. Unter Linux<\/a> kann man nur Linux<\/a>-Systeme in Docker<\/a> laufen lassen, unter Windows nur Windows.<\/p>\n\n\n\n

Was kann man mit Docker anstellen?<\/h3>\n\n\n\n

Man kann Anwendungen vom restlichen System isolieren, so etwa einen Webserver<\/a> mit Docker<\/a> betreiben, der vom restlichen System abgeschottet ist. Man kann andere Linux<\/a>-Distribution<\/a>en versuchen – so ist es beispielsweise möglich, unter Debian<\/a> openSUSE laufen zu lassen …<\/p>\n\n\n\n

Docker installieren<\/h3>\n\n\n\n

Unter den meisten Linux<\/a>-Distribution<\/a>en nennt sich das Paket<\/a> ganz einfach „docker<\/a><\/strong>„, unter auf Debian<\/a> basierenden Linux<\/a>-Distribution<\/a>en existiert schon ein gleichnamiges Paket<\/a> – hier installieren Sie über die Paket<\/a>-Verwaltung das Paket<\/a> „docker<\/a>.io<\/strong>„.<\/p>\n\n\n\n

Damit Docker<\/a> dauerhaft läuft, müssen Sie den automatischen Start aktivieren. Dies gelingt am Terminal<\/a> als Administrator<\/a> mit dem Befehl<\/a>:<\/p>\n\n\n\n

systemctl enable docker<\/code><\/pre>\n\n\n\n
Nach einem Neustart startet Docker<\/a> automatisch mit dem System. Möchten Sie Docker<\/a> nur hin und wieder nutzen, starten Sie den Dienst manuell auf dem Terminal<\/a> mit dem administrativen Befehl<\/a>:<\/p>\n\n\n\n
systemctl start docker<\/code><\/pre>\n\n\n\n
Mit:<\/p>\n\n\n\n
systemctl stop docker<\/code><\/pre>\n\n\n\n
lässt er sich anschließend wieder beenden. Mit:<\/p>\n\n\n\n
systemctl status docker<\/code><\/pre>\n\n\n\n
lässt sich der aktuelle Status anzeigen – hier läuft Docker<\/a> – „Active: active (running)“:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Nach Images suchen<\/h3>\n\n\n\n
Man muss nicht lan<\/a>ge selbst an Images basteln, es finden sich bereits für viele Aufgaben vorgefertigte Images auf dem Docker<\/a>-Server<\/a> im Internet. Gleich einmal zu Beginn – Docker<\/a> wird vom Administrator<\/a> genutzt. Nun wollen wir zu Beginn auf dem Terminal<\/a> suchen – hier etwa nach einer bestimmten Distribution<\/a>:<\/p>\n\n\n\n
docker search debian<\/code><\/pre>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Als Ausgabe sehen Sie zu Beginn den Namen des Images, anschließend eine kurze Beschreibung und zuletzt eine Statusmeldung. Sie müssen jedoch nicht unbedingt eine Distribution<\/a> wählen, es kann sich auch um eine Anwendung handeln, etwa:<\/p>\n\n\n\n
docker search apache2<\/code><\/pre>\n\n\n\n
Möchten Sie mehrere Begriffe der Suche übergeben, setzen Sie alle Begriffe in Anführungszeichen.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Sie müssen passende Images jedoch nicht unbedingt am Terminal<\/a> suchen, Sie können es auch auf der Webseite von Docker<\/a> grafisch im Webbrowser tun: https:\/\/hub.docker.com\/search?q=&type=image<\/a>:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Docker-Images herunterladen<\/h3>\n\n\n\n
Haben Sie ein passendes Image gefunden, brauchen Sie für den Download nur dessen Namen. Im Beispiel einfach „debian<\/a><\/strong>“ – der Download gelingt am Terminal<\/a> mit dem Befehl<\/a>:<\/p>\n\n\n\n
docker pull debian<\/code><\/pre>\n\n\n\n
In diesem Fall wird nur das Standard-System heruntergeladen, ohne jegliche Anwendungen (rund 60 MB<\/em>).<\/p>\n\n\n\n
Alle installierten Images anzeigen<\/h3>\n\n\n\n
Mit dem Befehl<\/a>:<\/p>\n\n\n\n
docker images<\/code><\/pre>\n\n\n\n
lassen sich anschließend alle installierten Images anzeigen:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Docker-Images starten<\/h3>\n\n\n\n
Ein installiertes Image starten Sie anschließend, indem Sie dessen Namen angeben, am besten steigen Sie gleich darin ein. Hierzu nutzen Sie die Optionen „-t -i<\/code><\/strong>“ und geben an, dass Sie das Terminal<\/a> starten wollen:<\/p>\n\n\n\n
docker run -t -i  debian \/bin\/bash<\/code><\/pre>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Sie lan<\/a>den also direkt im laufenden System auf dem Terminal<\/a>. Alternativ starten Sie den Container mit der Option „-d<\/code><\/strong>“ – in diesem Fall wartet das System im Hintergrund auf Eingaben:<\/p>\n\n\n\n
docker run -t -i -d debian<\/code><\/pre>\n\n\n\n
Nun können Sie sich auf einem anderen Terminal<\/a> alle laufenden Container anzeigen lassen:<\/p>\n\n\n\n
docker ps<\/code><\/pre>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Mit dem Befehl<\/a>:<\/p>\n\n\n\n
exit<\/code><\/pre>\n\n\n\n
innerhalb des laufenden Containers steigen Sie aus diesem aus und beenden ihn. Wie oben schon beschrieben, starten Sie ein Docker<\/a>-Image im Hintergrund mit dem Befehl<\/a>:<\/p>\n\n\n\n
docker run -i -t -d debian<\/code><\/pre>\n\n\n\n
Dies bedeutet: Sie müssen keine Eingaben machen – das System läuft, und Sie können auf dem Terminal<\/a> andere Aufgaben erledigen oder natürlich auch weitere Docker<\/a>-Images starten. Nun können Sie sich mit:<\/p>\n\n\n\n
docker ps<\/code><\/pre>\n\n\n\n
die laufenden Docker<\/a>-Images anzeigen lassen:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Wichtig ist hier nun die „CONTAINER ID<\/strong>„, mit dieser ID können Sie das Image steuern und Befehl<\/a>e in das im Hintergrund laufende System abgeben, hierzu dient der Befehl<\/a> „exec<\/code><\/strong>„. Um etwa den Befehl<\/a> „ls<\/code><\/strong>“ in das Image mit der ID „40ae1d009763<\/strong>“ abzugeben:<\/p>\n\n\n\n
docker exec 40ae1d009763 ls<\/code><\/pre>\n\n\n\n
Die Ausgabe des Befehl<\/a>s wird in diesem Fall am Terminal<\/a> ausgegeben, ohne direkt in den laufenden Container zu wechseln. Möchten Sie den im Hintergrund laufenden Container stoppen, genügt ein:<\/p>\n\n\n\n
docker stop 40ae1d009763<\/code><\/pre>\n\n\n\n
Arbeiten mit Docker-Images<\/h3>\n\n\n\n
Nun wissen wir, wie wir Docker<\/a>-Images installieren, starten und stoppen. Wir möchten darin natürlich auch arbeiten, in meinem Fall starte ich wieder mein Debian<\/a> mit dem Terminal<\/a>:<\/p>\n\n\n\n
docker run -i -t debian \/bin\/bash<\/code><\/pre>\n\n\n\n
Ich befinde mich nun auf dem Terminal<\/a> im laufenden Docker<\/a>-Container und kann darauf arbeiten – etwa das System aktualisieren, Software installieren, Datei<\/a>en anlegen und solche bearbeiten – was auch immer. Wird der laufende Container beendet, sind jedoch alle Änderungen verloren. Bei den heruntergeladenen Images handelt es sich um schreibgeschützte Images. Also muss man etwas anders arbeiten: Wir beginnen von vorne. Wir starten einen Container wie oben:<\/p>\n\n\n\n
docker run -i -t debian \/bin\/bash<\/code><\/pre>\n\n\n\n
Wir beenden den Container einfach mittels:<\/p>\n\n\n\n
exit<\/code><\/pre>\n\n\n\n
Nun starten wir den Befehl<\/a>:<\/p>\n\n\n\n
docker ps --all<\/code><\/pre>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Dieser Befehl<\/a> zeigt uns nun nicht nur laufende Docker<\/a>-Container, sondern auch solche, die wir bereits wieder beendet haben – ganz hinten finden Sie in der Tabelle auch die Spalte „NAME<\/strong>“ – dies ist eine freundliche Bezeichnung, mit der wir genau diesen Container wieder starten können – und in diesem Container können wir auch Änderungen vornehmen, die erhalten bleiben. Im Bild oben sehen wir die Bezeichnung „friendly_mclaren<\/code><\/strong>“ – wir können diesen Container also mit:<\/p>\n\n\n\n
docker start friendly_mclaren<\/code><\/pre>\n\n\n\n
starten:<\/p>\n\n\n\n
Nun können wir mit:<\/p>\n\n\n\n
docker attach friendly_mclaren<\/code><\/pre>\n\n\n\n
in den laufenden Container wechseln. Nun könnte man etwa das System aktualisieren, weitere Software installieren und sonstige Änderungen im System vornehmen – diese bleiben erhalten. Mit:<\/p>\n\n\n\n
exit<\/code><\/pre>\n\n\n\n
kann man aus dem System aussteigen (dadurch wird dieser Container natürlich beendet)<\/em>, den Container wieder starten, und die Änderungen bleiben erhalten.<\/p>\n\n\n\n
Laufende Container lassen sich nun mit:<\/p>\n\n\n\n
docker ps<\/code><\/pre>\n\n\n\n
anzeigen, alle gestarteten Container (auch wenn diese nicht laufen<\/em>) mit:<\/p>\n\n\n\n
docker ps --all<\/code><\/pre>\n\n\n\n
Container die nicht laufen, lassen sich mit:<\/p>\n\n\n\n
docker rm CONTAINER-ID<\/code><\/pre>\n\n\n\n
löschen, ganze Images, die Sie sich mit<\/p>\n\n\n\n
docker images<\/code><\/pre>\n\n\n\n
anzeigen lassen, lassen sich mit<\/p>\n\n\n\n
docker rmi Image-Name<\/code><\/pre>\n\n\n\n
löschen.<\/p>\n\n\n\n
Man sieht also schon: Um mit Docker<\/a> zu arbeiten, sollte man zu Beginn ein wenig plan<\/a>en. Nehmen wir einmal an, Sie möchten mit dem vorgefertigten Docker<\/a>-Image „nginx<\/strong>“ (der Webserver<\/a> nginx<\/em>) einen Webserver<\/a> betreiben – hier ist das System bereit, der Webserver<\/a> ist installiert. Das System muss jedoch freie Ports<\/a> haben – der Webserver<\/a> benötigt ohne HTTPS den Port „80<\/strong>“ – ganz klar: Wir müssen den Port aus dem Container auf das real installierte System aufschalten. Gelingt ganz einfach:<\/p>\n\n\n\n
-p Container-Port:Host-Port<\/code><\/pre>\n\n\n\n
In diesem Beispiel ganz einfach:<\/p>\n\n\n\n
docker run -p 80:80 nginx<\/code><\/pre>\n\n\n\n
Schon läuft der Container, und Sie können mit „localhost<\/a><\/strong>“ über einen Webserver<\/a> auf die Seite zugreifen:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Mittels:<\/p>\n\n\n\n
docker ps --all<\/code><\/pre>\n\n\n\n
sehen wir anschließend den Namen des Containers, mit dem wir den Container mit<\/p>\n\n\n\n
docker start NAME<\/code><\/pre>\n\n\n\n
wieder starten können. Möchte man sich den Server<\/a> komplett selbst zusammenstellen, in diesem Fall einfach einen Webserver<\/a> – etwa wieder mit dem Image „debian<\/a><\/strong>“ -, startet man das Image wieder mit den später zu nutzenden Ports<\/a> – also<\/p>\n\n\n\n
docker run -p 80:80 debian<\/code><\/pre>\n\n\n\n
sucht sich nun die ID oder den Namen und stoppt diesen mit:<\/p>\n\n\n\n
docker ps --all\ndocker stop NAME<\/code><\/pre>\n\n\n\n
Nun kann man den Container starten, in dem man beständige Änderungen vornehmen kann, und darin arbeiten:<\/p>\n\n\n\n
docker start NAME\ndocker attach NAME<\/code><\/pre>\n\n\n\n
Sie können einem Container natürlich auch selbst einen Namen geben – ist einfacher zu merken:<\/p>\n\n\n\n
docker run --name= NAME -p 80:80 debian<\/code><\/pre>\n\n\n\n
Docker-Volumes – Auf den Speicher eines Docker-Systems zugreifen und Docker Compose<\/h3>\n\n\n\n
Hat man eine Software unter Docker<\/a> installiert und möchte auf die Daten<\/a> dieser zugreifen, kann es schon einmal umständlich werden. In den Container wechseln, mit Befehl<\/a>en am Terminal<\/a> hantieren – mit sogenannten Volumes fällt dies viel einfacher.<\/p>\n\n\n\n
Ein Volume ist nichts anderes, als ein Verzeichnis<\/a> auf dem Docker<\/a>-System – dieses wird direkt mit dem Wirtssystem geteilt. Zusätzlichen Platz benötigt dies nicht. Man nennt die Geschichte auch gerne Persistenz.<\/p>\n\n\n\n
Sehen wir uns diese Geschichte mit einem Beispiel an – ich werde dazu ganz einfach MediaWiki<\/a> – die Software wird unter anderem bei Wiki<\/a>pedia genutzt.<\/p>\n\n\n\n
Mediawiki<\/a> unter Docker<\/a> installieren<\/p>\n\n\n\n
Für MediaWiki<\/a> gibt es auf DockerHub<\/a> bereits ein vorgefertigtes Image, dieses können wir ganz einfach mittels Docker<\/a> aufsetzen:<\/p>\n\n\n\n
docker run --name mediawiki -p 8080:80 -d mediawiki<\/code><\/pre>\n\n\n\n
Jetzt können wir via Webbrowser und der Adresse 127.0.0.1:8080<\/em> oder localhost<\/a>:8080<\/em> auf das Wiki<\/a> zugreifen. Jetzt wird es jedoch problematisch – man richtet das Wiki<\/a> ein und bekommt die Datei<\/a> „LocalSettings.php<\/strong>“ zum Download, diese gilt es anschließend im Verzeichnis<\/a> der MediaWiki<\/a>-Installation abzulegen, ansonsten läuft das Wiki<\/a> nicht.<\/p>\n\n\n\n
Dafür gibt es nun Volumes – eben Verzeichnis<\/a>se, die zwischen Host<\/a> und Gast geteilt werden. Um Docker<\/a>-Images anzupassen, erstellen wir uns eine Konfiguration<\/a>sdatei<\/a> in einem leeren Verzeichnis<\/a> – die Konfiguration<\/a>sdatei<\/a> nennt sich „docker<\/a>-compose.yml<\/strong>„. Mit dieser Konfiguration<\/a>sdatei<\/a> und der Software Docker<\/a>-Compose passen wir das Image an. Docker<\/a>-Compose wird unter auf Debian<\/a> basierenden Linux<\/a>-Distribution<\/a>en wie üblich ganz einfach über die Paket<\/a>-Verwaltung durch das Paket<\/a> „docker<\/a>-compose<\/strong>“ installiert.<\/p>\n\n\n\n
Wie schon beschrieben – für unser Beispiel dient MediaWiki<\/a> – am oben gezeigten Link findet sich bereits eine passende Vorlage für die Konfiguration<\/a>sdatei<\/a>:<\/p>\n\n\n\n
# MediaWiki with MariaDB\n#\n# Access via \"http:\/\/localhost:8080\"\n#   (or \"http:\/\/$(docker-machine ip):8080\" if using docker-machine)\nversion: '3'\nservices:\n  mediawiki:\n    image: mediawiki\n    restart: always\n    ports:\n      - 8080:80\n    links:\n      - database\n    volumes:\n      - images:\/var\/www\/html\/images\n      # After initial setup, download LocalSettings.php to the same directory as\n      # this yaml and uncomment the following line and use compose to restart\n      # the mediawiki service\n      # - .\/LocalSettings.php:\/var\/www\/html\/LocalSettings.php\n  # This key also defines the name of the database host used during setup instead of the default \"localhost\"\n  database:\n    image: mariadb\n    restart: always\n    environment:\n      # @see https:\/\/phabricator.wikimedia.org\/source\/mediawiki\/browse\/master\/includes\/DefaultSettings.php\n      MYSQL_DATABASE: my_wiki\n      MYSQL_USER: wikiuser\n      MYSQL_PASSWORD: example\n      MYSQL_RANDOM_ROOT_PASSWORD: 'yes'\n    volumes:\n      - db:\/var\/lib\/mysql\n\nvolumes:\n  images:\n  db:<\/code><\/pre>\n\n\n\n
Alle mit einer Raute „#<\/strong>“ auskommentierten Zeilen werden vom System ignoriert, dienen also zur Beschreibung. Wir sehen zu Beginn den Eintrag „services<\/strong>“ – dieser dient zur Beschreibung der einzelnen Images – wir haben in diesem Beispiel zwei Images – „mediawiki<\/a><\/strong>“ und „database<\/strong>„. Die Services geben den Images grob gesagt nur Namen, mit denen wir etwas anfangen können – für „mediawiki<\/a><\/strong>“ wird von Docker<\/a>Hub das Image „mediawiki<\/a><\/strong>“ heruntergeladen und eingerichtet, für „database<\/strong>“ das Image „mariadb<\/a><\/strong>„.<\/p>\n\n\n\n
„restart<\/strong>“ zeigt Docker<\/a> wie und wan<\/a>n Docker<\/a> das Image starten soll, „always<\/strong>“ heißt nichts anderes als, Docker<\/a> soll das System automatisch beim Start des Host<\/a>s (des Wirtes<\/em>) starten, gibt es Probleme mit dem Gast, soll Docker<\/a> das Image wieder neu starten.<\/p>\n\n\n\n
Mit „ports<\/a><\/strong>“ geben wir die Ports<\/a> an, über die das Image über den Webbrowser erreicht werden soll – vorne steht der Port, über den wir die Software im Webbrowser erreichen wollen, dahinter der Port im Image. „links<\/em>“ ist eine sehr einfache Definition für das Netzwerk<\/a>, über das die beiden Images kommunizieren – in diesem Fall nennt sich das Netzwerk<\/a> „database<\/strong>„.<\/p>\n\n\n\n
Als letzten Eintrag finden wir bei jedem Service den Eintrag „volumes<\/strong>“ – dies sind nun die mit dem Wirt geteilten Verzeichnis<\/a>se. Wir können hier eines oder auch mehrere Verzeichnis<\/a>se angeben. Als letzte Konfiguration<\/a> in der Datei<\/a> zeigt sich hier noch einmal der Eintrag „volumes<\/strong>“ – hier müssen alle Volumes – besser gesagt, deren Bezeichnungen noch einmal angegeben werden.<\/p>\n\n\n\n
Wichtig:<\/strong><\/p>\n\n\n\n
Bei der Konfiguration<\/a>sdatei<\/a> wird das YML-Format (YAML<\/em>) genutzt – dies ist ein wenig gemein – man nutzt hier für Einrückungen nicht den Tabulator<\/a>, sondern tatsächlich zwei Leerzeichen – alles andere funktioniert bei YML absolut nicht.<\/p>\n\n\n\n
Volumes einrichten<\/h3>\n\n\n\n
Wir sehen im Original der Einrichtungsdatei<\/a> oben bereits zwei Volumes:<\/p>\n\n\n\n
    volumes:\n      - images:\/var\/www\/html\/images\n      # After initial setup, download LocalSettings.php to the same directory as\n      # this yaml and uncomment the following line and use compose to restart\n      # the mediawiki service\n      # - .\/LocalSettings.php:\/var\/www\/html\/LocalSettings.php<\/code><\/pre>\n\n\n\n
Und:<\/p>\n\n\n\n
    volumes:\n      - db:\/var\/lib\/mysql<\/code><\/pre>\n\n\n\n
Im ersten Volume wird das im Gast liegende Verzeichnis<\/a> „images<\/em>“ mit dem Host<\/a> geteilt – alle anderen Zeilen sind nur Beschreibungen. Sehen wir uns diese Zeile etwas genauer an:<\/p>\n\n\n\n
      - images:\/var\/www\/html\/images<\/code><\/pre>\n\n\n\n
Vor jeder Volume hat sich ein Bindestrich zu zeigen „–<\/strong>„, anschließend folgt nach einem Leerzeichen das Verzeichnis<\/a>, das geteilt werden soll. Sie dürfen hier keinen Pfad angeben – nur das eindeutige Verzeichnis<\/a>. In diesem Fall liegt das Verzeichnis<\/a> „images<\/em>“ im Wirt unter „\/var\/www\/html\/image<\/em>s“ – angegeben darf jedoch nur wie schon beschrieben „images<\/em>“ werden.<\/p>\n\n\n\n
Das zweite Volume ist nun ganz einfach „db<\/em>“ – hiermit werden alle Datei<\/a>en in der Datenbank<\/a> des Images „mariadb<\/a><\/strong>“ mit dem Host<\/a> (Wirt<\/em>) geteilt.<\/p>\n\n\n\n
Im Beispiel des Originals wird nur das Verzeichnis<\/a> „images<\/em>“ geteilt – ich möchte jedoch das komplette HTML-Verzeichnis<\/a> teilen, dieses liegt anschließend wie schon beschrieben direkt am Host<\/a>. Dafür lasse ich das Verzeichnis<\/a> „images<\/em>“ weg – dieses liegt ja direkt im Verzeichnis<\/a> „html<\/em>„.<\/p>\n\n\n\n
Die komplette Konfiguration<\/a>sdatei<\/a> sieht in meinem Beispiel dann so aus (ohne Beschreibungen<\/em>):<\/p>\n\n\n\n
version: '3'\nservices:\n  mediawiki:\n    image: mediawiki\n    restart: always\n    ports:\n      - 8080:80\n    links:\n      - database\n    volumes:\n      - html:\/var\/www\/html\/\n  database:\n    image: mariadb\n    restart: always\n    environment:\n      MYSQL_DATABASE: my_wiki\n      MYSQL_USER: wikiuser\n      MYSQL_PASSWORD: example\n      MYSQL_RANDOM_ROOT_PASSWORD: 'yes'\n    volumes:\n      - db:\/var\/lib\/mysql\n\nvolumes:\n  html:\n  db:<\/code><\/pre>\n\n\n\n
Jetzt lässt sich aus der Konfiguration<\/a>sdatei<\/a> „docker<\/a>-compose.yml<\/strong>“ das originale Docker<\/a>-Image, das angepasste zaubern – natürlich mit administrativen Rechten am Terminal<\/a> im Verzeichnis<\/a> mit der Datei<\/a>:<\/p>\n\n\n\n
docker-compose up -d<\/code><\/pre>\n\n\n\n
Die mit dem Host<\/a> geteilten Verzeichnis<\/a>se liegen anschließend auf dem Host<\/a> unter „\/var\/lib\/docker<\/a>\/volumes\/<\/em>“ – dieses Verzeichnis<\/a> ist natürlich nur mit administrativen Rechten zugänglich.<\/p>\n\n\n\n
<\/p>\n
\r\n    
\r\n    \r\n                            \"Gef\u00e4llt\r\n            <\/a>\r\n    3    <\/span>\r\n<\/div>
\r\n    \r\n                            \"Gef\u00e4llt\r\n            <\/a>\r\n    <\/span>\r\n<\/div><\/div>","protected":false},"excerpt":{"rendered":"
VMWare, VirtualBox und Qemu haben dieselbe Eigenschaft: Sie ben\u00f6tigen Leistung von den Prozessoren. Einerseits ben\u00f6tigt schon die Software, die Hardware virtualisiert, Kraft, andererseits das darauf laufende Betriebssystem – im Grunde laufen hier dann zwei Betriebssysteme und die Software zur Virtualisierung. In gewissen F\u00e4llen kann hier die Software Docker helfen – hier l\u00e4uft im Grunde genommen […]<\/p>\n","protected":false},"author":1,"featured_media":2185,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[66,67],"tags":[68,69],"class_list":["post-2174","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-docker","category-virtualisierung","tag-docker","tag-virtualisierung"],"_links":{"self":[{"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/posts\/2174","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/comments?post=2174"}],"version-history":[{"count":1,"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/posts\/2174\/revisions"}],"predecessor-version":[{"id":2186,"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/posts\/2174\/revisions\/2186"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/media\/2185"}],"wp:attachment":[{"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/media?parent=2174"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/categories?post=2174"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/linux-bibel.at\/index.php\/wp-json\/wp\/v2\/tags?post=2174"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}