XING: https://www.xing.com/profile/Holger_SirtlLinkedIn: http://de.linkedin.com/in/hsirtl
Auf MSDN ist seit heute ein neuer Webcast von mir verfügbar:
SQL Azure (Version Mai 2011) – Überblick, Einblick, Ausblick
In diesem Webcast gebe ich einen Überblick über SQL Azure, zeige, wie sich SQL Azure administrieren lässt, erläutere an einem Beispiel die Synchronisation einer lokalen Datenbank mit SQL Azure und gebe einen Ausblick auf zukünftige Erweiterungen von SQL Azure.
Weitere Informationen
Die TechEd North America hat gerade ihre Pforten geschlossen… und einiges an Material für alle Azure-Interessierten zurück gelassen, sprich: die Videos der TechEd-Sessions sind für alle auf Channel 9 verfügbar.
Hier möchte ich einige für Cloud Computing, Azure und Office 365 relevante Sessions auflisten:
Cloud Computing und Azure allgemein
Windows Azure
SQL Azure
Windows Azure AppFabric
Office 365 (Auswahl)
Viel Spaß beim Schauen!
PS: natürlich keine Ganrantie für Vollständigkeit
Der SQL Azure Sync Service erlaubt es, eine lokale Datenbank mit einer SQL Azure Datenbank zu synchronisieren. D.h. Änderungen, die in einer der beiden beteiligten Datenbanken vorgenommen werden, können bei Bedarf in die jeweils andere Datenbank übertragen werden. Damit wird es sehr einfach möglich, Offline-Szenarien zu realisieren, in denen beim Ausfall der Internet-Verbindung mit einer lokalen Datenbank weitergearbeitet werden kann. Änderungen, die in dieser Zeit lokal vorgenommen werden, können dann sehr leicht nach SQL Azure übertragen werden, wenn die Verbindung wieder steht.
Das Microsoft Sync Framework
Synchronisation zwischen SQL Azure und einer lokalen Datenbank wird mit Hilfe des Microsoft Sync Frameworks implementiert. In den folgenden Abschnitten soll eine kleine Konsolenanwendung entwickelt werden, die eine Synchronisationsbeziehung zwischen einer lokalen SQL Express Datenbank und einer SQL Azure Datenbank herstellt. Die Architektur ist in Abbildung 1 zu sehen.
Abbildung 1: Architektur einer Sync Framework basierten Lösung
Eine auf dem Sync Framework aufsetzende Lösung enthält in der Regel folgende Komponenten, die in der Architekturabbildung zu sehen sind:
Starten Sie nun Visual Studio und legen über den Menüpunkt File / New / Project ein neues Projekt an. Wählen sie als Projektvorlage eine Konsolenanwendung (Visual C# / Windows / Console Application). Da die Anwendung das Sync Framework nutzen soll, werden vier DLLs benötigt, die in Tabelle 1 aufgelistet sind.
Datei (C:\Program Files\Microsoft Sync Framework\...)
Namespace
2.1\Runtime\x86\ Microsoft.Synchronization.dll
Microsoft.Synchronization
2.1\Runtime\ADO.NET\V3.1\x86\ Microsoft.Synchronization.Data.dll
Microsoft.Synchronization.Data
2.1\Runtime\ADO.NET\V3.1\x86\ Microsoft.Synchronization.Data.Server.dll
Microsoft.Synchronization.Data.Server
2.1\Runtime\ADO.NET\V3.1\x86\ Microsoft.Synchronization.Data.SqlServer.dll
Microsoft.Synchronization.Data.SqlServer
Tabelle 1: Für das Sync Framework benötigte Dateien und Namespaces
Nach Hinzufügen der DLLs sollte der Solution Explorer die entsprechenden Namespaces wie in Abbildung 2 zu sehen auflisten.
Abbildung 2: Referenzen zum Sync Framework
Die Konsolenanwendung soll die folgenden zwei Funktionalitäten bieten:
Die beiden hierzu benötigten Methoden sind in Listing 1 zu sehen. Sie werden je nach Aufrufparameter aufgerufen. Fehlt der Aufrufparameter, wird eine entsprechende Information auf der Konsole angezeigt.
1: using System;
2: using System.Data.SqlClient;
3: using Microsoft.Synchronization.Data.SqlServer;
4: using Microsoft.Synchronization.Data;
5: using Microsoft.Synchronization;
6:
7: namespace SyncTest
8: {
9: class Program
10: {
11: public static string sqlazureConnectionString =
12: @"Server=<MEIN_SERVER>.database.windows.net;
13: Database=<MEINE_DATENBANK>; @
14: User ID=<MEIN_SERVER_ADMIN_USER>@<MEIN_SERVER>; @
15: Password=<MEIN_SERVER_ADMIN_PASSWORT>; @
16: Trusted_Connection=False; @
17: Encrypt=True;"; @
18: public static string sqllocalConnectionString =
19: @"Server=.\SQLEXPRESS;
20: Database=<MEINE_LOKALE_DATENBANK>; @
21: Trusted_Connection=True"; @
22:
23: public static readonly string scopeName = "alltablesyncgroup";
24:
25: static void Main(string[] args)
26: {
27: // Test if input arguments were supplied:
28: if (args.Length == 0)
29: {
30: System.Console.WriteLine("Please enter an argument.");
31: System.Console.WriteLine("Usage: SyncTest.exe -setup");
32: System.Console.WriteLine(" SyncTest.exe -sync");
33: }
34:
35: else if (args[0] == "-setup")
36: Setup();
37: else if (args[0] == "-sync")
38: Sync();
39: }
40:
41: public static void Setup() { ... }
42: public static void Sync() { ... }
43: }
44: }
45: }
Listing 1: Code-Gerüst für die Sync Anwendung
Die beiden Connection-Strings definieren den Zugang zu den beiden beteiligten Datenbanken. Ersetzen Sie die Platzhalter durch die für Ihre Datenbanken gültigen Werte.
Konfiguration der beteiligten Datenbanken
Bevor eine Synchronisation der Datenbanken durchgeführt werden kann, müssen diese entsprechend vorbereitet werden. Dabei werden in den Datenbanken Hilfstabellen angelegt, in denen Synchronisationsinformationen gespeichert werden. Das Schema der zu synchronisierenden Tabellen bleibt dabei unverändert. Für die initiale Konfiguration der Datenbanken implementieren Sie die Setup()-Methode nun wie in Listing 2 gezeigt. Die dort durchgeführte Konfiguration setzt voraus, dass Sie die SQL Azure Datenbank wie in meinem letzten Blog-Eintrag zu SQL Azure beschrieben aufgesetzt haben, d.h. eine Kunden-Tabelle existiert.
1: public static void Setup()
2: {
3: try
4: {
5: SqlConnection sqlServerConn = new SqlConnection(sqllocalConnectionString);
6: SqlConnection sqlAzureConn = new SqlConnection(sqlazureConnectionString);
7: DbSyncScopeDescription myScope = new DbSyncScopeDescription(scopeName);
8:
9: DbSyncTableDescription Customer =
10: SqlSyncDescriptionBuilder.GetDescriptionForTable("Kunden", sqlAzureConn);
11:
12: // Add the tables from above to the scope
13: myScope.Tables.Add(Customer);
14:
15: // Setup SQL Server for sync
16: SqlSyncScopeProvisioning sqlServerProv =
17: new SqlSyncScopeProvisioning(sqlServerConn, myScope);
18: if (!sqlServerProv.ScopeExists(scopeName))
19: {
20: // Apply the scope provisioning.
21: Console.WriteLine("Provisioning SQL Server for sync " + DateTime.Now);
22: sqlServerProv.Apply();
23: Console.WriteLine("Done Provisioning SQL Server for sync " + DateTime.Now);
24: }
25: else
26: Console.WriteLine("SQL Server Database server already provisioned for sync " +
27: DateTime.Now);
28:
29: // Setup SQL Azure for sync
30: SqlSyncScopeProvisioning sqlAzureProv =
31: new SqlSyncScopeProvisioning(sqlAzureConn, myScope);
32: if (!sqlAzureProv.ScopeExists(scopeName))
33: {
34: // Apply the scope provisioning.
35: Console.WriteLine("Provisioning SQL Azure for sync " + DateTime.Now);
36: sqlAzureProv.Apply();
37: Console.WriteLine("Done Provisioning SQL Azure for sync " + DateTime.Now);
38: }
39: else
40: Console.WriteLine("SQL Azure Database server already provisioned for sync " +
41: DateTime.Now);
42:
43: sqlAzureConn.Close();
44: sqlServerConn.Close();
46: catch (Exception ex)
47: {
48: Console.WriteLine(ex);
49: }
50: }
Listing 2: Methode zum Initialisieren der Synchronisationsbeziehung
Die Methode baut zunächst Verbindungen zu den beiden Datenbanken (wie über die Connection-Strings konfiguriert) auf und initialisiert einen sogenannten Sync-Scope. Dieser legt den Bereich, d.h. die Tabellen, fest, der synchronisiert werden soll. Danach wird die Schema-Information der Kunden-Tabelle ermittelt und dem Sync-Scope hinzugefügt. Anschließend wird der Sync-Scope zunächst auf der lokalen Datenbank und dann in SQL Azure provisioniert. Abschließend werden die Verbindungen zu den Datenbanken wieder geschlossen. Bauen Sie die Solution durch Auswahl des Menüpunkts Build / Build Solution. Öffnen sie anschließend ein Konsolenfenster und wechseln dort in das Verzeichnis, in das Visual Studio die exe-Datei geschrieben hat. Abbildung 3 zeigt die Konsolenausgabe bei Ausführung der Anwendung (zuerst Aufruf ohne Parameter, dann mit Parameter -setup).
Abbildung 3: Initialisierung des Sync Frameworks
Damit ist die Initialisierung der Datenbanken abgeschlossen. Das Sync Framework hat in beiden Datenbanken Hilfstabellen angelegt, in denen Änderungen bis zur nächsten Synchronisation zwischengespeichert werden. Abbildung 4 zeigt die Tabellenansicht aus dem SQL Server Management Studio vor und nach der Initialisierung.
Abbildung 4: Tabellen vor und nach Initialisierung des Sync Frameworks
Vor der Initialisierung ist nur in SQL Azure eine Kunden-Tabelle vorhanden. Nach der Initialisierung wurde zum einen die Tabelle auch in der lokalen Datenbank angelegt (ja, dies erledigt das Sync Framework automatisch), zum anderen wurden in beiden Datenbanken die Hilfstabellen angelegt. Noch wurden allerdings keine Daten übertragen. Die Änderungen beziehen sich noch ausschließlich auf die Schemata.
Synchronisation mit einer lokalen Datenbank
Nun soll die Sync()-Methode implementiert werden, mit deren Hilfe eine Synchronisation der beiden Datenbanken, d.h. ein Datenabgleich, erfolgen kann. Implementieren Sie die Methode wie in Listing 3 gezeigt. Die Methode baut Verbindungen zu den beiden Datenbanken auf und instanziiert einen neuen Sync-Orchestrator. Im Orchestrator werden zwei passende Sync-Provider und die gewünschte Synchronisationsrichtung definiert. Im Beispiel soll die Synchronisation in beide Richtungen erfolgen.
1: public static void Sync()
7: SyncOrchestrator orch = new SyncOrchestrator
9: LocalProvider = new SqlSyncProvider(scopeName, sqlServerConn),
10: RemoteProvider = new SqlSyncProvider(scopeName, sqlAzureConn),
11: Direction = SyncDirectionOrder.UploadAndDownload
12: };
13:
14: Console.WriteLine("ScopeName={0} ", scopeName);
15: Console.WriteLine("Starting Sync " + DateTime.Now);
16:
17: ShowStatistics(orch.Synchronize());
18:
19: sqlAzureConn.Close();
20: sqlServerConn.Close();
21: }
22: catch (Exception ex)
23: {
24: Console.WriteLine(ex);
25: }
26: }
27:
28: public static void ShowStatistics(SyncOperationStatistics syncStats)
30: Console.WriteLine("General Sync Statistics");
31: Console.WriteLine("=======================");
32: Console.WriteLine("\tSync Start Time : " + syncStats.SyncStartTime.ToString());
33: Console.WriteLine("\tSync End Time : " + syncStats.SyncEndTime.ToString());
34: Console.WriteLine("");
35: Console.WriteLine("Upload Statistics (local SQL -> SQL Azure)");
36: Console.WriteLine("============================================");
37: Console.WriteLine("\tChanges Applied : " + syncStats.UploadChangesApplied.ToString());
38: Console.WriteLine("\tChanges Failed : " + syncStats.UploadChangesFailed.ToString());
39: Console.WriteLine("\tChanges Total : " + syncStats.UploadChangesTotal.ToString());
40: Console.WriteLine("");
41: Console.WriteLine("Download Statistics (SQL Azure -> local SQL)");
42: Console.WriteLine("============================================");
43: Console.WriteLine("\tChanges Applied : " + syncStats.DownloadChangesApplied.ToString());
44: Console.WriteLine("\tChanges Failed : " + syncStats.DownloadChangesFailed.ToString());
45: Console.WriteLine("\tChanges Total : " + syncStats.DownloadChangesTotal.ToString());
46: }
Listing 3: Methode zum Synchronisieren der Inhalte der Datenbanken
Nach erfolgreicher Synchronisation wird das Ergebnis über die Hilfsmethode ShowStatistics() angezeigt. Bauen Sie die Solution und wechseln Sie anschließend in das Konsolenfenster. Rufen Sie dort die Anwendung mit dem Aufrufparameter -sync auf. Abbildung 5 zeigt das Ergebnis.
Abbildung 5: Synchronisation der Inhalte aus SQL Azure
Da in der SQL Azure Datenbank nur ein Eintrag vorhanden war (und zwar der, der in meinem letzten Blog Eintrag zu SQL Azure hinzugefügt wurde), zeigt die Ausgabe an, dass eine Änderung von der SQL Azure Datenbank in die lokale Datenbank übertragen wurde. Prüfen Sie (z.B. im SQL Server Management Studio), ob der Eintrag nun korrekt in der lokalen Datenbank liegt.
Ändern Sie nun den Eintrag in der lokalen Datenbank. Hierzu können Sie das SQL Skript verwenden, das in Listing 4 abgebildet ist, und führen Sie dieses im SQL Server Management Studio aus.
1: UPDATE [LokalDB].[dbo].[Kunden]
2: SET [Vorname] = 'Max'
3: ,[Nachname] = 'Mustermann'
4: WHERE [KundenID] = 1
5: GO
Listing 4: Änderung eines Eintrags in der lokalen Datenbank
Starten Sie nun einen neuen Synchronisationslauf, indem Sie wieder in das Konsolenfenster wechseln und dort durch Aufruf der Anwendung mittels SyncTest -sync eine Synchronisation der Datenbanken durchfürhen. Das Ergebnis ist in Abbildung 6 zu sehen.
Abbildung 6: Synchronisation der Änderung der lokalen Datenbank
In diesem zweiten Synchronisationslauf wurde nun ein Eintrag (der geänderte Eintrag) von der lokalen Datenbank nach SQL Azure übertragen. Abbildung 7 zeigt, wie sich das Ergebnis im SQL Server Management Studio darstellt. Dort ist der geänderte Eintrag in SQL Azure abgebildet.
Abbildung 7: Ergebnis der Synchronisation
Die Datenbank Engine von SQL Azure stellt ein Subset der Funktionalitäten des SQL Servers als Cloud Service bereit. Aufgrund der Tatsache, dass hierbei gleiche Schnittstellen und Protokolle zum Einsatz kommen, können bestehende Zugriffstechnologien und Werkzeuge weiterverwendet werden. Entwickler, die bereits mit SQL Server arbeiten, werden sich also schnell zuhause fühlen.
Anlegen und Löschen einer SQL Azure Datenbank
In den folgenden Schritten soll eine neue Datenbank angelegt und zum Zugriff konfiguriert werden. Klicken Sie hierzu im SQL Azure Portal auf die Ribbon-Schaltfläche Create (siehe Abbildung 1).
Abbildung 1: Ribbon-Schaltfläche ‘Create’ zum Anlegen einer neuen Datenbank
Daraufhin öffnet sich die in Abbildung 2 gezeigte Eingabemaske, in der die in Tabelle 1 aufgelisteten Angaben zur anzulegenden Datenbank gemacht werden können:
Eingabefeld
Mögliche Eingabewerte
Erläuterung
Database name
String
Name, unter dem die Datenbank später ansprechbar ist.
Edition
Web
Business
Edition, die Auswirkungen auf die Maximalgröße und letztlich damit auch auf die Kosten hat.
Maximum size
Bei Web-Edition: 1 GB, 5 GB
Bei Business-Edition: 10 GB, 20 GB, 30 GB, 40 GB, 50 GB
Maximalgröße, bis zu der Daten in die Datenbank geschrieben warden können. Die Maximalgröße kann zur Laufzeit geändert werden.
Tabelle 1: Parameter für eine neu anzulegende SQL Azure Datenbank
Wählen Sie als Datenbanknamen TestDB und bestätigen Sie Ihre Eingaben mit der Schaltfläche OK.
Abbildung 2: Anlegen einer neuen SQL Azure Datenbank
Nach Bestätigung wird die Datenbank angelegt. Noch ist sie allerdings nich zugreifbar, solange nicht die vorgeschaltete SQL Azure Firewall entsprechend geöffnet wird. Die aktuell gültigen Firewall-Einstellungen können im SQL Azure Portal über die Schaltfläche Firewall Rules eingesehen werden. Nach Anklicken öffnet sich eine Liste der geöffneten IP-Adressbereiche, wie in Abbildung 2‑3 zu sehen ist.
Abbildung 3: Anzeige der Firewall Einstellungen im SQL Azure Portal
Eine neue Regel zur Freischaltung eines gewünschten IP-Adressbereichs kann über die Schaltfläche Add angelegt werden. Es öffnet sich die in Abbildung 4 gezeigte Eingabemaske.
Abbildung 4: Hinzufügen einer Firewall Regel
In dieser Eingabemaske kann der Name der Regel, sowie Start- und Endwert des Adressbereichs eingegeben werden. Durch Bestätigung über die Schaltfläche OK wird die Regel in SQL Azure eingetragen und aktiviert, d.h. Clients, die eine IP-Adresse innerhalb dieses Adressbereichs besitzen, können auf alle Datenbanken des betreffenden SQL Azure Servers zugreifen. Um die Verbindungsmöglichkeit zu SQL Azure zu testen, klicken Sie nun auf die Ribbon-Schaltfläche Test Connectivity (siehe Abbildung 5).
Abbildung 5: Ribbon-Schaltfläche ‘Test Connectivity’ zum Testen der Verbindung
Dies führt Sie auf die in Abbildung 6 gezeigte Eingabemaske, in der Sie Benutzernamen und Passwort des SQL Azure Servers eintragen können.
Abbildung 6: Testen der Verbindung zu SQL Azure
Eine Bestätigung mit der Schaltfläche Connect testet die Verbindung und zeigt das Ergebnis als Icon an (in Abbildung 6 die Meldung „Success“).
Anlegen von Datenbankobjekten
Zur Arbeit mit Datenbankobjekten kann dank der Schnittstellenkompatibilität zwischen SQL Server und SQL Azure das SQL Server Management Studio eingesetzt werden. Für die folgenden Abschnitte soll dieses verwendet werden, um SQL Anweisungen an SQL Azure zu senden. Rufen Sie das SQL Server Management Studio auf. Es erscheint die in Abbildung 7 gezeigte Eingabemaske, in die Sie die Anmeldeinformationen für den SQL Azure Server eintragen können.
Abbildung 7: Anmeldung am SQL Server Management Studio R2
Klicken Sie auf die Schaltfläche Options, um die SQL Azure Datenbank zu bestimmen, zu der Sie die Verbindung herstellen möchten. Es erscheint die in Abbildung 8 gezeigte Eingabemaske. Geben Sie dort den Datenbanknamen TestDB ein und bestätigen Sie Ihre Eingabe mit Connect.
Abbildung 8: Eigenschaften der Verbindung zur SQL Azure Datenbank
Damit ist die Verbindung zu SQL Azure hergestellt, und Sie können nun SQL Skripte an die Datenbank schicken.
Anlegen von Datenbankobjekten mittels SQL
Öffnen Sie nun ein neues Abfragefenster durch Auswahl des Menüpunktes File / New / Query with Current Connection. Geben Sie nun das in Listing 1 gezeigte SQL Skript in das Abfragefenster und führen Sie das Skript mittels Auswahl der Schaltfläche Execute aus.
1: CREATE TABLE [Kunden](
2: [KundenID] [int] IDENTITY(1,1) NOT NULL PRIMARY KEY CLUSTERED,
3: [Anrede] [nvarchar](6) NOT NULL,
4: [Vorname] [nvarchar](50) NOT NULL,
5: [Nachname] [nvarchar](50) NOT NULL,
6: [Email] [nvarchar](50) NOT NULL,
7: [Website] [nvarchar](50) NULL,
8: [Telefon] [nvarchar](30) NULL,
9: [Timestamp] [timestamp] NOT NULL
10: )
12: CREATE INDEX IX_Kunden_Email ON Kunden (Email)
14: INSERT INTO [Kunden]
15: ([Anrede], [Vorname], [Nachname], [Email], [Website], [Telefon])
16: VALUES
17: ('Herr', 'Holger', 'Sirtl', 'hsirtl@microsoft.com',
18: 'http://blogs.msdn.com/hsirtl', '089/123-456')
19:
20: SELECT * FROM [Kunden]
21:
Listing 1: Anlegen einer Datenbanktabelle mittels SQL
In der SQL Azure Datenbank wird nun eine Kundentabelle angelegt und ein Eintrag geschrieben. Abschließend werden noch alle Datenbankeinträge aufgelistet. Das Ergebnis ist in Abbildung 9 zu sehen.
Abbildung 9: Ausführung eines SQL Skripts über das SQL Server Management Studio
Zugriff auf Datenbankobjekte
Auf die über das SQL Server Management Studio erzeugte Tabelle soll nun über verschiedene Wege zugegriffen werden.
Die erste Alternative ist der Weg über ADO.NET. In einer kleinen Konsolenanwendung sollen Einträge in die Tabelle geschrieben, der gesamte Tabelleninhalt gelesen und angezeigt und der Tabelleneintrag wieder gelöscht werden. Listing 2‑2 zeigt den hierzu erforderlichen Programmcode.
Öffnen Sie nun Visual Studio 2010 und legen eine neue Konsolenanwendung über den Menüpunkt File / New / Project an. Wählen Sie als Projektvorlage Windows / Console Application aus. Geben Sie nun den in Listing 2 gezeigten Programmcode ein.
3:
4: namespace SqlAzure14
5: {
6: class Program
7: {
8: static void Main(string[] args)
9: {
10: string sqlAzureServer = "<MEIN_SERVER>";
11: string sqlAzureDatabase = "<MEINE_DATENBANK>";
12: string sqlAzureAdminUser = "<MEIN_SERVER_ADMIN_USER>";
13: string sqlAzureAdminPassword = "<MEIN_SERVER_ADMIN_PASSWORT>";
15: string testDbConnString = String.Format(
16: @"Server=tcp:{0}.database.windows.net;Database={1};
17: User ID={2}@{0};Password={3};Trusted_Connection=False;Encrypt=True;", @
18: sqlAzureServer,
19: sqlAzureDatabase,
20: sqlAzureAdminUser,
21: sqlAzureAdminPassword
22: );
23:
24: // Stelle Verbindung zur Datenbank her...
25: using (SqlConnection conn = new SqlConnection(testDbConnString))
27: using (SqlCommand command = conn.CreateCommand())
28: {
29: conn.Open();
30:
31: Console.Write("Anrede: ");
32: string anrede = Console.ReadLine();
33: Console.Write("Vorname: ");
34: string vorname = Console.ReadLine();
35: Console.Write("Nachname: ");
36: string nachname = Console.ReadLine();
37: Console.Write("E-Mail: ");
38: string email = Console.ReadLine();
39:
40: // Füge einen Eintrag in die Datenbank ein
41: command.CommandText = string.Format(
42: "INSERT INTO [Kunden] (Anrede, Vorname, Nachname, Email)
43: values ('{0}','{1}','{2}','{3}')", @
44: anrede, vorname, nachname, email);
45: int rowsAdded = command.ExecuteNonQuery();
46:
47: Console.WriteLine("{0} Zeilen erfolgreich hinzugefügt.", rowsAdded);
48:
49: // Lies alle Einträge aus der Kundentabelle aus
50: command.CommandText = "SELECT * FROM [Kunden]";
51:
52: using (SqlDataReader reader = command.ExecuteReader())
53: {
54: // Iteriere durch die Ergebnisliste
55: while (reader.Read())
56: {
57: Console.WriteLine("Vorname: {0}, Nachname: {1}, E-mail: {2}",
58: reader["Vorname"].ToString().Trim(),
59: reader["Nachname"].ToString().Trim(),
60: reader["Email"].ToString().Trim());
61: }
62: }
63:
64: // Lösche einen Eintrag
65: command.CommandText = String.Format(
66: "DELETE FROM [Kunden] WHERE Email='{0}'",
67: email);
68: command.ExecuteNonQuery();
69:
70: Console.WriteLine("Inhalt nach Löschen des letzten Eintrags.");
71:
72: // Lies alle Einträge aus der Kundentabelle aus
73: command.CommandText = "SELECT * FROM [Kunden]";
74:
75: using (SqlDataReader reader = command.ExecuteReader())
76: {
77: // Iteriere durch die Ergebnisliste
78: while (reader.Read())
79: {
80: Console.WriteLine("Vorname: {0}, Nachname: {1}",
81: reader["Vorname"].ToString().Trim(),
82: reader["Nachname"].ToString().Trim());
83: }
84: }
85:
86: }
87: }
88: Console.WriteLine("Press enter to continue...");
89: Console.ReadLine();
90: }
91: }
92: }
Listing 2: Konsolenanwendung zum Zugriff auf SQL Azure via ADO.NET
Folgende Werte müssen Sie im Programm durch entsprechende Werte Ihrer SQL Azure Umgebung ersetzen:
Attribut
<MEIN_SERVER>
Name des SQL Azure Servers (hat die Form ‘a1bcd2efgh’)
<MEINE_DATENBANK>
Name der Datenbank, die im Server angelegt wurde
<MEIN_SERVER_ADMIN_USER>
Name des Server-Administrators (muss beim Anlegen eines SQL Azure Servers angegeben werden)
<MEIN_SERVER_ADMIN_PASSWORT>
Passwort des Server-Administrators
Tabelle 2: Attribute einer SQL Azure Connection
Führen Sie nun die Anwendung mittels Debug / Start Debugging aus. Das Ergebnis ist in Abbildung 10 zu sehen.
Abbildung 10: Zugriff auf SQL Azure mittels ADO.NET
Veranstaltungshinweis: Live Webcasts
Im Rahmen dieser neuen MSDN Live Webcast Serie bekommen Sie einen Testzugang zur Windows Azure-Plattform und können einzelne Anwendungen in Ihre eigene Windows Azure Test-Instanz bringen. Mein Kollege Tim Fischer und ich stellen dafür Cloud-Anwendungen bereit, diskutieren deren Architektur und stehen Ihnen natürlich auch für Fragen zur Verfügung. Der kommende Termin am 19.05.2011 geht hier auch explizit auf die Möglichkeiten zur Datenspeicherung auf Azure (also auch SQL Azure) ein.
Weitere Termine
Melden Sie sich jetzt an
Im Rahmen dieser neuen MSDN Live Webcast Serie bekommen Sie einen Testzugang zur Windows Azure-Plattform und können einzelne Anwendungen in Ihre eigene Windows Azure Test-Instanz bringen. Mein Kollege Tim Fischer und ich stellen dafür Cloud-Anwendungen bereit, diskutieren deren Architektur und stehen Ihnen natürlich auch für Fragen zur Verfügung. Abgerundet wird das Programm durch die Vorstellung der Neuigkeiten und der besten Web-Ressourcen zum Thema Windows Azure.
Vom 28.03. bis 08.04.2011 waren Kollegen und ich in verschiedenen deutschen Städten unterwegs und haben eine Reihe von Vorträgen einen Überblick über die Möglichkeiten der Microsoft Cloud gegeben. Themen waren dabei unter anderem:
Auf der Website des TechSummit Cloud können nun die Videoaufzeichnungen der Vorträge sowie alle Präsentationen heruntergeladen werden. Zur Agenda (mit den Präsentations- und Video-Links) geht’s hier.
Übrigens gibt’s demnächst auch wieder einen neuen TechDay Online zum Internet Explorer 9. Meine Kollegen Lars Schmodt, Daniel Melanchton und Steffen Krause berichten dort über verschiedene Aspekte des aktuellen Microsoft Browsers.
SQL Azure stellt ein echtes relationales Datenbankmanagementsystem als Cloud Service bereit. Enthalten sind ein Subset der Datenbank-Engine aus SQL Server, die SQL Reporting Services sowie der SQL Sync Service, mit dem SQL Azure Datenbanken mit lokalen Datenbanken synchronisiert werden können.
Abb 1: SQL Azure
Vor SQL Azure befindet sich eine Firewall, die per Voreinstellung komplett geschlossen ist. Über das Azure Portal können IP-Adressbereiche geöffnet werden, von denen aus dann ein Zugriff auf die betreffenden Datenbanken möglich wird.
Eine neue SQL Azure Datenbank kann über das Entwicklerportal angelegt werden. Das Portal ist über den folgenden URL aufrufbar:
http://windows.azure.com
Nach Authentifizierung mittels einer Windows Live ID kann man die SQL Azure Verwaltung über den Link Database aufrufen. Dies öffnet das in Abbildung 2 gezeigte Portal.
Abb 2: Das SQL Azure Portal
Dort sind alle Verwaltungsfunktionen für SQL Azure über die Ribbon-Leiste zugänglich. Um eine neue Datenbank anzulegen kann auf die Schaltfläche Create geklickt werden. Daraufhin öffnet sich die in Abbildung 3 gezeigte Eingabemaske.
Abb 3: Anlegen einer neuen SQL Azure Datenbank
In dieser Maske können folgende Eingaben gemacht werden:
Nach Bestätigung der Eingabeparameter über OK wird die Datenbank angelegt. Noch ist sie allerdings nich zugreifbar, solange nicht die vorgeschaltete SQL Azure Firewall entsprechend geöffnet wird. Die aktuell gültigen Firewall-Einstellungen können im SQL Azure Portal über die Schaltfläche Firewall Rules eingesehen werden. Nach Anklicken öffnet sich eine Liste der geöffneten IP-Adressbereiche, wie in Abbildung 4 zu sehen ist.
Abb 4: Anzeige der Firewall-Regeln im SQL Azure Portal
Eine neue Regel zur Freischaltung eines gewünschten IP-Adressbereichs kann über die Schaltfläche Add angelegt werden. Es öffnet sich die in Abbildung 5 gezeigte Eingabemaske.
Abb 5: Hinzufügen einer neuen SQL Azure Firewall-Regel
In dieser Eingabemaske kann der Name der Regel, sowie Start- und Endwert des Adressbereichs eingegeben werden. Durch Bestätigung über die Schaltfläche OK wird die Regel in SQL Azure eingetragen und aktiviert, d.h. Clients, die eine IP-Adresse innerhalb dieses Adressbereichs besitzen, können auf alle Datenbanken des betreffenden SQL Azure Servers zugreifen.
Zugriff auf SQL Azure via JDBC Treiber
Für den Zugriff auf SQL Azure aus Java-Anwendungen heraus wird lediglich ein JDBC-Treiber benötigt, der von Microsoft als kostenloser Download angeboten wird. Für diesen gelten folgende Systemvoraussetzungen:
· Betriebssystem: Linux, Unix, Windows XP, Windows Vista, Windows 7Windows Server 2003, Windows Server 2008 R2
· Java Development Kit: 5.0 oder höher
· SQL Azure
Zu Installation des JDBC-Treibers kann die Installationsdatei sqljdbc_<version>_eng.exe heruntergeladen und ausgeführt werden. Dabei wird ein Installationsverzeichnis angelegt, in dem sich die benötigten Java-Bibliotheken befinden. Soll der JDBC-Treiber auch für den Zugriff auf einen lokalen SQL Server eingesetzt und hierbei integrierte Sicherheit (also automatische Windows-Authentifizierung) verwendet werden, muss die Datei sqljdbc_auth.dll in den Systempfad aufgenommen werden. SQL Azure unterstützt derzeit allerdings nur SQL Authentifizierung.
Aufgrund der Schnittstellenkompatibilität handelt es sich um den gleichen JDBC-Typ 4-Treiber, der auch für SQL Server verwendet werden kann. Dieser unterstützt JDBC 3.0 und JDBC 4.0. In einem Java-Projekt kann nun die JDBC-Jar-Datei in den Build Pfad aufgenommen werden. Die Datei sqljdbc4.jar befindet sich im Installationsverzeichnis unter sqljdbc_3.0/enu.
Die Java-Aufruflogik gestaltet sich analog dem Zugriff auf einen SQL Server, wie in Listing 3‑2 zu sehen ist. Dort wird zunächst eine Verbindung zu SQL Azure aufgebaut. Hierzu sind folgende Angaben erforderlich:
Name des SQL Azure Servers (hat die Form ‘a1bcd2efgh’
Tabelle 2: Attribute einer SQL Azure JDBC-Connection
Nachdem mit diesen Angaben eine Verbindung zur SQL Azure Datenbank aufgebaut wurde, können SQL Statements and die Datenbank gesendet werden. Listing 1 zeigt den Code einer Anwendung, die zunächst eine Datenbankverbindung aufbaut und anschließend eine Reihe von Methoden aufruft, über die zunächst eine Tabelle angelegt wird, danach Tabelleneinträge geschrieben und ausgelesen werden und zum Abschluss die Tabelle wieder gelöscht wird.
1: public static void main(String[] args) {
2: try {
3: Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
4:
5: SQLServerDataSource ds = new SQLServerDataSource();
6: ds.setServerName("<MEIN_SERVER>.database.windows.net");
7: ds.setDatabaseName("<MEINE_DATENBANK>");
8: ds.setUser("<MEIN_SERVER_ADMIN_USER>@<MEIN_SERVER>");
9: ds.setPassword("<MEIN_SERVER_ADMIN_PASSWORT>");
10:
11: Connection con = ds.getConnection();
12:
13: String tableName = "<MEINE_TABELLE>";
15: createTable(con, tableName);
16: addTableEntry(con, tableName);
17: listAllTableEntries(con, tableName);
18: dropTable(con, tableName);
20: con.close();
21: } catch (Exception e) {
22: e.printStackTrace();
23: }
Listing 1: Zugriff auf eine SQL Azure Datenbank über den SQL Azure JDBC-Treiber
Die Methode createTable() zum Anlegen einer Datenbanktabelle kann wie in Listing 2 gezeigt implementiert werden.
1: public static void createTable(Connection con, String tableName)
3: try {
4: String SQL =
5: "CREATE TABLE " +
6: tableName +
7: " (ID int IDENTITY, Name varchar(50), Vorname varchar(50), CONSTRAINT [PK_" +
8: tableName +
9: "] PRIMARY KEY CLUSTERED ([ID] ASC))";
10: Statement stmt = con.createStatement();
11: int count = stmt.executeUpdate(SQL);
13: System.out.printf("Table successfully created. '%d' rows affected.\n", count);
15: stmt.close();
16: } catch (Exception e) {
17: e.printStackTrace();
18: }
19: }
Listing 2: Anlegen einer Datenbanktabelle
Die in Listing 3 gezeigte Methode liest Werte für Vor- und Nachname von der Konsole aus und schreibt diese in die zuvor angelegte Tabelle.
1: public static void addTableEntry(Connection con, String tableName)
4: BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
5:
6: System.out.println("Name: ");
7: String name = br.readLine();
9: System.out.println("Vorname: ");
10: String vorname = br.readLine();
12: StringBuffer sb = new StringBuffer();
13: sb.append("INSERT INTO ");
14: sb.append(tableName);
15: sb.append(" (Name, Vorname) VALUES ('");
16: sb.append(name);
17: sb.append("', '");
18: sb.append(vorname);
19: sb.append("')");
20:
21: String SQL = sb.toString();
22: Statement stmt = con.createStatement();
23: int count = stmt.executeUpdate(SQL);
24: System.out.printf("Entry successfully written. '%d' rows affected.\n", count);
25: stmt.close();
26: } catch (Exception e) {
27: e.printStackTrace();
28: }
29: }
Listing 3: Schreiben eines Tabelleneintrags
Die Tabelleneinträge können dann mit der in Listing 4 gezeigten Methode listAllTableEntries() ausgelesen und angezeigt werden.
1: public static void listAllTableEntries(Connection con, String tableName)
4: String SQL = "SELECT Name, Vorname FROM [" + tableName + "]";
5: Statement stmt = con.createStatement();
6: ResultSet rs = stmt.executeQuery(SQL);
7:
8: System.out.printf("%-20s %-20s\n", "Name", "Vorname");
9: System.out.println("-------------------- --------------------");
11: int count = 0;
13: while (rs.next()) {
14: count++;
15: System.out.printf("%-20s %-20s\n",
16: rs.getString("Name"),
17: rs.getString("Vorname"));
20: System.out.printf("\nTable read completed. '%d' row entries listed.\n", count);
22: rs.close();
23: stmt.close();
24: } catch (Exception e) {
25: e.printStackTrace();
27: }
Listing 4: Auflisten aller Tabelleneinträge
Zum Abschluss noch die Methode dropTable() zum Löschen der zuvor angelegten Datenbanktabelle in Listing 5.
1: public static void dropTable(Connection con, String tableName)
4: String SQL = "DROP TABLE " + tableName;
6: int count = stmt.executeUpdate(SQL);
8: System.out.printf("Table successfully dropped. '%d' rows affected.\n", count);
9:
10: stmt.close();
11: } catch (Exception e) {
12: e.printStackTrace();
13: }
14: }
Listing 5: Löschen einer Tabelle
Für die Migration von einem bestehenden lokalen SQL Server nach SQL Azure wird von Microsoft der SQL Azure Migration Wizard bereitgestellt, mit dem Datenbankschema und die Daten selbst nach SQL Azure übertragen werden können.
Windows Azure AppFabric Caching Service verfügbar
Zur MIX 2011 wurde es ja bereits angekündigt, jetzt ist es endlich soweit: der Windows Azure AppFabric Caching Service wurde produktiv gesetzt.
Der Caching Service ist ein verteilter In-memory Application Cache, mit dessen Hilfe es möglich wird, die Performance von Windows Azure und SQL Azure Anwendungen deutlich zu steigern, indem Daten im Cache gehalten werden können, die dann nicht mehr erneut aus Windows Azure Storage oder einer SQL Azure Datenbank gelesen werden müssen. Beim Einsatz des Caching Service keinen Entwickler aus sechs verschiedenen Größen für den Cache wählen.
Die Preise für die einzelnen Cache-Größen gestalten sich wie folgt:
Cache-Größe
Preis pro Monat
Im Rahmen einer Markteinführungsphase ist der Caching Service bis 1. August 2011 kostenlos nutzbar.
Auf dem MS Developer Network ist ein FAQ Dokument verfügbar, das weitere Informationen zur Windows Azure AppFabric und dem Caching Service enthält. Außerdem beschäftigt sich auf MSDN ein eigener Abschnitt mit dem Caching Service.