Övning – Implementera data för flera klientorganisationer

30 minuter

Den här övningen tar dig igenom processen för att:

Installera Azure Database for PostgreSQL i serverdistributionsmodellen.
Skapa en databas med exempelinventeringsdata.
Integrera servern med Microsoft Entra-ID.
Implementera ett enkelt Node.js-baserat program som frågar databasen genom att förlita sig på Microsoft Entra-autentisering.

Kommentar

Den här övningen illustrerar en förenklad metod för att ge stöd för flera klienter genom att emulera multitenancy-funktionerna i Azure Database for the PostgreSQL Hyperscale-distributionsmodellen. Det ger också en förenklad metod för att implementera Microsoft Entra-autentisering i scenarier med flera klientorganisationer genom att förlita sig på Microsoft Entra B2B-funktionerna. Microsoft Entra ID har direkt stöd för program med flera klienter, men deras detaljerade täckning ligger utanför omfånget för den här modulen.

I den här övningen kommer du att:

Skapa en instans av Azure Database for PostgreSQL-servern.
Anslut till Azure Database for PostgreSQL-servern.
Skapa en databas och exempeltabeller.
Integrera Azure Database for PostgreSQL-servern med Microsoft Entra-ID.
Registrera ett program med Microsoft Entra ID.
Implementera ett enkelt, Microsoft Entra-integrerat Node.js-baserat program.
Verifiera funktionerna i det Node.js-baserade programmet.

Förutsättningar

För att utföra den här övningen behöver du:

För att ha slutfört övningen Konfigurera Microsoft Entra-ID i din Azure-prenumeration.
Ett Microsoft-konto eller ett Microsoft Entra-konto med rollen Global administratör i Microsoft Entra-klientorganisationen som är associerad med Azure-prenumerationen och med rollen Ägare eller Deltagare i Azure-prenumerationen.

Varning

Använd en testmiljö eftersom övningarna i den här modulen utför känsliga åtgärder som kräver utökade administrativa privilegier.

Skapa en instans av Azure Database for PostgreSQL-servern

Du börjar med att skapa en instans av Azure Database for PostgreSQL-servern:

Om det behövs startar du en webbläsare, navigerar till Azure Portal och loggar in för att komma åt den Azure-prenumeration som du använder i den här modulen.
Använd textrutan Sök efter resurser, tjänster och dokument i början av sidan Azure Portal för att söka efter Azure Database for PostgreSQL. I resultatlistan går du till avsnittet Tjänster och väljer Azure Database for PostgreSQL.
På bladet Azure Database for PostgreSQL-servrar väljer du + Skapa.
På bladet Välj Azure Database for PostgreSQL-distributionsalternativ går du till panelen Azure Database for PostgreSQL för Resurstyp och väljer Enskild server.
Välj Skapa.

På fliken Grundläggande på bladet Enskild server konfigurerar du följande inställningar och väljer sedan Granska + skapa, samtidigt som alla andra inställningar lämnas med sina standardvärden:

Inställning	Konfiguration
Prenumeration	Välj namnet på den Azure-prenumeration som du ska använda i den här modulen.
Resursgrupp	Skapa en ny resursgrupp med namnet postgresql-db-RG.
Servernamn	Ange ett unikt namn som består av gemener, siffror eller bindestreck och börja med en bokstav.
Data source	Välj Ingen.
Plats	Välj den Azure-region som är närmast platsen för labbmiljön där du kan skapa Azure Database for PostgreSQL-instanser.
Version	Välj 11.
Beräkning och lagring	Välj länken Konfigurera server. På bladet Konfigurera väljer du Grundläggande, anger värdet för virtuell kärna till 1 och Lagring till 5 GB och väljer sedan OK.
Användarnamn för administratör	Ange elev.
Lösenord	Ange en `<password>`.

Skärmbild av fliken Grundläggande på serverbladet i Azure Portal.

På fliken Granska + skapa på bladet Enskild server väljer du Skapa.
Vänta tills etableringen har slutförts. Det kan ta ungefär fem minuter.

Kommentar

Etableringsprocessen skapar automatiskt en databas med namnet postgres på målservern.

Ansluta till Azure Database for PostgreSQL-servern

Med Azure Database for PostgreSQL-servern etablerad ansluter du till den med hjälp av psql-verktyget .

På bladet Microsoft.PostgreSQLServer.createPostgreSqlServer Overview väljer du Gå till resurs.
På bladet Distribution går du till den lodräta menyn i avsnittet Inställningar och väljer Anslutningssäkerhet.
På bladet Anslutningssäkerhet anger du Tillåt åtkomst till Azure-tjänster till Ja, väljer + Lägg till klient-IP, anger Framtvinga SSL-anslutning till Inaktiverad och väljer sedan Spara.

Kommentar

De här inställningarna tillåter anslutning till databasen från datorn och från program som körs i Azure.

Kommentar

Att inaktivera SSL-tillämpningen är avsett att förenkla de efterföljande övningarna. I allmänhet bör du behålla den här inställningen aktiverad.
I webbläsarfönstret som visar Azure Portal med bladet Distribution går du till den lodräta menyn och väljer Översikt.
I avsnittet Essentials identifierar du posterna bredvid etiketterna Servernamn och Administratörsanvändarnamn och registrerar deras värden.

Kommentar

Observera att användarnamnet innehåller symbolen @ följt av det servernamn som du angav i föregående uppgift.
I webbläsarfönstret som visar Azure Portal med bladet Azure Database for PostgreSQL enskild server går du till den lodräta menyn i avsnittet Inställningar och väljer Anslutningssträngar.
I listan över anslutningssträng kopierar du värdet för psql-anslutningssträng och registrerar det, så att du kan använda det senare i den här övningen.

Kommentar

Anslutningssträng har följande syntax, där <server_name> platshållaren representerar namnet på den server som du identifierade tidigare i den här uppgiften:
```
psql "host=<server_name>.postgres.database.azure.com port=5432 dbname={your_database} user=student@<server_name> password={your_password} sslmode=require"
```
I Azure Portal öppnar du en Bash-session i Cloud Shell genom att välja dess ikon i verktygsfältet bredvid söktextrutan.
I Bash-sessionen i Cloud Shell-fönstret klistrar du in värdet för psql-anslutningssträng från Urklipp, ändrar det så att det matchar följande kommando och kör det för att ansluta till postgres-databasen som finns på den nyligen distribuerade serverinstansen av Azure Database for PostgreSQL. Värdet för <server_name> platshållaren tas redan med i anslutningssträng du klistrade in från Urklipp:
```
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"
```
Kommentar

När du ansluter visas uppmaningen postgres=> .

Skapa en databas och exempeltabeller

I Cloud Shell-fönstret kör du följande kommando från prompten postgres=> för att skapa en ny databas med namnet cnamtinventory:
```
CREATE DATABASE cnamtinventory;
```
Kör följande kommando för att växla anslutningen till den nyligen skapade databasen:
```
\c cnamtinventory
```

Kör följande kommando för att skapa en klienttabell:

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

Kör följande kommando för att skapa en inventeringstabell:

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;

Kommentar

Data partitioneras baserat på värdet för datumkolumnen.

Kör följande kommando för att kontrollera att tabellen har skapats:
```
\dt
```

Kör följande kommando för att läsa in exempeldata i klienttabellen:

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

Kör följande kommando för att läsa in exempeldata i inventeringstabellen:

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

Kör följande kommando för att kontrollera att inventeringstabellen innehåller de data som du har infogat:
```
SELECT * FROM inventory;
```
Stäng Cloud Shell-fönstret.

Integrera Azure Database for PostgreSQL-servern med Microsoft Entra-ID

Om du vill integrera Azure Database for PostgreSQL-serverinstansen med Microsoft Entra-ID måste du ange ett Microsoft Entra-användarkonto som utsedd Active Directory-administratör för servern. För det här ändamålet använder du det adatumadmin1-användarkonto som du skapade i föregående uppgift. Du måste logga in på servern med det användarkontot. Då kan du skapa Microsoft Entra ID-baserade databasanvändare och tilldela dem databasroller. Du använder för microsoft entra-objekten adatumuser1, adatumgroup1 och contosouser1 som du skapade i föregående övning.

I webbläsarfönstret som visar Azure Portal med bladet Azure Database for PostgreSQL-server går du till den lodräta menyn, i avsnittet Inställningar väljer du Active Directory-administratör och sedan Ange administratör i verktygsfältet.
På bladet Active Directory-administratör går du till listan över Microsoft Entra-användarkonton och väljer användarkontot adatumadmin1 som du skapade i föregående övning, väljer Välj och väljer sedan Spara.
Öppna ett annat webbläsarfönster i läget Incognito/InPrivate, navigera till Azure Portal och logga in med hjälp av användarkontot adatumadmin1 med det lösenord som du skapade i föregående övning.
I Azure Portal öppnar du Cloud Shell genom att välja dess ikon i verktygsfältet bredvid söktextrutan.
När du uppmanas att välja antingen Bash eller PowerShell väljer du Bash och sedan Skapa lagring när meddelandet Du inte har någon lagring monterad visas.
I Bash-sessionen i Cloud Shell-fönstret kör du följande kommandon för att hämta och visa en Microsoft Entra-åtkomsttoken som krävs för åtkomst till Azure Database for PostgreSQL:
```
FULL_TOKEN=$(az account get-access-token --resource-type oss-rdbms)
echo $FULL_TOKEN
```
Kommentar

Kommandot genererar utdata som innehåller en Base 64-kodad token som identifierar den autentiserade användaren för Azure Database for PostgreSQL-resursen.

Utdata använder följande format:
```
{
  "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"
}
```
Kör följande kommando för att ange värdet för PGPASSWORD-variabeln till värdet för åtkomsttoken från utdata från kommandot som du körde i föregående steg:
```
export PGPASSWORD=$(echo $FULL_TOKEN | jq -r '.accessToken')
```
Kör följande kommando för att ansluta till cnamtinventory-databasen med hjälp av psql-verktyget och med hjälp av Microsoft Entra-autentisering (ersätt <server_name> platshållaren med namnet på den server som du identifierade tidigare i den här övningen):
```
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"
```
Kommentar

När du ansluter bör du få kommandotolken cnamtinventory=> .
Kör följande kommando från prompten cnamtinventory=> för att skapa en databasroll som motsvarar microsoft entra-gruppen adatumgroup1 som du skapade i föregående övning:
```
CREATE ROLE "adatumgroup1" WITH LOGIN IN ROLE azure_ad_user;
```
Kör följande kommando för att kontrollera att rollerna har skapats:
```
SELECT rolname FROM pg_roles;
```
Kör följande kommando för att ge SELECT-behörigheterna i inventeringstabellen till den adatumgroup1 som du skapade i föregående övning:
```
GRANT SELECT ON inventory TO adatumgroup1;
```
Logga ut som användarkontot adatumadmin1 och stäng webbläsarfönstret Incognito/InPrivate-läge.

Registrera ett program med Microsoft Entra-ID

Om du vill implementera ett exempel Node.js-baserat program som använder Microsoft Entra-autentisering för att få åtkomst till en Azure Database for PostgreSQL-databas måste du skapa ett Microsoft Entra-programobjekt och motsvarande säkerhetsobjekt. Detta gör att det Node.js-baserade programmet kan personifiera Microsoft Entra-användare vid åtkomst till databasobjekt.

I Azure Portal använder du textrutan Sök efter resurser, tjänster och dokument för att söka efter Microsoft Entra-ID och i resultatlistan väljer du Microsoft Entra-ID.
På bladet Microsoft Entra går du till den lodräta menyn i avsnittet Hantera och väljer Appregistreringar.
På bladet Appregistreringar väljer du + Ny registrering.
På bladet Registrera ett program går du till textrutan Namn och anger can-app. I avsnittet Kontotyper som stöds kontrollerar du att alternativet Endast konton i den här organisationskatalogen (endast standardkatalog – enskild klientorganisation) är markerat. I avsnittet Omdirigerings-URI (valfritt) anger du webbposten till http://localhost:8080/redirectoch väljer sedan Registrera.

Kommentar

Du har möjlighet att konfigurera stöd för flera klienter för dina Microsoft Entra-registrerade program. Detaljerad täckning av den här metoden ligger dock utanför omfånget för den här modulen.

Kommentar

När du har distribuerat programmet måste du ändra värdet omdirigerings-URI (valfritt) för att återspegla dess faktiska URL.
På bladet can-app granskar du de resulterande inställningarna och registrerar värdena för program-ID:t (klient-ID:t) och egenskaperna för katalog-ID (klientorganisation).
På bladet can-app i avsnittet Hantera väljer du Certifikat och hemligheter och väljer + Ny klienthemlighet.
På bladet Lägg till en klienthemlighet går du till textrutan Beskrivning och anger can-secret-0. Lämna listrutan Upphör att gälla med standardvärdet och välj Lägg till.
Tillbaka till can-app | Bladet Certifikat och hemligheter kopierar värdet för den nyligen genererade hemligheten.

Kommentar

Se till att kopiera värdet för hemligheten innan du navigerar bort från det här bladet, eftersom du då inte längre kan hämta den. Om det händer skapar du en annan hemlighet.
I can-app | Bladet Certifikat och hemligheter går till den lodräta menyn i avsnittet Hantera och väljer API-behörigheter.
I can-app | Bladet API-behörigheter, välj + Lägg till en behörighet. Väljfliken API:er som min organisation använder i söktextrutan, ange Azure OSSRDBMS Database och välj sedan Azure OSSRDBMS Database i resultatlistan.
På bladet Förfrågnings-API-behörighet väljer du Delegerade behörigheter, markerar kryssrutan user_impersonation och väljer sedan Lägg till behörigheter.
Tillbaka till can-app | Bladet API-behörigheter , välj Bevilja administratörsmedgivande för Standardkatalog och välj Ja när du uppmanas att bekräfta.
I can-app | Bladet API-behörigheter kontrollerar att behörigheterna har beviljats.

Implementera ett enkelt, Microsoft Entra-integrerat Node.js-baserat program

Med programmet registrerat i Microsoft Entra-klientorganisationen kan du nu fortsätta med implementeringen.

I Azure Portal startar du en Bash-session i Cloud Shell genom att välja dess ikon i verktygsfältet bredvid söktextrutan.
I Bash-sessionen i Cloud Shell-fönstret kör du följande kommandon för att initiera ett Node.js projekt i en ny katalog:
```
mkdir -p cna-aadexpress && cd cna-aadexpress
npm init -y
```
Kör följande kommandon för att lägga till nödvändiga paket i projektets beroende:
```
npm install express
npm install pg
npm install @azure/msal-node
```
Kör följande kommando för att skapa en fil med namnet index.js i projektets rot:
```
touch ./index.js
```

Använd nanoredigeraren för att öppna filen index.js och lägga till följande innehåll. Du skapar ett appnamn senare i den här lektionen för att ersätta platshållaren <webapp_name>. Ersätt <client_id>, <tenant_id>, <client_secret>och <server_name> (exklusive suffixet .postgres.database.azure.com ) med de faktiska värden som du registrerade tidigare i den här övningen:

Kommentar

Platshållarna <client_id> och <tenant_id> motsvarar egenskaperna Program -ID (klient) och katalog-ID (klientorganisation) som refererades tidigare i den här övningen.

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

Kommentar

Ett Microsoft Entra-registrerat program med flera klienter använder url:en authority: "https://login.microsoftonline.com/common"för den allmänna utfärdaren, men i ditt fall måste du använda en URL för en enda klientorganisation som innehåller ditt klient-ID.

Kommentar

Tänk på att när du har distribuerat programmet måste du ersätta värdet för OMDIRIGERINGs-URL :en med dess faktiska omdirigerings-URL.

Använd nanoredigeraren för att redigera package.json-filen i projektets rot och ersätta den med följande innehåll:

{
  "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"
  }
}

Verifiera funktionerna i det Node.js-baserade programmet

Du är äntligen redo att testa funktionerna i webbappen. Även om du kan containerisera den distribuerar du den till en Azure App Service för enkelhetens skull. Detta ger ett snabbt sätt att verifiera dess funktioner och se till att containerstorleken är ett genomförbart alternativ.

I Bash-sessionen i Cloud Shell-fönstret kör du följande kommandon för att skapa en resursgrupp som ska vara värd för Azure-webbappen, där du distribuerar Node.js Express-appen:

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

Kör följande kommandon för att skapa en Azure App Service-plan på kostnadsfri nivå som ska vara värd för den nya Azure-webbappen:
```
SPNAME=aadexpress-sp
az appservice plan create --name $SPNAME --resource-group $RG2NAME --sku F1 --is-linux
```

Kör följande kommandon för att skapa den nya Node.js-baserade Azure-webbappen:

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

Kör följande kommandon för att identifiera namnet på webbappen:
```
echo $WEBAPPNAME
```
Använd nanoredigeraren för att öppna filen index.js , ersätta två <webapp_name> platshållare med det namn som du identifierade i föregående steg, spara ändringarna och stäng filen.

Kommentar

Se till att ersätta båda <webapp_name> platshållarna.
Öppna en annan flik i webbläsarfönstret med Azure Portal, navigera till Azure Portal och logga in om du uppmanas att komma åt den Azure-prenumeration som du ska använda i den här modulen.
I Azure Portal använder du textrutan Sök efter resurser, tjänster och dokument för att söka efter Microsoft Entra-ID och i resultatlistan väljer du Microsoft Entra-ID.
På bladet Microsoft Entra navigerar du till bladet Appregistreringar, väljer posten can-app i den lodräta menyn i avsnittet Hantera och väljer Autentisering.
I can-app | Autentiseringsbladet, ändra värdet för omdirigerings-URI:n så att den matchar posten som du uppdaterade i filen index.js och spara ändringen.
Växla tillbaka till webbläsarfliken som visar Bash-sessionen i Cloud Shell-fönstret och kör följande kommandon för att initiera den lokala Git-lagringsplatsen och checka in alla ändringar i huvudgrenen:
```
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"
```

Kör följande kommandon för att konfigurera autentiseringsuppgifter för distribution på användarnivå:

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

Kör följande kommandon för att identifiera autentiseringsuppgifterna för distribution på användarnivå och registrera deras värde, eftersom du behöver dem senare i den här uppgiften:
```
echo $DEPLOYMENTUSER
echo $DEPLOYMENTPASS
```

Kör följande kommandon för att identifiera url:en för Distribution av Azure-webbappar som du ska använda som mål för git push kommandot:

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)

Kör följande kommando för att konfigurera fjärrdatabasen med namnet azure, som representerar distributions-URL:en som du identifierade i föregående steg:
```
git remote add azure $DEPLOYMENTURL
```
Kör följande kommandon för att skapa testgrenen baserat på huvudgrenenoch skicka innehållet till Azure-webbappen (när du uppmanas att ange lösenordet som ingår i de autentiseringsuppgifter för distribution på användarnivå som du registrerade tidigare i den här uppgiften):
```
git checkout -b test
git commit -a -m "testing"
git push --set-upstream azure test
```
Stäng Cloud Shell-fönstret.
Öppna ett annat webbläsarfönster i läget Incognito/InPrivate, navigera till Azure Portal och logga in med hjälp av det adatumuser1-användarkonto som du skapade i föregående övning.
I Azure Portal använder du textrutan Sök efter resurser, tjänster och dokument i början av sidan Azure Portal för att söka efter App Services.
På bladet App Services går du till listan över App Service-instanser och väljer posten som representerar den nyligen distribuerade Azure-webbappen.
På bladet som visar egenskaperna för webbappen i avsnittet Essentials kopierar du värdet för url:en för standarddomänen.
Öppna en annan flik i samma webbläsarfönster och i sökrutan anger du https://, klistrar in url:en som du precis kopierade till Urklipp, lägger till suffixet /auth och väljer Retur.

Kommentar

URL:en bör ha följande format: https://<webapp_name>.azurewebsites.net/auth
Kontrollera att den resulterande webbsidan består av Microsoft Entra-autentiseringsinformation för den inloggade användaren (utdata kan skilja sig åt).

Resultat

Grattis! Du har slutfört den andra övningen i den här modulen. I den här övningen installerade du Azure Database for PostgreSQL i distributionsmodellen för en enskild server, skapade en databas med exempelinventeringsdata, integrerade servern med Microsoft Entra-ID och implementerade ett enkelt Node.js-baserat program som frågar databasen genom att förlita sig på Microsoft Entra-autentisering.

Övning – Implementera data för flera klientorganisationer

Förutsättningar

Skapa en instans av Azure Database for PostgreSQL-servern

Ansluta till Azure Database for PostgreSQL-servern

Skapa en databas och exempeltabeller

Integrera Azure Database for PostgreSQL-servern med Microsoft Entra-ID

Registrera ett program med Microsoft Entra-ID

Implementera ett enkelt, Microsoft Entra-integrerat Node.js-baserat program

Verifiera funktionerna i det Node.js-baserade programmet

Resultat

Feedback