A Node.js SDK használata az Azure Mobile Appshez

Ez a cikk részletes információkat és példákat tartalmaz, amelyek bemutatják, hogyan használható az Azure Mobile Apps NodeJS-háttérrendszere.

Introduction

Az Azure Mobile Apps lehetővé teszi, hogy mobiloptimalizált adathozzáférési webes API-t adjon hozzá egy webalkalmazáshoz. Az Azure Mobile Apps SDK az ASP.NET-keretrendszer és a Node.js webalkalmazásokhoz érhető el. Az SDK a következő műveleteket biztosítja:

• Táblaműveletek (olvasás, beszúrás, frissítés, törlés) az adathozzáféréshez
• Egyéni API-műveletek

Mindkét művelet biztosítja az összes olyan identitásszolgáltató hitelesítését, amelyet Azure-alkalmazás Szolgáltatás engedélyez. Ezek a szolgáltatók közé tartoznak a közösségi identitásszolgáltatók, például a Facebook, a Twitter, a Google és a Microsoft, valamint a Vállalati identitás Microsoft Entra-azonosítója.

Támogatott platformok

Az Azure Mobile Apps Node.js SDK támogatja a Node 6.x és újabb csomópontot, és a 12.x csomópontig tesztelték. Előfordulhat, hogy a Node más verziói is működnek, de nem támogatottak.

Az Azure Mobile Apps Node.js SDK két adatbázis-illesztőprogramot támogat:

• A node-mssql-illesztő támogatja az Azure SQL Database-t és a helyi SQL Server-példányokat.
• Az sqlite3-illesztő csak egyetlen példányon támogatja az SQLite-adatbázisokat.

Egyszerű csomópont háttérrendszerének létrehozása a parancssor használatával

Minden Azure Mobile Apps Node.js háttérrendszer Express-alkalmazásként indul. Az Express a Node.js legnépszerűbb webszolgáltatás-keretrendszere. Alapszintű Express-alkalmazást az alábbiak szerint hozhat létre:

1. Hozzon létre egy könyvtárat a projekthez egy parancsban vagy PowerShell-ablakban:

   $ mkdir basicapp
   

2. Futtassa npm init a csomagstruktúra inicializálásához:

   $ cd basicapp
   $ npm init
   

   A npm init parancs kérdéseket tesz fel a projekt inicializálásához. Lásd a példakimenetet:

   

3. Telepítse a express kódtárakat az azure-mobile-apps npm-adattárból:

   npm install --save express azure-mobile-apps
   

4. Hozzon létre egy app.js fájlt az alapszintű mobilkiszolgáló implementálásához:

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

Ez az alkalmazás egy mobilra optimalizált webes API-t hoz létre egyetlen végponttal (/tables/TodoItem), amely egy dinamikus séma használatával biztosít hitelesítés nélküli hozzáférést egy mögöttes SQL-adattárhoz. Az ügyfélkódtár rövid útmutatóinak követésére alkalmas:

• Apache Cordova
• Windows (UWP)
• Windows (WPF)
• Xamarin.Android
• Xamarin.Forms
• Xamarin.iOS

Az alapszintű alkalmazás kódját a GitHub mintaterületén találja.

Kezdőlap engedélyezése az alkalmazáshoz

Számos alkalmazás a webes és mobilalkalmazások kombinációja. Az Express keretrendszer használatával kombinálhatja a két aspektust. Előfordulhat azonban, hogy csak egy mobilfelületet szeretne implementálni. Hasznos, ha egy kezdőlapot biztosít, hogy az app service működőképes legyen. Megadhatja saját kezdőlapját, vagy engedélyezheti az ideiglenes kezdőlapot. Az ideiglenes kezdőlap engedélyezéséhez használja az alábbi kódot az Azure Mobile Apps példányosításához:

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

Ha csak helyi fejlesztéskor szeretné elérhetővé tenni ezt a beállítást, ezt a beállítást hozzáadhatja a azureMobile.js konfigurációs fájlhoz:

module.exports = {
    homePage: true,
};

Szükség szerint további beállításokat is hozzáadhat az azureMobile.js fájlhoz.

Táblaműveletek

Az azure-mobile-apps Node.js Server SDK mechanizmusokat biztosít az Azure SQL Database-ben tárolt adattáblák webes API-ként való közzétételéhez. Öt műveletet biztosít:

Művelet	Leírás
GET /tables/tablename	A tábla összes rekordjának lekérése.
GET /tables/tablename/:id	Egy adott rekord lekérése a táblában.
POST /tables/tablename	Hozzon létre egy rekordot a táblában.
PATCH /tables/tablename/:id	Frissítsen egy rekordot a táblában.
DELETE /tables/tablename/:id	Töröljön egy rekordot a táblából.

Ez a webes API támogatja az OData 3-at, és kibővíti a táblázatsémát az offline adatszinkronizálás támogatására.

Táblák definiálása dinamikus sémával

Mielőtt használhat egy táblát, meg kell határoznia. A táblákat statikus sémával (ahol a séma oszlopait definiálja) vagy dinamikusan (ahol az SDK a bejövő kérések alapján vezérli a sémát) definiálhatja. Emellett a Web API bizonyos aspektusait is szabályozhatja, ha JavaScript-kódot ad hozzá a definícióhoz.

Ajánlott eljárásként minden táblát meg kell határoznia egy JavaScript-fájlban a tables könyvtárban, majd a tables.import() metódus használatával importálnia kell a táblákat. Az alapalkalmazás-minta kibővítése esetén módosítsa az app.js fájlt:

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

Adja meg a táblát a ./tables/TodoItem.js fájlban:

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

var table = azureMobileApps.table();

// Additional configuration for the table goes here.

module.exports = table;

A táblák alapértelmezés szerint dinamikus sémát használnak.

Táblák definiálása statikus sémával

Explicit módon definiálhatja a webes API-val közzéteendő oszlopokat. Az azure-mobile-apps Node.js SDK automatikusan hozzáadja az offline adatszinkronizáláshoz szükséges további oszlopokat a megadott listához. A gyorsútmutató ügyfélalkalmazásokhoz például két oszlopból (sztringből) és complete (logikai) oszlopból text áll egy tábla. A tábla a következő módon definiálható a tábladefiníció JavaScript-fájljában (a tables könyvtárban):

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;

Ha statikusan definiál táblákat, akkor az tables.initialize() adatbázisséma indításkor történő létrehozásához is meg kell hívnia a metódust. A tables.initialize() metódus ígéretet ad vissza, így a webszolgáltatás nem szolgál ki kéréseket az adatbázis inicializálása előtt.

Az SQL Server Express használata fejlesztési adattárként a helyi gépen

Az Azure Mobile Apps Node.js SDK három lehetőséget kínál az adatok dobozon kívüli kiszolgálására:

• A memóriaillesztővel biztosítson nem állandó példatárat.
• Az mssql-illesztővel biztosítson egy SQL Server Express-adattárat a fejlesztéshez.
• Az mssql-illesztővel azure SQL Database-adattárat biztosíthat éles környezetben.

Az Azure Mobile Apps Node.js SDK az mssql Node.js csomag használatával hoz létre és használ kapcsolatot az SQL Server Express és az SQL Database szolgáltatással. Ehhez a csomaghoz engedélyeznie kell a TCP-kapcsolatokat az SQL Server Express-példányon.

Tipp.

A memóriaillesztő nem biztosít teljes készletet a teszteléshez. Ha helyileg szeretné tesztelni a háttérrendszert, javasoljuk egy SQL Server Express-adattár és az mssql-illesztőprogram használatát.

1. Töltse le és telepítse a Microsoft SQL Server 2019 Developer alkalmazást.

2. Futtassa a Configuration Managert:

   • Bontsa ki az SQL Server hálózati konfigurációs csomópontját a famenüben.
   • Válassza ki a példánynév protokolljait.
   • Kattintson a jobb gombbal a TCP/IP-címre , és válassza az Engedélyezés lehetőséget. Válassza az OK gombot az előugró párbeszédpanelen.
   • Válassza az SQL Server Services lehetőséget a famenüben.
   • Kattintson a jobb gombbal az SQL Serverre (példánynév), és válassza az Újraindítás lehetőséget.
   • Zárja be a Configuration Managert.

Emellett létre kell hoznia egy felhasználónevet és jelszót is, amellyel az Azure Mobile Apps csatlakozhat az adatbázishoz. Győződjön meg arról, hogy a létrehozott felhasználó rendelkezik a dbcreator kiszolgálói szerepkörrel. A felhasználók konfigurálásával kapcsolatos további információkért tekintse meg az SQL Server dokumentációját

Ügyeljen arra, hogy rögzítse a kiválasztott felhasználónevet és jelszót. Előfordulhat, hogy az adatbázis követelményeinek megfelelően további kiszolgálói szerepköröket vagy engedélyeket kell hozzárendelnie.

A Node.js alkalmazás beolvassa az SQLCONNSTR_MS_TableConnectionString adatbázis kapcsolati sztring környezeti változóit. Ezt a változót beállíthatja a környezetben. A PowerShell használatával például beállíthatja ezt a környezeti változót:

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

Az adatbázis elérése TCP/IP-kapcsolaton keresztül. Adjon meg egy felhasználónevet és jelszót a kapcsolathoz.

A projekt konfigurálása helyi fejlesztéshez

Az Azure Mobile Apps beolvassa a helyi fájlrendszerből hívott JavaScript-fájlt azureMobile.js . Ne használja ezt a fájlt az Azure Mobile Apps SDK éles környezetben való konfigurálásához. Ehelyett használja az Alkalmazásbeállításokat az Azure Portalon.

Az azureMobile.js fájlnak exportálnia kell egy konfigurációs objektumot. A leggyakoribb beállítások a következők:

• Adatbázis-beállítások
• Diagnosztikai naplózási beállítások
• Alternatív CORS-beállítások

Ez a példa azureMobile.js fájl implementálja az előző adatbázis-beállításokat:

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

Javasoljuk, hogy adja hozzá azureMobile.js a .gitignore fájlhoz (vagy más forráskód-vezérlő figyelmen kívül hagyja a fájlt), hogy megakadályozza a jelszavak felhőben való tárolását.

Mobilalkalmazás alkalmazásbeállításainak konfigurálása

A fájl legtöbb beállításának azureMobile.js megfelelő alkalmazásbeállítása van az Azure Portalon. Az alkalmazás alkalmazásbeállításokban való konfigurálásához használja az alábbi listát:

App setting	azureMobile.js-beállítás	Leírás	Érvényes értékek
MS_MobileAppName	név	Az alkalmazás neve	sztring
MS_MobileLoggingLevel	logging.level	Naplózandó üzenetek minimális naplószintje	hiba, figyelmeztetés, információ, részletes, hibakeresés, butaság
MS_DebugMode	Debug	Hibakeresési mód engedélyezése vagy letiltása	igaz, hamis
MS_TableSchema	data.schema	SQL-táblák alapértelmezett sémaneve	sztring (alapértelmezett: dbo)
MS_DynamicSchema	data.dynamicSchema	Hibakeresési mód engedélyezése vagy letiltása	igaz, hamis
MS_DisableVersionHeader	verzió (nincs definiálva)	Letiltja az X-ZUMO-Server-Version fejlécet	igaz, hamis
MS_SkipVersionCheck	skipversioncheck	Letiltja az ügyfél API verzióellenőrzését	igaz, hamis

A legtöbb alkalmazásbeállítás módosításához újra kell indítani a szolgáltatást.

Az Azure SQL használata éles adattárként

Az Azure SQL Database adattárként való használata minden Azure-alkalmazás szolgáltatásalkalmazás-típusban azonos. Ha még nem tette meg, az alábbi lépéseket követve hozzon létre egy Azure-alkalmazás szolgáltatás háttérrendszerét. Hozzon létre egy Azure SQL-példányt, majd állítsa be az alkalmazásbeállítást SQLCONNSTR_MS_TableConnectionString a használni kívánt Azure SQL-példány kapcsolati sztring. Győződjön meg arról, hogy a háttérrendszert futtató Azure-alkalmazás szolgáltatás képes kommunikálni az Azure SQL-példánysal.

Hitelesítés megkövetelése táblákhoz való hozzáféréshez

Ha az App Service-hitelesítést a végponttal tables szeretné használni, először az App Service-hitelesítést kell konfigurálnia az Azure Portalon . További információkért tekintse meg a használni kívánt identitásszolgáltató konfigurációs útmutatóját:

• Configure Microsoft Entra authentication
• Facebook-hitelesítés konfigurálása
• Google-hitelesítés konfigurálása
• Microsoft-hitelesítés konfigurálása
• Twitter-hitelesítés konfigurálása

Minden tábla rendelkezik egy hozzáférési tulajdonságot, amellyel szabályozhatja a táblához való hozzáférést. Az alábbi minta egy statikusan definiált táblát mutat be, amelyen hitelesítés szükséges.

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;

A hozzáférési tulajdonság három érték egyikét veheti igénybe:

• a névtelen azt jelzi, hogy az ügyfélalkalmazás hitelesítés nélkül is beolvashatja az adatokat.
• hitelesített azt jelzi, hogy az ügyfélalkalmazásnak érvényes hitelesítési jogkivonatot kell küldenie a kéréssel együtt.
• letiltva azt jelzi, hogy ez a tábla jelenleg le van tiltva.

Ha a hozzáférési tulajdonság nincs meghatározva, a hitelesítés nélküli hozzáférés engedélyezett.

Hitelesítési jogcímek használata a táblákkal

A hitelesítés beállításakor különböző jogcímeket állíthat be. Ezek a jogcímek általában nem érhetők el az context.user objektumon keresztül. A metódussal azonban lekérheti őket context.user.getIdentity() . A getIdentity() metódus egy objektumnak feloldható ígéretet ad vissza. Az objektumot a hitelesítési módszer (facebook, , google, twitter, microsoftaccountvagy aad) határozza meg.

Megjegyzés:

Ha Microsoft-hitelesítést használ a Microsoft Entra-azonosítón keresztül, a hitelesítési módszer nem aadmicrosoftaccount.

Ha például beállítja a Microsoft Entra-hitelesítést, és kéri az e-mail-címek jogcímét, az alábbi táblázatvezérlővel hozzáadhatja az e-mail-címet a rekordhoz:

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

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

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

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

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

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

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

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

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

module.exports = table;

A rendelkezésre álló jogcímek megtekintéséhez használjon webböngészőt a /.auth/me webhely végpontjának megtekintéséhez.

Adott táblaműveletek elérésének letiltása

Amellett, hogy megjelenik a táblában, a hozzáférési tulajdonság az egyes műveletek vezérlésére is használható. Négy művelet létezik:

• read A tábla RESTful GET művelete.
• insert A tábla RESTful POST művelete.
• update A tábla RESTful PATCH művelete.
• delete A tábla RESTful DELETE művelete.

Előfordulhat például, hogy egy írásvédett, nem hitelesített táblát szeretne megadni:

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;

A táblaműveletekkel használt lekérdezés módosítása

A táblaműveletek gyakori követelménye az adatok korlátozott megtekintésének biztosítása. Megadhat például egy olyan táblát, amely a hitelesített felhasználói azonosítóval van megjelölve, így csak a saját rekordjait olvashatja vagy frissítheti. A következő tábladefiníció biztosítja ezt a funkciót:

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

var table = azureMobileApps.table();

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

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

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

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

module.exports = table;

A lekérdezést általában futtató műveletek olyan lekérdezési tulajdonságtal rendelkeznek, amelyet egy where záradék használatával lehet módosítani. A lekérdezési tulajdonság egy Olyan QueryJS-objektum , amellyel OData-lekérdezést alakíthat át olyasmivé, amelyet az adatok háttérrendszere feldolgozhat. Egyszerű egyenlőségi esetekben (mint az előzőben) használhat térképet. Adott SQL-záradékokat is hozzáadhat:

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

Helyreállítható törlés konfigurálása egy táblán

A helyreállítható törlés valójában nem törli a rekordokat. Ehelyett a törölt oszlop igaz értékre állításával az adatbázison belül töröltként jelöli meg őket. Az Azure Mobile Apps SDK automatikusan eltávolítja a helyreállíthatóan törölt rekordokat az eredményekből, hacsak a Mobile Client SDK nem használja includeDeleted(). A tábla helyreállítható törléshez való konfigurálásához állítsa be a softDelete tulajdonságot a tábladefiníciós fájlban:

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;

Hozzon létre egy olyan mechanizmust, amely véglegesen törli a rekordokat, például ügyfélalkalmazást, webjobot, Azure-függvényt vagy egyéni API-t.

Adatbázis üzembe helyezése adatokkal

Új alkalmazás létrehozásakor érdemes lehet adatokat tartalmazó táblát létrehozni. Az adatokat a tábladefiníció JavaScript-fájlban az alábbiak szerint helyezheti el:

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;

Az adatok bevetése csak akkor történik, ha az Azure Mobile Apps SDK-val hozta létre a táblát. Ha a tábla már létezik az adatbázisban, a program nem szúr be adatokat a táblába. Ha a dinamikus séma be van kapcsolva, a rendszer a beszúrt adatokból következtet.

Javasoljuk, hogy explicit módon hívja meg a metódust a tables.initialize() tábla létrehozásához, amikor a szolgáltatás elindul.

A Swagger támogatásának engedélyezése

Az Azure Mobile Apps beépített Swagger-támogatással rendelkezik. A Swagger támogatásának engedélyezéséhez először telepítse a swagger-ui-t függőségként:

npm install --save swagger-ui

Ezután engedélyezheti a Swagger-támogatást az Azure Mobile Apps konstruktorában:

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

Valószínűleg csak a fejlesztői kiadásokban szeretné engedélyezni a Swagger támogatását. Az alkalmazásbeállítás használatával engedélyezheti a Swagger támogatását a NODE_ENV fejlesztés során:

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

A swagger végpont a http:// yoursite.azurewebsites.net/swagger helyen található. A Swagger felhasználói felületét a végponton keresztül érheti /swagger/ui el. Ha úgy dönt, hogy a teljes alkalmazáshoz hitelesítést kíván, a Swagger hibát okoz. A legjobb eredmény érdekében engedélyezze a hitelesítés nélküli kéréseket a Azure-alkalmazás szolgáltatáshitelesítési/engedélyezési beállításai között, majd a tulajdonság használatával szabályozza a table.access hitelesítést.

A Swagger lehetőséget akkor is hozzáadhatja a azureMobile.js fájlhoz, ha csak a helyi fejlesztéshez szeretne Swagger-támogatást.

Egyéni API-k

A végponton keresztüli Data Access API mellett az /tables Azure Mobile Apps egyéni API-lefedettséget is biztosít. Az egyéni API-k a tábladefiníciókhoz hasonlóan vannak definiálva, és minden eszközhöz hozzáférhetnek, beleértve a hitelesítést is.

Egyéni API definiálása

Az egyéni API-k meghatározása a Tables API-val azonos módon történik:

1. Hozzon létre egy könyvtárat api .
2. Hozzon létre egy API-definíciós JavaScript-fájlt a api könyvtárban.
3. A könyvtár importálásához használja az importálási api módszert.

Íme a prototípus API-definíciója a korábban használt alapalkalmazás-minta alapján:

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

Vegyünk egy példa API-t, amely a metódus használatával adja vissza a Date.now() kiszolgáló dátumát. Itt található a api/date.js fájl:

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

module.exports = api;

Minden paraméter a szokásos RESTful-igék egyike: GET, POST, PATCH vagy DELETE. A metódus egy szabványos ExpressJS köztes szoftverfüggvény , amely elküldi a szükséges kimenetet.

Hitelesítés megkövetelése egyéni API-hoz való hozzáféréshez

Az Azure Mobile Apps SDK ugyanúgy implementálja a hitelesítést a végpont és az tables egyéni API-k esetében is. Ha hitelesítést szeretne hozzáadni az előző szakaszban kifejlesztett API-hoz, adjon hozzá egy tulajdonságot access :

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;

Meghatározott műveletek hitelesítését is megadhatja:

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;

A végponthoz tables használt jogkivonatot a hitelesítést igénylő egyéni API-khoz kell használni.

Nagyméretű fájlfeltöltések kezelése

Az Azure Mobile Apps SDK a törzselemző köztes szoftver használatával fogadja el és dekódolja a beküldött szövegtörzs tartalmát. A törzselemzőt előre konfigurálhatja a nagyobb fájlfeltöltések elfogadásához:

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

A fájl az átvitel előtt base-64 kódolású. Ez a kódolás növeli a tényleges feltöltés méretét (és azt a méretet, amelyet figyelembe kell vennie).

Egyéni SQL-utasítások végrehajtása

Az Azure Mobile Apps SDK a kérelemobjektumon keresztül teszi lehetővé a teljes környezet elérését. A paraméteres SQL-utasításokat egyszerűen végrehajthatja a definiált adatszolgáltatón:

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

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

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

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

Debugging

Az Azure Mobile Apps hibakeresése, diagnosztizálása és hibaelhárítása

Azure-alkalmazás szolgáltatás számos hibakeresési és hibaelhárítási technikát biztosít a Node.js-alkalmazásokhoz. A Node.js Azure Mobile Apps háttérrendszer hibaelhárításának megkezdéséhez tekintse meg az alábbi cikkeket:

• Monitorozási Azure-alkalmazás szolgáltatás
• Diagnosztikai naplózás engedélyezése Azure-alkalmazás szolgáltatásban
• Csomópontalkalmazások hibaelhárítása Azure-alkalmazás szolgáltatásban

A Node.js-alkalmazások számos diagnosztikai naplóeszközhöz férhetnek hozzá. Az Azure Mobile Apps Node.js SDK belsőleg a [Winston] függvényt használja a diagnosztikai naplózáshoz. A naplózás automatikusan engedélyezve van, ha engedélyezi a hibakeresési módot, vagy igazra állítja az MS_DebugMode alkalmazásbeállítást az Azure Portalon. A létrehozott naplók megjelennek a diagnosztikai naplókban az Azure Portalon.