Come usare Node.js SDK per App per dispositivi mobili di AzureHow to use the Azure Mobile Apps Node.js SDK

Questo articolo fornisce informazioni dettagliate ed esempi sull'uso di un back-end Node.js nelle app per dispositivi mobili del servizio app di Azure.This article provides detailed information and examples showing how to work with a Node.js backend in Azure App Service Mobile Apps.

IntroduzioneIntroduction

App per dispositivi mobili del servizio app di Azure consente di aggiungere un'API Web di accesso ai dati ottimizzata per dispositivi mobili a un'applicazione Web.Azure App Service Mobile Apps provides the capability to add a mobile-optimized data access Web API to a web application. Azure App Service Mobile Apps SDK viene fornito per le applicazioni Web Node.js e ASP.NET.The Azure App Service Mobile Apps SDK is provided for ASP.NET and Node.js web applications. L'SDK consente le operazioni seguenti:The SDK provides the following operations:

  • Operazioni su tabella (read, insert, update, delete) per l'accesso ai datiTable operations (Read, Insert, Update, Delete) for data access
  • Operazioni sulle API personalizzateCustom API operations

Entrambe le operazioni permettono l'autenticazione in tutti i provider di identità consentiti dal servizio app di Azure, inclusi i provider di identità basati su social network, ad esempio Facebook, Twitter, Google e Microsoft nonché Azure Active Directory per l'identità aziendale.Both operations provide for authentication across all identity providers allowed by Azure App Service, including social identity providers such as Facebook, Twitter, Google and Microsoft as well as Azure Active Directory for enterprise identity.

Esempi per ogni caso d'uso sono disponibili nella directory degli esempi in GitHub.You can find samples for each use case in the [samples directory on GitHub].

Piattaforme supportateSupported Platforms

Node SDK per App per dispositivi mobili di Azure supporta la versione LTS corrente di Node e le versioni successive.The Azure Mobile Apps Node SDK supports the current LTS release of Node and later. Al momento della stesura di questo testo, la versione LTS più recente di è Node v4.5.0.As of writing, the latest LTS version is Node v4.5.0. Altre versioni di Node potrebbero funzionare, ma non sono supportate.Other versions of Node may work, but are not supported.

Node SDK per App per dispositivi mobili di Azure supporta due driver di database, il driver node-mssql supporta SQL Azure e le istanze locali di SQL Server.The Azure Mobile Apps Node SDK supports two database drivers - the node-mssql driver supports SQL Azure and local SQL Server instances. Il driver sqlite3 supporta i database SQLite solo su un'unica istanza.The sqlite3 driver supports SQLite databases on a single instance only.

Creare un back-end Node.js di base usando la riga di comandoHow to: Create a Basic Node.js backend using the Command Line

Ogni back-end Node.js per le app per dispositivi mobili del servizio app di Azure viene avviato come applicazione ExpressJS.Every Azure App Service Mobile App Node.js backend starts as an ExpressJS application. ExpressJS è il framework dei servizi Web più diffuso disponibile per Node.js.ExpressJS is the most popular web service framework available for Node.js. È possibile creare un'applicazione Express di base seguendo questa procedura:You can create a basic Express application as follows:

  1. Creare una directory per il progetto in una finestra di comando o di PowerShell.In a command or PowerShell window, create a directory for your project.

     mkdir basicapp
    
  2. Eseguire npm init per inizializzare la struttura del pacchetto.Run npm init to initialize the package structure.

     cd basicapp
     npm init
    

    Il comando npm init pone una serie di domande per inizializzare il progetto.The npm init command asks a set of questions to initialize the project. Vedere l'output di esempio:See the example output:

    L'output di init npm

  3. Installare le librerie express e azure-mobile-apps dal repository npm.Install the express and azure-mobile-apps libraries from the npm repository.

     npm install --save express azure-mobile-apps
    
  4. Creare un file app.js per implementare il server per dispositivi mobili di base.Create an app.js file to implement the basic mobile server.

     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.This application creates a mobile-optimized WebAPI with a single endpoint (/tables/TodoItem) that provides unauthenticated access to an underlying SQL data store using a dynamic schema. È adatta per l'avvio rapido delle librerie client seguenti:It is suitable for following the client library quick starts:

Il codice per questa applicazione di base è disponibile nell' esempio basicapp in GitHub.You can find the code for this basic application in the [basicapp sample on GitHub].

Procedura: Creare un back-end Node.js con Visual Studio 2015How to: Create a Node backend with Visual Studio 2015

Visual Studio 2015 richiede un'estensione per lo sviluppo di applicazioni Node.js all'interno dell'IDE.Visual Studio 2015 requires an extension to develop Node.js applications within the IDE. Per iniziare, installare gli Strumenti Node.js 1.1 per Visual Studio.To start, install the [Node.js Tools 1.1 for Visual Studio]. Dopo aver installato gli Strumenti Node.js per Visual Studio, creare un'applicazione Express 4.x:Once the Node.js Tools for Visual Studio are installed, create an Express 4.x application:

  1. Aprire la finestra di dialogo Nuovo progetto (da File > Nuovo > Progetto...).Open the New Project dialog (from File > New > Project...).
  2. Espandere Modelli > JavaScript > Node.js.Expand Templates > JavaScript > Node.js.
  3. Selezionare Basic Azure Node.js Express 4 Application.Select the Basic Azure Node.js Express 4 Application.
  4. Immettere il nome del progetto.Fill in the project name. Fare clic su OK.Click OK.

    Nuovo progetto di Visual Studio 2015

  5. Fare clic sul nodo npm e selezionare Install New npm packages....Right-click the npm node and select Install New npm packages....
  6. Al momento della creazione della prima applicazione Node.js potrebbe essere necessario aggiornare il catalogo npm.You may need to refresh the npm catalog on creating your first Node.js application. Fare clic su Refresh (Aggiorna), se necessario.Click Refresh if necessary.
  7. Immettere azure-mobile-apps nella casella di ricerca.Enter azure-mobile-apps in the search box. Fare clic sul pacchetto azure-mobile-apps 2.0.0, quindi fare clic su Install Package.Click the azure-mobile-apps 2.0.0 package, then click Install Package.

    Installare nuovi pacchetti npm

  8. Fare clic su Close.Click Close.
  9. Aprire il file app.js per aggiungere il supporto per l'SDK per App per dispositivi mobili di Azure.Open the app.js file to add support for the Azure Mobile Apps SDK. Nella riga 6 nella parte inferiore delle istruzioni require della libreria aggiungere il codice seguente:At line 6 at the bottom of the library require statements, add the following code:

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

    Circa alla riga 27 dopo le altre istruzioni app.use aggiungere il codice seguente:At approximately line 27 after the other app.use statements, add the following code:

     app.use('/users', users);
    
     // Azure Mobile Apps Initialization
     var mobile = azureMobileApps();
     mobile.tables.add('TodoItem');
     app.use(mobile);
    

    Salvare il file.Save the file.

  10. Eseguire l'applicazione in locale, ovvero l'API viene eseguita in http://localhost:3000, o pubblicarla in Azure.Either run the application locally (the API is served on http://localhost:3000) or publish to Azure.

Procedura: Creare un back-end Node.js usando il portale di AzureHow to: Create a Node.js backend using the Azure portal

È possibile creare un back-end dell'app per dispositivi mobili direttamente nel Portale di Azure.You can create a Mobile App backend right in the [Azure portal]. È possibile seguire i passaggi seguenti o creare un client e un nuovo server seguendo l'esercitazione Creare un'app per dispositivi mobili .You can either follow the following steps or create a client and server together by following the Create a mobile app tutorial. L'esercitazione contiene una versione semplificata di queste istruzioni e dimostra i progetti del concetto.The tutorial contains a simplified version of these instructions and is best for proof of concept projects.

  1. Accedere al portale di Azure.Log in at the [Azure Portal].
  2. Fare clic su +NUOVO > Web e dispositivi mobili > App per dispositivi mobili e quindi specificare un nome per il back-end dell'app per dispositivi mobili.Click +NEW > Web + Mobile > Mobile App, then provide a name for your Mobile App backend.
  3. In Gruppo di risorseselezionare un gruppo di risorse esistente o crearne uno nuovo usando lo stesso nome dell'app.For the Resource Group, select an existing resource group, or create a new one (using the same name as your app.)

    È possibile selezionare un altro piano del servizio app o crearne uno nuovo.You can either select another App Service plan or create a new one. Per altre informazioni sui piani di Servizi app e su come creare un nuovo piano in un piano tariffario diverso e nella località preferita, vedere Panoramica approfondita dei piani del servizio app di Azure.For more about App Services plans and how to create a new plan in a different pricing tier and in your desired location, see Azure App Service plans in-depth overview.

  4. Per Piano di Servizio appviene selezionato il piano predefinito nel livello Standard.For the App Service plan, the default plan (in the Standard tier) is selected. È anche possibile selezionare un piano diverso oppure crearne uno nuovo.You can also select a different plan, or create a new one. Le impostazioni del piano di servizio app determinano località, funzionalità, costo e risorse di calcolo associati all'app.The App Service plan's settings determine the location, features, cost and compute resources associated with your app.

    Dopo aver scelto il piano, fare clic su Crea.After you decide on the plan, click Create. Verrà creato il back-end dell'app per dispositivi mobili.This creates the Mobile App backend.

  5. Nel pannello Impostazioni relativo al nuovo back-end dell'app per dispositivi mobili, fare clic su Avvio rapido > piattaforma dell'app client > Connetti al database.In the Settings blade for the new Mobile App backend, click Quick start > your client app platform > Connect a database.

  6. Nel pannello Aggiungi connessione dati fare clic su Database SQL > Crea un nuovo database, immettere il nome del database, scegliere un piano tariffario e quindi fare clic su Server.In the Add data connection blade, click SQL Database > Create a new database, type the database Name, choose a pricing tier, then click Server. È possibile riutilizzare questo nuovo database.You can reuse this new database. Se si ha già un database nella stessa località, è possibile scegliere Usare un database esistente.If you already have a database in the same location, you can instead choose Use an existing database. Non è consigliabile usare un database in una località diversa a causa dei costi di larghezza di banda e della latenza più elevata.The use of a database in a different location isn't recommended due to bandwidth costs and higher latency.

  7. Nel pannello Nuovo server digitare un nome del server univoco nel campo Nome server, specificare un account di accesso e una password, selezionare Consenti ai servizi di Azure di accedere al server e fare clic su OK.In the New server blade, type a unique server name in the Server name field, provide a login and password, check Allow azure services to access server, and click OK. Verrà creato il nuovo database.This creates the new database.
  8. Nel pannello Aggiungi connessione dati fare clic su Stringa di connessione, immettere i valori per l'account di accesso e la password del database e fare clic su OK.Back in the Add data connection blade, click Connection string, type the login and password values for your database, and click OK. Prima di procedere, attendere alcuni minuti che a distribuzione del database venga completata.Wait a few minutes for the database to be deployed successfully before proceeding.

Nel pannello Attività iniziali, in Creare un'API di tabella scegliere Node.js come Linguaggio back-end.Back in the Get started blade, under Create a table API, choose Node.js as your Backend language. Selezionare la casella per "Sono consapevole che questa operazione comporterà la sovrascrittura di tutti i contenuti del sito." e fare clic su Crea tabella TodoItem.Check the box for "I acknowledge that this will overwrite all site contents.", then click Create TodoItem table.

Procedura: Scaricare il progetto di codice di avvio rapido del back-end Node.js tramite GitHow to: Download the Node.js backend quickstart code project using Git

Quando si crea un back-end dell'app per dispositivi mobili Node.js usando il pannello Avvio rapido del portale, viene creato e distribuito nel sito un progetto Node.js.When you create a Node.js Mobile App backend by using the portal Quick start blade, a Node.js project is created for you and deployed to your site. È possibile aggiungere tabelle e API e modificare i file di codice per il back-end Node.js nel portale.You can add tables and APIs and edit code files for the Node.js backend in the portal. Si possono anche usare vari strumenti di distribuzione per scaricare il progetto back-end, per poter aggiungere o modificare tabelle e API, quindi ripubblicare il progetto.You can also use various deployment tools to download the backend project so that you can add or modify tables and APIs, then republish the project. Per altre informazioni, vedere la Guida alla distribuzione del servizio app di Azure.For more information, see the [Azure App Service Deployment Guide]. La procedura seguente usa un repository Git per scaricare il codice del progetto di avvio rapido.the following procedure uses a Git repository to download the quickstart project code.

  1. Se non è già stato fatto, installare Git.Install Git, if you haven't already done so. I passaggi necessari per installare Git variano a seconda del sistema operativo.The steps required to install Git vary between operating systems. Vedere la sezione Installazione di Git per indicazioni specifiche del sistema operativo relative a distribuzioni e installazione.See Installing Git for operating system-specific distributions and installation guidance.
  2. Seguire i passaggi in Abilitare il repository dell'app del servizio app per abilitare il repository Git per il sito di back-end, prendendo nota del nome utente e della password della distribuzione.Follow the steps in Enable the App Service app repository to enable the Git repository for your backend site, making a note of the deployment username and password.
  3. Nel pannello di back-end dell'app per dispositivi mobili annotare l'impostazione URL clone Git .In the blade for your Mobile App backend, make a note of the Git clone URL setting.
  4. Eseguire il comando git clone usando l'URL clone Git e immettendo la password quando richiesto, come nell'esempio seguente:Execute the git clone command using the Git clone URL, entering your password when required, as in the following example:

     $ git clone https://username@todolist.scm.azurewebsites.net:443/todolist.git
    
  5. Passare alla directory locale, che nell'esempio precedente è /todolist e osservare che sono stati scaricati i file di progetto.Browse to local directory, which in the preceding example is /todolist, and notice that project files have been downloaded. Individuare il file todoitem.json nella directory /tables.Locate the todoitem.json file in the /tables directory. Questo file definisce le autorizzazioni sulla tabella.This file defines permissions on the table. Individuare il file todoitem.js nella stessa directory, che definisce gli script di operazioni CRUD per la tabella.Also find the todoitem.js file in the same directory, which defines that CRUD operation scripts for the table.
  6. Dopo che sono state apportate modifiche ai file di progetto, eseguire i comandi seguenti per aggiungere, eseguire il commit delle modifiche e quindi caricare nel sito:After you have made changes to project files, execute the following commands to add, commit, then upload the changes to the site:

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

    Quando si aggiungono nuovi file al progetto, è necessario prima di tutto eseguire il comando git add ..When you add new files to the project, you first need to execute the git add . command.

Il sito viene ripubblicato ogni volta che viene effettuato il push di un nuovo set di commit al sito.The site is republished every time a new set of commits is pushed to the site.

Procedura: Pubblicare il back-end Node.js in AzureHow to: Publish your Node.js backend to Azure

Microsoft Azure offre numerosi meccanismi per la pubblicazione del back-end Node.js per le app per dispositivi mobili del servizio app di Azure,Microsoft Azure provides many mechanisms for publishing your Azure App Service Mobile Apps Node.js backend to the Azure service. tra cui l'uso di strumenti di distribuzione integrati in Visual Studio, strumenti da riga di comando e opzioni di distribuzione continua basate sul controllo del codice sorgente.These include utilizing deployment tools integrated into Visual Studio, command-line tools, and continuous deployment options based on source control. Per altre informazioni su questo argomento, vedere la Guida alla distribuzione del servizio app di Azure.For more information on this topic, see the [Azure App Service Deployment Guide].

Il servizio app di Azure include suggerimenti specifici per l'applicazione Node.js che è consigliabile esaminare prima della distribuzione:Azure App Service has specific advice for Node.js application that you should review before deploying:

Procedura: Abilitare una home page dell'applicazioneHow to: Enable a Home Page for your application

Molte applicazioni sono una combinazione di app Web e per dispositivi mobili e il framework ExpressJS consente di combinare i due aspetti.Many applications are a combination of web and mobile apps and the ExpressJS framework allows you to combine the two facets. In alcuni casi, tuttavia, è consigliabile implementare solo un'interfaccia per dispositivi mobili.Sometimes, however, you may wish to only implement a mobile interface. È utile fornire una pagina di destinazione per garantire il servizio app sia in esecuzione.It is useful to provide a landing page to ensure the app service is up and running. È possibile fornire la propria home page o abilitarne una temporanea.You can either provide your own home page or enable a temporary home page. Per abilitare una home page temporanea, usare quanto segue per creare un'istanza di App per dispositivi mobili di Azure:To enable a temporary home page, use the following to instantiate Azure Mobile Apps:

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

È possibile aggiungere questa impostazione al file azureMobile.js se si vuole che questa opzione sia disponibile solo quando si sviluppa in locale.If you only want this option available when developing locally, you can add this setting to your azureMobile.js file.

Operazioni su tabellaTable operations

Node.js Server SDK (azure-mobile-apps) offre diversi meccanismi per esporre le tabelle dati archiviate nel database SQL di Azure come API Web.The azure-mobile-apps Node.js Server SDK provides mechanisms to expose data tables stored in Azure SQL Database as a WebAPI. Sono disponibili cinque operazioni.Five operations are provided.

OperazioneOperation DescrizioneDescription
GET /tables/tablenameGET /tables/tablename Ottiene tutti i record nella tabellaGet all records in the table
GET /tables/tablename/:idGET /tables/tablename/:id Ottiene un record specifico nella tabellaGet a specific record in the table
POST /tables/tablenamePOST /tables/tablename Creare un record nella tabellaCreate a record in the table
PATCH /tables/tablename/:idPATCH /tables/tablename/:id Aggiornare un record nella tabellaUpdate a record in the table
DELETE /tables/tablename/:idDELETE /tables/tablename/:id Elimina un record dalla tabellaDelete a record in the table

Questa API Web supporta OData ed estende lo schema della tabella per supportare la sincronizzazione dati offline.This WebAPI supports OData and extends the table schema to support [offline data sync].

Procedura: Definire le tabelle con uno schema dinamicoHow to: Define tables using a dynamic schema

Perché sia possibile usare una tabella, è necessario prima definirla.Before a table can be used, it must be defined. Le tabelle possono essere definite con uno schema statico (dove lo sviluppatore definisce le colonne all'interno dello schema) o in modo dinamico (dove l'SDK controlla lo schema in base alle richieste in ingresso).Tables can be defined with a static schema (where the developer defines the columns within the schema) or dynamically (where the SDK controls the schema based on incoming requests). Lo sviluppatore può anche controllare alcuni aspetti specifici dell'API Web aggiungendo codice JavaScript alla definizione.In addition, the developer can control specific aspects of the WebAPI by adding Javascript code to the definition.

Come procedura consigliata, è necessario definire ogni tabella in un file JavaScript nella directory delle tabelle, quindi usare il metodo tables.import() per importare le tabelle.As a best practice, you should define each table in a Javascript file in the tables directory, then use the tables.import() method to import the tables. Estendendo l'app di base, il file app.js viene regolato:Extending the basic-app, the app.js file would be adjusted:

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:Define the table 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 lo schema dinamico.Tables use dynamic schema by default. Per disattivare lo schema dinamico a livello globale, impostare su false l'impostazione dell'app MS_DynamicSchema nel portale di Azure.To turn off dynamic schema globally, set the App Setting MS_DynamicSchema to false within the Azure portal.

Per un esempio completo, vedere l' esempio todo in GitHub.You can find a complete example in the [todo sample on GitHub].

Procedura: Definire le tabelle con uno schema staticoHow to: Define tables using a static schema

È possibile definire in modo esplicito le colonne da esporre con l'API Web.You can explicitly define the columns to expose via the WebAPI. Node.js SDK (azure-mobile-apps) aggiunge automaticamente tutte le altre colonne necessarie per la sincronizzazione dati offline all'elenco specificato.The azure-mobile-apps Node.js SDK automatically adds any additional columns required for offline data sync to the list that you provide. Ad esempio, le applicazioni client di avvio rapido richiedono una tabella con due colonne: text (una stringa) e complete (un valore booleano).For example, the QuickStart client applications require a table with two columns: text (a string) and complete (a boolean).
Questa tabella può essere specificata nel file JavaScript di definizione della tabella, presente nella directory delle tabelle, nel modo seguente:The table can be defined in the table definition JavaScript file (located in the tables directory) as follows:

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

var table = azureMobileApps.table();

// Define the columns within the table
table.columns = {
    "text": "string",
    "complete": "boolean"
};

// Turn off dynamic schema
table.dynamicSchema = false;

module.exports = table;

Se si definiscono le tabelle in modo statico, è necessario chiamare il metodo tables.initialize() per creare lo schema del database all'avvio.If you define tables statically, then you must also call the tables.initialize() method to create the database schema on startup. Il metodo tables.initialize() restituisce un oggetto Promise in modo che il servizio Web non gestisca le richieste prima dell'inizializzazione del database.The tables.initialize() method returns a Promise so that the web service does not serve requests before the database being initialized.

Procedura: Usare SQL Express come archivio dati di sviluppo nel computer localeHow to: Use SQL Express as a development data store on your local machine

Node SDK per le app per dispositivi mobili di Azure offre tre opzioni predefinite per la gestione dei dati:The Azure Mobile Apps The AzureMobile Apps Node SDK provides three options for serving data out of the box: SDK provides three options for serving data out of the box:

  • Usare il driver memory per fornire un archivio di esempio non persistenteUse the memory driver to provide a non-persistent example store
  • Usare il driver mssql per fornire un archivio dati di SQL Express per lo sviluppoUse the mssql driver to provide a SQL Express data store for development
  • Usare il driver mssql per fornire un archivio dati del database SQL di Azure per la produzioneUse the mssql driver to provide an Azure SQL Database data store for production

Node.js SDK per le app per dispositivi mobili di Azure usa il pacchetto mssql per Node.js per stabilire e usare una connessione a SQL Express e al database SQL di Azure.The Azure Mobile Apps Node.js SDK uses the [mssql Node.js package] to establish and use a connection to both SQL Express and SQL Database. Per questo pacchetto è necessario abilitare le connessioni TCP nell'istanza di SQL Express.This package requires that you enable TCP connections on your SQL Express instance.

Suggerimento

Il driver memory non fornisce un set completo di funzionalità per i test.The memory driver does not provide a complete set of facilities for testing. Per testare il back-end in locale, è consigliabile usare un archivio dati di SQL Express con il driver mssql.If you wish to test your backend locally, we recommend the use of a SQL Express data store and the mssql driver.

  1. Scaricare e installare Microsoft SQL Server 2014 Express.Download and install Microsoft SQL Server 2014 Express. Assicurarsi di installare l'edizione SQL Server 2014 Express with Tools.Ensure you install the SQL Server 2014 Express with Tools edition. A meno che non sia richiesto in modo esplicito il supporto a 64 bit, l'esecuzione della versione a 32 bit richiede una quantità di memoria inferiore.Unless you explicitly require 64-bit support, the 32-bit version consumes less memory when running.
  2. Eseguire Gestione configurazione SQL Server 2014.Run the SQL Server 2014 Configuration Manager.

    1. Espandere il nodo Configurazione di rete SQL Server nel menu ad albero a sinistra.Expand the SQL Server Network Configuration node in the left-hand tree menu.
    2. Fare clic su Protocolli per SQLEXPRESS.Click Protocols for SQLEXPRESS.
    3. Fare clic con il pulsante destro del mouse su TCP/IP e scegliere Abilita.Right-click TCP/IP and select Enable. Fare clic su OK nella finestra di dialogo popup.Click OK in the pop-up dialog.
    4. Fare clic con il pulsante destro del mouse su TCP/IP e scegliere Proprietà.Right-click TCP/IP and select Properties.
    5. Fare clic sulla scheda Indirizzi IP .Click the IP Addresses tab.
    6. Trovare il nodo IPAll .Find the IPAll node. Nel campo Porta TCP immettere 1433.In the TCP Port field, enter 1433.

      ![Configure SQL Express for TCP/IP][3]
      
    7. Fare clic su OK.Click OK. Fare clic su OK nella finestra di dialogo popup.Click OK in the pop-up dialog.
    8. Fare clic su Servizi di SQL Server nel menu ad albero a sinistra.Click SQL Server Services in the left-hand tree menu.
    9. Fare clic con il pulsante destro del mouse su SQL Server (SQLEXPRESS) e scegliere RiavviaRight-click SQL Server (SQLEXPRESS) and select Restart
    10. Chiudere Gestione configurazione SQL Server 2014.Close the SQL Server 2014 Configuration Manager.
  3. Eseguire SQL Server 2014 Management Studio e connettersi all'istanza locale di SQL ExpressRun the SQL Server 2014 Management Studio and connect to your local SQL Express instance

    1. Fare clic con il pulsante destro del mouse sull'istanza in Esplora oggetti e scegliere ProprietàRight-click your instance in the Object Explorer and select Properties
    2. Selezionare la pagina Sicurezza .Select the Security page.
    3. Assicurarsi che l'opzione Modalità di autenticazione di SQL Server e di Windows sia selezionata.Ensure the SQL Server and Windows Authentication mode is selected
    4. Fare clic su OKClick OK

      ![Configure SQL Express Authentication][4]
      
    5. Espandere Sicurezza > Account di accesso .Expand Security > Logins in the Object Explorer
    6. Fare clic con il pulsante destro del mouse su Account di accesso e scegliere Nuovo account di accessoRight-click Logins and select New Login...
    7. Immettere un nome account di accesso.Enter a Login name. Selezionare Autenticazione di SQL Server.Select SQL Server authentication. Immettere una password e quindi immetterla di nuovo in Conferma password.Enter a Password, then enter the same password in Confirm password. La password deve soddisfare i requisiti di complessità di Windows.The password must meet Windows complexity requirements.
    8. Fare clic su OKClick OK

      ![Add a new user to SQL Express][5]
      
    9. Fare clic con il pulsante destro del mouse sul nuovo account di accesso e scegliere ProprietàRight-click your new login and select Properties
    10. Selezionare la pagina Ruoli server .Select the Server Roles page
    11. Selezionare la casella accanto al ruolo server dbcreator .Check the box next to the dbcreator server role
    12. Fare clic su OKClick OK
    13. Chiudere SQL Server 2015 Management Studio.Close the SQL Server 2015 Management Studio

Prendere nota del nome utente e della password selezionati.Ensure you record the username and password you selected. Potrebbe essere necessario assegnare autorizzazioni o ruoli del server aggiuntivi a seconda dei requisiti di database specifici.You may need to assign additional server roles or permissions depending on your specific database requirements.

L'applicazione Node.js legge la variabile di ambiente SQLCONNSTR_MS_TableConnectionString per la stringa di connessione per il database.The Node.js application reads the SQLCONNSTR_MS_TableConnectionString environment variable for the connection string for this database. Questa variabile può essere impostata all'interno dell'ambiente.You can set this variable within your environment. Ad esempio, è possibile usare PowerShell per impostare questa variabile di ambiente:For example, you can use PowerShell to set this environment variable:

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

Accedere al database con una connessione TCP/IP e fornire un nome utente e una password per la connessione.Access the database through a TCP/IP connection and provide a username and password for the connection.

Procedura: Configurare il progetto per lo sviluppo localeHow to: Configure your project for local development

App per dispositivi mobili di Azure legge un file JavaScript denominato azureMobile.js dal file system locale.Azure Mobile Apps reads a JavaScript file called azureMobile.js from the local filesystem. Non usare questo file per configurare Azure Mobile Apps SDK nell'ambiente di produzione. Usare invece Impostazioni app nel Portale di Azure.Do not use this file to configure the Azure Mobile Apps SDK in production - use App Settings within the [Azure portal] instead. Il file azureMobile.js deve esportare un oggetto di configurazione.The azureMobile.js file should export a configuration object. Le impostazioni più comuni sono:The most common settings are:

  • Impostazioni databaseDatabase Settings
  • Impostazioni di registrazione diagnosticaDiagnostic Logging Settings
  • Impostazioni CORS alternativeAlternate CORS Settings

Di seguito è riportato un file azureMobile.js di esempio che implementa le impostazioni del database seguenti:An example azureMobile.js file implementing the preceding database settings follows:

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 file con estensione .gitignore, o altro file IGNORE di controllo del codice sorgente, per evitare che le password vengano archiviate nel cloud.We recommend that you add azureMobile.js to your .gitignore file (or other source code control ignore file) to prevent passwords from being stored in the cloud. Configurare sempre le impostazioni di produzione in Impostazioni app nel Portale di Azure.Always configure production settings in App Settings within the [Azure portal].

Procedura: Configurare le impostazioni dell'app per dispositivi mobiliHow: Configure App Settings for your Mobile App

Quasi tutte le impostazioni nel file azureMobile.js hanno un'impostazione app equivalente nel Portale di Azure.Most settings in the azureMobile.js file have an equivalent App Setting in the [Azure portal]. Usare l'elenco seguente per configurare l'app in Impostazioni app:Use the following list to configure your app in App Settings:

Impostazione appApp Setting azureMobile.jsazureMobile.js Setting DescrizioneDescription Valori validiValid Values
MS_MobileAppNameMS_MobileAppName namename Nome dell'appThe name of the app stringstring
MS_MobileLoggingLevelMS_MobileLoggingLevel logging.levellogging.level Livello log minimo di messaggi da registrareMinimum log level of messages to log error, warning, info, verbose, debug, sillyerror, warning, info, verbose, debug, silly
MS_DebugModeMS_DebugMode debugdebug Abilitare o disabilitare la modalità di debugEnable or Disable debug mode true, falsetrue, false
MS_TableSchemaMS_TableSchema data.schemadata.schema Nome dello schema predefinito per le tabelle SQLDefault schema name for SQL tables string (valore predefinito: dbo)string (default: dbo)
MS_DynamicSchemaMS_DynamicSchema data.dynamicSchemadata.dynamicSchema Abilitare o disabilitare la modalità di debugEnable or Disable debug mode true, falsetrue, false
MS_DisableVersionHeaderMS_DisableVersionHeader version (impostata su undefined)version (set to undefined) Disabilita l'intestazione X-ZUMO-Server-VersionDisables the X-ZUMO-Server-Version header true, falsetrue, false
MS_SkipVersionCheckMS_SkipVersionCheck skipversioncheckskipversioncheck Disabilita il controllo della versione dell'API clientDisables the client API version check true, falsetrue, false

Per definire un'impostazione app:To set an App Setting:

  1. Accedere al Portale di Azure.Log in to the [Azure portal].
  2. Selezionare Tutte le risorse o Servizi app e quindi fare clic sul nome dell'app per dispositivi mobili.Select All resources or App Services then click the name of your Mobile App.
  3. Per impostazione predefinita si apre il pannello Impostazioni.The Settings blade opens by default. In caso contrario fare clic su Impostazioni.If it doesn't, click Settings.
  4. Fare clic su Impostazioni dell'applicazione nel menu GENERALE.Click Application settings in the GENERAL menu.
  5. Scorrere fino alla sezione Impostazioni app.Scroll to the App Settings section.
  6. Se l'impostazione app esiste già, fare clic sul valore dell'impostazione dell'app per modificarlo.If your app setting already exists, click the value of the app setting to edit the value.
  7. Se l'impostazione app non esiste, immettere l'impostazione app nella casella Chiave e il valore nella casella Valore.If your app setting does not exist, enter the App Setting in the Key box and the value in the Value box.
  8. Al termine, fare clic su Salva.Once you are complete, click Save.

Per modificare la maggior parte delle impostazioni dell'app, è necessario riavviare il servizio.Changing most app settings requires a service restart.

Procedura: Usare il database SQL come archivio dati di produzioneHow to: Use SQL Database as your production data store

L'uso del database SQL di Azure come archivio dati è identico in tutti i tipi di applicazione del Servizio app di Azure.Using Azure SQL Database as a data store is identical across all Azure App Service application types. Se non è già stato fatto, seguire questa procedura per creare un back-end dell'app per dispositivi mobili.If you have not done so already, follow these steps to create a Mobile App backend.

  1. Accedere al Portale di Azure.Log in to the [Azure portal].
  2. Nella parte superiore sinistra della finestra fare clic sul pulsante +NUOVO > Web e dispositivi mobili > App per dispositivi mobili e quindi specificare un nome per il back-end dell'app per dispositivi mobili.In the top left of the window, click the +NEW button > Web + Mobile > Mobile App, then provide a name for your Mobile App backend.
  3. Nella casella Gruppo di risorse immettere lo stesso nome dell'app.In the Resource Group box, enter the same name as your app.
  4. Viene selezionato il piano di servizio app predefinito.The Default App Service plan is selected. Per modificare il piano di servizio app, fare clic su Piano di servizio app > + Crea nuovo.If you wish to change your App Service plan, you can do so by clicking the App Service Plan > + Create New. Specificare un nome del nuovo piano del servizio app e selezionare un percorso appropriato.Provide a name of the new App Service plan and select an appropriate location. Fare clic su Piano tariffario e selezionare un piano tariffario appropriato per il servizio.Click the Pricing tier and select an appropriate pricing tier for the service. Selezionare Visualizza tutto per visualizzare altre opzioni sui prezzi, ad esempio Gratuito e Condiviso.Select View all to view more pricing options, such as Free and Shared. Dopo aver scelto il livello di prezzo, fare clic su Seleziona .Once you have selected the pricing tier, click the Select button. Nel pannello Piano di servizio app fare clic su OK.Back in the App Service plan blade, click OK.
  5. Fare clic su Crea.Click Create. L'operazione di provisioning di un back-end dell'app per dispositivi mobili può richiedere alcuni minuti.Provisioning a Mobile App backend can take a couple of minutes. Dopo avere eseguito il provisioning del back-end dell'app per dispositivi mobili, nel portale viene aperto il pannello Impostazioni relativo al back-end dell'app per dispositivi mobili.Once the Mobile App backend is provisioned, the portal opens the Settings blade for the Mobile App backend.

Una volta creato il back-end dell'app per dispositivi mobili, è possibile scegliere se connettere un database SQL esistente o creare un nuovo database SQL.Once the Mobile App backend is created, you can choose to either connect an existing SQL database to your Mobile App backend or create a new SQL database. In questa sezione viene creato un database SQL.In this section, we create a SQL database.

Nota

Se nella stessa posizione del back-end dell'app per dispositivi mobili è già presente un database, è possibile scegliere Usare un database esistente e quindi selezionare questo database.If you already have a database in the same location as the mobile app backend, you can instead choose Use an existing database and then select that database. Non è consigliabile usare un database in una posizione diversa, a causa di latenze più elevate.The use of a database in a different location is not recommended because of higher latencies.

  1. Nel nuovo back-end dell'app per dispositivi mobili fare clic su Impostazioni > App per dispositivi mobili > Dati > +Aggiungi.In the new Mobile App backend, click Settings > Mobile App > Data > +Add.
  2. Nel pannello Aggiungi connessione dati fare clic su Database SQL - Configurare le impostazioni necessarie > Crea un nuovo database.In the Add data connection blade, click SQL Database - Configure required settings > Create a new database. Immettere il nome del nuovo database nel campo Nome .Enter the name of the new database in the Name field.
  3. Fare clic su Server.Click Server. Nel pannello Nuovo server immettere un nome di server univoco nel campo Nome server e specificare un Account di accesso amministratore server e una Password idonei.In the New server blade, enter a unique server name in the Server name field, and provide a suitable Server admin login and Password. Verificare che l'opzione Consenti ai servizi di Azure di accedere al server sia selezionata.Ensure Allow azure services to access server is checked. Fare clic su OK.Click OK.

    Creare un database SQL di Azure

  4. Nel pannello Nuovo database fare clic su OK.On the New database blade, click OK.
  5. Nel pannello Aggiungi connessione dati selezionare Stringa di connessione e immettere l'account di accesso e la password forniti al momento della creazione del database.Back on the Add data connection blade, select Connection string, enter the login and password that you provided when creating the database. Se si usa un database esistente, fornire le credenziali di accesso per il database.If you use an existing database, provide the login credentials for that database. Dopo averli immessi fare clic su OK.Once entered, click OK.
  6. Nel pannello Aggiungi connessione dati fare nuovamente clic su OK per creare il database.Back on the Add data connection blade again, click OK to create the database.

La creazione del database può richiedere alcuni minuti.Creation of the database can take a few minutes. Usare l'area Notifiche per monitorare l'avanzamento della distribuzione.Use the Notifications area to monitor the progress of the deployment. L'avanzamento non viene eseguito se il database non è stato distribuito correttamente.Do not progress until the database has been deployed successfully. Al termine della distribuzione viene creata una stringa di connessione per l'istanza di database SQL nelle impostazioni dell'app del back-end mobile.Once successfully deployed, a Connection String is created for the SQL Database instance in your Mobile backend App Settings. È possibile visualizzare l'impostazione dell'app in Impostazioni > Impostazioni dell'applicazione > Stringhe di connessione.You can see this app setting in the Settings > Application settings > Connection strings.

Procedura: Richiedere l'autenticazione per l'accesso alle tabelleHow to: Require authentication for access to tables

Per usare l'autenticazione del servizio app con l'endpoint delle tabelle, è necessario prima configurare l'autenticazione del servizio app nel Portale di Azure .If you wish to use App Service Authentication with the tables endpoint, you must configure App Service Authentication in the [Azure portal] first. Per altre informazioni sulla configurazione dell'autenticazione in un Servizio app di Azure, vedere la Guida alla configurazione per il provider di identità che si intende usare:For more details about configuring authentication in an Azure App Service, review the Configuration Guide for the identity provider you intend to use:

Ogni tabella ha una proprietà di accesso che può essere usata per controllare l'accesso alla tabella.Each table has an access property that can be used to control access to the table. L'esempio seguente mostra una tabella definita in modo statico in cui è richiesta l'autenticazione.The following sample shows a statically defined table with authentication required.

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

var table = azureMobileApps.table();

// Define the columns within the table
table.columns = {
    "text": "string",
    "complete": "boolean"
};

// Turn off 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:The access property can take one of three values

  • anonymous indica che all'applicazione client è consentito leggere i dati senza autenticazioneanonymous indicates that the client application is allowed to read data without authentication
  • authenticated indica che l'applicazione client deve inviare un token di autenticazione valido con la richiestaauthenticated indicates that the client application must send a valid authentication token with the request
  • disabled indica che la tabella è attualmente disabilitata.disabled indicates that this table is currently disabled

Se la proprietà di accesso non è definita, è consentito l'accesso non autenticato.If the access property is undefined, unauthenticated access is allowed.

Procedura: Usare le attestazioni di autenticazione con le tabelleHow to: Use authentication claims with your tables

È possibile impostare diverse attestazioni richieste quando viene impostata l'autenticazione.You can set up various claims that are requested when authentication is set up. Queste attestazioni non sono in genere disponibili tramite l'oggetto context.user .These claims are not normally available through the context.user object. È possibile tuttavia recuperarle usando il metodo context.user.getIdentity() .However, they can be retrieved using the context.user.getIdentity() method. Il metodo getIdentity() restituisce una promessa che viene risolta in un oggetto.The getIdentity() method returns a Promise that resolves to an object. L'oggetto viene associato a una chiave tramite il metodo di autenticazione (facebook, google, twitter, microsoftaccount o aad).The object is keyed by the authentication method (facebook, google, twitter, microsoftaccount, or aad).

Ad esempio, se si configura l'autenticazione dell'account Microsoft e si richiede l'attestazione degli indirizzi di posta elettronica, è possibile aggiungere l'indirizzo di posta elettronica nel record con il controller tabelle seguente:For example, if you set up Microsoft Account authentication and request the email addresses claim, you can add the email address to the record with the following table controller:

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 belonging 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 record belong to the authenticated user
table.update(queryContextForEmail);

// DELETE - only allow deletion of records belong to the authenticated uer
table.delete(queryContextForEmail);

module.exports = table;

Per visualizzare le attestazioni disponibili, usare un browser Web per visualizzare l'endpoint /.auth/me del sito.To see what claims are available, use a web browser to view the /.auth/me endpoint of your site.

Procedura: Disabilitare l'accesso a specifiche operazioni su tabellaHow to: Disable access to specific table operations

Oltre che sulla tabella, la proprietà di accesso può essere usata per controllare singole operazioni.In addition to appearing on the table, the access property can be used to control individual operations. Sono disponibili quattro operazioni:There are four operations:

  • read è l'operazione RESTful GET nella tabella.read is the RESTful GET operation on the table
  • insert è l'operazione POST RESTful sulla tabellainsert is the RESTful POST operation on the table
  • update è l'operazione PATCH RESTful sulla tabellaupdate is the RESTful PATCH operation on the table
  • delete è l'operazione RESTful DELETE nella tabella.delete is the RESTful DELETE operation on the table

Si supponga, ad esempio, di voler fornire una tabella non autenticata di sola lettura:For example, you may wish to provide a read-only unauthenticated table:

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;

Procedura: Modificare la query usata con le operazioni su tabellaHow to: Adjust the query that is used with table operations

Un requisito comune per le operazioni su tabella è consentire una visualizzazione con restrizioni dei dati.A common requirement for table operations is to provide a restricted view of the data. Ad esempio, è possibile fornire una tabella contrassegnata con l'ID dell'utente autenticato in modo sia possibile solo leggere o aggiornare i propri record.For example, you may provide a table that is tagged with the authenticated user ID such that you can only read or update your own records. La definizione di tabella riportata di seguito fornisce questa funzionalità:The following table definition provides this functionality:

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 avranno una proprietà query modificabile con una clausola where.Operations that normally execute a query have a query property that you can adjust with a where clause. La proprietà query è un oggetto QueryJS usato per convertire una query OData in qualcosa che il back-end dei dati possa elaborare.The query property is a QueryJS object that is used to convert an OData query to something that the data backend can process. Per i casi di semplice uguaglianza, come quello riportato in precedenza, è possibile usare una mappa.For simple equality cases (like the preceding one), a map can be used. È anche possibile aggiungere clausole SQL specifiche:You can also add specific SQL clauses:

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

Procedura: Configurare l'eliminazione temporanea in una tabellaHow to: Configure soft delete on a table

L'eliminazione temporanea non elimina effettivamente i record.Soft Delete does not actually delete records. Al contrario, questi vengono contrassegnati come eliminati nel database impostando la colonna relativa all'eliminazione su true.Instead it marks them as deleted within the database by setting the deleted column to true. L'SDK di App per dispositivi mobili di Azure rimuove automaticamente dai risultati i record con eliminazione temporanea, a meno che l'SDK del client mobile non usi il metodo IncludeDeleted().The Azure Mobile Apps SDK automatically removes soft-deleted records from results unless the Mobile Client SDK uses IncludeDeleted(). Per configurare una tabella per l'eliminazione temporanea, impostare la proprietà softDelete nel file di definizione della tabella:To configure a table for soft delete, set the softDelete property in the table definition file:

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

var table = azureMobileApps.table();

// Define the columns within the table
table.columns = {
    "text": "string",
    "complete": "boolean"
};

// Turn off dynamic schema
table.dynamicSchema = false;

// Turn on Soft Delete
table.softDelete = true;

// Require authentication to access the table
table.access = 'authenticated';

module.exports = table;

È necessario stabilire un meccanismo per l'eliminazione dei record, che sia da un'applicazione client, con un processo Web, tramite Funzioni di Azure o un'API personalizzata.You should establish a mechanism for purging records - either from a client application, via a WebJob, Azure Function or through a custom API.

Procedura: Eseguire il seeding dei dati nel databaseHow to: Seed your database with data

Quando si crea una nuova applicazione, è consigliabile eseguire il seeding dei dati in una tabella.When creating a new application, you may wish to seed a table with data. Questa operazione può essere eseguita all'interno del file JavaScript di definizione della tabella, come illustrato di seguito:This can be done within the table definition JavaScript file as follows:

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 dynamic schema
table.dynamicSchema = false;

// Require authentication to access the table
table.access = 'authenticated';

module.exports = table;

Il seeding dei dati viene eseguito solo quando la tabella viene creata dall'SDK di App per dispositivi mobili di Azure.Seeding of data is only done when the table is created by the Azure Mobile Apps SDK. Se la tabella esiste già all'interno del database, non verranno inseriti dati nella tabella.If the table already exists within the database, no data is injected into the table. Se lo schema dinamico è abilitato, lo schema viene dedotto dai dati di seeding.If dynamic schema is turned on, then the schema is inferred from the seeded data.

È consigliabile chiamare in modo esplicito il metodo tables.initialize() per creare la tabella all'avvio dell'esecuzione del servizio.We recommend that you explicitly call the tables.initialize() method to create the table when the service starts running.

Procedura: Abilitare il supporto di SwaggerHow to: Enable Swagger support

Le app per dispositivi mobili del servizio app di Azure sono fornite con il supporto di Swagger incorporato.Azure App Service Mobile Apps comes with built-in Swagger support. Per abilitare il supporto di Swagger, installare prima di tutto swagger-ui come una dipendenza:To enable Swagger support, first install the swagger-ui as a dependency:

npm install --save swagger-ui

Una volta installato, è possibile abilitare il supporto di Swagger nel costruttore di app per dispositivi mobili di Azure:Once installed, you can enable Swagger support in the Azure Mobile Apps constructor:

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

È consigliabile abilitare il supporto di Swagger solo nelle edizioni di sviluppo.You probably only want to enable Swagger support in development editions. È possibile farlo usando l'impostazione dell'app NODE_ENV :You can do this by utilizing the NODE_ENV app setting:

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

L'endpoint swagger sarà posizionato in http://yoursite.azurewebsites.net/swagger.The swagger endpoint is located at http://yoursite.azurewebsites.net/swagger. È possibile accedere all'interfaccia utente di Swagger tramite l'endpoint /swagger/ui .You can access the Swagger UI via the /swagger/ui endpoint. Se si sceglie di richiedere l'autenticazione a livello dell'intera applicazione., Swagger genera un errore.if you choose to require authentication across your entire application, Swagger produces an error. Per ottenere risultati ottimali, scegliere di consentire le richieste non autenticate tramite le impostazioni di autenticazione/autorizzazione del Servizio app di Azure e quindi controllare l'autenticazione con la proprietà table.access .For best results, choose to allow unauthenticated requests through in the Azure App Service Authentication / Authorization settings, then control authentication using the table.access property.

È anche possibile aggiungere l'opzione Swagger al file azureMobile.js se si vuole supportare Swagger solo quando si sviluppa in locale.You can also add the Swagger option to your azureMobile.js file if you only want Swagger support when developing locally.

Notifiche pushPush notifications

App per dispositivi mobili si integra con Hub di notifica di Azure per consentire l'invio di notifiche push mirate a milioni di dispositivi basati sulle piattaforme principali.Mobile Apps integrates with Azure Notification Hubs to enable you to send targeted push notifications to millions of devices across all major platforms. Con Hub di notifica è possibile inviare notifiche push a dispositivi iOS, Android e Windows.By using Notification Hubs, you can send push notifications to iOS, Android and Windows devices. Per altre informazioni su tutte le operazioni disponibili con Hub di notifica, vedere Panoramica dell'Hub di notifica di Azure.To learn more about all that you can do with Notification Hubs, see Notification Hubs Overview.

Procedura: Inviare notifiche pushHow to: Send push notifications

Il codice seguente illustra come usare l'oggetto push per inviare una notifica push di trasmissione ai dispositivi iOS registrati:The following code shows how to use the push object to send a broadcast push notification to registered iOS devices:

// 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 using APNS.
    context.push.apns.send(null, payload, function (error) {
        if (error) {
            // Do something or log the error.
        }
    });
}

Creando una registrazione push con modello dal client, è possibile inviare un messaggio di push con modello ai dispositivi basati su tutte le piattaforme supportate.By creating a template push registration from the client, you can instead send a template push message to devices on all supported platforms. Il codice seguente illustra come inviare una notifica con modello:The following code shows how to send a template notification:

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

Procedura: Inviare notifiche push agli utenti autenticati tramite tagHow to: Send push notifications to an authenticated user using tags

Se un utente autenticato esegue la registrazione per le notifiche push, viene automaticamente aggiunto un tag con l'ID utente.When an authenticated user registers for push notifications, a user ID tag is automatically added to the registration. Tramite questo tag, è possibile inviare notifiche push a tutti i dispositivi registrati da un utente specifico.By using this tag, you can send push notifications to all devices registered by a specific user. Il codice seguente ottiene il SID dell'utente che esegue la richiesta e invia un modello di notifica push a ogni registrazione del dispositivo per tale utente:The following code gets the SID of user making the request and sends a template push notification to every device registration for that user:

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

Durante la registrazione per le notifiche push da un client autenticato, assicurarsi che l'autenticazione sia stata completata prima di tentare la registrazione.When registering for push notifications from an authenticated client, make sure that authentication is complete before attempting registration.

API personalizzateCustom APIs

Procedura: Definire un'API personalizzataHow to: Define a custom API

Oltre all'API di accesso ai dati attraverso l'endpoint /tables, App per dispositivi mobili di Azure può fornire la copertura per le API personalizzate.In addition to the data access API via the /tables endpoint, Azure Mobile Apps can provide custom API coverage. Le API personalizzate sono definite in modo analogo alle definizioni di tabella e possono accedere alle stesse funzionalità, inclusa l'autenticazione.Custom APIs are defined in a similar way to the table definitions and can access all the same facilities, including authentication.

Per usare l'autenticazione del servizio app con un'API personalizzata, è necessario prima configurare l'autenticazione del servizio app nel Portale di Azure .If you wish to use App Service Authentication with a Custom API, you must configure App Service Authentication in the [Azure portal] first. Per altre informazioni sulla configurazione dell'autenticazione in un Servizio app di Azure, vedere la Guida alla configurazione per il provider di identità che si intende usare:For more details about configuring authentication in an Azure App Service, review the Configuration Guide for the identity provider you intend to use:

Le API personalizzate vengono definite in modo molto simile alle API di tabella.Custom APIs are defined in much the same way as the Tables API.

  1. Creare una directory api .Create an api directory
  2. Creare un file JavaScript di definizione dell'API nella directory api .Create an API definition JavaScript file in the api directory.
  3. Usare il metodo di importazione per importare la directory api .Use the import method to import the api directory.

Di seguito è riportata la definizione dell'API prototipo basata sull'esempio di app di base usato in precedenza.Here is the prototype api definition based on the basic-app sample we used earlier.

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() .Let's take an example API that returns the server date using the Date.now() method. Il file api/date.js è il seguente:Here is the 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.Each parameter is one of the standard RESTful verbs - GET, POST, PATCH, or DELETE. Il metodo è una funzione ExpressJS Middleware standard che invia l'output richiesto.The method is a standard ExpressJS Middleware function that sends the required output.

Procedura: Richiedere l'autenticazione per l'accesso a un'API personalizzataHow to: Require authentication for access to a custom API

L'SDK di App per dispositivi mobili di Azure implementa l'autenticazione nello stesso modo sia per l'endpoint delle tabelle che per le API personalizzate.Azure Mobile Apps SDK implements authentication in the same way for both the tables endpoint and custom APIs. Per aggiungere l'autenticazione all'API sviluppata nella sezione precedente, aggiungere una proprietà access :To add authentication to the API developed in the previous section, add an access property:

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:You can also specify authentication on specific operations:

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 delle tabelle deve essere usato per le API personalizzate che richiedono l'autenticazione.The same token that is used for the tables endpoint must be used for custom APIs requiring authentication.

Procedura: Gestire il caricamento di file di grandi dimensioniHow to: Handle large file uploads

L'SDK delle app per dispositivi mobili di Azure usa il middleware body-parser per accettare e decodificare il contenuto del corpo nell'elemento inviato.Azure Mobile Apps SDK uses the body-parser middleware to accept and decode body content in your submission. È possibile preconfigurare il body-parser per accettare caricamenti di file più grandi:You can pre-configure body-parser to accept larger file uploads:

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,The file is base-64 encoded before transmission. che aumenterà le dimensioni del caricamento effettivo e di cui è quindi necessario tenere conto.This increases the size of the actual upload (and hence the size you must account for).

Procedura: Eseguire istruzioni SQL personalizzateHow to: Execute custom SQL statements

Con Azure Mobile App SDK è possibile accedere all'intero contesto tramite l'oggetto request, consentendo di eseguire facilmente istruzioni SQL con parametri sul provider di dati definito:The Azure Mobile Apps SDK allows access to the entire Context through the request object, allowing you to execute parameterized SQL statements to the defined data provider easily:

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 can be handled by the mssql
        // driver 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, tabelle semplici e API sempliciDebugging, Easy Tables, and Easy APIs

Procedura: Eseguire il debug e diagnosticare e risolvere i problemi di App per dispositivi mobili di AzureHow to: Debug, diagnose, and troubleshoot Azure Mobile apps

Il Servizio app di Azure offre diverse tecniche di debug e risoluzione dei problemi per le applicazioni Node.js.The Azure App Service provides several debugging and troubleshooting techniques for Node.js applications. Per iniziare la risoluzione dei problemi del back-end Node.js Mobile, consultare i seguenti articoli:Refer to the following articles to get started in troubleshooting your Node.js Mobile backend:

Le applicazioni Node.js hanno accesso a un'ampia gamma di strumenti per i log di diagnostica.Node.js applications have access to a wide range of diagnostic log tools. Al suo interno l'SDK di Node.js per App per dispositivi mobili di Azure usa Winston per la registrazione diagnostica.Internally, the Azure Mobile Apps Node.js SDK uses Winston for diagnostic logging. La registrazione viene abilitata automaticamente abilitando la modalità di debug o impostando su true l'impostazione dell'app MS_DebugMode nel Portale di Azure.Logging is automatically enabled by enabling debug mode or by setting the MS_DebugMode app setting to true in the [Azure portal]. I log generati vengono visualizzati tra i log di diagnostica del Portale di Azure.Generated logs appear in the Diagnostic Logs on the [Azure portal].

Procedura: Usare tabelle semplici nel portale di AzureHow to: Work with Easy Tables in the Azure portal

L'impostazione Easy Tables nel portale consente di creare e usare tabelle direttamente nel portale.Easy Tables in the portal let you create and work with tables right in the portal. È possibile caricare il set di dati in Easy Tables in formato CSV.You can upload dataset to Easy Tables in CSV format. Si noti che non è possibile usare nomi di proprietà (nel set di dati CSV) in conflitto con i nomi di proprietà di sistema del back-end di App per dispositivi mobili di Azure.Note that you cannot use properties names (in your CSV dataset) that conflict with system properties names of Azure Mobile Apps backend. I nomi delle proprietà di sistema sono:The system properties names are:

  • createdAtcreatedAt
  • updatedAtupdatedAt
  • deleteddeleted
  • versionversion

Consente anche di modificare le operazioni di tabella usando l'editor del servizio app.You can even edit table operations using the App Service Editor. Quando si fa clic su Tabelle semplici nelle impostazioni del sito di back-end, è possibile aggiungere, modificare o eliminare una tabella.When you click Easy tables in your backend site settings, you can add, modify, or delete a table. È anche possibile visualizzare i dati nella tabella.You can also see data in the table.

Utilizzare Easy Tables

I comandi seguenti sono disponibili sulla barra dei comandi di una tabella:The following commands are available on the command bar for a table:

  • Modifica autorizzazioni : è possibile modificare l'autorizzazione per le operazioni di lettura, inserimento, aggiornamento ed eliminazione di operazioni sulla tabella.Change permissions - modify the permission for read, insert, update and delete operations on the table. Le opzioni consentono di eseguire l'accesso anonimo, richiedere l'autenticazione o disabilitare qualunque tipo di accesso all'operazione.Options are to allow anonymous access, to require authentication, or to disable all access to the operation.
  • Modifica script : il file di script per la tabella viene aperto nell'editor del servizio app.Edit script - the script file for the table is opened in the App Service Editor.
  • Gestisci schema : è possibile aggiungere o eliminare le colonne o modificare l'indice di tabella.Manage schema - add or delete columns or change the table index.
  • Cancella tabella : tronca una tabella esistente eliminando tutte le righe di dati ma lasciando lo schema invariato.Clear table - truncates an existing table be deleting all data rows but leaving the schema unchanged.
  • Elimina righe : è possibile eliminare singole righe di dati.Delete rows - delete individual rows of data.
  • Visualizzare log di streaming : consente di connettersi al servizio di log in streaming del sito.View streaming logs - connects you to the streaming log service for your site.

Procedura: Usare Easy APIs nel portale di AzureHow to: Work with Easy APIs in the Azure portal

L'impostazione Easy APIs nel portale consentono di creare e usare API personalizzate direttamente nel portale.Easy APIs in the portal let you create and work with custom APIs right in the portal. È possibile modificare gli script dell'API usando l'editor del servizio app.You can edit API scripts using the App Service Editor.

Quando si fa clic su API semplici nelle impostazioni del sito di back-end, è possibile aggiungere, modificare o eliminare un endpoint API personalizzato.When you click Easy APIs in your backend site settings, you can add, modify, or delete a custom API endpoint.

Utilizzare Easy APIs

Nel portale è possibile modificare le autorizzazioni di accesso per una determinata azione HTTP, modificare il file di script dell'API nell'editor del servizio app o visualizzare i log in streaming.In the portal, you can change the access permissions for a given HTTP action, edit the API script file in the App Service Editor, or view the streaming logs.

Procedura: Modificare il codice nell'editor del servizio appHow to: Edit code in the App Service Editor

Il portale di Azure consente di modificare i file di script del back-end Node.js nell'editor del servizio app senza dover scaricare il progetto nel computer locale.The Azure portal lets you edit your Node.js backend script files in the App Service Editor without having to download the project to your local computer. Per modificare i file di script nell'editor online:To edit script files in the online editor:

  1. Nel pannello del back-end dell'app per dispositivi mobili fare clic su Tutte le impostazioni > Easy tables o Easy APIs, fare clic su una tabella o un'API e quindi su Modifica script.In your Mobile App backend blade, click All settings > either Easy tables or Easy APIs, click a table or API, then click Edit script. Il file di script viene aperto nell'editor del servizio app.The script file is opened in the App Service Editor.

    Editor del servizio app

  2. Apportare le modifiche al file di codice nell'editor online.Make your changes to the code file in the online editor. Le modifiche vengono salvate automaticamente durante la digitazione.Changes are saved automatically as you type.