---
title: "XML in der Cloud"
date: "2011-01-07"
categories: 
  - "hardware"
tags: 
  - "cloud-services"
  - "databasespy"
  - "missionkit"
description: Erfahren Sie, wie Sie Altova-Tools mit Amazon RDS verbinden, eine MySQL-Datenbank erstellen und XML-Funktionen für cloudbasierte Datenbankanwendungen nutzen können.
---
Status: #blog

Tags:  #cloud-services #databasespy #missionkit

Categories: [xml](/blog/de/category/xml.md) [cloud](/blog/de/category/cloud.md)
# XML in der Cloud

## Die Verwendung von Altova-Tools in Verbindung mit dem Amazon Relational Database Service (Amazon RDS)

Immer mehr Unternehmen erkennen die Vorteile, die sich aus der Implementierung von Datenbankanwendungen in der Cloud ergeben:

- Hohe Verfügbarkeit und Zuverlässigkeit
- Automatische Skalierung
- Freiheit von Hardwarekosten und Wartungsaufwand

In diesem Blogbeitrag zeigen wir, wie man sich mit dem Amazon Relational Database Service (Amazon RDS) verbindet und eine kleine Datenbank mit Altova [DatabaseSpy](https://www.altova.com/de/databasespy.html) erstellt. Da der Datenbankverbindungsassistent in allen [Altova MissionKit](https://www.altova.com/de/missionkit/software-development-tools.html)-Produkten gleich ist, können Sie sich auf die gleiche Weise mit [XMLSpy](https://www.altova.com/de/xmlspy.html), [MapForce](https://www.altova.com/de/mapforce.html) oder [StyleVision](https://www.altova.com/de/stylevision.html) verbinden. 

Wenn Sie die unten beschriebenen Schritte selbst ausprobieren möchten, benötigen Sie ein Konto bei Amazon Web Services (AWS), das Sie unter folgender Adresse erstellen können: [http://aws.amazon.com/rds/](http://aws.amazon.com/rds/) Sie können auch eine voll funktionsfähige Testversion von Altova MissionKit oder einer beliebigen einzelnen Altova-Anwendung unter folgender Adresse herunterladen: [https://www.altova.com/download-trial/](https://www.altova.com/de/download-trial/)

##### Erstellen Sie ein lokales Prototyp

Amazon RDS basiert auf MySQL, daher werden wir zunächst eine kleine, lokale Datenbank in der MySQL Community Edition erstellen, diese dann zu Amazon RDS migrieren und unsere Datenbank in der Cloud testen. Obwohl MySQL XML nicht als Datentyp für Datenbankspalten unterstützt, ermöglichen MySQL-Versionen 5.1 und 6.0 einige Operationen für XML-Daten, die als Text gespeichert sind. Für diese Übung werden wir einige der MySQL-XML-Beispiele anpassen und erweitern, die in den MySQL-Referenzressourcen unter den folgenden Links aufgeführt sind:
[http://dev.mysql.com/doc/refman/5.1/en/xml-functions.html](http://dev.mysql.com/doc/refman/5.1/en/xml-functions.html) [http://dev.mysql.com/tech-resources/articles/xml-in-mysql5.1-6.0.html](http://dev.mysql.com/tech-resources/articles/xml-in-mysql5.1-6.0.html) [http://dev.mysql.com/tech-resources/articles/mysql-5.1-xml.html](http://dev.mysql.com/tech-resources/articles/mysql-5.1-xml.html) Zunächst haben wir DatabaseSpy gestartet und mit unserer lokalen MySQL Community Edition verbunden. Wir haben eine neue Datenquelle namens "LocalPrototype" erstellt und ein neues Datenbankschema entworfen, das wir "XMLtest" genannt haben. Hier werden das Online-Browser-Fenster und das Eigenschaftenfenster von DatabaseSpy angezeigt: 

[![Fenster für das Datenbank-Projekt und dessen Eigenschaften](https://lh3.ggpht.com/_REdrfeVqYdU/TSYvog3-1xI/AAAAAAAAAQc/FmMFHyM0-yc/blogSnap1_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy Project and Properties windows")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYvoDdXvWI/AAAAAAAAAQU/qEea5H03j3U/s1600-h/blogSnap1%5B3%5D.png) 

Als Nächstes haben wir zwei Tabellen mit den Namen "books" (Bücher) und "cities" (Städte) erstellt und Daten eingefügt, wobei wir uns an den Beispielen in der MySQL-Dokumentation orientiert haben. Hier ist eine Designansicht unserer Tabellen in DatabaseSpy: 

[![DatabaseSpy – Designansicht](https://lh5.ggpht.com/_REdrfeVqYdU/TSYvpYyta6I/AAAAAAAAAQk/3oJcRfcVafs/blogSnap2_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy Design View")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYvpNqGrlI/AAAAAAAAAQg/m15NZt1yLgU/s1600-h/blogSnap2%5B3%5D.png) 

Wir können bestimmte Abfragen ausführen und den Inhalt unserer Tabellen in gestapelten Ergebnisfenstern anzeigen

[![DatabaseSpy: Fenster zur Anzeige von Ergebnissen](https://lh6.ggpht.com/_REdrfeVqYdU/TSYvxCJz7BI/AAAAAAAAAQs/KrKbkgW_cKc/blogSnap3_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy stacked results windows")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYvqaOVCqI/AAAAAAAAAQo/sDFsYLrNi7k/s1600-h/blogSnap3%5B3%5D.png)

Bitte beachten Sie, dass die Spalte "doc" in der Tabelle "books" XML-Daten enthält, obwohl sie als "varchar(150)" definiert ist. MySQL unterstützt zwei Funktionen zur Verarbeitung von XML in Textfeldern: "ExtractValue()" und "UpdateXML()", die mithilfe von XPath-Ausdrücken auf einzelne Elemente zugreifen können. Im Folgenden finden Sie eine einfache "ExtractValue()"-Abfrage, die nur die Initialen des Autors aus jeder Zeile in der Tabelle "books" zurückgibt: 

[![Funktion `ExtractValue()`](https://lh3.ggpht.com/_REdrfeVqYdU/TSYvyNUEhfI/AAAAAAAAAQ0/JOPn0w1ZAOA/blogSnap4_thumb%5B1%5D.png?imgmax=800 "ExtractValue( ) function")](http://lh4.ggpht.com/_REdrfeVqYdU/TSYvxiQrogI/AAAAAAAAAQw/rlT5OA5cB-M/s1600-h/blogSnap4%5B3%5D.png) 

Die Funktion `UpdateXML()` kann verwendet werden, um den Inhalt einzelner XML-Elemente mithilfe eines SQL-Ausdrucks zu ändern. Im folgenden Screenshot aktualisiert die Abfrage in Zeile 1 jede Zeile unserer Tabelle "books", und die Abfrage in Zeile 2 gibt die neuen Werte zurück: 

[![Funktion zum Aktualisieren von XML-Daten](https://lh4.ggpht.com/_REdrfeVqYdU/TSYvyzem2KI/AAAAAAAAAQ8/BCW9ZEzc77k/blogSnap5_thumb%5B1%5D.png?imgmax=800 "UpdateXML( ) function")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYvyTiRDNI/AAAAAAAAAQ4/qna29a6Bw6o/s1600-h/blogSnap5%5B3%5D.png)

Wir können die Funktion Concat() auch verwenden, um XML-Elemente zu Daten hinzuzufügen, die keine XML-Daten sind, wie beispielsweise die Tabelle mit den Städten, wie im folgenden Beispiel gezeigt: 

[![Die Funktion "Concat()"](https://lh3.ggpht.com/_REdrfeVqYdU/TSYvz4jJO8I/AAAAAAAAARE/GECrInoROUM/blogSnap6_thumb%5B1%5D.png?imgmax=800 "Concat( ) function")](http://lh4.ggpht.com/_REdrfeVqYdU/TSYvzdA02MI/AAAAAAAAARA/IHlT_sKpzAk/s1600-h/blogSnap6%5B3%5D.png)

Bisher haben unsere XML-Abfragen alle Zeilen jeder Tabelle berücksichtigt. Um Abfragen für eine einzelne Zeile zu vereinfachen, ist es hilfreich, eine Spalte zur Tabelle hinzuzufügen, die einen eindeutigen Zeilenindex enthält. Wir können eine Kopie unserer Tabelle "books" erstellen und eine Spalte namens "id" hinzufügen, um den Zeilenindex zu speichern. Die Spalte "id" eignet sich auch gut als Fremdschlüssel, um von einer Zeile in einer anderen Tabelle auf ein einzelnes XML-Dokument in unserer Tabelle zu verweisen. 

Beispielsweise können Sie eine Tabelle definieren, die die Namen von Bewerbern enthält, wobei ein Fremdschlüssel verwendet wird, um auf den im XML-Format gespeicherten Lebenslauf jedes Bewerbers zu verweisen. Dieser Lebenslauf wird in einer separaten Tabelle gespeichert. Sie können den [SQL-Editor](https://www.altova.com/de/databasespy/sql-editor.html) in DatabaseSpy verwenden, um eine CREATE-Anweisung für die bestehende Tabelle zu generieren und diese direkt zu bearbeiten, oder Sie können den DatabaseSpy [Design-Editor](https://www.altova.com/de/databasespy/database-design.html) verwenden, um die Tabelle grafisch zu erstellen. (Weitere Informationen finden Sie im Abschnitt [DatabaseSpy](https://www.altova.com/de/databasespy.html) auf der [Altova](https://www.altova.com/de/)-Website.) 

Da wir planen, dieselben Abfragen später in Amazon RDS auszuführen, haben wir eine SQL-CREATE-Anweisung und mehrere SQL-INSERT-Anweisungen zu einem einzigen Skript für die Tabelle "books2" zusammengefasst. Der folgende Screenshot zeigt einen Ausschnitt aus diesem Skript für die Tabelle "books2": 

[![Erstellen Sie ein Skript zur Tabellenerstellung](https://lh5.ggpht.com/_REdrfeVqYdU/TSYwOm9o6qI/AAAAAAAAARM/DRJQIGyrS7M/blogSnap6a_thumb%5B3%5D.png?imgmax=800 "Create table script")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYv0JrSNhI/AAAAAAAAARI/T4-ylo2HPaY/s1600-h/blogSnap6a%5B7%5D.png) 

Wir können eine Abfrage der Tabelle "books2" ausführen, die für jede Zeile die eindeutige ID-Spalte anzeigt: 

[![SQL-SELECT-Abfrage](https://lh6.ggpht.com/_REdrfeVqYdU/TSYwQHmnPoI/AAAAAAAAARU/Mi1mEaTUMU4/blogSnap7_thumb%5B4%5D.png?imgmax=800 "SQL SELECT query")](http://lh3.ggpht.com/_REdrfeVqYdU/TSYwPEtwIdI/AAAAAAAAARQ/gPgwsQX94Ak/s1600-h/blogSnap7%5B8%5D.png) 

Jetzt können wir unsere Funktionen `UpdateXML()` und `ExtractValue()` so erweitern, dass sie auf einzelne Zeilen angewendet werden können: 

[![blogSnap8](https://lh5.ggpht.com/_REdrfeVqYdU/TSYyzesZA8I/AAAAAAAAARc/Le1Qs6k4GMY/blogSnap8_thumb%5B2%5D.png?imgmax=800 "blogSnap8")](http://lh4.ggpht.com/_REdrfeVqYdU/TSYwQfREjtI/AAAAAAAAARY/sUtXyDoOq7A/s1600-h/blogSnap8%5B6%5D.png) [![blogSnap9](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy0nw8n2I/AAAAAAAAARk/hRPWhnmcudI/blogSnap9_thumb%5B1%5D.png?imgmax=800 "blogSnap9")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy0LgjvmI/AAAAAAAAARg/yh-JtXmQR2U/s1600-h/blogSnap9%5B3%5D.png) 

Dies gibt uns eine gute Grundlage an Beispielen, die wir in die Cloud hochladen und in Amazon RDS testen können.

## Verbinden Sie DatabaseSpy mit dem Amazon RDS Cloud

Nachdem Sie die Anweisungen in der [AWS Management Console](http://aws.amazon.com/console/) befolgt haben, um eine Datenbankinstanz auf Amazon RDS zu erstellen, erleichtert der Verbindungsassistent den Start mit DatabaseSpy. Wählen Sie einfach die Option "MySQL" wie hier gezeigt: 

[![Der Datenbankverbindungsassistent von DatabaseSpy](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy1HzeX7I/AAAAAAAAARs/OV62tBUdU1g/blogSnap10_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy Connection Wizard")](http://lh4.ggpht.com/_REdrfeVqYdU/TSYy04hWtSI/AAAAAAAAARo/ePZmjb3wIbM/s1600-h/blogSnap10%5B3%5D.png) 

Beim ersten Verbindungsaufbau müssen Sie einen neuen Datenquellenname (DSN) erstellen. Nach dem ersten Mal können Sie den DSN aus einer Liste auswählen, indem Sie die Option "Vorhandenen Datenquellennamen verwenden" wählen. Sie können sogar den ursprünglichen DSN wiederverwenden, wenn Sie von XMLSpy, MapForce oder StyleVision aus eine Verbindung herstellen möchten.

[![Verbindung zu MySQL herstellen](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy2KLWVjI/AAAAAAAAAR0/P_SfoWqNqmk/blogSnap11_thumb%5B1%5D.png?imgmax=800 "Connecting to MySQL")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy1s8cwkI/AAAAAAAAARw/Vo8A8G5y5k4/s1600-h/blogSnap11%5B3%5D.png) 

Im Verbindungsdialog sind folgende Informationen einzutragen:

- **Name der Datenquelle:** Dies ist der Name, der im Fenster "DatabaseSpy-Projekt" und in der Liste der vorhandenen Datenquellen angezeigt wird, wenn Sie sich erneut verbinden.
- **Beschreibung:** Informationen zur eigenen Information.
- **Server:** Dies ist der Name des Endpunkts, der in Ihrem Amazon RDS-Kontobereich angezeigt wird.
- **Port:** 3306 – Stellen Sie sicher, dass Ihre IT-Abteilung diesen Port nicht mit einer Firewall blockiert!
- **Benutzername / Passwort**: Dies ist ein Benutzer, den Sie in Amazon RDS eingerichtet haben.
- **Datenbank:** Der Standardname der Datenbank, den Sie bei der Einrichtung Ihrer RDS-Instanz festgelegt haben.

[![MySQL Connector/ODBC](https://lh4.ggpht.com/_REdrfeVqYdU/TSYy3A4BZNI/AAAAAAAAAR8/MQ-j5h1PdMQ/blogSnap12_thumb%5B1%5D.png?imgmax=800 "MySQL Connector/ODBC")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy2g81jPI/AAAAAAAAAR4/yz8-Isp-rCY/s1600-h/blogSnap12%5B3%5D.png) 

Wir haben uns mit unserer Amazon RDS-Cloud-Datenbank in demselben DatabaseSpy-Projekt verbunden, das wir für das lokale Prototyp entwickelt hatten. Hier ist ein Screenshot des Projektfensters, der sowohl die Namen der Datenquellen als auch die SQL-Dateien zeigt, die wir unserem Projekt hinzugefügt haben: 

[![Projektfenster von DatabaseSpy mit Cloud-Verbindung](https://lh6.ggpht.com/_REdrfeVqYdU/TSYy4Z2yQAI/AAAAAAAAASE/jjkGuAVBZYY/blogSnap15_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy Project window with cloud connection")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy3qGsQpI/AAAAAAAAASA/hC99hBGpc3Y/s1600-h/blogSnap15%5B3%5D.png) 

Bevor wir unsere Tabellen erstellen und die Abfragen ausführen, ist es interessant, die Versionen der einzelnen Systeme zu überprüfen. Die folgenden Screenshots zeigen eine Abfrage, die Versionsinformationen für jedes System anfordert. Beachten Sie, dass die graue Leiste direkt über jeder Abfrage angibt, welche Datenverbindung für die SQKL-Anweisung verwendet wird. 

[![Version, die vom lokalen Server gemeldet wird](https://lh3.ggpht.com/_REdrfeVqYdU/TSYy5G-k3SI/AAAAAAAAASM/WwjShCXN8NM/blogSnap16_thumb%5B1%5D.png?imgmax=800 "Version reported by the local server")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy4w4Lt3I/AAAAAAAAASI/7HQFtTCam7g/s1600-h/blogSnap16%5B3%5D.png) 

[![Version, die vom Cloud-Server gemeldet wird](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy6bIVXoI/AAAAAAAAASU/-JyDD32Kp2g/blogSnap17_thumb%5B1%5D.png?imgmax=800 "Version reported by the cloud server")](http://lh3.ggpht.com/_REdrfeVqYdU/TSYy6A4UeJI/AAAAAAAAASQ/G1YLJDmUqrQ/s1600-h/blogSnap17%5B3%5D.png) 

Laut den Berichten von Amazon RDS läuft dort Version 5.1 des MySQL Community Servers, genau wie bei unserem lokalen Prototyp – ein vielversprechendes Zeichen!

## Migrieren Sie das lokale Projekt in die Cloud

Wir können jedes unserer ursprünglichen Skripte zur Tabellenerstellung öffnen und sie in der Cloud-Datenbank ausführen, indem wir im Eigenschaftenfenster das Ausführungsziel neu zuweisen 

[![Auswahl der Datenquelle im Eigenschaftenfenster von DatabaseSpy](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy7_iTcXI/AAAAAAAAASc/q0X1LX25ZVI/blogSnap19_thumb%5B1%5D.png?imgmax=800 "Data Source selection in the DatabaseSpy Properties window")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy7SFih4I/AAAAAAAAASY/u2ciH6xLgA4/s1600-h/blogSnap19%5B3%5D.png) 

Die graue Leiste "Ausführungsziel" am oberen Rand des SQL-Editors zeigt die Cloud-Datenbank Amazon RDS als Ziel für die Abfrage an:

[![Fenster des SQL-Editors von DatabaseSpy](https://lh6.ggpht.com/_REdrfeVqYdU/TSYy8UqW2LI/AAAAAAAAASk/f8LxhxA5KVE/blogSnap18_thumb%5B1%5D.png?imgmax=800 "DatabaseSpy SQL Editor window")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy8HAL2UI/AAAAAAAAASg/rrrnJEP-cZ8/s1600-h/blogSnap18%5B3%5D.png) 

Nachdem wir auf ähnliche Weise die Tabellen "books" und "books2" erstellt haben, können wir jede der SQL-Abfragen in der Cloud-Datenbank ausführen. Beispiel für die Funktion "ExtractValue()" für alle Zeilen: 

[![Funktion `ExtractValue()`](https://lh6.ggpht.com/_REdrfeVqYdU/TSYy9LMPvLI/AAAAAAAAASs/ELCuIt6yr6A/blogSnap20_thumb%5B2%5D.png?imgmax=800 "ExtractValue( ) function")](http://lh6.ggpht.com/_REdrfeVqYdU/TSYy8xnwAYI/AAAAAAAAASo/ZiXvT3Dpt3M/s1600-h/blogSnap20%5B6%5D.png) 

Eine `Concat()`-Abfrage, um XML-Ausgabe aus nicht-XML-Daten in einer Tabelle zu erstellen: 

[![Die Funktion "Concat()" verwenden, um XML-Elemente zu Daten aus einer nicht-XML-Tabelle hinzuzufügen](https://lh4.ggpht.com/_REdrfeVqYdU/TSYy-KZdIUI/AAAAAAAAAS0/tBjejnmSxt8/blogSnap21_thumb%5B1%5D.png?imgmax=800 "Using the Concat( ) function to add XML elements to data from a non-XML table")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy9ozYo3I/AAAAAAAAASw/hiDcxS51Fg8/s1600-h/blogSnap21%5B3%5D.png)

Beispiel für die Funktion `UpdateXML()` für eine einzelne Zeile in einer Tabelle.

[![Die Verwendung der Funktion "UpdateXML()" in Amazon RDS](https://lh6.ggpht.com/_REdrfeVqYdU/TSYy-5p4W0I/AAAAAAAAAS8/S-IU7BoJrc4/blogSnap22_thumb%5B1%5D.png?imgmax=800 "Using the UpdateXML( ) function in the Amazon RDS cloud")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy-egtAMI/AAAAAAAAAS4/bEza7pRhyTs/s1600-h/blogSnap22%5B3%5D.png) 

`ExtractValue()` für eine einzelne Zeile: 

[![blogSnap23](https://lh5.ggpht.com/_REdrfeVqYdU/TSYy_qnwgsI/AAAAAAAAATE/gRjQHwNgX3w/blogSnap23_thumb%5B1%5D.png?imgmax=800 "blogSnap23")](http://lh5.ggpht.com/_REdrfeVqYdU/TSYy_ePFw3I/AAAAAAAAATA/gc3yssi4DvI/s1600-h/blogSnap23%5B3%5D.png)

## Schlussfolgerung

Bei jedem Test, den wir durchgeführt haben, verhielt sich Amazon RDS genau wie die lokale MySQL-Community-Edition. Dieses Verhalten ermöglicht es Entwicklern, neue Cloud-Datenbankanwendungen oder Erweiterungen bestehender Anwendungen effizienter zu entwickeln und zu testen, ohne dabei die Kosten für Cloud-Ressourcen für die Entwicklungsphasen in Kauf nehmen zu müssen. 

Wir haben auch die Funktionalität der MySQL-XML-Funktionen für XML-Daten überprüft, die in Textspalten in den Cloud-Datenbanken gespeichert sind. Unsere XML-Daten waren sehr begrenzt – die Textspalte in unserer Tabelle "Bücher" war auf 150 Zeichen beschränkt. MySQL ermöglicht es jedoch, viel größere XML-Dokumente in einer einzigen Spalte zu speichern. Jede Tabelle hat eine maximale Zeilengröße von 65.535 Bytes. Selbst wenn Ihre Tabelle eine Indexspalte verwendet, bedeutet dies, dass eine VARCHAR-Spalte für einen einzelnen XML-Eintrag mehr als 64 Kilobyte groß sein kann. Wenn Sie noch größere XML-Dokumente speichern müssen, bietet MySQL die Datentypen MediumText und LongText an, ähnlich wie BLOBs. MediumText kann mehr als 16 Millionen einzelne Zeichen speichern, und LongText kann bis zu 4 GB speichern. Obwohl dies in diesem Blogbeitrag nicht dargestellt wird, haben wir die Funktionen ExtractValue() und UpdateXML() erfolgreich mit den Datentypen MediumText und LongText getestet.

Wenn Sie große XML-Datendateien speichern müssen, kann das Schreiben von XPath-Ausdrücken zur Identifizierung einzelner Elemente zu einer Herausforderung in der Entwicklung werden. Der in XMLSpy enthaltene XPath-Analysator ist ein unschätzbares Werkzeug, das die [Testung und Fehlersuche von XPath-Ausdrücken der Versionen 1.0 und 2.0 erleichtert](https://www.altova.com/de/xmlspy/xpath-analyzer.html). Während Sie einen XPath-Ausdruck in den Analysator eingeben, wertet XMLSpy ihn aus und zeigt das resultierende Knoten-Set in Echtzeit an. Dies kann Stunden der Fehlersuche sparen, die sonst für das Verständnis und die Behebung von XPath-Problemen aufgewendet würden. 

In zukünftigen Blogbeiträgen werden wir weitere Möglichkeiten untersuchen, wie XMLSpy, MapForce, DiffDog und DatabaseSpy Entwicklern helfen können, die Entwicklung von Cloud-Anwendungen mit Amazon RDS zu beschleunigen. Wir freuen uns darauf, Sie bald wieder begrüßen zu dürfen! Wenn Sie selbst erfahren möchten, wie gut die Altova-Tools mit Amazon RDS zusammenarbeiten, können Sie eine kostenlose Testversion des [Altova MissionKit](https://www.altova.com/de/missionkit/software-development-tools.html) [herunterladen](https://www.altova.com/de/download/missionkit/software_development_tools_enterprise.html).
