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
Cloud ist die Erweiterung einer Private Cloud, die eine RESTful Cloud Schnittstelle bereitstellt. Cloud Schnittstellen können sowohl zu einer Private als auch zu einer Hybrid Cloud hinzugefügt werden, um z.B. Partnern oder extern Benutzer den Zugriff auf die eigene Infrastruktur zu ermöglichen, oder um eigene Überkapazitäten zu verkaufen. Somit ist eine lokale Cloud Lösung das natürliche Back-End für eine Public Cloud.
einmalig in Deutschland statt.