Verwalten von Linux-Containern mit Docker auf Ubuntu

Version: 1.0
Autoren: Srijan Kishore
Zuletzt bearbeitet: 02 /Jul/2014

Dieser Leitfaden erklärt, wie man Docker installiert und virtuelle Maschinen effektiv verwaltet. Docker ist eine Open Source Linux-Virtualisierungsplattform für Entwickler und Systemadministratoren, um verteilte Anwendungen einfach zu erstellen, bereitzustellen und auszuführen. Docker besteht aus der Docker Engine, einer leichten Laufzeit- und Virtualisierungsschicht, Werkzeugen zum Verpacken und Versionieren virtueller Maschinen, ähnlich einem Quellcode-Repository, und Docker Hub, einem Cloud-Dienst zum Teilen von Anwendungen und Automatisierung von Workflows. Docker ermöglicht es, Anwendungen schnell aus Komponenten zusammenzustellen und beseitigt Reibungen zwischen Entwicklungsumgebungen, Qualitätskontrolle und Produktion.

1 Vorbemerkung

In meinem Fall habe ich Ubuntu 14.04, auf dem ich Docker installieren werde. Auf dem Markt für Virtualisierungssoftware stehen uns mehrere vollständige Hardware-Virtualisierungstechnologien wie KVM, Xen oder Hyper-V zur Verfügung. Aber die vollständigen Virtualisierungen sind zu schwer, um einzelne Anwendungen unter Linux zu virtualisieren. Wir können diese Situation überwinden, indem wir Linux-Container verwenden, die eine gute Alternative zur Virtualisierung auf Betriebssystemebene darstellen. Linux-Container sind sehr nützlich, um eine Entwicklungs-/Testumgebung in einem gesicherten Bündel von Containern zu haben. Docker bietet eine Linux-Container-Umgebung für diesen Zweck.

2 Installation

Wie ich oben erwähnt habe, habe ich Ubuntu, auf dem ich Docker installieren werde. In diesem Kapitel zeige ich Ihnen 2 Optionen zur Installation von Docker. In 2a verwende ich die Docker-Version aus dem Ubuntu-Repository, diese Version wird von Ubuntu für die vollen 5 Jahre LTS-Support gepflegt, ist jedoch nicht die neueste Version. In 2b werde ich die neueste Version aus dem Ubuntu PPA-Repository verwenden. Da Docker sich in einer intensiven Entwicklung befindet, wird die neueste Docker-Version aus 2b) höchstwahrscheinlich den meisten Benutzern entsprechen. Bitte verwenden Sie entweder Methode 2a oder 2b, aber nicht beide gleichzeitig!

2a Installation aus dem offiziellen Ubuntu-Repository

Um zu installieren, verwenden Sie:

sudo apt-get update  
sudo apt-get install docker.io

und erstellen Sie einen Symlink, um die Verwendung in der Shell zu erleichtern.

sudo ln -sf /usr/bin/docker.io /usr/local/bin/docker  
sudo sed -i '$acomplete -F _docker docker' /etc/bash_completion.d/docker.io

2b Neueste Docker-Version installieren

Um die neueste Docker-Version aus dem docker.io-Repository zu installieren, führen Sie diesen Befehl aus:

curl -s https://get.docker.io/ubuntu/ | sudo sh

3 Vorbereiten der Shell-Umgebung

Jetzt werde ich meinen Benutzer=srijan zur Docker-Gruppe hinzufügen:

sudo usermod -a -G docker srijan

Oder verwenden Sie:

sudo usermod -a -G docker $USER

Hier werde ich meine aktuelle Sitzung abmelden und mich erneut anmelden. Jetzt werde ich die Docker-Konfigurationsdatei hinzufügen, um das System über ihren Standort zu benachrichtigen.

sudo vi /etc/default/docker.io

| DOCKER="/usr/bin/docker.io" |

Jetzt starten Sie den Dienst wie folgt neu:

sudo service docker.io restart

4 Containerverwaltung

Ich werde einen Container mit dem Ubuntu-Betriebssystem starten. Ich werde das Docker-Image wie folgt herunterladen:

docker pull ubuntu

Hinweis: pull wird verwendet, um ein Image oder ein Repository aus dem Registry zu ziehen

Jetzt werde ich mich in die Bash-Shell des Ubuntu-Containers einloggen, indem ich:

docker run -i -t ubuntu /bin/bash

Nur zur Bestätigung werde ich meine Container-IP wie folgt überprüfen:

root@fd98ee950252:/# ifconfig 
eth0      Link encap:Ethernet  HWaddr 5a:a6:c6:88:f2:48  
          inet addr:172.17.0.3  Bcast:0.0.0.0  Mask:255.255.0.0
          inet6 addr: fe80::58a6:c6ff:fe88:f248/64 Scope:Link
          UP BROADCAST RUNNING  MTU:1500  Metric:1
          RX packets:7 errors:0 dropped:2 overruns:0 frame:0
          TX packets:8 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:558 (558.0 B)  TX bytes:648 (648.0 B)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

root@fd98ee950252:/#

Ich habe eine IP von 172.17.0.3 in meinem Container. Ebenso kann ich auch andere Container verwenden. Um den Container zu verlassen, geben Sie einfach ein:

exit

Ebenso können Sie andere OS-Container haben, z.B.

Ich möchte einen Debian-Container verwenden, ich werde den Code verwenden:

docker run -i -t debian /bin/bash

Wenn Sie eine bestimmte Distribution haben möchten, verwenden Sie:

docker run -i -t ubuntu:12.04 /bin/bash

Es wird den ubuntu12.04-Container erstellen. Ich werde es wie folgt überprüfen:

root@44b56100fd1f:/# cat /etc/lsb-release 
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=12.04
DISTRIB_CODENAME=precise
DISTRIB_DESCRIPTION="Ubuntu 12.04.4 LTS"
root@44b56100fd1f:/#

4 Erstellen eigener Images

Es gibt zwei Möglichkeiten, ein Docker-Image zu erstellen:

Über den Befehl docker commit
Über den Befehl docker build mit einer Dockerfile

Die Methode docker commit wird derzeit nicht empfohlen, da das Erstellen mit einer Dockerfile viel flexibler und leistungsfähiger ist, aber wir werden sie Ihnen der Vollständigkeit halber demonstrieren. Danach werde ich mich auf die empfohlene Methode zum Erstellen von Docker-Images konzentrieren: das Schreiben einer Dockerfile und die Verwendung des docker build-Befehls.

4.1 Verwendung von Docker commit zum Erstellen von Images

Ich werde einen Container erstellen, Änderungen an diesem Container vornehmen, wie Sie Code ändern würden, und dann diese Änderungen in ein neues Image übernehmen.

Lassen Sie uns mit der Erstellung eines Containers aus dem Ubuntu-Image beginnen, das wir in der Vergangenheit verwendet haben.

docker run -i -t ubuntu /bin/bash  
root@73527b8b4261:/#

Hinweis: Bitte beachten Sie, dass root oben den Hostnamen 73527b8b4261 anzeigt, es ist der erstellte Containername und wird in Ihrem Fall unterschiedlich sein.

Darüber hinaus werde ich Apache darin installieren:

apt-get install apache2

Ich habe den Container gestartet und dann Apache darin installiert. Jetzt werde ich diesen Container als Webserver verwenden, also werde ich ihn in seinem aktuellen Zustand speichern.
Das wird uns ersparen, ihn mit Apache jedes Mal neu zu erstellen, wenn ich einen neuen Container erstelle. Dazu werde ich den Container mit dem Befehl exit verlassen,
und den Befehl docker commit verwenden.

exit

docker commit 73527b8b4261 srijan/apache2 8ce0ea7a1528

Hinweis: Hier ist 73527b8b4261 mein Containername und ich verwende 8ce0ea7a1528 als Tag für den Container, Sie können einen beliebigen Tag-Namen vergeben oder denselben verwenden.

Angenommen, Sie haben die ID des zuletzt erstellten Containers vergessen, können Sie verwenden:

docker ps -l -q

Es wird 73527b8b4261 ergeben.

Hinweis: 73527b8b4261 ist Ihr zuletzt erstellter Containername, er wird in Ihrem Fall unterschiedlich sein.*

Lassen Sie uns unser neues Image ansehen. Es kann wie folgt erreicht werden:

docker images srijan/apache2

srijan@vboxtest:~$ docker images srijan/apache2
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
srijan/apache2      8ce0ea7a1528        741155868ac8        vor 6 Minuten       207.2 MB
srijan@vboxtest:~$

Hinweis: Hier war 8ce0ea7a1528 der Tag-Name, den ich beim Speichern des Containers verwendet habe,   
Hinweis: 741155868ac8 ist die IMAGE ID dieses Containers  
Hinweis: All diese Werte werden in Ihrem Fall unterschiedlich sein, da Docker beim Speichern des Containers zufällige Namen generiert.

Jetzt werde ich das angepasste Image wie folgt speichern:

docker commit -m="Ein neues benutzerdefiniertes Image" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver

Es wird folgendes Ergebnis liefern:

srijan@vboxtest:~$ docker commit -m="Ein neues benutzerdefiniertes Image" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver
f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec

Um einen Container aus unserem neuen Image auszuführen, können wir dies mit dem docker run-Befehl tun.

docker run -t -i srijan/apache2:webserver /bin/bash

Wir können unser übergebenes Image wie folgt überprüfen:

docker inspect srijan/apache2:webserver

srijan@vboxtest:~$ docker inspect srijan/apache2:webserver
[{
    "Architecture": "amd64",
    "Author": "Srijan Kishore",
    "Comment": "Ein neues benutzerdefiniertes Image",
    "Config": {
        "AttachStderr": false,
        "AttachStdin": false,
        "AttachStdout": false,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "",
        "Image": "",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": false,
        "PortSpecs": null,
        "StdinOnce": false,
        "Tty": false,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Container": "73527b8b42614f6ecd83fb5f9822d6086988d3b68fd5e32b4afbc7cd415402fd",
    "ContainerConfig": {
        "AttachStderr": true,
        "AttachStdin": true,
        "AttachStdout": true,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "73527b8b4261",
        "Image": "ubuntu",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": true,
        "PortSpecs": null,
        "StdinOnce": true,
        "Tty": true,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Created": "2014-06-30T12:58:04.973349049Z",
    "DockerVersion": "1.0.1",
    "Id": "f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec",
    "Os": "linux",
    "Parent": "ef83896b7fb99b00b9e0e6ac943826386e7edcef11a3a2f58b42011ab4a4e683",
    "Size": 14463026
}
]srijan@vboxtest:~$

Um einen Container aus unserem neuen Image auszuführen, können wir dies mit dem docker run-Befehl tun.

docker run -t -i srijan/apache2:webserver /bin/bash