Jak używać zestawu Node.js SDK dla usługi Azure Mobile Apps

Ten artykuł zawiera szczegółowe informacje i przykłady pokazujące, jak pracować z zapleczem nodeJS dla usługi Azure Mobile Apps.

Wprowadzenie

Usługa Azure Mobile Apps umożliwia dodawanie internetowego interfejsu API dostępu do danych zoptymalizowanych pod kątem urządzeń przenośnych do aplikacji internetowej. Zestaw SDK usługi Azure Mobile Apps jest dostępny dla aplikacji internetowych ASP.NET Framework i Node.js. Zestaw SDK udostępnia następujące operacje:

• Operacje tabel (odczyt, wstawianie, aktualizowanie, usuwanie) na potrzeby dostępu do danych
• Niestandardowe operacje interfejsu API

Obie operacje zapewniają uwierzytelnianie dla wszystkich dostawców tożsamości, którzy aplikacja systemu Azure Service zezwalają. Dostawcy ci obejmują dostawców tożsamości społecznościowych, takich jak Facebook, Twitter, Google i Microsoft oraz Microsoft Entra ID dla tożsamości przedsiębiorstwa.

Obsługiwane platformy

Zestaw Node.js SDK usługi Azure Mobile Apps obsługuje platformę Node 6.x lub nowszą i został przetestowany do wersji Node 12.x. Inne wersje środowiska Node mogą działać, ale nie są obsługiwane.

Zestaw Node.js SDK usługi Azure Mobile Apps obsługuje dwa sterowniki baz danych:

• Sterownik node-mssql obsługuje usługi Azure SQL Database i lokalne wystąpienia programu SQL Server.
• Sterownik sqlite3 obsługuje tylko bazy danych SQLite w jednym wystąpieniu.

Tworzenie podstawowego zaplecza węzła przy użyciu wiersza polecenia

Każde zaplecze usługi Azure Mobile Apps Node.js jest uruchamiane jako aplikacja Express . Platforma Express to najbardziej popularna platforma usług internetowych dostępna dla środowiska Node.js. Podstawową aplikację Express można utworzyć w następujący sposób:

1. W oknie polecenia lub programu PowerShell utwórz katalog dla projektu:

   $ mkdir basicapp
   

2. Uruchom polecenie npm init , aby zainicjować strukturę pakietu:

   $ cd basicapp
   $ npm init
   

   Polecenie npm init zadaje zestaw pytań w celu zainicjowania projektu. Zobacz przykładowe dane wyjściowe:

   

3. Zainstaluj biblioteki express i azure-mobile-apps z repozytorium npm:

   npm install --save express azure-mobile-apps
   

4. app.js Utwórz plik w celu zaimplementowania podstawowego serwera mobilnego:

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

Ta aplikacja tworzy zoptymalizowany pod kątem urządzeń przenośnych internetowy interfejs API z jednym punktem końcowym (/tables/TodoItem), który zapewnia nieuwierzytelniony dostęp do bazowego magazynu danych SQL przy użyciu schematu dynamicznego. Jest odpowiedni dla następujących przewodników Szybki start dotyczących biblioteki klienta:

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

Kod tej podstawowej aplikacji można znaleźć w obszarze przykładów w witrynie GitHub.

Włączanie strony głównej aplikacji

Wiele aplikacji to połączenie aplikacji internetowych i mobilnych. Możesz użyć platformy Express, aby połączyć dwa aspekty. Czasami jednak może być konieczne zaimplementowanie tylko interfejsu mobilnego. Warto podać stronę główną, aby upewnić się, że usługa App Service jest uruchomiona. Możesz podać własną stronę główną lub włączyć tymczasową stronę główną. Aby włączyć tymczasową stronę główną, użyj następującego kodu, aby utworzyć wystąpienie usługi Azure Mobile Apps:

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

Jeśli ta opcja jest dostępna tylko podczas tworzenia aplikacji lokalnie, możesz dodać to ustawienie do azureMobile.js pliku konfiguracji:

module.exports = {
    homePage: true,
};

Możesz dodać inne ustawienia do pliku azureMobile.js zgodnie z potrzebami.

Operacje na tabelach

Zestaw SDK platformy Node.js Server azure-mobile-apps udostępnia mechanizmy uwidaczniania tabel danych przechowywanych w usłudze Azure SQL Database jako internetowego interfejsu API. Zapewnia pięć operacji:

Działanie	opis
GET /tables/tablename	Pobierz wszystkie rekordy w tabeli.
GET /tables/tablename/:id	Pobierz określony rekord w tabeli.
POST /tables/tablename	Utwórz rekord w tabeli.
PATCH /tables/tablename/:id	Zaktualizuj rekord w tabeli.
DELETE /tables/tablename/:id	Usuń rekord w tabeli.

Ten internetowy interfejs API obsługuje usługę OData w wersji 3 i rozszerza schemat tabeli w celu obsługi synchronizacji danych w trybie offline.

Definiowanie tabel przy użyciu schematu dynamicznego

Aby można było użyć tabeli, należy ją zdefiniować. Tabele można definiować przy użyciu schematu statycznego (w którym definiuje się kolumny w schemacie) lub dynamicznie (gdzie zestaw SDK kontroluje schemat na podstawie żądań przychodzących). Ponadto można kontrolować konkretne aspekty internetowego interfejsu API, dodając kod JavaScript do definicji.

Najlepszym rozwiązaniem jest zdefiniowanie każdej tabeli w pliku JavaScript w tables katalogu, a następnie użycie tables.import() metody do zaimportowania tabel. Rozszerzenie przykładu podstawowej aplikacji spowoduje dostosowanie pliku 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);
});

Zdefiniuj tabelę w pliku ./tables/TodoItem.js:

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

var table = azureMobileApps.table();

// Additional configuration for the table goes here.

module.exports = table;

Tabele domyślnie używają schematu dynamicznego.

Definiowanie tabel przy użyciu schematu statycznego

Możesz jawnie zdefiniować kolumny do uwidocznienia za pośrednictwem internetowego interfejsu API. Zestaw SDK node.js aplikacji azure-mobile-apps automatycznie dodaje wszystkie dodatkowe kolumny wymagane do synchronizacji danych w trybie offline z listą, którą podajesz. Na przykład aplikacje klienckie szybkiego startu wymagają tabeli z dwiema kolumnami: text (ciąg) i complete (wartość logiczna). Tabelę można zdefiniować w pliku JavaScript definicji tabeli (znajdującym się w tables katalogu) w następujący sposób:

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;

Jeśli tabele są definiowane statycznie, należy również wywołać metodę tables.initialize() w celu utworzenia schematu bazy danych podczas uruchamiania. Metoda tables.initialize() zwraca obietnicę, aby usługa internetowa nie obsługiwała żądań przed zainicjowaniem bazy danych.

Używanie programu SQL Server Express jako magazynu danych programistycznych na komputerze lokalnym

Zestaw Node.js SDK usługi Azure Mobile Apps udostępnia trzy opcje obsługi danych poza urządzeniem:

• Użyj sterownika pamięci, aby udostępnić przykładowy magazyn nietrwale.
• Użyj sterownika mssql, aby zapewnić magazyn danych programu SQL Server Express na potrzeby programowania.
• Użyj sterownika mssql, aby udostępnić magazyn danych usługi Azure SQL Database dla środowiska produkcyjnego.

Zestaw SDK node.js usługi Azure Mobile Apps używa pakietu mssql Node.js do ustanowienia połączenia z usługą SQL Server Express i sql Database oraz używania go. Ten pakiet wymaga włączenia połączeń TCP w wystąpieniu programu SQL Server Express.

Napiwek

Sterownik pamięci nie zapewnia kompletnego zestawu obiektów do testowania. Jeśli chcesz przetestować zaplecze lokalnie, zalecamy użycie magazynu danych SQL Server Express i sterownika mssql.

1. Pobierz i zainstaluj program Microsoft SQL Server 2019 Developer.

2. Uruchom program Configuration Manager:

   • Rozwiń węzeł Konfiguracja sieci programu SQL Server w menu drzewa.
   • Wybierz pozycję Protokoły dla nazwy wystąpienia.
   • Kliknij prawym przyciskiem myszy pozycję TCP/IP i wybierz pozycję Włącz. Wybierz przycisk OK w oknie podręcznym.
   • W menu drzewa wybierz pozycję Usługi programu SQL Server.
   • Kliknij prawym przyciskiem myszy pozycję SQL Server (nazwa wystąpienia) i wybierz polecenie Uruchom ponownie.
   • Zamknij program Configuration Manager.

Musisz również utworzyć nazwę użytkownika i hasło, których usługa Azure Mobile Apps może używać do nawiązywania połączenia z bazą danych. Upewnij się, że utworzony użytkownik ma dbcreator rolę serwera. Aby uzyskać więcej informacji na temat konfigurowania użytkowników, zobacz dokumentację programu SQL Server

Pamiętaj, aby zarejestrować wybraną nazwę użytkownika i hasło. W zależności od wymagań bazy danych może być konieczne przypisanie większej liczby ról lub uprawnień serwera.

Aplikacja Node.js odczytuje zmienną SQLCONNSTR_MS_TableConnectionString środowiskową dla parametry połączenia dla tej bazy danych. Tę zmienną można ustawić w swoim środowisku. Na przykład możesz użyć programu PowerShell, aby ustawić tę zmienną środowiskową:

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

Uzyskaj dostęp do bazy danych za pośrednictwem połączenia TCP/IP. Podaj nazwę użytkownika i hasło dla połączenia.

Konfigurowanie projektu na potrzeby programowania lokalnego

Usługa Azure Mobile Apps odczytuje plik JavaScript wywoływany azureMobile.js z lokalnego systemu plików. Nie używaj tego pliku do konfigurowania zestawu SDK usługi Azure Mobile Apps w środowisku produkcyjnym. Zamiast tego użyj ustawień aplikacji w witrynie Azure Portal.

Plik azureMobile.js powinien wyeksportować obiekt konfiguracji. Najbardziej typowe ustawienia to:

• Ustawienia bazy danych
• Ustawienia rejestrowania diagnostycznego
• Alternatywne ustawienia mechanizmu CORS

W tym przykładzie plik azureMobile.js implementuje poprzednie ustawienia bazy danych:

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

Zalecamy dodanie azureMobile.js do pliku .gitignore (lub innej kontroli kodu źródłowego ignorowania pliku), aby zapobiec przechowywaniu haseł w chmurze.

Konfigurowanie ustawień aplikacji dla aplikacji mobilnej

Większość ustawień w azureMobile.js pliku ma równoważne ustawienie aplikacji w witrynie Azure Portal. Użyj poniższej listy, aby skonfigurować aplikację w obszarze Ustawienia aplikacji:

Ustawienia aplikacji	ustawienie azureMobile.js	opis	Prawidłowe wartości
MS_MobileAppName	name	Nazwa aplikacji	string
MS_MobileLoggingLevel	logging.level	Minimalny poziom dziennika komunikatów do rejestrowania	błąd, ostrzeżenie, informacje, pełne, debugowanie, głupie
MS_DebugMode	debug	Włącza lub wyłącza tryb debugowania	wartość true, false
MS_TableSchema	data.schema	Domyślna nazwa schematu dla tabel SQL	string (wartość domyślna: dbo)
MS_DynamicSchema	data.dynamicSchema	Włącza lub wyłącza tryb debugowania	wartość true, false
MS_DisableVersionHeader	wersja (ustawiona na niezdefiniowaną)	Wyłącza nagłówek X-ZUMO-Server-Version	wartość true, false
MS_SkipVersionCheck	skipversioncheck	Wyłącza sprawdzanie wersji interfejsu API klienta	wartość true, false

Zmiana większości ustawień aplikacji wymaga ponownego uruchomienia usługi.

Używanie usługi Azure SQL jako produkcyjnego magazynu danych

Używanie usługi Azure SQL Database jako magazynu danych jest identyczne we wszystkich typach aplikacji usługi aplikacja systemu Azure Service. Jeśli jeszcze tego nie zrobiono, wykonaj następujące kroki, aby utworzyć zaplecze usługi aplikacja systemu Azure Service. Utwórz wystąpienie usługi Azure SQL, a następnie ustaw ustawienie SQLCONNSTR_MS_TableConnectionString aplikacji na parametry połączenia dla wystąpienia usługi Azure SQL, którego chcesz użyć. Upewnij się, że usługa aplikacja systemu Azure z uruchomionym zapleczem może komunikować się z wystąpieniem usługi Azure SQL.

Wymaganie uwierzytelniania w celu uzyskania dostępu do tabel

Jeśli chcesz użyć uwierzytelniania usługi App Service z tables punktem końcowym, musisz najpierw skonfigurować uwierzytelnianie usługi App Service w witrynie Azure Portal . Aby uzyskać więcej informacji, zobacz przewodnik konfiguracji dostawcy tożsamości, którego zamierzasz użyć:

• Konfigurowanie uwierzytelniania Microsoft Entra
• Konfigurowanie uwierzytelniania w usłudze Facebook
• Konfigurowanie uwierzytelniania google
• Konfigurowanie uwierzytelniania firmy Microsoft
• Konfigurowanie uwierzytelniania w usłudze Twitter

Każda tabela ma właściwość dostępu, której można użyć do kontrolowania dostępu do tabeli. W poniższym przykładzie przedstawiono statycznie zdefiniowaną tabelę z wymaganym uwierzytelnianiem.

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;

Właściwość dostępu może przyjmować jedną z trzech wartości:

• anonimowe wskazuje, że aplikacja kliencka może odczytywać dane bez uwierzytelniania.
• Uwierzytelnione wskazuje, że aplikacja kliencka musi wysłać prawidłowy token uwierzytelniania z żądaniem.
• disabled wskazuje, że ta tabela jest obecnie wyłączona.

Jeśli właściwość dostępu jest niezdefiniowana, dostęp nieuwierzytelniony jest dozwolony.

Używanie oświadczeń uwierzytelniania z tabelami

Możesz skonfigurować różne oświadczenia, które są żądane podczas konfigurowania uwierzytelniania. Te oświadczenia nie są zwykle dostępne za pośrednictwem context.user obiektu. Można je jednak pobrać przy użyciu context.user.getIdentity() metody . Metoda getIdentity() zwraca obietnicę, która jest rozpoznawana jako obiekt. Obiekt jest kluczem metody uwierzytelniania (facebook, google, twitter, microsoftaccountlub aad).

Uwaga

Jeśli używasz uwierzytelniania firmy Microsoft za pośrednictwem identyfikatora Entra firmy Microsoft, metoda uwierzytelniania to aad, a nie microsoftaccount.

Jeśli na przykład skonfigurowano uwierzytelnianie firmy Microsoft Entra i zażądano oświadczenia adresów e-mail, możesz dodać adres e-mail do rekordu przy użyciu następującego kontrolera tabeli:

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;

Aby zobaczyć, jakie oświadczenia są dostępne, użyj przeglądarki internetowej, aby wyświetlić /.auth/me punkt końcowy witryny.

Wyłączanie dostępu do określonych operacji tabeli

Oprócz wyświetlania w tabeli właściwość dostępu może służyć do kontrolowania poszczególnych operacji. Istnieją cztery operacje:

• read to operacja RESTful GET w tabeli.
• insert to operacja RESTful POST w tabeli.
• update to operacja RESTful PATCH w tabeli.
• delete to operacja RESTful DELETE w tabeli.

Na przykład możesz podać tabelę nieuwierzytelnione tylko do odczytu:

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;

Dostosowywanie zapytania używanego z operacjami tabeli

Typowym wymaganiem dla operacji tabeli jest zapewnienie ograniczonego widoku danych. Możesz na przykład podać tabelę otagowana za pomocą uwierzytelnionego identyfikatora użytkownika, tak aby można było tylko odczytywać lub aktualizować własne rekordy. Poniższa definicja tabeli zawiera następujące funkcje:

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;

Operacje, które zwykle uruchamiają zapytanie, mają właściwość zapytania, którą można dostosować przy użyciu klauzuli where . Właściwość zapytania jest obiektem QueryJS , który służy do konwertowania zapytania OData na coś, co może przetwarzać zaplecze danych. W przypadku prostych przypadków równości (takich jak poprzedni), możesz użyć mapy. Można również dodać określone klauzule SQL:

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

Konfigurowanie usuwania nietrwałego w tabeli

Usuwanie nietrwałe nie powoduje usunięcia rekordów. Zamiast tego oznacza je jako usunięte w bazie danych, ustawiając usuniętą kolumnę na true. Zestaw SDK usługi Azure Mobile Apps automatycznie usuwa nietrwałe rekordy z wyników, chyba że zestaw SDK klienta mobilnego używa polecenia includeDeleted(). Aby skonfigurować tabelę usuwania nietrwałego, ustaw softDelete właściwość w pliku definicji tabeli:

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;

Ustanów mechanizm usuwania rekordów trwale, takich jak aplikacja kliencka, usługa WebJob, funkcja platformy Azure lub niestandardowy interfejs API.

Rozmieszczanie bazy danych przy użyciu danych

Podczas tworzenia nowej aplikacji warto umieścić tabelę z danymi. Dane można rozmieszczać w pliku JavaScript definicji tabeli w następujący sposób:

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;

Rozmieszczanie danych odbywa się tylko wtedy, gdy do utworzenia tabeli użyto zestawu SDK usługi Azure Mobile Apps. Jeśli tabela już istnieje w bazie danych, żadne dane nie są wstrzykiwane do tabeli. Jeśli schemat dynamiczny jest włączony, schemat jest wywnioskowany z danych wstępnie wyzwane.

Zalecamy jawne wywołanie tables.initialize() metody w celu utworzenia tabeli po uruchomieniu usługi.

Włączanie obsługi struktury Swagger

Usługa Azure Mobile Apps jest dostarczana z wbudowaną obsługą struktury Swagger . Aby włączyć obsługę struktury Swagger, najpierw zainstaluj narzędzie swagger-ui jako zależność:

npm install --save swagger-ui

Następnie możesz włączyć obsługę struktury Swagger w konstruktorze usługi Azure Mobile Apps:

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

Prawdopodobnie chcesz włączyć obsługę struktury Swagger tylko w wersjach programistycznych. Obsługę struktury Swagger można włączyć podczas programowania przy użyciu NODE_ENV ustawienia aplikacji:

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

Punkt swagger końcowy znajduje się w http:// oursite.azurewebsites.net/swagger. Dostęp do interfejsu użytkownika struktury Swagger można uzyskać za pośrednictwem punktu końcowego /swagger/ui . Jeśli zdecydujesz się wymagać uwierzytelniania w całej aplikacji, program Swagger generuje błąd. Aby uzyskać najlepsze wyniki, wybierz opcję zezwalania na nieuwierzytelnione żądania w ustawieniach uwierzytelniania/autoryzacji usługi aplikacja systemu Azure, a następnie kontrolować uwierzytelnianie przy użyciu table.access właściwości .

Możesz również dodać opcję Struktury Swagger do pliku azureMobile.js , jeśli chcesz tylko obsługiwać strukturę Swagger do tworzenia lokalnie.

Niestandardowe interfejsy API

Oprócz interfejsu API dostępu do danych za pośrednictwem punktu końcowego /tables usługa Azure Mobile Apps może zapewnić niestandardowe pokrycie interfejsu API. Niestandardowe interfejsy API są definiowane w podobny sposób do definicji tabel i mogą uzyskiwać dostęp do wszystkich tych samych obiektów, w tym uwierzytelniania.

Definiowanie niestandardowego interfejsu API

Niestandardowe interfejsy API są definiowane w taki sam sposób jak interfejs API tabel:

1. api Utwórz katalog.
2. Utwórz plik JavaScript definicji interfejsu api API w katalogu.
3. Użyj metody import, aby zaimportować api katalog.

Poniżej przedstawiono prototypową definicję interfejsu API opartą na przykładzie podstawowej aplikacji, który użyliśmy wcześniej:

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

Weźmy przykładowy interfejs API, który zwraca datę serwera przy użyciu Date.now() metody . api/date.js Oto plik:

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

module.exports = api;

Każdy parametr jest jednym ze standardowych zleceń RESTful: GET, POST, PATCH lub DELETE. Metoda jest standardową funkcją oprogramowania pośredniczącego ExpressJS, która wysyła wymagane dane wyjściowe.

Wymaganie uwierzytelniania w celu uzyskania dostępu do niestandardowego interfejsu API

Zestaw SDK usługi Azure Mobile Apps implementuje uwierzytelnianie w taki sam sposób zarówno dla punktu końcowego tables , jak i niestandardowych interfejsów API. Aby dodać uwierzytelnianie do interfejsu API opracowanego w poprzedniej sekcji, dodaj access właściwość:

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;

Można również określić uwierzytelnianie dla określonych operacji:

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;

Ten sam token, który jest używany dla punktu końcowego tables , musi być używany dla niestandardowych interfejsów API, które wymagają uwierzytelniania.

Obsługa przekazywania dużych plików

Zestaw SDK usługi Azure Mobile Apps używa oprogramowania pośredniczącego body-parser do akceptowania i dekodowania zawartości treści w przesłaniu. Możesz wstępnie skonfigurować analizator body-parser, aby zaakceptować większe przekazywanie plików:

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

Plik jest zakodowany w formacie base-64 przed transmisją. To kodowanie zwiększa rozmiar rzeczywistego przekazywania (i rozmiar, dla którego musisz uwzględnić).

Wykonywanie niestandardowych instrukcji SQL

Zestaw SDK usługi Azure Mobile Apps umożliwia dostęp do całego kontekstu za pośrednictwem obiektu żądania. Instrukcje SQL sparametryzowane można łatwo wykonać u zdefiniowanego dostawcy danych:

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;

Debugowanie

Debugowanie, diagnozowanie i rozwiązywanie problemów z usługą Azure Mobile Apps

usługa aplikacja systemu Azure udostępnia kilka technik debugowania i rozwiązywania problemów dla aplikacji Node.js. Aby rozpocząć rozwiązywanie problemów z zapleczem usługi Node.js Azure Mobile Apps, zobacz następujące artykuły:

• Monitorowanie usługi aplikacja systemu Azure
• Włączanie rejestrowania diagnostycznego w usłudze aplikacja systemu Azure
• Rozwiązywanie problemów z aplikacjami węzłów w usłudze aplikacja systemu Azure Service

Aplikacje Node.js mają dostęp do szerokiej gamy narzędzi dziennika diagnostycznego. Wewnętrznie zestaw SDK usługi Azure Mobile Apps Node.js używa narzędzia [Winston] do rejestrowania diagnostycznego. Rejestrowanie jest włączane automatycznie po włączeniu trybu debugowania lub ustawieniu MS_DebugMode ustawienia aplikacji na wartość true w witrynie Azure Portal. Wygenerowane dzienniki są wyświetlane w dziennikach diagnostycznych w witrynie Azure Portal.