Come usare Node.js SDK per app per dispositivi mobili di Azure

Questo articolo fornisce informazioni dettagliate ed esempi che illustrano come usare un back-end NodeJS per app per dispositivi mobili di Azure.

Introduzione

App per dispositivi mobili di Azure offre la possibilità di aggiungere un'API Web per l'accesso ai dati ottimizzata per dispositivi mobili a un'applicazione Web. Azure Mobile Apps SDK è disponibile per le applicazioni Web ASP.NET Framework e Node.js. L'SDK consente le operazioni seguenti:

• Operazioni su tabella (read, insert, update, delete) per l'accesso ai dati
• Operazioni sulle API personalizzate

Entrambe le operazioni permettono l'autenticazione in tutti i provider di identità consentiti dal servizio app di Azure, Questi provider includono provider di identità di social networking come Facebook, Twitter, Google e Microsoft e Microsoft Entra ID per l'identità aziendale.

Piattaforme supportate

L'SDK Node.js di App per dispositivi mobili di Azure supporta Node 6.x e versioni successive ed è stato testato fino a Node 12.x. Altre versioni di Node potrebbero funzionare, ma non sono supportate.

Node.js SDK di App per dispositivi mobili di Azure supporta due driver di database:

• Il driver node-mssql supporta il database SQL di Azure e le istanze locali di SQL Server.
• Il driver sqlite3 supporta i database SQLite solo su un'unica istanza.

Creare un back-end node di base usando la riga di comando

Ogni back-end Node.js di App per dispositivi mobili di Azure viene avviato come applicazione Express . Express è il framework di servizio Web più diffuso disponibile per Node.js. È possibile creare un'applicazione Express di base seguendo questa procedura:

1. Creare una directory per il progetto in una finestra di comando o di PowerShell:

   $ mkdir basicapp
   

2. Eseguire npm init per inizializzare la struttura del pacchetto:

   $ cd basicapp
   $ npm init
   

   Il comando npm init pone una serie di domande per inizializzare il progetto. Vedere l'output di esempio:

   

3. Installare le librerie express e azure-mobile-apps dal repository npm:

   npm install --save express azure-mobile-apps
   

4. Creare un app.js file per implementare il server mobile di base:

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

Questa applicazione crea un'API Web ottimizzata per dispositivi mobili con un endpoint singolo (/tables/TodoItem) che consente l'accesso non autenticato a un archivio dati SQL sottostante usando uno schema dinamico. È adatta per l'avvio rapido delle librerie client seguenti:

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

È possibile trovare il codice per questa applicazione di base nell'area degli esempi in GitHub.

Abilitare una home page per l'applicazione

Molte applicazioni sono una combinazione di app Web e per dispositivi mobili. È possibile usare il framework Express per combinare i due facet. In alcuni casi è tuttavia consigliabile implementare solo un'interfaccia per dispositivi mobili. È utile fornire una home page per garantire che il servizio app sia in esecuzione. È possibile fornire la propria home page o abilitarne una temporanea. Per abilitare una home page temporanea, usare il codice seguente per creare un'istanza di App per dispositivi mobili di Azure:

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

Se si vuole che questa opzione sia disponibile solo durante lo sviluppo in locale, è possibile aggiungere questa impostazione al azureMobile.js file di configurazione:

module.exports = {
    homePage: true,
};

È possibile aggiungere altre impostazioni al file azureMobile.js in base alle esigenze.

Operazioni su tabella

Node.js Server SDK (azure-mobile-apps) offre diversi meccanismi per esporre le tabelle dati archiviate nel database SQL di Azure come API Web. Offre cinque operazioni:

Operazione	Descrizione
GET /tables/tablename	Ottenere tutti i record nella tabella.
GET /tables/tablename/:id	Ottenere un record specifico nella tabella.
POST /tables/tablename	Creare un record nella tabella.
PATCH /tables/tablename/:id	Aggiornare un record nella tabella.
DELETE /tables/tablename/:id	Eliminare un record dalla tabella.

Questa API Web supporta OData v3 ed estende lo schema della tabella per supportare la sincronizzazione dei dati offline.

Definire le tabelle con uno schema dinamico

Prima di usare una tabella è necessario definirla. È possibile definire le tabelle con uno schema statico (in cui l'utente definisce le colonne nello schema) o in modo dinamico (in cui l'SDK controlla lo schema in base alle richieste in ingresso). È anche possibile controllare alcuni aspetti specifici dell'API Web aggiungendo codice JavaScript alla definizione.

Come procedura consigliata, è necessario definire ogni tabella in un file JavaScript nella directory tables, quindi usare il metodo tables.import() per importare le tabelle. Estendendo l'esempio di app di base, il file app.js viene modificato come segue:

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

Definire la tabella in ./tables/TodoItem.js:

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

var table = azureMobileApps.table();

// Additional configuration for the table goes here.

module.exports = table;

Per impostazione predefinita, le tabelle usano uno schema dinamico.

Definire le tabelle con uno schema statico

È possibile definire in modo esplicito le colonne da esporre con l'API Web. Node.js SDK (azure-mobile-apps) aggiunge automaticamente tutte le altre colonne necessarie per la sincronizzazione dei dati offline con l'elenco specificato. Ad esempio, le applicazioni client di avvio rapido richiedono una tabella con due colonne: text (una stringa) e complete (un valore booleano). La tabella può essere specificata nel file JavaScript di definizione della tabella, presente nella directory tables, nel modo seguente:

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;

Se si definiscono le tabelle in modo statico, è anche necessario chiamare il metodo tables.initialize() per creare lo schema del database all'avvio. Il metodo tables.initialize() restituisce un oggetto promise in modo che il servizio Web non gestisca le richieste prima dell'inizializzazione del database.

Usare SQL Server Express come archivio dati di sviluppo nel computer locale

Node.js SDK di App per dispositivi mobili di Azure offre tre opzioni per gestire i dati predefiniti:

• Usare il driver memory per fornire un archivio di esempio non persistente.
• Usare il driver mssql per fornire un archivio dati di SQL Server Express per lo sviluppo.
• Usare il driver mssql per fornire un archivio dati del database SQL di Azure per la produzione.

L'SDK Node.js di App per dispositivi mobili di Azure usa il pacchetto mssql Node.js per stabilire e usare una connessione sia a SQL Server Express che a database SQL. Per questo pacchetto è necessario abilitare le connessioni TCP nell'istanza di SQL Server Express.

Suggerimento

Il driver memory non fornisce un set completo di funzionalità per i test. Per testare il back-end in locale, è consigliabile usare un archivio dati di SQL Server Express con il driver mssql.

1. Scaricare e installare Microsoft SQL Server 2019 Developer.

2. Eseguire Configuration Manager:

   • Espandere il nodo Configurazione di rete SQL Server nel menu ad albero.
   • Selezionare Protocolli per nome istanza.
   • Fare clic con il pulsante destro del mouse su TCP/IP e scegliere Abilita. Selezionare OK nella finestra di dialogo popup.
   • Fare clic su Servizi di SQL Server nel menu ad albero.
   • Fare clic con il pulsante destro del mouse su SQL Server (nome-istanza) e scegliere Riavvia.
   • Chiudere Configuration Manager.

Sarà anche necessario creare un nome utente e una password che le app per dispositivi mobili di Azure possono usare per connettersi al database. Verificare che l'utente creato abbia il ruolo del dbcreator server. Per altre informazioni sulla configurazione degli utenti, vedere la documentazione di SQL Server

Prendere nota del nome utente e della password selezionati. Potrebbe essere necessario assegnare più ruoli o autorizzazioni del server, a seconda dei requisiti del database.

L'applicazione Node.js legge la variabile di ambiente SQLCONNSTR_MS_TableConnectionString per la stringa di connessione per il database. Questa variabile può essere impostata nell'ambiente. Ad esempio, è possibile usare PowerShell per impostare questa variabile di ambiente:

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

Accedere al database con una connessione TCP/IP. Fornire un nome utente e una password per la connessione.

Configurare il progetto per lo sviluppo locale

App per dispositivi mobili di Azure legge un file JavaScript chiamato azureMobile.js dal file system locale. Non usare questo file per configurare Azure Mobile Apps SDK nell'ambiente di produzione. Usare invece le impostazioni dell'app nel portale di Azure.

Il file azureMobile.js deve esportare un oggetto di configurazione. Le impostazioni più comuni sono:

• Impostazioni database
• Impostazioni di registrazione diagnostica
• Impostazioni CORS alternative

Questo file azureMobile.js di esempio implementa le impostazioni del database precedenti:

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

È consigliabile aggiungere azureMobile.js al .gitignore file (o ad altri file di controllo del codice sorgente) per evitare che le password vengano archiviate nel cloud.

Configurare le impostazioni dell'app per dispositivi mobili

La maggior parte delle impostazioni nel azureMobile.js file ha un'impostazione di app equivalente nella portale di Azure. Usare l'elenco seguente per configurare l'app in Impostazioni app:

Impostazione app	Impostazione in azureMobile.js	Descrizione	Valori validi
MS_MobileAppName	name	Nome dell'app	string
MS_MobileLoggingLevel	logging.level	Livello log minimo di messaggi da registrare	error, warning, info, verbose, debug, silly
MS_DebugMode	debug	Abilita o disabilita la modalità debug	true, false
MS_TableSchema	data.schema	Nome dello schema predefinito per le tabelle SQL	string (valore predefinito: dbo)
MS_DynamicSchema	data.dynamicSchema	Abilita o disabilita la modalità debug	true, false
MS_DisableVersionHeader	version (impostata su undefined)	Disabilita l'intestazione X-ZUMO-Server-Version	true, false
MS_SkipVersionCheck	skipversioncheck	Disabilita il controllo della versione dell'API client	true, false

Per modificare la maggior parte delle impostazioni dell'app, è necessario riavviare il servizio.

Usare Azure SQL come archivio dati di produzione

L'uso del database SQL di Azure come archivio dati è identico in tutti i tipi di applicazione del Servizio app di Azure. Se non è già stato fatto, seguire questa procedura per creare un back-end del servizio app Azure. Creare un'istanza di SQL di Azure, quindi impostare l'impostazione SQLCONNSTR_MS_TableConnectionString dell'app sul stringa di connessione per l'istanza di SQL di Azure che si vuole usare. Assicurarsi che il servizio app Azure che esegue il back-end possa comunicare con l'istanza di SQL di Azure.

Richiedere l'autenticazione per l'accesso alle tabelle

Per usare l'autenticazione del servizio app con l'endpoint tables, è prima necessario configurare l'autenticazione del servizio app nel portale di Azure. Per altre informazioni, vedere la guida alla configurazione del provider di identità che si intende usare:

• Configurare l'autenticazione di Microsoft Entra
• Configurare l'autenticazione di Facebook
• Configurare l'autenticazione di Google
• Configurare l'autenticazione di Microsoft
• Configurare l'autenticazione di Twitter

Ogni tabella ha una proprietà di accesso che può essere usata per controllare l'accesso alla tabella. L'esempio seguente mostra una tabella definita in modo statico in cui è richiesta l'autenticazione.

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;

La proprietà di accesso può assumere uno dei tre valori seguenti:

• anonymous indica che all'applicazione client è consentito leggere i dati senza autenticazione.
• authenticated indica che l'applicazione client deve inviare un token di autenticazione valido con la richiesta.
• disabled indica che la tabella è attualmente disabilitata.

Se la proprietà di accesso non è definita, è consentito l'accesso non autenticato.

Usare le attestazioni di autenticazione con le tabelle

È possibile impostare diverse attestazioni richieste quando viene impostata l'autenticazione. Queste attestazioni non sono in genere disponibili tramite l'oggetto context.user . Possono essere tuttavia recuperate usando il metodo context.user.getIdentity(). Il metodo getIdentity() restituisce una promessa che viene risolta in un oggetto. L'oggetto viene associato a una chiave tramite il metodo di autenticazione (facebook, google, twitter, microsoftaccount o aad).

Nota

Se si usa l'autenticazione Microsoft tramite Microsoft Entra ID, il metodo di autenticazione è aad, non microsoftaccount.

Ad esempio, se si configura l'autenticazione di Microsoft Entra e si richiede l'attestazione degli indirizzi di posta elettronica, è possibile aggiungere l'indirizzo di posta elettronica al record con il controller di tabella seguente:

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;

Per visualizzare le attestazioni disponibili, usare un browser Web per visualizzare l'endpoint /.auth/me del sito.

Disabilitare l'accesso a specifiche operazioni su tabella

Oltre che sulla tabella, la proprietà di accesso può essere usata per controllare singole operazioni. Sono disponibili quattro operazioni:

• read è l'operazione RESTful GET nella tabella.
• insert è l'operazione RESTful POST nella tabella.
• update è l'operazione RESTful PATCH nella tabella.
• delete è l'operazione RESTful DELETE nella tabella.

Si supponga, ad esempio, di voler fornire una tabella non autenticata di sola lettura:

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;

Modificare la query usata con le operazioni su tabella

Un requisito comune per le operazioni su tabella è consentire una visualizzazione con restrizioni dei dati. È ad esempio possibile fornire una tabella contrassegnata con l'ID dell'utente autenticato in modo sia possibile solo leggere o aggiornare i propri record. La definizione di tabella riportata di seguito fornisce questa funzionalità:

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;

Le operazioni che in genere eseguono una query hanno una proprietà query modificabile con una clausola where. La proprietà query è un oggetto QueryJS usato per convertire una query OData in un elemento che il back-end dei dati possa elaborare. Per i casi di semplice uguaglianza, come quello riportato in precedenza, è possibile usare una mappa. È anche possibile aggiungere clausole SQL specifiche:

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

Configurare l'eliminazione temporanea in una tabella

L'eliminazione temporanea non elimina effettivamente i record. Al contrario, questi vengono contrassegnati come eliminati nel database impostando la colonna relativa all'eliminazione su true. Azure Mobile Apps SDK rimuove automaticamente i record eliminati soft-delete dai risultati, a meno che Mobile Client SDK non usi includeDeleted(). Per configurare una tabella per l'eliminazione temporanea, impostare la proprietà softDelete nel file di definizione della tabella:

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;

Stabilire un meccanismo per eliminare i record in modo permanente, ad esempio un'applicazione client, un processo Web, una funzione di Azure o un'API personalizzata.

Eseguire il seeding dei dati nel database

Quando si crea una nuova applicazione, è consigliabile eseguire il seeding dei dati in una tabella. È possibile inizializzare i dati all'interno del file JavaScript di definizione della tabella come indicato di seguito:

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;

Il seeding dei dati si verifica solo quando è stato usato Azure Mobile Apps SDK per creare la tabella. Se la tabella esiste già all'interno del database, non verranno inseriti dati nella tabella. Se lo schema dinamico è abilitato, lo schema viene dedotto dai dati di seeding.

È consigliabile chiamare in modo esplicito il metodo tables.initialize() per creare la tabella all'avvio dell'esecuzione del servizio.

Abilitare il supporto di Swagger

App per dispositivi mobili di Azure include il supporto Swagger predefinito. Per abilitare il supporto di Swagger, installare prima di tutto swagger-ui come dipendenza:

npm install --save swagger-ui

È quindi possibile abilitare il supporto di Swagger nel costruttore di App per dispositivi mobili di Azure:

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

È consigliabile abilitare il supporto di Swagger solo nelle edizioni di sviluppo. È possibile abilitare il supporto di Swagger in fase di sviluppo usando l'impostazione dell'app NODE_ENV :

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

L'endpoint swagger è disponibile in http://yoursite.azurewebsites.net/swagger. È possibile accedere all'interfaccia utente di Swagger tramite l'endpoint /swagger/ui . Se si sceglie di richiedere l'autenticazione a livello dell'intera applicazione, Swagger genera un errore. Per ottenere risultati ottimali, scegliere di consentire le richieste non autenticate tramite le impostazioni di autenticazione/autorizzazione del servizio app di Azure e quindi gestire l'autenticazione con la proprietà table.access.

È anche possibile aggiungere l'opzione Swagger al azureMobile.js file se si vuole solo il supporto di Swagger per lo sviluppo in locale.

API personalizzate

Oltre all'API di accesso ai dati tramite l'endpoint /tables , App per dispositivi mobili di Azure può fornire una copertura API personalizzata. Le API personalizzate sono definite in modo analogo alle definizioni di tabella e possono accedere alle stesse funzionalità, inclusa l'autenticazione.

Definire un'API personalizzata

Le API personalizzate vengono definite in modo molto simile alle API di tabella:

1. Creare una directory api.
2. Creare un file JavaScript di definizione dell'API nella directory api.
3. Usare il metodo di importazione per importare la directory api.

Di seguito è riportata la definizione dell'API prototipo basata sull'esempio di app di base usato in precedenza:

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

Si prenda ad esempio un'API che restituisce la data del server usando il metodo Date.now(). Ecco il api/date.js file:

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

module.exports = api;

Ogni parametro è uno dei verbi RESTful standard: GET, POST, PATCH o DELETE. Il metodo è una funzione ExpressJS Middleware standard che invia l'output richiesto.

Richiedere l'autenticazione per l'accesso a un'API personalizzata

Azure Mobile Apps SDK implementa l'autenticazione nello stesso modo sia per l'endpoint tables che per le API personalizzate. Per aggiungere l'autenticazione all'API sviluppata nella sezione precedente, aggiungere una proprietà 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;

È anche possibile specificare l'autenticazione su operazioni specifiche:

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;

Lo stesso token usato per l'endpoint tables deve essere usato per le API personalizzate che richiedono l'autenticazione.

Gestire il caricamento di file di grandi dimensioni

Azure Mobile Apps SDK usa il middleware body-parser per accettare e decodificare il contenuto del corpo nell'invio. È possibile preconfigurare il body-parser per accettare caricamenti di file più grandi:

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

Il file ha una codifica in base 64 prima della trasmissione, che aumenta le dimensioni del caricamento effettivo e di cui è quindi necessario tenere conto.

Eseguire istruzioni SQL personalizzate

Azure Mobile Apps SDK consente l'accesso all'intero contesto tramite l'oggetto richiesta. per eseguire facilmente istruzioni SQL con parametri nel provider di dati definito:

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;

Debug

Eseguire il debug, diagnosticare e risolvere i problemi delle app per dispositivi mobili di Azure

Il servizio app di Azure offre diverse tecniche di debug e risoluzione dei problemi per le applicazioni Node.js. Per iniziare a risolvere i problemi relativi al back-end di App per dispositivi mobili di Azure Node.js, vedere gli articoli seguenti:

• Monitoraggio del servizio app di Azure
• Abilitare la registrazione diagnostica nel servizio app di Azure
• Risolvere i problemi relativi alle applicazioni node nel servizio app Azure

Le applicazioni Node.js hanno accesso a un'ampia gamma di strumenti per i log di diagnostica. Internamente, l'SDK Node.js di App per dispositivi mobili di Azure usa [Winston] per la registrazione diagnostica. La registrazione viene abilitata automaticamente quando si abilita la modalità di debug o si imposta l'impostazione dell'app MS_DebugMode su true nella portale di Azure. I log generati vengono visualizzati tra i log di diagnostica del portale di Azure.