Como usar o SDK .js nó para aplicativos móveis do Azure

Artigo
10/23/2023

Este artigo fornece informações detalhadas e exemplos que mostram como trabalhar com um back-end NodeJS para Aplicativos Móveis do Azure.

Introdução

Os Aplicativos Móveis do Azure fornecem a capacidade de adicionar uma API Web de acesso a dados otimizada para dispositivos móveis a um aplicativo Web. O SDK de Aplicativos Móveis do Azure é fornecido para aplicativos Web ASP.NET Framework e Node.js. O SDK fornece 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 permitidos pelo Serviço de Aplicativo do Azure. Esses provedores incluem provedores de identidade social, como Facebook, Twitter, Google e Microsoft, e Microsoft Entra ID para identidade corporativa.

Plataformas suportadas

O SDK .js Nó de Aplicativos Móveis do Azure dá suporte ao Nó 6.x e posterior e foi testado até o Nó 12.x. Outras versões do Node podem funcionar, mas não são suportadas.

O SDK .js Nó de 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 a instâncias locais do SQL Server.
O driver sqlite3 suporta bancos de dados SQLite em uma única instância somente.

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

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

Em uma janela de comando ou PowerShell, crie um diretório para seu projeto:
```
$ mkdir basicapp
```
Execute npm init para inicializar a estrutura do pacote:
```
$ cd basicapp
$ npm init
```
O npm init comando faz um conjunto de perguntas para inicializar o projeto. Veja o exemplo de saída:
Instale as express bibliotecas e azure-mobile-apps a partir do repositório npm:
```
npm install --save express azure-mobile-apps
```

Crie um app.js arquivo 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);

Este aplicativo cria uma API da Web otimizada para dispositivos móveis 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. É adequado para seguir os inícios rápidos da biblioteca do cliente:

Você pode encontrar o código para este aplicativo básico na área de exemplos no GitHub.

Habilitar uma home page para seu aplicativo

Muitas aplicações são uma combinação de aplicações Web e móveis. Você pode usar a estrutura Express para combinar as duas facetas. Às vezes, no entanto, você pode querer implementar apenas uma interface móvel. É útil fornecer uma página inicial para garantir que o serviço do aplicativo esteja instalado e funcionando. Você pode fornecer sua própria página inicial ou habilitar uma página inicial temporária. Para habilitar uma home page temporária, use o seguinte código para instanciar os Aplicativos Móveis do Azure:

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

Se você quiser que essa opção esteja disponível apenas ao desenvolver localmente, você pode adicionar essa configuração ao azureMobile.js arquivo de configuração:

module.exports = {
    homePage: true,
};

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

Operações de tabela

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

Operation	Description
`GET /tables/tablename`	Obtenha todos os registros na tabela.
`GET /tables/tablename/:id`	Obtenha um registro específico na tabela.
`POST /tables/tablename`	Crie um registro na tabela.
`PATCH /tables/tablename/:id`	Atualizar um registro na tabela.
`DELETE /tables/tablename/:id`	Excluir um registro na tabela.

Esta API Web suporta OData v3 e estende o esquema de tabela para suportar a sincronização de dados offline.

Definir tabelas usando um esquema dinâmico

Antes de poder usar uma tabela, você deve 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 com base em solicitações de entrada). Além disso, você pode controlar aspetos específicos da API da Web adicionando código JavaScript à definição.

Como prática recomendada, você deve definir cada tabela em um arquivo JavaScript no tables diretório e, em seguida, usar o tables.import() método para importar as tabelas. Estendendo o exemplo de aplicativo básico, você ajustaria o arquivo .js aplicativo:

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

Defina 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

Você pode definir explicitamente as colunas a serem expostas por meio da API da Web. O SDK do nó azure-mobile-apps.js adiciona automaticamente quaisquer colunas extras necessárias para a sincronização de dados offline à lista fornecida. Por exemplo, os aplicativos cliente de início rápido exigem uma tabela com duas colunas: text (uma cadeia de caracteres) e complete (um booleano). A tabela pode ser definida no arquivo JavaScript de definição de tabela (localizado no tables diretório) da seguinte maneira:

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, também deverá chamar o método para criar o tables.initialize() esquema de banco de dados na inicialização. O tables.initialize() método retorna uma promessa para que o serviço Web não atenda solicitações antes que o banco de dados seja inicializado.

Usar o SQL Server Express como um armazenamento de dados de desenvolvimento em sua máquina local

O SDK .js Nó de Aplicativos Móveis do Azure fornece três opções para fornecer dados prontos para uso:

Use o driver de memória para fornecer um armazenamento de exemplo não persistente.
Use o driver mssql para fornecer um armazenamento de dados do SQL Server Express para desenvolvimento.
Use o driver mssql para fornecer um armazenamento de dados do Banco de Dados SQL do Azure para produção.

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

Gorjeta

O driver de memória não fornece um conjunto completo de recursos para teste. Se você quiser testar seu back-end localmente, recomendamos o uso de um armazenamento de dados do SQL Server Express e do driver mssql.

Baixe e instale o Microsoft SQL Server 2019 Developer.
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 rato em TCP/IP e selecione Ativar. Selecione OK na caixa de diálogo pop-up.
- Selecione Serviços do SQL Server no menu de árvore.
- Clique com o botão direito do mouse em SQL Server (nome da instância) e selecione Reiniciar.
- Feche o Configuration Manager.

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

Certifique-se de que regista o nome de utilizador e a palavra-passe que 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 para a SQLCONNSTR_MS_TableConnectionString cadeia de conexão desse 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;"

Aceda à base de dados através de uma ligação TCP/IP. Forneça um nome de usuário e senha para a conexão.

Configure seu projeto para desenvolvimento local

As Aplicações Móveis do Azure lêem um ficheiro JavaScript chamado azureMobile.js a partir do sistema de ficheiros local. Não use esse arquivo para configurar o SDK de Aplicativos Móveis do Azure em produção. Em vez disso, use as configurações do 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 do banco de dados
Configurações de log de diagnóstico
Configurações alternativas de CORS

Este exemplo do 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 azureMobile.js ao seu .gitignore arquivo (ou outro arquivo de ignorar controle do código-fonte) para impedir que as senhas sejam armazenadas na nuvem.

Definir definições da aplicação para a sua aplicação móvel

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

Definição da aplicação	azureMobile.js configuração	Description	Valores válidos
MS_MobileAppName	nome	Nome do aplicativo	string
MS_MobileLoggingLevel	logging.level	Nível mínimo de log de mensagens a serem registradas	erro, aviso, info, detalhado, depuração, bobo
MS_DebugMode	depurar	Ativa ou desativa o modo de depuração	TRUE, false
MS_TableSchema	data.schema	Nome do esquema padrão para tabelas SQL	string (padrão: dbo)
MS_DynamicSchema	data.dynamicSchema	Ativa ou desativa o modo de depuração	TRUE, false
MS_DisableVersionHeader	versão (definida como indefinida)	Desativa o cabeçalho X-ZUMO-Server-Version	TRUE, false
MS_SkipVersionCheck	skipversioncheck	Desativa a verificação de versão da API do cliente	TRUE, false

A alteração da maioria das configurações do aplicativo requer uma reinicialização do serviço.

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

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

Exigir autenticação para acesso a tabelas

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

Cada tabela tem uma propriedade de acesso que você pode usar para controlar o acesso à tabela. O exemplo a seguir mostra uma tabela definida estaticamente 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 ter um de três valores:

Anonymous indica que o aplicativo cliente tem permissão para ler 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 esta tabela está desativada no momento.

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

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

Você pode configurar várias declarações que são solicitadas quando a autenticação é configurada. Estas declarações não estão normalmente disponíveis através do context.user objeto. No entanto, você pode recuperá-los usando o context.user.getIdentity() método. O getIdentity() método retorna uma promessa que resolve para um objeto. O objeto é chaveado pelo método de autenticação (facebook, , , , microsoftaccountgoogletwitterou ).aad

Nota

Se estiver usando a autenticação da Microsoft via ID do Microsoft Entra, 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 /.auth/me ponto de extremidade do seu site.

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

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

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

Por exemplo, talvez você queira 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 com operações de tabela

Um requisito comum para operações de tabela é fornecer uma visão restrita dos dados. Por exemplo, você pode fornecer uma tabela marcada com o ID de usuário autenticado para que você só possa ler ou atualizar seus próprios registros. A definição de tabela a seguir 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 têm uma propriedade de consulta que você pode ajustar usando uma where cláusula. A propriedade query é um objeto QueryJS usado para converter uma consulta OData em algo que o back-end de dados pode processar. Para casos de igualdade simples (como o anterior), você pode usar um mapa. Você também pode adicionar cláusulas SQL específicas:

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

Configurar uma exclusão suave em uma tabela

Na verdade, uma exclusão suave não exclui registros. Em vez disso, ele os marca como excluídos dentro do banco de dados definindo a coluna excluída como true. O SDK de Aplicativos Móveis do Azure remove automaticamente os registros excluídos por software dos resultados, a menos que o SDK do Cliente Móvel use includeDeleted(). Para configurar uma tabela para uma exclusão suave, defina a softDelete propriedade 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.

Semeie seu banco de dados com dados

Ao criar um novo aplicativo, convém semear uma tabela com dados. Você pode semear dados dentro do arquivo JavaScript de definição de tabela da seguinte maneira:

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 de dados acontece somente quando você usa o SDK de 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 a partir dos dados propagados.

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

Ativar suporte a Swagger

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

npm install --save swagger-ui

Em seguida, você pode habilitar o suporte ao Swagger no construtor de Aplicativos Móveis do Azure:

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

Você provavelmente só deseja habilitar o suporte ao Swagger em edições de desenvolvimento. Você pode habilitar o suporte ao Swagger no desenvolvimento usando a configuração do NODE_ENV aplicativo:

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

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

Você também pode adicionar a opção Swagger ao seu azureMobile.js arquivo se quiser apenas suporte ao Swagger para desenvolvimento local.

APIs Personalizadas

Além da API de Acesso a Dados por meio do ponto de extremidade, os Aplicativos Móveis do /tables Azure podem fornecer cobertura de API personalizada. As APIs personalizadas são definidas de forma semelhante às definições de tabela e podem 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:

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

Aqui está a definição de API de protótipo com base no exemplo de aplicativo básico 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 pegar um exemplo de API que retorna a data do servidor usando o Date.now() método. Aqui está o api/date.js arquivo:

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 RESTful padrão: GET, POST, PATCH ou DELETE. O método é uma função de middleware ExpressJS padrão que envia a saída necessária.

Exigir autenticação para acesso a uma API personalizada

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

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 usado para o tables ponto de extremidade deve ser usado para APIs personalizadas que exigem autenticação.

Lidar com carregamentos de arquivos grandes

O SDK de Aplicativos Móveis do Azure usa o middleware do analisador de corpo para aceitar e decodificar o conteúdo do corpo em seu envio. Você pode pré-configurar o analisador de corpo 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 de Aplicativos Móveis do Azure permite o acesso a todo o contexto por meio do objeto de solicitação. Você pode facilmente executar instruções SQL parametrizadas 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 de Aplicativos Móveis do Azure

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

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