Megosztás a következőn keresztül:

A Mobile Apps Node.js SDK használata

  • Cikk

Ez a cikk részletes információkat és példákat tartalmaz, amelyek bemutatják, hogyan használható a Node.js háttérrendszer a Azure App Service Mobile Apps szolgáltatásában.

Bevezetés

A Mobile Apps lehetővé teszi, hogy mobilra optimalizált adatelérési webes API-t adjon hozzá egy webalkalmazáshoz. A Mobile Apps SDK ASP.NET és 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 adatelé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 App Service engedélyez. Ezek közé 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 Azure Active Directory a vállalati identitáshoz.

Az egyes használati esetek mintáit a GitHub mintakönyvtárában találja.

Támogatott platformok

A Mobile Apps Node.js SDK a Node és újabb verziók aktuális LTS-kiadását támogatja. Jelenleg a legújabb LTS-verzió a Node 4.5.0-s verziója. A Node más verziói működhetnek, de nem támogatottak.

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

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

Alapszintű Node.js háttér létrehozása a parancssor használatával

Minden Mobile Apps-Node.js háttérrendszer ExpressJS-alkalmazásként indul. Az ExpressJS az Node.js legnépszerűbb webszolgáltatási keretrendszere. Az alábbi módon hozhat létre alapszintű Express-alkalmazást :

  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. Tekintse meg a példakimenetet:

    The npm init output

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

     npm install --save express azure-mobile-apps

  4. Hozzon létre egy app.js fájlt az alapszintű mobilkiszolgáló megvalósítá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 nem hitelesített hozzáférést biztosít egy mögöttes SQL-adattárhoz. Az ügyfélkódtár rövid útmutatóinak követésére alkalmas:

Az alapszintű alkalmazás kódját a GitHub basicapp-mintájában találja.

Node.js háttérrendszer létrehozása a Visual Studio 2015 használatával

Visual Studio 2015-ben egy bővítményre van szükség Node.js alkalmazások fejlesztéséhez az IDE-ben. Első lépésként telepítse a Node.js Tools 1.1 for Visual Studio eszközt. A telepítés befejezése után hozzon létre egy Express 4.x-alkalmazást:

  1. Nyissa meg az Új Project párbeszédpanelt (azÚj>fájlból>Project).

  2. > Sablonok kibontásaJavaScript>Node.js.

  3. Válassza az Alapszintű Azure Node.js Express 4-alkalmazást.

  4. Adja meg a projekt nevét. Válassza az OK lehetőséget.

    Visual Studio 2015 new project

  5. Kattintson a jobb gombbal az npm-csomópontra , és válassza az Új npm-csomagok telepítése lehetőséget.

  6. Előfordulhat, hogy az első Node.js alkalmazás létrehozása után frissítenie kell az npm-katalógust. Szükség esetén válassza a Frissítés lehetőséget .

  7. Írja be az azure-mobile-apps kifejezést a keresőmezőbe. Válassza ki az azure-mobile-apps 2.0.0 csomagot, majd válassza a Csomag telepítése lehetőséget.

    Install new npm packages

  8. Válassza a Bezárás gombot.

  9. Nyissa meg a app.js fájlt a Mobile Apps SDK támogatásának hozzáadásához. A kódtár-utasítások require alján található 6. sorban adja hozzá a következő kódot:

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

    A többi app.use utasítás után körülbelül a 27. sorban adja hozzá a következő kódot:

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

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

    Mentse a fájlt.

  10. Futtassa az alkalmazást helyileg (az API-t kiszolgálja), https://localhost:3000vagy tegye közzé az Azure-ban.

Node.js háttérrendszer létrehozása a Azure Portal használatával

A Mobile Apps háttérrendszerét közvetlenül a Azure Portal hozhatja létre. A mobilalkalmazás-létrehozási oktatóanyagot követve elvégezheti az alábbi lépéseket, vagy együtt hozhat létre egy ügyfelet és egy kiszolgálót. Az oktatóanyag ezen utasítások egyszerűsített változatát tartalmazza, és a legjobb megoldás megvalósíthatósági projektekhez.

  1. Jelentkezzen be az Azure Portalra.

  2. Válassza a +NEW>Web + Mobile>Mobile App lehetőséget, majd adjon nevet a Mobile Apps háttéralkalmazásának.

  3. Erőforráscsoport esetén válasszon ki egy meglévő erőforráscsoportot, vagy hozzon létre egy újat (ugyanazzal a névvel, mint az alkalmazás).

  4. App Service csomag esetén az alapértelmezett csomag (a Standard szinten) van kiválasztva. Másik csomagot is kiválaszthat, vagy létrehozhat egy újat.

    A App Service csomag beállításai határozzák meg az alkalmazáshoz társított helyet, funkciókat, költségeket és számítási erőforrásokat. A App Service csomagokról, valamint arról, hogyan hozhat létre új csomagot egy másik tarifacsomagban és a kívánt helyen, tekintse meg Azure App Service csomagok részletes áttekintését.

  5. Válassza a Létrehozás lehetőséget. Ez a lépés létrehozza a Mobile Apps háttérrendszerét.

  6. Az új Mobile Apps-háttéralkalmazás Gépház panelen válassza az adatbázis Csatlakozás ügyfélalkalmazás-platform >gyors üzembe helyezését>.

    Selections for connecting a database

  7. Az Adatkapcsolat hozzáadása panelen válassza az SQL Database>Új adatbázis létrehozása lehetőséget. Adja meg az adatbázis nevét, válasszon egy tarifacsomagot, majd válassza a Kiszolgáló lehetőséget. Ezt az új adatbázist többször is felhasználhatja. Ha már rendelkezik adatbázissal ugyanazon a helyen, választhatja a Meglévő adatbázis használata lehetőséget is. A sávszélességi költségek és a nagyobb késés miatt nem javasoljuk egy másik helyen található adatbázis használatát.

    Selecting a database

  8. Az Új kiszolgáló panelen adjon meg egy egyedi kiszolgálónevet a Kiszolgálónév mezőben, adjon meg egy bejelentkezést és jelszót, válassza az Azure-szolgáltatások hozzáférésének engedélyezése a kiszolgálóhoz lehetőséget, majd kattintson az OK gombra. Ez a lépés létrehozza az új adatbázist.

  9. Az Adatkapcsolat hozzáadása panelen válassza a Kapcsolati sztring lehetőséget, adja meg az adatbázis bejelentkezési és jelszóértékeit, majd kattintson az OK gombra.

    A folytatás előtt várjon néhány percet, amíg az adatbázis sikeresen üzembe lesz helyezve.

A Első lépések panelen, a Tábla API létrehozása területen válassza a Node.js háttérnyelvet. Jelölje be a jelölőnégyzetet, és nyugtázza, hogy ez felülírja az összes webhelytartalmat, majd válassza a TodoItem tábla létrehozása lehetőséget.

A Node.js háttérbeli gyorsindítási kódprojekt letöltése a Git használatával

Amikor Node.js Mobile Apps-háttéralkalmazást hoz létre a portál Gyors üzembe helyezés paneljén, létrejön egy Node.js projekt, és üzembe lesz helyezve a webhelyen. A portálon hozzáadhat táblákat és API-kat, és szerkesztheti a Node.js háttérrendszer kódfájljait. Különböző üzembehelyezési eszközökkel is letöltheti a háttérprojektet, hogy táblákat és API-kat adjon hozzá vagy módosítson, majd tegye közzé újra a projektet. További információt az Azure App Service üzembe helyezési útmutatójában talál.

Az alábbi eljárás egy Git-adattárat használ a rövid útmutató projektkódjának letöltéséhez:

  1. Ha még nem tette meg, telepítse a Gitet. A Git telepítéséhez szükséges lépések operációs rendszerek között változnak. Az operációs rendszerre vonatkozó disztribúciókkal és telepítési útmutatóval kapcsolatban lásd a Git telepítését ismertető témakört.

  2. Lásd : Az adattár előkészítése a Git-adattár háttérhelyhez való engedélyezéséhez. Jegyezze fel az üzembe helyezés felhasználónevét és jelszavát.

  3. A Mobile Apps háttérrendszerének paneljén jegyezze fel a Git-klón URL-címét .

  4. Hajtsa végre a git clone parancsot a Git-klón URL-címével. Ha szükséges, adja meg a jelszavát, ahogyan az alábbi példában látható:

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

  5. Keresse meg a helyi könyvtárat (/todolist az előző példában), és figyelje meg, hogy a projektfájlok le lettek töltve. Keresse meg a todoitem.json fájlt a /tables könyvtárban. Ez a fájl határozza meg a táblára vonatkozó engedélyeket. Keresse meg a todoitem.js fájlt is ugyanabban a könyvtárban. Ez határozza meg a táblához tartozó CRUD műveleti szkripteket.

  6. Miután módosította a projektfájlokat, futtassa a következő parancsokat a módosítások hozzáadásához, véglegesítéséhez és feltöltéséhez a webhelyre:

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

    Amikor új fájlokat ad hozzá a projekthez, először futtatnia kell a git add . parancsot.

A rendszer minden alkalommal újra közzétei a webhelyet, amikor új véglegesítéseket küld a webhelyre.

A Node.js háttérrendszer közzététele az Azure-ban

Microsoft Azure számos mechanizmust biztosít a Mobile Apps Node.js háttérrendszer azure-szolgáltatásban való közzétételéhez. Ezek a mechanizmusok közé tartoznak a Visual Studio integrált üzembehelyezési eszközök, a parancssori eszközök és a verziókövetésen alapuló folyamatos üzembe helyezési lehetőségek. További információt az Azure App Service üzembe helyezési útmutatójában talál.

Azure App Service konkrét tanácsokkal rendelkezik Node.js alkalmazásokhoz, amelyeket érdemes áttekintenie a háttérrendszer közzététele előtt:

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

Számos alkalmazás webes és mobilalkalmazások kombinációja. Az ExpressJS-keretrendszer használatával kombinálhatja a két aspektust. Néha azonban előfordulhat, hogy csak egy mobil felületet szeretne implementálni. Hasznos lehet egy kezdőlapot megadni, hogy az App Service megfelelően működjön. 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 a Mobile Apps példányosításához:

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

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

Táblaműveletek

Az azure-mobile-apps Node.js Server SDK olyan mechanizmusokat biztosít, amelyek a Azure SQL Database-ben tárolt adattáblákat teszik elérhetővé webes API-ként. Ö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-t , és kibővíti a táblasémát az offline adatszinkronizálás támogatásához.

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

Ahhoz, hogy használni tudja a táblázatot, 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 javaScript-kód a definícióhoz való hozzáadásával szabályozhatja a webes API adott aspektusait.

Ajánlott eljárásként minden táblát egy JavaScript-fájlban kell definiálnia a tables könyvtárban, majd a tables.import() metódussal importálnia kell a táblákat. Az alapszintű alkalmazásminta kibővítése esetén módosítania kell a 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);
});

Definiálja a táblát a ./tables/TodoItem.js:

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. Ha globálisan ki szeretné kapcsolni a dinamikus sémát, állítsa az MS_DynamicSchema alkalmazásbeállítást false (hamis) értékre a Azure Portal.

Az GitHub teendőmintájában egy teljes példát talál.

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

Explicit módon definiálhatja a webes API-val elérhetővé tenni kívánt 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 gyorsindítási ügyfélalkalmazásokhoz például két oszlopból (sztringből) és complete (logikai) oszlopból text kell táblázatot létrehozni.
A tábla a következő módon definiálható a (könyvtárban található) tábladefiníciós JavaScript-fájlban tables :

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.

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

A Mobile Apps Node.js SDK három lehetőséget kínál az adatok használatra való kiszolgálására:

  • A memóriaillesztővel nem állandó példatárolót biztosíthat.
  • Az mssql-illesztővel SQL Server Express adattárat biztosíthat a fejlesztéshez.
  • Az mssql-illesztőprogram használatával biztosítson Azure SQL Database adattárat éles környezetben.

A Mobile Apps Node.js SDK az mssql Node.js csomagot használja a SQL Server Express és a SQL Database közötti kapcsolat létrehozásához és használatához. Ehhez a csomaghoz engedélyeznie kell a TCP-kapcsolatokat a SQL Server Express-példányon.

Tipp

A memóriaillesztő nem biztosít a teszteléshez szükséges összes lehetőséget. Ha helyileg szeretné tesztelni a háttérrendszert, javasoljuk, hogy használjon egy SQL Server Express-adattárat és az mssql-illesztőt.

  1. Töltse le és telepítse az Microsoft SQL Server 2014 Expresst. Győződjön meg arról, hogy a SQL Server 2014 Express with Tools kiadást telepíti. Ha nem kifejezetten 64 bites támogatást igényel, a 32 bites verzió kevesebb memóriát használ futtatáskor.

  2. Futtassa SQL Server 2014-Configuration Manager:

    a. Bontsa ki a SQL Server Hálózati konfiguráció csomópontot a famenüben.

    b. Válassza ki az SQLEXPRESS protokolljait.

    c. Kattintson a jobb gombbal a TCP/IP protokollra , és válassza az Engedélyezés parancsot. Válassza az OK gombot az előugró párbeszédpanelen.

    d. Kattintson a jobb gombbal a TCP/IP protokollra, és válassza a Tulajdonságok parancsot.

    e. Válassza az IP-címek lapot.

    f. Keresse meg az IPAll csomópontot. A TCP-port mezőbe írja be az 1433-at.

    Configure SQL Server Express for TCP/IP

    : Válassza az OK lehetőséget. Válassza az OK gombot az előugró párbeszédpanelen.

    h. Válassza a SQL Server Szolgáltatások lehetőséget a famenüben.

    i. Kattintson a jobb gombbal a SQL Server (SQLEXPRESS) elemre, és válassza az Újraindítás parancsot.

    j. Zárja be SQL Server 2014-Configuration Manager.

  3. Futtassa SQL Server 2014-Management Studio, és csatlakozzon a helyi SQL Server Express-példányhoz:

    1. Kattintson a jobb gombbal a példányra Object Explorer, és válassza a Tulajdonságok parancsot.

    2. Válassza a Biztonság lapot.

    3. Győződjön meg arról, hogy SQL Server és Windows hitelesítési mód van kiválasztva.

    4. Válassza az OK lehetőséget.

      Configure SQL Server Express authentication

    5. Bontsa ki a biztonsági>bejelentkezéseket a Object Explorer.

    6. Kattintson a jobb gombbal a Bejelentkezések elemre, és válassza az Új bejelentkezés lehetőséget.

    7. Adjon meg egy bejelentkezési nevet. Válassza SQL Server hitelesítést. Adjon meg egy jelszót, majd írja be ugyanazt a jelszót a Jelszó megerősítése mezőbe. A jelszónak meg kell felelnie Windows összetettségi követelményeknek.

    8. Válassza az OK lehetőséget.

      Add a new user to SQL Server Express

    9. Kattintson a jobb gombbal az új bejelentkezésre, és válassza a Tulajdonságok parancsot.

    10. Válassza a Kiszolgálói szerepkörök lapot.

    11. Jelölje be a dbcreator-kiszolgálói szerepkör jelölőnégyzetét.

    12. Válassza az OK lehetőséget.

    13. Zárja be SQL Server 2015-ös Management Studio.

Jegyezze fel a kiválasztott felhasználónevet és jelszót. Előfordulhat, hogy az adatbázis követelményeitől függő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ázishoz tartozó kapcsolati sztring környezeti változót. Ezt a változót a környezetében állíthatja be. 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 egy jelszót a kapcsolathoz.

A projekt konfigurálása helyi fejlesztéshez

A Mobile Apps egy azureMobile.js nevű JavaScript-fájlt olvas be a helyi fájlrendszerből. Ne használja ezt a fájlt a Mobile Apps SDK éles környezetben való konfigurálásához. Ehelyett használja az alkalmazásbeállításokat a Azure Portal.

A 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éldaazureMobile.js fájl az előző adatbázis-beállításokat valósítja meg:

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

Javasoljuk, hogy adjon hozzáazureMobile.js a .gitignore fájlhoz (vagy más forráskódvezérlő figyelmen kívül hagyja a fájlt), hogy megakadályozza a jelszavak felhőben való tárolását. Mindig konfigurálja az éles beállításokat az alkalmazásbeállításokban a Azure Portal.

Alkalmazásbeállítások konfigurálása a mobilalkalmazáshoz

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

Alkalmazásbeállítás azureMobile.js beállítás Leírás Érvényes értékek
MS_MobileAppName name Az alkalmazás neve sztring
MS_MobileLoggingLevel logging.level A naplózandó üzenetek minimális naplózási szintje hiba, figyelmeztetés, információ, részletes, hibakeresés, silly
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 megadva) 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

Alkalmazásbeállítás beállítása:

  1. Jelentkezzen be az Azure Portalra.
  2. Válassza az Összes erőforrás vagy az App Services lehetőséget, majd válassza ki a mobilalkalmazás nevét.
  3. Alapértelmezés szerint megnyílik a Gépház panel. Ha nem, válassza a Gépház lehetőséget.
  4. Az ÁLTALÁNOS menüben válassza az Alkalmazásbeállítások lehetőséget.
  5. Görgessen az Alkalmazásbeállítások szakaszhoz.
  6. Ha az alkalmazásbeállítás már létezik, válassza ki az alkalmazásbeállítás értékét az érték szerkesztéséhez. Ha az alkalmazásbeállítás nem létezik, írja be az alkalmazásbeállítást a Kulcs mezőbe, az értéket pedig az Érték mezőbe.
  7. Kattintson a Mentés gombra.

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

A SQL Database használata éles adattárként

A Azure SQL Database adattárként való használata minden Azure App Service alkalmazástípusban azonos. Ha még nem tette meg, az alábbi lépéseket követve hozzon létre egy Mobile Apps-háttéralkalmazást:

  1. Jelentkezzen be az Azure Portalra.

  2. Az ablak bal felső sarkában válassza az +ÚJ gomb >Web + Mobil>mobilalkalmazás lehetőséget, majd adjon nevet a Mobile Apps háttéralkalmazásának.

  3. Az Erőforráscsoport mezőbe írja be az alkalmazás nevét.

  4. Az alapértelmezett App Service terv van kiválasztva. Ha módosítani szeretné a App Service csomagot:

    a. Válassza App Service Plan+Create New (Terv>+Új létrehozása) lehetőséget.

    b. Adja meg az új App Service terv nevét, és válasszon egy megfelelő helyet.

    c. Válassza ki a szolgáltatáshoz megfelelő tarifacsomagot. Válassza az Összes megtekintése lehetőséget a további díjszabási lehetőségek( például az Ingyenes és a Megosztott) megtekintéséhez.

    d. Kattintson a Kijelölés gombra.

    e. A App Service terv panelen kattintson az OK gombra.

  5. Válassza a Létrehozás lehetőséget.

A Mobile Apps-háttérrendszer kiépítése eltarthat néhány percig. A Mobile Apps háttérrendszerének kiépítése után a portál megnyitja a Mobile Apps háttérrendszerének Gépház panelét.

Választhat, hogy csatlakoztat egy meglévő SQL-adatbázist a Mobile Apps háttérrendszeréhez, vagy létrehoz egy új SQL-adatbázist. Ebben a szakaszban létrehozunk egy SQL-adatbázist.

Megjegyzés

Ha már rendelkezik adatbázissal a Mobile Apps háttérrendszerével megegyező helyen, válassza a Meglévő adatbázis használata lehetőséget, majd jelölje ki az adatbázist. A nagyobb késések miatt nem javasoljuk egy másik helyen lévő adatbázis használatát.

  1. Az új Mobile Apps háttérrendszerben válassza> Gépház Mobile App>Data>+Add lehetőséget.

  2. Az Adatkapcsolat hozzáadása panelen válassza a SQL Database – A szükséges beállítások> konfigurálásaÚj adatbázis létrehozása lehetőséget. Írja be az új adatbázis nevét a Név mezőbe.

  3. Válassza a Kiszolgáló lehetőséget. Az Új kiszolgáló panelen adjon meg egy egyedi kiszolgálónevet a Kiszolgálónév mezőben, és adjon meg egy megfelelő kiszolgálói rendszergazdai bejelentkezést és jelszót. Győződjön meg arról, hogy az Azure-szolgáltatások hozzáférhetnek a kiszolgálóhoz jelölőnégyzet be van jelölve. Válassza az OK lehetőséget.

    Create an Azure SQL database

  4. Az Új adatbázis panelen válassza az OK gombot.

  5. Az Adatkapcsolat hozzáadása panelen válassza a Kapcsolati sztring lehetőséget, majd adja meg az adatbázis létrehozásakor megadott bejelentkezési és jelszót. Ha meglévő adatbázist használ, adja meg az adatbázis bejelentkezési hitelesítő adatait. Válassza az OK lehetőséget.

  6. Ismét az Adatkapcsolat hozzáadása panelen kattintson az OK gombra az adatbázis létrehozásához.

Az adatbázis létrehozása eltarthat néhány percig. Az Értesítések terület használatával monitorozza az üzembe helyezés előrehaladását. Az adatbázis sikeres üzembe helyezéséig ne haladj tovább. Az adatbázis üzembe helyezése után létrejön egy kapcsolati sztring a SQL Database-példányhoz a Mobile Apps háttéralkalmazás-beállításaiban. Ezt az alkalmazásbeállítást a Gépház>Alkalmazás beállításai>kapcsolati sztringekben tekintheti meg.

A táblákhoz való hozzáférés hitelesítésének megkövetelése

Ha App Service hitelesítést szeretne használni a tables végponttal, először konfigurálnia kell App Service hitelesítést a Azure Portal. További információt a használni kívánt identitásszolgáltató konfigurációs útmutatójában talál:

Minden tábla rendelkezik egy hozzáférési tulajdonságtal, 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 fel:

  • A névtelen azt jelzi, hogy az ügyfélalkalmazás hitelesítés nélkül is olvashatja az adatokat.
  • A hitelesített beállítás azt jelzi, hogy az ügyfélalkalmazásnak érvényes hitelesítési jogkivonatot kell küldenie a kéréssel együtt.
  • A disabled (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 objektumra feloldó ígéretet ad vissza. Az objektumot a hitelesítési módszer (facebook, , google, twitter, microsoftaccountvagy aad) határozza meg.

Ha például beállítja a Microsoft-fiók hitelesítését, és kéri az e-mail-címek jogcímét, az e-mail-címet a következő táblavezérlővel adhatja hozzá 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.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;

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

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

A táblázaton kívül 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 a tábla RESTful GET művelete.
  • insert A a tábla RESTful POST művelete.
  • update A a tábla RESTful PATCH művelete.
  • delete A a tábla RESTful DELETE művelete.

Előfordulhat például, hogy í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 címkézve, így csak a saját rekordjait olvashatja vagy frissítheti. A következő táblázatdefiní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 rendelkeznek egy olyan lekérdezési tulajdonságtal, amelyet egy where záradék használatával módosíthat. A lekérdezési tulajdonság egy QueryJS-objektum , amely egy OData-lekérdezésnek az adatok háttérrendszere által feldolgozhatóvá alakítására szolgál. Egyszerű egyenlőségi esetekhez (például az előzőhöz) 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öröl rekordokat. Ehelyett az adatbázison belül töröltként jelöli meg őket a törölt oszlop igaz értékre állításával. A 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(). Tábla helyreállítható törlésre 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;

Létre kell hoznia egy rekordtörlési mechanizmust: ügyfélalkalmazást, webjobot, Azure-függvényt vagy egyéni API-t.

Az adatbázis üzembe helyezése adatokkal

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

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 a 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 séma kikövetkeztethető a beszúrt adatokból.

Javasoljuk, hogy a szolgáltatás futásának megkezdésekor explicit módon hívja meg tables.initialize() a táblát létrehozó metódust.

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

A 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ását a Mobile Apps konstruktorban:

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

Valószínűleg csak a fejlesztési kiadásokban szeretné engedélyezni a Swagger támogatását. Ezt az NODE_ENV alkalmazásbeállítással teheti meg:

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ásban hitelesítést igényel, a Swagger hibát jelez. A legjobb eredmény érdekében engedélyezze a hitelesítés nélküli kéréseket a Azure App Service hitelesí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.

Leküldéses értesítések

A Mobile Apps integrálható az Azure Notification Hubs szolgáltatással, így célzott leküldéses értesítéseket küldhet több millió eszköznek az összes nagyobb platformon. A Notification Hubs használatával leküldéses értesítéseket küldhet iOS, Android és Windows eszközökre. A Notification Hubs használatával elvégezhető műveletekről a Notification Hubs áttekintésében olvashat bővebben.

Leküldéses értesítések küldése

Az alábbi kód bemutatja, hogyan használható az push objektum szórásos leküldéses értesítés küldésére a regisztrált iOS eszközökre:

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

Ha létrehoz egy sablon leküldéses regisztrációt az ügyféltől, ehelyett elküldheti a sablon leküldéses üzenetét az összes támogatott platformon lévő eszközökre. Az alábbi kód bemutatja, hogyan küldhet sablonértesítést:

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

Leküldéses értesítések küldése hitelesített felhasználónak címkék használatával

Amikor egy hitelesített felhasználó leküldéses értesítésekre regisztrál, a rendszer automatikusan hozzáad egy felhasználói azonosító címkét a regisztrációhoz. Ezzel a címkével leküldéses értesítéseket küldhet egy adott felhasználó által regisztrált összes eszközre. Az alábbi kód lekéri a kérést küldő felhasználó BIZTONSÁGI azonosítóját, és küld egy sablon leküldéses értesítést az adott felhasználó összes eszközregisztrációjának:

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

Amikor leküldéses értesítésekre regisztrál egy hitelesített ügyfélről, a regisztráció megkísérlése előtt győződjön meg arról, hogy a hitelesítés befejeződött.

Egyéni API-k

Egyéni API definiálása

A Végponton keresztüli Adatelérési API mellett a /tables 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.

Ha egyéni API-val szeretné használni App Service-hitelesítést, először konfigurálnia kell App Service hitelesítést a Azure Portal. További információt a használni kívánt identitásszolgáltató konfigurációs útmutatójában talál:

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. Importálja a könyvtárat az importálási api módszerrel.

Í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ó az 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-műveletek 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

A Mobile Apps SDK ugyanúgy valósítja meg a hitelesítést a végpont és az tables egyéni API-k esetében is. Ha az előző szakaszban kifejlesztett API-hoz szeretne hitelesítést hozzáadni, 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;

A hitelesítést adott műveletekhez 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

A Mobile Apps SDK a body-parser 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

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

Hibakeresés

Mobilalkalmazások hibakeresése, diagnosztizálása és hibaelhárítása

Azure App Service számos hibakeresési és hibaelhárítási módszert kínál Node.js alkalmazásokhoz. A Node.js Mobile Apps-háttérrendszer hibaelhárításának első lépéseit az alábbi cikkekben találja:

Node.js alkalmazások számos diagnosztikai naplóeszközhöz férhetnek hozzá. A Mobile Apps Node.js SDK belsőleg Winstont használja a diagnosztikai naplózáshoz. A naplózás automatikusan engedélyezve van, ha engedélyezi a hibakeresési módot, vagy true (igaz) értékre állítja az MS_DebugMode alkalmazásbeállítást a Azure Portal. A létrehozott naplók megjelennek a diagnosztikai naplókban a Azure Portal.