Como usar o SDK do Node.js para os Aplicativos Móveis do Azure

Este artigo oferece informações detalhadas e exemplos que mostram como trabalhar com um back-end Node.js nos Aplicativos Móveis do Azure.

Introdução

Os Aplicativos Móveis do Azure oferecem a capacidade de adicionar uma API Web de acesso a dados otimizada para mobilidade a um aplicativo Web. O SDK dos Aplicativos Móveis do Azure é fornecido para aplicativos Web ASP.NET Framework e Node.js. O SDK oferece as seguintes operações:

• Operações de tabela (ler, inserir, atualizar, excluir) para acesso a dados
• Operações de API personalizadas

Ambas as operações fornecem autenticação em todos os provedores de identidade que o Serviço de Aplicativo do Azure permite. Esses provedores incluem provedores de identidade social, como Facebook, Twitter, Google e Microsoft, e Microsoft Entra ID para identidade corporativa.

Plataformas com Suporte

O SDK do Node.js dos Aplicativos Móveis do Azure dá suporte ao Node 6.x e posteriores e foi testado até o Node 12.x. Outras versões do Node podem funcionar, mas não são têm suporte.

O SDK do Node.js dos Aplicativos Móveis do Azure dá suporte a dois drivers de banco de dados:

• O driver node-mssql dá suporte ao Banco de Dados SQL do Azure e instâncias do SQL Server locais.
• O driver sqlite3 dá suporte a bancos de dados SQLite somente em uma instância única.

Criar um back-end Node básico usando a linha de comando

Todo back-end Node.js dos Aplicativos Móveis do Azure começa como um aplicativo Express. O Express é a estrutura de serviço Web mais popular disponível para Node.js. Você pode criar um aplicativo Express básico da seguinte maneira:

1. Em um comando ou a janela do PowerShell, crie um diretório para seu projeto:

   $ mkdir basicapp
   

2. Execute npm init para inicializar a estrutura do pacote:

   $ cd basicapp
   $ npm init
   

   O comando npm init solicita um conjunto de perguntas para inicializar o projeto. Confira a saída de exemplo:

   

3. Instale as bibliotecas express e azure-mobile-apps do repositório npm:

   npm install --save express azure-mobile-apps
   

4. Crie um arquivo app.js para implementar o servidor móvel básico:

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

Esse aplicativo cria uma API Web otimizada para celular com um único ponto de extremidade, (/tables/TodoItem) que fornece acesso não autenticado a um armazenamento de dados SQL subjacente usando um esquema dinâmico. Ele é adequado para os inícios rápidos da biblioteca de clientes a seguir:

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

Encontre o código desse aplicativo básico na área de exemplos no GitHub.

Habilitar uma home page para o aplicativo

Muitos aplicativos são uma combinação de aplicativos móveis e da Web. Você pode usar a estrutura Express para combinar as duas facetas. No entanto, às vezes você pode querer implementar apenas uma interface móvel. É útil fornecer uma home page para garantir que o serviço de aplicativo esteja em execução. Você pode fornecer sua própria home page ou habilitar uma home page temporária. Para habilitar uma home page temporária, use o seguinte código para criar uma instância dos Aplicativos Móveis do Azure:

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

Se você quer que essa opção esteja disponível apenas durante o desenvolvimento local, adicione esta configuração ao arquivo de configuração azureMobile.js:

module.exports = {
    homePage: true,
};

Você pode adicionar outras configurações ao arquivo azureMobile.js, conforme o necessário.

Operações de tabela

O SDK do servidor do Node.js do azure-mobile-apps fornece mecanismos para expor tabelas de dados armazenadas no Banco de Dados SQL do Azure como uma API Web. Ele fornece cinco operações:

Operação	Descrição
GET /tables/tablename	Obter todos os registros na tabela.
GET /tables/tablename/:id	Obter um registro específico na tabela.
POST /tables/tablename	Criar um registro na tabela.
PATCH /tables/tablename/:id	Atualizar um registro na tabela.
DELETE /tables/tablename/:id	Excluir um registro na tabela.

Essa API Web dá suporte ao OData v3 e estende o esquema de tabela para dar suporte à sincronização de dados offline.

Definir tabelas usando um esquema dinâmico

Antes de poder usar uma tabela, será necessário defini-la. Você pode definir tabelas usando um esquema estático (onde você define as colunas no esquema) ou dinamicamente (onde o SDK controla o esquema baseado em solicitações de entrada). Além disso, é possível controlar aspectos específicos da API Web, adicionando código JavaScript à definição.

Como melhor prática, é necessário definir cada tabela em um arquivo JavaScript no diretório tables e, em seguida, usar o método tables.import() para importar as tabelas. Estendendo o exemplo basic-app, o arquivo app.js seria ajustado:

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

Definir a tabela em. /tables/TodoItem.js:

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

var table = azureMobileApps.table();

// Additional configuration for the table goes here.

module.exports = table;

As tabelas usam um esquema dinâmico por padrão.

Definir tabelas usando um esquema estático

É possível definir explicitamente as colunas que serão expostas usando a API Web. O SDK do Node.js do azure-mobile-apps adiciona automaticamente as colunas extras necessárias à sincronização de dados offline para a lista fornecida por você. Por exemplo, os aplicativos clientes de inicio rápido exigem uma tabela com duas colunas: text (uma cadeia de caracteres) e complete (uma booliana). A tabela pode ser definida no arquivo JavaScript de definição de tabela (localizado no diretório tables), conforme a seguir:

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 você definir tabelas estaticamente, será necessário também chamar o tables.initialize() método para criar o esquema de banco de dados ao inicializar. O tables.initialize() método retorna uma promessa para que o serviço Web não atenda as solicitações antes que o banco de dados seja inicializado.

Usar o SQL Server Express como um armazenamento de dados de desenvolvimento no computador local

O SDK do Node.js dos Aplicativos Móveis do Azure oferece três opções prontas para fornecer dados:

• Usar o driver de memória para fornecer um repositório de exemplo não persistente.
• Usar o driver MSSQL para fornecer um repositório de dados do SQL Server Express para desenvolvimento.
• Usar o driver MSSQL para fornecer um armazenamento de dados do Banco de Dados SQL do Azure para produção.

O SDK do Node.js dos Aplicativos Móveis do Azure usa o pacote mssql do Node.js para estabelecer e usar uma conexão tanto com o SQL Server Express quanto com o Banco de Dados SQL. Este pacote exige que você habilite as conexões TCP na instância do SQL Server Express.

Dica

O driver de memória não fornece um conjunto completo de recursos para teste. Se você quiser testar o back-end local, é recomendável o uso de um armazenamento de dados do SQL Server Express e do driver MSSQL.

1. Baixe e instale o Microsoft SQL Server 2019 Developer.

2. Execute o Configuration Manager:

   • Expanda o nó Configuração de Rede do SQL Server no menu de árvore.
   • Selecione Protocolos para instance-name.
   • Clique com o botão direito do mouse em TCP/IP e escolha Habilitar. Selecione OK caixa de diálogo popup.
   • Selecione Serviços do SQL Server no menu de árvore.
   • Clique com o botão direito do mouse em SQL Server (instance-name) e selecione Reiniciar.
   • Feche o Configuration Manager.

Você também precisará criar um nome de usuário e uma senha que os Aplicativos Móveis do Azure possam usar para se conectar com o banco de dados. Verifique se o usuário criado tem a função de servidor dbcreator. Para obter mais informações de como configurar usuários, confira a Documentação do SQL Server

Certifique-se de registrar o nome de usuário e senha que você selecionou. Talvez seja necessário atribuir mais funções ou permissões de servidor, dependendo dos requisitos do banco de dados.

O aplicativo Node.js lê a variável de ambiente SQLCONNSTR_MS_TableConnectionString para a cadeia de conexão para esse banco de dados. Você pode definir essa variável em seu ambiente. Por exemplo, você pode usar o PowerShell para definir essa variável de ambiente:

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

Acesse o banco de dados por meio de uma conexão TCP/IP. Forneça um nome de usuário e senha para a conexão.

Configurar seu projeto para desenvolvimento local

Os Aplicativos Móveis do Azure leem um arquivo JavaScript chamado azureMobile.js no sistema de arquivos local. Não use esse arquivo para configurar o SDK dos Aplicativos Móveis do Azure em produção. Nesse caso, use as Configurações de aplicativo no portal do Azure.

O arquivo azureMobile.js deve exportar um objeto de configuração. As configurações mais comuns são:

• Configurações de banco de dados
• Configurações de registro em log de diagnóstico
• Configurações de CORS alternativas

Esse exemplo de arquivo azureMobile.js implementa as configurações de banco de dados anteriores:

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

Recomendamos que você adicione o azureMobile.js ao arquivo .gitignore (ou a outro arquivo que ignora o controle do código-fonte) para evitar que as senhas sejam armazenadas na nuvem.

Definir configurações de aplicativo para seu aplicativo móvel

A maioria das configurações no arquivo azureMobile.js tem uma configuração de aplicativo equivalente no portal do Azure. Use a lista a seguir para configurar seu aplicativo nas Configurações de Aplicativo:

Configurações de aplicativo	Configuração azureMobile.js	Descrição	Valores válidos
MS_MobileAppName	name	Nome do aplicativo	string
MS_MobileLoggingLevel	logging.level	Nível de log mínimo das mensagens a serem registradas	erro, aviso, informações, detalhado, depuração, simples
MS_DebugMode	depurar	Habilita ou desabilita o modo de depuração	verdadeiro, falso
MS_TableSchema	data.schema	Nome do esquema padrão para tabelas SQL	cadeia de caracteres (padrão: dbo)
MS_DynamicSchema	data.dynamicSchema	Habilita ou desabilita o modo de depuração	verdadeiro, falso
MS_DisableVersionHeader	versão (definido como indefinido)	Desabilita o cabeçalho X-ZUMO-Server-Version	verdadeiro, falso
MS_SkipVersionCheck	skipversioncheck	Desabilita a verificação de versão de API do cliente	verdadeiro, falso

A alteração da maioria das Configurações do Aplicativo requer o reinício do serviço.

Usar o SQL do Azure como o armazenamento de dados de produção

O uso do Banco de Dados SQL do Azure como armazenamento de dados é idêntico em todos os tipos de aplicativo do Serviço de Aplicativo do Azure. Se você ainda não fez isso, siga estas etapas para criar um back-end do Serviço de Aplicativo do Azure. Crie uma instância SQL do Azure e defina a configuração de aplicativo SQLCONNSTR_MS_TableConnectionString como a cadeia de conexão da instância SQL do Azure que você deseja usar. Verifique se o Serviço de Aplicativo do Azure que está executando o back-end pode se comunicar com a instância SQL do Azure.

Exigir autenticação para acesso às tabelas

Se você quer usar a Autenticação do Serviço de Aplicativo com o ponto de extremidade tables, primeiro configure a Autenticação do Serviço de Aplicativo no portal do Azure. Para obter mais informações, consulte o guia de configuração para o provedor de identidade que você pretende utilizar:

• Configurar a autenticação do Microsoft Entra
• Configurar a autenticação do Facebook
• Configurar a autenticação do Google
• Configurar o Microsoft authentication
• Configurar a autenticação do Twitter

Cada tabela tem uma propriedade de acesso que pode ser utilizada para controlar o acesso à tabela. O exemplo a seguir mostra uma tabela estaticamente definida com autenticação necessária.

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;

A propriedade de acesso pode assumir um dentre três valores:

• anônimo indica que o aplicativo cliente tem permissão para ler os dados sem autenticação.
• autenticado indica que o aplicativo cliente deve enviar um token de autenticação válido com a solicitação.
• desabilitado indica que essa tabela está atualmente desabilitada.

Se a propriedade de acesso estiver indefinida, o acesso não autenticado será permitido.

Usar declarações de autenticação com as tabelas

Você pode configurar várias declarações que são solicitadas durante a configuração da autenticação. Normalmente, essas declarações não estão disponíveis por meio do objeto context.user . No entanto, é possível recuperá-las utilizando o context.user.getIdentity() método. O método getIdentity() retorna uma promessa que resolve um objeto. O objeto é inserido pelo método de autenticação (facebook, google, twitter, microsoftaccount, ou aad).

Observação

Se estiver usando a autenticação da Microsoft por meio do Microsoft Entra ID, o método de autenticação será aad, não microsoftaccount.

Por exemplo, se você configurar a autenticação do Microsoft Entra e solicitar a declaração de endereços de email, poderá adicionar o endereço de email ao registro com o seguinte controlador de tabela:

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

// Create a new table definition.
var table = azureMobileApps.table();

table.columns = {
    "emailAddress": "string",
    "text": "string",
    "complete": "boolean"
};
table.dynamicSchema = false;
table.access = 'authenticated';

/**
* Limit the context query to those records with the authenticated user email address
* @param {Context} context the operation context
* @returns {Promise} context execution Promise
*/
function queryContextForEmail(context) {
    return context.user.getIdentity().then((data) => {
        context.query.where({ emailAddress: data.aad.claims.emailaddress });
        return context.execute();
    });
}

/**
* Adds the email address from the claims to the context item - used for
* insert operations
* @param {Context} context the operation context
* @returns {Promise} context execution Promise
*/
function addEmailToContext(context) {
    return context.user.getIdentity().then((data) => {
        context.item.emailAddress = data.aad.claims.emailaddress;
        return context.execute();
    });
}

// Configure specific code when the client does a request.
// READ: only return records that belong to the authenticated user.
table.read(queryContextForEmail);

// CREATE: add or overwrite the userId based on the authenticated user.
table.insert(addEmailToContext);

// UPDATE: only allow updating of records that belong to the authenticated user.
table.update(queryContextForEmail);

// DELETE: only allow deletion of records that belong to the authenticated user.
table.delete(queryContextForEmail);

module.exports = table;

Para ver quais declarações estão disponíveis, use um navegador da Web para exibir o ponto de extremidade do /.auth/me de seu site.

Desabilitar o acesso a operações de tabela específicas

Além de aparecer na tabela, a propriedade de acesso pode ser usada para controlar operações individuais. Há quatro operações:

• read é a operação RESTful GET na tabela.
• insert é a operação RESTful POST na tabela.
• update é a operação RESTful PATCH na tabela.
• delete é a operação RESTful DELETE na tabela.

Por exemplo, você pode querer fornecer uma tabela não autenticada somente leitura:

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;

Ajustar a consulta usada em operações de tabela

Um requisito comum para operações de tabela é fornecer uma exibição restrita dos dados. Por exemplo, você pode fornecer uma tabela que é marcada com a ID de usuário autenticado, de modo que só possa ler ou atualizar seus próprios registros. A definição da tabela abaixo fornece essa funcionalidade:

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;

As operações que normalmente executam uma consulta possuem uma propriedade de consulta que podem ser ajustadas utilizando uma cláusula where. A propriedade de consulta é um objeto QueryJS usado para converter uma consulta OData em algo que pode ser processado pelo back-end de dados. Para casos de igualdade simples (como mostrado anteriormente), você pode usar um mapa. Você também pode adicionar cláusulas SQL específicas:

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

Configurar a exclusão reversível em uma tabela

A exclusão reversível não exclui registros. Em vez disso, ela os marca como excluídos no banco de dados definindo a coluna excluída como true. O SDK dos Aplicativos Móveis do Azure remove automaticamente os registros com exclusão reversível dos resultados, exceto quando o SDK do Cliente Móvel usa includeDeleted(). Para configurar uma tabela para exclusão reversível, defina a propriedade softDelete no arquivo de definição de tabela:

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;

Estabeleça um mecanismo para excluir registros permanentemente, como um aplicativo cliente, um WebJob, uma função do Azure ou uma API personalizada.

Propagar seu banco de dados com dados

Quando você está criando um novo aplicativo, é possível que você queira propagar uma tabela com dados. Você pode propagar os dados no arquivo JavaScript de definição de tabela da seguinte forma:

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;

A semeadura dos dados ocorre somente quando você usa o SDK dos Aplicativos Móveis do Azure para criar a tabela. Se a tabela já existir no banco de dados, nenhum dado será injetado na tabela. Se o esquema dinâmico estiver ativado, o esquema será inferido dos dados propagados.

Recomendamos que você chame explicitamente o método tables.initialize() para criar a tabela quando o serviço começar a ser executado.

Habilitar o suporte para o Swagger

Os Aplicativos Móveis do Azure vêm com suporte do Swagger interno. Para habilitar o suporte do Swagger, primeiro instale a swagger-ui como uma dependência:

npm install --save swagger-ui

Depois, habilite o suporte do Swagger no construtor dos Aplicativos Móveis do Azure:

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

Provavelmente você quer apenas habilitar o suporte do Swagger em edições de desenvolvimento. Você pode habilitar o suporte do Swagger no desenvolvimento usando a configuração do aplicativo NODE_ENV:

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

O ponto de extremidade swagger está localizado em http://seusite.azurewebsites.net/swagger. Você pode acessar a interface do usuário do Swagger pelo ponto de extremidade /swagger/ui . Se você optar por exigir autenticação em todo o aplicativo, o Swagger produzirá um erro. Para obter melhores resultados, opte por permitir solicitações não autenticadas nas configurações de Autenticação/Autorização do Serviço de Aplicativo do Azure e, então, controle a autenticação usando a propriedade table.access.

Você também pode adicionar a opção do Swagger ao arquivo azureMobile.js para habilitar o suporte do Swagger somente para o desenvolvimento local.

APIs Personalizadas

Além da API de Acesso a Dados por meio do ponto de extremidade /tables, os Aplicativos Móveis do Azure podem oferecer uma cobertura de API personalizada. As APIs personalizadas são definidas de forma semelhante às definições de tabela e pode acessar todos os mesmos recursos, incluindo autenticação.

Definir uma API personalizada

As APIs personalizadas são definidas da mesma forma que a API de tabelas:

1. Crie um diretório api.
2. Crie um arquivo JavaScript de definição de API no diretório api.
3. Use o método de importação para importar o diretório api.

Aqui está a definição de API do protótipo baseada no exemplo basic-app que usamos anteriormente:

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

Vamos tomar como exemplo, uma API que retorna a data do servidor usando o método Date.now(). Veja o arquivo api/date.js:

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

module.exports = api;

Cada parâmetro é um dos verbos padrão RESTful: GET, POST, PATCH ou DELETE. O método é uma função padrão ExpressJS middleware que envia a saída necessária.

Solicitar autenticação para acesso a uma API personalizada

O SDK dos Aplicativos Móveis do Azure implementa a autenticação da mesma forma para o ponto de extremidade tables e para as APIs personalizadas. Para adicionar autenticação à API desenvolvida na seção anterior, adicione uma propriedade access:

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

module.exports = api;

Você também pode especificar a autenticação em operações específicas:

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;

O mesmo token que é usado para o ponto de extremidade tables deve ser utilizado para APIs personalizadas que requerem autenticação.

Manipular transferências de arquivos grandes

O SDK dos Aplicativos Móveis do Azure usa o middleware body-parser para aceitar e decodificar o conteúdo do corpo no envio. Você pode pré-configurar o body-parser para aceitar carregamentos de arquivos maiores:

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

O arquivo é codificado em base 64 antes da transmissão. Essa codificação aumenta o tamanho do upload real (e o tamanho que você deve considerar).

Executar instruções SQL personalizadas

O SDK dos Aplicativos Móveis do Azure permite acesso ao contexto inteiro por meio do objeto de solicitação. Você pode executar instruções SQL parametrizadas com facilidade para o provedor de dados definido:

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

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

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

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

Depuração

Depurar, diagnosticar e solucionar problemas dos Aplicativos Móveis do Azure

O Serviço de Aplicativo do Azure fornece várias técnicas de depuração e de solução de problemas para aplicativos Node.js. Para começar a solução de problemas do back-end Node.js dos Aplicativos Móveis do Azure, confira os seguintes artigos:

• Monitorar o Serviço de Aplicativo do Azure
• Habilitar o registro em log de diagnósticos no Serviço de Aplicativo do Azure
• Solucionar problemas de aplicativos Node no Serviço de Aplicativo do Azure

Os aplicativos Node.js têm acesso a uma ampla gama de ferramentas de log de diagnóstico. Internamente, o SDK do Node.js dos Aplicativos Móveis do Azure usa o [Winston] para o log de diagnóstico. O registro é habilitado automaticamente quando você habilita o modo de depuração ou define a configuração de aplicativo MS_DebugMode como true no portal do Azure. Logs gerados aparecem nos logs de diagnóstico no Portal do Azure.