Hur man använder Mobile Apps Node.js SDK

Den här artikeln ger detaljerad information och exempel på hur du kan arbeta med en Node.js back end i Mobile Apps-funktionen i Azure App Service.

Inledning

Mobile Apps ger möjlighet att lägga till ett webb-API för mobiloptimerad dataåtkomst 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 omfattar sociala identitetsprovidrar som Facebook, Twitter, Google och Microsoft samt Azure Active Directory för företagsidentitet.

Du hittar exempel för varje användningsfall i katalogen exempel 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:

• Node-mssql-drivrutinen 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 bakdel med hjälp av kommandoraden

Varje Mobile Apps-Node.js serverdel startar som ett ExpressJS-program. ExpressJS är det mest populära webbtjänstramverket 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:

   

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 snabbstarterna för klientbiblioteket:

• Snabbstartsguide för Android-klient
• Apache Cordova-klientens snabbstart
• iOS-Klient Snabbstart
• snabbstart för Windows Store-klienten
• snabbstart för Xamarin.iOS-klienten
• snabbstart för Xamarin.Android-klienten
• snabbstart för Xamarin.Forms-klienten

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

Skapa en Node.js backend i Visual Studio 2015

Visual Studio 2015 kräver ett tillägg för att utveckla Node.js program i IDE. Starta genom att installera Node.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 New Project (från File>New>Project).

2. Expandera mallar>JavaScript>Node.js.

3. Välj Grundläggande Azure Node.js Express 4-applikation.

4. Fyll i projektnamnet. Välj OK.

   

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.

   

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 biblioteket require-instruktioner:

   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 backend med hjälp av Azure-portalen

Du kan skapa en Mobile Apps-serverdel direkt i Azure-portalen. 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 projekt för koncepttest.

1. Logga in på Azure-portalen.

2. Välj +NEW>Web + Mobile>Mobile App, och ange sedan ett namn för din mobilappar-backend.

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

4. För App Service-planväljs standardplanen (i Standard-nivån) som standard. Du kan också välja en annan plan, eller skapa en ny.

   App Service-planens inställningar avgör plats, 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 översikt över Azure App Service-planer.

5. Välj Skapa. Det här steget skapar Mobile Apps-backend.

6. I fönstret Inställningar för den nya mobilapps-bakdelen väljer du Snabbstart> din klientapplikationsplattform >Anslut en databas.

   

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 i stä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.

   

8. I fönstret Ny server anger du ett unikt servernamn i rutan Servernamn, anger ett inloggnings- och lösenord, väljer Tillåt Att Azure-tjänster får åtkomst till serveroch väljer OK. Det här steget skapar den nya databasen.

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

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

I fönsterpanelen Kom igång går du till Skapa ett tabell-APIoch väljer Node.js som ditt bakgrundsspråk. Markera rutan för jag bekräftar att detta kommer att skriva över allt webbplatsinnehålloch 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-serverdel 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örbered lagringsplatsen för att möjliggöra Git-lagringsplatsen för din backendwebbplats. Anteckna användarnamnet och lösenordet för distributionen.

3. I fönstret för mobile apps-serverdelen antecknar du inställningen Git-klonings-URL.

4. Kör kommandot git clone med hjälp av Git-klonings-URL:en. 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 projektfilerna har laddats ned. Leta upp filen todoitem.json i katalogen /tables. Den här filen definierar behörigheter i tabellen. Leta också upp 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 kommandot git add ..

Webbplatsen publiceras på nytt varje gång en ny grupp kommentarer skickas till webbplatsen.

Publicera din Node.js backend på Azure

Microsoft Azure tillhandahåller många mekanismer för att publicera dina Mobile Apps Node.js backend 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-applikationer som du bör granska innan du publicerar bakändan.

• Så här anger du nodversionen
• Så här du använda Node-moduler

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å fasetter. 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 din azureMobile.js-fil.

Tabelloperationer

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

Det här webb-API:et stöder OData- och utökar tabellschemat för att stödja offline-datasynkronisering.

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.

Som bästa praxis bör du definiera varje tabell i en JavaScript-fil i katalogen tables och sedan använda metoden tables.import() 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 inställningen MS_DynamicSchema app till false i Azure-portalen.

Du hittar ett fullständigt exempel i todo-exemplet på GitHub.

Definiera tabeller med hjälp av ett statiskt schema

Du kan uttryckligen definiera vilka kolumner 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 datasynkronisering offline i listan som du anger. Till exempel kräver snabbstartsklientprogrammen en tabell med två kolumner: text (en sträng) och complete (ett booleskt värde).
Tabellen kan definieras i tabelldefinitionens JavaScript-fil (finns i katalogen tables) 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 också anropa metoden tables.initialize() 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 drivrutinen minne för att tillhandahålla ett icke-beständigt exempelarkiv.
• Använd drivrutinen mssql för att tillhandahålla ett SQL Server Express-datalager för utveckling.
• Använd drivrutinen mssql 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å SQL Server Express-instansen.

1. Ladda ned och installera Microsoft SQL Server 2014 Express. Se till att du installerar SQL Server 2014 Express med Tools-versionen. Om du inte uttryckligen behöver 64-bitarsstöd förbrukar 32-bitarsversionen mindre minne när den körs.

2. Kör SQL Server 2014 Configuration Manager:

   a. Expandera noden SQL Server Network Configuration i 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 noden IPAll. I fältet TCP Port anger du 1433.

   

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

   h. Välj SQL Server Services- 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å instansen 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.

      

   5. Expandera Säkerhet>Inloggningar 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 kraven på Windows-komplexitet.

   8. Välj OK.

      

   9. Högerklicka på din nya inloggning och välj Egenskaper.

   10. Välj sidan Serverroller.

   11. Välj kryssrutan för dbcreator server-roll.

   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.

Node.js-programmet läser miljövariabeln SQLCONNSTR_MS_TableConnectionString 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-portalen.

Filen azureMobile.js ska 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 till din .gitignore- fil (eller 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 App-inställningar i Azure-portalen.

Konfigurera appinställningar för din mobilapp

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

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

1. Logga in på Azure-portalen.
2. Välj Alla resurser eller App Servicesoch 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 Key och värdet i rutan Value.
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 de här stegen för att skapa en Mobile Apps-serverdel:

1. Logga in på Azure-portalen.

2. Överst till vänster i fönstret väljer du knappen +NEW>Web + Mobile>Mobile Appoch anger sedan ett namn för Mobile Apps-serverdelen.

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

4. Den förvalda planen för App Service är vald. 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 fönstret Inställningar för mobile apps-serverdelen.

Du kan välja att antingen ansluta en befintlig SQL-databas till mobile apps-serverdelen eller skapa en ny SQL-databas. I det här avsnittet skapar vi en SQL-databas.

1. I den nya mobile apps-serverdelen väljer du Inställningar>Mobilapp>Data>+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. Kontrollera att Tillåt att Azure-tjänster får åtkomst till server har valts. Välj OK.

   

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

5. I fönstret Lägg till dataanslutning väljer du Anslutningssträngoch 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 framgångsrikt. 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-portalen först. Mer information finns i konfigurationsguiden för den identitetsprovider som du tänker använda:

• Konfigurera Azure Active Directory-autentisering
• Konfigurera Facebook-autentisering
• Konfigurera Google-autentisering
• Konfigurera Microsoft-autentisering
• Konfigurera Twitter-autentisering

Varje tabell har en åtkomstegenskap som du kan använda för att styra åtkomsten till tabellen. I följande exempel visas en statiskt definierad tabell med nödvändig autentisering.

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 innehålla något av tre värden:

• anonyma 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änd autentiseringsanspråk med dina tabeller

Du kan konfigurera olika anspråk som begärs när autentiseringen har konfigurerats. Dessa anspråk är normalt inte tillgängliga via context.user-objektet. Du kan dock hämta dem med hjälp av metoden context.user.getIdentity(). Metoden getIdentity() returnerar ett löfte som resulterar i ett objekt. Objektet styrs av autentiseringsmetoden (facebook, google, twitter, microsoftaccounteller aad).

Om du till exempel konfigurerar Microsoft-kontoautentisering och begär e-postadressinformationen kan du lägga till e-postadressen i posten med följande tabellstyrenhet:

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 webbplatsens /.auth/me 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 åtgärden RESTful DELETE 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 sökfrågan som används med tabelloperationer

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 innehåller följande funktioner:

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 den borttagna kolumnen anges 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 egenskapen softDelete 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.

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

Sådd 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 anropar metoden tables.initialize() 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 inställningen NODE_ENV app:

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

Slutpunkten swagger finns på http://din webbplats.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 med hjälp av egenskapen table.access.

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. Genom att använda 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 översikten ö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 mallbaserad push-registrering från klienten kan du i stället skicka ett mallbaserat 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 användaren som gör begäran och skickar ett mall-pushmeddelande 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 kan komma åt samma faciliteter, inklusive autentisering.

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

• Konfigurera Azure Active Directory-autentisering
• Konfigurera Facebook-autentisering
• Konfigurera Google-autentisering
• Konfigurera Microsoft-autentisering
• Konfigurera Twitter-autentisering

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

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

Här är api-prototypdefinitionen baserat på exemplet med basic-app 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 av metoden Date.now(). 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 standardfunktion ExpressJS-mellanprogram 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 body-parser-mellanprogrammet för att acceptera och avkoda meddelandets brödtext i din inlämning. 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, diagnostisera och lösa problem med mobilappar

Azure App Service erbjuder flera tekniker för felsökning och felskorrigering av Node.js-program. Information om hur du kommer igång med att felsöka Node.js Mobile Apps-serverdelen finns i följande artiklar:

• Övervaka Azure App Service
• Aktivera diagnostikloggning i Azure App Service
• Felsöka Azure App Service i Visual Studio

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