Använda Mobile Apps Node.js SDK

  • Artikel

Den här artikeln innehåller detaljerad information och exempel som visar hur du arbetar med en Node.js serverdel i mobile apps-funktionen i Azure App Service.

Introduktion

Mobile Apps ger möjlighet att lägga till en mobiloptimerad dataåtkomstwebb-API till ett webbprogram. Mobile Apps SDK tillhandahålls för ASP.NET och Node.js webbprogram. SDK:et tillhandahåller följande åtgärder:

  • Tabellåtgärder (läsa, infoga, uppdatera, ta bort) för dataåtkomst
  • Anpassade API-åtgärder

Båda åtgärderna tillhandahåller autentisering för alla identitetsprovidrar som Azure App Service tillåter. Dessa leverantörer inkluderar sociala identitetsleverantörer som Facebook, Twitter, Google och Microsoft, samt Azure Active Directory för företagsidentitet.

Du hittar exempel för varje användningsfall i exempelkatalogen på GitHub.

Plattformar som stöds

Mobile Apps Node.js SDK stöder den aktuella LTS-versionen av Node och senare. För närvarande är den senaste LTS-versionen Node v4.5.0. Andra versioner av Node kan fungera men stöds inte.

Mobile Apps Node.js SDK stöder två databasdrivrutiner:

  • Drivrutinen node-mssql stöder Azure SQL Database och lokala SQL Server instanser.
  • Sqlite3-drivrutinen stöder endast SQLite-databaser på en enda instans.

Skapa en grundläggande Node.js serverdel med hjälp av kommandoraden

Varje Mobile Apps-Node.js serverdel startar som ett ExpressJS-program. ExpressJS är det mest populära webbtjänstramverket som är tillgängligt för Node.js. Du kan skapa ett grundläggande Express-program på följande sätt:

  1. I ett kommando- eller PowerShell-fönster skapar du en katalog för projektet:

     mkdir basicapp

  2. Kör npm init för att initiera paketstrukturen:

     cd basicapp
 npm init

    Kommandot npm init ställer en uppsättning frågor för att initiera projektet. Se exempelutdata:

    The npm init output

  3. Installera biblioteken express och azure-mobile-apps från npm-lagringsplatsen:

     npm install --save express azure-mobile-apps

  4. Skapa en app.js-fil för att implementera den grundläggande mobila servern:

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

Det här programmet skapar ett mobiloptimerad webb-API med en enda slutpunkt (/tables/TodoItem) som ger oautentiserad åtkomst till ett underliggande SQL datalager med hjälp av ett dynamiskt schema. Den är lämplig för att följa klientbibliotekets snabbstarter:

Du hittar koden för det här grundläggande programmet i basicapp-exemplet på GitHub.

Skapa en Node.js serverdel med hjälp av Visual Studio 2015

Visual Studio 2015 kräver ett tillägg för att utveckla Node.js program inom IDE. Starta genom att installeraNode.js Tools 1.1 för Visual Studio. När du är klar med installationen skapar du ett Express 4.x-program:

  1. Öppna dialogrutan Ny Project (från Ny fil>>Project).

  2. Expandera Mallar>JavaScript>Node.js.

  3. Välj Basic Azure Node.js Express 4-program.

  4. Fyll i projektnamnet. Välj OK.

    Visual Studio 2015 new project

  5. Högerklicka på noden npm och välj Installera nya npm-paket.

  6. Du kan behöva uppdatera npm-katalogen när du har skapat ditt första Node.js program. Välj Uppdatera om det behövs.

  7. Ange azure-mobile-apps i sökrutan. Välj paketet azure-mobile-apps 2.0.0 och välj sedan Installera paket.

    Install new npm packages

  8. Välj Stäng.

  9. Öppna filen app.js för att lägga till stöd för Mobile Apps SDK. Lägg till följande kod på rad 6 längst ned i biblioteksinstruktionerna require :

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

    Vid ungefär rad 27 efter de andra app.use instruktionerna lägger du till följande kod:

    app.use('/users', users);

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

    Spara filen.

  10. Kör antingen programmet lokalt (API:et hanteras på https://localhost:3000) eller publicera till Azure.

Skapa en Node.js serverdel med hjälp av Azure Portal

Du kan skapa en Mobile Apps-serverdel direkt i Azure Portal. Du kan antingen utföra följande steg eller skapa en klient och server tillsammans genom att följa självstudien Skapa en mobilapp . Självstudien innehåller en förenklad version av dessa instruktioner och passar bäst för konceptbevisprojekt.

  1. Logga in på Azure Portal.

  2. Välj +NY>webb + mobilapp> och ange sedan ett namn för mobile apps-serverdelen.

  3. För Resursgrupp väljer du en befintlig resursgrupp eller skapar en ny (med samma namn som din app).

  4. För App Service plan väljs standardplanen (på standardnivån). Du kan också välja en annan plan eller skapa en ny.

    Inställningarna för App Service plan avgör var, vilka funktioner, kostnader och beräkningsresurser som är associerade med din app. Mer information om App Service planer och hur du skapar en ny plan på en annan prisnivå och på önskad plats finns i översikten över Azure App Service planer.

  5. Välj Skapa. Det här steget skapar mobile apps-serverdelen.

  6. I fönstret Inställningar för den nya mobile apps-serverdelen väljer du Snabbstarta> klientappplattformen >Anslut en databas.

    Selections for connecting a database

  7. I fönstret Lägg till dataanslutning väljer du SQL Database>Skapa en ny databas. Ange databasnamnet, välj en prisnivå och välj sedan Server. Du kan återanvända den nya databasen. Om du redan har en databas på samma plats kan du istället välja Använd en befintlig databas. Vi rekommenderar inte att du använder en databas på en annan plats på grund av bandbreddskostnader och högre svarstid.

    Selecting a database

  8. I fönstret Ny server anger du ett unikt servernamn i rutan Servernamn , anger en inloggning och ett lösenord, väljer Tillåt Azure-tjänster att komma åt servern och väljer OK. Det här steget skapar den nya databasen.

  9. I fönstret Lägg till dataanslutning väljer du Anslutningssträng, anger inloggnings- och lösenordsvärdena för databasen och väljer OK.

    Vänta några minuter tills databasen har distribuerats innan du fortsätter.

I fönstret Kom igång går du till Skapa ett tabell-API och väljer Node.js som serverdelsspråk. Markera rutan för Jag bekräftar att detta kommer att skriva över allt webbplatsinnehåll och välj sedan Skapa TodoItem-tabell.

Ladda ned Node.js snabbstartskodprojektet för serverdelen med hjälp av Git

När du skapar en Node.js Mobile Apps-serverdelen med hjälp av portalens snabbstartsfönster skapas ett Node.js projekt åt dig och distribueras till din webbplats. I portalen kan du lägga till tabeller och API:er och redigera kodfiler för Node.js serverdelen. Du kan också använda olika distributionsverktyg för att ladda ned backend-projektet så att du kan lägga till eller ändra tabeller och API:er och sedan publicera om projektet. Mer information finns i distributionsguiden för Azure App Service.

Följande procedur använder en Git-lagringsplats för att ladda ned snabbstartsprojektkoden:

  1. Installera Git om du inte redan har gjort det. De steg som krävs för att installera Git varierar mellan operativsystem. Information om operativsystemspecifika distributioner och installationsvägledning finns i Installera Git.

  2. Se Förbereda din lagringsplats för att aktivera Git-lagringsplatsen för din serverdelsplats. Anteckna användarnamnet och lösenordet för distributionen.

  3. Anteckna URL-inställningen för Git-klon i fönstret för mobile apps-serverdelen.

  4. git clone Kör kommandot med hjälp av Git-klonens URL. Ange ditt lösenord när det behövs, som i följande exempel:

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

  5. Bläddra till den lokala katalogen (/todolist i föregående exempel) och observera att projektfiler har laddats ned. Leta upp filen todoitem.json i /tables katalogen. Den här filen definierar behörigheter i tabellen. Leta också upp den todoitem.js filen i samma katalog. Den definierar CRUD-åtgärdsskripten för tabellen.

  6. När du har ändrat projektfilerna kör du följande kommandon för att lägga till, checka in och sedan ladda upp ändringarna till webbplatsen:

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

    När du lägger till nya filer i projektet måste du först köra git add . kommandot.

Webbplatsen publiceras på nytt varje gång en ny uppsättning incheckningar skickas till webbplatsen.

Publicera din Node.js serverdel till Azure

Microsoft Azure innehåller många mekanismer för att publicera dina Mobile Apps-Node.js serverdel till Azure-tjänsten. Dessa mekanismer omfattar distributionsverktyg som är integrerade i Visual Studio, kommandoradsverktyg och alternativ för kontinuerlig distribution baserat på källkontroll. Mer information finns i distributionsguiden för Azure App Service.

Azure App Service har specifika råd för Node.js program som du bör granska innan du publicerar serverdelen:

Aktivera en startsida för ditt program

Många program är en kombination av webb- och mobilappar. Du kan använda ExpressJS-ramverket för att kombinera de två fasorna. Ibland kanske du dock bara vill implementera ett mobilt gränssnitt. Det är användbart att tillhandahålla en startsida för att säkerställa att apptjänsten är igång. Du kan antingen ange en egen startsida eller aktivera en tillfällig startsida. Om du vill aktivera en tillfällig startsida använder du följande kod för att instansiera Mobile Apps:

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

Om du bara vill att det här alternativet ska vara tillgängligt när du utvecklar lokalt kan du lägga till den här inställningen i azureMobile.js-filen.

Tabellåtgärder

Azure-mobile-apps Node.js Server SDK tillhandahåller mekanismer för att exponera datatabeller som lagras i Azure SQL Database som ett webb-API. Den innehåller fem åtgärder:

Åtgärd Description
GET /tables/tablename Hämta alla poster i tabellen.
GET /tables/tablename/:id Hämta en specifik post i tabellen.
POST /tables/tablename Skapa en post i tabellen.
PATCH /tables/tablename/:id Uppdatera en post i tabellen.
DELETE /tables/tablename/:id Ta bort en post i tabellen.

Det här webb-API:et stöder OData och utökar tabellschemat så att det stöder synkronisering av offlinedata.

Definiera tabeller med hjälp av ett dynamiskt schema

Innan du kan använda en tabell måste du definiera den. Du kan definiera tabeller med hjälp av ett statiskt schema (där du definierar kolumnerna i schemat) eller dynamiskt (där SDK:t styr schemat baserat på inkommande begäranden). Dessutom kan du styra specifika aspekter av webb-API:et genom att lägga till JavaScript-kod i definitionen.

Vi rekommenderar att du definierar varje tabell i en JavaScript-fil i tables katalogen och sedan använder tables.import() metoden för att importera tabellerna. Om du utökar basic-app-exemplet justerar du app.js-filen:

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

Definiera tabellen i ./tables/TodoItem.js:

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

var table = azureMobileApps.table();

// Additional configuration for the table goes here.

module.exports = table;

Tabeller använder ett dynamiskt schema som standard. Om du vill inaktivera det dynamiska schemat globalt anger du appinställningen MS_DynamicSchema till false i Azure Portal.

Du hittar ett fullständigt exempel i att göra-exemplet på GitHub.

Definiera tabeller med hjälp av ett statiskt schema

Du kan uttryckligen definiera kolumnerna som ska exponeras via webb-API:et. Azure-mobile-apps Node.js SDK lägger automatiskt till eventuella extra kolumner som krävs för synkronisering av offlinedata i listan som du anger. Till exempel kräver snabbstartsklientprogram en tabell med två kolumner: text (en sträng) och complete (ett booleskt värde).
Tabellen kan definieras i tabelldefinitionens JavaScript-fil (finns i tables katalogen) på följande sätt:

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;

Om du definierar tabeller statiskt måste du även anropa tables.initialize() metoden för att skapa databasschemat vid start. Metoden tables.initialize() returnerar ett löfte så att webbtjänsten inte hanterar begäranden innan databasen initieras.

Använda SQL Server Express som ett datalager för utveckling på din lokala dator

Mobile Apps Node.js SDK innehåller tre alternativ för att hantera data direkt:

  • Använd minnesdrivrutinen för att tillhandahålla ett icke-beständigt exempelarkiv.
  • Använd mssql-drivrutinen för att tillhandahålla ett SQL Server Express datalager för utveckling.
  • Använd mssql-drivrutinen för att tillhandahålla ett Azure SQL Database datalager för produktion.

Mobile Apps Node.js SDK använder mssql Node.js-paketet för att upprätta och använda en anslutning till både SQL Server Express och SQL Database. Det här paketet kräver att du aktiverar TCP-anslutningar på din SQL Server Express-instans.

Tips

Minnesdrivrutinen tillhandahåller inte en fullständig uppsättning funktioner för testning. Om du vill testa serverdelen lokalt rekommenderar vi att du använder ett SQL Server Express datalager och mssql-drivrutinen.

  1. Ladda ned och installera Microsoft SQL Server 2014 Express. Se till att du installerar SQL Server 2014 Express med Tools-utgåvan. Om du inte uttryckligen behöver 64-bitars stöd förbrukar 32-bitarsversionen mindre minne vid körning.

  2. Kör SQL Server 2014 Configuration Manager:

    a. Expandera noden SQL Server Nätverkskonfiguration på trädmenyn.

    b. Välj Protokoll för SQLEXPRESS.

    c. Högerklicka på TCP/IP och välj Aktivera. Välj OK i popup-dialogrutan.

    d. Högerklicka på TCP/IP och välj Egenskaper.

    e. Välj fliken IP-adresser .

    f. Hitta IPAll-noden . I fältet TCP-port anger du 1433.

    Configure SQL Server Express for TCP/IP

    ex. Välj OK. Välj OK i popup-dialogrutan.

    h. Välj SQL Server Tjänster i trädmenyn.

    i. Högerklicka på SQL Server (SQLEXPRESS) och välj Starta om.

    j. Stäng SQL Server 2014 Configuration Manager.

  3. Kör SQL Server 2014 Management Studio och anslut till din lokala SQL Server Express-instans:

    1. Högerklicka på din instans i Object Explorer och välj Egenskaper.

    2. Välj sidan Säkerhet .

    3. Kontrollera att SQL Server och Windows autentiseringsläge är markerat.

    4. Välj OK.

      Configure SQL Server Express authentication

    5. ExpanderaSäkerhetsinloggningar> i Object Explorer.

    6. Högerklicka på Inloggningar och välj Ny inloggning.

    7. Ange ett inloggningsnamn. Välj SQL Server autentisering. Ange ett lösenord och ange sedan samma lösenord i Bekräfta lösenord. Lösenordet måste uppfylla Windows komplexitetskrav.

    8. Välj OK.

      Add a new user to SQL Server Express

    9. Högerklicka på den nya inloggningen och välj Egenskaper.

    10. Välj sidan Serverroller .

    11. Markera kryssrutan för serverrollen dbcreator .

    12. Välj OK.

    13. Stäng SQL Server 2015 Management Studio.

Se till att registrera användarnamnet och lösenordet som du har valt. Du kan behöva tilldela ytterligare serverroller eller behörigheter, beroende på dina databaskrav.

Det Node.js programmet läser SQLCONNSTR_MS_TableConnectionString miljövariabeln för anslutningssträngen för den här databasen. Du kan ange den här variabeln i din miljö. Du kan till exempel använda PowerShell för att ange den här miljövariabeln:

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

Få åtkomst till databasen via en TCP/IP-anslutning. Ange ett användarnamn och lösenord för anslutningen.

Konfigurera projektet för lokal utveckling

Mobile Apps läser en JavaScript-fil med namnet azureMobile.js från det lokala filsystemet. Använd inte den här filen för att konfigurera Mobile Apps SDK i produktion. Använd i stället Appinställningar i Azure Portal.

Den azureMobile.js filen bör exportera ett konfigurationsobjekt. De vanligaste inställningarna är:

  • Databasinställningar
  • Inställningar för diagnostikloggning
  • Alternativa CORS-inställningar

Det här exemplet azureMobile.js-filen implementerar de föregående databasinställningarna:

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

Vi rekommenderar att du lägger till azureMobile.js i .gitignore-filen (eller någon annan fil för källkodskontroll som ignorerar filen) för att förhindra att lösenord lagras i molnet. Konfigurera alltid produktionsinställningar i Appinställningar inom Azure Portal.

Konfigurera appinställningar för din mobilapp

De flesta inställningar i azureMobile.js-filen har en motsvarande appinställning i Azure Portal. Använd följande lista för att konfigurera din app i Appinställningar:

Appinställning azureMobile.js inställning Description Giltiga värden
MS_MobileAppName name Namnet på appen sträng
MS_MobileLoggingLevel logging.level Minsta loggnivå för meddelanden som ska loggas error, warning, info, verbose, debug, silly
MS_DebugMode felsökning Aktiverar eller inaktiverar felsökningsläge SANT, FALSKT
MS_TableSchema data.schema Standardschemanamn för SQL tabeller sträng (standard: dbo)
MS_DynamicSchema data.dynamicSchema Aktiverar eller inaktiverar felsökningsläge SANT, FALSKT
MS_DisableVersionHeader version (inställd på odefinierad) Inaktiverar huvudet X-ZUMO-Server-Version SANT, FALSKT
MS_SkipVersionCheck skipversioncheck Inaktiverar versionskontroll av klient-API:et SANT, FALSKT

Så här anger du en appinställning:

  1. Logga in på Azure-portalen.
  2. Välj Alla resurser eller App Services och välj sedan namnet på din mobilapp.
  3. Fönstret Inställningar öppnas som standard. Om den inte gör det väljer du Inställningar.
  4. På menyn ALLMÄNT väljer du Programinställningar.
  5. Bläddra till avsnittet Appinställningar .
  6. Om appinställningen redan finns väljer du värdet för appinställningen för att redigera värdet. Om appinställningen inte finns anger du appinställningen i rutan Nyckel och värdet i rutan Värde .
  7. Välj Spara.

För att ändra de flesta appinställningar krävs en omstart av tjänsten.

Använda SQL Database som produktionsdatalager

Att använda Azure SQL Database som ett datalager är identiskt för alla Azure App Service programtyper. Om du inte redan har gjort det följer du dessa steg för att skapa en Mobile Apps-serverdel:

  1. Logga in på Azure-portalen.

  2. Längst upp till vänster i fönstret väljer du knappen >+NYTTWebb + Mobilapp> och anger sedan ett namn för mobile apps-serverdelen.

  3. I rutan Resursgrupp anger du samma namn som din app.

  4. Standardplanen för App Service är markerad. Om du vill ändra din App Service plan:

    a. Välj App Service Plan>+Skapa ny.

    b. Ange ett namn på den nya App Service-planen och välj en lämplig plats.

    c. Välj en lämplig prisnivå för tjänsten. Välj Visa alla om du vill visa fler prisalternativ, till exempel Kostnadsfri och Delad.

    d. Klicka på knappen Välj .

    e. I fönstret App Service plan väljer du OK.

  5. Välj Skapa.

Det kan ta några minuter att etablera en Mobile Apps-serverdel. När mobile apps-serverdelen har etablerats öppnar portalen Inställningar-fönstret för Mobile Apps-serverdelen.

Du kan välja att antingen ansluta en befintlig SQL databas till din Mobile Apps-serverdel eller skapa en ny SQL databas. I det här avsnittet skapar vi en SQL databas.

Anteckning

Om du redan har en databas på samma plats som Mobile Apps-serverdelen kan du i stället välja Använd en befintlig databas och sedan välja den databasen. Vi rekommenderar inte att du använder en databas på en annan plats på grund av högre svarstider.

  1. I den nya mobile apps-serverdelen väljer du Inställningar>Mobilappdata>>+Lägg till.

  2. I fönstret Lägg till dataanslutning väljer du SQL Database – Konfigurera nödvändiga inställningar>Skapa en ny databas. Ange namnet på den nya databasen i rutan Namn .

  3. Välj Server. I fönstret Ny server anger du ett unikt servernamn i rutan Servernamn och anger en lämplig inloggning och lösenord för serveradministratör. Se till att Tillåt azure-tjänster att komma åt servern är valt. Välj OK.

    Create an Azure SQL database

  4. I fönstret Ny databas väljer du OK.

  5. I fönstret Lägg till dataanslutning väljer du Anslutningssträng och anger inloggningen och lösenordet som du angav när du skapade databasen. Om du använder en befintlig databas anger du inloggningsuppgifterna för databasen. Välj OK.

  6. I fönstret Lägg till dataanslutning igen väljer du OK för att skapa databasen.

Det kan ta några minuter att skapa databasen. Använd området Meddelanden för att övervaka distributionens förlopp. Fortsätt inte förrän databasen har distribuerats. När databasen har distribuerats skapas en anslutningssträng för SQL Database-instansen i inställningarna för mobile apps-serverdelsappen. Du kan se den här appinställningen i Inställningar>Programinställningar>Anslutningssträngar.

Kräv autentisering för åtkomst till tabeller

Om du vill använda App Service-autentisering med tables slutpunkten måste du konfigurera App Service autentisering i Azure Portal först. Mer information finns i konfigurationsguiden för den identitetsprovider som du tänker använda:

Varje tabell har en åtkomstegenskap som du kan använda för att styra åtkomsten till tabellen. Följande exempel visar en statiskt definierad tabell med autentisering som krävs.

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;

Åtkomstegenskapen kan ha något av tre värden:

  • anonym anger att klientprogrammet får läsa data utan autentisering.
  • autentiserad anger att klientprogrammet måste skicka en giltig autentiseringstoken med begäran.
  • inaktiverad anger att den här tabellen för närvarande är inaktiverad.

Om åtkomstegenskapen är odefinierad tillåts oautentiserad åtkomst.

Använda autentiseringsanspråk med dina tabeller

Du kan konfigurera olika anspråk som begärs när autentisering konfigureras. Dessa anspråk är normalt inte tillgängliga via objektet context.user . Du kan dock hämta dem med hjälp context.user.getIdentity() av metoden . Metoden getIdentity() returnerar ett löfte som matchar ett objekt. Objektet nyckelas av autentiseringsmetoden (facebook, , googletwitter, microsoftaccounteller aad).

Om du till exempel konfigurerar Microsoft-kontoautentisering och begär anspråket för e-postadresser kan du lägga till e-postadressen i posten med följande tabellkontrollant:

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;

Om du vill se vilka anspråk som är tillgängliga använder du en webbläsare för att visa /.auth/me webbplatsens slutpunkt.

Inaktivera åtkomst till specifika tabellåtgärder

Förutom att visas i tabellen kan åtkomstegenskapen användas för att styra enskilda åtgärder. Det finns fyra åtgärder:

  • read är RESTful GET-åtgärden i tabellen.
  • insert är RESTful POST-åtgärden i tabellen.
  • update är RESTful PATCH-åtgärden i tabellen.
  • delete är RESTful DELETE-åtgärden i tabellen.

Du kanske till exempel vill ange en skrivskyddad oautentiserad tabell:

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;

Justera frågan som används med tabellåtgärder

Ett vanligt krav för tabellåtgärder är att tillhandahålla en begränsad vy av data. Du kan till exempel ange en tabell som är taggad med det autentiserade användar-ID:t så att du bara kan läsa eller uppdatera dina egna poster. Följande tabelldefinition tillhandahåller den här funktionen:

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;

Åtgärder som normalt kör en fråga har en frågeegenskap som du kan justera med hjälp av en where sats. Frågeegenskapen är ett QueryJS-objekt som används för att konvertera en OData-fråga till något som dataserverdelen kan bearbeta. För enkla likhetsfall (till exempel föregående) kan du använda en karta. Du kan också lägga till specifika SQL-satser:

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

Konfigurera en mjuk borttagning i en tabell

En mjuk borttagning tar inte bort poster. I stället markeras de som borttagna i databasen genom att ställa in den borttagna kolumnen till true. Mobile Apps SDK tar automatiskt bort mjukt borttagna poster från resultat om inte Mobile Client SDK använder IncludeDeleted(). Om du vill konfigurera en tabell för mjuk borttagning anger du softDelete egenskapen i tabelldefinitionsfilen:

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;

Du bör upprätta en mekanism för att ta bort poster: ett klientprogram, ett webbjobb, en Azure-funktion eller ett anpassat API.

Seed din databas med data

När du skapar ett nytt program kanske du vill skapa en tabell med data. Du kan göra detta i tabelldefinitionens JavaScript-fil på följande sätt:

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;

Seeding av data sker bara när du har använt Mobile Apps SDK för att skapa tabellen. Om tabellen redan finns i databasen matas inga data in i tabellen. Om det dynamiska schemat är aktiverat härleds schemat från de data som har hämtats.

Vi rekommenderar att du uttryckligen tables.initialize() anropar metoden för att skapa tabellen när tjänsten börjar köras.

Aktivera Swagger-stöd

Mobile Apps levereras med inbyggt Swagger-stöd . Om du vill aktivera Swagger-stöd installerar du först swagger-ui som ett beroende:

npm install --save swagger-ui

Du kan sedan aktivera Swagger-stöd i Mobile Apps-konstruktorn:

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

Du vill förmodligen bara aktivera Swagger-stöd i utvecklingsversioner. Du kan göra detta med hjälp av appinställningen NODE_ENV :

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

Slutpunkten swagger finns på http:// yoursite.azurewebsites.net/swagger. Du kan komma åt Swagger-användargränssnittet via /swagger/ui slutpunkten. Om du väljer att kräva autentisering i hela programmet genererar Swagger ett fel. För bästa resultat väljer du att tillåta oautentiserade begäranden i inställningarna för Azure App Service-autentisering/auktorisering och sedan styra autentiseringen table.access med hjälp av egenskapen .

Du kan också lägga till Swagger-alternativet i din azureMobile.js-fil om du bara vill ha Swagger-stöd för att utveckla lokalt.

Push-meddelanden

Mobile Apps integreras med Azure Notification Hubs så att du kan skicka riktade push-meddelanden till miljontals enheter på alla större plattformar. Med Notification Hubs kan du skicka push-meddelanden till iOS, Android och Windows enheter. Mer information om allt du kan göra med Notification Hubs finns i Översikt över Notification Hubs.

Skicka push-meddelanden

Följande kod visar hur du använder push objektet för att skicka ett push-meddelande till registrerade iOS enheter:

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

Genom att skapa en push-registrering för mallar från klienten kan du i stället skicka ett mall-push-meddelande till enheter på alla plattformar som stöds. Följande kod visar hur du skickar ett mallmeddelande:

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

Skicka push-meddelanden till en autentiserad användare med hjälp av taggar

När en autentiserad användare registrerar sig för push-meddelanden läggs en användar-ID-tagg automatiskt till i registreringen. Med den här taggen kan du skicka push-meddelanden till alla enheter som registrerats av en viss användare. Följande kod hämtar SID för den användare som gör begäran och skickar ett push-meddelande för mallar till varje enhetsregistrering för den användaren:

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

När du registrerar dig för push-meddelanden från en autentiserad klient kontrollerar du att autentiseringen är klar innan du försöker registrera dig.

Anpassade API:er

Definiera ett anpassat API

Utöver API:et för dataåtkomst via /tables slutpunkten kan Mobile Apps tillhandahålla anpassad API-täckning. Anpassade API:er definieras på ett liknande sätt som tabelldefinitionerna och har åtkomst till samma funktioner, inklusive autentisering.

Om du vill använda App Service-autentisering med ett anpassat API måste du konfigurera App Service-autentisering i Azure Portal först. Mer information finns i konfigurationsguiden för den identitetsprovider som du tänker använda:

Anpassade API:er definieras på ungefär samma sätt som tabell-API:et:

  1. Skapa en api katalog.
  2. Skapa en JavaScript-fil för API-definition i api katalogen .
  3. Använd importmetoden för att importera api katalogen.

Här är api-prototypdefinitionen baserat på exemplet med grundläggande appar som vi använde tidigare:

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

Nu ska vi ta ett exempel-API som returnerar serverdatumet med hjälp Date.now() av metoden . Här är filen api/date.js:

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

module.exports = api;

Varje parameter är ett av standard-RESTful-verben: GET, POST, PATCH eller DELETE. Metoden är en expressJS-mellanprogramsfunktion som skickar de utdata som krävs.

Kräv autentisering för åtkomst till ett anpassat API

Mobile Apps SDK implementerar autentisering på samma sätt för både tables slutpunkten och anpassade API:er. Om du vill lägga till autentisering i API:et som utvecklades i föregående avsnitt lägger du till en access egenskap:

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;

Du kan också ange autentisering för specifika åtgärder:

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;

Samma token som används för tables slutpunkten måste användas för anpassade API:er som kräver autentisering.

Hantera stora filuppladdningar

Mobile Apps SDK använder mellanprogrammet body-parser för att acceptera och avkoda brödtextinnehåll i din överföring. Du kan förkonfigurera body-parser för att acceptera större filuppladdningar:

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

Filen är base-64 kodad före överföring. Den här kodningen ökar storleken på den faktiska uppladdningen (och den storlek som du måste ta hänsyn till).

Köra anpassade SQL-instruktioner

Mobile Apps SDK ger åtkomst till hela kontexten via begärandeobjektet. Du kan enkelt köra parametriserade SQL-instruktioner till den definierade dataprovidern:

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;

Felsökning

Felsöka Mobile Apps

Azure App Service innehåller flera felsöknings- och felsökningstekniker för Node.js program. Information om hur du kommer igång med att felsöka serverdelen för Node.js Mobile Apps finns i följande artiklar:

Node.js program har åtkomst till en mängd olika verktyg för diagnostikloggar. Internt använder Mobile Apps Node.js SDK Winston för diagnostisk loggning. Loggning aktiveras automatiskt när du aktiverar felsökningsläge eller anger appinställningen MS_DebugMode till true i Azure Portal. Genererade loggar visas i diagnostikloggarna i Azure Portal.