Come usare Node.js SDK per App per dispositivi mobiliHow to use the Mobile Apps Node.js SDK

Questo articolo fornisce informazioni dettagliate ed esempi sull'uso di un back-end Node.js nella funzionalità App per dispositivi mobili del servizio app di Azure.This article provides detailed information and examples that show how to work with a Node.js back end in the Mobile Apps feature of Azure App Service.

IntroduzioneIntroduction

App per dispositivi mobili consente di aggiungere a un'applicazione Web un'API Web di accesso ai dati ottimizzata per dispositivi mobili.Mobile Apps provides the capability to add a mobile-optimized data access Web API to a web application. Mobile Apps SDK viene fornito per le applicazioni Web Node.js e ASP.NET.The 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,Both operations provide for authentication across all identity providers that Azure App Service allows. inclusi i provider di identità basati su social network, ad esempio Facebook, Twitter, Google e Microsoft nonché Azure Active Directory per l'identità aziendale.These providers include 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.js SDK per App per dispositivi mobili supporta la versione LTS corrente di Node e le versioni successive.The Mobile Apps Node.js SDK supports the current LTS release of Node and later. Al momento della stesura di questo testo, la versione LTS più recente è Node v4.5.0.Currently, the latest LTS version is Node v4.5.0. Altre versioni di Node potrebbero funzionare, ma non sono supportate.Other versions of Node might work but are not supported.

Node.js SDK per App per dispositivi mobili supporta due driver di database:The Mobile Apps Node.js SDK supports two database drivers:

  • Il driver node-mssql supporta il databse SQL Azure e le istanze locali di SQL Server.The node-mssql driver supports Azure SQL Database 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 comandoCreate a basic Node.js back end by using the command line

Ogni back-end Node.js per App per dispositivi mobili viene avviato come applicazione ExpressJS.Every Mobile Apps Node.js back end 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 Web API with a single endpoint (/tables/TodoItem) that provides unauthenticated access to an underlying SQL data store by using a dynamic schema. È adatta per l'avvio rapido delle librerie client seguenti:It is suitable for following the client library quickstarts:

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.

Creare un back-end Node.js usando Visual Studio 2015Create a Node.js back end by using 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 terminato l'installazione, creare un'applicazione Express 4.x:When you finish the installation, create an Express 4.x application:

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

    Nuovo progetto di Visual Studio 2015

  5. Fare clic con il pulsante destro del mouse sul nodo npm e scegliere Installa nuovi pacchetti npm.Right-click the npm node and select Install New npm packages.
  6. Dopo aver creato la prima applicazione Node.js potrebbe essere necessario aggiornare il catalogo npm.You might need to refresh the npm catalog after you create your first Node.js application. Fare clic su Aggiorna, se necessario.Select Refresh if necessary.
  7. Immettere azure-mobile-apps nella casella di ricerca.Enter azure-mobile-apps in the search box. Selezionare il pacchetto azure-mobile-apps 2.0.0 e quindi fare clic su Installa pacchetto.Select the azure-mobile-apps 2.0.0 package, and then select Install Package.

    Installare nuovi pacchetti npm

  8. Selezionare Chiudi.Select Close.
  9. Aprire il file app.js per aggiungere il supporto per Mobile Apps SDK.Open the app.js file to add support for the 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);
    
    // 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.

Creare un back-end Node.js usando il portale di AzureCreate a Node.js back end by using the Azure portal

È possibile creare un back-end di App per dispositivi mobili direttamente nel portale di Azure.You can create a Mobile Apps back end right in the Azure portal. È possibile completare i passaggi seguenti o creare un client e un server seguendo l'esercitazione Creare un'app per dispositivi mobili.You can either complete 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 ed è ideale per progetti di prova.The tutorial contains a simplified version of these instructions and is best for proof-of-concept projects.

  1. Accedere al portale di Azure.Sign in at the Azure portal.
  2. Selezionare +NUOVO > Web e dispositivi mobili > App per dispositivi mobili e quindi specificare un nome per il back-end di App per dispositivi mobili.Select +NEW > Web + Mobile > Mobile App, and then provide a name for your Mobile Apps back end.
  3. Per Gruppo di risorse selezionare un gruppo di risorse esistente o crearne uno nuovo usando lo stesso nome dell'app.For Resource Group, select an existing resource group, or create a new one (by using the same name as your app).
  4. Per Piano di servizio app viene selezionato il piano predefinito nel livello Standard.For 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. Per altre informazioni sui piani di servizio app e su come creare un nuovo piano in un diverso piano tariffario e nella località desiderata, vedere la panoramica approfondita dei piani di servizio app di Azure.For more about App Service 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.

  5. Selezionare Create.Select Create. Questo passaggio crea il back-end di App per dispositivi mobili.This step creates the Mobile Apps back end.

  6. Nel riquadro Impostazioni per il nuovo back-end di App per dispositivi mobili selezionare Avvio rapido > piattaforma app client > Connettere un database.In the Settings pane for the new Mobile Apps back end, select Quick start > your client app platform > Connect a database.

    Selezioni per la connessione di un database

  7. Nel riquadro Aggiungi connessione dati selezionare Database SQL > Crea un nuovo database.In the Add data connection pane, select SQL Database > Create a new database. Immettere il nome del database, scegliere un piano tariffario e quindi selezionare Server.Enter the database name, choose a pricing tier, and then select 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.We don't recommend the use of a database in a different location, due to bandwidth costs and higher latency.

    Selezione di un database

  8. Nel riquadro Nuovo server immettere un nome server univoco nella casella Nome server, specificare un account di accesso e una password e selezionare Consenti ai servizi di Azure di accedere al server e quindi OK.In the New server pane, enter a unique server name in the Server name box, provide a login and password, select Allow Azure services to access server, and select OK. Questo passaggio crea il nuovo database.This step creates the new database.
  9. Nel riquadro Aggiungi connessione dati selezionare Stringa di connessione, immettere i valori di account di accesso e password per il database e selezionare OK.Back in the Add data connection pane, select Connection string, enter the login and password values for your database, and select OK.

    Prima di procedere, attendere alcuni minuti che la distribuzione del database venga completata.Wait a few minutes for the database to be deployed successfully before you proceed.

Nel riquadro Attività iniziali, in Creare un'API di tabella scegliere Node.js come linguaggio back-end.Back in the Get started pane, under Create a table API, choose Node.js as your back-end 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.Select the box for I acknowledge that this will overwrite all site contents, and then select Create TodoItem table.

Scaricare il progetto di codice di avvio rapido del back-end Node.js tramite GitDownload the Node.js back-end quickstart code project by using Git

Quando si crea un back-end Node.js per App per dispositivi mobili usando il pannello Avvio rapido del portale, viene creato e distribuito nel sito un progetto Node.js.When you create a Node.js Mobile Apps back end by using the portal's Quick start pane, a Node.js project is created for you and deployed to your site. Nel portale è possibile aggiungere tabelle e API e modificare i file di codice per il back-end Node.js.In the portal, you can add tables and APIs, and edit code files for the Node.js back end. Si possono anche usare vari strumenti di distribuzione per scaricare il progetto back-end, in modo da poter aggiungere o modificare tabelle e API, quindi ripubblicare il progetto.You can also use various deployment tools to download the back-end project so that you can add or modify tables and APIs, and 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 Installing Git (Installazione di Git) per istruzioni di installazione e distribuzione specifiche per i sistemi operativi.For operating system-specific distributions and installation guidance, see Installing Git.
  2. Vedere Preparare il repository per abilitare il repository Git per il sito di back-end.See Prepare your repository to enable the Git repository for your back-end site. Prendere nota del nome utente e della password della distribuzione.Make a note of the deployment username and password.
  3. Nel riquadro del back-end di App per dispositivi mobili annotare l'impostazione URL clone Git.In the pane for your Mobile Apps back end, make a note of the Git clone URL setting.
  4. Eseguire il comando git clone usando l'URL clone Git.Execute the git clone command by using the Git clone URL. Immettere la password quando richiesto, come nell'esempio seguente:Enter 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 (/todolist nell'esempio precedente) e osservare che sono stati scaricati i file di progetto.Browse to the local directory (/todolist in the preceding example), 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 anche il file todoitem.js nella stessa directory.Also find the todoitem.js file in the same directory. Il file definisce gli script di operazioni CRUD per la tabella.It defines the CRUD operation scripts for the table.

  6. Dopo aver apportato modifiche ai file di progetto, eseguire questi comandi per aggiungere ed eseguire il commit delle modifiche e quindi caricarle nel sito:After you make changes to project files, run the following commands to add, commit, and 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, è prima necessario eseguire il comando git add ..When you add new files to the project, you first need to run 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.

Pubblicare il back-end Node.js in AzurePublish your Node.js back end to Azure

Microsoft Azure offre numerosi meccanismi per la pubblicazione del back-end Node.js per App per dispositivi mobili del servizio di Azure,Microsoft Azure provides many mechanisms for publishing your Mobile Apps Node.js back end 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 mechanisms include deployment tools integrated into Visual Studio, command-line tools, and continuous deployment options based on source control. Per altre informazioni, vedere la Guida alla distribuzione del servizio app di Azure.For more information, see the Azure App Service deployment guide.

Il servizio app di Azure include suggerimenti specifici per le applicazioni Node.js che è consigliabile esaminare prima di pubblicare il back-end:Azure App Service has specific advice for Node.js applications that you should review before you publish the back end:

Abilitare una home page per l'applicazioneEnable a home page for your application

Molte applicazioni sono una combinazione di app Web e per dispositivi mobili.Many applications are a combination of web and mobile apps. È possibile usare il framework ExpressJS per combinare i due aspetti.You can use the ExpressJS framework to combine the two facets. In alcuni casi è tuttavia consigliabile implementare solo un'interfaccia per dispositivi mobili.Sometimes, however, you might want to only implement a mobile interface. È utile fornire una home page per garantire che il servizio app sia in esecuzione.It's useful to provide a home page to ensure that 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 il codice seguente per creare un'istanza di App per dispositivi mobili:To enable a temporary home page, use the following code to instantiate 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 Web API. Offre cinque operazioni:It provides five operations:

OperazioneOperation DESCRIZIONEDescription
GET /tables/tablenameGET /tables/tablename Ottenere tutti i record nella tabella.Get all records in the table.
GET /tables/tablename/:idGET /tables/tablename/:id Ottenere un record specifico nella tabella.Get a specific record in the table.
POST /tables/tablenamePOST /tables/tablename Creare un record nella tabella.Create a record in the table.
PATCH /tables/tablename/:idPATCH /tables/tablename/:id Aggiornare un record nella tabella.Update a record in the table.
DELETE /tables/tablename/:idDELETE /tables/tablename/:id Eliminare un record dalla tabella.Delete a record in the table.

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

Definire le tabelle con uno schema dinamicoDefine tables by using a dynamic schema

Prima di usare una tabella è necessario definirla.Before you can use a table, you must define it. È 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).You can define tables by using a static schema (where you define the columns in the schema) or dynamically (where the SDK controls the schema based on incoming requests). È anche possibile controllare alcuni aspetti specifici dell'API Web aggiungendo codice JavaScript alla definizione.In addition, you can control specific aspects of the Web API by adding JavaScript code to the definition.

Come procedura consigliata, è necessario definire ogni tabella in un file JavaScript nella directory tables, 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, and then use the tables.import() method to import the tables. Estendendo l'esempio di app di base, il file app.js viene modificato come segue:Extending the basic-app sample, you would adjust the app.js file:

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 uno schema dinamico.Tables use a dynamic schema by default. Per disattivare lo schema dinamico a livello globale, impostare su false l'impostazione app MS_DynamicSchema nel portale di Azure.To turn off the dynamic schema globally, set the MS_DynamicSchema app setting to false in 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.

Definire le tabelle con uno schema staticoDefine tables by 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 Web API. Node.js SDK (azure-mobile-apps) aggiunge automaticamente tutte le altre colonne necessarie per la sincronizzazione dei dati offline con l'elenco specificato.The azure-mobile-apps Node.js SDK automatically adds any extra 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).
La tabella può essere specificata nel file JavaScript di definizione della tabella, presente nella directory tables, 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 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.If you define tables statically, 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 is initialized.

Usare SQL Server Express come archivio dati di sviluppo nel computer localeUse SQL Server Express as a development data store on your local machine

Node.js SDK per App per dispositivi mobili offre tre opzioni predefinite per la gestione dei dati:The Mobile Apps Node.js SDK provides three options for serving data out of the box:

  • Usare il driver memory per fornire un archivio di esempio non persistente.Use the memory driver to provide a non-persistent example store.
  • Usare il driver mssql per fornire un archivio dati di SQL Server Express per lo sviluppo.Use the mssql driver to provide a SQL Server Express data store for development.
  • Usare il driver mssql per fornire un archivio dati del database SQL di Azure per la produzione.Use the mssql driver to provide an Azure SQL Database data store for production.

Node.js SDK per App per dispositivi mobili usa il pacchetto mssql per Node.js per stabilire e usare una connessione a SQL Server Express e al database SQL di Azure.The Mobile Apps Node.js SDK uses the mssql Node.js package to establish and use a connection to both SQL Server Express and SQL Database. Per questo pacchetto è necessario abilitare le connessioni TCP nell'istanza di SQL Server Express.This package requires that you enable TCP connections on your SQL Server 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 Server Express con il driver mssql.If you want to test your back end locally, we recommend the use of a SQL Server 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 that 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 SQL Server 2014 Configuration Manager:

    a.a. Espandere il nodo Configurazione di rete SQL Server nel menu ad albero.Expand the SQL Server Network Configuration node in the tree menu.

    b.b. Selezionare Protocolli per SQLEXPRESS.Select Protocols for SQLEXPRESS.

    c.c. Fare clic con il pulsante destro del mouse su TCP/IP e scegliere Abilita.Right-click TCP/IP and select Enable. Selezionare OK nella finestra di dialogo popup.Select OK in the pop-up dialog box.

    d.d. Fare clic con il pulsante destro del mouse su TCP/IP e scegliere Proprietà.Right-click TCP/IP and select Properties.

    e.e. Selezionare la scheda Indirizzi IP.Select the IP Addresses tab.

    f.f. Trovare il nodo IPAll .Find the IPAll node. Nel campo Porta TCP immettere 1433.In the TCP Port field, enter 1433.

    Configurare SQL Server Express per TCP/IP

    g.g. Selezionare OK.Select OK. Selezionare OK nella finestra di dialogo popup.Select OK in the pop-up dialog box.

    h.h. Fare clic su Servizi di SQL Server nel menu ad albero.Select SQL Server Services in the tree menu.

    i.i. Fare clic con il pulsante destro del mouse su SQL Server (SQLEXPRESS) e scegliere RiavviaRight-click SQL Server (SQLEXPRESS) and select Restart.

    j.j. Chiudere Gestione configurazione SQL Server 2014.Close SQL Server 2014 Configuration Manager.

  3. Eseguire SQL Server 2014 Management Studio e connettersi all'istanza locale di SQL Server Express:Run SQL Server 2014 Management Studio and connect to your local SQL Server Express instance:

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

      Configurare l'autenticazione di SQL Server Express

    5. Espandere Sicurezza > Account di accesso in Esplora oggetti.Expand Security > Logins in Object Explorer.
    6. Fare clic con il pulsante destro del mouse su Account di accesso e scegliere Nuovo account accesso.Right-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, and 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. Selezionare OK.Select OK.

      Aggiungere un nuovo utente a SQL Server Express

    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 di controllo accanto al ruolo server dbcreator.Select the check box for the dbcreator server role.
    12. Selezionare OK.Select OK.
    13. Chiudere SQL Server 2015 Management Studio.Close SQL Server 2015 Management Studio.

Prendere nota del nome utente e della password selezionati.Be sure to record the username and password that you selected. Potrebbe essere necessario assegnare autorizzazioni o ruoli del server aggiuntivi a seconda dei requisiti di database specifici.You might need to assign additional server roles or permissions, depending on your 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 nell'ambiente.You can set this variable in 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.Access the database through a TCP/IP connection. Fornire un nome utente e una password per la connessione.Provide a username and password for the connection.

Configurare il progetto per lo sviluppo localeConfigure your project for local development

App per dispositivi mobili legge un file JavaScript denominato azureMobile.js dal file system locale.Mobile Apps reads a JavaScript file called azureMobile.js from the local file system. Non usare questo file per configurare Mobile Apps SDK nell'ambiente di produzione.Do not use this file to configure the Mobile Apps SDK in production. Usare invece Impostazioni app nel portale di Azure.Instead, use App settings in the Azure portal.

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

Questo file azureMobile.js di esempio implementa le impostazioni del database precedenti:This example azureMobile.js file implements the preceding database settings:

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.

Configurare le impostazioni dell'app per dispositivi mobiliConfigure 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 Impostazione in azureMobile.jsazureMobile.js setting DESCRIZIONEDescription Valori validiValid values
MS_MobileAppNameMS_MobileAppName namename Nome dell'appName of the app stringastring
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 Abilita o disabilita la modalità debugEnables or disables 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 Abilita o disabilita la modalità debugEnables or disables 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.Sign in to the Azure portal.
  2. Selezionare Tutte le risorse o Servizi app e quindi selezionare il nome dell'app per dispositivi mobili.Select All resources or App Services, and then select the name of your mobile app.
  3. Per impostazione predefinita si apre il riquadro Impostazioni.The Settings pane opens by default. In caso contrario selezionare Impostazioni.If it doesn't, select Settings.
  4. Nel menu GENERALE selezionare Impostazioni dell'applicazione.On the GENERAL menu, select Application settings.
  5. Scorrere fino alla sezione Impostazioni app.Scroll to the App settings section.
  6. Se l'impostazione app esiste già, selezionare il valore dell'impostazione dell'app per modificarlo.If your app setting already exists, select the value of the app setting to edit the value. 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.
  7. Selezionare Salva.Select Save.

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

Usare il database SQL come archivio dati di produzioneUse 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 di App per dispositivi mobili:If you have not done so already, follow these steps to create a Mobile Apps back end:

  1. Accedere al portale di Azure.Sign in to the Azure portal.
  2. Nella parte superiore sinistra della finestra selezionare +NUOVO > Web e dispositivi mobili > App per dispositivi mobili e quindi specificare un nome per il back-end di App per dispositivi mobili.In the upper left of the window, select the +NEW button > Web + Mobile > Mobile App, and then provide a name for your Mobile Apps back end.
  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:If you want to change your App Service plan:

    a.a. Selezionare Piano di servizio app > +Crea nuovo.Select App Service Plan > +Create New.

    b.b. 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.

    c.c. Selezionare un piano tariffario appropriato per il servizio.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.

    d.d. Fare clic sul pulsante Seleziona.Click the Select button.

    e.e. Nel riquadro Piano di servizio app fare clic su OK.Back in the App Service plan pane, select OK.

  5. Selezionare Create.Select Create.

L'operazione di provisioning di un back-end di App per dispositivi mobili può richiedere alcuni minuti.Provisioning a Mobile Apps back end can take a couple of minutes. Dopo avere eseguito il provisioning del back-end di App per dispositivi mobili, nel portale si apre il riquadro Impostazioni relativo al back-end di App per dispositivi mobili.After the Mobile Apps back end is provisioned, the portal opens the Settings pane for the Mobile Apps back end.

È possibile scegliere se connettere un database SQL esistente al back-end di App per dispositivi mobili o creare un nuovo database SQL.You can choose to either connect an existing SQL database to your Mobile Apps back end 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 di 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 Apps back end, you can instead select Use an existing database and then select that database. Non è consigliabile usare un database in una posizione diversa, a causa di latenze più elevate.We don't recommend the use of a database in a different location because of higher latencies.

  1. Nel nuovo back-end di App per dispositivi mobili selezionare Impostazioni > App per dispositivi mobili > Dati > +Aggiungi.In the new Mobile Apps back end, select Settings > Mobile App > Data > +Add.
  2. Nel riquadro Aggiungi connessione dati selezionare Database SQL - Configura le impostazioni obbligatorie > Crea un nuovo database.In the Add data connection pane, select SQL Database - Configure required settings > Create a new database. Immettere il nome del nuovo database nella casella Nome.Enter the name of the new database in the Name box.
  3. Selezionare Server.Select Server. Nel riquadro Nuovo server immettere un nome di server univoco nella casella Nome server e specificare un account di accesso amministratore server e una password idonei.In the New server pane, enter a unique server name in the Server name box, 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 that Allow azure services to access server is selected. Selezionare OK.Select OK.

    Creare un database SQL di Azure

  4. Nel riquadro Nuovo database selezionare OK.In the New database pane, select OK.
  5. Nel pannello Aggiungi connessione dati selezionare Stringa di connessione e immettere l'account di accesso e la password specificati al momento della creazione del database.Back in the Add data connection pane, select Connection string, and enter the login and password that you provided when you created 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. Selezionare OK.Select OK.
  6. Nel riquadro Aggiungi connessione dati selezionare OK per creare il database.Back in the Add data connection pane again, select 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. Non proseguire finché il database non è stato distribuito correttamente.Do not progress until the database is deployed successfully. Al termine della distribuzione del database viene creata una stringa di connessione per l'istanza di database SQL nelle impostazioni del back-end di App per dispositivi mobili.After the database is deployed, a connection string is created for the SQL Database instance in your Mobile Apps back-end app settings. È possibile visualizzare l'impostazione dell'app in Impostazioni > Impostazioni dell'applicazione > Stringhe di connessione.You can see this app setting in Settings > Application settings > Connection strings.

Richiedere l'autenticazione per l'accesso alle tabelleRequire authentication for access to tables

Per usare l'autenticazione del servizio app con l'endpoint tables, è prima necessario configurare l'autenticazione del servizio app nel portale di Azure.If you want to use App Service Authentication with the tables endpoint, you must configure App Service Authentication in the Azure portal first. Per altre informazioni, vedere la guida alla configurazione del provider di identità che si intende usare:For more information, see the configuration guide for the identity provider that 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 you can use 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 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:The access property can take one of three values:

  • anonymous indica che all'applicazione client è consentito leggere i dati senza autenticazione.anonymous 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 richiesta.authenticated 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.

Usare le attestazioni di autenticazione con le tabelleUse 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. Possono essere tuttavia recuperate usando il metodo context.user.getIdentity().However, you can retrieve them by 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).

Se ad esempio 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 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.To see what claims are available, use a web browser to view the /.auth/me endpoint of your site.

Disabilitare l'accesso a specifiche operazioni su tabellaDisable 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 RESTful POST nella tabella.insert is the RESTful POST operation on the table.
  • update è l'operazione RESTful PATCH nella tabella.update 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 might want 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;

Modificare la query usata con le operazioni su tabellaAdjust 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 can 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 hanno una proprietà query modificabile con una clausola where.Operations that normally run a query have a query property that you can adjust by using a where clause. La proprietà query è un oggetto QueryJS usato per convertire una query OData in un elemento 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 back end 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), you can use a map. È anche possibile aggiungere clausole SQL specifiche:You can also add specific SQL clauses:

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

Configurare l'eliminazione temporanea in una tabellaConfigure a soft delete on a table

L'eliminazione temporanea non elimina effettivamente i record.A 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. Mobile Apps SDK rimuove automaticamente dai risultati i record con eliminazione temporanea, a meno che Mobile Client SDK non usi IncludeDeleted().The 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 a 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 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;

È necessario stabilire un meccanismo per l'eliminazione dei record: un'applicazione client, un processo Web, una funzione di Azure o un'API personalizzata.You should establish a mechanism for deleting records: a client application, a WebJob, an Azure function, or a custom API.

Eseguire il seeding dei dati nel databaseSeed your database with data

Quando si crea una nuova applicazione, è consigliabile eseguire il seeding dei dati in una tabella.When you're creating a new application, you might want to seed a table with data. Questa operazione può essere eseguita nel file JavaScript di definizione della tabella, come illustrato di seguito:You can do this 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 the dynamic schema.
table.dynamicSchema = false;

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

module.exports = table;

Il seeding dei dati viene eseguito solo se è stato usato Mobile Apps SDK per creare la tabella.Seeding of data happens only when you've used the Mobile Apps SDK to create the table. Se la tabella esiste già all'interno del database, non verranno inseriti dati nella tabella.If the table already exists in the database, no data is injected into the table. Se lo schema dinamico è abilitato, lo schema viene dedotto dai dati di seeding.If the dynamic schema is turned on, 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.

Abilitare il supporto di SwaggerEnable Swagger support

App per dispositivi mobili viene fornito con il supporto di Swagger incorporato.Mobile Apps comes with built-in Swagger support. Per abilitare il supporto di Swagger, installare prima di tutto swagger-ui come dipendenza:To enable Swagger support, first install swagger-ui as a dependency:

npm install --save swagger-ui

Sarà quindi possibile abilitare il supporto di Swagger nel costruttore di App per dispositivi mobili:You can then enable Swagger support in the 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. Questa operazione può essere eseguita usando l'impostazione dell'app NODE_ENV:You can do this by using the NODE_ENV app setting:

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

L'endpoint swagger è disponibile 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 gestire l'autenticazione con la proprietà table.access.For best results, choose to allow unauthenticated requests in the Azure App Service Authentication/Authorization settings, and then control authentication by 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 for 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 so you can 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 Hub di notifica di Azure.To learn more about all that you can do with Notification Hubs, see the Notification Hubs overview.

Inviare notifiche pushSend push notifications

Il codice seguente illustra come usare l'oggetto push per inviare una notifica push 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 by 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.
        }
    });
}

Inviare notifiche push agli utenti autenticati tramite tagSend push notifications to an authenticated user by 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 who's 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 you're registering for push notifications from an authenticated client, make sure that authentication is complete before you attempt registration.

API personalizzateCustom APIs

Definire un'API personalizzataDefine a custom API

Oltre all'API di accesso ai dati tramite l'endpoint /tables, App per dispositivi mobili può fornire la copertura per le API personalizzate.In addition to the Data Access API via the /tables endpoint, 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, è prima necessario configurare l'autenticazione del servizio app nel portale di Azure.If you want to use App Service Authentication with a custom API, you must configure App Service Authentication in the Azure portal first. Per altre informazioni, vedere la guida alla configurazione del provider di identità che si intende usare:For more information, see the configuration guide for the identity provider that 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 that 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 by 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.

Richiedere l'autenticazione per l'accesso a un'API personalizzataRequire authentication for access to a custom API

Mobile Apps SDK implementa l'autenticazione nello stesso modo sia per l'endpoint tables che per le API personalizzate.The 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 tables 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 that require authentication.

Gestire il caricamento di file di grandi dimensioniHandle large file uploads

Mobile Apps SDK usa il middleware body-parser per accettare e decodificare il contenuto del corpo nell'elemento inviato.The 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 preconfigure 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 aumenta le dimensioni del caricamento effettivo e di cui è quindi necessario tenere conto.This encoding increases the size of the actual upload (and the size that you must account for).

Eseguire istruzioni SQL personalizzateExecute custom SQL statements

Con Mobile Apps SDK è possibile accedere all'intero contesto tramite l'oggetto request,The Mobile Apps SDK allows access to the entire context through the request object. per eseguire facilmente istruzioni SQL con parametri nel provider di dati definito:You can easily execute parameterized SQL statements to the defined data provider:

var api = {
    get: function (request, response, next) {
        // Check for parameters. If not there, pass on to a later API call.
        if (typeof request.params.completed === 'undefined')
            return next();

        // Define the query. Anything that the mssql
        // driver can handle is allowed.
        var query = {
            sql: 'UPDATE TodoItem SET complete=@completed',
            parameters: [{
                completed: request.params.completed
            }]
        };

        // Execute the query. The context for Mobile Apps is available through
        // request.azureMobile. The data object contains the configured data provider.
        request.azureMobile.data.execute(query)
        .then(function (results) {
            response.json(results);
        });
    }
};

api.get.access = 'authenticated';
module.exports = api;

Debug, tabelle semplici e API sempliciDebugging, Easy Tables, and Easy APIs

Eseguire il debug, la diagnosi e la risoluzione dei problemi di App per dispositivi mobiliDebug, diagnose, and troubleshoot Mobile Apps

Il servizio app di Azure offre diverse tecniche di debug e risoluzione dei problemi per le applicazioni Node.js.Azure App Service provides several debugging and troubleshooting techniques for Node.js applications. Per iniziare la risoluzione dei problemi del back-end Node.js di App per dispositivi mobili, vedere gli articoli seguenti:To get started in troubleshooting your Node.js Mobile Apps back end, see the following articles:

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. Node.js SDK per App per dispositivi mobili usa al suo interno Winston per la registrazione diagnostica.Internally, the Mobile Apps Node.js SDK uses Winston for diagnostic logging. La registrazione viene abilitata automaticamente abilitando la modalità di debug o usando true per l'impostazione MS_DebugMode dell'app nel portale di Azure.Logging is automatically enabled when you enable debug mode or set 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 in the Azure portal.

Usare Tabelle semplici nel portale di AzureWork with Easy Tables in the Azure portal

È possibile usare Tabelle semplici e interagire con le tabelle direttamente nel portale.You can use Easy Tables to 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 nel set di dati CSV non è possibile usare nomi di proprietà in conflitto con i nomi di proprietà di sistema del back-end di App per dispositivi mobili.Note that you cannot use property names (in your CSV dataset) that conflict with system property names of the Mobile Apps back end. I nomi delle proprietà di sistema sono le seguenti:The system property names are:

  • createdAtcreatedAt
  • updatedAtupdatedAt
  • deleteddeleted
  • versionversion

È anche possibile modificare le operazioni di tabella usando l'editor del servizio app.You can even edit table operations by using App Service Editor. Quando si seleziona Tabelle semplici nelle impostazioni del sito di back-end, è possibile aggiungere, modificare o eliminare una tabella.When you select Easy tables in your back-end 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 App Service Editor.
  • Gestisci schema: consente di aggiungere o eliminare le colonne o modificare l'indice della tabella.Manage schema: Add or delete columns, or change the table index.
  • Cancella tabella: consente di troncare una tabella esistente eliminando tutte le righe di dati ma lasciando lo schema invariato.Clear table: Truncate an existing table by deleting all data rows but leaving the schema unchanged.
  • Elimina righe: consente di eliminare singole righe di dati.Delete rows: Delete individual rows of data.
  • Visualizza log in streaming: consente di connettersi al servizio di log in streaming del sito.View streaming logs: Connect to the streaming log service for your site.

Usare API semplici nel portale di AzureWork with Easy APIs in the Azure portal

Con API semplici è possibile creare e usare API personalizzate direttamente nel portale.You can use Easy APIs to create and work with custom APIs right in the portal. È possibile modificare gli script delle API usando l'editor del servizio app.You can edit API scripts by using App Service Editor.

Quando si seleziona API semplici nelle impostazioni del sito di back-end, è possibile aggiungere, modificare o eliminare un endpoint API personalizzato.When you select Easy APIs in your back-end 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 an HTTP action, edit the API script file in App Service Editor, or view the streaming logs.

Modificare il codice nell'editor del servizio appEdit code in 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.By using the Azure portal, you can edit your Node.js back-end script files in 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 riquadro del back-end di App per dispositivi mobili selezionare Tutte le impostazioni > Tabelle semplici o API semplici.In pane for your Mobile Apps back end, select All settings > either Easy tables or Easy APIs. Selezionare una tabella o un'API e quindi Modifica script.Select a table or API, and then select Edit script. Il file di script si apre nell'editor del servizio app.The script file opens in 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.