Interoperabilität mit Azure: SQL Azure mit Java

아티클
05/09/2011

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.

Anlegen und Löschen einer SQL Azure Datenbank

Eine neue SQL Azure Datenbank kann über das Entwicklerportal angelegt werden. Das Portal ist über den folgenden URL aufrufbar:

https://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:

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.

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

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:

Attribut	Erläuterung
<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 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>";
   14:  
   15:         createTable(con, tableName);
   16:         addTableEntry(con, tableName);
   17:         listAllTableEntries(con, tableName);
   18:         dropTable(con, tableName);
   19:   
   20:         con.close();
   21:     } catch (Exception e) {
   22:         e.printStackTrace();
   23:     }
   24: }

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)
    2: {
    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);
   12:         
   13:         System.out.printf("Table successfully created. '%d' rows affected.\n", count);
   14:         
   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)
    2: {
    3:     try {
    4:         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    5:         
    6:         System.out.println("Name: ");
    7:         String name = br.readLine();
    8:         
    9:         System.out.println("Vorname: ");
   10:         String vorname = br.readLine();
   11:  
   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)
    2: {
    3:     try {
    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("-------------------- --------------------");
   10:  
   11:         int count = 0;
   12:         
   13:         while (rs.next()) {
   14:             count++;
   15:             System.out.printf("%-20s %-20s\n",
   16:                 rs.getString("Name"),
   17:                 rs.getString("Vorname"));
   18:         }
   19:  
   20:         System.out.printf("\nTable read completed. '%d' row entries listed.\n", count);
   21:       
   22:         rs.close();
   23:         stmt.close();
   24:     } catch (Exception e) {
   25:         e.printStackTrace();
   26:     }
   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)
    2: {
    3:     try {
    4:         String SQL = "DROP TABLE " + tableName;
    5:         Statement stmt = con.createStatement();
    6:         int count = stmt.executeUpdate(SQL);
    7:         
    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.

다음을 통해 공유

Interoperabilität mit Azure: SQL Azure mit Java

Anlegen und Löschen einer SQL Azure Datenbank

추가 리소스