So verwenden Sie das Mobile Apps Node.js SDK

Dieser Artikel enthält ausführliche Informationen und Beispiele, die zeigen, wie Sie mit einem Node.js Back-End im Feature "Mobile Apps" von Azure App Service arbeiten.

Einleitung

Mobile Apps bieten die Möglichkeit, einer Webanwendung eine mobile optimierte Datenzugriffs-Web-API hinzuzufügen. Das Mobile Apps SDK wird für ASP.NET und Node.js Webanwendungen bereitgestellt. Das SDK stellt die folgenden Vorgänge bereit:

• Tabellenvorgänge (Lesen, Einfügen, Aktualisieren, Löschen) für den Datenzugriff
• Benutzerdefinierte API-Vorgänge

Beide Vorgänge bieten eine Authentifizierung für alle Identitätsanbieter, die Azure App Service zulässt. Zu diesen Anbietern gehören Soziale Identitätsanbieter wie Facebook, Twitter, Google und Microsoft sowie Azure Active Directory für Unternehmensidentität.

Sie finden Beispiele für jeden Anwendungsfall im Beispielverzeichnis auf GitHub.

Unterstützte Plattformen

Das Mobile Apps Node.js SDK unterstützt die aktuelle LTS-Version von Node und höher. Derzeit ist die neueste LTS-Version Node v4.5.0. Andere Versionen von Node funktionieren möglicherweise, werden aber nicht unterstützt.

Das Mobile Apps Node.js SDK unterstützt zwei Datenbanktreiber:

• Der Node-mssql-Treiber unterstützt Azure SQL-Datenbank und lokale SQL Server-Instanzen.
• Der sqlite3-Treiber unterstützt nur SQLite-Datenbanken in einer einzigen Instanz.

Erstellen eines einfachen Node.js Back-End mithilfe der Befehlszeile

Jedes mobile Apps Node.js Back-End beginnt als ExpressJS-Anwendung. ExpressJS ist das beliebteste Webdienstframework, das für Node.jsverfügbar ist. Sie können eine einfache Express Anwendung wie folgt erstellen:

1. Erstellen Sie in einem Befehls- oder PowerShell-Fenster ein Verzeichnis für Ihr Projekt:

    mkdir basicapp
   

2. Führen Sie npm init aus, um die Paketstruktur zu initialisieren:

    cd basicapp
    npm init
   

   Der Befehl npm init stellt eine Reihe von Fragen, um das Projekt zu initialisieren. Sehen Sie sich die Beispielausgabe an:

   

3. Installieren Sie die bibliotheken express und azure-mobile-apps aus dem npm-Repository:

    npm install --save express azure-mobile-apps
   

4. Erstellen Sie eine app.js Datei, um den grundlegenden mobilen Server zu implementieren:

   var express = require('express'),
       azureMobileApps = require('azure-mobile-apps');
   
   var app = express(),
       mobile = azureMobileApps();
   
   // Define a TodoItem table.
   mobile.tables.add('TodoItem');
   
   // Add the Mobile API so it is accessible as a Web API.
   app.use(mobile);
   
   // Start listening on HTTP.
   app.listen(process.env.PORT || 3000);
   

Diese Anwendung erstellt eine mobile optimierte Web-API mit einem einzelnen Endpunkt (/tables/TodoItem), der nicht authentifizierten Zugriff auf einen zugrunde liegenden SQL-Datenspeicher mithilfe eines dynamischen Schemas ermöglicht. Sie eignet sich für die Schnellstartanleitungen der Clientbibliothek:

• Android-Client – Schnellstart
• Apache Cordova-Client – Schnellstart
• iOS-Client – Schnellstart
• Schnellstart des Windows Store-Clients
• Schnellstart des Xamarin.iOS-Clients
• Schnellstart des Xamarin.Android-Clients
• Schnellstart des Xamarin.Forms-Clients

Den Code für diese einfache Anwendung finden Sie im Basicapp-Beispiel auf GitHub.

Erstellen eines Node.js Back-End mithilfe von Visual Studio 2015

Visual Studio 2015 erfordert eine Erweiterung, um Node.js Anwendungen innerhalb der IDE zu entwickeln. Installieren Sie zunächst die Node.js Tools 1.1 für Visual Studio. Wenn Sie die Installation abgeschlossen haben, erstellen Sie eine Express 4.x-Anwendung:

1. Öffnen Des Dialogfelds "Neues Projekt" (aus "Neues>Projektspeichern>").

2. Expand Templates>JavaScript>Node.js.

3. Wählen Sie "Basic Azure Node.js Express 4-Anwendung" aus.

4. Geben Sie den Projektnamen ein. Wählen Sie OK aus.

   

5. Klicken Sie mit der rechten Maustaste auf den npm-Knoten , und wählen Sie "Neue npm-Pakete installieren" aus.

6. Möglicherweise müssen Sie den npm-Katalog aktualisieren, nachdem Sie Ihre erste Node.js Anwendung erstellt haben. Wählen Sie bei Bedarf "Aktualisieren" aus.

7. Geben Sie azure-mobile-apps in das Suchfeld ein. Wählen Sie das Paket "azure-mobile-apps 2.0.0" und dann " Paket installieren" aus.

   

8. Wählen Sie Schließen aus.

9. Öffnen Sie die datei app.js, um Unterstützung für das Mobile Apps SDK hinzuzufügen. Fügen Sie in Zeile 6 unten in den Bibliotheksanweisungen require den folgenden Code hinzu:

   var bodyParser = require('body-parser');
   var azureMobileApps = require('azure-mobile-apps');
   

   Fügen Sie in etwa Zeile 27 nach den anderen app.use Anweisungen den folgenden Code hinzu:

   app.use('/users', users);
   
   // Mobile Apps initialization
   var mobile = azureMobileApps();
   mobile.tables.add('TodoItem');
   app.use(mobile);
   

   Speichern Sie die Datei.

10. Führen Sie die Anwendung entweder lokal aus (die API wird auf https://localhost:3000 bereitgestellt) oder veröffentlichen Sie sie auf Azure.

Erstellen eines Node.js Back-End mithilfe des Azure-Portals

Sie können ein Back-End für mobile Apps direkt im Azure-Portal erstellen. Sie können entweder die folgenden Schritte ausführen oder einen Client und server zusammen erstellen, indem Sie das Lernprogramm zum Erstellen einer mobilen App befolgen. Das Lernprogramm enthält eine vereinfachte Version dieser Anweisungen und eignet sich am besten für Machbarkeitsprojekte.

1. Melden Sie sich beim Azure-Portalan.

2. Wählen Sie +NEW>Web + Mobile>App aus, und geben Sie dann einen Namen für Ihr Mobile Apps-Back-End an.

3. Wählen Sie für die Ressourcengruppe eine vorhandene Ressourcengruppe aus, oder erstellen Sie eine neue Gruppe (mit demselben Namen wie Ihre App).

4. Für App Service-Plan ist der Standardplan (in der Standardebene) ausgewählt. Sie können auch einen anderen Plan auswählen oder einen neuen Plan erstellen.

   Die Einstellungen des App Service-Plans bestimmen den Standort, die Features, die Kosten und die Computeressourcen, die Ihrer App zugeordnet sind. Weitere Informationen zu App Service-Plänen und zum Erstellen eines neuen Plans in einem anderen Preisniveau und an Ihrem gewünschten Standort finden Sie in der detaillierten Übersicht über Azure App Service-Pläne.

5. Klicken Sie auf Erstellen. In diesem Schritt wird das Back-End für mobile Apps erstellt.

6. Wählen Sie im Bereich "Einstellungen" für das neue Back-End für Mobile Apps die Option Schnellstart für Ihre Client-App-Plattform aus und verbinden Sie eine Datenbank.

   

7. Wählen Sie im Bereich " Datenverbindung hinzufügen " die Option "SQL-Datenbank>erstellen" aus. Geben Sie den Datenbanknamen ein, wählen Sie ein Preisniveau aus, und wählen Sie dann "Server" aus. Sie können diese neue Datenbank wiederverwenden. Wenn Sie bereits an demselben Speicherort über eine Datenbank verfügen, können Sie stattdessen "Vorhandene Datenbank verwenden" auswählen. Die Verwendung einer Datenbank an einem anderen Ort wird aufgrund von Bandbreitenkosten und höherer Latenz nicht empfohlen.

   

8. Geben Sie im Bereich "Neuer Server " einen eindeutigen Servernamen in das Feld " Servername " ein, geben Sie eine Anmeldung und ein Kennwort ein, wählen Sie "Azure-Dienste für den Zugriff auf den Server zulassen" aus, und wählen Sie "OK" aus. In diesem Schritt wird die neue Datenbank erstellt.

9. Wählen Sie im Bereich "Datenverbindung hinzufügen die Verbindungszeichenfolge aus, geben Sie die Anmelde- und Kennwortwerte für Ihre Datenbank ein und wählen Sie OK aus.

   Warten Sie einige Minuten, bis die Datenbank erfolgreich bereitgestellt wurde, bevor Sie fortfahren.

Wählen Sie im Bereich " Erste Schritte " unter "Tabellen-API erstellen" Node.js als Back-End-Sprache aus. Wählen Sie das Feld aus, in dem ich bekenne, dass dadurch alle Websiteinhalte überschrieben werden, und wählen Sie dann "TodoItem-Tabelle erstellen" aus.

Herunterladen des Node.js Back-End-Schnellstartcodeprojekts mithilfe von Git

Wenn Sie ein Node.js Mobile Apps Back-End mithilfe des Schnellstartbereichs des Portals erstellen, wird ein Node.js Projekt für Sie erstellt und auf Ihrer Website bereitgestellt. Im Portal können Sie Tabellen und APIs hinzufügen und Codedateien für das Node.js Back-End bearbeiten. Sie können auch verschiedene Bereitstellungstools verwenden, um das Back-End-Projekt herunterzuladen, sodass Sie Tabellen und APIs hinzufügen oder ändern und dann das Projekt erneut veröffentlichen können. Weitere Informationen finden Sie im Azure App Service-Bereitstellungshandbuch.

Im folgenden Verfahren wird ein Git-Repository zum Herunterladen des Schnellstartprojektcodes verwendet:

1. Installieren Sie Git, falls noch nicht geschehen. Die zum Installieren von Git erforderlichen Schritte variieren zwischen Betriebssystemen. Informationen zu betriebssystemspezifischen Verteilungen und Installationsanleitungen finden Sie unter Installieren von Git.

2. Lesen Sie "Vorbereiten Ihres Repositorys ", um das Git-Repository für Ihre Back-End-Website zu aktivieren. Notieren Sie sich den Benutzernamen und das Kennwort der Bereitstellung.

3. Notieren Sie sich im Bereich für Ihr Mobile Apps-Back-End die Git-Klon-URL-Einstellung .

4. Führen Sie den git clone Befehl mithilfe der Git-Klon-URL aus. Geben Sie bei Bedarf Ihr Kennwort ein, wie im folgenden Beispiel gezeigt:

    $ git clone https://username@todolist.scm.azurewebsites.net:443/todolist.git
   

5. Navigieren Sie zum lokalen Verzeichnis (/todolist im vorherigen Beispiel), und beachten Sie, dass Projektdateien heruntergeladen wurden. Suchen Sie die todoitem.json Datei im /tables Verzeichnis. Diese Datei definiert Berechtigungen für die Tabelle. Suchen Sie auch die todoitem.js Datei im selben Verzeichnis. Sie definiert die CRUD-Vorgangsskripts für die Tabelle.

6. Nachdem Sie Änderungen an Projektdateien vorgenommen haben, führen Sie die folgenden Befehle aus, um die Änderungen hinzuzufügen, zu übernehmen und dann auf die Website hochzuladen:

    $ git commit -m "updated the table script"
    $ git push origin master
   

   Wenn Sie dem Projekt neue Dateien hinzufügen, müssen Sie zuerst den git add . Befehl ausführen.

Die Website wird jedes Mal erneut veröffentlicht, wenn eine neue Gruppe von Commits an die Website übertragen wird.

Veröffentlichen Ihres Node.js Back-End in Azure

Microsoft Azure bietet viele Mechanismen zum Veröffentlichen Ihrer mobilen Apps Node.js-Backend auf den Azure-Dienst. Zu diesen Mechanismen gehören Bereitstellungstools, die in Visual Studio, Befehlszeilentools und fortlaufende Bereitstellungsoptionen basierend auf der Quellcodeverwaltung integriert sind. Weitere Informationen finden Sie im Azure App Service-Bereitstellungshandbuch.

Azure App Service enthält spezifische Ratschläge für Node.js Anwendungen, die Sie überprüfen sollten, bevor Sie das Back-End veröffentlichen:

• So geben Sie die Node-Version an
• Verwenden von Node-Modulen

Aktivieren einer Startseite für Ihre Anwendung

Viele Anwendungen sind eine Kombination aus Web- und mobilen Apps. Sie können das ExpressJS-Framework verwenden, um die beiden Facets zu kombinieren. Manchmal möchten Sie jedoch möglicherweise nur eine mobile Schnittstelle implementieren. Es ist hilfreich, eine Startseite bereitzustellen, um sicherzustellen, dass der App-Dienst ausgeführt wird. Sie können entweder Eine eigene Startseite bereitstellen oder eine temporäre Startseite aktivieren. Um eine temporäre Startseite zu aktivieren, verwenden Sie den folgenden Code, um Mobile Apps zu instanziieren:

var mobile = azureMobileApps({ homePage: true });

Wenn diese Option nur bei der lokalen Entwicklung verfügbar sein soll, können Sie diese Einstellung ihrer azureMobile.js Datei hinzufügen.

Tabellenvorgänge

Das azure-mobile-apps Node.js Server SDK bietet Mechanismen zum Verfügbarmachen von Datentabellen, die in der Azure SQL-Datenbank als Web-API gespeichert sind. Sie stellt fünf Vorgänge bereit:

Diese Web-API unterstützt OData und erweitert das Tabellenschema, um die Offlinedatensynchronisierung zu unterstützen.

Definieren von Tabellen mithilfe eines dynamischen Schemas

Bevor Sie eine Tabelle verwenden können, müssen Sie sie definieren. Sie können Tabellen mithilfe eines statischen Schemas (in dem Sie die Spalten im Schema definieren) oder dynamisch definieren (wobei das SDK das Schema basierend auf eingehenden Anforderungen steuert). Darüber hinaus können Sie bestimmte Aspekte der Web-API steuern, indem Sie der Definition JavaScript-Code hinzufügen.

Als bewährte Methode sollten Sie jede Tabelle in einer JavaScript-Datei im tables Verzeichnis definieren und dann die tables.import() Methode verwenden, um die Tabellen zu importieren. Wenn Sie das Beispiel für einfache Apps erweitern, würden Sie die app.js Datei anpassen:

var express = require('express'),
    azureMobileApps = require('azure-mobile-apps');

var app = express(),
    mobile = azureMobileApps();

// Define the database schema that is exposed.
mobile.tables.import('./tables');

// Provide initialization of any tables that are statically defined.
mobile.tables.initialize().then(function () {
    // Add the Mobile API so it is accessible as a Web API.
    app.use(mobile);

    // Start listening on HTTP.
    app.listen(process.env.PORT || 3000);
});

Definieren Sie die Tabelle in ./tables/TodoItem.js:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Additional configuration for the table goes here.

module.exports = table;

Tabellen verwenden standardmäßig ein dynamisches Schema. Um das dynamische Schema global zu deaktivieren, legen Sie die MS_DynamicSchema App-Einstellung im Azure-Portal auf "false" fest.

Sie finden ein vollständiges Beispiel im Todo-Beispiel auf GitHub.

Definieren von Tabellen mithilfe eines statischen Schemas

Sie können die Spalten explizit definieren, die über die Web-API verfügbar gemacht werden sollen. Das azure-mobile-apps Node.js SDK fügt automatisch alle zusätzlichen Spalten hinzu, die für die Offlinedatensynchronisierung erforderlich sind, in die von Ihnen bereitgestellte Liste. Für die Schnellstartclientanwendungen ist beispielsweise eine Tabelle mit zwei Spalten erforderlich: text (eine Zeichenfolge) und complete (boolescher Wert).
Die Tabelle kann in der JavaScript-Datei der Tabellendefinition (im verzeichnis tables) wie folgt definiert werden:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define the columns within the table.
table.columns = {
    "text": "string",
    "complete": "boolean"
};

// Turn off the dynamic schema.
table.dynamicSchema = false;

module.exports = table;

Wenn Sie Tabellen statisch definieren, müssen Sie auch die tables.initialize()-Methode aufrufen, um das Datenbankschema beim Start zu erstellen. Die tables.initialize()-Methode gibt eine Zusage zurück, sodass der Webdienst keine Anforderungen bereitstellt, bevor die Datenbank initialisiert wird.

Verwenden von SQL Server Express als Entwicklungsdatenspeicher auf Ihrem lokalen Computer

Das SDK für Mobile Apps Node.js bietet drei Optionen für die Bereitstellung von Daten standardmäßig.

• Verwenden Sie den Speicher-Treiber, um einen flüchtigen Beispielspeicher bereitzustellen.
• Verwenden Sie den mssql Treiber, um einen SQL Server Express-Datenspeicher für die Entwicklung bereitzustellen.
• Verwenden Sie den mssql Treiber, um einen Azure SQL-Datenbankdatenspeicher für die Produktion bereitzustellen.

Das Mobile Apps Node.js SDK verwendet das mssql Node.js-Paket , um eine Verbindung mit SQL Server Express und SQL-Datenbank herzustellen und zu verwenden. Dieses Paket erfordert, dass Sie TCP-Verbindungen in Ihrer SQL Server Express-Instanz aktivieren.

1. Laden Sie Microsoft SQL Server 2014 Express herunter, und installieren Sie sie. Stellen Sie sicher, dass Sie sql Server 2014 Express mit Tools Edition installieren. Sofern Sie keine 64-Bit-Unterstützung benötigen, verbraucht die 32-Bit-Version bei der Ausführung weniger Arbeitsspeicher.

2. Ausführen von SQL Server 2014 Configuration Manager:

   a) Erweitern Sie den SQL Server-Netzwerkkonfiguration Knotenpunkt im Strukturmenü.

   b. Wählen Sie Protokolle für SQLEXPRESS aus.

   c. Klicken Sie mit der rechten Maustaste auf TCP/IP-, und wählen Sie aktivieren aus. Wählen Sie im Popupdialogfeld OK aus.

   d. Klicken Sie mit der rechten Maustaste auf TCP/IP , und wählen Sie "Eigenschaften" aus.

   e. Wählen Sie die Registerkarte "IP-Adressen" aus .

   f. Suchen Sie den IPAll-Knoten . Geben Sie im Feld TCP-Port1433 ein.

   

   g. Wählen Sie OK aus. Wählen Sie im Popupdialogfeld OK aus.

   h. Wählen Sie SQL Server Services- im Strukturmenü aus.

   i. Klicken Sie mit der rechten Maustaste auf SQL Server (SQLEXPRESS), und wählen Sie "Neu starten" aus.

   j. Schließen Sie SQL Server 2014 Configuration Manager.

3. Führen Sie SQL Server 2014 Management Studio aus, und stellen Sie eine Verbindung mit Ihrer lokalen SQL Server Express-Instanz her:

   1. Klicken Sie im Objekt-Explorer mit der rechten Maustaste auf Ihre Instanz, und wählen Sie "Eigenschaften" aus.

   2. Wählen Sie die Seite Sicherheit aus.

   3. Stellen Sie sicher, dass der SQL Server- und Windows-Authentifizierungsmodus ausgewählt ist.

   4. Wählen Sie OK aus.

      

   5. Erweitern Sie Sicherheit>Anmeldungen im Objekt-Explorer.

   6. Klicken Sie mit der rechten Maustaste auf "Anmeldungen ", und wählen Sie "Neue Anmeldung" aus.

   7. Geben Sie einen Anmeldenamen ein. Wählen Sie SQL Server-Authentifizierung aus. Geben Sie ein Kennwort ein, und geben Sie dann dasselbe Kennwort in " Kennwort bestätigen" ein. Das Kennwort muss den Anforderungen an die Windows-Komplexität entsprechen.

   8. Wählen Sie OK aus.

      

   9. Klicken Sie mit der rechten Maustaste auf Ihre neue Anmeldung, und wählen Sie "Eigenschaften" aus.

   10. Wählen Sie die Seite "Serverrollen " aus.

   11. Aktivieren Sie das Kontrollkästchen für die Dbcreator-Serverrolle .

   12. Wählen Sie OK aus.

   13. Schließen Sie SQL Server 2015 Management Studio.

Achten Sie darauf, den von Ihnen ausgewählten Benutzernamen und das Kennwort aufzuzeichnen. Je nach Ihren Datenbankanforderungen müssen Sie möglicherweise zusätzliche Serverrollen oder Berechtigungen zuweisen.

Die Node.js Anwendung liest die umgebungsvariable SQLCONNSTR_MS_TableConnectionString für die Verbindungszeichenfolge für diese Datenbank vor. Sie können diese Variable in Ihrer Umgebung festlegen. Sie können beispielsweise PowerShell verwenden, um diese Umgebungsvariable festzulegen:

$env:SQLCONNSTR_MS_TableConnectionString = "Server=127.0.0.1; Database=mytestdatabase; User Id=azuremobile; Password=T3stPa55word;"

Greifen Sie über eine TCP/IP-Verbindung auf die Datenbank zu. Geben Sie einen Benutzernamen und ein Kennwort für die Verbindung an.

Konfigurieren Ihres Projekts für die lokale Entwicklung

Mobile Apps liest eine JavaScript-Datei namens azureMobile.js aus dem lokalen Dateisystem. Verwenden Sie diese Datei nicht, um das Mobile Apps SDK in der Produktion zu konfigurieren. Verwenden Sie stattdessen App-Einstellungen im Azure-Portal.

Die azureMobile.js Datei sollte ein Konfigurationsobjekt exportieren. Die am häufigsten verwendeten Einstellungen sind:

• Datenbankeinstellungen
• Diagnoseprotokollierungseinstellungen
• Alternative CORS-Einstellungen

In diesem Beispiel azureMobile.js Datei werden die vorherigen Datenbankeinstellungen implementiert:

module.exports = {
    cors: {
        origins: [ 'localhost' ]
    },
    data: {
        provider: 'mssql',
        server: '127.0.0.1',
        database: 'mytestdatabase',
        user: 'azuremobile',
        password: 'T3stPa55word'
    },
    logging: {
        level: 'verbose'
    }
};

Es wird empfohlen, Ihrer GITIGNORE-Datei (oder einer anderen Quellcodeverwaltungsdatei) azureMobile.js hinzuzufügen, um zu verhindern, dass Kennwörter in der Cloud gespeichert werden. Konfigurieren Sie die Produktionseinstellungen immer in den App-Einstellungen im Azure-Portal.

Konfigurieren von App-Einstellungen für Ihre mobile App

Die meisten Einstellungen in der datei azureMobile.js verfügen über eine entsprechende App-Einstellung im Azure-Portal. Verwenden Sie die folgende Liste, um Ihre App in App-Einstellungenzu konfigurieren:

So legen Sie eine App-Einstellung fest:

1. Melden Sie sich beim Azure-Portal an.
2. Wählen Sie "Alle Ressourcen " oder "App Services" und dann den Namen Ihrer mobilen App aus.
3. Der Einstellungsbereich wird standardmäßig geöffnet. Wenn dies nicht der Fall ist, wählen Sie Einstellungen aus.
4. Wählen Sie im Menü "ALLGEMEIN " die Option "Anwendungseinstellungen" aus.
5. Scrollen Sie zum Abschnitt "App-Einstellungen" .
6. Wenn Ihre App-Einstellung bereits vorhanden ist, wählen Sie den Wert der App-Einstellung aus, um den Wert zu bearbeiten. Wenn Ihre App-Einstellung nicht vorhanden ist, geben Sie die App-Einstellung in das Feld "Schlüssel " und den Wert im Feld "Wert " ein.
7. Wählen Sie Speichern aus.

Das Ändern der meisten App-Einstellungen erfordert einen Dienstneustart.

Verwenden der SQL-Datenbank als Produktionsdatenspeicher

Die Verwendung der Azure SQL-Datenbank als Datenspeicher ist in allen Azure App Service-Anwendungstypen identisch. Wenn dies noch nicht geschehen ist, führen Sie die folgenden Schritte aus, um ein Back-End für mobile Apps zu erstellen:

1. Melden Sie sich beim Azure-Portal an.

2. Wählen Sie oben links im Fenster die Schaltfläche +NEU>(Web + Mobile>App) aus, und geben Sie dann einen Namen für Ihr Mobile-Apps-Back-End an.

3. Geben Sie im Feld "Ressourcengruppe " denselben Namen wie Ihre App ein.

4. Der Standardmäßige App Service-Plan ist ausgewählt. Wenn Sie Ihren App Service-Plan ändern möchten:

   a) Wählen Sie "App Service Plan>"+"Neu erstellen" aus.

   b. Geben Sie einen Namen des neuen App Service-Plans an, und wählen Sie einen geeigneten Ort aus.

   c. Wählen Sie ein geeignetes Preisniveau für den Dienst aus. Wählen Sie "Alle anzeigen" aus, um weitere Preisoptionen anzuzeigen, z. B. "Kostenlos " und "Freigegeben".

   d. Klicken Sie auf die Schaltfläche Auswählen.

   e. Wählen Sie im Bereich "App Service-Plan " "OK" aus.

5. Klicken Sie auf Erstellen.

Das Bereitstellen eines Back-Ends für mobile Apps kann einige Minuten dauern. Nachdem das Mobile Apps-Back-End bereitgestellt wurde, öffnet das Portal den Einstellungsbereich für das Mobile Apps-Back-End.

Sie können entweder eine vorhandene SQL-Datenbank mit Ihrem Mobilen Apps-Back-End verbinden oder eine neue SQL-Datenbank erstellen. In diesem Abschnitt erstellen wir eine SQL-Datenbank.

1. Wählen Sie im neuen Back-End mobile Apps "Einstellungen>" "MobileApp-Daten>>+Hinzufügen" aus.

2. Wählen Sie im Bereich "Datenverbindung hinzufügen" die Option "SQL-Datenbank – Erforderliche Einstellungen> konfigurieren" aus, um eine neue Datenbank zu erstellen. Geben Sie den Namen der neuen Datenbank in das Feld "Name " ein.

3. Wählen Sie Server aus. Geben Sie im Bereich "Neuer Server " einen eindeutigen Servernamen in das Feld " Servername " ein, und geben Sie einen geeigneten Serveradministratoranmeldung und ein entsprechendes Kennwort an. Stellen Sie sicher, dass Azure-Dienste für den Zugriff auf den Server ausgewählt sind. Wählen Sie OK aus.

   

4. Wählen Sie im Bereich "Neue Datenbank " "OK" aus.

5. Wählen Sie wieder im Bereich "Datenverbindung hinzufügen" die Verbindungszeichenfolge aus, und geben Sie die Anmeldung und das Kennwort ein, die Sie beim Erstellen der Datenbank angegeben haben. Wenn Sie eine vorhandene Datenbank verwenden, geben Sie die Anmeldeinformationen für diese Datenbank an. Wählen Sie OK aus.

6. Wählen Sie wieder im Bereich " Datenverbindung hinzufügen " "OK " aus, um die Datenbank zu erstellen.

Die Erstellung der Datenbank kann einige Minuten dauern. Verwenden Sie den Bereich "Benachrichtigungen ", um den Fortschritt der Bereitstellung zu überwachen. Fahren Sie erst fort, wenn die Datenbank erfolgreich bereitgestellt wurde. Nachdem die Datenbank bereitgestellt wurde, wird eine Verbindungszeichenfolge für die SQL-Datenbankinstanz in den Back-End-App-Einstellungen Ihrer mobilen Apps erstellt. Sie können diese App-Einstellung in Einstellungen>, Anwendungseinstellungen> und Verbindungszeichenfolgen anzeigen.

Anfordern der Authentifizierung für den Zugriff auf Tabellen

Wenn Sie die App Service-Authentifizierung mit dem tables Endpunkt verwenden möchten, müssen Sie zuerst die App-Dienstauthentifizierung im Azure-Portal konfigurieren. Weitere Informationen finden Sie im Konfigurationshandbuch für den Identitätsanbieter, den Sie verwenden möchten:

• Konfigurieren der Azure Active Directory-Authentifizierung
• Konfigurieren der Facebook-Authentifizierung
• Konfigurieren der Google-Authentifizierung
• Konfigurieren der Microsoft-Authentifizierung
• Konfigurieren der Twitter-Authentifizierung

Jede Tabelle verfügt über eine Zugriffseigenschaft, mit der Sie den Zugriff auf die Tabelle steuern können. Das folgende Beispiel zeigt eine statisch definierte Tabelle mit erforderlicher Authentifizierung.

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define the columns within the table.
table.columns = {
    "text": "string",
    "complete": "boolean"
};

// Turn off the dynamic schema.
table.dynamicSchema = false;

// Require authentication to access the table.
table.access = 'authenticated';

module.exports = table;

Die Zugriffseigenschaft kann einen von drei Werten annehmen.

• anonym gibt an, dass die Clientanwendung Daten ohne Authentifizierung lesen kann.
• authentifizierte gibt an, dass die Clientanwendung ein gültiges Authentifizierungstoken mit der Anforderung senden muss.
• deaktiviert gibt an, dass diese Tabelle derzeit deaktiviert ist.

Wenn die Access-Eigenschaft nicht definiert ist, ist der nicht authentifizierte Zugriff zulässig.

Verwenden Sie Authentifizierungsansprüche mit Ihren Tabellen

Sie können verschiedene Ansprüche einrichten, die beim Einrichten der Authentifizierung angefordert werden. Diese Ansprüche sind normalerweise nicht über das context.user-Objekt verfügbar. Sie können sie jedoch mithilfe der context.user.getIdentity()-Methode abrufen. Die getIdentity()-Methode gibt eine Zusage zurück, die in ein Objekt aufgelöst wird. Das Objekt wird durch die Authentifizierungsmethode (facebook, google, twitter, microsoftaccountoder aad) schlüsselt.

Wenn Sie beispielsweise die Microsoft-Kontoauthentifizierung einrichten und den Anspruch auf E-Mail-Adressen anfordern, können Sie die E-Mail-Adresse dem Datensatz mit dem folgenden Tabellencontroller hinzufügen:

var azureMobileApps = require('azure-mobile-apps');

// Create a new table definition.
var table = azureMobileApps.table();

table.columns = {
    "emailAddress": "string",
    "text": "string",
    "complete": "boolean"
};
table.dynamicSchema = false;
table.access = 'authenticated';

/**
* Limit the context query to those records with the authenticated user email address
* @param {Context} context the operation context
* @returns {Promise} context execution Promise
*/
function queryContextForEmail(context) {
    return context.user.getIdentity().then((data) => {
        context.query.where({ emailAddress: data.microsoftaccount.claims.emailaddress });
        return context.execute();
    });
}

/**
* Adds the email address from the claims to the context item - used for
* insert operations
* @param {Context} context the operation context
* @returns {Promise} context execution Promise
*/
function addEmailToContext(context) {
    return context.user.getIdentity().then((data) => {
        context.item.emailAddress = data.microsoftaccount.claims.emailaddress;
        return context.execute();
    });
}

// Configure specific code when the client does a request.
// READ: only return records that belong to the authenticated user.
table.read(queryContextForEmail);

// CREATE: add or overwrite the userId based on the authenticated user.
table.insert(addEmailToContext);

// UPDATE: only allow updating of records that belong to the authenticated user.
table.update(queryContextForEmail);

// DELETE: only allow deletion of records that belong to the authenticated user.
table.delete(queryContextForEmail);

module.exports = table;

Um zu sehen, welche Ansprüche verfügbar sind, verwenden Sie einen Webbrowser, um den /.auth/me Endpunkt Ihrer Website anzuzeigen.

Deaktivieren des Zugriffs auf bestimmte Tabellenvorgänge

Zusätzlich zum Angezeigtwerden in der Tabelle kann die Zugriffseigenschaft verwendet werden, um einzelne Vorgänge zu steuern. Es gibt vier Vorgänge:

• read ist der RESTful GET-Vorgang in der Tabelle.
• insert ist der RESTful POST-Vorgang in der Tabelle.
• update ist der RESTful PATCH-Vorgang in der Tabelle.
• delete ist der RESTful DELETE-Vorgang in der Tabelle.

Sie können z. B. eine schreibgeschützte nicht authentifizierte Tabelle bereitstellen:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Read-only table. Only allow READ operations.
table.read.access = 'anonymous';
table.insert.access = 'disabled';
table.update.access = 'disabled';
table.delete.access = 'disabled';

module.exports = table;

Anpassen der Abfrage, die mit Tabellenvorgängen verwendet wird

Eine häufige Anforderung für Tabellenvorgänge besteht darin, eine eingeschränkte Ansicht der Daten bereitzustellen. Sie können z. B. eine Tabelle bereitstellen, die mit der authentifizierten Benutzer-ID gekennzeichnet ist, sodass Sie nur Ihre eigenen Datensätze lesen oder aktualisieren können. Die folgende Tabellendefinition bietet diese Funktionalität:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define a static schema for the table.
table.columns = {
    "userId": "string",
    "text": "string",
    "complete": "boolean"
};
table.dynamicSchema = false;

// Require authentication for this table.
table.access = 'authenticated';

// Ensure that only records for the authenticated user are retrieved.
table.read(function (context) {
    context.query.where({ userId: context.user.id });
    return context.execute();
});

// When adding records, add or overwrite the userId with the authenticated user.
table.insert(function (context) {
    context.item.userId = context.user.id;
    return context.execute();
});

module.exports = table;

Vorgänge, die normalerweise eine Abfrage ausführen, weisen eine Abfrageeigenschaft auf, die Sie mithilfe einer where-Klausel anpassen können. Die Abfrageeigenschaft ist ein QueryJS--Objekt, das verwendet wird, um eine OData-Abfrage in etwas zu konvertieren, das das Daten-Back-End verarbeiten kann. Bei einfachen Gleichheitsfällen (z. B. dem vorherigen Fall) können Sie eine Karte verwenden. Sie können auch bestimmte SQL-Klauseln hinzufügen:

context.query.where('myfield eq ?', 'value');

Konfigurieren eines Softdeletes in einer Tabelle

Beim weichen Löschen werden Datensätze nicht tatsächlich gelöscht. Stattdessen wird sie in der Datenbank als gelöscht markiert, indem die gelöschte Spalte auf "true" festgelegt wird. Das Mobile Apps SDK entfernt automatisch vorläufig gelöschte Datensätze aus Ergebnissen, es sei denn, das Mobile Client SDK verwendet IncludeDeleted(). Um eine Tabelle für einen vorläufigen Löschvorgang zu konfigurieren, legen Sie die eigenschaft softDelete in der Tabellendefinitionsdatei fest:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define the columns within the table.
table.columns = {
    "text": "string",
    "complete": "boolean"
};

// Turn off the dynamic schema.
table.dynamicSchema = false;

// Turn on soft delete.
table.softDelete = true;

// Require authentication to access the table.
table.access = 'authenticated';

module.exports = table;

Sie sollten einen Mechanismus zum Löschen von Datensätzen einrichten: eine Clientanwendung, einen WebJob, eine Azure-Funktion oder eine benutzerdefinierte API.

Befüllen Sie Ihre Datenbank mit Daten

Wenn Sie eine neue Anwendung erstellen, möchten Sie vielleicht eine Tabelle mit Daten befüllen. Sie können dies in der JavaScript-Datei der Tabellendefinition wie folgt tun:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define the columns within the table.
table.columns = {
    "text": "string",
    "complete": "boolean"
};
table.seed = [
    { text: 'Example 1', complete: false },
    { text: 'Example 2', complete: true }
];

// Turn off the dynamic schema.
table.dynamicSchema = false;

// Require authentication to access the table.
table.access = 'authenticated';

module.exports = table;

Das Seeding von Daten erfolgt nur, wenn Sie das Mobile Apps SDK zum Erstellen der Tabelle verwendet haben. Wenn die Tabelle bereits in der Datenbank vorhanden ist, werden keine Daten in die Tabelle eingefügt. Wenn das dynamische Schema aktiviert ist, wird das Schema aus den Seeded-Daten abgeleitet.

Es wird empfohlen, die tables.initialize()-Methode explizit aufzurufen, um die Tabelle zu erstellen, wenn der Dienst gestartet wird.

Aktivieren der Swagger-Unterstützung

Mobile Apps verfügen über integrierte Swagger-Unterstützung . Um die Swagger-Unterstützung zu aktivieren, installieren Sie zuerst swagger-ui als Abhängigkeit:

npm install --save swagger-ui

Anschließend können Sie die Swagger-Unterstützung im Konstruktor für mobile Apps aktivieren:

var mobile = azureMobileApps({ swagger: true });

Wahrscheinlich möchten Sie nur die Swagger-Unterstützung in Entwicklungseditionen aktivieren. Dazu können Sie die App-Einstellung NODE_ENV verwenden:

var mobile = azureMobileApps({ swagger: process.env.NODE_ENV !== 'production' });

Der swagger Endpunkt befindet sich auf http://Ihrer Website.azurewebsites.net/swagger. Sie können über den /swagger/ui Endpunkt auf die Swagger-Benutzeroberfläche zugreifen. Wenn Sie die Authentifizierung für die gesamte Anwendung benötigen, erzeugt Swagger einen Fehler. Wählen Sie optimale Ergebnisse aus, um nicht authentifizierte Anforderungen in den Azure App Service-Authentifizierungs-/Autorisierungseinstellungen zuzulassen und dann die Authentifizierung mithilfe der table.access-Eigenschaft zu steuern.

Sie können ihrer azureMobile.js Datei auch die Option "Swagger" hinzufügen, wenn Sie nur Swagger-Unterstützung für die lokale Entwicklung benötigen.

Pushbenachrichtigungen

Mobile Apps sind in Azure Notification Hubs integriert, sodass Sie gezielte Pushbenachrichtigungen an Millionen von Geräten auf allen wichtigen Plattformen senden können. Mithilfe von Benachrichtigungshubs können Sie Pushbenachrichtigungen an iOS-, Android- und Windows-Geräte senden. Weitere Informationen zu allen Aktionen, die Sie mit Benachrichtigungshubs ausführen können, finden Sie in der Übersicht über Benachrichtigungshubs.

Senden von Pushbenachrichtigungen

Der folgende Code zeigt, wie das push Objekt verwendet wird, um eine Übertragungs-Pushbenachrichtigung an registrierte iOS-Geräte zu senden:

// Create an APNS payload.
var payload = '{"aps": {"alert": "This is an APNS payload."}}';

// Only do the push if configured.
if (context.push) {
    // Send a push notification by using APNS.
    context.push.apns.send(null, payload, function (error) {
        if (error) {
            // Do something or log the error.
        }
    });
}

Durch Erstellen einer Vorlagen-Pushregistrierung vom Client können Sie stattdessen eine Vorlagen-Pushnachricht an Geräte auf allen unterstützten Plattformen senden. Der folgende Code zeigt, wie eine Vorlagenbenachrichtigung gesendet wird:

// Define the template payload.
var payload = '{"messageParam": "This is a template payload."}';

// Only do the push if configured.
if (context.push) {
    // Send a template notification.
    context.push.send(null, payload, function (error) {
        if (error) {
            // Do something or log the error.
        }
    });
}

Senden von Pushbenachrichtigungen an einen authentifizierten Benutzer mithilfe von Tags

Wenn sich ein authentifizierter Benutzer für Pushbenachrichtigungen registriert, wird der Registrierung automatisch ein Benutzer-ID-Tag hinzugefügt. Mithilfe dieses Tags können Sie Pushbenachrichtigungen an alle Geräte senden, die von einem bestimmten Benutzer registriert wurden. Der folgende Code ruft die SID des Benutzers ab, der die Anforderung vornimmt, und sendet eine Pushbenachrichtigung einer Vorlage an jede Geräteregistrierung für diesen Benutzer:

// Only do the push if configured.
if (context.push) {
    // Send a notification to the current user.
    context.push.send(context.user.id, payload, function (error) {
        if (error) {
            // Do something or log the error.
        }
    });
}

Wenn Sie sich für Pushbenachrichtigungen von einem authentifizierten Client registrieren, stellen Sie sicher, dass die Authentifizierung abgeschlossen ist, bevor Sie die Registrierung versuchen.

Benutzerdefinierte APIs

Definieren einer benutzerdefinierten API

Zusätzlich zur Datenzugriffs-API über den /tables Endpunkt können mobile Apps eine benutzerdefinierte API-Abdeckung bereitstellen. Benutzerdefinierte APIs sind auf ähnliche Weise wie die Tabellendefinitionen definiert und können auf alle gleichen Einrichtungen zugreifen, einschließlich Authentifizierung.

Wenn Sie die App Service-Authentifizierung mit einer benutzerdefinierten API verwenden möchten, müssen Sie zuerst die App Service-Authentifizierung im Azure-Portal konfigurieren. Weitere Informationen finden Sie im Konfigurationshandbuch für den Identitätsanbieter, den Sie verwenden möchten:

• Konfigurieren der Azure Active Directory-Authentifizierung
• Konfigurieren der Facebook-Authentifizierung
• Konfigurieren der Google-Authentifizierung
• Konfigurieren der Microsoft-Authentifizierung
• Konfigurieren der Twitter-Authentifizierung

Benutzerdefinierte APIs werden ähnlich wie die Tabellen-API definiert:

1. Erstellen Sie ein api Verzeichnis.
2. Erstellen Sie eine JAVAScript-Api-Definitionsdatei im api Verzeichnis.
3. Verwenden Sie die Importmethode, um das api Verzeichnis zu importieren.

Nachfolgend sehen Sie die Prototyp-API-Definition basierend auf dem Beispiel für die einfache App, das wir zuvor verwendet haben:

var express = require('express'),
    azureMobileApps = require('azure-mobile-apps');

var app = express(),
    mobile = azureMobileApps();

// Import the custom API.
mobile.api.import('./api');

// Add the Mobile API so it is accessible as a Web API.
app.use(mobile);

// Start listening on HTTP
app.listen(process.env.PORT || 3000);

Nehmen wir uns eine Beispiel-API an, die das Serverdatum mithilfe der Date.now()-Methode zurückgibt. Dies ist die API/date.js Datei:

var api = {
    get: function (req, res, next) {
        var date = { currentTime: Date.now() };
        res.status(200).type('application/json').send(date);
    });
};

module.exports = api;

Jeder Parameter ist eines der standardmäßigen RESTful-Verben: GET, POST, PATCH oder DELETE. Die Methode ist eine Standard-ExpressJS-Middleware--Funktion, die die erforderliche Ausgabe sendet.

Anfordern der Authentifizierung für den Zugriff auf eine benutzerdefinierte API

Das Mobile Apps SDK implementiert die Authentifizierung auf die gleiche Weise sowohl für den tables Endpunkt als auch für benutzerdefinierte APIs. Um der im vorherigen Abschnitt entwickelten API eine Authentifizierung hinzuzufügen, fügen Sie eine access Eigenschaft hinzu:

var api = {
    get: function (req, res, next) {
        var date = { currentTime: Date.now() };
        res.status(200).type('application/json').send(date);
    });
};
// All methods must be authenticated.
api.access = 'authenticated';

module.exports = api;

Sie können auch die Authentifizierung für bestimmte Vorgänge angeben:

var api = {
    get: function (req, res, next) {
        var date = { currentTime: Date.now() };
        res.status(200).type('application/json').send(date);
    }
};
// The GET methods must be authenticated.
api.get.access = 'authenticated';

module.exports = api;

Das gleiche Token, das für den tables Endpunkt verwendet wird, muss für benutzerdefinierte APIs verwendet werden, die eine Authentifizierung erfordern.

Große Dateiuploads bearbeiten

Das Mobile Apps SDK verwendet die Body-Parser-Middleware , um Textkörperinhalte in Ihrer Übermittlung zu akzeptieren und zu decodieren. Sie können den Body-Parser vorkonfigurieren, um größere Dateiuploads zu akzeptieren:

var express = require('express'),
    bodyParser = require('body-parser'),
    azureMobileApps = require('azure-mobile-apps');

var app = express(),
    mobile = azureMobileApps();

// Set up large body content handling.
app.use(bodyParser.json({ limit: '50mb' }));
app.use(bodyParser.urlencoded({ limit: '50mb', extended: true }));

// Import the custom API.
mobile.api.import('./api');

// Add the Mobile API so it is accessible as a Web API.
app.use(mobile);

// Start listening on HTTP.
app.listen(process.env.PORT || 3000);

Die Datei ist vor der Übertragung base64 codiert. Diese Codierung erhöht die Größe des tatsächlichen Uploads (und die Größe, die Sie berücksichtigen müssen).

Ausführen von benutzerdefinierten SQL-Anweisungen

Das Mobile Apps SDK ermöglicht den Zugriff auf den gesamten Kontext über das Anforderungsobjekt. Sie können parametrisierte SQL-Anweisungen auf einfache Weise an den definierten Datenanbieter ausführen:

var api = {
    get: function (request, response, next) {
        // Check for parameters. If not there, pass on to a later API call.
        if (typeof request.params.completed === 'undefined')
            return next();

        // Define the query. Anything that the mssql
        // driver can handle is allowed.
        var query = {
            sql: 'UPDATE TodoItem SET complete=@completed',
            parameters: [{
                completed: request.params.completed
            }]
        };

        // Execute the query. The context for Mobile Apps is available through
        // request.azureMobile. The data object contains the configured data provider.
        request.azureMobile.data.execute(query)
        .then(function (results) {
            response.json(results);
        });
    }
};

api.get.access = 'authenticated';
module.exports = api;

Fehlersuche

Debuggen, Diagnostizieren und Problembehandlung für mobile Apps

Azure App Service bietet verschiedene Debugging- und Problembehandlungstechniken für Node.js Anwendungen. Informationen zu den ersten Schritten bei der Problembehandlung für Ihr Node.js Mobile Apps-Back-End finden Sie in den folgenden Artikeln:

• Überwachen von Azure App Service
• Aktivieren der Diagnoseprotokollierung in Azure App Service
• Problembehandlung für Azure App Service in Visual Studio

Node.js Anwendungen haben Zugriff auf eine Vielzahl von Diagnoseprotokolltools. Intern verwendet das Mobile Apps Node.js SDK Winston für die Diagnoseprotokollierung. Die Protokollierung wird automatisch aktiviert, wenn Sie den Debugmodus aktivieren oder die MS_DebugMode App-Einstellung im Azure-Portal auf "true" festlegen. Generierte Protokolle werden in den Diagnoseprotokollen im Azure-Portal angezeigt.