Linux Containers (LXC), OpenVZ-Templates
(Link zu dieser Seite als [[QEMU-KVM-Buch/ Anhang/ Weitere Virtualisierer und Emulatoren/ LXC]])
Inhaltsverzeichnis |
[bearbeiten] Linux Containers (LXC)
Website: http://lxc.sourceforge.net/
Linux Containers (LXC) ist eine Virtualisierungslösung auf Betriebssystemebene unter Linux. Das Einsatzgebiet ist die Serverkonsolidierung. Bei der Virtualisierung auf Betriebssystemebene teilen sich das Host- und die Gast-Systeme einen Kernel (Single Kernel Image – SKI). Hier wird das Betriebssystem virtualisiert und nicht die Hardware. Das Host-Betriebssystem erzeugt weitere Instanzen seiner selbst. Aus diesem Grund werden nur Gast-Systeme mit dem gleichen Kernel wie das Host-System unterstützt. Da der Overhead gering ist, ist die Ausführungsgeschwindigkeit sehr hoch. Neben LXC gibt es unter Linux noch OpenVZ und Linux-VServer als Lösungen zur Virtualisierung auf Betriebssystemebene. Allerdings wurde nur LXC in den Linux-Kernel ab Version 2.6.27 aufgenommen. Das heißt, für LXC ist kein Kernel-Patch notwendig. Zu empfehlen ist eine Kernel-Version ab 2.6.29.
[bearbeiten] Installation
Unter Ubuntu 10.04 ist das Paket lxc zu installieren. Weiterhin sind die Paket bridge-utils, debootstrap und libcap2-bin notwendig.
Host ~$ sudo apt-get install lxc bridge-utils debootstrap libcap2-bin
Unter Fedora als Host-System wird mit febootstrap ein Container mit Fedora angelegt.
Host ~$ su -c "yum install lxc bridge-utils febootstrap debootstrap"
Die LXC-Version zeigt der Befehl lxc-version an.
Host ~$ lxc-version lxc version: 0.7.2
Für die Zuteilung von System-Ressourcen zu den Containern werden Control Groups (cgroups) verwendet. Falls bei der Installation der Pakete in der Datei /etc/fstab nicht die Zeile none /dev/cgroup cgroup defaults 0 0 eingetragen wurde, aktiviert man die Control Groups mit folgenden Befehlen:
Host ~$ sudo mkdir /dev/cgroup Host ~$ sudo sh -c "echo 'none /dev/cgroup cgroup defaults 0 0' >> /etc/fstab" Host ~$ sudo mount -a
Mit dem Befehl lxc-checkconfig wird die LXC-Unterstützung des Kernels überprüft.
Host ~$ lxc-checkconfig Found kernel config file /boot/config-2.6.32-22-generic
--- Namespaces --- Namespaces: enabled Utsname namespace: enabled Ipc namespace: enabled Pid namespace: enabled User namespace: enabled Network namespace: enabled Multiple /dev/pts instances: enabled
--- Control groups --- Cgroup: enabled Cgroup namespace: enabled Cgroup device: enabled Cgroup sched: enabled Cgroup cpu account: enabled Cgroup memory controller: enabled Cgroup cpuset: enabled
--- Misc --- Veth pair device: enabled Macvlan: enabled Vlan: enabled File capabilities: enabled
Für die Konfiguration des virtuellen Netzwerkes mit bridge-utils ist der Netzwerk-Manager zu deinstallieren (siehe auch http://qemu-buch.de/d/Netzwerkoptionen/_Virtuelle_Netzwerke_konfigurieren).
Host ~$ sudo apt-get remove --purge network-manager network-manager-gnome Host ~$ service networking stop
Die Datei /etc/network/interfaces ist anzupassen. Vorher ist eine Sicherungskopie anzulegen.
Host ~$ sudo cp /etc/network/interfaces /etc/network/interfaces.bak
Es müssen die bisherigen Einträge zu eth0 geändert werden. Die Bridge und damit der Host-Rechner sind in diesem Beispiel über die IP-Adresse 192.168.1.220 erreichbar.
# /etc/network/interfaces
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet manual
auto br0
iface br0 inet static
address 192.168.1.220
netmask 255.255.255.0
broadcast 192.168.1.255
gateway 192.168.1.1
bridge_ports eth0
bridge_stp off
bridge_maxwait 5
post-up /usr/sbin/brctl setfd br0 0
Falls die IP-Adresse per DHCP zugewiesen wird, ist diese Konfiguration anzuwenden:
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet manual
auto br0
iface br0 inet dhcp
bridge_ports eth0
bridge_stp off
bridge_maxwait 5
post-up /usr/sbin/brctl setfd br0 0
up echo "nameserver 192.168.0.1" >> /etc/resolv.conf
Anschließend ist der Netzwerkdienst neu zu starten.
Host ~$ sudo /etc/init.d/networking restart
Zum Test der Konfiguration ist der Rechner neu zu booten.
Host ~$ sudo reboot
[bearbeiten] Anlegen von Containern
Container ermöglichen eine Abschottung der in ihnen gestarteten Prozesse. Dies ist vergleichbar mit einer chroot-Umgebung (siehe http://qemu-buch.de/d/Anhang/_Weitere_Virtualisierer_und_Emulatoren/_chroot). Allerdings bietet LXC eine bessere Isolation und Konfiguration.
[bearbeiten] Eine isolierte Applikation
Ein Container muss nicht ein Betriebssystem beinhalten. Es ist möglich, eine Applikation, in diesem Beispiel /bin/bash, in einem Container auszuführen. Dazu dient der Befehl lxc-execute. Hinter der Option -n ist der Name des Containers anzugeben.
Host ~$ sudo lxc-execute -n test01 /bin/bash Gast ~# ps aux USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.0 0.1 1888 476 pts/0 S 17:37 0:00 /usr/lib/lxc/lxc-init -- /bin/bash root 2 0.5 1.0 5780 3084 pts/0 S 17:37 0:01 /bin/bash root 29 0.0 0.3 2708 1020 pts/0 R+ 17:42 0:00 ps aux Gast ~# exit
[bearbeiten] Die LXC-Konfigurationsdatei
Mit einer Konfigurationsdatei lässt sich unter anderem das Netzwerk konfigurieren. Im folgenden wird eine mitgelieferte Beispiel-Konfigurationsdatei verwendet. Die Syntax der Konfigurationsdatei erläutert der Befehl man lxc.conf.
Host ~$ sudo lxc-execute -n test1 \ -f /usr/share/doc/lxc/examples/lxc-macvlan.conf /bin/bash
Es ist zu empfehlen, für jeden Container ein eigenes Verzeichnis zur Verfügung zu stellen.
Host ~$ sudo mkdir -p /lxcontainers/tests Host ~$ cd /lxcontainers/tests
In diesem Verzeichnis wird die Konfigurationsdatei ip-statisch.conf mit folgenden Inhalt angelegt. Für die statische IP-Adresse ist eine freie IP-Adresse im eigenen Netzwerk auszuwählen.
lxc.utsname = test02 lxc.network.type = veth lxc.network.flags = up lxc.network.link = br0 lxc.network.ipv4 = 192.168.1.150
Die Konfigurationsdatei wird mit der Option -f vorgegeben.
Host ~$ sudo lxc-execute -n test02 -f /lxcontainers/tests/ip-statisch.conf /bin/bash
Gast ~# ifconfig
eth0 Link encap:Ethernet Hardware Adresse 4a:49:43:49:79:bd
inet Adresse:192.168.1.150 Bcast:0.0.0.0 Maske:255.255.0.0
...
Gast ~# exit
Host ~$
[bearbeiten] Linux im Container
Unter Verwendung eines Verzeichnisses mit einem Linux-Dateisystem und einer Konfigurationsdatei lässt sich mit dem Befehl lxc-create ein Container mit einem Linux-System anlegen. Ein Kernel wird nicht benötigt, da sich unter LXC die Gast-Systeme den Kernel mit dem Host-System teilen. Man ist bei der Kernel-Version des Gast-Systems nicht flexibel. Es lassen sich aber zum Host-System abweichende Linux-Distributionen unter LXC betreiben.
Linux-Dateisysteme lassen sich auf unterschiedliche Weise anlegen. Man kopiert zum Beispiel die Verzeichnisse und Dateien eines vorhandenen Linux-Systems. Es können auch Template von OpenVZ verwendet werden. Komfortabel lassen sich Linux-Dateisysteme mit den Tools lxc-busybox, debootstrap (Debian/Ubuntu), lxc-debian (Debian) oder lxc-fedora (Fedora) anlegen. Mit chroot lassen sich die angelegten Linux-Dateisysteme anpassen. Zum Beispiel werden notwendige Software-Pakete installiert. Zu empfehlen ist die Installation eines SSH-Servers für den Remote-Zugriff.
Eine Anpassung der Linux-Dateisysteme ist auch aus weiteren Gründen notwendig. Es sind einige Skripte zur Initialisierung zu ändern oder zu entfernen. Dies betrifft zum Beispiel Dateien in dem Verzeichnis /etc/init und die Datei /etc/inittab. In Abhängigkeit von der Distribution sind noch einige Mount-Points anzulegen und einige Anpassungen an weiteren Konfigurationsdateien notwendig.
Im Container funktioniert udev nicht. udev dient zur Verwaltung von Geräten, die im laufenden Betrieb angeschlossen werden (hotplug). Dazu werden Informationen dem sysfs-Dateisystem entnommen und eine neue Gerätedatei im /dev-Verzeichnis angelegt. udev muss im Container-System deinstalliert werden. Stattdessen müssen die entsprechenden Gerätedateien in dem Verzeichnis /dev manuell angelegt werden. Das Generieren der Devices kann von einem Skript übernommen werden. Dazu wird die Datei /usr/local/bin/lxc-config mit folgenden Inhalt angelegt.
#!/bin/bash
#
# /usr/local/bin/lxc-config
#
# bodhi.zazen's lxc-config
# Makes default devices needed in lxc containers
# modified from http://lxc.teegra.net/
ROOT=$(pwd)
DEV=${ROOT}/dev
if [ $ROOT = '/' ]; then
printf "\033[22;35m\nDO NOT RUN ON THE HOST NODE\n\n"
tput sgr0
exit 1
fi
if [ ! -d $DEV ]; then
printf "\033[01;33m\nRun this script in rootfs\n\n"
tput sgr0
exit 1
fi
rm -rf ${DEV}
mkdir ${DEV}
mknod -m 666 ${DEV}/null c 1 3
mknod -m 666 ${DEV}/zero c 1 5
mknod -m 666 ${DEV}/random c 1 8
mknod -m 666 ${DEV}/urandom c 1 9
mkdir -m 755 ${DEV}/pts
mkdir -m 1777 ${DEV}/shm
mknod -m 666 ${DEV}/tty c 5 0
mknod -m 666 ${DEV}/tty0 c 4 0
mknod -m 666 ${DEV}/tty1 c 4 1
mknod -m 666 ${DEV}/tty2 c 4 2
mknod -m 666 ${DEV}/tty3 c 4 3
mknod -m 666 ${DEV}/tty4 c 4 4
mknod -m 600 ${DEV}/console c 5 1
mknod -m 666 ${DEV}/full c 1 7
mknod -m 600 ${DEV}/initctl p
mknod -m 666 ${DEV}/ptmx c 5 2
exit 0
Das Skript ist ausführbar zu setzen.
Host ~$ sudo chmod u+x /usr/local/bin/lxc-config
Es wird bei Bedarf in dem Dateisystem des Containers ausgeführt (siehe unten).
[bearbeiten] lxc-busybox
Mit dem Shell-Skript lxc-busybox lässt sich ein kleines Linux-System anlegen. Weiterhin wird eine Konfigurationsdatei für LXC generiert. Als Optionen werden der Name (-n) und der Pfad (p) angegeben.
Host ~$ sudo lxc-busybox -n busy01 -p /lxcontainers/busy01 empty password for root, don't forget to change it !
Die Konfigurationsdatei wird mit den Zeilen zur Netzwerkkonfiguration ergänzt.
Host ~$ sudo vi /lxcontainers/busy01/config
lxc.utsname = busy01
lxc.tty = 1
lxc.rootfs = /lxcontainers/busy01/rootfs
lxc.cgroup.devices.deny = a
# /dev/null and zero
lxc.cgroup.devices.allow = c 1:3 rwm
lxc.cgroup.devices.allow = c 1:5 rwm
# consoles
lxc.cgroup.devices.allow = c 5:1 rwm
lxc.cgroup.devices.allow = c 5:0 rwm
lxc.cgroup.devices.allow = c 4:0 rwm
lxc.cgroup.devices.allow = c 4:1 rwm
# /dev/{,u}random
lxc.cgroup.devices.allow = c 1:9 rwm
lxc.cgroup.devices.allow = c 1:8 rwm
lxc.cgroup.devices.allow = c 136:* rwm
lxc.cgroup.devices.allow = c 5:2 rwm
# rtc
lxc.cgroup.devices.allow = c 254:0 rwm
### Manuell zu ergaenzen:
lxc.network.type = veth
lxc.network.flags = up
lxc.network.link = br0
lxc.network.name = eth0
lxc.network.mtu = 1500
lxc.network.ipv4 = 192.168.1.0/24
Mit dem Befehl lxc-create wird ein Container angelegt.
Host ~$ sudo lxc-create -f /lxcontainers/busy01/config -n busy01 'busy01' created
Der Befehl lxc-ls listet alle Container auf.
Host ~$ lxc-ls busy01
Über den Zustand eines Containers informiert der Befehl lxc-info.
Host ~$ sudo lxc-info -n busy01 'busy01' is STOPPED
Das System im Container wird mit dem Befehl lxc-start gestartet.
Host ~$ sudo lxc-start -n busy01 init started: BusyBox v1.13.3 (Ubuntu 1:1.13.3-1ubuntu11) udhcpc (v1.13.3) started Sending discover... Sending select for 192.168.1.242... Lease of 192.168.1.242 obtained, lease time 21600 Please press Enter to activate this console. BusyBox v1.13.3 (Ubuntu 1:1.13.3-1ubuntu11) built-in shell (ash) Enter 'help' for a list of built-in commands. /bin/sh: can't access tty; job control turned off / #
Auf einer zweiten Konsole überprüft man den Status des Containers.
Host ~$ lxc-info -n busy01 'busy01' is RUNNING
Ein Zugriff auf die Text-Konsole des Gast-Systems erfolgt mit dem Befehl lxc-console. Dazu ist derr Name des Containers (-n) und die Konsole (-t) anzugeben.
Host ~$ sudo lxc-console -n busy01 -t 0 Type <Ctrl+a q> to exit the console busy01 login:
Heruntergefahren wird der Container mit dem Befehl lxc-stop.
Host ~$ sudo lxc-stop -n busy01 Host ~$ lxc-info -n busy01 'busy01' is STOPPED
Wird ein Container nicht mehr benötigt, wird er mit dem Befehl lxc-destroy zerstört.
Host ~$ sudo lxc-destroy -n busy01
[bearbeiten] Probleme
Mitunter tauchen diese Fehlermeldungen auf.
Host ~$ sudo lxc-start -n busy01 lxc-start: Device or resource busy - could not unmount old rootfs lxc-start: failed to pivot_root to '/lxcontainers/busy01/rootfs' lxc-start: failed to set rootfs for 'busy01' lxc-start: failed to setup the container
Ursache ist ein Bug, der bei einer separaten Partition für /var auftritt. Eine detaillierte Ausgabe zeigt folgender Befehl.
Host ~$ sudo lxc-start -n busy01 -l DEBUG -o $(tty)
[bearbeiten] Ubuntu 10.04.1 LTS (Lucid Lynx) im Container
In diesem Beispiel erfolgt das Anlegen des Dateisystems mit debootstrap. Vorher wird ein Unterverzeichnis für den Container angelegt.
Host ~$ sudo mkdir -p /lxcontainers/lucid/rootfs Host ~$ cd /lxcontainers/lucid
Mit der anzulegenden Datei /lxcontainers/lucid/fstab werden die Mount-Points definiert. Diese Datei erhält folgenden Inhalt:
# /lxcontainers/lucid/fstab none /lxcontainers/lucid/rootfs/dev/pts devpts defaults 0 0 none /lxcontainers/lucid/rootfs/var/run tmpfs defaults 0 0 none /lxcontainers/lucid/rootfs/dev/shm tmpfs defaults 0 0
Mit debootstrap wird das Gast-System (64-Bit) installiert.
Host ~$ sudo debootstrap --arch amd64 lucid \ /lxcontainers/lucid/rootfs http://archive.ubuntu.com/ubuntu
In der Datei /lxcontainers/lucid/rootfs/lib/init/fstab sind die Zeilen mit /proc, /dev und /dev/pts auszukommentieren.
#<file system> <mount point> <type> <options> <dump> <pass> /dev/root / rootfs defaults 0 1 # none /proc proc nodev,noexec,nosuid 0 0 none /proc/sys/fs/binfmt_misc binfmt_misc nodev,noexec,nosuid,optional 0 0 none /sys sysfs nodev,noexec,nosuid 0 0 none /sys/fs/fuse/connections fusectl optional 0 0 none /sys/kernel/debug debugfs optional 0 0 none /sys/kernel/security securityfs optional 0 0 none /spu spufs gid=spu,optional 0 0 # none /dev devtmpfs,tmpfs mode=0755 0 0 # none /dev/pts devpts noexec,nosuid,gid=tty,mode=0620 0 0 none /dev/shm tmpfs nosuid,nodev 0 0 none /tmp none defaults 0 0 none /var/run tmpfs mode=0755,nosuid,showthrough 0 0 none /var/lock tmpfs nodev,noexec,nosuid,showthrough 0 0 none /lib/init/rw tmpfs mode=0755,nosuid,optional 0 0
Damit das Gast-System einen Namen, zum Beispiel horst, erhält, ist dieser in der Datei /lxcontainers/lucid/rootfs/etc/hostname einzutragen. Weiterhin erhält die Datei /lxcontainers/lucid/rootfs/etc/hosts folgenden Inhalt:
127.0.0.1 localhost horst
Zur weiteren Konfiguration wechselt man mit chroot in die angelegte Umgebung. In dieser Umgebung installiert man das Paket ssh für den SSH-Zugang in dieses Gast-System.
Host ~$ sudo chroot /lxcontainers/lucid/rootfs/ /bin/bash Gast ~# apt-get install ssh
Man legt die Konfiurationsdatei /lxcontainers/lucid/conf Inhalt an. Die Netzwerk-Einstellungen sind den eingenen Bedürfnissen anzupassen.
# /lxcontainers/lucid/conf
lxc.utsname = horst
lxc.tty = 4
lxc.network.type = veth
lxc.network.flags = up
lxc.network.link = br0
lxc.network.hwaddr = 4a:49:43:49:79:be
lxc.network.ipv4 = 192.168.1.50
lxc.network.name = eth0
lxc.network.mtu = 1500
lxc.rootfs = /lxcontainers/lucid/rootfs
lxc.pts = 1024
#
lxc.cgroup.devices.deny = a
# /dev/null and zero
lxc.cgroup.devices.allow = c 1:3 rwm
lxc.cgroup.devices.allow = c 1:5 rwm
# consoles
lxc.cgroup.devices.allow = c 5:1 rwm
lxc.cgroup.devices.allow = c 5:0 rwm
lxc.cgroup.devices.allow = c 4:0 rwm
lxc.cgroup.devices.allow = c 4:1 rwm
# /dev/{,u}random
lxc.cgroup.devices.allow = c 1:9 rwm
lxc.cgroup.devices.allow = c 1:8 rwm
lxc.cgroup.devices.allow = c 136:* rwm
lxc.cgroup.devices.allow = c 5:2 rwm
# rtc
lxc.cgroup.devices.allow = c 254:0 rwm
Nun wird der Container angelegt und gestartet.
Host ~$ sudo lxc-create -n horst /lxcontainers/lucid/conf 'horst' created Host ~$ sudo lxc-start -n horst -d
Man überprüft, ob die virtuelle Maschine läuft.
Host ~$ sudo lxc-info -n horst 'horst' is RUNNING
Ein Zugriff auf die Text-Konsole des Gast-Systems erfolgt mit dem Befehl lxc-console. Dazu ist derr Name des Containers (-n) und die Konsole (-t) anzugeben.
Host ~$ sudo lxc-console -n horst -t 0 Type <Ctrl+a q> to exit the console horst login:
Alternativ loggt man sich per ssh ein.
Host ~$ ssh root@192.168.1.50
Heruntergefahren wird der Container mit dem Befehl lxc-stop.
Host ~$ sudo lxc-stop -n horst Host ~$ lxc-info -n horst 'horst' is STOPPED
[bearbeiten] Ubuntu 9.10 Karmic Koala im Container
In diesem Beispiel erfolgt das Anlegen des Dateisystems mit debootstrap. Vorher wird ein Unterverzeichnis für den Container angelegt.
Host ~$ sudo -i Host ~# cd /lxcontainers Host ~# mkdir ubuntu.karmic-01 Host ~# cd ubuntu.karmic-01 Host ~# debootstrap --variant=minbase karmic rootfs
Die Datei /etc/resolv.conf des Host-Systems wird in das Dateisystem kopiert.
Host ~# cp /etc/resolv.conf rootfs/etc
Das Generieren der Devices wird mit dem oben beschriebenen Skript /usr/local/bin/lxc-config erledigt. Im Verzeichnis des Dateisystems des anzulegenden Containers wird es ausgeführt.
Host ~# cd rootfs Host ~# /usr/local/bin/lxc-config Host ~# cd -
Für den Container wird eine Konfigurationsdatei mit dem Namen config angelegt.
# /lxcontainers/ubuntu.karmic-01/config
lxc.utsname = karmic-01
lxc.tty = 4
lxc.network.type = veth
lxc.network.flags = up
lxc.network.link = br0
lxc.network.name = eth0
lxc.network.mtu = 1500
lxc.network.ipv4 = 192.168.1.0/24
lxc.rootfs = /lxcontainers/ubuntu.karmic-01/rootfs
lxc.cgroup.devices.deny = a
# /dev/null and zero
lxc.cgroup.devices.allow = c 1:3 rwm
lxc.cgroup.devices.allow = c 1:5 rwm
# consoles
lxc.cgroup.devices.allow = c 5:1 rwm
lxc.cgroup.devices.allow = c 5:0 rwm
lxc.cgroup.devices.allow = c 4:0 rwm
lxc.cgroup.devices.allow = c 4:1 rwm
# /dev/{,u}random
lxc.cgroup.devices.allow = c 1:9 rwm
lxc.cgroup.devices.allow = c 1:8 rwm
# /dev/pts/* - pts namespaces are "coming soon"
lxc.cgroup.devices.allow = c 136:* rwm
lxc.cgroup.devices.allow = c 5:2 rwm
# rtc
lxc.cgroup.devices.allow = c 254:0 rwm
Mit dem Befehl chroot wird das Root-Dateisystem angepasst.
Host ~# chroot /lxcontainers/ubuntu.karmic-01/rootfs Gast ~# mount -t devpts devpts /dev/pts Gast ~# mount -t proc proc /proc Gast ~# mount -t sysfs sysfs /sys
Im ersten Schritt ist das Paket gpgv (GNU privacy guard) zu installieren.
Gast ~# apt-get install --force-yes -y gpgv
Es sind weiterhin folgende Pakete notwendig.
Gast ~# apt-get update
Gast ~# apt-get install -y adduser apt-utils iproute netbase \
openssh-blacklist openssh-blacklist-extra openssh-server \
console-setup sudo ping
Wie beschrieben, muss udev entfernt werden.
Gast ~# apt-get remove --purge udev Gast ~# rm -rf /etc/udev /lib/udev Gast ~# apt-get autoremove
Es sind die folgenden Skripte zur Initialisierung zu löschen.
Gast ~# cd /etc/init Gast ~# rm mountall* upstart*
Das Passwort ist zu setzen.
Gast ~# passwd
Man verlässt die chroot-Umgebung.
Gast ~# umount /dev/pts Gast ~# umount /proc Gast ~# umount /sys Gast ~# exit Host ~#
Die Netzwerk-Konfigurationsdatei ist zu bearbeiten:
/lxcontainers/ubuntu.karmic-01/rootfs/etc/network/interfaces
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address 192.168.1.61
netmask 255.255.255.0
broadcast 192.168.1.255
gateway 192.168.1.10
Weitere Anpassungen sind nötig.
Host ~# rm rootfs/etc/init/tty{5,6}.conf
Host ~# mkdir -p rootfs/var/run/network
Host ~# touch rootfs/var/run/network/ifstate
Host ~# echo "karmic-01" > rootfs/etc/hostname
Es ist folgendes Skript anzulegen. Es dient zur Initialisierung des Systems im Container.
/lxcontainers/ubuntu.karmic-01/rootfs/etc/init/lxc.conf
# LXC – Fix init sequence to have LXC working with upstart # description “Fix LXC container - Karmic” start on startup task pre-start script mount -t proc proc /proc mount -t devpts devpts /dev/pts mount -t sysfs sys /sys mount -t tmpfs varrun /var/run mount -t tmpfs varlock /var/lock mkdir -p /var/run/network touch /var/run/utmp chmod 664 /var/run/utmp chown root.utmp /var/run/utmp if [ "$(find /etc/network/ -name upstart -type f)" ]; then chmod -x /etc/network/*/upstart || true fi end script script start networking initctl emit filesystem --no-wait initctl emit local-filesystems --no-wait initctl emit virtual-filesystems --no-wait init 2 end script
Der Container wird erzeugt und gestartet.
Host ~# lxc-create -f /lxcontainers/ubuntu.karmic-01/config -n karmic-01 Host ~# lxc-start -n karmic-01
Auf einer zweiten Konsole verbindet man sich mit dem Konsole des Containers.
Host 2.Konsole ~$ sudo lxc-console -n karmic-01
Alternativ loggt man sich per ssh von einem beliebigen Rechner im Netzwerk ein.
~$ ssh root@192.168.1.61
Mit dem Befehl lxc-stop wird das System im Container heruntergefahren.
Host 2.Konsole ~$ sudo lxc-stop -n karmic-01
Ist das System installiert und konfiguriert, sichert man es. Mit dem angelegten Archiv lässt ein Template bereitstellen.
Host ~# cd /lxcontainers/ Host ~# tar czf ubuntu.karmic-01.tar.gz ubuntu.karmic-01
Im_Aufbau
[bearbeiten] Fedora im Container mit lxc-fedora
Unter Fedora steht das Skript lxc-fedora zum Generieren von Containern mit Fedora zur Verfügung. Im folgenden Beispiel wird ein Container mit dem Namen fedora01 generiert.
Host ~$ su - Host ~# mkdir -p mkdir -p /lxcontainers/fedora01 Host ~# cd /lxcontainers/fedora01 Host ~# lxc-fedora create What is the name for the container ? [fedora] fedora01 What hostname do you wish for this container ? '[fedora01] What IP address do you wish for this container ? [172.20.0.21] 192.168.1.123 What is the gateway IP address ? [172.20.0.1] 192.168.1.1 What is the MTU size ? [1500]
Das System im Container wird mit dem Befehl lxc-start gestartet.
Host ~# lxc-start -n fedora01
[bearbeiten] Die Userspace-Emulation von QEMU
Die Userspace-Emulation von QEMU (siehe http://qemu-buch.de/d/Spezielle_QEMU-Optionen#Userspace-Emulation) kann mit LXC kombiniert werden. Bei der Userspace-Emulation wird kein vollständiger PC emuliert, sondern es wird die Verwendung von anderen dynamischen Bibliotheken unterstützt. Dadurch können Programme gestartet werden, die eigentlich für Bibliotheken anderer Architekturen kompiliert wurden. Zuerst ist QEMU zu installieren. Weiterhin benötig man Beispiele von Bibliotheken und Binaries für diverse Architekturen. Diese können von der QEMU-Website http://wiki.qemu.org/Download, unter dem Punkt QEMU Linux user mode emulation tests heruntergeladen werden.
Host ~$ sudo apt-get install qemu-kvm qemu-kvm-extras Host ~$ sudo mkdir -p /lxcontainers/qemu-userspace-emulation Host ~$ sudo chown `whoami` /lxcontainers/qemu-userspace-emulation/ Host ~$ cd /lxcontainers/qemu-userspace-emulation/ Host ~$ wget http://wiki.qemu.org/download/linux-user-test-0.3.tar.gz Host ~$ tar xzvf linux-user-test-0.3.tar.gz Host ~$ cd linux-user-test-0.3
Es ist die Datei userspace.sh mit folgenden Inhalt anzulegen.
#!/bin/bash /usr/bin/qemu-arm -L gnemul/qemu-arm/ arm/uname -a
Dieses Skript ist ausführbar zu machen.
Host ~$ chmod +x userspace.sh
Das Skript wird in einem Container gestartet.
Host ~$ sudo lxc-execute -n qemu-userspace01 ./userspace.sh Linux schlappi 2.6.32-22-generic #33-Ubuntu SMP Wed Apr 28 13:27:30 UTC 2010 armv7l unknown
Wie man sieht, ist es durch die Kombination von LXC und der Userspace-Emulation von QEMU möglich, Bibliotheken und Binaries anderer Prozessor-Architekturen unter LXC zu nutzen.
[bearbeiten] Weitere Befehle
Host ~$ sudo lxc-netstat -n busy01 Host ~$ sudo lxc-ps -n busy01
lxc-checkpoint lxc-netstat lxc-setcap lxc-unfreeze lxc-wait lxc-cgroup lxc-ls lxc-ps lxc-unshare lxc-checkconfig lxc-freeze lxc-monitor lxc-restart
[bearbeiten] Verbinden zu einem Container
[bearbeiten] ssh
[bearbeiten] vnc
Host ~# echo '/usr/bin/vnc4server :0 -geometry 1024x768 -depth 24' >> /lxcontainers/testus/etc/rc.local Gast ~# apt-get install vnc4server fluxbox Host ~$vncviewer ip:display