So verwenden Sie das Node.js SDK für Azure Mobile Apps

Artikel
05/05/2021

Anmerkung

Dieses Produkt wird eingestellt. Eine Ersetzung für Projekte mit .NET 8 oder höher finden Sie in der Community Toolkit Datasync-Bibliothek.

Dieser Artikel enthält ausführliche Informationen und Beispiele, die zeigen, wie Sie mit einem NodeJS-Back-End für Azure Mobile Apps arbeiten.

Einleitung

Azure Mobile Apps bietet die Möglichkeit, einer Webanwendung eine mobile optimierte Datenzugriffs-Web-API hinzuzufügen. Das Azure Mobile Apps SDK wird für ASP.NET Framework 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 Social Identity-Anbieter wie Facebook, Twitter, Google und Microsoft und Microsoft Entra ID for Enterprise Identity.

Unterstützte Plattformen

Das Azure Mobile Apps Node.js SDK unterstützt das Node 6.x und höher und wurde bis zu Node 12.x getestet. Andere Versionen von Node funktionieren möglicherweise, werden aber nicht unterstützt.

Das Azure 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-Back-End mithilfe der Befehlszeile

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

Erstellen Sie in einem Befehls- oder PowerShell-Fenster ein Verzeichnis für Ihr Projekt:
```
$ mkdir basicapp
```
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:
Installieren Sie die bibliotheken express und azure-mobile-apps aus dem npm-Repository:
```
npm install --save express azure-mobile-apps
```

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:

Sie finden den Code für diese einfache Anwendung im Bereich Beispiele auf GitHub.

Aktivieren einer Startseite für Ihre Anwendung

Viele Anwendungen sind eine Kombination aus Web- und mobilen Apps. Sie können das Express-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. Verwenden Sie zum Aktivieren einer temporären Startseite den folgenden Code, um Azure 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 der konfigurationsdatei azureMobile.js hinzufügen:

module.exports = {
    homePage: true,
};

Sie können der azureMobile.js Datei nach Bedarf weitere Einstellungen 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:

Operation	Beschreibung
`GET /tables/tablename`	Ruft alle Datensätze in der Tabelle ab.
`GET /tables/tablename/:id`	Rufen Sie einen bestimmten Datensatz in der Tabelle ab.
`POST /tables/tablename`	Erstellen Sie einen Datensatz in der Tabelle.
`PATCH /tables/tablename/:id`	Aktualisieren eines Datensatzes in der Tabelle.
`DELETE /tables/tablename/:id`	Löschen eines Datensatzes in der Tabelle.

Diese Web-API unterstützt OData v3- und erweitert das Tabellenschema, um Offlinedatensynchronisierungzu 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.

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 Azure Mobile Apps Node.js SDK bietet drei Optionen, um Daten sofort zu verarbeiten:

Verwenden Sie den Speicher Treibers, um einen nicht persistenten 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 Azure 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.

Trinkgeld

Der Speichertreiber stellt keinen vollständigen Satz von Einrichtungen zum Testen bereit. Wenn Sie Ihr Back-End lokal testen möchten, empfehlen wir die Verwendung eines SQL Server Express-Datenspeichers und des mssql-Treibers.

Laden Sie Microsoft SQL Server 2019 Developerherunter, und installieren Sie sie.
Configuration Manager ausführen:
- Erweitern Sie die SQL Server-Netzwerkkonfiguration Knoten im Strukturmenü.
- Wählen Sie Protokolle für Instanznamenaus.
- Klicken Sie mit der rechten Maustaste auf TCP/IP-, und wählen Sie aktivieren aus. Wählen Sie im Popupdialogfeld OK aus.
- Wählen Sie SQL Server Services- im Strukturmenü aus.
- Klicken Sie mit der rechten Maustaste auf SQL Server (Instanzname), und wählen Sie Neustartenaus.
- Schließen Sie Configuration Manager.

Sie müssen auch einen Benutzernamen und ein Kennwort erstellen, den Azure Mobile Apps verwenden können, um eine Verbindung mit der Datenbank herzustellen. Stellen Sie sicher, dass der von Ihnen erstellte Benutzer über die dbcreator Serverrolle verfügt. Weitere Informationen zum Konfigurieren von Benutzern finden Sie in der SQL Server-Dokumentation

Achten Sie darauf, den von Ihnen ausgewählten Benutzernamen und das Kennwort aufzuzeichnen. Je nach Ihren Datenbankanforderungen müssen Sie möglicherweise weitere 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

Azure Mobile Apps liest eine JavaScript-Datei namens azureMobile.js aus dem lokalen Dateisystem. Verwenden Sie diese Datei nicht, um das Azure 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 Quellcodeverwaltung, die Datei ignorieren) azureMobile.js hinzuzufügen, um zu verhindern, dass Kennwörter in der Cloud gespeichert werden.

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:

App-Einstellung	azureMobile.js Einstellung	Beschreibung	Gültige Werte
MS_MobileAppName	Name	Name der App	Schnur
MS_MobileLoggingLevel	logging.level	Minimale Protokollebene der zu protokollierenden Nachrichten	Fehler, Warnung, Info, ausführlich, Debuggen, dumm
MS_DebugMode	debuggen	Aktiviert oder deaktiviert den Debugmodus	true, false
MS_TableSchema	data.schema	Standardschemaname für SQL-Tabellen	Zeichenfolge (Standard: dbo)
MS_DynamicSchema	data.dynamicSchema	Aktiviert oder deaktiviert den Debugmodus	true, false
MS_DisableVersionHeader	Version (auf "undefiniert" festgelegt)	Deaktiviert den X-ZUMO-Server-Version-Header.	true, false
MS_SkipVersionCheck	skipversioncheck	Deaktiviert die Client-API-Versionsüberprüfung.	true, false

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

Verwenden von Azure SQL als Produktionsdatenspeicher

Die Verwendung der Azure SQL-Datenbank als Datenspeicher ist in allen Azure App Service-Anwendungstypen identisch. Wenn Sie dies noch nicht getan haben, führen Sie die folgenden Schritte aus, um ein Azure App Service-Back-End zu erstellen. Erstellen Sie eine Azure SQL-Instanz, und legen Sie dann die App-Einstellung SQLCONNSTR_MS_TableConnectionString auf die Verbindungszeichenfolge für die Azure SQL-Instanz fest, die Sie verwenden möchten. Stellen Sie sicher, dass der Azure App Service, der Ihr Back-End ausführt, mit Ihrer Azure SQL-Instanz kommunizieren kann.

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 Service-Authentifizierung im Azure-Portal konfigurieren. Weitere Informationen finden Sie im Konfigurationshandbuch für den Identitätsanbieter, den Sie verwenden möchten:

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 Access-Eigenschaft kann einen von drei Werten annehmen:

anonymen gibt an, dass die Clientanwendung Daten ohne Authentifizierung lesen darf.
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 von Authentifizierungsansprüchen 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.

Anmerkung

Wenn Sie die Microsoft-Authentifizierung über die Microsoft Entra-ID verwenden, ist die Authentifizierungsmethode aad, nicht microsoftaccount.

Wenn Sie beispielsweise die Microsoft Entra-Authentifizierung einrichten und den Anspruch der 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.aad.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.aad.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 Anzeigen in der Tabelle kann die Access-Eigenschaft 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 vorläufigen Löschens in einer Tabelle

Bei einem vorläufigen 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 Azure 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;

Richten Sie einen Mechanismus zum dauerhaften Löschen von Datensätzen ein, z. B. eine Clientanwendung, einen WebJob, eine Azure-Funktion oder eine benutzerdefinierte API.

Seeden Ihrer Datenbank mit Daten

Wenn Sie eine neue Anwendung erstellen, möchten Sie möglicherweise eine Tabelle mit Daten ausserieren. Sie können Daten in der JavaScript-Datei der Tabellendefinition wie folgt seeden:

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 Azure 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

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

npm install --save swagger-ui

Sie können dann die Swagger-Unterstützung im Azure Mobile Apps-Konstruktor aktivieren:

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

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

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.

Benutzerdefinierte APIs

Zusätzlich zur Datenzugriffs-API über den /tables-Endpunkt können Azure 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.

Definieren einer benutzerdefinierten API

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

Erstellen Sie ein api Verzeichnis.
Erstellen Sie eine JAVAScript-Api-Definitionsdatei im api Verzeichnis.
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 Azure 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.

Behandeln großer Dateiuploads

Das Azure 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 Azure 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 Azure 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;

Debuggen

Debuggen, Diagnostizieren und Problembehandlung für Azure Mobile Apps

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

Node.js Anwendungen haben Zugriff auf eine Vielzahl von Diagnoseprotokolltools. Intern verwendet das Azure 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.

Freigeben über