Verwendung von Linux-Containern mit LXC und LXD

In der guten alten Zeit bedeutete die Installation eines Betriebssystems, alle Hardwarekomponenten zusammenzuführen, Ihren neuen Computer mit einer Installationsdiskette in einem Peripherie-Laufwerk zu starten und den Installationsprozess zu lösen. Die insgesamt verstrichene Zeit kann zwischen Stunden und Wochen liegen.

Heutzutage kann ich mir sagen: "Es würde mir nichts ausmachen, das auf einem Server zu testen, auf dem eine bestimmte Version von CentOS ausgeführt wird." Abhängig von einer Reihe von Variablen und der Annahme, dass das Originalbild bereits heruntergeladen wurde, kann ich ein voll funktionsfähiges Bild haben virtuelles System innerhalb von 30 Sekunden bereit. Ihre genauen Ergebnisse können variieren, aber nicht so stark.

Wie das alles funktioniert, können Sie in meinem neuen Pluralsight-Kurs "Linux-Systemoptimierung" sehen, auf dem dieser Artikel basiert.

Was hat all diese Veränderungen vorangetrieben? Virtualisierung. Und insbesondere die Containervirtualisierung.

Ein virtualisiertes Betriebssystem ist ein Dateisystem, das alle Softwarebibliotheken, Binärdateien und Konfigurationsdateien enthält, die Sie zum Starten eines herkömmlichen Computers benötigen würden. Es ist nur so, dass dieses bestimmte Dateisystem nicht in der Root- oder Boot-Partition gespeichert ist, die Ihr Computer beim Einschalten lesen würde, sondern auf einem anderen Teil Ihres Speichervolumens.

Und das "Einschalten" Ihres virtuellen Computers geschieht, wenn eine Software die Dateien geschickt täuscht und denkt, sie würden ganz alleine auf ihrer eigenen Hardware ausgeführt, wenn sie wirklich Speicherplatz und Ressourcen mit dem Host-Betriebssystem und möglicherweise einem anderen teilen virtuelle Computer.

Grundsätzlich gibt es zwei Arten von Softwaresystemen, die für die Verwaltung der Servervirtualisierung verwendet werden: Hypervisor und Container.

Hypervisoren bieten eine Abstraktionsebene, mit der Gast-VMs eine isolierte Umgebung mit Zugriff auf die Systemhardware erstellen können, die einen Bare-Metal-Server emuliert. Dies bedeutet, dass Hypervisor-VMs von jedem Betriebssystem aus erstellt werden können, das mit Ihrer zugrunde liegenden Hardware kompatibel ist. Es bedeutet aber auch, dass sie mehr Speicherplatz und mehr Speicher verbrauchen und Ressourcen berechnen.

Containervirtualisierung

Container hingegen teilen sich den Betriebssystemkern des Host-Computers und befinden sich in sorgfältig gesicherten und isolierten Bereichen, die von Systemtools wie cgroups verwaltet werden. Da sie den Kernel gemeinsam nutzen, können die von Containern verbrauchten Speicher- und Systemressourcen sehr gering sein, ohne dass etwas verschwendet wird. Und wie Sie sehen werden, sind die Geschwindigkeiten, mit denen Sie Containeranwendungen ausführen, atemberaubend.

In den letzten Jahren wurde viel Aufmerksamkeit im Zusammenhang mit Containern auf Docker und in jüngerer Zeit auf das Container-Orchestrierungs-Tool von Google, Kubernetes, gerichtet. Tatsächlich eignet sich Kubernetes gut für Microservices-Architekturen im Unternehmensmaßstab.

Aber es gibt eine ältere und wohl ausgereiftere Implementierung des Containermodells, die nirgendwo hingegangen ist. Das Linux Container Project, LXC, und sein neueres Toolset, LXD, haben Stärken, von denen viele behaupten würden, dass es für einige Anwendungsfälle ein besserer Kandidat ist als Kubernetes. LXC zeichnet sich insbesondere durch das Erstellen leichter und schneller Sandbox-Umgebungen zum Testen und zur Anwendungsentwicklung aus.

In diesem Artikel werde ich Ihnen zeigen, wie Sie LXD installieren, einen einfachen Container vorbereiten und starten, auf dem das ultrakleine Alpine Linux ausgeführt wird, und dann eine Shell-Sitzung in Ihrem neuen Container öffnen. Ich werde auch erklären, wie Sie mehrere Versionen anderer Distributionen finden und starten.

Eine Sache, die ich Ihnen sofort sagen kann, ist, dass die Schüler jedes Mal, wenn ich LXC unterrichte, erstaunt darüber reagieren, wie leistungsfähig und effizient die Verwendung von Containern sein kann.

Wenn wir mit all dem fertig sind, können Sie Maschinen starten, um innerhalb von Sekunden zu testen, was Sie gerade lernen oder arbeiten. Wenn ein Experiment fehlschlägt, können Sie einen Container sofort herunterfahren, entfernen und einen anderen bauen, um ihn zu ersetzen. Es gibt einfach keine Entschuldigung mehr, nicht zu lernen.

Erstellen von LXD-Containern

Wir werden LXC zum Laufen bringen und an einer Neuinstallation eines Ubuntu 18.04-Computers arbeiten. In dieser Demo installieren und initialisieren wir eine LXD-Umgebung und verwenden dann die LXD-Version der LXC-Befehlszeilenschnittstelle, um einen Alpine Linux-Container herunterzuladen und zu starten. Wir werden bestätigen, dass alles funktioniert hat, und uns dann ein wenig umschauen, um zu sehen, wie die Umgebung besiedelt ist.

Ich werde den Snap-Paket-Manager verwenden, um LXD zu installieren, da dies jetzt die offizielle Empfehlung ist. Und das nicht nur für LXD, wohlgemerkt: Alle Arten von Anwendungen wechseln zu alternativen Managern wie Snap oder AppImmage und Flatpak. Ich liebe immer noch meine Debian-Begabung, aber du kannst nicht die ganze Welt bekämpfen.

$ sudo snap install lxd 

LXD - wiederum ein aktualisiertes Toolset zur Verwaltung der LXC-API - wird in einem Paket geliefert, das alle regulären LXC-Abhängigkeiten enthält. Ein Installationsbefehl und wir sind fertig.

Es ist wichtig, die LXC-Umgebung mit dem Befehl lxd init zu initialisieren. Sie könnten die Dinge selbst manuell einrichten, aber es ist wahrscheinlicher, dass Sie auf diese Weise alles richtig machen. Der Init-Prozess stellt Ihnen eine Reihe von Fragen, und zumindest für den Moment funktionieren alle Standardantworten.

$ sudo lxd init 

Sobald dies erledigt ist, können wir Ihren ersten Container bauen. Unabhängig von der gewünschten Linux-Distribution und -Version müssen wir das Image finden und herunterladen. Das LXC-Projekt unterhält unter images.linuxcontainers.org ein Repository mit einer Reihe von Bildern. Sie können sehen, dass es normalerweise mehrere Versionen jeder Distribution gibt, sodass Sie Container erstellen können, die mit nahezu jeder Software funktionieren, die Sie darauf werfen können.

Ich werde die neueste Version von Alpine Linux verwenden, weil sie sehr klein ist. Fühlen Sie sich frei, jedes Bild zu verwenden, das Sie mögen - einschließlich der großen Jungs wie Ubuntu und CentoOS. Alpine wird natürlich sehr schnell heruntergeladen.

Aber bevor wir das tun, sollte ich Ihnen sagen, wie Sie die Befehlszeilensyntax herausfinden, die erforderlich ist, um Ihr Image zu erhalten.

Wie Sie in diesem Screenshot von der LXD-Website sehen können, erhalten Sie drei Informationen, die Sie auf der Seite selbst benötigen: den Namen der Distribution - Alpine, in diesem Fall - die Versionsnummer - 3.10 - und die Architektur . Wir sind nach amd64.

Wir sind jetzt bereit, den Download durch Ausführen des folgenden launchBefehls auszulösen :

$ sudo lxc launch images:alpine/3.10/amd64 demo 

Beachten Sie, dass die Syntax "lxc" lautet, obwohl dies technisch gesehen eine LXD-Schnittstelle ist. "images" sagt LXC, dass unser Bild in dem öffentlichen Repo lebt, das wir zuvor gesehen haben. Unsere drei Datenbits - der Name der Distribution, die Versionsnummer und die Architektur - werden getrennt durch Schrägstriche eingegeben. Ich werde "Demo" als Namen meines Containers verwenden. Das sollte alles sein, was wir brauchen.

Wie klein Alpine ist, können Sie daran erkennen, wie schnell es heruntergeladen wird. Meine Internetverbindung ist nicht so schnell und ich habe mit der Aufnahme keine Spiele gespielt. Um zu bestätigen, dass es funktioniert hat, führe ich "lxc ls" aus, um alle derzeit installierten Container aufzulisten. Da ist nur der eine. Und sein aktueller Status ist "läuft".

sudo lxc ls +------+---------+----------------------+------------+-----------+ | NAME | STATE | IPV4 | TYPE | SNAPSHOTS | +------+---------+----------------------+------------+-----------+ | demo | RUNNING | 10.125.45.119 (eth0) | PERSISTENT | 0 | +------+---------+----------------------+------------+-----------+ 

Mit dem Befehl "lxc exec" können Sie eine Nicht-Login-Root-Sitzung in einem Container öffnen. Geben Sie einfach den Containernamen an und teilen Sie LXC mit, dass Sie eine Shell mit dem sh-Interpreter ausführen möchten (möglicherweise bevorzugen /bin/bashSie, wenn Sie mit einem Ubuntu- oder CentOS-Container arbeiten - Ihr Aufruf in beide Richtungen). Wie Sie selbst sehen können, wenn Sie zu Hause mitmachen, haben wir eine normale Linux-Eingabeaufforderung und alles, was Linux-y ist, ist jetzt möglich.

$ sudo lxc exec demo sh ~ # 

You could also run a single command without opening a full shell by typing the command instead of this sh.

$ sudo lxc exec demo ls / bin etc lib mnt proc run srv tmp var dev home media opt root sbin sys usr 

You can bail out of the shell any time you like using exit and return to your host. Here, besides listing running containers, I can also list any storage pools. The default pool that was created during initialization is there, and we can see where the disk image is stored. /var/lib/lxd is, by default, where all LXC resources are kept.

$ sudo lxc storage ls +---------+-------------+--------+--------------------------------+---------+ | NAME | DESCRIPTION | DRIVER | SOURCE | USED BY | +---------+-------------+--------+--------------------------------+---------+ | default | | btrfs | /var/lib/lxd/disks/default.img | 3 | +---------+-------------+--------+--------------------------------+---------+ 

I can similarly list all my networks. There happen to be a few network bridges on this system (I've been playing around a bit, as you can see). There's also the physical enp0s3 bridge used by the host Ubuntu server. Although between you and me, that one's not physical either, as this is actually a VM running in Oracle's Virtual Box.

$ lxc network ls +---------+----------+---------+-------------+---------+ | NAME | TYPE | MANAGED | DESCRIPTION | USED BY | +---------+----------+---------+-------------+---------+ | enp0s3 | physical | NO | | 1 | +---------+----------+---------+-------------+---------+ | lxdbr0 | bridge | YES | | 1 | +---------+----------+---------+-------------+---------+ | mynet | bridge | YES | | 0 | +---------+----------+---------+-------------+---------+ | testbr0 | bridge | YES | | 1 | +---------+----------+---------+-------------+---------+ 

If we needed to, we could easily add a new virtual interface to our container using the "lxc network attach" command. Here, I'll specify the physical network and then the name of our container.

$ lxc network attach enp0s3 demo 

With that done, you could open a new shell in the container to see what's changed. There should now be an eth1 interface listed. You may need to reboot for all the changes to take full effect. By doing that you can also marvel at just how fast this thing can reboot itself - for all intents and purposes, it'll happen faster than you can type your exec command to open a new shell.

Enjoy your new environment!

This article is based on content in my Pluralsight course, "Linux System Optimization." There's much more administration goodness in the form of books, courses, and articles available at bootstrap-it.com.