Exercício - Implementar dados multilocatários

30 minutos

Este exercício leva-o através do processo de:

Instalando o Banco de Dados do Azure para PostgreSQL no modelo de implantação de servidor.
Criação de um banco de dados com dados de inventário de exemplo.
Integração do servidor com o Microsoft Entra ID.
Implementar um aplicativo simples baseado em Node.js que consulta o banco de dados confiando na autenticação do Microsoft Entra.

Nota

Este exercício ilustra uma abordagem simplificada para fornecer suporte a vários locatários emulando a funcionalidade de multilocação do Banco de Dados do Azure para o modelo de implantação de Hiperescala PostgreSQL. Ele também fornece uma abordagem simplificada para implementar a autenticação do Microsoft Entra em cenários multilocatários, confiando na funcionalidade B2B do Microsoft Entra. O Microsoft Entra ID suporta diretamente aplicativos multilocatário, mas sua cobertura detalhada está fora do escopo deste módulo.

Neste exercício, irá:

Crie uma instância do Banco de Dados do Azure para o servidor PostgreSQL.
Conecte-se ao Banco de Dados do Azure para servidor PostgreSQL.
Crie um banco de dados e tabelas de exemplo.
Integre o Banco de Dados do Azure para o servidor PostgreSQL com o Microsoft Entra ID.
Registe uma aplicação com o Microsoft Entra ID.
Implemente um aplicativo simples e integrado baseado em Node.js do Microsoft Entra.
Valide a funcionalidade do aplicativo baseado em Node.js.

Pré-requisitos

Para realizar este exercício, você precisará:

Para ter concluído o exercício : Configure o Microsoft Entra ID na sua subscrição do Azure.
Uma conta Microsoft ou uma conta Microsoft Entra com a função de Administrador Global no inquilino do Microsoft Entra associada à subscrição do Azure e com a função de Proprietário ou Colaborador na subscrição do Azure.

Aviso

Use um ambiente de teste porque os exercícios neste módulo executam operações confidenciais que exigem privilégios administrativos elevados.

Criar uma instância do Banco de Dados do Azure para o servidor PostgreSQL

Você começará criando uma instância do Banco de Dados do Azure para o servidor PostgreSQL:

Se necessário, inicie um navegador da Web, navegue até o portal do Azure e entre para acessar a assinatura do Azure que você usará neste módulo.
Use a caixa de texto Pesquisar recursos, serviços e documentos no início da página do portal do Azure para pesquisar o Banco de Dados do Azure para PostgreSQL e, na lista de resultados, na seção Serviços, selecione Banco de Dados do Azure para PostgreSQL.
Na folha Banco de Dados do Azure para servidores PostgreSQL, selecione + Criar.
Na folha Selecionar opção de implantação do Banco de Dados do Azure para PostgreSQL, no bloco Banco de Dados do Azure para PostgreSQL, para Tipo de recurso, selecione Servidor único.
Selecione Criar.

Na guia Noções básicas da folha Servidor único, defina as seguintes configurações e selecione Revisar + criar, deixando todas as outras configurações com seus valores padrão:

Definição	Configuração
Subscrição	Selecione o nome da assinatura do Azure que você usará neste módulo.
Grupo de recursos	Crie um novo grupo de recursos chamado postgresql-db-RG.
Nome do servidor	Insira um nome exclusivo que consista em letras minúsculas, dígitos ou traços e comece com uma letra.
Data source	Selecione Nenhuma.
Location	Selecione a região do Azure mais próxima do local do seu ambiente de laboratório onde você pode criar o Banco de Dados do Azure para instâncias do PostgreSQL.
Versão	Selecione 11.
Computação + armazenamento	Selecione o link Configurar servidor . Na folha Configurar, selecione Básico, defina o valor vCore como 1 e Armazenamento como 5 GB e selecione OK.
Nome de utilizador de administrador	Digite estudante.
Palavra-passe	Insira um `<password>`arquivo .

Captura de ecrã do separador Noções básicas da folha do servidor no portal do Azure.

Na guia Revisão + criação da folha Servidor único, selecione Criar.
Aguarde a conclusão do provisionamento. Isto pode demorar cerca de cinco minutos.

Nota

O processo de provisionamento cria automaticamente um banco de dados chamado postgres no servidor de destino.

Conectar-se ao Banco de Dados do Azure para servidor PostgreSQL

Com o Banco de Dados do Azure para servidor PostgreSQL provisionado, você se conectará a ele usando a ferramenta psql .

Na folha Microsoft.PostgreSQLServer.createPostgreSqlServer Overview (Visão geral do Microsoft.PostgreSQLServer.createPostgreSqlServer), selecione Ir para o recurso.
Na folha Implantação, no menu vertical, na seção Configurações, selecione Segurança da conexão.
Na folha Segurança da conexão , defina Permitir acesso aos serviços do Azure como Sim, selecione + Adicionar IP do cliente, defina Impor conexão SSL como DESABILITADO e selecione Salvar.

Nota

Essas configurações permitirão a conectividade com o banco de dados do seu computador e de aplicativos em execução no Azure.

Nota

A desativação da aplicação SSL destina-se a simplificar os exercícios subsequentes. Em geral, você deve manter essa configuração ativada.
Na janela do navegador que exibe o portal do Azure com a folha Implantação , no menu vertical, selecione Visão geral.
Na seção Essenciais, identifique as entradas ao lado dos rótulos Nome do servidor e Nome de usuário Admin e registre seus valores.

Nota

Observe que o nome de usuário inclui o @ símbolo seguido pelo nome do servidor especificado na tarefa anterior.
Na janela do navegador que exibe o portal do Azure com a folha de servidor único do Banco de Dados do Azure para PostgreSQL, no menu vertical, na seção Configurações , selecione Cadeias de conexão.
Na lista de cadeias de conexão, copie o valor da cadeia de conexão psql e registre-o, para que você possa usá-lo posteriormente neste exercício.

Nota

A cadeia de conexão tem a seguinte sintaxe, onde o espaço reservado <server_name> representa o nome do servidor identificado anteriormente nesta tarefa:
```
psql "host=<server_name>.postgres.database.azure.com port=5432 dbname={your_database} user=student@<server_name> password={your_password} sslmode=require"
```
No portal do Azure, abra uma sessão Bash do Cloud Shell selecionando seu ícone na barra de ferramentas ao lado da caixa de texto de pesquisa.
Na sessão Bash no painel do Cloud Shell, cole o valor da cadeia de conexão psql da área de transferência, modifique-a para que corresponda ao comando a seguir e execute-a para se conectar ao banco de dados postgres hospedado na instância de servidor recém-implantada do Banco de Dados do Azure para PostgreSQL. O valor do espaço reservado já estará incluído na cadeia de <server_name> conexão colada da área de transferência:
```
psql "host=<server_name>.postgres.database.azure.com port=5432 dbname=postgres user=student@<server_name>.postgres.database.azure.com password=<enter your password> sslmode=require"
```
Nota

Quando você se conectar com êxito, o prompt será apresentado postgres=> .

Criar um banco de dados e tabelas de exemplo

No painel Cloud Shell, no postgres=> prompt, execute o seguinte comando para criar um novo banco de dados chamado cnamtinventory:
```
CREATE DATABASE cnamtinventory;
```
Execute o seguinte comando para alternar a conexão com o banco de dados recém-criado:
```
\c cnamtinventory
```

Execute o seguinte comando para criar uma tabela de locatários:

CREATE TABLE tenants (
  id bigserial PRIMARY KEY,
  name text NOT NULL,
  created_at TIMESTAMP DEFAULT NOW()::date,
  updated_at TIMESTAMP DEFAULT NOW()::date
);

Execute o seguinte comando para criar uma tabela de inventário:

CREATE TABLE inventory (
id bigserial,
tenant_id bigint REFERENCES tenants (id),
name VARCHAR(50),
quantity INTEGER,
    date DATE NOT NULL DEFAULT NOW()::date,
    created_at TIMESTAMP DEFAULT NOW()::date,
    updated_at TIMESTAMP DEFAULT NOW()::date,
    PRIMARY KEY (tenant_id, id, date)
) PARTITION BY RANGE (date);

CREATE TABLE inventory_default PARTITION OF inventory DEFAULT;

Nota

Os dados são particionados com base no valor da coluna de data.

Execute o seguinte comando para verificar se a tabela foi criada com êxito:
```
\dt
```

Execute o seguinte comando para carregar dados de exemplo na tabela de locatários:

INSERT INTO tenants (id, name) VALUES (1, 'adatum');
INSERT INTO tenants (id, name) VALUES (2, 'contoso');

Execute o seguinte comando para carregar dados de exemplo na tabela de inventário:

INSERT INTO inventory (id, tenant_id, name, quantity) VALUES (1, 1, 'yogurt', 200);
INSERT INTO inventory (id, tenant_id, name, quantity) VALUES (2, 1, 'milk', 100);
INSERT INTO inventory (id, tenant_id, name, quantity) VALUES (1, 2, 'yogurt', 20);
INSERT INTO inventory (id, tenant_id, name, quantity) VALUES (2, 2, 'milk', 10);

Execute o seguinte comando para verificar se a tabela de inventário contém os dados inseridos:
```
SELECT * FROM inventory;
```
Feche o painel do Cloud Shell .

Integrar o Banco de Dados do Azure para o servidor PostgreSQL com a ID do Microsoft Entra

Para integrar a instância do servidor do Banco de Dados do Azure para PostgreSQL com a ID do Microsoft Entra, você deve fornecer uma conta de usuário do Microsoft Entra como o administrador designado do Ative Directory do servidor. Você usará para este fim a conta de usuário adatumadmin1 que você criou na tarefa anterior. Você precisa entrar no servidor usando essa conta de usuário. Nesse ponto, você poderá criar usuários de banco de dados baseados em ID do Microsoft Entra e atribuir a eles funções de banco de dados. Você usará para os objetos adatumuser1, adatumgroup1 e contosouser1 Microsoft Entra criados no exercício anterior.

Na janela do navegador que exibe o portal do Azure com a folha do servidor Banco de Dados do Azure para PostgreSQL, no menu vertical, na seção Configurações , selecione Administrador do Ative Directory e, na barra de ferramentas, selecione Definir administrador.
Na folha de administração do Ative Directory, na lista de contas de usuário do Microsoft Entra, selecione a conta de usuário adatumadmin1 que você criou no exercício anterior, selecione Selecionar e, em seguida, selecione Salvar.
Abra outra janela do navegador da Web no modo de navegação anônima/InPrivate, navegue até o portal do Azure e entre usando a conta de usuário adatumadmin1 com a senha criada no exercício anterior.
No portal do Azure, abra o Cloud Shell selecionando seu ícone na barra de ferramentas ao lado da caixa de texto de pesquisa.
Quando lhe for pedido para selecionar Bash ou PowerShell, selecione Bash e, em seguida, quando lhe for apresentada a mensagem Não tem armazenamento montado, selecione Criar armazenamento.
Na sessão Bash no painel Cloud Shell, execute os seguintes comandos para recuperar e exibir um token de acesso do Microsoft Entra necessário para acessar o Banco de Dados do Azure para PostgreSQL:
```
FULL_TOKEN=$(az account get-access-token --resource-type oss-rdbms)
echo $FULL_TOKEN
```
Nota

O comando gera uma saída que inclui um token codificado em Base 64, que identifica o usuário autenticado no recurso Banco de Dados do Azure para PostgreSQL.

A saída usa o seguinte formato:
```
{
  "accessToken": "<placeholder for token value>",
  "expiresOn": "2021-05-21 18:22:44.000000",
  "subscription": "cccc2c2c-dd3d-ee4e-ff5f-aaaaaa6a6a6a",
  "tenant": "eeeeffff-4444-aaaa-5555-bbbb6666cccc",
  "tokenType": "Bearer"
}
```
Execute o seguinte comando para definir o valor da variável PGPASSWORD para o valor do token de acesso da saída do comando executado na etapa anterior:
```
export PGPASSWORD=$(echo $FULL_TOKEN | jq -r '.accessToken')
```
Execute o seguinte comando para se conectar ao banco de dados cnamtinventory usando a ferramenta psql e usando a autenticação do Microsoft Entra (substitua o espaço reservado <server_name> pelo nome do servidor identificado anteriormente neste exercício):
```
DOMAIN_NAME=$(az rest --method GET --url 'https://management.azure.com/tenants?api-version=2020-01-01' --query "value[0].defaultDomain" -o tsv)
psql "host=<server_name>.postgres.database.azure.com user=adatumadmin1@$DOMAIN_NAME@<server_name> dbname=cnamtinventory sslmode=require"
```
Nota

Quando você se conectar com êxito, o prompt deverá ser apresentado cnamtinventory=> .
cnamtinventory=> No prompt, execute o seguinte comando para criar uma função de banco de dados correspondente ao grupo adatumgroup1 Microsoft Entra criado no exercício anterior:
```
CREATE ROLE "adatumgroup1" WITH LOGIN IN ROLE azure_ad_user;
```
Execute o seguinte comando para verificar se as funções foram criadas com êxito:
```
SELECT rolname FROM pg_roles;
```
Execute o seguinte comando para conceder as permissões SELECT na tabela de inventário ao adatumgroup1 criado no exercício anterior:
```
GRANT SELECT ON inventory TO adatumgroup1;
```
Saia como a conta de usuário adatumadmin1 e feche a janela do navegador da Web do modo de navegação anônima/InPrivate.

Registar uma aplicação com o Microsoft Entra ID

Para implementar um aplicativo baseado em Node.js de exemplo que usa a autenticação do Microsoft Entra para acessar um banco de dados do Azure Database for PostgreSQL, você deve criar um objeto de aplicativo Microsoft Entra e a entidade de segurança correspondente. Isso permitirá que o aplicativo baseado em Node.js represente usuários do Microsoft Entra ao acessar objetos de banco de dados.

No portal do Azure, use a caixa de texto Pesquisar recursos, serviços e documentos para pesquisar ID do Microsoft Entra e, na lista de resultados, selecione ID do Microsoft Entra.
Na folha Microsoft Entra, no menu vertical, na seção Gerenciar , selecione Registros de aplicativos.
Na folha Registos da aplicação, selecione + Novo registo.
Na folha Registrar um aplicativo, na caixa de texto Nome, digite can-app. Na seção Tipos de conta suportados, verifique se a opção Contas somente neste diretório organizacional (Somente diretório padrão - Locatário único) está selecionada. Na seção Redirecionar URI (opcional), defina a entrada da Web como http://localhost:8080/redirecte selecione Registrar.

Nota

Você tem a opção de configurar o suporte multilocatário para seus aplicativos registrados do Microsoft Entra. No entanto, a cobertura detalhada desta abordagem está fora do âmbito deste módulo.

Nota

Depois de implantar seu aplicativo, você precisará modificar o valor de URI de redirecionamento (opcional) para refletir sua URL real.
Na folha can-app, revise as configurações resultantes e registre os valores da ID do aplicativo (cliente) e das propriedades da ID do diretório (locatário).
Na folha can-app, na seção Gerenciar, selecione Certificados & segredos e selecione + Novo segredo do cliente.
Na folha Adicionar um segredo do cliente, na caixa de texto Descrição, digite can-secret-0. Deixe a entrada da lista suspensa Expira com seu valor padrão e selecione Adicionar.
Voltar ao can-app | Folha Certificados & segredos , copie o valor do segredo recém-gerado.

Nota

Certifique-se de copiar o valor do segredo antes de navegar para fora desta lâmina, porque nesse ponto, você não será mais capaz de recuperá-lo. Se isso acontecer, crie outro segredo.
No can-app | Folha Certificados & segredos, no menu vertical, na seção Gerenciar, selecione Permissões de API.
No can-app | Folha de permissões de API, selecione + Adicionar uma permissão, na folha Solicitar permissão de API, selecione a guia APIs que minha organização usa, na caixa de texto de pesquisa, digite Banco de Dados OSSRDBMS do Azure e, na lista de resultados, selecione Banco de Dados OSSRDBMS do Azure.
Na folha Solicitar permissão da API, selecione Permissões delegadas, marque a caixa de seleção user_impersonation e selecione Adicionar permissões.
Voltar ao can-app | Folha Permissões da API, selecione Conceder consentimento de administrador para o Diretório Padrão e, quando for solicitada a confirmação, selecione Sim.
No can-app | Folha de permissões da API, verifique se as permissões foram concedidas.

Implemente um aplicativo simples e integrado baseado em Node.js do Microsoft Entra

Com a aplicação registada no inquilino do Microsoft Entra, pode agora prosseguir com a sua implementação.

No portal do Azure, inicie uma sessão Bash no Cloud Shell selecionando seu ícone na barra de ferramentas ao lado da caixa de texto de pesquisa.
Na sessão Bash no painel Cloud Shell , execute os seguintes comandos para inicializar um projeto Node.js em um novo diretório:
```
mkdir -p cna-aadexpress && cd cna-aadexpress
npm init -y
```
Execute os seguintes comandos para adicionar os pacotes necessários à dependência do projeto:
```
npm install express
npm install pg
npm install @azure/msal-node
```
Execute o seguinte comando para criar um arquivo chamado index.js na raiz do projeto:
```
touch ./index.js
```

Use o nano editor para abrir o arquivo index.js e adicionar o seguinte conteúdo. Você criará um nome de aplicativo posteriormente nesta unidade para substituir o espaço reservado <webapp_name>. Substitua <client_id>, <tenant_id>, <client_secret>e <server_name> (excluindo o sufixo .postgres.database.azure.com ) por seus valores reais registrados anteriormente neste exercício:

Nota

Os espaços reservados <client_id> e <tenant_id> correspondem às propriedades ID do aplicativo (cliente) e ID do diretório (locatário) mencionadas anteriormente neste exercício.

// Import dependencies
const express = require("express");
const msal = require('@azure/msal-node');
const pg = require('pg');
const port = process.env.PORT || 8080
// Initialize express
const app = express();
app.use(express.json());
app.listen(port, () => console.log(`Sample app is listening on port ${port}!`))

// Authentication parameters
const config = {
auth: {
        clientId: "<client_id>",
        authority: "https://login.microsoftonline.com/<tenant_id>",
        clientSecret: "<client_secret>"
},
system: {
    loggerOptions: {
        loggerCallback(loglevel, message, containsPii) {
        console.log(message);
        },
    piiLoggingEnabled: false,
    logLevel: msal.LogLevel.Verbose,
    }
    }
};

var outputrows = ""

// Initialize MSAL Node object using authentication parameters
const cca = new msal.ConfidentialClientApplication(config);

app.get('/auth', (req, res) => {

redirectUri = req.hostname.toLowerCase()=="localhost" ? "http://localhost:8080/redirect" : "https://<webapp_name>.azurewebsites.net/redirect";

// Construct a request object for auth code
const authCodeUrlParameters = {
    scopes: ["https://ossrdbms-aad.database.windows.net/user_impersonation"],
    redirectUri: redirectUri,
};

// Request auth code, then redirect
cca.getAuthCodeUrl(authCodeUrlParameters)
    .then((response) => {
        res.redirect(response);
    }).catch((error) => res.send(error));
});

app.get('/redirect', (req, res) => {
redirectUri = req.hostname.toLowerCase()=="localhost" ? "http://localhost:8080/redirect" : "https://<webapp_name>.azurewebsites.net/redirect";

// Use the auth code in redirect request to construct a token request object
const tokenRequest = {
    code: req.query.code,
    scopes: ["https://ossrdbms-aad.database.windows.net/user_impersonation"],
    redirectUri: redirectUri,
};

// Exchange the auth code for tokens
cca.acquireTokenByCode(tokenRequest)
.then((response) => {
    //res.send(response);

    var username = 'adatumgroup1';
    var databasename = 'cnamtinventory';
    var servername = '<server_name>';
    var tablename = 'inventory';

    process.env.PGPASSWORD = response.accessToken;
    const connectionString =
        `postgres://${username}@${servername}@${servername}.postgres.database.azure.com:5432/${databasename}?ssl=true`;

    res.write(connectionString + "\n\n");
    res.write(response.accessToken + "\n\n");

    const client = new pg.Client(connectionString);
    client.connect(err => {
        if (err) throw err;
        else {
            queryDatabase(response.account.name);
        }
    });

    function queryDatabase(tenant_id) {
        console.log(`Running query to PostgreSQL server: ${servername}`);
        switch (tenant_id) {
            case "adatumuser1":
                id = "1";
                break;
            case "contosouser1":
                id = "2";
                break;
        }
        const query = `SELECT * FROM ${tablename} WHERE tenant_id = ${id};`;
        client.query(query)
        .then(qresponse => {
            const rows = qresponse.rows;
            rows.map(row => {
                var singlerow = `${JSON.stringify(row)}`;
                console.log(singlerow);
                outputrows += singlerow + "\n";
            });
            res.write(outputrows);
            res.end();
            process.exit();
        })
        .catch(err => {
             console.log(err);
        });
    }
  }).catch((error) => res.write(error));
});

Nota

Um aplicativo registrado multilocatário do Microsoft Entra usa a URL authority: "https://login.microsoftonline.com/common"de autoridade genérica, mas, no seu caso, você precisa usar uma URL de locatário único que inclua sua ID de locatário.

Nota

Lembre-se de que, depois de implantar o aplicativo, você precisará substituir o valor de URL de REDIRECIONAMENTO por sua URL de redirecionamento real.

Use o nano editor para editar o arquivo package.json na raiz do projeto e substituí-lo pelo seguinte conteúdo:

{
  "name": "node-express",
  "version": "1.0.0",
  "description": "Node.js express sample",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@azure/msal-node": "^1.1.0",
    "body-parser": "^1.19.0",
    "express": "^4.17.1",
    "http": "0.0.0",
    "morgan": "^1.10.0",
    "pg": "^8.6.0"
  }
}

Validar a funcionalidade do aplicativo baseado em Node.js

Você finalmente está pronto para testar a funcionalidade do seu aplicativo Web. Embora você possa conteinerizá-lo, por uma questão de simplicidade, você o implantará em um Serviço de Aplicativo do Azure. Isso fornecerá uma maneira rápida de validar sua funcionalidade e garantir que a conteinerização seja uma opção viável.

Na sessão Bash no painel Cloud Shell , execute os seguintes comandos para criar um grupo de recursos que hospedará o aplicativo Web do Azure, no qual você implantará o aplicativo Node.js Express:
```
RG1NAME=postgresql-db-RG
LOCATION=$(az group show --resource-group $RG1NAME --query location --output tsv)
RG2NAME=cna-aadexpress-RG
az group create --name $RG2NAME --location $LOCATION
```
Execute os seguintes comandos para criar um plano do Serviço de Aplicativo do Azure de camada gratuita que hospedará o novo aplicativo Web do Azure:
```
SPNAME=aadexpress-sp
az appservice plan create --name $SPNAME --resource-group $RG2NAME --sku F1 --is-linux
```

Execute os seguintes comandos para criar o novo aplicativo Web do Azure baseado em Node.js:

WEBAPPNAME=aadexpress$RANDOM$RANDOM
az webapp create --name $WEBAPPNAME --resource-group $RG2NAME --plan $SPNAME --runtime "NODE|16-lts"

Execute os seguintes comandos para identificar o nome do aplicativo Web:
```
echo $WEBAPPNAME
```
Use o nano editor para abrir o arquivo index.js , substituir dois <webapp_name> espaços reservados pelo nome que você identificou na etapa anterior, salvar as alterações e fechar o arquivo.

Nota

Certifique-se de substituir ambos os <webapp_name> espaços reservados.
Abra outra guia na janela do navegador da Web exibindo o portal do Azure, navegue até o portal do Azure e, se solicitado, entre para acessar a assinatura do Azure que você usará neste módulo.
No portal do Azure, use a caixa de texto Pesquisar recursos, serviços e documentos para pesquisar ID do Microsoft Entra e , na lista de resultados, selecione ID do Microsoft Entra.
Na folha Microsoft Entra, navegue até a folha Registros de aplicativos, selecione a entrada can-app , no menu vertical, na seção Gerenciar , selecione Autenticação.
No can-app | Folha de autenticação, modifique o valor do URI de redirecionamento para corresponder à entrada atualizada no arquivo de index.js e salve a alteração.
Volte para a guia do navegador da Web exibindo a sessão Bash no painel do Cloud Shell e execute os seguintes comandos para inicializar o repositório Git local e confirmar todas as alterações na ramificação principal:
```
cd ~/cna-aadexpress
git config --global user.email "user1@adatum.com"
git config --global user.name "Adatum User1"
git init
git add -A
git commit -m "Initial Commit"
```

Execute os seguintes comandos para configurar credenciais de implantação no nível do usuário:

DEPLOYMENTUSER=m06User$RANDOM
DEPLOYMENTPASS=m06Pass$RANDOM$RANDOM
az webapp deployment user set --user-name $DEPLOYMENTUSER --password $DEPLOYMENTPASS

Execute os seguintes comandos para identificar as credenciais de implantação no nível do usuário e registrar seu valor, pois você precisará delas mais tarde nesta tarefa:
```
echo $DEPLOYMENTUSER
echo $DEPLOYMENTPASS
```

Execute os seguintes comandos para identificar a URL de implantação do aplicativo Web do Azure que você usará como destino do git push comando:

RG2NAME=cna-aadexpress-RG
WEBAPPNAME=$(az webapp list --resource-group $RG2NAME --query "[0].name" --output tsv)
DEPLOYMENTURL=$(az webapp deployment source config-local-git --name $WEBAPPNAME --resource-group $RG2NAME --output tsv)

Execute o seguinte comando para configurar o repositório remoto chamado azure, representando a URL de implantação identificada na etapa anterior:
```
git remote add azure $DEPLOYMENTURL
```
Execute os seguintes comandos para criar a ramificação de teste com base na ramificação principal e enviar seu conteúdo para o aplicativo Web do Azure (quando solicitado a fornecer a senha que faz parte das credenciais de implantação no nível do usuário que você registrou anteriormente nesta tarefa):
```
git checkout -b test
git commit -a -m "testing"
git push --set-upstream azure test
```
Feche o painel do Cloud Shell .
Abra outra janela do navegador da Web no modo de navegação anônima/InPrivate, navegue até o portal do Azure e entre usando a conta de usuário adatumuser1 que você criou no exercício anterior.
No portal do Azure, use a caixa de texto Pesquisar recursos, serviços e documentos no início da página do portal do Azure para pesquisar Serviços de Aplicativo.
Na folha Serviços de Aplicativo, na lista de instâncias do Serviço de Aplicativo, selecione a entrada que representa o aplicativo Web do Azure recém-implantado.
Na folha que exibe as propriedades do aplicativo Web, na seção Essentials , copie o valor da URL de domínio padrão.
Abra outra guia na mesma janela do navegador e, em sua caixa de pesquisa, digite https://, cole o URL que você acabou de copiar na área de transferência, adicione o sufixo /auth e selecione Enter.

Nota

O URL deve ter o seguinte formato: https://<webapp_name>.azurewebsites.net/auth
Verifique se a página da Web resultante consiste nas informações de autenticação do Microsoft Entra para o usuário conectado no momento (a saída pode ser diferente).

Resultados

Parabéns! Você concluiu o segundo exercício deste módulo. Neste exercício, você instalou o Banco de Dados do Azure para PostgreSQL no modelo de implantação de servidor único, criou um banco de dados com dados de inventário de exemplo, integrou o servidor com a ID do Microsoft Entra e implementou um aplicativo simples baseado em Node.js que consulta o banco de dados confiando na autenticação do Microsoft Entra.

Exercício - Implementar dados multilocatários

Pré-requisitos

Criar uma instância do Banco de Dados do Azure para o servidor PostgreSQL

Conectar-se ao Banco de Dados do Azure para servidor PostgreSQL

Criar um banco de dados e tabelas de exemplo

Integrar o Banco de Dados do Azure para o servidor PostgreSQL com a ID do Microsoft Entra

Registar uma aplicação com o Microsoft Entra ID

Implemente um aplicativo simples e integrado baseado em Node.js do Microsoft Entra

Validar a funcionalidade do aplicativo baseado em Node.js

Resultados

Comentários