Schlagwort: openQRM

Kategorien
Tutorials

Einrichten der openQRM Cloud für das Deployment von physikalischen Windows Systemen auf CentOS 5.5

Dieses Tutorial zeigt Schritt für Schritt, wie eine openQRM Cloud auf CentOS 5.5 so eingerichtet wird, dass damit anschließend physikalische Windows Systeme deployed werden können. Für dieses Tutorial werden dazu zwei physikalische Systeme benötigt.

1. Los geht es mit einer neuen CentOS 5.5 Installation

Während der Installation des Systems nehmen wir eine manuelle Partitionierung vor und erstellen 3 Partitionen:

    1. primary ext3 mounted at / (the rootfs)
    2. primary swap
    3. primary “lvm” (wird zum Speichern des Server-Image benötigt)

An dieser Stelle ist es wichtig zu beachten, ein benutzerspezifisches Partitionsschema zu wählen und eine dedizierte Partition zu erstellen, auf der später die Server-Images gespeichert werden. (/dev/hda3). Bei der Paketauswahl selektieren wird zudem das “Gnome Desktop Environment”. Weitere Software wird nicht benötigt.

Wichtig: SELinux und die Firewall müssen deaktiviert werden!

Wenn die Installation abgeschlossen ist, starten wir das System neu und melden uns an.

Die folgende Konsolenausgabe zeigt die exakte CentOS Version. Alle Konsolenbefehle in diesem Tutorial werden des Weiteren mit „root“ ausgeführt.

[root@cloud ~]# lsb_release -a
LSB Version: :core-3.1-ia32:core-3.1-noarch:graphics-3.1-ia32:graphics-3.1-noarch
Distributor ID: CentOS
Description: CentOS release 5.5 (Final)
Release: 5.5
Codename: Final
[root@cloud ~]#

2. Vorbereiten des Netzwerks

Nun bearbeiten wir die /etc/sysconfig/network-scripts/ifcfg-eth0 und tragen eine statische, private IP-Adresse ein. (In diesem Beispiel: 192.168.88.6)

[root@cloud network-scripts]# cat /etc/sysconfig/network-scripts/ifcfg-eth0
DEVICE=eth0
BOOTPROTO=none
HWADDR=00:02:b3:a0:d3:12
ONBOOT=yes
DHCP_HOSTNAME=cloud
IPADDR=192.168.88.6
NETMASK=255.255.255.0
GATEWAY=192.168.88.1
TYPE=Ethernet
[root@cloud network-scripts]#

Um die Änderungen zu übernehmen, starten wir das Netzwerk neu.

[root@cloud network-scripts]# /etc/init.d/network restart
Shutting down interface eth0: [ OK ]
Shutting down loopback interface: [ OK ]
Bringing up loopback interface: [ OK ]
Bringing up interface eth0:
[ OK ]
[root@cloud network-scripts]#

Nun hinterlegen wir die statische IP-Adresse (in unserem Fall “192.168.88.6″) und den Hostname (in unserem Fall “cloud”) in der /etc/hosts. Der Hostname darf hierbei nicht in der ersten Zeile zusammen mit 127.0.0.1 stehen!

[root@cloud ~]# cat /etc/hosts
# Do not remove the following line, or various programs
# that require network functionality will fail.
127.0.0.1 localhost.localdomain localhost
192.168.88.6 cloud
::1 localhost6.localdomain6 localhost6
[root@cloud ~]#

3. Vorbereiten des Speicherplatz für die Server-Images

Nun bereiten wir die dedizierte Partition so vor, dass sie zusammen mit lvm genutzt werden kann. Anschließend erstellen wir eine Logical Volume Group “vol”.

[root@cloud ~]# pvcreate /dev/hda3
Physical volume "/dev/hda3" successfully created
[root@cloud ~]# vgcreate vol /dev/hda3
Volume group "vol" successfully created
[root@cloud ~]# vgs
VG #PV #LV #SN Attr VSize VFree
vol 1 0 0 wz--n- 186.22G 186.22G
[root@cloud ~]#

4. Installation des Enterprise iSCSI Target

Seitdem CentOS das „ietd“ (Enterprise iSCSI Target) nicht mehr als Standard RPM Paket unterstützt, müssen wir dieses nun aus den Sourcen erstellen.

[root@cloud ~]# yum -y install kernel-devel openssl-devel gcc rpm-build
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
.... 
Complete!
[root@cloud ~]#

Wir erstellen ein ietd Verzeichnis und laden und entpacken die letzte iscsi-target-[version].tar.gz Version von http://iscsitarget.sourceforge.net

[root@cloud ~]# mkdir ietd
[root@cloud ~]# cd ietd/
[root@cloud ietd]# wget http://sourceforge.net/projects/iscsitarget/files/iscsitarget/1.4.20.1/iscsitarget-1.4.20.1.tar.gz/
.... 
2002-06-10 20:41:12 (245 KB/s) - `iscsitarget-1.4.20.1.tar.gz' saved [137487/137487]
[root@cloud ietd]# tar -xzf iscsitarget-1.4.20.1.tar.gz
[root@cloud ietd]# cd iscsitarget-1.4.20.1

Kompilieren:

[root@cloud iscsitarget-1.4.20.1]# make
Applying Patch compat-2.6.32.patch
patching file kernel/conn.c
Applying Patch compat-2.6.31.patch
.... 
CC [M] /root/ietd/iscsitarget-1.4.20.1/kernel/seq_list.o
LD [M] /root/ietd/iscsitarget-1.4.20.1/kernel/iscsi_trgt.o
Building modules, stage 2.
MODPOST
CC /root/ietd/iscsitarget-1.4.20.1/kernel/iscsi_trgt.mod.o
LD [M] /root/ietd/iscsitarget-1.4.20.1/kernel/iscsi_trgt.ko
make[1]: Leaving directory `/usr/src/kernels/2.6.18-194.3.1.el5-i686'

Installieren:

[root@cloud iscsitarget-1.4.20.1]# make install
`usr/ietd' -> `/usr/sbin/ietd'
`usr/ietadm' -> `/usr/sbin/ietadm'
`etc/initd/initd.redhat' -> `/etc/init.d/iscsi-target'
install: creating directory `/etc/iet'
`etc/ietd.conf' -> `/etc/iet/ietd.conf'
`etc/initiators.allow' -> `/etc/iet/initiators.allow'
`etc/targets.allow' -> `/etc/iet/targets.allow'
`doc/manpages/ietadm.8' -> `/usr/share/man/man8/ietadm.8'
`doc/manpages/ietd.8' -> `/usr/share/man/man8/ietd.8'
`doc/manpages/ietd.conf.5' -> `/usr/share/man/man5/ietd.conf.5'
install: creating directory `/usr/share/doc/iscsitarget'
`ChangeLog' -> `/usr/share/doc/iscsitarget/ChangeLog'
`COPYING' -> `/usr/share/doc/iscsitarget/COPYING'
`RELEASE_NOTES' -> `/usr/share/doc/iscsitarget/RELEASE_NOTES'
`README' -> `/usr/share/doc/iscsitarget/README'
`README.vmware' -> `/usr/share/doc/iscsitarget/README.vmware'
`README.initiators' -> `/usr/share/doc/iscsitarget/README.initiators'
`kernel/iscsi_trgt.ko' -> `/lib/modules/2.6.18-194.3.1.el5/extra/iscsi/iscsi_trgt.ko'
Running depmod
[root@cloud iscsitarget-1.4.20.1]#

Verlinken den Ablageort der ietd.conf Konfigurationsdatei.

[root@cloud ~]# mv /etc/iet/ietd.conf /etc/iet/ietd.conf.org
[root@cloud ~]# > /etc/ietd.conf
[root@cloud ~]# ln -s /etc/ietd.conf /etc/iet/ietd.conf
[root@cloud ~]#

Und starten das iSCSI-Target:

[root@cloud ~]# /etc/init.d/iscsi-target start
Starting iSCSI Target: [ OK ]
[root@cloud ~]#

5. Vorbereiten der Datenbank

Als Datenbank für den openQRM Server nutzen wir das Package “mysql-server”.

[root@cloud ~]# yum -y install mysql-server
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
.... 
Complete!
[root@cloud ~]#

Nach der Installation starten wir den mysqld service.

[root@cloud ~]# /etc/init.d/mysqld start
Initializing MySQL database: Installing MySQL system tables...
100521 14:44:53 [Warning] option 'max_join_size': unsigned value 18446744073709551615 adjusted to 4294967295
100521 14:44:53 [Warning] option 'max_join_size': unsigned value 18446744073709551615 adjusted to 4294967295
OK
Filling help tables...
100521 14:44:53 [Warning] option 'max_join_size': unsigned value 18446744073709551615 adjusted to 4294967295
100521 14:44:53 [Warning] option 'max_join_size': unsigned value 18446744073709551615 adjusted to 4294967295
OK
To start mysqld at boot time you have to copy
support-files/mysql.server to the right place for your system
PLEASE REMEMBER TO SET A PASSWORD FOR THE MySQL root USER !
To do so, start the server, then issue the following commands:
/usr/bin/mysqladmin -u root password 'new-password'
/usr/bin/mysqladmin -u root -h cloud password 'new-password'
Alternatively you can run:
/usr/bin/mysql_secure_installation
which will also give you the option of removing the test
databases and anonymous user created by default. This is
strongly recommended for production servers.
See the manual for more instructions.
You can start the MySQL daemon with:
cd /usr ; /usr/bin/mysqld_safe &
You can test the MySQL daemon with mysql-test-run.pl
cd mysql-test ; perl mysql-test-run.pl
Please report any problems with the /usr/bin/mysqlbug script!
The latest information about MySQL is available on the web at
http://www.mysql.com
Support MySQL by buying support/licenses at http://shop.mysql.com
[ OK ]
Starting MySQL: [ OK ]
[root@cloud ~]#

Nun prüfen wir, dass wir uns mit der Datenbank verbinden können.

[root@cloud ~]# mysql
Welcome to the MySQL monitor. Commands end with ; or g.
Your MySQL connection id is 2
Server version: 5.0.77 Source distribution
Type 'help;' or 'h' for help. Type 'c' to clear the buffer.
mysql> quit
Bye
[root@cloud ~]#

Und fügen mysqld zu den init Startskripten mittels chkconfig hinzu.

[root@cloud bin]# chkconfig --add mysqld
[root@cloud bin]# chkconfig mysqld on
[root@cloud bin]# chkconfig --list mysqld
mysqld 0:off 1:off 2:on 3:on 4:on 5:on 6:off
[root@cloud bin]#

6. Installation von openQRM

openQRM wird in diesem Tutorial aus den Sourcen erstellt. Diese sind in dem Subversion Repository des openQRM Projects verfügbar. Für die Installation sind hier lediglich ein Subversion Client und “make” notwendig. Diese sollten also installiert werden.

[root@cloud ~]# yum -y install subversion
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
.... 
Complete!
[root@cloud ~]#

Nun müssen die openQRM Sourcen aus dem SVN Repository ausgecheckt werden.

[root@cloud ~]# svn co https://openqrm.svn.sourceforge.net/svnroot/openqrm openqrm
.... 
A openqrm/trunk/src/rpm/README
A openqrm/trunk/src/rpm/openqrm-entire.spec
A openqrm/branches
A openqrm/tags
Checked out revision 1996.
[root@cloud ~]#

Wir wechseln in das src/ Verzeichnis.

[root@cloud ~]# cd openqrm/trunk/src/
[root@cloud src]#

Anschließend führen wir “make” aus. Dafür wird eine funktionsfähige Internetverbindung benötigt. Sollte dieses nicht der Fall sein, können die Sourcen auch von http://sourceforge.net/projects/openqrm/files/openQRM-4.6/source/openqrm-thirdparty-cache.tgz/download heruntergeladen werden. Diese müssen danach in das Home-Verzeichnis entpackt werden.

[root@cloud src]# make
.... 
[root@cloud src]#

Alle Ergebnisse der Kompilierung werden vom openQRM-Build System automatisch gecached. Um sicherzustellen, dass alle Komponenten richtig erstellt wurden, kann “make” einfach erneut ausgeführt werden.

[root@cloud src]# make
Checking requirements for the compilation phase
openqrm-server requires: make, gcc, portmap, rsync, zlib-devel, wget, tar, bzip2, unzip, patch
found make installed
found gcc installed
found portmap installed
found rsync installed
found zlib-devel installed
found wget installed
found tar installed
found bzip2 installed
found unzip installed
found patch installed
openqrm-plugin-aoe-storage requires:
openqrm-plugin-aws requires:
openqrm-plugin-citrix requires:
openqrm-plugin-cloud requires:
openqrm-plugin-collectd requires:
openqrm-plugin-dhcpd requires:
openqrm-plugin-dns requires:
openqrm-plugin-equallogic-storage requires:
openqrm-plugin-highavailability requires:
openqrm-plugin-image-shelf requires:
openqrm-plugin-iscsi-storage requires:
openqrm-plugin-kvm requires:
openqrm-plugin-kvm-storage requires:
openqrm-plugin-linux-vserver requires:
openqrm-plugin-linuxcoe requires:
openqrm-plugin-local-server requires:
openqrm-plugin-local-storage requires:
openqrm-plugin-lvm-storage requires:
openqrm-plugin-nagios2 requires:
openqrm-plugin-nagios3 requires:
openqrm-plugin-netapp-storage requires:
openqrm-plugin-nfs-storage requires:
openqrm-plugin-puppet requires:
openqrm-plugin-sanboot-storage requires:
openqrm-plugin-solx86 requires:
openqrm-plugin-sshterm requires:
openqrm-plugin-tftpd requires:
openqrm-plugin-tmpfs-storage requires:
openqrm-plugin-vbox requires:
openqrm-plugin-vmware-esx requires:
openqrm-plugin-vmware-server requires:
openqrm-plugin-vmware-server2 requires:
openqrm-plugin-windows requires:
openqrm-plugin-xen requires:
openqrm-plugin-xen-storage requires:
openqrm-plugin-zabbix requires:
openqrm-plugin-zfs-storage requires:
Checking for required components to compile openQRM finished successfully
if [ -d ./thirdparty ]; then mkdir -p ../buildtmp; cp -aR ./thirdparty/* ../buildtmp/; fi
-> found component gpxe (undionly.kpxe.0.9.9.tgz) already downloaded
-> found component kvm-nic-bios (kvm-nic-bios-1.1.tgz) already downloaded
-> found component openqrm-client.windows (openQRM-Client-4.6.1-setup.exe) already downloaded
-> found component sshterm-component (openqrm-plugin-sshterm-components-1.0.tgz) already downloaded
Creating the default initrd-template
-> found component busybox (busybox-1.14.2.tar.bz2) already downloaded
-> Found busybox-1.14.2/_install/bin/busybox already in the build-cache
-> Skipping compilation, taking the ready built component from the cache
-> found component pciutils (pciutils-3.1.4.tar.gz) already downloaded
-> Found pciutils-3.1.4/pcimodules already in the build-cache
-> Skipping compilation, taking the ready built component from the cache
-> found component dropbear (dropbear-0.52.tar.gz) already downloaded
-> Found dropbear-0.52/dropbear already in the build-cache
-> Skipping compilation, taking the ready built component from the cache
Adding /sbin/portmap to default initrd-template
Adding /sbin/rpc.statd to default initrd-template
Adding /bin/bash to default initrd-template
Adding /usr/bin/rsync to default initrd-template
Adding /usr/bin/wget to default initrd-template
Adding /sbin/modprobe to default initrd-template
Adding /sbin/depmod to default initrd-template
Adding /sbin/insmod to default initrd-template
Adding /sbin/lsmod to default initrd-template
Adding /sbin/mke2fs to default initrd-template
Adding /sbin/sfdisk to default initrd-template
Adding /sbin/udevd to default initrd-template
Adding /lib/udev/vol_id to default initrd-template
-> found component gpxe (undionly.kpxe.0.9.9.tgz) already downloaded
-> found component kvm-nic-bios (kvm-nic-bios-1.1.tgz) already downloaded
-> found component openqrm-client.windows (openQRM-Client-4.6.1-setup.exe) already downloaded
-> found component sshterm-component (openqrm-plugin-sshterm-components-1.0.tgz) already downloaded
-> found component adodb (adodb498.tgz) already downloaded
-> found component jquery (jquery-1.3.2.tgz) already downloaded
-> found component js-interface (interface_1.2.zip) already downloaded
-> found component openqrm-client.centos.i386 (openqrm-client.4.6.1.centos.i386.tgz) already downloaded
-> found component openqrm-client.centos.x86_64 (openqrm-client.4.6.1.centos.x86_64.tgz) already downloaded
-> found component openqrm-client.debian.i386 (openqrm-client.4.6.1.debian.i386.tgz) already downloaded
-> found component openqrm-client.debian.x86_64 (openqrm-client.4.6.1.debian.x86_64.tgz) already downloaded
-> found component openqrm-client.ubuntu.i386 (openqrm-client.4.6.1.ubuntu.i386.tgz) already downloaded
-> found component openqrm-client.ubuntu.x86_64 (openqrm-client.4.6.1.ubuntu.x86_64.tgz) already downloaded
-> found component openqrm-initrd-template.centos.i386 (openqrm-initrd-template.4.6.1.centos.i386.tgz) already downloaded
-> found component openqrm-initrd-template.centos.x86_64 (openqrm-initrd-template.4.6.1.centos.x86_64.tgz) already download
-> found component openqrm-initrd-template.debian.i386 (openqrm-initrd-template.4.6.1.debian.i386.tgz) already downloaded
-> found component openqrm-initrd-template.debian.x86_64 (openqrm-initrd-template.4.6.1.debian.x86_64.tgz) already download
-> found component openqrm-initrd-template.ubuntu.i386 (openqrm-initrd-template.4.6.1.ubuntu.i386.tgz) already downloaded
-> found component openqrm-initrd-template.ubuntu.x86_64 (openqrm-initrd-template.4.6.1.ubuntu.x86_64.tgz) already download
[root@cloud src]#

Nun führen wir “make install” aus.

[root@cloud src]# make install
include/
include/openqrm-plugin-local-storage-functions
bin/
.... 
Creating the openqrm-client boot-service package
[root@cloud src]#

Am Ende initialisieren und starten wir openQRM mittels “sudo make start”.

[root@cloud src]# make start
Checking the requirements for RedHat based systems ...
openqrm-server requires: httpd, php, php-mysql, php-soap, mysql, syslinux, screen, procmail, openssl
-> found httpd installed
NOTICE: Trying to automatically install php ...
Loaded plugins: fastestmirror
.... 
Checking for required components finished successfully
Starting httpd: httpd: Could not reliably determine the server's fully qualified domain name, using 192.168.88.6 for Server
[ OK ]
First startup detected. Running initialization.
Looking for syslinux/pxelinux.0...found: /usr/lib/syslinux/pxelinux.0
Creating custom apache config.../etc/httpd/conf.d/openqrm-httpd.conf
Checking /usr/share/openqrm/etc/openqrm-server.conf for OP[ OK ]B_PROTOCOL=https..Reloading httpd:
Adding password for user openqrm
Initializing dropbear...
Will output 1024 bit rsa secret key to '/usr/share/openqrm/etc/dropbear/dropbear_rsa_host_key'
Generating key, this may take a while...
Public key portion is:
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgmOa49UMeOPqid06cR96yfRD/SQ98J1REpLKyyJ518iFFQyGKb9j2quZD+8FfKYt6rgFgS6
kGw95qJf6lqYc/rIH5ezcl4bVCn0Zo9pQkTyF496+iAp6AbPOX9KfBivu+5KWc7sfxOiDWGErPhzTGSkvjxwDAu2PkXAvTjUHMhhXxLk= root@cloud
Fingerprint: md5 de:cc:34:cb:2b:e5:b1:3d:50:dd:cc:f0:b5:ca:e9:e5
Adding public key to /root/.ssh/authorized_keys...
Starting the openQRM-server ver. 4.6.
Initialization complete. Please configure your openQRM Server at: http://192.168.88.6/openqrm/
-> User: openqrm -> Password: openqrm
[root@cloud src]#

“make start” führt zusätzlich eine Check-Routine aus, die überprüft, dass alle Abhängigkeiten für die Einwandfreie Nutzung von openQRM vorhanden sind. Ggf. nicht vorhandene Pakete werden automatisch installiert.

Während des ersten Starts wird der openQRM Server initialisiert. Nachdem openQRM vollständig installiert wurde, kann nun die Konfiguration mittels der Weboberfläche vorgenommen werden.

7. Konfiguration von openQRM

Wir melden uns am openQRM Server per http://ip-adresse/openqrm an. Der Benutzer und das Passwort sind jeweils “openqrm”. Nach der Konfiguration sollten diese Daten geändert werden.

Als erstes wählen wir als Netzwerkkarte die Bridge Schnittstelle für das openQRM Management.

Als Datenbank für das openQRM Backend wählen wir “myslq”.

Anschließend konfigurieren wir die Verbindungsinformationen für die Datenbank.

openQRM ist nun vollständig konfiguriert.

Wir werden automatisch zum Datacenter Dashboard weitergeleitet.

8. Erstellen eines Windows Image

Mit dem Plugin-Manager müssen wir als nächstes die folgenden Plugins aktivieren und starten:

  • dhcpd
  • tftpd
  • sanboot-storage
  • windows
  • cloud

Anschließend wechseln wir nach Base >> Components >> Create >> Storage. Dort erstellen wir einen neuen Speicher vom Typ “Sanboot-Storage (iSCSI)” und wählen den openQRM Server als Ressource.

Wir geben dem Storage Server einen Namen und speichern diesen.

Die Liste der verfügbaren Speicher sind nun wie folgt aus.

Wir klicken auf den “Mgmt” Button des neu erstellten “sanboot” Storage Server.

Hier wählen wir die Volume Group “vol”.

Nun erstellen wir ein neues Volume mit dem Namen “windowsxp″. Die Größe muss etwas größer sein als die der lokalen Festplatte des Systems, das verwendet wird, um das Image zu erstellen.

In unserem Tutorial verwenden wir eine 40 GB große lokale Festplatte, um ein Windows System zu installieren und zu einem LUN auf ein iSCSI-Target zu übertragen. Das Volume das wir erstellen hat eine Größe von 41GB und ist damit ein wenig Größer als die eigentliche physikalische Festplatte.

Mittels der Konsole würden wir wie folgt vorgehen:

[root@cloud ~]# lvs
LV VG Attr LSize Origin Snap% Move Log Copy% Convert
windowsxp vol -wi-ao 40.04G
[root@cloud ~]# cat /etc/ietd.conf
Target windowsxp:windowsxp
Lun 0 Path=/dev/mapper/vol-windowsxp,Type=fileio
[root@cloud ~]#

Installation von Windows auf der lokalen Festplatte des zweiten Systems

In diesem Tutorial verwenden wir Windows XP Professional und nutzen exakt die GPXE Anweisungen von http://etherboot.org/wiki/sanboot/winxp. Wir nutzen dazu eine frische Windows Installation und nehmen keine Partitionierung der Festplatte vor.

Achtung:

Es wird „Install local + Transfer to iSCSI Lun“ verwendet, da Windows XP es nicht unterstützt, direkt auf einem iSCSI-Target installiert zu werden. Neuere Windows Version wie bspw. Windows 7 können dagegen direkt auf einem iSCSI-Target installiert werden, siehe dazu http://etherboot.org/wiki/sanboot/iscsi_install

Nachdem Windows installiert wurde, fügen wir die “iSCSI Boot” Unterstützung hinzu. Dazu gehen wir auf die Webseite http://etherboot.org/wiki/sanboot/winnt_iscsi und laden dort die für Windows passende „Initiator 2.x boot-buildxxx-arch/lang.exe“ herunter. In unserem Fall i386/X86 EN.

Wir speichern die Datei auf unserem Desktop.

Wir führen die Datei aus und folgen den Anweisungen.

Nun laden wir den Windows SAN Boot Configuration Driver von http://etherboot.org/wiki/sanboot/winnt_sanbootconf herunter.

Die ZIp-Datei beinhaltet den SAN Boot Treiber. Wir entpacken den Inhalt auf unseren Desktop.

Nun starten wir den sanbootconf Installer und folgen den Anweisungen.

Damit ist die Installation abgeschlossen.

Übertragen des Festplatteninhalts mittels nc

Um den Inhalt der lokalen Festplatte des Windows Systems auf das iSCSI LUN auf dem “Sanboot” Storage Server zu übertragen, nutzen wir „nc“ und „dd“. Weitere Informationen hierzu sind unter http://solutions.unixsherpa.com/2009/08/10/remote-mirroring-using-nc-and-dd zu finden.

Nach der Windows Installation starten wir das System neu und konfigurieren den Systemstart im BIOS so, dass das System vom Netzwerk aus (pxe-boot) gestartet werden kann. Anschließend wird das System nun innerhalb von openQRM als neue „idle“ Ressource vom Typ “Physical System” gestartet.

Wenn sich das System im Status „idle“ befindet müssen wir die folgenden Schritte vornehmen, um den Festplatteninhalt des physikalischen Windows Systems auf das iSCSI LUN zu übertragen:

1. Starten eines nc Listener auf dem logischen Windows Volume

[root@cloud ~]# ls /dev/mapper/vol-windowsxp
/dev/mapper/vol-windowsxp
[root@cloud ~]# nc -l 12345 | dd of=/dev/mapper/vol-windowsxp
# this command won't return but listen on port 12345 to submit data
# which it reads bitwise from the network port to /dev/mapper/vol-windowsxp

2. Mittels des “openqrm login” Befehl anmelden
Here the syntax of the “openqrm login” comand:

/usr/share/openqrm/bin/openqrm login -i [ip-address-of-the-idle-resource-withe-the-windows-installed-on-local-disk]
[root@cloud ~]# cd /usr/share/openqrm/bin/
[root@cloud bin]# ./openqrm login -i 192.168.88.251
Login to resource 192.168.88.251 ...
Host '192.168.88.251' key accepted unconditionally.
(fingerprint md5 ff:5f:e7:60:ae:14:74:4a:39:15:8c:a6:62:98:73:0b)
bash-3.2#

Wir müssen hierbei beachten, dass die Shell in diesem Fall über keine PATH Umgebung verfügt. Die Befehle müssen daher unter der Angabe des vollständigen Pfads ausgeführt werden.

Der folgende Befehl dient dazu, die lokale Festplatte der Windows Installation zu identifizieren.

bash-3.2# cat /proc/partitions
major minor #blocks name
8 0 39082680 sda
8 1 39070048 sda1
bash-3.2# /sbin/fdisk -l /dev/sda
Disk /dev/sda: 40.0 GB, 40020664320 bytes
255 heads, 63 sectors/track, 4865 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Device Boot Start End Blocks Id System
/dev/sda1 * 1 4864 39070048+ 7 HPFS/NTFS
bash-3.2#

3. dd und nc gemeinsam nutzen

Um den Festplatteninhalt remote auf das logische Volume zu übertragen, nutzen wir die Kombination von dd und nc.

bash-3.2#
bash-3.2# dd if=/dev/sda | nc 192.168.88.6 12345

Abhängig von der Größe der Festplatte und der Geschwindigkeit des Netzwerks, kann dieser Vorgang ein Weile dauern.

Auf dem openQRM Server kann der Befehl „kill -USR1 [pid-of-dd-process]“ genutzt werden, um zu sehen, wie viele Bytes dd bereits übertragen hat.

..
78165360+0 records in
78165360+0 records out
40020664320 bytes (40 GB) copied, 6322.11 seconds, 6.3 MB/s
[root@cloud ~]#

Nun führen für „sync“ aus, um sicherzustellen, dass alle Bits auf das logische Volume übertragen wurden.

[root@cloud ~]# sync
[root@cloud ~]#

9. Vorbereiten des Windows Image

Wir schalten die Ressource die sich im Zustand „idle“ befindet herunter (die Windows Installation auf der lokalen Festplatte), entfernen die Festplatte und starten sie über das Netzwerk neu.

Es sollte darauf geachtet werden, das die Bootreihenfolge auf „Network Boot only“ steht.

Wenn das System neu gestartet ist und sich im Status „idle“ befindet, erstellen wir erneut in logisches „Image“ in openQRM.

Wir wechseln dazu nach Base >> Components >> Create >> Image und wählen den “Sanboot” Storage Server.

Anschließend geben wir dem Image einen Namen und wählen das “windowsxp″ Volume als das Root-Device.

Die Liste der verfügbaren Images sind nun wie folgt aus.

Nun erstellen wir eine „Appliance“. Dazu wechseln wir zu Base >> Appliance >> Create und wählen die Ressource „idle“.

Wir nennen die „Appliance“ windowsxp, wählen den “default” kernel und das “windowsxp” Image und speichern die Appliance.

Wir starten die „Appliance“.

Das folgende Video auf YouTube zeigt den Systemstart des Windows Systems von dem iSCSI Storage Server.

Das Windows Image ist damit nun deployed und funktionsfähig. Nun müssen wir das Image so konfigurieren, damit es mittels openQRM verwaltet werden kann.

Dazu erstellen wir auf dem Windows Image im ersten Schritt einen Windows Benutzer mit dem Namen „root“.

Als nächstes muss der openQRM Client auf dem Windows Image installiert werden. Dazu öffnen wir einen Web-Browser und melden uns an den openQRM Server an.

Anschließend gehen wir zu Plugins >> Deployment >> Windows >> About

Hier laden wir den Windows openQRM-Client herunter.

Wir starten die openQRM-Client Installationsroutine und folgen den Anweisungen.

Now please run “gpedit.msc” and add the permission to “remote shutdown” to user “root”.

Wichtig: Sollte die Windows Firewall aktiviert sein, muss der TCP Port 22 geöffnet werden.

10. openQRM Cloud Konfiguration

Nun wechseln wir nach Plugins >> Cloud >> Configuration >> Main Config und konfigurieren die folgenden Punkte:

  • cloud_admin_email > eine valide E-Mail Adresse
  • auto_provision → true
  • external_portal_url → (optional) externe URL zu einem Cloud Portal
  • request_physical_systems → false
  • auto_give_ccus → 100
  • show_disk_resize → (optional) true
  • show_private_image → true
  • cloud_currency → (optional) auf US oder Euro setzen
  • cloud_1000_ccus → Wie viele 1000 CCUs wie viel US/Euro entsprechen

Für alle weiteren Konfigurationspunkte können die Standardwerte genommen werden. Speichern nicht vergessen!

Der folgende Screenshot zeigt die Hauptseite zur Konfiguration der Cloud.

Als nächstes müssen die Cloud Produkte mittels des „Cloud-Selector“ konfiguriert werden.

Dazu gehen wir nach Plugins >> Cloud >> Configuration >> Products >> Kernel und erstellen ein neues „Windows“ Kernel Produkt.

Das sieht dann wie im folgenden Screenshot aus.

Nun erstellen wir ein „Memory“ Produkt. Dieses muss den exakt verfügbaren Speicher aufweisen, das auf dem zweiten physikalischen System verfügbar ist. (Das System, welches das Windows Image deployed.) In diesem Tutorial verwenden wir ein System mit 3008 MB physikalischen Arbeitsspeicher. Dieser muss entsprechend angepasst werden.

Das sieht dann wie im folgenden Screenshot aus.

Nun erstellen wir ein “Physical System”.

Das sieht dann wie im folgenden Screenshot aus.

Der nächste Schritt besteht darin, der Cloud mitzuteilen, welche Images den Cloud Benutzern angezeigt werden sollen. Dazu wechseln wir nach Plugins >> Cloud >> Configuration >> Private Images und wählen in den Checkboxen „All“ für das „windowsxp “ Image.

Nun erstellen wir einen oder mehrere Cloud Benutzer. Hierfür gehen wir nach Plugins >> Cloud >> User und fügen einen neuen Benutzer inkl. einer gültigen E-Mail Adresse hinzu. Als Cloud Administrator kann man sich mit jedem beliebigen Cloud Benutzer anmelden, indem man auf den Namen des Cloud Benutzers klickt.

Die Liste der Cloud Benutzer sieht im Anschluss wie folgt aus.

Das openQRM Portal sieht nach einem erfolgreichen Login dann wie folgt aus.

Wir klicken auf den 2ten Tab mit dem Namen „Visual Cloud Designer“.

Der Virtual Cloud Designer zeigt alle verfügbaren Komponenten innerhalb der Cloud an. Mittels Drag and Drop kann nun eine eigene Cloud Appliance konstruiert werden.

Anschließend sollten die Kosten (stündlich, täglich, moantlich) für die Appliance betrachtet werden.

Mit einem einzigen Klick kann die Appliance der Cloud hinzugefügt werden.

Für das Cloud Deployment erstellt openQRM automatisch ein LVM Snapshot für das ursprüngliche Windows Image. Das bedeutet, dass es sich bei der (remote) Festplatte des Windows Image eigentlich um ein LVM Snapshot handelt. Im Storage Manager ist das Cloud Volume daher mit einem „s“ (Snapshot) gekennzeichnet.

Auf der Konsole verwendet man dazu den folgenden Befehl:

[root@cloud ~]# lvs
LV VG Attr LSize Origin Snap% Move Log Copy% Convert
2.cloud_1_1_ vol swi-ao 19.53G windowsxp 0.06
windowsxp vol owi-ao 40.04G
[root@cloud ~]#

Lizenzen:
Wichtig! Für das Deployment jedes einzelnen Windows Image ist eine entsprechende und gültige Windows Lizenz erforderlich.

11. Die nächsten Schritte

  • Verwenden von Sanboot-Storage inkl. AOE Deployment
  • Separierung des Storage, Hypvervisors und openQRM auf dedizierte Systeme
  • openQRM Server als Hochverfügbarkeitslösung
  • Hinzufügen weiterer virtualisierter Hosts unterschiedlichen Typs
  • Hinzufügen von physikalischen Systemen
  • Hinzufügen von weiteren Storage Systemen
  • Aktivieren des automatischen Monitorings
  • IP- und Netzwerkmanagement
  • Cloud-Billing
  • Cloud Integration / SOAP WebService

Quelle

  • Howto: Setup openQRM Cloud deploying physical Windows Systems on CentOS 5.5
Kategorien
News

openQRM integriert Ubuntu Enterprise Cloud, Amazon EC2 und Eucalyptus

Gesponsert durch die openQRM Enterprise, veröffentlicht das openQRM project ein neues Plugin, das Hybrid Cloud Computing ermöglicht.

Mit dem Plugin erhalten openQRM Nutzer nun die Möglichkeit, ihre selbst verwalteten Systeme transparent und vollautomatisiert zwischen Private und Public Clouds zu migrieren. Das Importieren bereits vorhandener Cloud Instanzen aus der Ubuntu Enterprise Cloud (UEC), Amazon EC2 oder Eucalyptus kann damit ohne großen Aufwand erfolgen. Dasselbe gilt ebenso für den Export der Systeme aus der openQRM Cloud heraus. Cloud Transparenz! Über die graphische Web Oberfläche können alle dafür benötigten Schritte der Migration durchgeführt werden. Damit können dem eigenen Rechenzentrum nach Bedarf externe Ressourcen von Public Cloud Anbietern hinzugefügt werden.

Durch die Nutzung einer agilen Privat zu Public oder Public zu Private Migration, kann damit kontrolliert werden, welche Daten und Dienste in einem sicheren Bereich bereitgestellt werden sollen. Somit können sensible Systeme innerhalb des eigenen Rechenzentrums betrieben und alle weiteren ressourcenintensiven Systeme zu Cloud Anbietern verlagert werden.

Ein Überblick über die neuen Funktionen zeigt das Video am Ende dieses Artikels.

Für alle die einen tieferen Einblick in eine Hybrid Cloud Lösung haben möchten, stellt openQRM Enterprise ein detailliert beschriebenes How to auf ihren Webseiten zur Verfügung. Dieses kann hier heruntergeladen werden.

Das Plugin steht bereits auf der Seite des openQRM project unter http://sourceforge.net/projects/openqrm zum Download bereit.

Kategorien
Tutorials

Einrichtung einer openQRM Cloud mit KVM auf Ubuntu Lucid Lynx

Dieses Tutorial dient als Schritt für Schritt Anleitung zur Einrichtung einer openQRM Cloud auf einem Ubuntu 10.04 Lucid Lynx und der KVM Virtualisierungstechnologie. Benötigt wird dafür ein physikalisches System, auf welchem VT (Virtualization Technology) aktiviert ist.

1. Los geht es mit einer neuen Ubuntu Lucid Linux Installation

Während der Installation des Systems nehmen wir eine manuelle Partitionierung vor und erstellen 3 Partitionen:

  • 1 – primary ext4 mounted at / (the rootfs)
  • 2 – primary swap
  • 3 – primary „nicht verwenden“ (wird zum Speichern des Server-Image benötigt)

An dieser Stelle ist es wichtig zu beachten, ein benutzerspezifisches Partitionsschema zu wählen und eine dedizierte Partition zu erstellen, auf der später die Server-Images gespeichert werden. Diese Partition wird dann als „do not use“ markiert.

Wenn die Installation abgeschlossen ist, starten wir das System neu und melden uns an. Wurde zu beginn die Ubuntu-Server Version installiert muss zusätzlich das „ubuntu-desktop“ package installiert werden.

matt@cloud:~$ sudo apt-get install ubuntu-desktop

2. Vorbereiten des Netzwerks

Zunächst installieren wir die „bridge-utils“.

matt@cloud:~$ sudo apt-get install bridge-utils
Reading package lists... Done
Building dependency tree
...
Setting up bridge-utils (1.4-5ubuntu2) ...
matt@cloud:~$

Anschließend editieren wir „/etc/network/interfaces“ und richten eine Bridge mit einer statischen, privaten IP-Adresse ein.

matt@cloud:~$ sudo /etc/init.d/networking restart
* Reconfiguring network interfaces...
Waiting for br0 to get ready (MAXWAIT is 2 seconds).
ssh stop/waiting
ssh start/running, process 2864
matt@cloud:~$

Wir führen den Befehl „brctl show“ aus und überprüfen damit die Netzwerkkonfiguration.

matt@cloud:~$ brctl show
bridge name bridge id STP enabled interfaces
br0 8000.002215be747a no eth0
matt@cloud:~$

Nun hinterlegen wir die statische IP-Adresse (in unserem Fall „192.168.88.3“) und den Hostname (in unserem Fall „cloud“) in der /etc/hosts. Der Hostname darf hierbei nicht in der ersten Zeile zusammen mit 127.0.0.1 stehen!

matt@cloud:~$ cat /etc/hosts
127.0.0.1 localhost
192.168.88.3 cloud.openqrm cloud
# The following lines are desirable for IPv6 capable hosts
::1 localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
matt@cloud:~$

3. Vorbereiten des Speicherplatz für die Server-Images

Wir installieren lvm2, nfs-kernel-server, iscsi-target und vblade.

matt@cloud:~$ sudo apt-get install lvm2 nfs-kernel-server iscsitarget vblade
Reading package lists... Done
Building dependency tree
...
ldconfig deferred processing now taking place
Processing triggers for initramfs-tools ...
update-initramfs: Generating /boot/initrd.img-2.6.32-21-server
matt@cloud:~$

Nun bereiten wir die dedizierte Partition aus Schritt 1 so vor, dass sie zusammen mit lvm genutzt werden kann. Anschließend erstellen wir eine Logical Volume Group „vol“.

matt@cloud:~$ sudo pvcreate /dev/sda3
Physical volume "/dev/sda3" successfully created
matt@cloud:~$ sudo pvs
PV VG Fmt Attr PSize PFree
/dev/sda3 lvm2 -- 186.23g 186.23g
matt@cloud:~$ sudo vgcreate vol /dev/sda3
Volume group "vol" successfully created
matt@cloud:~$ sudo vgs
VG #PV #LV #SN Attr VSize VFree
vol 1 0 0 wz--n- 186.22g 186.22g
matt@cloud:~$

Wir editieren /etc/default/iscsitarget und konfigurieren „iscsitarget“ so, dass es während des Bootvorgangs startet.

matt@cloud:~$ cat /etc/default/iscsitarget
ISCSITARGET_ENABLE=true
matt@cloud:~$

Nun starten wir „iscsitarget“ und die „nfs-kernel-server“ Services.

matt@cloud:~$ sudo /etc/init.d/iscsitarget start
* Starting iSCSI enterprise target service
matt@cloud:~$
matt@cloud:~$ sudo /etc/init.d/nfs-kernel-server start
* Exporting directories for NFS kernel daemon...
* Starting NFS kernel daemon
matt@cloud:~$

4. Vorbereiten der Datenbank

Als Datenbank für den openQRM Server nutzen wir das Package „mysql-server“.

matt@cloud:~$ sudo apt-get install -y mysql-server
Reading package lists... Done
Building dependency tree
...
Setting up mysql-server (5.1.41-3ubuntu12) ...
Processing triggers for libc-bin ...
ldconfig deferred processing now taking place
matt@cloud:~$

Aus Gründen der Einfachheit wird in diesem Beispiel das MySQL Passwort leer gelassen.

5. Vorbereiten von KVM

Dafür installieren wir das „kvm“ Package.

matt@cloud:~$ sudo apt-get install -y kvm
Reading package lists... Done
Building dependency tree
.....
Setting up qemu-kvm (0.12.3+noroms-0ubuntu9) ...
qemu-kvm start/running
Setting up kvm (1:84+dfsg-0ubuntu16+0.12.3+noroms+0ubuntu9) ...
Processing triggers for libc-bin ...
ldconfig deferred processing now taking place
matt@cloud:~$

6. Installation von openQRM

openQRM wird in diesem Tutorial aus den Sourcen erstellt. Diese sind in dem Subversion Repository des openQRM Projects verfügbar. Für die Installation sind hier lediglich ein Subversion Client und „make“ notwendig. Diese sollten also installiert werden.

matt@cloud:~$ sudo apt-get install -y subversion make
Reading package lists... Done
Building dependency tree
...
Setting up subversion (1.6.6dfsg-2ubuntu1) ...
Processing triggers for libc-bin ...
ldconfig deferred processing now taking place
matt@cloud:~$

Nun müssen die openQRM Sourcen aus dem SVN Repository ausgecheckt werden.

matt@cloud:~$ svn co https://openqrm.svn.sourceforge.net/svnroot/openqrm openqrm
....
matt@cloud:~$

Wir wechseln in das src/ Verzeichnis.

matt@cloud:~$ cd openqrm/trunk/src/
matt@cloud:~/openqrm/trunk/src$

Anschließend führen wir „make“ aus. Dafür wird eine funktionsfähige Internetverbindung benötigt. Sollte dieses nicht der Fall sein, können die Sourcen auch von http://sourceforge.net/projects/openqrm/files/openQRM-4.6/source/openqrm-thirdparty-cache.tgz/download heruntergeladen werden. Diese müssen danach in das Home-Verzeichnis entpackt werden.

matt@cloud:~/openqrm/trunk/src$ make
....

Alle Ergebnisse der Kompilierung werden vom openQRM-Build System automatisch gecached. Um sicherzustellen, dass alle Komponenten richtig erstellt wurden, kann „make“ einfach erneut ausgeführt werden.

matt@cloud:~/openqrm/trunk/src$ make
Checking requirements for the compilation phase
openqrm-server requires: make, gcc, portmap, rsync, zlib1g-dev, wget, tar, bzip2, unzip, wget, netbase, patch
found make installed
found gcc installed
found portmap installed
found rsync installed
found zlib1g-dev installed
found wget installed
found tar installed
found bzip2 installed
found unzip installed
found wget installed
found netbase installed
found patch installed
openqrm-plugin-aoe-storage requires:
openqrm-plugin-aws requires:
openqrm-plugin-citrix requires:
openqrm-plugin-cloud requires:
openqrm-plugin-collectd requires:
openqrm-plugin-dhcpd requires:
openqrm-plugin-dns requires:
openqrm-plugin-equallogic-storage requires:
openqrm-plugin-highavailability requires:
openqrm-plugin-image-shelf requires:
openqrm-plugin-iscsi-storage requires:
openqrm-plugin-kvm requires:
openqrm-plugin-kvm-storage requires:
openqrm-plugin-linux-vserver requires:
openqrm-plugin-linuxcoe requires:
openqrm-plugin-local-server requires:
openqrm-plugin-local-storage requires:
openqrm-plugin-lvm-storage requires:
openqrm-plugin-nagios2 requires:
openqrm-plugin-nagios3 requires:
openqrm-plugin-netapp-storage requires:
openqrm-plugin-nfs-storage requires:
openqrm-plugin-puppet requires:
openqrm-plugin-sanboot-storage requires:
openqrm-plugin-solx86 requires:
openqrm-plugin-sshterm requires:
openqrm-plugin-tftpd requires:
openqrm-plugin-tmpfs-storage requires:
openqrm-plugin-vbox requires:
openqrm-plugin-vmware-esx requires:
openqrm-plugin-vmware-server requires:
openqrm-plugin-vmware-server2 requires:
openqrm-plugin-windows requires:
openqrm-plugin-xen requires:
openqrm-plugin-xen-storage requires:
openqrm-plugin-zabbix requires:
openqrm-plugin-zfs-storage requires:
Checking for required components to compile openQRM finished successfully
if [ -d ./thirdparty ]; then mkdir -p ../buildtmp; cp -aR ./thirdparty/* ../buildtmp/; fi
-> found component kvm-nic-bios (kvm-nic-bios-1.1.tgz) already downloaded
-> found component gpxe (undionly.kpxe.0.9.9.tgz) already downloaded
-> found component sshterm-component (openqrm-plugin-sshterm-components-1.0.tgz) already downloaded
-> found component openqrm-client.windows (openQRM-Client-4.6.1-setup.exe) already downloaded
Creating the default initrd-template
-> found component busybox (busybox-1.14.2.tar.bz2) already downloaded
-> Found busybox-1.14.2/_install/bin/busybox already in the build-cache
-> Skipping compilation, taking the ready built component from the cache
-> found component pciutils (pciutils-3.1.4.tar.gz) already downloaded
-> Found pciutils-3.1.4/pcimodules already in the build-cache
-> Skipping compilation, taking the ready built component from the cache
-> found component dropbear (dropbear-0.52.tar.gz) already downloaded
-> Found dropbear-0.52/dropbear already in the build-cache
-> Skipping compilation, taking the ready built component from the cache
/lib64/ld-2.11.1.so /lib64/ld-linux-x86-64.so.2
Adding /sbin/portmap to default initrd-template
Adding /sbin/rpc.statd to default initrd-template
Adding /bin/bash to default initrd-template
Adding /usr/bin/rsync to default initrd-template
Adding /usr/bin/wget to default initrd-template
Adding /sbin/modprobe to default initrd-template
Adding /sbin/depmod to default initrd-template
Adding /sbin/insmod to default initrd-template
Adding /sbin/lsmod to default initrd-template
Adding /sbin/mke2fs to default initrd-template
Adding /sbin/sfdisk to default initrd-template
Adding /sbin/udevd to default initrd-template
Adding /sbin/blkid to default initrd-template
/lib64/libnss_files-2.11.1.so /lib64/libnss_files.so.2
-> found component jquery (jquery-1.3.2.tgz) already downloaded
-> found component js-interface (interface_1.2.zip) already downloaded
-> found component openqrm-client.centos.i386 (openqrm-client.4.6.1.centos.i386.tgz) already downloaded
-> found component openqrm-client.centos.x86_64 (openqrm-client.4.6.1.centos.x86_64.tgz) already downloaded
-> found component openqrm-client.debian.i386 (openqrm-client.4.6.1.debian.i386.tgz) already downloaded
-> found component openqrm-client.debian.x86_64 (openqrm-client.4.6.1.debian.x86_64.tgz) already downloaded
-> found component openqrm-client.ubuntu.i386 (openqrm-client.4.6.1.ubuntu.i386.tgz) already downloaded
-> found component openqrm-client.ubuntu.x86_64 (openqrm-client.4.6.1.ubuntu.x86_64.tgz) already downloaded
-> found component openqrm-initrd-template.centos.i386 (openqrm-initrd-template.4.6.1.centos.i386.tgz) already downloaded
-> found component openqrm-initrd-template.centos.x86_64 (openqrm-initrd-template.4.6.1.centos.x86_64.tgz) already download
-> found component openqrm-initrd-template.debian.i386 (openqrm-initrd-template.4.6.1.debian.i386.tgz) already downloaded
-> found component openqrm-initrd-template.debian.x86_64 (openqrm-initrd-template.4.6.1.debian.x86_64.tgz) already download
-> found component openqrm-initrd-template.ubuntu.i386 (openqrm-initrd-template.4.6.1.ubuntu.i386.tgz) already downloaded
-> found component openqrm-initrd-template.ubuntu.x86_64 (openqrm-initrd-template.4.6.1.ubuntu.x86_64.tgz) already download
-> found component kvm-nic-bios (kvm-nic-bios-1.1.tgz) already downloaded
-> found component gpxe (undionly.kpxe.0.9.9.tgz) already downloaded
-> found component sshterm-component (openqrm-plugin-sshterm-components-1.0.tgz) already downloaded
-> found component openqrm-client.windows (openQRM-Client-4.6.1-setup.exe) already downloaded
matt@cloud:~/openqrm/trunk/src$

Nun führen wir „sudo make install“ aus.

matt@cloud:~/openqrm/trunk/src$ sudo make install
Creating the openqrm-client boot-service package
include/
include/openqrm-plugin-kvm-functions
.... further install output
sbin/
sbin/openqrm-kvm-storage-monitord
matt@cloud:~/openqrm/trunk/src$

Am Ende initialisieren und starten wir openQRM mittels „sudo make start“.

matt@cloud:~/openqrm/trunk/src$ sudo make start
.... runtime dependency check, automatic install additional requirements
...
openqrm-plugin-xen requires: , screen
-> found screen installed
openqrm-plugin-xen-storage requires: , screen
-> found screen installed
openqrm-plugin-zabbix requires:
openqrm-plugin-zfs-storage requires: , open-iscsi
-> found open-iscsi installed
Checking for required components finished successfully
First startup detected. Running initialization.

Adding system startup for /etc/init.d/openqrm ...
/etc/rc0.d/K24openqrm -> ../init.d/openqrm
/etc/rc1.d/K24openqrm -> ../init.d/openqrm
/etc/rc6.d/K24openqrm -> ../init.d/openqrm
/etc/rc2.d/S98openqrm -> ../init.d/openqrm
/etc/rc3.d/S98openqrm -> ../init.d/openqrm
/etc/rc4.d/S98openqrm -> ../init.d/openqrm
/etc/rc5.d/S98openqrm -> ../init.d/openqrm
Looking for syslinux/pxelinux.0...found: /usr/lib/syslinux/pxelinux.0
Creating custom apache config.../etc/apache2/conf.d/openqrm-httpd.conf
Checking /usr/share/openqrm/etc/openqrm-server.conf for OPENQRM_WEB_PROTOCOL=https.. * Reloading web server config apache2
Adding password for user openqrm
Initializing dropbear...
Will output 1024 bit rsa secret key to '/usr/share/openqrm/etc/dropbear/dropbear_rsa_host_key'
Generating key, this may take a while...
Public key portion is:
ssh-rsa xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxroot@cloud
Fingerprint: md5 28:46:66:b4:b7:59:b6:28:70:ec:2b:6f:16:4a:dd:70
Adding public key to /root/.ssh/authorized_keys...
Starting the openQRM-server ver. 4.6.
Initialization complete. Please configure your openQRM Server at: http://[server-ip-address]/openqrm/
-> User: openqrm -> Password: openqrm
matt@cloud:~/openqrm/trunk/src$

„make start“ führt zusätzlich eine Check-Routine aus, die überprüft, dass alle Abhängigkeiten für die Einwandfreie Nutzung von openQRM vorhanden sind. Ggf. nicht vorhandene Pakete werden automatisch installiert.

Während des ersten Starts wird der openQRM Server initialisiert. Nachdem openQRM vollständig installiert wurde, kann nun die Konfiguration mittels der Weboberfläche vorgenommen werden.

7. Konfiguration von openQRM

Wir melden uns am openQRM Server per http://localhost/openqrm an. Der Benutzer und das Passwort sind jeweils „openqrm“. Nach der Konfiguration sollten diese Daten geändert werden.

Als erstes wählen wir als Netzwerkkarte die Bridge Schnittstelle für das openQRM Management.

Als Datenbank für das openQRM Backend wählen wir „myslq“.

Anschließend konfigurieren wir die Verbindungsinformationen für die Datenbank.

openQRM ist nun vollständig konfiguriert.

Wir werden automatisch zum Datacenter Dashboard weitergeleitet.

8. Vorbereiten der Server-Images

Als Nächstes müssen wir die folgenden Plugins aktivieren und starten:

  • cloud
  • dhcpd
  • image-shelf
  • kvm
  • lvm-storage
  • tftpd

Anschließend wechseln wir nach Base >> Components >> Create >> Storage. Dort erstellen wir einen neuen Speicher vom Typ „Lvm Storage Server (NFS)“ und wählen den openQRM Server als Ressource.

Wir geben dem Storage Server einen Namen und speichern diesen.

Die Liste der verfügbaren Speicher sind nun wie folgt aus.

Wir klicken auf den „Mgmt“ Button des neu erstellten „lvm-nfs“ Storage Server.

Hier wählen wir die Volume Group „vol“.

Nun erstellen wir ein neues Volume mit dem Namen „ubuntu64“ und einer Größe von 5000 MB.

Im Anschluss erstellen wir ein weiteres Volume mit dem Namen „debian64“ und einer Größe von 5000 MB.

Nun wechseln wir nach Base >> Components >> Create >> Image und erstellen Images aus den eben erstellten Volumes. Im ersten Schritt wählen wir den Storage Server auf dem die Images physikalisch gespeichert sind.

Anschließend geben wir dem Image einen Namen (in diesem Beispiel „ubuntu64“) und wählen das „ubuntu64“ Volume als das Root-Device.

Dieses wiederholen wir für ein weiteres Image und geben diesem den Namen „debian64“ und wählen das „debian64“ Volume als das Root-Device.

Die Liste der verfügbaren Images sind nun wie folgt aus.

Auf der Konsole erhalten wir folgende Ausgabe:

matt@cloud:~$ df
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda1 38543848 3470824 33115088 10% /
none 1523376 324 1523052 1% /dev
none 1528204 200 1528004 1% /dev/shm
none 1528204 164 1528040 1% /var/run
none 1528204 0 1528204 0% /var/lock
none 1528204 0 1528204 0% /lib/init/rw
none 38543848 3470824 33115088 10% /var/lib/ureadahead/debugfs
/dev/mapper/vol-ubuntu64
5039616 141212 4642404 3% /vol/ubuntu64
/dev/mapper/vol-debian64
5039616 141212 4642404 3% /vol/debian64
matt@cloud:~$ sudo exportfs
/vol/ubuntu64 192.168.88.3
/vol/debian64 192.168.88.3
matt@cloud:~$ ls /vol/ubuntu64/
lost+found
matt@cloud:~$ ls /vol/debian64/
lost+found
matt@cloud:~$

Mittels des „image-shelf“ Plugin werden die weiterhin noch leeren Images mit dem Root Dateisystem befüllt.

Dazu gehen wir nach Plugins >> Deployment >> Image-Shelf >> Import und wählen das „openqrm-enterprise“ Image-Shelf.

Hier erhalten wir nun eine liste von verfügbaren Server Templates. Wir wählen das „Ubuntu x86_64“ und klicken auf „get“.

Nun wählen wir das Image zu dem die Server Templates hinzugefügt werden sollen. Wir nehmen das „ubuntu64“ Image, dass wir vorhin erstellt haben und klicken „put“.

Image-Shelf verarbeitet nun die Anfrage im Hintergrund. Dabei werden die ausgewählten Server Templates heruntergeladen und auf dem Storage Server entpackt. Der gesamte Vorgang nimmt ein wenig Zeit in Anspruch.

Derselbe Vorgang muss für das „debian64“ Image ebenfalls vorgenommen werden.

Nachdem Image-Shelf die Verarbeitung abgeschlossen hat, erhalten wir folgende Konsolenausgabe:

matt@cloud:~$ df
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda1 38543848 3552184 33033728 10% /
none 1523376 324 1523052 1% /dev
none 1528204 200 1528004 1% /dev/shm
none 1528204 164 1528040 1% /var/run
none 1528204 0 1528204 0% /var/lock
none 1528204 0 1528204 0% /lib/init/rw
none 38543848 3552184 33033728 10% /var/lib/ureadahead/debugfs
/dev/mapper/vol-ubuntu64
5039616 1144532 3639084 24% /vol/ubuntu64
/dev/mapper/vol-debian64
5039616 1084104 3699512 23% /vol/debian64
matt@cloud:~$ sudo exportfs
/vol/ubuntu64 192.168.88.3
/vol/debian64 192.168.88.3
matt@cloud:~$ ls /vol/ubuntu64/
bin cdrom etc initrd.img lib64 media opt root selinux sys usr vmlinuz
boot dev home lib lost+found mnt proc sbin srv tmp var
matt@cloud:~$ ls /vol/debian64/
bin cdrom emul home lib lib64 media opt root selinux sys usr vmlinuz
boot dev etc initrd.img lib32 lost+found mnt proc sbin srv tmp var
matt@cloud:~$

Beide Images sind nun mit einem validen Root Dateisystem befüllt. Die Konfiguration der openQRM Cloud kann nun fortgeführt werden.

9. Erstellen eines KVM Host

Nun müssen wir openQRM die virtualisierten Hosts mitteilen. Dazu gehen wir nach Base >> Appliances >> Create und wählen „openQRM Server“ als „resource“.

Wir geben der neuen Appliance einen Namen (in diesem Beispiel „kvm-host“), setzen den „resource-type“ auf „KVM Host“ und speichern.

Die Liste der Appliances sieht nach dem Erstellen der „kvm-host“ Appliance wie folgt aus.

10. Konfiguration der openQRM Cloud

Nun wechseln wir nach Plugins >> Cloud >> Configuration >> Main Config und konfigurieren die folgenden Punkte:

  • cloud_admin_email > eine valide E-Mail Adresse
  • auto_provision → true
  • external_portal_url → (optional) externe URL zu einem Cloud Portal
  • request_physical_systems → false
  • auto_give_ccus → 100
  • show_disk_resize → (optional) true
  • show_private_image → true
  • cloud_currency → (optional) auf US oder Euro setzen
  • cloud_1000_ccus → Wie viele 1000 CCUs wie viel US/Euro entsprechen

Für alle weiteren Konfigurationspunkte können die Standardwerte genommen werden. Speichern nicht vergessen!

Der folgende Screenshot zeigt die Hauptseite zur Konfiguration der Cloud.

Als nächstes müssen die Cloud Produkte mittels des „Cloud-Selector“ konfiguriert werden.

Dazu gehen wir nach Plugins >> Cloud >> Configuration >> Products >> Kernel und erstellen ein neues „Ubuntu64“ Kernel Produkt.

Diesen Schritt wiederholen wir, um ein „Debian64“ Kernel Produkt zu erstellen.

Im Anschluss erstellen wir ein „KVM VM“ Virtualisierung Produkt.

Das sieht dann wie im folgenden Screenshot aus.

Der nächste Schritt besteht darin, der Cloud mitzuteilen, welche Images den Cloud Benutzern angezeigt werden sollen. Dazu wechseln wir nach Plugins >> Cloud >> Configuration >> Private Images und wählen in den Checkboxen „All“ für das „ubuntu64“ und „debian64“ Image.

Nun erstellen wir einen oder mehrere Cloud Benutzer. Hierfür gehen wir nach Plugins >> Cloud >> User und fügen einen neuen Benutzer inkl. einer gültigen E-Mail Adresse hinzu.

Die Liste der Cloud Benutzer sieht im Anschluss wie folgt aus.

Als Cloud Administrator kann man sich mit jedem beliebigen Cloud Benutzer anmelden, indem man auf den Namen des Cloud Benutzers klickt.

Das openQRM Portal sieht nach einem erfolgreichen Login dann wie folgt aus.

Wir klicken auf den 2ten Tab mit dem Namen „Visual Cloud Designer“.

Der Virtual Cloud Designer zeigt alle verfügbaren Komponenten innerhalb der Cloud an. Mittels Drag and Drop kann nun eine eigene Cloud Appliance konstruiert werden.

Anschließend sollten die Kosten (stündlich, täglich, moantlich) für die Appliance betrachtet werden.

Mit einem einzigen Klick kann die Appliance der Cloud hinzugefügt werden.

11. Nutzen der openQRM Cloud

Um Zugriff auf die „KVM VM“ Konsole zu erhalten, muss das „xtightvncviewer“ Package installiert werden.

matt@cloud:~$ sudo apt-get install xtightvncviewer
Reading package lists... Done
...
Setting up xtightvncviewer (1.3.9-6) ...
update-alternatives: using /usr/bin/xtightvncviewer to provide /usr/bin/vncviewer (vncviewer) in auto mode.
matt@cloud:~$

Um sich per VNC an der ersten Cloud Appliance (KVM VM) anzumelden nutzen wir den folgenden Befehl.

matt@cloud:~$ vncviewer localhost:1

Der folgende Screenshot zeigt den Bootvorgang der Cloud Appliance in einer KVM VM.

Die openQRM Cloud schickt dem Cloud Benutzer automatisch eine E-Mail, in der die IP-Adresse und alle Anmeldeinformationen enthalten sind.

Wir können uns nun anmelden und mit der Cloud Appliance arbeiten.

12. Die nächsten Schritte

  • Separierung des Storage, Hypvervisors und openQRM auf dedizierte Systeme
  • openQRM Server als Hochverfügbarkeitslösung
  • Hinzufügen weiterer virtualisierter Hosts unterschiedlichen Typs (XEN, VMwAre, etc.)
  • Hinzufügen von physikalischen Systemen
  • Hinzufügen von weiteren Storage Systemen
  • Aktivieren des automatischen Monitorings
  • IP- und Netzwerkmanagement
  • Cloud-Billing
  • Cloud Integration / SOAP WebService

Quelle

  • HowTo: Setup your own openQRM Cloud with KVM on Ubuntu Lucid Lynx
Kategorien
Services

openQRM Enterprise wird Partner des Canonical Software Partner Programms

Das Kölner Unternehmen openQRM-Enterprise, Anbieter der gleichnamigen Cloud Computing Plattform openQRM, ist dem Canonical Software Partner Programm beigetreten und wird in diesem Zuge mit Professional Services und einem langfristigen Support die openQRM Cloud auf den Ubuntu Server Distributionen unterstützen.

Canonical ist Distributor von Ubuntu Linux und stellt mit der Ubuntu Enterprise Cloud eine auf Eucalyptus basierende Cloud Computing Infrastruktur Lösung bereit.

Weitere Informationen sind auf den Webseiten von Ubuntu zu finden:

Quelle

  • openQRM-Enterprise
Kategorien
News

openQRM ab sofort mit Service Level Agreements & Professional Services

Die openQRM Enterprise aus Köln bietet ihren Kunden und Nutzern von openQRM per sofort professionelle Service Level Agreements (SLA) auf Basis der Level Basic, Standard und Premium.

Durch die Einführung dieser SLAs setzt sich die openQRM Enterprise damit selbst das Ziel, hochqualitativen Support für die Cloud Computing Plattform openQRM zu liefern, wodurch Kunden direkten Kontakt mit dem openQRM Enterprise Support-Team herstellen können und weiterhin Zugriff auf einen Bug-Tracker erhalten.

Abgerundet werden die SLAs mit Professional Services, mit denen eine direkte Unterstützung bei der Einführung und der Lösung von Problemen mit openQRM geboten wird. Dazu gehören ebenfalls die regelmäßige Unterstützung durch das openQRM Enterprise Support-Team, um den einwandfreien Betrieb und die Wartung (Updates) von openQRM zu gewährleisten und die Entwicklung spezieller und spezifischer Funktionen und Anforderungen durch den Kunden.

Service Level Agreements

  • Vollständiges Zugriff auf das openQRM Enterprise Bug-Tracking System
  • Updates durch die openQRM Enterprise
  • Zertifizierung der openQRM Umgebung durch die openQRM Enterprise
  • openQRM Enterprise Newsletter
  • Monatliche Berichte inkl. Besprechung
  • Direkter Kontakt zum openQRM Enterprise Support-Team

Professional Services

  • Unterstützung der openQRM Umgebung auf Basis der eigenen Anforderungen
  • Automatische openQRM Updates
  • Entwicklung neuer Funktionen für openQRM – auch auf Basis eigener Anforderungen
  • Zertifizierung der openQRM Umgebung durch die openQRM Enterprise
  • openQRM Enterprise Newsletter

openQRM Updates ab sofort durch die openQRM Enterprise

Weiterhin wird die openQRM Enterprise die aktive Entwicklung von openQRM übernehmen, wodurch die Qualität und Innovation von openQRM weiter verbessert werden soll und wichtige Updates zeitnah veröffentlicht werden können.

Wichtig hierbei ist, dass die openQRM Enterprise alle Änderungen und Releases weiterhin auf dem Open-Source Repository von SourceForge.net zur Verfügung stellen wird, so dass jeder openQRM weiter frei nutzen kann.

Quelle

  • openQRM
  • openQRM Enterprise
Kategorien
News

openQRM mit neuen Funktionen

Bereits seit dem 12.03.2010 ist der Funktionsumfang der Cloud Computing Plattform openQRM erweitert. Eines der neuen Features ist die Unterstützung des Windows Betriebssystems. Folgende vier neue Funktionen sind verfügbar:

kvm-storage plug-in

Das kvm-storage Plugin kombiniert die KVM Virtualisierungstechnologie mit der LVM Speichertechnologie. Dadurch können ab sofort lokale virtuelle Maschinen auf Basis von KVM durch die Nutzung von virtuellen Festplatten auf Basis von LVM Volumes schnell bereitgestellt werden.

xen-storage plug-in

Das xen-storage Plugin kombiniert die Xen Virtualisierungstechnologie mit der LVM Speichertechnologie. Dadurch können ab sofort lokale virtuelle Maschinen auf Basis von Xen durch die Nutzung von virtuellen Festplatten auf Basis von LVM Volumes schnell bereitgestellt werden.

sanboot-storage plug-in

Mit dem sanboot-storage Plugin können Windows Betriebssysteme schnell auf dem physischen System bereitgestellt werden. Dazu werden die Windows Server Images auf direktem Weg von einem SAN Speicher (iSCSI oder AOE) mittels gPXE bereitgestellt. Eine der herausragenden neuen Funktionen ist die Möglichkeit Live Snapshots des Windows Betriebssystems direkt in einem SAN zu speichern. Diese Snapshots können anschließend für ein erneutes Deployment/ Rollback verwendet werden.

windows plug-in

Mit dem windows Plugin kann über die Oberfläche des openQRM Servers ein Windows Betriebssystem vollständig verwaltet werden, indem der openQRM-Client auf dem Windows Server Image installiert wird. Durch die Unterstützung des Windows Betriebssystems geht openQRM damit den nächsten Schritt, eine zentrale Management Console für Cloud Computing Rechenzentren und IT-Infrastrukturen bereitzustellen.

Kategorien
Grundlagen

Podcast: Matthias Rechenburg über Private Cloud Computing

Matthias Rechenburg von openQRM Enterprise spricht in diesem Podcast auf der CeBIT 2010 über Private Cloud Computing für Internet Service Provider mit der Cloud Computing Plattform openQRM.

[audio: http://audio.clouduser.de/Matt_Private_Cloud.mp3]

Quelle

Kategorien
Analysen Services

Cloud Computing Technologien im Vergleich

Auf den Devopsdays 09 fand ein Vergleich aktueller Cloud Computing Technologien auf Basis einer Matrix statt. Dabei wurden die Funktionen und Services diverser führender Anbieter/ Technologien einander gegenübergestellt.

Weiterlesen „Cloud Computing Technologien im Vergleich“
Kategorien
Analysen

Eigenschaften einer Cloud Platform

Ich habe bisher einige Cloud Computing Plattformen, darunter openQRM, OpenNebula oder OpenECP vorgestellt und ein paar weitere werden noch folgen. Daher erläutere ich in diesem Artikel die grundsätzlichen Eigenschaften die eine Cloud Plattform (meiner Meinung nach) hat bzw. haben sollte.

1. Zunächst sollten ausreichend virtualisierte Serverressourcen zur Verfügung stehen. Weiterhin müssen, (vor allem dann) wenn sich mehrere Kunden auf einem System befinden, jedem Kunden diese virtualisierten Serverressourcen garantiert werden und die einzelnen virtuellen Instanzen isoliert und damit vollständig von einander getrennt betrieben werden.

2. Zum Bereitstellen von umfangreichen Enterprise-Class-Services wie z.B. hohe Verfügbarkeit, Systemwiederherstellungen nach Datenverlusten, automatische Skalierung während Lastspitzen und Ressourcenoptimierungen muss eine große (unbegrenzte) Menge an virtualisierten Serverressourcen vorhanden sein.

3. Für ein zustandsbehaftetes Lifecycle Management, wozu Snapshots, schnelles Cloning (duplizieren) und eine dynamische Versorgung mit Ressourcen über große Server Infrastrukturen gehören, wird ein virtualisierter Cloud Speicher benötigt.

4. Für die Anpassung der virtuellen Topologie – durch das Hinzufügen weiterer Netzwerkfunktionen für Sicherheit, Routing, Load Balancing, Application Firewalls, Protokol Optimierung, etc. in den OSI Schichten 3 bis 7 – und die Möglichkeit die jeweiligen (Teil)-Netzwerke auf Multi-Kunden Systemen zu isolieren und Ressourcen zu garantieren, werden virtuelle Netzwerk Ressourcen benötigt.

5. Es müssen umfangreiche und offene APIs zur Kontrolle sämtlicher Ressourcen vorhanden sein, damit Cloud Computing Anbieter ihren Kunden die vollständige Kontrolle über deren privaten virtuellen Rechenzentren anbieten können.

6. Die Cloud Plattform muss für allen gängigen Virtualisierungs-Plattformen vollständige Kompatibilität bieten und jede virtuelle Maschine unterstützen, um u.a. einen Vendor Lock-in zu vermeiden. Des Weiteren müssen Funktionen für die Migration von virtuellen Maschinen zwischen unterschiedlichen Virtualisierungs-Technologien (P2V, V2P und V2V) vorhanden sein.

7. Zu guter letzt sollte die Cloud Plattform auf Open Source basieren, um eine größtmögliche Kompatibilität zu allen möglichen Clouds aufzuweisen und um einfach adaptiert und angenommen zu werden.

Kategorien
Tutorials

Ein Cloud Desktop mit openQRM

Nachdem ich eyeOS in zwei Artikeln ausführlich vorgestellt habe, möchte ich in diesem Artikel eine weitere interessante Möglichkeit aufzeigen, einen persönlichen Cloud Desktop zu nutzen. Dazu dient das von mir ebenfalls schon vorgestellte Cloud Management Tool openQRM, auf dessen Portal Webseite (http://www.openqrm-portal.de) ich die Idee (von Matt Rechenburg beschrieben) entdeckt habe.

Cloud Desktops wie auch Desktop-Virtualisierung sind für mich die Megatrends der Zukunft, die bei jedem auf der Roadmap stehen sollten!

Um uns einen Cloud Desktop mit openQRM zu erstellen gehen wir wir folgt vor:

1. Bestellen einer Cloud Appliance von openQRM

Zunächst legt man sich einen Account unter https://demo.openqrm.com und erstellt einen neuen Cloud-Request.

2. Installation von vncserver und Gnome auf der Cloud Appliance

Die Pakete vnc4server, xorg und gnome müssen per apt-get auf der Cloud Appliance wie folgt installiert werden.

root@cloud-91-1-x:~# apt-get install tightvncserver vnc4server xorg gnome

3. Erstellen eines VNC Users

Mit dem Befehl adduser wird ein neuer Benutzer erstellt.

root@cloud-91-1-x:~# adduser matt
Adding user `matt' ...
Adding new group `matt' (1001) ...
Adding new user `matt' (1001) with group `matt' ...
Creating home directory `/home/matt' ...
Copying files from `/etc/skel' ...
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
Changing the user information for matt
Enter the new value, or press ENTER for the default
Full Name []:
Room Number []:
Work Phone []:
Home Phone []:
Other []:
Is the information correct? [y/N] y
root@cloud-91-1-x:~#

Danach mit dem su Befehl zum eben erstellten Benutzer wechseln.

root@cloud-91-1-x:~# su - matt
matt@cloud-91-1-x:~$

4. Erstellen einer VNC Passwortdatei

Mit dem vnc4passwd Tool wird eine neue VNC Passwortdatei erzeugt.

matt@cloud-91-1-x:~$ vnc4passwd
Password:
Verify:
matt@cloud-91-1-x:~$

5. Erstellen eines xstartup Skript

Für den automatischen Start einer Gnome Session nach dem VNC-Login muss eine xstartup Datei im .vnc/ Verzeichnis angelegt werden.

matt@cloud-91-1-x:~$ vi .vnc/xstartup
matt@cloud-91-1-x:~$ cat .vnc/xstartup
#!/bin/sh

xrdb $HOME/.Xresources
xsetroot -solid grey
gnome-session &

matt@cloud-91-1-x:~$

Die Datei muss nun noch ausführbar gemacht werden.

matt@cloud-91-1-x:~$ chmod -x
matt@cloud-91-1-x:~$ .vnc/xstartup

6. Start des vncserver

Nun muss der vncserver gestartet werden.

matt@cloud-91-1-x:~$ tightvncserver
xauth: creating new authority file /home/matt/.Xauthority

Creating default startup script /home/matt/.vnc/xstartup
Starting applications specified in /home/matt/.vnc/xstartup
Log file is /home/matt/.vnc/cloud-91-1-x:1.log

7. Verbindung mit dem Cloud Desktop herstellen

Mit einem vncviewer Tool (Linux/Windows) kann man sich nun mit dem Befehl vncviewer[IP-Adresse der Cloud-Appliance]:1 mit dem Gnome Desktop in der Cloud verbinden.

matt@matt-laptop:~$ vncviewer x.x.x.x:1

Nach der Anmeldung steht ein vollständiger Gnome Desktop in der Cloud zur Verfügung.

Quelle

Your Desktop in the Cloud (DE)