iCloud ist für iOS Nutzer die ideale Lösung, Daten zwischen mehreren mobilen Endgeräten und Computern zu synchronisieren. Apple’s iWork Suite hat iCloud bereits fest integriert, womit Pages, Numbers und Keynote Daten bequem auf den unterschiedlichen Geräten ausgetauscht und bearbeitet werden können.
Die iCloud Synchronisation zwischen dem iPad, iPhone und iPod touch funktioniert sehr gut, woran das “alles aus einer Hand” Prinzip gut zu erkennen ist. Der Synchronisationsvorgang verhält sich bei allen drei Geräten ähnlich. Anhand von Pages schauen wir mal, wie das funktioniert.
Solltest Du Pages das erste Mal nutzen bzw. das erste Mal öffnen, nachdem die Anwendung geupdated wurde, wirst Du zunächst gefragt, ob Du iCloud nutzen möchtest. Hier befolgst Du einfach die Anweisungen und solltest Dich dann mit iCloud verbinden können.
Solltest Du bei der Anmeldung mit iCloud Probleme haben, schaust Du unter Einstellungen am besten noch einmal nach, ob hier alle Konfigurationen in Ordnung sind. Gehe unter Einstellungen zum Pages Tap und aktiviere hier ggf. iCloud. Anschließend gehst Du zurück zu Pages. Hier sollten die Dokumente nun mit Pfeilen versehen sein, was bedeutet, dass diese nun mit iCloud synchronisiert werden können. Jedes Dokument erhält einen eigenen Statusbalken, wenn dieses in die Cloud hochgeladen wird.
Es handelt sich hier allerdings um einen Alles oder Nichts Ansatz. Bedeutet, entweder werden alle Dokumente mit iCloud synchronisiert oder keines. Sobald iCloud für eine iWork Anwendung aktiviert ist, gilt das auch für alle anderen iWork Anwendungen. Sobald Änderungen an einem Dokument gemacht werden, erfolgt eine automatische Synchronisation – wenn eine Datenverbindung besteht.
Solltest Du offline arbeiten, achte darauf, dass Du Pages neu startest, nachdem das iOS Endgerät wieder online ist. Nach einer kurzen Zeit wird der Pfeil für die Synchronisation mit iCloud wieder erscheinen. Ist der Pfeil verschwunden, sind die Änderungen in die Cloud hochgeladen.
Amazon DynamoDB ist der aktuelle NoSQL Service der Amazon Web Services. Es handelt sich dabei um eine verwaltete, skalierbare und bei Bedarf nutzbare Datenbank inkl. bereitgestellten Durchsatz. Der Bereitgestellte Durchsatz ermittelt vorab die Anforderungen für den Lese-und Schreib-Durchsatz, auf deren Basis die Kosten berechnet werden.
Dieses Tutorial von cloudstory.in richtet sich an .NET Entwickler, die mit Amazon DynamoDB starten möchten. Es zeigt, wie eine Tabelle erstellt und darauf Operationen ausgeführt werden. Amazon DynamoDB bietet für .NET-Entwickler dazu eine Low-Level-API sowie eine Object-Persistence-API. Das Tutorial beschreibt, wie die Object-Persistence-API genutzt wird, um mit Amazon DynamoDB zu kommunizieren. Dazu wird als Beispiel eine DVD Bibliothek erstellt, mit der individuelle DVDs hinzugefügt, modifiziert, gesucht und gelöscht werden können.
Zunächst wird in Visual Studio ein neues Projekt angelegt und die Umgebung eingerichtet.
Dazu muss eine Referenz zu der AWSSDK.dll hinzugefügt werden. Zu finden unter C:[*]Program Files[*]AWS SDK for .NET[*]bin.
[*] bitte durch einen SLASH ersetzen.
Anschließend wird eine neue Konfigurationsdatei für die Anwendung hinzugefügt. Als Standard-Dateiname kann App.config genommen werden.
Nun benötigen wir die AWS Anmeldedaten, also den AWS Access Key und Secret Key.
Wir fügen den folgenden “using” Ausdruck hinzu.
using Amazon.DynamoDB.DataModel;
Und übernehmen den AWS Access Key und Secret Key in die App.config Datei.
Schritt 2 – Erstellen des DVD-Schema
Als Nächstes wird eine Klasse angelegt, die für das Amazon DynamoDB Schema benötigt wird.
Dazu legen wir eine neue Klasse mit dem Namen DVD.cs an.
Und fügen den folgenden “using” Ausdruck hinzu.
using Amazon.DynamoDB.DataModel;
Wir fügen die folgenden Eigenschaften hinzu und überschreiben die ToString Methode.
public class DVD
{
public string Title { get; set; }
public int ReleaseYear { get; set; }
public ListActorNames { get; set; }
public string Director { get; set; }
public string Producer { get; set; }
public override string ToString(){
return string.Format(@"{0} - {1} Actors: {2}", Title, ReleaseYear, string.Join(", ", ActorNames.ToArray()));}
}
}
Nun müssen wir Amazon DynamoDB spezifische Attribute hinzufügen, um die Tabelle, den Hash Key und Range Key identifizieren zu können. Im Folgenden befindet sich der Code der endgültigen DVD.cs inkl. aller notwendigen Attribute.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Amazon.DynamoDB.DataModel;
namespace DVDsOnCloud
{
[DynamoDBTable("DVD")]
public class DVD
{
[DynamoDBHashKey]
public string Title { get; set; }
[DynamoDBRangeKey]
public int ReleaseYear { get; set; }
[DynamoDBProperty]
public List ActorNames { get; set; }
public string Director { get; set; }
public string Producer { get; set; }
public override string ToString()
{
return string.Format(@"{0} - {1} Actors: {2}", Title, ReleaseYear, string.Join(", ", ActorNames.ToArray()));
}
}
}
Ein Hash Key ist vergleichbar mit dem Primary Key einer Tabelle. Es wird erwartet, dass dieser immer einzigartig ist und ist der am meisten genutzte Key für Anfragen. Der Range-Key ist ein sekundärer Schlüssel, der von DynamoDB verwendet wird, um einen sortierten Index-Bereich zu schaffen. Obwohl der Range Key optional ist, kann die Kombination von Hash Key und Range Key die Query-Performance optimieren.
Schritt 3 – Erstellen der DVDLibrary Hilfsklasse
Nun erstellen wir einen Wrapper für die DynamoDB API innerhalb einer Klasse, die von einem Client genutzt werden kann. Dazu erstellen wir eine neue Klasse mit dem Namen DVDLibray.cs.
Wir fügen die folgenden “using” Ausdrücke hinzu.
using Amazon;
using Amazon.DynamoDB;
using Amazon.DynamoDB.Model;
using Amazon.DynamoDB.DataModel;
using Amazon.SecurityToken;
using Amazon.Runtime;
Schritt 4 – Hinzufügen der öffentliche Mitglieder und des Konstruktors
Nun fügen wir den Konstruktor zur DVDLibrary Klasse hinzu. Der Konstruktor verwendet den AWS Security Token Authentifizierung, um die Anmeldedaten zu überprüfen.
AmazonDynamoDB client;
public DVDLibrary()
{
AmazonSecurityTokenServiceClient stsClient = new AmazonSecurityTokenServiceClient();
RefreshingSessionAWSCredentials sessionCredentials = new RefreshingSessionAWSCredentials(stsClient);
client = new AmazonDynamoDBClient(sessionCredentials);
}
Schritt 5 – Initialisierung der Amazonas DynamoDB Tabelle
In diesem Schritt initialisieren wir Amazon DynamoDB Tabelle. Wir stellen sicher, dass die Tabelle nicht existiert und erstellen eine neue. Zudem konfigurieren wir die benötigten Parameter, wie den bereitgestellten Durchsatz, Hash Key und Range Key. Das Erstellen einer Amazon DynamoDB Tabelle dauert eine Weile. Zu dieser Zeit können keine weiteren Operationen durchgeführt werden. Daher wird die Methode solange blockiert, bis der Status der Tabelle in den Zustand “Active” wechselt.
public void Init()
{
List currentTables = client.ListTables().ListTablesResult.TableNames;
if (!currentTables.Contains("DVD"))
{
CreateTableRequest reqCreateTable = new CreateTableRequest();
CreateTableResponse resCreateTable=new CreateTableResponse();
reqCreateTable.TableName = "DVD";
reqCreateTable.ProvisionedThroughput = new ProvisionedThroughput();
reqCreateTable.ProvisionedThroughput.ReadCapacityUnits=10;
reqCreateTable.ProvisionedThroughput.WriteCapacityUnits=10;
reqCreateTable.KeySchema = new KeySchema();
reqCreateTable.KeySchema.HashKeyElement = new KeySchemaElement();
reqCreateTable.KeySchema.HashKeyElement.AttributeName = "Title";
reqCreateTable.KeySchema.HashKeyElement.AttributeType = "S";
reqCreateTable.KeySchema.RangeKeyElement = new KeySchemaElement();
reqCreateTable.KeySchema.RangeKeyElement.AttributeName = "ReleaseYear";
reqCreateTable.KeySchema.RangeKeyElement.AttributeType = "N";
resCreateTable = client.CreateTable(reqCreateTable);
while (resCreateTable.CreateTableResult.TableDescription.TableStatus != "ACTIVE")
{
System.Threading.Thread.Sleep(5000);
}
}
}
Bei Amazon DynamoDB besteht die Möglichkeit, den Anforderungsdurchsatz festzulegen, den eine Tabelle erreichen soll. Der Service sorgt dann dafür, die Ressourcen bereitstehen, mit denen die erforderliche Durchsatzrate erreicht wird. Die Durchsatzanforderungen können in Bezug auf die Lesekapazität und Schreibkapazität in der Tabelle festgelegt werden. Dazu werden beim Erstellen einer Tabelle die erforderlichen Lese- und Schreibkapazitätsanforderungen angegeben. Auf dieser Basis partitioniert Amazon DynamoDB automatisch die entsprechende Anzahl von Ressourcen und reserviert diese, damit der Durchsatz erreicht wird.
Schritt 6 – Hinzufügen einer neuen DVD
Nun erstellen wir eine Funktion mit dem Namen AddDVD, die das DVD Objekt akzeptiert und ein Element in der Amazon DynamoDB erstellt.
public void AddDVD(DVD dvd)
{
DynamoDBContext context = new DynamoDBContext(client);
context.Save(dvd);
}
Schritt 7 – Ändern einer vorhandenen DVD
Als Nächstes erstellen wir eine Methode ModifyDVD, die versucht eine vorhandene DVD zu laden, diese zu modifizieren und anschließend zu speichern. Wird das Element nicht gefunden, kommt es zu einer Exception.
public void ModifyDVD(DVD dvd)
{
DynamoDBContext context = new DynamoDBContext(client);
DVD oDVD = context.Load(dvd.Title, dvd.ReleaseYear);
if(oDVD==null)
new Exception("Non-existent DVD");
context.Save(dvd);
}
Schritt 8 – Alle DVDs ausgeben
Um alle DVDs auszugeben, führen wir einen Table Scan durch.
public IEnumerable GetAllDVDs()
{
DynamoDBContext context = new DynamoDBContext(client);
IEnumerable alldvds=context.Scan();
return alldvds;
}
Wie bei jeder anderen Datenbank auch, ist ein vollständiger Scan auf Amazon DynamoDB kostspielig. Diese Operation berücksichtigt nicht den Hash Key und Range Key und durchläuft jedes Element. Der Scanvorgang wird beendet, wenn die aggregierte Größe der gescannten Objekte 1MB übersteigt. Der Client muss die Operation für den Rest der Elemente dann erneut starten.
Schritt 9 – DVDs auf Basis des Titels und Erscheinungsjahrs suchen
Um nach den DVDs zu suchen, benötigen wir den Hash Key als auch den Range Key. Daher wird diese Methode beide Schlüssel nutzen, um die DVDs zu durchsuchen.
public IEnumerable SearchDVDs(string title, int releaseyear)
{
DynamoDBContext context = new DynamoDBContext(client);
IEnumerable alldvds = context.Query(title, Amazon.DynamoDB.DocumentModel.QueryOperator.Equal, releaseyear);
return alldvds;
}
Schritt 10 – DVDs auf Basis des Titels suchen
Wenn das Erscheinungsjahr nicht zu den Suchkriterien gehören soll, nutzen wir nur die folgende Methode, die nur auf Basis des Titels sucht.
public List>SearchDVDByTitle(string title)
{
DynamoDBContext context = new DynamoDBContext(client);
QueryRequest reqQuery = new QueryRequest();
reqQuery.TableName = "DVD";
reqQuery.HashKeyValue = new AttributeValue() { S = title };
QueryResponse resQuery = client.Query(reqQuery);
return resQuery.QueryResult.Items;
}
Schritt 11 – Löschen der DVD
Mit der folgenden Methode löschen wir eine DVD.
public void DeleteDVD(DVD dvd)
{
DynamoDBContext context = new DynamoDBContext(client);
DVD oDVD = context.Load(dvd.Title, dvd.ReleaseYear);
if (oDVD == null)
new Exception("Non-existent DVD");
context.Delete(dvd);
}
Im Folgenden befindet sich der gesamte Quellcode für die DVDLibrary.cs.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Amazon;
using Amazon.DynamoDB;
using Amazon.DynamoDB.Model;
using Amazon.DynamoDB.DataModel;
using Amazon.SecurityToken;
using Amazon.Runtime;
namespace DVDsOnCloud
{
class DVDLibrary
{
AmazonDynamoDB client;
public DVDLibrary()
{
AmazonSecurityTokenServiceClient stsClient = new AmazonSecurityTokenServiceClient();
RefreshingSessionAWSCredentials sessionCredentials = new RefreshingSessionAWSCredentials(stsClient);
client = new AmazonDynamoDBClient(sessionCredentials);
}
public void Init()
{
List currentTables = client.ListTables().ListTablesResult.TableNames;
if (!currentTables.Contains("DVD"))
{
CreateTableRequest reqCreateTable = new CreateTableRequest();
CreateTableResponse resCreateTable=new CreateTableResponse();
reqCreateTable.TableName = "DVD";
reqCreateTable.ProvisionedThroughput = new ProvisionedThroughput();
reqCreateTable.ProvisionedThroughput.ReadCapacityUnits=10;
reqCreateTable.ProvisionedThroughput.WriteCapacityUnits=10;
reqCreateTable.KeySchema = new KeySchema();
reqCreateTable.KeySchema.HashKeyElement = new KeySchemaElement();
reqCreateTable.KeySchema.HashKeyElement.AttributeName = "Title";
reqCreateTable.KeySchema.HashKeyElement.AttributeType = "S";
reqCreateTable.KeySchema.RangeKeyElement = new KeySchemaElement();
reqCreateTable.KeySchema.RangeKeyElement.AttributeName = "ReleaseYear";
reqCreateTable.KeySchema.RangeKeyElement.AttributeType = "N";
resCreateTable = client.CreateTable(reqCreateTable);
while (resCreateTable.CreateTableResult.TableDescription.TableStatus != "ACTIVE")
{
System.Threading.Thread.Sleep(5000);
}
}
}
public void AddDVD(DVD dvd)
{
DynamoDBContext context = new DynamoDBContext(client);
context.Save(dvd);
}
public void ModifyDVD(DVD dvd)
{
DynamoDBContext context = new DynamoDBContext(client);
DVD oDVD = context.Load(dvd.Title, dvd.ReleaseYear);
if(oDVD==null)
new Exception("Non-existent DVD");
context.Save(dvd);
}
public IEnumerable GetAllDVDs()
{
DynamoDBContext context = new DynamoDBContext(client);
IEnumerable alldvds=context.Scan();
return alldvds;
}
public IEnumerable SearchDVDs(string title, int releaseyear)
{
DynamoDBContext context = new DynamoDBContext(client);
IEnumerable alldvds = context.Query(title, Amazon.DynamoDB.DocumentModel.QueryOperator.Equal, releaseyear);
return alldvds;
}
public List>SearchDVDByTitle(string title)
{
DynamoDBContext context = new DynamoDBContext(client);
QueryRequest reqQuery = new QueryRequest();
reqQuery.TableName = "DVD";
reqQuery.HashKeyValue = new AttributeValue() { S = title };
QueryResponse resQuery = client.Query(reqQuery);
return resQuery.QueryResult.Items;
}
public void DeleteDVD(DVD dvd)
{
DynamoDBContext context = new DynamoDBContext(client);
DVD oDVD = context.Load(dvd.Title, dvd.ReleaseYear);
if (oDVD == null)
new Exception("Non-existent DVD");
context.Delete(dvd);
}
}
}
Der komplette Quellcode
Im Folgenden ist der vollständige Code des Clients zu finden, der auf die DVDLibrary zugreift.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DVDsOnCloud
{
class Program
{
static void Main(string[] args)
{
//Create the helper object
DVDLibrary DVDLib= new DVDLibrary();
//Initialize
DVDLib.Init();
//Create the DVD object
DVD dvd = new DVD() { Title = "Businessman", ReleaseYear = 2011, ActorNames = new List { "Mahesh", "Kajal" }, Director = "Puri Jagannath", Producer = "Venkat" };
//Add the new DVD
DVDLib.AddDVD(dvd);
//Print all the DVDs
foreach (var odvd in DVDLib.GetAllDVDs())
Console.WriteLine(odvd.Title);
//Create a new DVD object with modified values
DVD newdvd = new DVD() { Title = "Businessman", ReleaseYear = 2011, ActorNames = new List { "Mahesh Babu", "Kajal Agarwal" }, Director = "Puri Jagannath", Producer = "Venkat" };
//Commit the changes
DVDLib.ModifyDVD(newdvd);
//Search for the DVD
foreach (var dvd in DVDLib.SearchDVDs("Businessman",2011))
Console.WriteLine(dvd.Director);
//Delete the DVD
DVDLib.DeleteDVD(newdvd);
}
}
}
Amazon EC2 Micro Instanzen stehen nur 613 MB Arbeitsspeicher zur Verfügung. Das reicht in den meisten Fällen nicht, um große Datenmengen performant zu verarbeiten. Hinzu kommt, dass die Linux Micro Instanzen standardmäßig keine Swap Partition haben.
Mit den folgenden Schritten wird einer Linux basierten Amazon EC2 Micro Instanz eine Swap Partition hinzugefügt, wodurch deren Leistung erhöht werden kann.
Zunächst melden wir uns als Root an und geben folgenden Befehl ein, um die Werte für die gewünschte Blockgröße anzugeben.
dd if=/dev/zero of=/swapfile bs=1M count=1024
Anschließend richten wir das Swapfile ein.
mkswap /swapfile
Nun aktivieren das Swapfile.
swapon /swapfile
Um das Swapfile während des Bootvorgangs zu aktivieren, tragen wir folgendes in die /etc/fstab ein.
Vor kurzem haben wir Witsbits, einen “Private Cloud Management as a Service” aus Schweden vorgestellt. Heute geht es darum, wie vorgegangen werden muss, um Witsbits im eigenen Rechenzentrum/ Serverraum nutzen zu können.
Vorbereitung
Zunächst benötigen wir einen oder mehrere “leere” physikalische Systeme (64bit) als Host für die virtuelle Infrastruktur sowie einen Desktop Computer inkl. Webbrowser, mit dem die webbasierte Management Konsole genutzt werden kann.
Der physikalische Server sollte mindestens über einen 64 bit x86 Prozessor mit Intel VT oder AMD-V Technologie verfügen sowie ein CD-ROM, DVD-ROM oder USB-Ports, um darüber die Installation mittels des Witsbits ISO zu ermöglichen. Der Arbeitsspeicher sollte eine Mindestgröße von 1GB RAM besitzen und die Festplatte sollte nicht zu klein ausfallen, da hier die virtuellen Festplatten und Snapshots der virtuellen Maschinen gespeichert werden.
Weiterhin benötigen wir eine für DHCP konfigurierte Netzwerkumgebung inkl. einer aktiven Internetverbindung. Der DHCP-Server wird IP Adressen für die physikalischen Hosts als auch die virtuellen Maschinen bereitstellen müssen. Jeder physikalische Host benötigt zudem eine Vielzahl an IP Adressen, je nach Anzahl der virtuellen Maschinen, die auf ihm laufen sollen.
Für die Verwaltung der GoCloud Infrastruktur wird ein gewöhnlicher Desktop PC mit Windows, Linux oder Mac Betriebssystem oder ein Smartphone benötigt. Die Managementoberfläche unterstützt derzeit den Internet Explorer 7 und 8, Firefox, Chrome/Chromium und Safari.
Installation und Einrichtung von Go Cloud
Als erstes benötigen wir einen Go Cloud Account. Nach der erfolgreichen Registrierung laden wir uns das ISO Image (ca. 180 MB) herunter und entpacken es.
Nun erstellen wir uns aus dem ISO Image entweder eine bootbare CD/DVD oder einen USB-Stick. Anschließend starten wir den physikalischen Server mit dem ISO Image. Voraussetzung hierfür ist, dass der Server via eines DHCP Servers IP Adressen empfangen kann und das eine aktive Internetverbindung besteht. Der physikalische Host wird sich nun automatisch mit dem Go Cloud Management System verbinden. Nach dem Bootvorgang kann die CD/DVD oder der USB-Stick entfernt werden und dieselbe Prozedur kann mit dem nächsten physikalischen Server erfolgen.
Das zuvor heruntergeladene ISO Image ist mit einer persönlichen Account-ID gekennzeichnet, wodurch alle Server die mit dem ISO Image gebootet werden automatisch an dem Go Cloud Management System dieses Accounts registriert werden. Nachdem das Host System vollständig gebooted wurde, erscheint es auf der Management Konsole in der Weboberfläche. Der physikalische Server ist nun soweit vorbereitet, um virtuelle Maschinen zu starten.
Verwaltung der physikalischen Server und virtuellen Maschinen
Um einen physikalischen Server zu konfigurieren klicken wir in der Web Konsole zunächst auf “Physical Servers”. Hier sollte nun ein neuer Server mit einem Datum sowie einem Timestamp zu sehen sein. Hier wählen wir nun “New Server” und anschließend “Initiate Disks”. Das kann einen Moment dauern. Das darauf folgende Pop-Up bestätigen wir. Go Cloud sucht nun die größte Festplatte, entfernt von dieser alle Partitionen und erstellt eine Große. Wir müssen nun ein paar Mal aktualisieren (F5) bis der “Update Repo (Repository)” Button aktiv ist. Nachdem die Festplatte initialisiert ist, sollte auch die Queue leer sein. Wir klicken anschließen den “Update Repo (Repository)” Button.
Die Public Images von Go Cloud werden nun heruntergeladen und extrahiert. Abhängig von der Internetverbindung kann dieses bis zu 15 Minten dauern. Nach Beendigung wird dieser Job aus der Queue verschwinden.
Um eine erste virtuelle Maschine (VM) auf dem physikalischen Host zu erstellen, geben wir der VM als erstes einen Namen und hinterlegen für das Image ein Passwort. Als nächstes wählen wir ein Image bzw. Gast Betriebssystem und entscheiden uns für die Anzahl an CPUs sowie die Größe des zuzuweisenden Arbeitsspeichers. Mit dem klick auf den Button “Power On” wird ein neues VM Image erstellt, welches unten angezeigt wird. Der Status des Image sollte grün (OK) sein sowie die VM eine zugewiesene IP Adresse haben.
Per Remote Desktop, dem Administrator Passwort und dem Image Passwort der erstellten VM kann die VM nun gestartet werden. Für die Anmeldung benötigen wir hier das Passwort des VM Image und nicht das Passwort für die Anmeldung an Go Gloud.
Eine Ubuntu Enterprise Cloud kann aus zwei, bzw. bis zu hunderten oder sogar tausenden physikalischen bestehen. Es ist daher wichtig, die möglichen Topologien zu verstehen, die auf Basis der vorhandenen physikalischen Maschinen aufzubauen sind.
1 physikalisches System (Nicht für den produktiven Einsatz empfohlen)
Dies ist die einfachste mögliche Konfiguration. Dabei werden der CLC/Walrus/CC/SC und NC alle gemeinsam auf einer einzigen Maschine betrieben. Diese Konfiguration unterscheidet sich nicht von allen anderen möglichen. Der einzige Unterschied besteht darin, dass der Netzwerkverkehr hierbei nicht durch das lokale Netzwerk übertragen wird.
1. Maschine A: CLC/Walrus/CC/SC/NC
Beispiel Konfiguration (für ein bestehendes LAN)
Netzwerk Konfiguration:
Netzwerk: 192.168.1.0/24
DHCP und DNS Server: 192.168.1.2
UEC Server: 192.168.1.4
/etc/network/interfaces auf dem UEC Server
iface eth0 inet manual
auto br0
iface br0 inet static
address 192.168.1.4
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255
gateway 192.168.1.2
# dns-* options are implemented by the resolvconf package, if installed
# these are google's dns servers
dns-nameservers 8.8.8.8 8.8.4.4
# this setting could be "local" if you all your local hosts
# were named something like a.localdomain b.localdomain c.localdomain etc
dns-search localdomain
bridge_ports eth0
bridge_fd 9
bridge_hello 2
bridge_maxage 12
bridge_stp off
VNET_PUBINTERFACE="br0" # must match the br definition above
VNET_PRIVINTERFACE="br0" # must match the br definition above
VNET_MODE="MANAGED-NOVLAN"
VNET_SUBNET="172.19.0.0" # ips from this range are bound to $VNET_PRIVINTERFACE:priv
VNET_NETMASK="255.255.0.0"
VNET_DNS="192.168.1.2" # what DNS server nodes are given
# v - should be ips on the LAN, not in use anywhere, and excluded from the DHCP server
VNET_PUBLICIPS="192.168.1.100-192.168.1.110"
Sollten das Netzwerk nach der Konfiguration nicht starten helfen die folgenden Befehle beim Korrigieren.
sudo stop eucalyptus CLEAN=1
sudo /etc/init.d/eucalyptus-nc stop
# fix the config file here
sudo start eucalyptus CLEAN=1
sudo /etc/init.d/eucalyptus-nc start
Der Parameter CLEAN sorgt dafür, dass sich das Netzwerk nicht bei jedem Neustart resetet. Es sollte darauf geachtet werden, dass kein System auf die ETH0 Schnittstelle gebunden ist. Um sicherzugehen, dass man mit einer sauberen Konfiguration arbeiten kann, ist ein Neustart des gesamten Systems. Wurde die PRIV Schnittstelle falsch konfiguriert, werden die Nodes ihre DHCP-Antworten von dem LAN-DHCP-Server anstelle des privaten CC-DHCP-Server erhalten.
Mindestens 2 physikalische Systeme
Bei dieser Konfiguration werden alle Verwaltungskomponenten für den Benutzer wie CLC und Walrus, sowie die Verwaltungskomponenten für das Backend wie der CC und SC auf einer gemeinsamen Maschine installiert. Der NC für das Hosting der virtuellen Maschinen erhält eine eigene physikalische Maschine.
Bei dieser Konfiguration werden die Verwaltungskomponenten für den Benutzer wie CLC und Walrus auf eine physikalische Maschine, sowie die Verwaltungskomponenten für das Backend wie der CC und SC auf einer weiteren zweiten Maschine installiert. Der NC für das Hosting der virtuellen Maschinen wird auf eine dritte physikalische Maschine installiert.
Bei dieser Konfiguration erhalten der CLC und Walrus jeweils eine eigene physikalische Maschine. Auf die dritte Maschine werden der CC und SC installiert. Für den NC wird eine vierte physikalische Maschine eingesetzt.
Für diese Konfiguration werden der CLC und der Walrus auf einer gemeinsamen Maschine konfiguriert. Auf eine dritte Maschine werden der CC1 sowie der SC1 installiert. Für den NC1 kommt eine eigene Maschine zum Einsatz. Um die Performance der Cloud zu erhöhen und die Last besser zu verteilen, werden auf einer vierten Maschine ein CC2 und ein SC2 konfiguriert. Auf eine fünfte Maschine wird ein NC2 installiert, der anschließend seine Ressourcen von dem CC2 und SC2 erhält.
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.
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”.
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.
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.
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]#
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:
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.
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:
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.
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:
Nach der Vorstellung und weiteren Hintergrundinformationen zur domainFACTORY “JiffyBox”, gibt dieses Tutorial einen Einblick in das Innere. Dazu habe ich von der domainFACTORY GmbH einen kostenlosen Testzugang erhalten, für den ich mich auf diesem Wege bedanken möchte!
Nach einer erfolgreichen Anmeldung werden wir im Control Panel begrüßt, wo wir im ersten Schritt mittels “Jetzt Trial-Server bestellen” einen kostenlosen Test der JiffyBox vornehmen können oder uns über “Neue JiffyBox erstellen” eine neue JiffyBox erzeugen. Wir wählen hier den zweiten Schritt.
Wir geben der neuen JiffyBox einen Namen, wählen einen Tarif, hier “CloudLevel 1 – mit 1 GB Arbeitsspeicher und 50 GB Festplatte für 0,02 € / Stunde” und eine Linux Distribution, hier “Ubuntu 10.04 LTS”. Würden wir bereits über eine JiffyBox verfügen, hätten wir als Distribution ebenfalls ein Backup als Quelle angeben können.
Unter dem Punkt “Erweitert” können wir der JiffyBox ein selbst gewähltes Root Passwort zuweisen. Anschließend wählen wir “Erstellen”.
Die JiffyBox wird nun automatisch im Hintergrund erzeugt. Statusinformationen zeigen dabei den aktuellen Vorgang!
Zurück im “Control Panel” sehen wir die erzeugte JiffyBox und können nun mittels “Konfigurieren” weitere Einstellungen vornehmen, die JiffyBox “Starten”, “Einfrieren” oder wieder vollständig “Löschen”.
Hinter dem Menüpunkt “Voreinstellungen” verbirgt sich das Schlüsselmanagement, wo wir mehrere SSH-Public-Keys eintragen können.
Über den Punkt “Alle Meldungen” gelangen wir in den Statusbereich. Hier erhalten wir detailliert alle Informationen zu allen Vorgängen innerhalb unseres Accounts.
Weitere Informationen
Über den Menüpunkt “Account” gelangen wir direkt zu den Stammdaten.
Weiterhin können wir über “Kundenservice” direkt elektronischen Kontakt zu dem domainFACTORY Support aufnehmen und erhalten einen historischen Überblick über alle bisherigen Anfragen.
Wir können zusätzlich über den Menüpunkt “Passwörter”, unsere Passwörter für das JiffyBox Control Panel und dem Telefon Support eigenständig ändern. Zudem erhalten wir einen Überblick über alle bisher gestellten Rechnungen durch domainFACTORY über den Punkt “Rechnungen”.
Der Menüpunkt “Verbräuche” gibt einen genauen Überblick zu den bisher entstandenen Kosten zu allen JiffyBoxen und dem verbrauchten Traffic.
Weiterhin erhalten wir einen detaillierten Überblick über die Nutzung jeder einzelnen, in unserem Account vorhandenen, JiffyBox.
Sowie vom derzeit verbrauchten Traffic.
Ein weiteres interessantes Feature ist die Möglichkeit zur Begrenzung der Kosten. Hier kann ein Betrag (in EUR) als Obergrenze eingetragen werden und die Folgeaktion, die stattfinden soll, wenn der Betrag erreicht wird.
Um die JiffyBox über Skripte zu steuern, haben wir über den Menüpunkt “API-Zugriff” die Möglichkeit, einen API-Token zu erzeugen. Weitere Informationen für die Nutzung der API sind in der PDF-Datei “JiffyBox-API” zu finden.
Arbeiten mit der JiffyBox
Zurück im Control Panel wollen wir nun ein Blick hinter die Konfigurationsmöglichkeiten einer JiffyBox werfen. Wie wir sehen werden, stehen uns dazu viele Möglichkeiten zur Verfügung. Wir wählen dazu unter “Ihre JiffyBoxen” die Aktion “Konfigurieren”.
Wir erhalten zunächst einen Überblick zu allen notwendigen Informationen, wie der aktuellen IP-Adresse und dem aktuellen Hostnamen, dem genutzten Tarif, dem verfügbaren Arbeitsspeicher und der Festplattengröße, sowie der für diese JiffyBox verwendeten Linux Distribution.
Über “Profile und Festplatten” können wir weitere Konfigurationen am System, der Festplattengröße und deren Zuordnung vornehmen.
Hinter “Netzwerk” verbergen sich weitere Informationen zu den IP und DNS Informationen. Hier haben wir die Möglichkeit den “Reverse-DNS” Namen zu ändern und eine weitere IP-Adresse zu bestellen.
Von jeder JiffyBox werden automatisch tägliche Backups erstellt. Dennoch haben wir die Option über den Menüpunkt “Backups” ein manuelles Backup zu starten, bzw. eigene Backup Pläne zu erstellen.
Über “Konsole und Recovery” steht uns der Zugriff mittels einer Web-Konsole und per SSH-Konsole zur Verfügung. Weiterhin kann ein Recovery-System aktiviert werden, um die JiffyBox im Notfallmodus zu starten.
Um die JiffyBox nun zu nutzen, wählen wir im Control Panel unter “Ihre JiffyBoxen” lediglich “Starten”.
Mittels eines SSH-Clients, hier Putty, verbinden wir uns mit der JiffyBox. Die dazu benötigte IP-Adresse bzw. den DNS-Namen erhalten wir unter dem Menüpunkt “Netzwerk” in dem Konfigurationsbereich der JiffyBox.
Anschließend melden wir uns mit dem Benutzer “root” und dem von uns bei dem Erstellen der JiffyBox unter “Erweitert” gewählten Passwort an.
Damit sind wir mit unserer ersten eigenen JiffyBox verbunden.
Um die JiffyBox wieder zu beenden, wählen wir im Control Panel für die entsprechende JiffyBox “Stoppen”.
Und dann “Herunterfahren”.
Die JiffyBox wird anschließend automatisch heruntergefahren. Eine Statusmeldung informiert uns über den erfolgreichen Vorgang.
Die JiffyBox kann anschließend wieder angepasst, gestartet, eingefriert oder gelöscht werden.
Die Verbrauchsanzeige informiert uns darüber, dass für eine Gesamtdauer von 1:33:36 Stunden bisher 0,03 EUR entstanden sind.
Das Ziel einer Private Cloud besteht nicht darin, der Öffentlichkeit eine Schnittstelle zur Cloud zur Verfügung zu stellen. um damit eigene Kapazitäten über der Internet anzubieten. Es geht vielmehr darum, seinen eigenen lokalen Nutzern eine flexible und agile private Infrastruktur bereitzustellen, in der die genutzten Services virtualisiert innerhalb eines selbst administrierten Bereich ausgeführt werden, um die Belastung effizient aufzuteilen. Die virtuelle Infrastruktur-Schnittstelle von OpenNebula stellt den Administratoren Funktionen für die Virtualisierung, die Netzwerkverwaltung, die Konfiguration von Images und physischen Ressourcen, das Management, sowie dem Monitoring und dem Accounting.
Die Sicht des Benutzers
Mit einer OpenNebula Private Cloud steht Nutzern der Infrastruktur eine elastische Plattform zum schnellen Bereitstellen und Skalieren von Services bereit, um den dynamischen Anforderungen gerecht zu werden. Die virtuelle Infrastruktur-Schnittstelle bietet folgenden Möglichkeiten, um Services auf virtuellen Maschinen zu hosten, bereitzustellen, sowie zu kontrollieren und zu überwachen.
Kommandozeile
XML-RPC API
Libvirt Virtualization API inkl. Management Tools
Die folgenden Beispiele zeigen die Funktionalität, die von der OpenNebula Kommandozeile bereitgestellt wird, um eine Private Cloud zu verwalten.
Zunächst überprüfen wir den Host und den physikalischen Cluster:
$ onehost list
HID NAME RVM TCPU FCPU ACPU TMEM FMEM STAT
0 host01 0 800 800 800 8194468 7867604 on
1 host02 0 800 797 800 8387584 1438720 on
Anschließend kann mittels onevm eine virtuelle Maschine an OpenNebula übertragen werden. Dazu wird als erstes ein Template einer virtuellen Maschine benötigt, aus dem ein Image erstellt wird. Das Image wird in dem Verzeichnis /opt/nebula/images abgelegt.
CPU = 0.5
MEMORY = 128
OS = [
kernel = "/boot/vmlinuz-2.6.18-4-xen-amd64",
initrd = "/boot/initrd.img-2.6.18-4-xen-amd64",
root = "sda1" ]
DISK = [
source = "/opt/nebula/images/disk.img",
target = "sda1",
readonly = "no" ]
DISK = [
type = "swap",
size = 1024,
target = "sdb"]
NIC = [ NETWORK = "Public VLAN" ]
Nachdem die virtuelle Maschine z.B. bzgl. der CPU und des Arbeitsspeichers auf die eigenen Bedürfnisse angepasst wurde, kann diese übertragen werden.
$ onevm submit myfirstVM.template
Nach dem Übertragen der virtuellen Maschine erhalten wir eine ID, mit welcher die virtuelle Maschine identifiziert werden kann, um diese zu überwachen und zu steuern. Die ID erhalten wir mit dem folgenden Befehl:
$ onevm list
ID USER NAME STAT CPU MEM HOSTNAME TIME
0 oneadmin one-0 runn 0 65536 host01 00 0:00:02
Das Feld STAT beschreibt den aktuellen Status der virtuellen Maschine. Befindet sich dieser im Status runn, ist die virtuelle Maschine online und wird ausgeführt. Abhängig davon, wie das Image konfiguriert wurde, haben wir Kenntnis von der IP-Adresse, wodurch wir uns auf der virtuellen Maschine anmelden können.
Um eine Migration durchzuführen, verwenden wir erneut den onevm Befehl. Wenn wir z.B. die virtuelle Maschine (VID=0) nach host02 (HID=1) übertragen wollen, nutzen wir:
$ onevm livemigrate 0 1
Damit wird die virtuelle Maschine von host01 nach host02 übertragen. Der Befehl onevm list sollte eine ähnliche Ausgabe der Folgenden anzeigen:
$ onevm list
ID USER NAME STAT CPU MEM HOSTNAME TIME
0 oneadmin one-0 runn 0 65536 host02 00 0:00:06
Wie das System funktioniert
OpenNebula – Eigenschaften
Verwaltung virtueller Netzwerke: Virtuelle Netzwerke verbinden die einzelnen virtuellen Maschinen.
Erstellen virtueller Maschinen: Die Beschreibung jeder einzelnen virtuellen Maschine wird der Datenbank hinzugefügt.
Bereitstellen virtueller Maschinen: Der Scheduler entscheided auf Basis von Richtlinien, wo eine virtuelle Maschine ausgeführt wird.
Verwaltung virtueller Maschinen Images: Vor dem Ausführen werden die virtuellen Maschinen Images zu dem Host übertragen und SWAP Disk Images erstellt. Nach dem Ausführen werden die virtuellen Maschinen Images in das Repository zurückkopiert.
Verwaltung gestarteter virtueller Maschinen: Virtuelle Maschinen werden gestartet und der aktuelle Status periodisch abgefragt. Zudem können die virtuellen Maschinen heruntergefahren, angehalten, gestopped und migriert werden.
OpenNebula Private Cloud – Die wichtigsten Komponeten
Hypervisor: Der Virtualisierungsmanager – auf den Ressourcen des Clusters installiert, die OpenNebula für die Verwaltung der virtuellen Maschinen vorgesehen hat.
Virtual Infrastructure Manager: Zentrale Verwaltungseinheit zum Steuern und Überwachen der virtuellen Maschinen und Ressourcen. Unterstützt weiterhin die Verwaltung der virtuellen Netzwerke, das Life-Cycle Management der virtuellen Maschinen, das Management der virtuellen Maschinen Images sowie die Fehlertoleranz.
Scheduler: Verwaltung der Richtlinien für die virtuellen Maschinen hinsichtlich der gleichmäßigen Verteilung der Last, Server Konsolidierung, Zugehörigkeit, Reservierung der Kapazitäten und SLAs
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”.
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$
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.
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
Eine Public 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.
Die Sicht des Benutzers
Die folgenden Schittstellen stellen eine einfache Möglichkeit für das Remote Management von Cloud Ressourcen dar.
EC2 Query subset
RESERVOIR Cloud Interface und OGF OCCI
Benutzer haben die Möglichkeit, Befehle zu verwenden, welche die Funktionalität der Amazon EC2 Services abbilden. Mit drei einfachen Befehlen kann ein bereits vorinstalliertes Betriebssystem (als vorhandene .img Datei) in der Cloud gestartet werden.
Weiterhin kann die ausgeführte Instanz überwacht werden:
$ ./econe-describe-instances -H
Owner Id ImageId State IP Type
------------------------------------------------------------------------------------------------------------
helen 15 872ce740-5904-012c-08e0-0017f231be96 pending 147.96.80.33 m1.small
Wie das System funktioniert
Es müssen keine Änderung an der Funktionsweise von OpenNebula vorgenommen werden, um Cloud Schnittstellen bereitzustellen. Benutzer können sich mit der Infrastruktur verbinden, indem sie eine Private oder Public Cloud Schnittstelle verwenden.
der Öffentlichkeit eine Schnittstelle zur Cloud zur Verfügung zu stellen. um damit eigene Kapazitäten über der Internet anzubieten. Es geht vielmehr darum, seinen eigenen lokalen Nutzern eine flexible und agile private Infrastruktur bereitzustellen, in der die genutzten Services virtualisiert innerhalb eines selbst administrierten Bereich ausgeführt werden, um die Belastung effizient aufzuteilen. Die virtuelle Infrastruktur-Schnittstelle von OpenNebula stellt den Administratoren Funktionen für die Virtualisierung, die Netzwerkverwaltung, die Konfiguration von Images und physischen Ressourcen, das Management, sowie dem Monitoring und dem Accounting.
Infrastruktur eine elastische Plattform zum schnellen Bereitstellen und Skalieren von Services bereit, um den dynamischen Anforderungen gerecht zu werden. Die virtuelle Infrastruktur-Schnittstelle bietet folgenden Möglichkeiten, um Services auf virtuellen Maschinen zu hosten, bereitzustellen, sowie zu kontrollieren und zu überwachen.
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.