De Mobile Apps Node.js SDK gebruiken

Artikel
10/01/2016

Dit artikel bevat gedetailleerde informatie en voorbeelden die laten zien hoe u met een Node.js back-end kunt werken in de functie Mobile Apps van Azure App Service.

Introductie

Mobile Apps biedt de mogelijkheid om een web-API voor mobiele toegang tot gegevens toe te voegen aan een webtoepassing. De Mobile Apps SDK is beschikbaar voor ASP.NET en Node.js webtoepassingen. De SDK biedt de volgende bewerkingen:

Tabelbewerkingen (lezen, invoegen, bijwerken, verwijderen) voor gegevenstoegang
Aangepaste API-bewerkingen

Beide bewerkingen bieden verificatie voor alle id-providers die Azure App Service toestaat. Deze providers omvatten sociale id-providers zoals Facebook, Twitter, Google en Microsoft, evenals Azure Active Directory voor bedrijfsidentiteit.

U vindt voorbeelden voor elke use-case in de map met voorbeelden op GitHub.

Ondersteunde platforms

De Mobile Apps Node.js SDK ondersteunt de huidige LTS-versie van Node en hoger. De nieuwste LTS-versie is momenteel Node v4.5.0. Andere versies van Node werken mogelijk, maar worden niet ondersteund.

De Mobile Apps Node.js SDK ondersteunt twee databasestuurprogramma's:

Het knooppunt-mssql-stuurprogramma ondersteunt Azure SQL Database en lokale SQL Server exemplaren.
Het sqlite3-stuurprogramma biedt alleen ondersteuning voor SQLite-databases op één exemplaar.

Een eenvoudige Node.js back-end maken met behulp van de opdrachtregel

Elke Mobile Apps Node.js back-end wordt gestart als een ExpressJS-toepassing. ExpressJS is het populairste webserviceframework dat beschikbaar is voor Node.js. U kunt als volgt een eenvoudige Express-toepassing maken:

Maak in een opdracht- of PowerShell-venster een map voor uw project:
```
 mkdir basicapp
```
Voer deze opdracht uit npm init om de pakketstructuur te initialiseren:
```
 cd basicapp
 npm init
```
Met npm init de opdracht wordt een reeks vragen gesteld om het project te initialiseren. Bekijk de voorbeelduitvoer:
Installeer de express en azure-mobile-apps bibliotheken vanuit de NPM-opslagplaats:
```
 npm install --save express azure-mobile-apps
```

Maak een app.js-bestand om de eenvoudige mobiele server te implementeren:

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);

Met deze toepassing maakt u een web-API die voor mobiel is geoptimaliseerd met één eindpunt (/tables/TodoItem) dat niet-geverifieerde toegang biedt tot een onderliggende SQL gegevensopslag met behulp van een dynamisch schema. Het is geschikt voor het volgen van de quickstarts voor de clientbibliotheek:

U vindt de code voor deze basistoepassing in het basicapp-voorbeeld op GitHub.

Een Node.js back-end maken met behulp van Visual Studio 2015

Visual Studio 2015 is een uitbreiding vereist om Node.js toepassingen binnen de IDE te ontwikkelen. Installeer eerst de Node.js Tools 1.1 voor Visual Studio. Wanneer u de installatie hebt voltooid, maakt u een Express 4.x-toepassing:

Het dialoogvenster Nieuw Project openen (vanuit Bestand>nieuw>Project).
Vouw DeJavaScript>-Node.jssjablonen> uit.
Selecteer Basic Azure Node.js Express 4-toepassing.
Vul de projectnaam in. Selecteer OK.
Klik met de rechtermuisknop op het npm-knooppunt en selecteer Nieuwe npm-pakketten installeren.
Mogelijk moet u de NPM-catalogus vernieuwen nadat u uw eerste Node.js-toepassing hebt gemaakt. Selecteer Indien nodig Vernieuwen .
Voer azure-mobile-apps in het zoekvak in. Selecteer het pakket azure-mobile-apps 2.0.0 en selecteer Vervolgens Pakket installeren.
Selecteer Sluiten.
Open het app.js-bestand om ondersteuning toe te voegen voor de Mobile Apps SDK. Voeg op regel 6 onder aan de bibliotheekinstructies require de volgende code toe:
```
var bodyParser = require('body-parser');
var azureMobileApps = require('azure-mobile-apps');
```
Voeg op ongeveer regel 27 na de andere app.use instructies de volgende code toe:
```
app.use('/users', users);

// Mobile Apps initialization
var mobile = azureMobileApps();
mobile.tables.add('TodoItem');
app.use(mobile);
```
Sla het bestand op.
Voer de toepassing lokaal uit (de API wordt aangeboden) https://localhost:3000of publiceer naar Azure.

Een Node.js back-end maken met behulp van de Azure Portal

U kunt rechtstreeks in de Azure Portal een back-end voor Mobile Apps maken. U kunt de volgende stappen uitvoeren of een client en server samen maken door de zelfstudie Een mobiele app maken te volgen. De zelfstudie bevat een vereenvoudigde versie van deze instructies en is het beste voor proof-of-concept-projecten.

Meld u aan bij Azure Portal.
Selecteer +NEW>Web + Mobile Mobile>App en geef vervolgens een naam op voor de back-end van Mobile Apps.
Voor de resourcegroep selecteert u een bestaande resourcegroep of maakt u een nieuwe resourcegroep (met dezelfde naam als uw app).
Voor App Service abonnement is het standaardabonnement (in de standard-laag) geselecteerd. U kunt ook een ander plan selecteren of een nieuw plan maken.

De instellingen van het App Service-plan bepalen de locatie, functies, kosten en rekenresources die aan uw app zijn gekoppeld. Zie voor meer informatie over App Service abonnementen en het maken van een nieuw abonnement in een andere prijscategorie en op de gewenste locatie Azure App Service overzicht van abonnementen.
Selecteer Maken. Met deze stap maakt u de back-end van Mobile Apps.
Selecteer in het deelvenster Instellingen voor de nieuwe back-end voor mobiele apps snel aan de slag> met uw client-app-platform >Verbinding maken een database.
Selecteer in het deelvenster Gegevensverbinding toevoegenSQL Database>Een nieuwe database maken. Voer de databasenaam in, kies een prijscategorie en selecteer Vervolgens Server. U kunt deze nieuwe database opnieuw gebruiken. Als u al een database op dezelfde locatie hebt, kunt u in plaats daarvan Een bestaande database gebruiken kiezen. Het gebruik van een database op een andere locatie wordt niet aanbevolen vanwege de bandbreedtekosten en een hogere latentie.
Voer in het deelvenster Nieuwe server een unieke servernaam in het vak Servernaam in, geef een aanmelding en wachtwoord op, selecteer Azure-services toegang geven tot de server en selecteer OK. Met deze stap maakt u de nieuwe database.
Selecteer in het deelvenster Gegevensverbinding toevoegende verbindingsreeks, voer de aanmeldings- en wachtwoordwaarden voor uw database in en selecteer OK.

Wacht enkele minuten totdat de database is geïmplementeerd voordat u doorgaat.

Kies in het deelvenster Aan de slag onder Een tabel-API makenNode.js als back-endtaal. Selecteer het vak voor ik bevestig dat hiermee alle inhoud van de site wordt overschreven en selecteer vervolgens de tabel TodoItem maken.

Download het Node.js quickstartcodeproject voor de back-end met behulp van Git

Wanneer u een back-end van Node.js Mobile Apps maakt met behulp van het deelvenster Snel starten van de portal, wordt er een Node.js project voor u gemaakt en geïmplementeerd op uw site. In de portal kunt u tabellen en API's toevoegen en codebestanden bewerken voor de Node.js back-end. U kunt ook verschillende implementatiehulpprogramma's gebruiken om het back-endproject te downloaden, zodat u tabellen en API's kunt toevoegen of wijzigen en het project vervolgens opnieuw kunt publiceren. Zie de Azure App Service implementatiehandleiding voor meer informatie.

In de volgende procedure wordt een Git-opslagplaats gebruikt om de quickstart-projectcode te downloaden:

Installeer Git als u dit nog niet hebt gedaan. De stappen die nodig zijn om Git te installeren, variëren per besturingssystemen. Zie Git installeren voor specifieke distributies en installatierichtlijnen voor het besturingssysteem.
Zie Uw opslagplaats voorbereiden om de Git-opslagplaats in te schakelen voor uw back-endsite. Noteer de gebruikersnaam en het wachtwoord voor de implementatie.
Noteer in het deelvenster voor de back-end van Mobile Apps de instelling voor de Git-kloon-URL .
Voer de git clone opdracht uit met behulp van de Git-kloon-URL. Voer indien nodig uw wachtwoord in, zoals in het volgende voorbeeld:
```
 $ git clone https://username@todolist.scm.azurewebsites.net:443/todolist.git
```
Blader naar de lokale map (/todolist in het vorige voorbeeld) en u ziet dat projectbestanden zijn gedownload. Zoek het bestand todoitem.json in de /tables map. Dit bestand definieert machtigingen voor de tabel. Zoek ook het todoitem.js bestand in dezelfde map. Hiermee worden de CRUD-bewerkingsscripts voor de tabel gedefinieerd.
Nadat u wijzigingen in projectbestanden hebt aangebracht, voert u de volgende opdrachten uit om de wijzigingen toe te voegen, door te voeren en vervolgens te uploaden naar de site:
```
 $ git commit -m "updated the table script"
 $ git push origin master
```
Wanneer u nieuwe bestanden aan het project toevoegt, moet u eerst de git add . opdracht uitvoeren.

De site wordt telkens opnieuw gepubliceerd wanneer een nieuwe set doorvoeringen naar de site wordt gepusht.

Uw Node.js back-end publiceren naar Azure

Microsoft Azure biedt veel mechanismen voor het publiceren van uw Mobile Apps Node.js back-end naar de Azure-service. Deze mechanismen omvatten implementatiehulpprogramma's die zijn geïntegreerd in Visual Studio, opdrachtregelprogramma's en opties voor continue implementatie op basis van broncodebeheer. Zie de Azure App Service implementatiehandleiding voor meer informatie.

Azure App Service heeft specifiek advies voor Node.js toepassingen die u moet controleren voordat u de back-end publiceert:

Een startpagina inschakelen voor uw toepassing

Veel toepassingen zijn een combinatie van web- en mobiele apps. U kunt het ExpressJS-framework gebruiken om de twee facetten te combineren. Soms wilt u echter mogelijk alleen een mobiele interface implementeren. Het is handig om een startpagina te bieden om ervoor te zorgen dat de App Service actief is. U kunt uw eigen startpagina opgeven of een tijdelijke startpagina inschakelen. Als u een tijdelijke startpagina wilt inschakelen, gebruikt u de volgende code om Mobile Apps te instantiëren:

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

Als u deze optie alleen beschikbaar wilt maken bij het lokaal ontwikkelen, kunt u deze instelling toevoegen aan uw azureMobile.js-bestand.

Tabelbewerkingen

De azure-mobile-apps Node.js Server SDK biedt mechanismen voor het beschikbaar maken van gegevenstabellen die zijn opgeslagen in Azure SQL Database als een web-API. Het biedt vijf bewerkingen:

Bewerking	Beschrijving
GET /tables/tablename	Haal alle records in de tabel op.
GET /tables/tablename/:id	Haal een specifieke record op in de tabel.
POST /tables/tablename	Maak een record in de tabel.
PATCH /tables/tablename/:id	Een record in de tabel bijwerken.
DELETE /tables/tablename/:id	Verwijder een record in de tabel.

Deze web-API ondersteunt OData en breidt het tabelschema uit om offline gegevenssynchronisatie te ondersteunen.

Tabellen definiëren met behulp van een dynamisch schema

Voordat u een tabel kunt gebruiken, moet u deze definiëren. U kunt tabellen definiëren met behulp van een statisch schema (waarbij u de kolommen in het schema definieert) of dynamisch (waarbij de SDK het schema beheert op basis van binnenkomende aanvragen). Daarnaast kunt u specifieke aspecten van de web-API beheren door JavaScript-code toe te voegen aan de definitie.

Als best practice moet u elke tabel in een JavaScript-bestand in de tables map definiëren en vervolgens de tables.import() methode gebruiken om de tabellen te importeren. Als u het voorbeeld van de basic-app uitbreidt, past u het app.js-bestand aan:

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);
});

Definieer de tabel 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 maken standaard gebruik van een dynamisch schema. Als u het dynamische schema globaal wilt uitschakelen, stelt u de MS_DynamicSchema app-instelling in op false in de Azure Portal.

U vindt een volledig voorbeeld in het takenvoorbeeld op GitHub.

Tabellen definiëren met behulp van een statisch schema

U kunt de kolommen expliciet definiëren om beschikbaar te maken via de web-API. De azure-mobile-apps Node.js SDK voegt automatisch extra kolommen toe die nodig zijn voor offlinegegevenssynchronisatie naar de lijst die u opgeeft. Voor de quickstart-clienttoepassingen is bijvoorbeeld een tabel met twee kolommen vereist: text (een tekenreeks) en complete (een Booleaanse waarde).
De tabel kan als volgt worden gedefinieerd in het JavaScript-bestand met de tabeldefinitie (in de tables map):

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;

Als u tabellen statisch definieert, moet u ook de tables.initialize() methode aanroepen om het databaseschema te maken bij het opstarten. De tables.initialize() methode retourneert een belofte , zodat de webservice geen aanvragen verwerkt voordat de database wordt geïnitialiseerd.

SQL Server Express gebruiken als een ontwikkelingsgegevensarchief op uw lokale computer

De Mobile Apps Node.js SDK biedt drie opties voor het leveren van gegevens uit het vak:

Gebruik het geheugenstuurprogramma om een niet-persistent voorbeeldarchief te bieden.
Gebruik het mssql-stuurprogramma om een SQL Server Express gegevensarchief te bieden voor ontwikkeling.
Gebruik het mssql-stuurprogramma om een Azure SQL Database gegevensarchief te bieden voor productie.

De Mobile Apps Node.js SDK maakt gebruik van het mssql Node.js-pakket om een verbinding tot stand te brengen en te gebruiken met zowel SQL Server Express als SQL Database. Voor dit pakket moet u TCP-verbindingen inschakelen op uw SQL Server Express exemplaar.

Tip

Het geheugenstuurprogramma biedt geen volledige set faciliteiten voor het testen. Als u uw back-end lokaal wilt testen, raden we u aan een SQL Server Express gegevensarchief en het mssql-stuurprogramma te gebruiken.

Download en installeer Microsoft SQL Server 2014 Express. Zorg ervoor dat u de SQL Server 2014 Express met tools-editie installeert. Tenzij u expliciet 64-bits ondersteuning nodig hebt, verbruikt de 32-bits versie minder geheugen wanneer deze wordt uitgevoerd.
Voer SQL Server 2014-Configuration Manager uit:

a. Vouw het knooppunt SQL Server Netwerkconfiguratie uit in het structuurmenu.

b. Selecteer Protocollen voor SQLEXPRESS.

c. Klik met de rechtermuisknop op TCP/IP en selecteer Inschakelen. Selecteer OK in het pop-updialoogvenster.

d. Klik met de rechtermuisknop op TCP/IP en selecteer Eigenschappen.

e. Selecteer het tabblad IP-adressen .

f. Zoek het IPAll-knooppunt . Voer 1433 in het veld TCP-poort in.

g. Selecteer OK. Selecteer OK in het pop-updialoogvenster.

h. Selecteer SQL Server Services in het structuurmenu.

i. Klik met de rechtermuisknop op SQL Server (SQLEXPRESS) en selecteer Opnieuw opstarten.

j. Sluit SQL Server 2014 Configuration Manager.
Voer SQL Server 2014-Management Studio uit en maak verbinding met uw lokale SQL Server Express-exemplaar:
1. Klik met de rechtermuisknop op uw exemplaar in Objectverkenner en selecteer Eigenschappen.
2. Selecteer de pagina Beveiliging .
3. Zorg ervoor dat SQL Server en Windows verificatiemodus is geselecteerd.
4. Selecteer OK.
5. Vouwbeveiligingsaanmeldingen> uit in Objectverkenner.
6. Klik met de rechtermuisknop op Aanmeldingen en selecteer Nieuwe aanmelding.
7. Voer een aanmeldingsnaam in. Selecteer SQL Server verificatie. Voer een wachtwoord in en voer hetzelfde wachtwoord in bij Wachtwoord bevestigen. Het wachtwoord moet voldoen aan Windows complexiteitsvereisten.
8. Selecteer OK.
9. Klik met de rechtermuisknop op uw nieuwe aanmelding en selecteer Eigenschappen.
10. Selecteer de pagina Serverfuncties .
11. Schakel het selectievakje in voor de dbcreator-serverfunctie .
12. Selecteer OK.
13. Sluit SQL Server 2015 Management Studio.

Zorg ervoor dat u de gebruikersnaam en het wachtwoord opneemt die u hebt geselecteerd. Mogelijk moet u aanvullende serverfuncties of -machtigingen toewijzen, afhankelijk van uw databasevereisten.

De Node.js-toepassing leest de SQLCONNSTR_MS_TableConnectionString omgevingsvariabele voor de connection string voor deze database. U kunt deze variabele instellen in uw omgeving. U kunt powerShell bijvoorbeeld gebruiken om deze omgevingsvariabele in te stellen:

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

Toegang tot de database via een TCP/IP-verbinding. Geef een gebruikersnaam en wachtwoord op voor de verbinding.

Uw project configureren voor lokale ontwikkeling

Mobile Apps leest een JavaScript-bestand met de naam azureMobile.js uit het lokale bestandssysteem. Gebruik dit bestand niet om de Mobile Apps SDK in productie te configureren. Gebruik in plaats daarvan app-instellingen in de Azure Portal.

Het azureMobile.js-bestand moet een configuratieobject exporteren. De meest voorkomende instellingen zijn:

Database-instellingen
Instellingen voor diagnostische logboekregistratie
Alternatieve CORS-instellingen

In dit voorbeeldazureMobile.js bestand de voorgaande database-instellingen implementeert:

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

U wordt aangeraden azureMobile.js toe te voegen aan uw .gitignore-bestand (of een ander broncodebeheer bestand negeren) om te voorkomen dat wachtwoorden worden opgeslagen in de cloud. Configureer altijd productie-instellingen in app-instellingen in de Azure Portal.

App-instellingen configureren voor uw mobiele app

De meeste instellingen in het azureMobile.js-bestand hebben een equivalente app-instelling in de Azure Portal. Gebruik de volgende lijst om uw app te configureren in app-instellingen:

App-instelling	instelling voor azureMobile.js	Description	Geldige waarden
MS_MobileAppName	naam	Naam van de app	tekenreeks
MS_MobileLoggingLevel	logging.level	Minimale logboekniveau van berichten die moeten worden geregistreerd	fout, waarschuwing, info, uitgebreid, foutopsporing, dom
MS_DebugMode	debug	Foutopsporingsmodus in- of uitschakelen	de waarde True, false
MS_TableSchema	data.schema	Standaardschemanaam voor SQL tabellen	tekenreeks (standaard: dbo)
MS_DynamicSchema	data.dynamicSchema	Foutopsporingsmodus in- of uitschakelen	de waarde True, false
MS_DisableVersionHeader	versie (ingesteld op niet-gedefinieerd)	Hiermee wordt de header X-ZUMO-Server-Version uitgeschakeld	de waarde True, false
MS_SkipVersionCheck	skipversioncheck	Hiermee schakelt u de controle van de client-API-versie uit	de waarde True, false

Een app-instelling instellen:

Meld u aan bij de Azure-portal.
Selecteer Alle resources of App Services en selecteer vervolgens de naam van uw mobiele app.
Het deelvenster Instellingen wordt standaard geopend. Als dit niet het probleem is, selecteert u Instellingen.
Selecteer toepassingsinstellingen in het menu ALGEMEEN.
Blader naar de sectie App-instellingen .
Als uw app-instelling al bestaat, selecteert u de waarde van de app-instelling om de waarde te bewerken. Als uw app-instelling niet bestaat, voert u de app-instelling in het vak Sleutel en de waarde in het vak Waarde in.
Selecteer Opslaan.

Voor het wijzigen van de meeste app-instellingen moet de service opnieuw worden opgestart.

SQL Database gebruiken als uw productiegegevensarchief

Het gebruik van Azure SQL Database als gegevensarchief is identiek in alle Azure App Service toepassingstypen. Als u dit nog niet hebt gedaan, volgt u deze stappen om een Back-end van Mobile Apps te maken:

Meld u aan bij de Azure-portal.
Selecteer linksboven in het venster de knop >+NEWWeb + Mobile Mobile>App en geef vervolgens een naam op voor de back-end van Mobile Apps.
Voer in het vak Resourcegroep dezelfde naam in als uw app.
Het standaardabonnement App Service is geselecteerd. Als u uw App Service-abonnement wilt wijzigen:

a. Selecteer App Service Plan>+Nieuwe maken.

b. Geef een naam op van het nieuwe App Service-plan en selecteer een geschikte locatie.

c. Selecteer een geschikte prijscategorie voor de service. Selecteer Alles weergeven om meer prijsopties weer te geven, zoals Gratis en Gedeeld.

d. Klik op de knop Selecteren.

e. Selecteer OK in het deelvenster App Service plan.
Selecteer Maken.

Het inrichten van een back-end van Mobile Apps kan enkele minuten duren. Nadat de back-end van Mobile Apps is ingericht, opent de portal het Instellingen deelvenster voor de back-end van Mobile Apps.

U kunt ervoor kiezen om een bestaande SQL-database te verbinden met de back-end van Mobile Apps of een nieuwe SQL-database te maken. In deze sectie maken we een SQL-database.

Notitie

Als u al een database op dezelfde locatie hebt als de back-end van Mobile Apps, kunt u in plaats daarvan Een bestaande database gebruiken selecteren en vervolgens die database selecteren. We raden het gebruik van een database op een andere locatie niet aan vanwege hogere latenties.

Selecteer in de nieuwe back-end van Mobile Apps Instellingen>Mobile App>Data>+Add.
Selecteer in het deelvenster Gegevensverbinding toevoegenSQL Database - Vereiste instellingen>een nieuwe database maken configureren. Voer de naam van de nieuwe database in het vak Naam in.
Selecteer Server. Voer in het deelvenster Nieuwe server een unieke servernaam in het vak Servernaam in en geef een geschikte aanmelding en wachtwoord voor de serverbeheerder op. Zorg ervoor dat Azure-services toegang hebben tot de server is geselecteerd. Selecteer OK.
Selecteer OK in het deelvenster Nieuwe database.
Selecteer in het deelvenster Gegevensverbinding toevoegen de verbindingsreeks en voer de aanmelding en het wachtwoord in die u hebt opgegeven bij het maken van de database. Als u een bestaande database gebruikt, geeft u de aanmeldingsreferenties voor die database op. Selecteer OK.
Selecteer in het deelvenster Gegevensverbinding toevoegen weer OK om de database te maken.

Het maken van de database kan enkele minuten duren. Gebruik het gebied Meldingen om de voortgang van de implementatie te controleren. Ga pas verder als de database is geïmplementeerd. Nadat de database is geïmplementeerd, wordt er een connection string gemaakt voor het SQL Database exemplaar in de back-end-app-instellingen van uw Mobile Apps. U kunt deze app-instelling zien in Instellingen>Toekenningsinstellingen>Verbindingsreeksen.

Verificatie vereisen voor toegang tot tabellen

Als u App Service-verificatie wilt gebruiken met het tables eindpunt, moet u eerst App Service verificatie configureren in de Azure Portal. Zie de configuratiehandleiding voor de id-provider die u wilt gebruiken voor meer informatie:

Elke tabel heeft een toegangseigenschap die u kunt gebruiken om de toegang tot de tabel te beheren. In het volgende voorbeeld ziet u een statisch gedefinieerde tabel met verificatie vereist.

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;

De toegangseigenschap kan een van de volgende drie waarden hebben:

anoniem geeft aan dat de clienttoepassing gegevens mag lezen zonder verificatie.
geverifieerd geeft aan dat de clienttoepassing een geldig verificatietoken moet verzenden met de aanvraag.
uitgeschakeld geeft aan dat deze tabel momenteel is uitgeschakeld.

Als de toegangseigenschap niet is gedefinieerd, is niet-geverifieerde toegang toegestaan.

Verificatieclaims gebruiken met uw tabellen

U kunt verschillende claims instellen die worden aangevraagd wanneer verificatie is ingesteld. Deze claims zijn normaal gesproken niet beschikbaar via het context.user object. U kunt ze echter ophalen met behulp van de context.user.getIdentity() methode. De getIdentity() methode retourneert een belofte die wordt omgezet in een object. Het object wordt gesleuteld door de verificatiemethode (facebook, google, twitter, microsoftaccountof aad).

Als u bijvoorbeeld Microsoft-accountverificatie instelt en de claim voor e-mailadressen aanvraagt, kunt u het e-mailadres toevoegen aan de record met de volgende tabelcontroller:

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;

Als u wilt zien welke claims beschikbaar zijn, gebruikt u een webbrowser om het /.auth/me eindpunt van uw site weer te geven.

Toegang tot specifieke tabelbewerkingen uitschakelen

Naast het weergeven van de tabel, kan de toegangseigenschap worden gebruikt om afzonderlijke bewerkingen te beheren. Er zijn vier bewerkingen:

read is de RESTful GET-bewerking in de tabel.
insert is de RESTful POST-bewerking in de tabel.
update is de RESTful PATCH-bewerking in de tabel.
delete is de RESTful DELETE-bewerking in de tabel.

U wilt bijvoorbeeld een niet-geverifieerde tabel met alleen-lezengegevens opgeven:

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;

De query aanpassen die wordt gebruikt met tabelbewerkingen

Een algemene vereiste voor tabelbewerkingen is om een beperkte weergave van de gegevens te bieden. U kunt bijvoorbeeld een tabel opgeven die is getagd met de geverifieerde gebruikers-id, zodat u alleen uw eigen records kunt lezen of bijwerken. De volgende tabeldefinitie biedt deze functionaliteit:

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;

Bewerkingen die normaal gesproken een query uitvoeren, hebben een queryeigenschap die u kunt aanpassen met behulp van een where component. De queryeigenschap is een QueryJS-object dat wordt gebruikt om een OData-query te converteren naar iets dat de back-end van de gegevens kan verwerken. Voor eenvoudige gelijkheidsgevallen (zoals de voorgaande) kunt u een kaart gebruiken. U kunt ook specifieke SQL componenten toevoegen:

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

Een voorlopig verwijderen voor een tabel configureren

Met een voorlopig verwijderen worden records niet daadwerkelijk verwijderd. In plaats daarvan worden ze gemarkeerd als verwijderd in de database door de verwijderde kolom in te stellen op waar. De Mobile Apps SDK verwijdert automatisch voorlopig verwijderde records uit de resultaten, tenzij de Mobile Client SDK gebruikmaakt IncludeDeleted(). Als u een tabel wilt configureren voor voorlopig verwijderen, stelt u de softDelete eigenschap in het tabeldefinitiebestand in:

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;

U moet een mechanisme instellen voor het verwijderen van records: een clienttoepassing, een webtaak, een Azure-functie of een aangepaste API.

Uw database seeden met gegevens

Wanneer u een nieuwe toepassing maakt, wilt u mogelijk een tabel met gegevens seeden. U kunt dit als volgt doen in het JavaScript-bestand met de tabeldefinitie:

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;

Het seeden van gegevens gebeurt alleen wanneer u de Mobile Apps SDK hebt gebruikt om de tabel te maken. Als de tabel al in de database bestaat, worden er geen gegevens in de tabel geïnjecteerd. Als het dynamische schema is ingeschakeld, wordt het schema afgeleid van de seeded gegevens.

U wordt aangeraden de tables.initialize() methode expliciet aan te roepen om de tabel te maken wanneer de service wordt uitgevoerd.

Swagger-ondersteuning inschakelen

Mobile Apps wordt geleverd met ingebouwde Swagger-ondersteuning . Als u Swagger-ondersteuning wilt inschakelen, installeert u eerst swagger-ui als een afhankelijkheid:

npm install --save swagger-ui

Vervolgens kunt u Swagger-ondersteuning inschakelen in de constructor Mobile Apps:

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

U wilt waarschijnlijk alleen Swagger-ondersteuning inschakelen in ontwikkelingsversies. U kunt dit doen met behulp van de NODE_ENV app-instelling:

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

Het swagger eindpunt bevindt zich op http:// yoursite.azurewebsites.net/swagger. U hebt toegang tot de Swagger-gebruikersinterface via het /swagger/ui eindpunt. Als u ervoor kiest om verificatie in uw hele toepassing te vereisen, produceert Swagger een fout. Voor de beste resultaten kiest u ervoor om niet-geverifieerde aanvragen toe te staan in de instellingen voor Azure App Service verificatie/autorisatie en vervolgens verificatie te beheren met behulp van de table.access eigenschap.

U kunt ook de Swagger-optie toevoegen aan uw azureMobile.js-bestand als u alleen Swagger-ondersteuning wilt voor het lokaal ontwikkelen.

Pushmeldingen

Mobile Apps kan worden geïntegreerd met Azure Notification Hubs, zodat u gerichte pushmeldingen kunt verzenden naar miljoenen apparaten op alle belangrijke platforms. Met Notification Hubs kunt u pushmeldingen verzenden naar iOS, Android en Windows apparaten. Zie het overzicht van Notification Hubs voor meer informatie over alles wat u met Notification Hubs kunt doen.

Pushmeldingen verzenden

De volgende code laat zien hoe u het push object gebruikt om een pushmelding voor een uitzending te verzenden naar geregistreerde iOS-apparaten:

// 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.
        }
    });
}

Door een sjabloonpushregistratie van de client te maken, kunt u in plaats daarvan een sjabloonpushbericht verzenden naar apparaten op alle ondersteunde platforms. De volgende code laat zien hoe u een sjabloonmelding verzendt:

// 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.
        }
    });
}

Pushmeldingen verzenden naar een geverifieerde gebruiker met behulp van tags

Wanneer een geverifieerde gebruiker zich registreert voor pushmeldingen, wordt automatisch een gebruikers-id-tag toegevoegd aan de registratie. Met behulp van deze tag kunt u pushmeldingen verzenden naar alle apparaten die zijn geregistreerd door een specifieke gebruiker. De volgende code haalt de SID op van de gebruiker die de aanvraag doet en verzendt een sjabloonpushmelding naar elke apparaatregistratie voor die gebruiker:

// 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.
        }
    });
}

Wanneer u zich registreert voor pushmeldingen van een geverifieerde client, moet u ervoor zorgen dat de verificatie is voltooid voordat u de registratie probeert uit te voeren.

Aangepaste API's

Een aangepaste API definiëren

Naast de Data Access-API via het /tables eindpunt kan Mobile Apps aangepaste API-dekking bieden. Aangepaste API's worden op een vergelijkbare manier gedefinieerd als de tabeldefinities en hebben toegang tot dezelfde faciliteiten, inclusief verificatie.

Als u App Service-verificatie wilt gebruiken met een aangepaste API, moet u eerst App Service verificatie configureren in de Azure Portal. Zie de configuratiehandleiding voor de id-provider die u wilt gebruiken voor meer informatie:

Aangepaste API's worden op ongeveer dezelfde manier gedefinieerd als de Tables-API:

Maak een api map.
Maak een JavaScript-bestand met API-definities in de api map.
Gebruik de importmethode om de api map te importeren.

Hier volgt de prototype-API-definitie op basis van het basis-app-voorbeeld dat we eerder hebben gebruikt:

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);

Laten we een voorbeeld-API nemen die de serverdatum retourneert met behulp van de Date.now() methode. Dit is het API-/date.js-bestand:

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

module.exports = api;

Elke parameter is een van de standaard RESTful-bewerkingen: GET, POST, PATCH of DELETE. De methode is een standaard ExpressJS-middlewarefunctie waarmee de vereiste uitvoer wordt verzonden.

Verificatie vereisen voor toegang tot een aangepaste API

De Mobile Apps SDK implementeert verificatie op dezelfde manier voor zowel het tables eindpunt als de aangepaste API's. Als u verificatie wilt toevoegen aan de API die in de vorige sectie is ontwikkeld, voegt u een access eigenschap toe:

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;

U kunt ook verificatie opgeven voor specifieke bewerkingen:

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;

Hetzelfde token dat voor het tables eindpunt wordt gebruikt, moet worden gebruikt voor aangepaste API's waarvoor verificatie is vereist.

Grote bestandsuploads verwerken

De Mobile Apps SDK maakt gebruik van de body-parser middleware voor het accepteren en decoderen van hoofdtekstinhoud in uw inzending. U kunt de hoofdtekstparser vooraf configureren om grotere bestandsuploads te accepteren:

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);

Het bestand is base-64 gecodeerd vóór verzending. Deze codering verhoogt de grootte van de werkelijke upload (en de grootte waarvoor u rekening moet houden).

Aangepaste SQL-instructies uitvoeren

De Mobile Apps SDK biedt toegang tot de volledige context via het aanvraagobject. U kunt eenvoudig geparameteriseerde SQL instructies uitvoeren bij de gedefinieerde gegevensprovider:

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;

Foutopsporing

Fouten opsporen, diagnosticeren en problemen met Mobile Apps oplossen

Azure App Service biedt verschillende foutopsporings- en probleemoplossingstechnieken voor Node.js toepassingen. Raadpleeg de volgende artikelen om aan de slag te gaan met het oplossen van problemen met de back-end van uw Node.js Mobile Apps:

Node.js toepassingen toegang hebben tot een breed scala aan hulpprogramma's voor diagnostisch logboeken. Intern gebruikt de Mobile Apps Node.js SDK Winston voor diagnostische logboekregistratie. Logboekregistratie wordt automatisch ingeschakeld wanneer u de foutopsporingsmodus inschakelt of de MS_DebugMode app-instelling instelt op True in de Azure Portal. Gegenereerde logboeken worden weergegeven in de diagnostische logboeken in de Azure Portal.

Delen via