Sdílet prostřednictvím

Používání sady Mobile Apps Node.js SDK

Tento článek obsahuje podrobné informace a příklady, které ukazují, jak pracovat s back-endem Node.js ve funkci Mobile Apps služby Azure App Service.

Úvod

Mobile Apps poskytuje možnost přidat webové rozhraní API pro přístup k datům optimalizovaným pro mobilní zařízení do webové aplikace. Sada Mobile Apps SDK je k dispozici pro webové aplikace ASP.NET a Node.js. Sada SDK poskytuje následující operace:

  • Operace tabulek (čtení, vložení, aktualizace, odstranění) pro přístup k datům
  • Vlastní operace rozhraní API

Obě operace poskytují ověřování napříč všemi zprostředkovateli identity, které azure App Service umožňuje. Mezi tyto poskytovatele patří zprostředkovatelé sociálních identit, jako jsou Facebook, Twitter, Google a Microsoft, a také Azure Active Directory pro podnikovou identitu.

Ukázky pro každý případ použití najdete v adresáři ukázek na GitHubu.

Podporované platformy

Sada Mobile Apps Node.js SDK podporuje aktuální verzi LTS node a novější. Nejnovější verze LTS je v současné době Node v4.5.0. Jiné verze Node můžou fungovat, ale nejsou podporované.

Sada Mobile Apps Node.js SDK podporuje dva ovladače databáze:

  • Ovladač node-mssql podporuje Azure SQL Database a místní instance SQL Serveru.
  • Ovladač sqlite3 podporuje databáze SQLite pouze v jedné instanci.

Vytvoření základního Node.js back-endu pomocí příkazového řádku

Každý back end aplikací Mobile Apps Node.js začíná jako aplikace ExpressJS. ExpressJS je nejoblíbenější architektura webové služby dostupná pro Node.js. Základní aplikaci Express můžete vytvořit následujícím způsobem:

  1. V okně příkazu nebo PowerShellu vytvořte adresář pro váš projekt:

     mkdir basicapp

  2. Spusťte npm init k inicializaci struktury balíčku:

     cd basicapp
 npm init

    Příkaz npm init položí sadu otázek pro inicializaci projektu. Podívejte se na ukázkový výstup:

    Inicializační výstup npm

  3. Nainstalujte knihovny express a azure-mobile-apps z úložiště npm:

     npm install --save express azure-mobile-apps

  4. Vytvořte soubor app.js pro implementaci základního mobilního serveru:

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

Tato aplikace vytvoří mobilní optimalizované webové rozhraní API s jedním koncovým bodem (/tables/TodoItem), který poskytuje neověřený přístup k podkladovému úložišti dat SQL pomocí dynamického schématu. Je vhodný pro následující rychlé starty klientské knihovny:

Kód pro tuto základní aplikaci najdete v ukázce basicapp na GitHubu.

Vytvoření back-endu Node.js pomocí sady Visual Studio 2015

Visual Studio 2015 vyžaduje rozšíření pro vývoj Node.js aplikací v integrovaném vývojovém prostředí (IDE). Nainstalujte Node.js Tools 1.1 pro Visual Studio. Po dokončení instalace vytvořte aplikaci Express 4.x:

  1. Otevření dialogového okna Nový projekt (ze souboru>nového>projektu)

  2. Rozbalit šablony>JavaScriptu>Node.js.

  3. Vyberte základní aplikaci Azure Node.js Express 4.

  4. Zadejte název projektu. Vyberte OK.

    Nový projekt sady Visual Studio 2015

  5. Klikněte pravým tlačítkem na uzel npm a vyberte Nainstalovat nové balíčky npm.

  6. Po vytvoření první Node.js aplikace možná budete muset aktualizovat katalog npm. V případě potřeby vyberte Aktualizovat .

  7. Do vyhledávacího pole zadejte azure-mobile-apps . Vyberte balíček azure-mobile-apps 2.0.0 a pak vyberte Nainstalovat balíček.

    Instalace nových balíčků npm

  8. Vyberte Zavřít.

  9. Otevřete soubor app.js a přidejte podporu sady Mobile Apps SDK. Na řádek 6 v dolní části příkazů knihovny require přidejte následující kód:

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

    Na přibližně řádek 27 za ostatní app.use příkazy přidejte následující kód:

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

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

    Uložte soubor.

  10. Buď spusťte aplikaci místně (rozhraní API je dostupné https://localhost:3000) nebo publikujte na Azure.

Vytvoření back-endu Node.js pomocí webu Azure Portal

Mobilní aplikace back-end můžete vytvořit přímo v Azure portálu. Pomocí kurzu Vytvoření mobilní aplikace můžete buď provést následující kroky, nebo vytvořit klienta a server společně. Tento kurz obsahuje zjednodušenou verzi těchto pokynů a je nejvhodnější pro projekty testování konceptu.

  1. Přihlaste se na webu Azure Portal.

  2. Vyberte +NEW>Web + Mobile>Mobile Appa poté zadejte název pro backend mobilních aplikací.

  3. Pro skupinu prostředkůvyberte existující skupinu prostředků nebo vytvořte novou (pomocí stejného názvu jako aplikace).

  4. Pro plán služby App Serviceje vybraný výchozí plán (v úrovni Standard). Můžete také vybrat jiný plán, nebo vytvořit nový.

    Nastavení plánu služby App Service určují umístění, funkce, náklady a výpočetní prostředky přidružené k vaší aplikaci. Další informace o plánech služby App Service a o tom, jak vytvořit nový plán v jiné cenové úrovni a v požadovaném umístění, najdete v tématu podrobný přehled plánů služby Azure App Service.

  5. Vyberte Vytvořit. Tento krok vytvoří backend mobilních aplikací.

  6. V podokně Nastavení nového back endu pro mobilní aplikace vyberte Rychlý start, platformu vaší klientské aplikace>, >.

    výběry pro připojení databáze

  7. V podokně Přidat datové připojení vyberte SQL Database>Vytvořit novou databázi. Zadejte název databáze, zvolte cenovou úroveň a pak vyberte Server. Tuto novou databázi můžete znovu použít. Pokud již máte databázi ve stejném umístění, můžete místo toho zvolit Použít existující databázi. Nedoporučujeme používat databázi v jiném umístění kvůli nákladům na šířku pásma a vyšší latenci.

    Výběr databáze

  8. V podokně Nový server zadejte jedinečný název serveru do pole Název serveru, zadejte přihlašovací jméno a heslo, vyberte Povolit službám Azure přístup k serverua vyberte OK. Tento krok vytvoří novou databázi.

  9. Zpět v podokně Přidat datové připojení vyberte Připojovací řetězec, zadejte hodnoty pro přihlášení a heslo pro vaši databázi a vyberte OK.

    Než budete pokračovat, počkejte několik minut, než se databáze úspěšně nasadí.

Zpět v podokně Začínáme v části Vytvořit rozhraní API tabulky zvolte Node.js jako back-endový jazyk. Zaškrtněte políčko pro potvrzuji, že tím přepíšu veškerý obsah stránky, poté vyberte Vytvořit tabulka TodoItem.

Stáhněte si projekt kódu pro rychlý start Node.js back-endu pomocí Git.

Když vytvoříte zázemí mobilních aplikací Node.js pomocí podokna portálu Rychlý start, pro vás se vytvoří projekt Node.js, který bude nasazen na vaši webovou stránku. Na portálu můžete přidávat tabulky a rozhraní API a upravovat soubory kódu pro Node.js back-end. Pomocí různých nástrojů pro nasazení můžete také stáhnout back-endový projekt, abyste mohli přidat nebo upravit tabulky a rozhraní API a pak projekt znovu publikovat. Další informace najdete v průvodci nasazením služby Azure App Service.

Následující postup používá úložiště Git ke stažení kódu projektu pro rychlý start:

  1. Pokud jste to ještě neudělali, nainstalujte Git. Kroky potřebné k instalaci Gitu se mezi operačními systémy liší. Pro distribuce a informace o instalaci specifické pro operační systém viz Instalace Gitu.

  2. Viz Příprava úložiště pro povolení úložiště Git pro váš back-endový web. Poznamenejte si uživatelské jméno a heslo nasazení.

  3. V podokně backendu vašich mobilních aplikací si poznamenejte adresu URL klonu Git.

  4. git clone Spusťte příkaz pomocí adresy URL klonu Gitu. V případě potřeby zadejte heslo, jak je znázorněno v následujícím příkladu:

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

  5. Přejděte do místního adresáře (/todolist v předchozím příkladu) a všimněte si, že byly staženy soubory projektu. Vyhledejte soubor todoitem.json v /tables adresáři. Tento soubor definuje oprávnění k tabulce. Vyhledejte také todoitem.js soubor ve stejném adresáři. Definuje skripty operací CRUD pro tabulku.

  6. Po provedení změn souborů projektu spusťte následující příkazy pro přidání, potvrzení a nahrání změn na web:

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

    Když do projektu přidáte nové soubory, musíte nejdřív spustit git add . příkaz.

Web se znovu publikuje pokaždé, když se do webu odešle nová sada potvrzení.

Publikujte svůj Node.js backend do Azure

Microsoft Azure poskytuje mnoho mechanismů pro publikování mobile apps Node.js back-endu do služby Azure. Mezi tyto mechanismy patří nástroje pro nasazení integrované do sady Visual Studio, nástroje příkazového řádku a možnosti průběžného nasazování založené na správě zdrojového kódu. Další informace najdete v průvodci nasazením služby Azure App Service.

Azure App Service má konkrétní rady pro Node.js aplikace, které byste měli před publikováním back-endu zkontrolovat:

Povolení domovské stránky pro vaši aplikaci

Mnoho aplikací je kombinací webových a mobilních aplikací. Ke kombinování těchto dvou omezujících vlastnost můžete použít architekturu ExpressJS. Někdy ale můžete chtít implementovat jenom mobilní rozhraní. Je užitečné poskytnout domovskou stránku, aby se zajistilo, že je služba App Service v provozu. Můžete buď zadat vlastní domovskou stránku, nebo povolit dočasnou domovskou stránku. Pokud chcete povolit dočasnou domovskou stránku, pomocí následujícího kódu vytvořte instanci Mobile Apps:

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

Pokud chcete tuto možnost zpřístupnit jenom při místním vývoji, můžete toto nastavení přidat do souboru azureMobile.js.

Operace tabulek

Sada AZURE-mobile-apps Node.js Server SDK poskytuje mechanismy pro zveřejnění tabulek dat uložených ve službě Azure SQL Database jako webového rozhraní API. Poskytuje pět operací:

Operace Popis
GET /tables/tablename Získejte všechny záznamy v tabulce.
GET /tables/tablename/:id Získejte konkrétní záznam v tabulce.
POST /tables/tablename Vytvořte záznam v tabulce.
PATCH /tables/tablename/:id Aktualizujte záznam v tabulce.
DELETE /tables/tablename/:id Odstraňte záznam v tabulce.

Toto webové rozhraní API podporuje OData a rozšiřuje schéma tabulky tak, aby podporovalo offline synchronizaci dat.

Definování tabulek pomocí dynamického schématu

Než budete moct použít tabulku, musíte ji definovat. Tabulky můžete definovat pomocí statického schématu (kde definujete sloupce ve schématu) nebo dynamicky (kde sada SDK řídí schéma na základě příchozích požadavků). Kromě toho můžete řídit konkrétní aspekty webového rozhraní API přidáním javascriptového kódu do definice.

Osvědčeným postupem je definovat každou tabulku v souboru JavaScriptu tables v adresáři a pak použít metodu tables.import() pro import tabulek. Při rozšiřování příkladu základní aplikace byste upravili soubor app.js:

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

Definujte tabulku v ./tables/TodoItem.js:

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

var table = azureMobileApps.table();

// Additional configuration for the table goes here.

module.exports = table;

Tabulky ve výchozím nastavení používají dynamické schéma. Pokud chcete dynamické schéma globálně vypnout, nastavte MS_DynamicSchema nastavení aplikace na webu Azure Portal na false.

Kompletní příklad najdete v ukázce úkolů na GitHubu.

Definování tabulek pomocí statického schématu

Sloupce, které se mají zveřejnit prostřednictvím webového rozhraní API, můžete explicitně definovat. Sada azure-mobile-apps Node.js SDK automaticky přidá do seznamu, který zadáte, všechny další sloupce potřebné pro synchronizaci offline dat. Například klientské aplikace pro rychlý start vyžadují tabulku se dvěma sloupci: text (řetězec) a complete (logická hodnota).
Tabulku lze definovat v souboru JavaScript definice tabulky (umístěném tables v adresáři) následujícím způsobem:

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;

Pokud definujete tabulky staticky, musíte také volat metodu tables.initialize() pro vytvoření schématu databáze při spuštění. Metoda tables.initialize() vrátí příslib , aby webová služba neobsloužila požadavky před inicializace databáze.

Použití SQL Serveru Express jako vývojového úložiště dat na místním počítači

Sada Mobile Apps Node.js SDK poskytuje tři možnosti pro okamžité zpracování dat.

  • Pomocí ovladače paměti můžete poskytnout netrvalé ukázkové úložiště.
  • Pomocí ovladače mssql můžete poskytnout úložiště dat SQL Server Express pro vývoj.
  • Pomocí ovladače mssql můžete poskytnout úložiště dat Azure SQL Database pro produkční prostředí.

Sada Mobile Apps Node.js SDK používá balíček mssql Node.js k navázání a použití připojení k SQL Serveru Express i SQL Database. Tento balíček vyžaduje povolení připojení TCP v instanci SQL Serveru Express.

Návod

Ovladač paměti neposkytuje úplnou sadu zařízení pro testování. Pokud chcete back-end otestovat místně, doporučujeme použít úložiště dat SQL Server Express a ovladač mssql.

  1. Stáhněte a nainstalujte Microsoft SQL Server 2014 Express. Ujistěte se, že nainstalujete edici SQL Server 2014 Express s nástroji. Pokud explicitně nevyžadujete 64bitovou podporu, 32bitová verze při spuštění spotřebovává méně paměti.

  2. Spusťte SQL Server 2014 Configuration Manager:

    a. Rozbalte uzel Konfigurace sítě SQL Server ve stromové nabídce.

    b) Vyberte protokoly pro SQLEXPRESS.

    c. Klikněte pravým tlačítkem na TCP/IP a vyberte Povolit. Ve vyskakovacím dialogovém okně vyberte OK.

    d. Klikněte pravým tlačítkem na TCP/IP a vyberte Vlastnosti.

    e. Vyberte kartu IP Adresy.

    f. Vyhledejte uzel IPAll . Do pole Port TCP zadejte 1433.

    Konfigurace SQL Serveru Express pro TCP/IP

    gram Vyberte OK. Ve vyskakovacím dialogovém okně vyberte OK.

    h. Ve stromové nabídce vyberte služby SQL Serveru .

    i. Klikněte pravým tlačítkem na SQL Server (SQLEXPRESS) a vyberte Restartovat.

    j. Zavřete SQL Server 2014 Configuration Manager.

  3. Spusťte SQL Server 2014 Management Studio a připojte se k místní instanci SQL Serveru Express:

    1. Klikněte pravým tlačítkem na instanci v Průzkumníku objektů a vyberte Vlastnosti.

    2. Vyberte stránku Zabezpečení.

    3. Ujistěte se, že je vybraný režim ověřování SQL Server a Windows.

    4. Vyberte OK.

      Konfigurace ověřování SQL Server Express

    5. Rozbalte Zabezpečení>Přihlášení v Průzkumníku objektů.

    6. Klikněte pravým tlačítkem na Přihlášení a vyberte Nové přihlášení.

    7. Zadejte přihlašovací jméno. Vyberte Ověřování SQL Serveru. Zadejte heslo a pak zadejte stejné heslo do pole Potvrdit heslo. Heslo musí splňovat požadavky na složitost Systému Windows.

    8. Vyberte OK.

      Přidání nového uživatele do SQL Serveru Express

    9. Klikněte pravým tlačítkem na nové přihlášení a vyberte Vlastnosti.

    10. Vyberte stránku Role serveru .

    11. Označte políčko pro roli serveru dbcreator.

    12. Vyberte OK.

    13. Zavřete SQL Server 2015 Management Studio.

Nezapomeňte zaznamenat uživatelské jméno a heslo, které jste vybrali. V závislosti na požadavcích na databázi možná budete muset přiřadit další role nebo oprávnění serveru.

Aplikace Node.js přečte proměnnou SQLCONNSTR_MS_TableConnectionString prostředí pro připojovací řetězec pro tuto databázi. Tuto proměnnou můžete nastavit ve svém prostředí. K nastavení této proměnné prostředí můžete například použít PowerShell:

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

Přístup k databázi prostřednictvím připojení TCP/IP. Zadejte uživatelské jméno a heslo pro připojení.

Konfigurace projektu pro místní vývoj

Mobile Apps čte javascriptový soubor s názvem azureMobile.js z místního systému souborů. Tento soubor nepoužívejte ke konfiguraci sady Mobile Apps SDK v produkčním prostředí. Místo toho použijte nastavení aplikace na webu Azure Portal.

Soubor azureMobile.js by měl exportovat objekt konfigurace. Nejběžnější nastavení jsou:

  • Nastavení databáze
  • Nastavení protokolování diagnostiky
  • Alternativní nastavení CORS

Tento příklad azureMobile.js soubor implementuje předchozí nastavení databáze:

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

Doporučujeme přidat azureMobile.js do souboru .gitignore (nebo do jiného souboru ignorování správy zdrojového kódu), abyste zabránili ukládání hesel do cloudu. Nastavení produkčního prostředí vždy konfigurujte v nastavení aplikace na webu Azure Portal.

Konfigurace nastavení aplikace pro mobilní aplikaci

Většina nastavení v souboru azureMobile.js má ekvivalentní nastavení aplikace na webu Azure Portal. Ke konfiguraci aplikace v nastavení aplikace použijte následující seznam:

Nastavení aplikace nastavení azureMobile.js Popis Platné hodnoty
MS_MobileAppName název Název aplikace struna
MS_MobileLoggingLevel úroveň protokolování Minimální úroveň protokolu zpráv, které se mají protokolovat chyba, upozornění, informace, podrobné, ladění, hloupost
MS_DebugMode ladění Povolí nebo zakáže režim ladění. pravda, nepravda
MS_TableSchema datový schéma Výchozí název schématu pro tabulky SQL řetězec (výchozí: dbo)
MS_DynamicSchema data.dynamicSchema Povolí nebo zakáže režim ladění. pravda, nepravda
MS_DisableVersionHeader verze (nastavená na nedefinovanou hodnotu) Zakáže záhlaví X-ZUMO-Server-Version pravda, nepravda
MS_SkipVersionCheck skipversioncheck Zakáže kontrolu verze klientského rozhraní API. pravda, nepravda

Nastavení aplikace:

  1. Přihlaste se do Azure Portalu.
  2. Vyberte Všechny prostředky nebo App Services a pak vyberte název mobilní aplikace.
  3. Ve výchozím nastavení se otevře podokno Nastavení . Pokud ne, vyberte Nastavení.
  4. V nabídce OBECNÉ vyberte Nastavení aplikace.
  5. Přejděte do části Nastavení aplikace .
  6. Pokud nastavení aplikace již existuje, vyberte hodnotu nastavení aplikace a upravte ji. Pokud nastavení aplikace neexistuje, zadejte nastavení aplikace do pole Klíč a hodnotu do pole Hodnota .
  7. Zvolte Uložit.

Změna většiny nastavení aplikace vyžaduje restartování služby.

Použití SLUŽBY SQL Database jako produkčního úložiště dat

Použití Azure SQL Database jako úložiště dat je stejné ve všech typech aplikací služby Azure App Service. Pokud jste to ještě neudělali, vytvořte back-end Mobile Apps pomocí následujícího postupu:

  1. Přihlaste se do Azure Portalu.

  2. V levém horním rohu okna vyberte tlačítko +NOVÝ>Web + Mobilní>Aplikace pro mobilní, a poté zadejte název pro back-end vašich mobilních aplikací.

  3. Do pole Skupina prostředků zadejte stejný název jako vaše aplikace.

  4. Je vybraný výchozí plán služby App Service. Pokud chcete změnit plán služby App Service:

    a. Vyberte Plán služby App Service>+ Vytvořit nový.

    b) Zadejte název nového plánu služby App Service a vyberte příslušné umístění.

    c. Vyberte pro službu odpovídající cenovou úroveň. Výběrem možnosti Zobrazit vše zobrazíte další cenové možnosti, například Free a Shared.

    d. Klikněte na tlačítko Vybrat .

    e. Zpět v podokně plánu služby App Service vyberte OK.

  5. Vyberte Vytvořit.

Zřízení back-endu Mobile Apps může trvat několik minut. Po zřízení back-endu Mobile Apps se na portálu otevře podokno Nastavení back-endu Mobile Apps.

Můžete se rozhodnout připojit existující databázi SQL k back-endu Mobile Apps nebo vytvořit novou databázi SQL. V této části vytvoříme databázi SQL.

Poznámka:

Pokud už máte databázi ve stejném umístění jako back-end Mobile Apps, můžete místo toho vybrat Možnost Použít existující databázi a pak tuto databázi vybrat. Nedoporučujeme používat databázi v jiném umístění kvůli vyšší latenci.

  1. V novém backendu Mobile Apps vyberte Nastavení>Mobilní aplikace>Data>+ Přidat.

  2. V podokně Přidat datové připojení vyberte SQL Database – Nakonfigurujte požadovaná nastavení>Vytvořit novou databázi. Do pole Název zadejte název nové databáze.

  3. Vyberte Server. V podokně Nový server zadejte do pole Název serveru jedinečný název serveru a zadejte vhodné přihlašovací jméno a heslo správce serveru. Ujistěte se, že je vybraná možnost Povolit službám Azure přístup k serveru . Vyberte OK.

    Vytvoření databáze Azure SQL

  4. V podokně Nová databáze vyberte OK.

  5. Zpět v podokně Přidat datové připojení vyberte Připojovací řetězec a zadejte přihlašovací jméno a heslo, které jste zadali při vytváření databáze. Pokud používáte existující databázi, zadejte přihlašovací údaje pro tuto databázi. Vyberte OK.

  6. Znovu v podokně Přidat datové připojení vyberte OK a vytvořte databázi.

Vytvoření databáze může trvat několik minut. Pomocí oblasti Oznámení můžete monitorovat průběh nasazení. Nepokračujte, dokud nebude databáze úspěšně nasazena. Po nasazení databáze se v nastavení back-endové aplikace Mobile Apps vytvoří připojovací řetězec pro instanci služby SQL Database. Toto nastavení aplikace můžete zobrazit v Nastavení>nastavení aplikace>připojovacích řetězcích.

Vyžadování ověřování pro přístup k tabulkám

Pokud chcete používat ověřování pomocí služby App Service s tables koncovým bodem, musíte nejprve nakonfigurovat ověřování služby App Service na webu Azure Portal . Další informace najdete v průvodci konfigurací pro zprostředkovatele identity, kterého chcete použít:

Každá tabulka má přístupovou vlastnost, kterou můžete použít k řízení přístupu k tabulce. Následující ukázka ukazuje staticky definovanou tabulku s požadovaným ověřováním.

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;

Přístupová vlastnost může mít jednu ze tří hodnot:

  • Anonymní značí, že klientská aplikace může číst data bez ověřování.
  • Ověřeno znamená, že klientská aplikace musí odeslat platný ověřovací token s požadavkem.
  • Disabled označuje, že tato tabulka je aktuálně zakázaná.

Pokud je vlastnost přístupu nedefinovaná, je povolený neověřený přístup.

Použijte ověřovací nároky s vašimi tabulkami

Můžete nastavit různé deklarace identity, které jsou požadovány při nastavování ověřování. Tyto nároky nejsou obvykle dostupné prostřednictvím objektu context.user. Můžete je ale načíst pomocí context.user.getIdentity() metody. Metoda getIdentity() vrátí příslib, který se přeloží na objekt. Objekt je klíčován metodou ověřování (facebook, google, twitter, microsoftaccount, nebo aad).

Pokud například nastavíte ověřování účtu Microsoft a požádáte o deklaraci e-mailových adres, můžete e-mailovou adresu přidat do záznamu pomocí následujícího kontroleru tabulky:

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;

Chcete-li zjistit, jaké nároky jsou k dispozici, použijte webový prohlížeč k zobrazení koncového bodu /.auth/me vašeho webu.

Zakázání přístupu ke konkrétním operacím tabulek

Kromě zobrazení v tabulce lze vlastnost přístupu použít k řízení jednotlivých operací. Existují čtyři operace:

  • read je operace RESTful GET v tabulce.
  • insert je operace RESTful POST v tabulce.
  • update je operace RESTful PATCH na tabulce.
  • delete je operace RESTful DELETE v tabulce.

Můžete například chtít zadat neověřenou tabulku jen pro čtení:

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;

Úprava dotazu, který se používá s operacemi tabulek

Běžným požadavkem pro operace tabulek je poskytnutí omezeného zobrazení dat. Můžete například zadat tabulku, která je označená ověřeným ID uživatele, abyste mohli číst nebo aktualizovat pouze vlastní záznamy. Následující definice tabulky poskytuje tuto funkci:

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;

Operace, které obvykle spouští dotaz, mají vlastnost dotazu, kterou můžete upravit pomocí where klauzule. Vlastnost dotazu je objekt QueryJS , který slouží k převodu dotazu OData na něco, co může back-end dat zpracovat. Pro jednoduché případy rovnosti (jako je předchozí) můžete použít mapu. Můžete také přidat konkrétní klauzule SQL:

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

Nakonfigurujte měkké odstranění v tabulce

Měkké smazání ve skutečnosti nezpůsobí odstranění záznamů. Místo toho je označí jako odstraněné v databázi nastavením odstraněného sloupce na true. Sada Mobile Apps SDK automaticky odebere měkce smazané záznamy z výsledků, pokud sada Mobile Client SDK nepoužívá IncludeDeleted(). Pokud chcete nakonfigurovat tabulku pro obnovitelné odstranění, nastavte softDelete vlastnost v definičním souboru tabulky:

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;

Měli byste vytvořit mechanismus pro odstranění záznamů: klientskou aplikaci, webovou úlohu, funkci Azure nebo vlastní rozhraní API.

Naplňte svou databázi daty

Při vytváření nové aplikace můžete chtít vytvořit tabulku s daty. Můžete to udělat v souboru JavaScript definice tabulky následujícím způsobem:

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;

Naplnění dat se provádí pouze tehdy, když jste použili Mobile Apps SDK k vytvoření tabulky. Pokud tabulka již v databázi existuje, do tabulky se nevkážou žádná data. Pokud je dynamické schéma zapnuté, schéma se odvodí z počátečních dat.

Doporučujeme explicitně volat metodu tables.initialize() pro vytvoření tabulky při spuštění služby.

Povolení podpory Swaggeru

Mobile Apps se dodává s integrovanou podporou Swaggeru . Pokud chcete povolit podporu Swaggeru, nejprve nainstalujte swagger-ui jako závislost:

npm install --save swagger-ui

Podporu Swaggeru pak můžete povolit v konstruktoru Mobile Apps:

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

Pravděpodobně chcete povolit podporu Swaggeru pouze ve vývojových edicích. Můžete to udělat pomocí NODE_ENV nastavení aplikace:

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

Koncový swagger bod se nachází v http:// yoursite.azurewebsites.net/swagger. K uživatelskému rozhraní Swaggeru se dostanete přes /swagger/ui koncový bod. Pokud se rozhodnete vyžadovat ověřování v celé aplikaci, Swagger způsobí chybu. Nejlepších výsledků dosáhnete tak, že v nastavení ověřování/autorizace služby Azure App Service povolíte neověřené požadavky a pak pomocí vlastnosti řídíte ověřování table.access .

Možnost Swagger můžete také přidat do souboru azureMobile.js, pokud chcete podporu Swaggeru jenom pro místní vývoj.

Nabízená oznámení

Mobile Apps se integruje se službou Azure Notification Hubs, takže můžete odesílat cílená nabízená oznámení milionům zařízení na všech hlavních platformách. Pomocí Notification Hubs můžete odesílat push oznámení do zařízení s iOS, Androidem a Windows. Další informace o tom, co můžete dělat se službou Notification Hubs, najdete v přehledu Notification Hubs.

Odeslat push oznámení

Následující kód ukazuje, jak pomocí objektu push odeslat vysílané push oznámení registrovaným zařízením s iOS.

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

Vytvořením registrace šablony push z aplikace klienta můžete místo toho odeslat zprávu push šablony do zařízení na všech podporovaných platformách. Následující kód ukazuje, jak odeslat šablonové oznámení:

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

Odesílání nabízených oznámení ověřenému uživateli pomocí značek

Když se ověřený uživatel zaregistruje k nabízeným oznámením, značka ID uživatele se automaticky přidá do registrace. Pomocí této značky můžete odesílat push oznámení všem zařízením registrovaným konkrétním uživatelem. Následující kód získá SID uživatele, který provádí požadavek, a odešle oznámení na základě šablony každé registraci zařízení pro daného uživatele:

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

Při registraci nabízených oznámení z ověřeného klienta se před pokusem o registraci ujistěte, že je ověřování dokončené.

Vlastní rozhraní API

Definování vlastního rozhraní API

Kromě rozhraní API pro přístup k datům prostřednictvím koncového bodu /tables můžou mobilní aplikace poskytovat vlastní pokrytí rozhraní API. Vlastní rozhraní API jsou definována podobným způsobem jako definice tabulek a mají přístup ke všem stejným zařízením, včetně ověřování.

Pokud chcete použít ověřování pomocí služby App Service s vlastním rozhraním API, musíte nejprve nakonfigurovat ověřování služby App Service na webu Azure Portal . Další informace najdete v průvodci konfigurací pro zprostředkovatele identity, kterého chcete použít:

Vlastní rozhraní API jsou definována velmi stejným způsobem jako rozhraní API pro tabulky:

  1. Vytvořte api adresář.
  2. Vytvořte v adresáři api soubor JavaScript definice API.
  3. K importu adresáře použijte metodu importu api .

Tady je definice prototypu rozhraní API založená na ukázce základní aplikace, kterou jsme použili dříve:

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

Podívejme se na příklad rozhraní API, které vrací datum serveru pomocí Date.now() metody. Tady je soubor 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;

Každý parametr je jedním ze standardních příkazů RESTful: GET, POST, PATCH nebo DELETE. Metoda je standardní funkce middlewaru ExpressJS , která odesílá požadovaný výstup.

Vyžadování ověřování pro přístup k vlastnímu rozhraní API

SDK pro mobilní aplikace implementuje ověřování stejným způsobem pro koncový bod tables i vlastní API. Pokud chcete přidat ověřování do rozhraní API vyvinutého v předchozí části, přidejte access vlastnost:

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;

Můžete také zadat ověřování pro konkrétní operace:

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;

Stejný token, který se používá pro tables koncový bod, musí být použit pro vlastní rozhraní API, která vyžadují ověření.

Zpracování nahrávání velkých souborů

Sada Mobile Apps SDK používá middleware body-parser k přijetí a dekódování obsahu těla zprávy ve vašem příspěvku. Můžete přednastavit body-parser tak, aby přijímal větší soubory:

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

Soubor je před přenosem kódován kódováním base-64. Toto kódování zvětšuje velikost nahrávaných dat (a velikost, s níž musíte počítat).

Spouštění vlastních příkazů SQL

Sada Mobile Apps SDK umožňuje přístup k celému kontextu prostřednictvím objektu požadavku. Parametrizované příkazy SQL můžete snadno spouštět pro definovaného zprostředkovatele dat:

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;

Ladění

Ladění, diagnostika a řešení potíží s Mobile Apps

Azure App Service poskytuje několik technik ladění a řešení potíží pro Node.js aplikace. Pokud chcete začít řešit potíže s back-endem Node.js Mobile Apps, přečtěte si následující články:

Node.js aplikace mají přístup k široké škále nástrojů diagnostického protokolu. Interně sada Mobile Apps Node.js SDK používá Winston pro diagnostické logování. Protokolování se povolí automaticky, když povolíte režim ladění nebo nastavíte MS_DebugMode nastavení aplikace na "true" na portálu Azure. Vygenerované protokoly se zobrazí v diagnostických protokolech na webu Azure Portal.