qemu, kvm, xen & libvirtHauptseite | Über | Hilfe | FAQ | Spezialseiten | Anmelden

Druckversion | Impressum | Datenschutz

Linux Containers (LXC), OpenVZ-Templates

(Link zu dieser Seite als [[QEMU-KVM-Buch/ Anhang/ Weitere Virtualisierer und Emulatoren/ LXC]])

<<<|###| >>> | English


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
[bearbeiten] VT

<<<|###| >>>

Von „http://qemu-buch.de/de/index.php?title=QEMU-KVM-Buch/_Anhang/_Weitere_Virtualisierer_und_Emulatoren/_LXC

Diese Seite wurde bisher 25.718 mal abgerufen. Diese Seite wurde zuletzt am 19. Januar 2013 um 18:10 Uhr geändert. Inhalt ist verfügbar unter der GNU Free Documentation License 1.2.


Finden

Blättern

News

Deutsch
Weitersagen
Tipps für Autoren
Autoren
Impressum


English
Recommendation
The Authors
Contact



Letzte Änderungen


Ändern
Seite bearbeiten
Bearbeitungshilfe
Seitenoptionen
Diskussion
Kommentar hinzufügen
Druckversion
Seitendaten
Versionen
Links auf diese Seite
Änderungen an verlinkten Seiten
Meine Seiten
Anmelden
Spezialseiten
Neue Seiten
Dateiliste
Statistik
Kontakt
Mehr …