Übung: Implementieren mehrinstanzenfähiger Daten

30 Minuten

Diese Übung führt Sie durch die folgenden Prozesse:

Installieren von Azure Database for PostgreSQL im Serverbereitstellungsmodell.
Erstellen einer Datenbank mit Beispielbestandsdaten.
Integrieren des Servers mit Microsoft Entra ID.
Implementieren einer einfachen Node.js-basierten Anwendung, welche die Datenbank abfragt und sich auf die Microsoft Entra-Authentifizierung verlässt.

Hinweis

Diese Übung veranschaulicht einen vereinfachten Ansatz für die Unterstützung mehrerer Mandanten, indem die Funktionalität der Mehrinstanzenfähigkeit des Azure Database for PostgreSQL Hyperscale-Bereitstellungsmodell emuliert wird. Außerdem bietet sie einen vereinfachten Ansatz für die Implementierung der Microsoft Entra-Authentifizierung in mandantenfähigen Szenarien, indem sie sich auf die Microsoft Entra B2B-Funktionalität verlässt. Microsoft Entra ID unterstützt mandantenfähige Anwendungen direkt, ihre ausführliche Behandlung liegt jedoch außerhalb des Rahmens dieses Moduls.

In dieser Übung führen Sie die folgenden Schritte aus:

Erstellen Sie eine Instanz von Azure Database for PostgreSQL-Server.
Stellen Sie eine Verbindung mit dem Azure Database for PostgreSQL-Server her.
Erstellen Sie eine Datenbank und Beispieltabellen.
Integrieren Sie den Azure Database for PostgreSQL-Server mit Microsoft Entra ID.
Registrieren Sie eine Anwendung mit Microsoft Entra ID.
Implementieren Sie eine einfache, in Microsoft Entra integrierte Node.js-basierte Anwendung.
Überprüfen Sie die Funktionalität der Next.js-basierten Anwendung.

Voraussetzungen

Zur Durchführung dieser Übung benötigen Sie Folgendes:

Ein Azure-Abonnement.
Ein Microsoft-Konto oder ein Microsoft Entra-Konto mit der Rolle „Globaler Administrator“ im Microsoft Entra-Mandanten, der dem Azure-Abonnement zugeordnet ist, und mit der Rolle „Besitzer“ oder „Mitwirkender“ im Azure-Abonnement.
Sie müssen die erste Übung dieses Moduls abgeschlossen haben.

Erstellen Sie eine Instanz von Azure Database for PostgreSQL-Server.

Zunächst erstellen Sie eine Instanz von Azure Database for PostgreSQL-Server:

Starten Sie ggf. einen Webbrowser, navigieren Sie zum Azure-Portal, und melden Sie sich an, um auf das Azure-Abonnement zuzugreifen, das Sie in diesem Modul verwenden.
Verwenden Sie das Textfeld Ressourcen, Dienste und Dokumentation durchsuchen am Anfang der Azure-Portalseite, um nach Azure Database for PostgreSQL zu suchen, und wählen Sie in der Liste der Ergebnisse im Abschnitt Dienste die Option Azure Database for PostgreSQL aus.
Wählen Sie im Blatt Azure Database for PostgreSQL-Server die Option + Erstellen aus.
Wählen Sie im Blatt Azure Database for PostgreSQL-Bereitstellungsoption auf der Kachel Azure Database for PostgreSQL für Ressourcentyp die Option Einzelserver aus.
Klicken Sie auf Erstellen.

Konfigurieren Sie im Blatt Einzelserver auf der Registerkarte Grundlagen die folgenden Einstellungen, und wählen Sie dann Überprüfen + erstellen aus, während Sie alle anderen Einstellungen auf den Standardwerten belassen:

Einstellung	Konfiguration
Subscription	Wählen Sie den Namen des Azure-Abonnements aus, das Sie in diesem Modul verwenden.
Resource group	Erstellen Sie eine neue Ressourcengruppe mit dem Namen postgresql-db-RG.
Servername	Geben Sie einen eindeutigen Namen ein, der aus Kleinbuchstaben, Ziffern oder Bindestrichen besteht und mit einem Buchstaben beginnt.
Datenquellen-	Wählen Sie Keine.
Standort	Wählen Sie die Azure-Region aus, die dem Standort Ihrer Laborumgebung am nächsten liegt, in der Sie Azure Database for PostgreSQL erstellen können.
Version	Wählen Sie 11 aus.
Compute und Speicher	Wählen Sie den Link Server konfigurieren aus. Wählen Sie auf dem Blatt Konfigurieren die Option Einfach aus, legen Sie den Wert von vCore auf 1 und von Speicher auf 5 GB fest, und wählen Sie dann OK aus.
Administratorbenutzername	Geben Sie Student ein.
Kennwort	Geben Sie Pa55w0rd1234 ein.

Screenshot: Registerkarte „Grundlagen“ des Blatts „Server“ im Azure-Portal

Wählen Sie auf der Registerkarte Überprüfen und erstellen des Blatts Einzelserver die Option Erstellen aus.
Warten Sie, bis die Bereitstellung abgeschlossen wurde. Dies kann etwa fünf Minuten dauern.

Hinweis

Beim Bereitstellungsprozess wird automatisch eine Datenbank mit dem Namen postgres auf dem Zielserver erstellt.

Herstellen einer Verbindung mit dem Azure Database for PostgreSQL-Server

Nach der Bereitstellung des Azure Database for PostgreSQL-Servers stellen Sie mit dem Tool psql eine Verbindung mit ihm her.

Wählen Sie im Blatt Microsoft.PostgreSQLServer.createPostgreSqlServer Overview die Option Zur Ressource wechseln aus.
Wählen Sie im Blatt Bereitstellung im vertikalen Menü im Abschnitt Einstellungen die Option Verbindungssicherheit aus.
Legen Sie auf dem Blatt Verbindungssicherheit die Option Zugriff auf Azure-Dienste zulassen auf Ja fest,wählen Sie + Client-IP hinzufügen aus, legen Sie SSL-Verbindung erzwingen auf DEAKTIVIERT fest, und wählen Sie dann Speichern aus.

Hinweis

Diese Einstellungen ermöglichen die Konnektivität mit der Datenbank von Ihrem Computer und von Anwendungen, die in Azure ausgeführt werden.

Hinweis

Das Deaktivieren der SSL-Erzwingung ist dazu gedacht, die nachfolgenden Übungen zu vereinfachen. Im Allgemeinen sollten Sie diese Einstellung aktiviert lassen.
Wählen Sie im Browserfenster, in dem das Azure-Portal mit dem Blatt Bereitstellung angezeigt wird, im vertikalen Menü die Option Übersicht aus.
Identifizieren Sie im Abschnitt Essentials die Einträge neben den Bezeichnungen Servername und Administratorbenutzername, und zeichnen Sie deren Werte auf.

Hinweis

Beachten Sie, dass der Benutzername das Symbol @ gefolgt vom Servernamen enthält, den Sie in der vorherigen Aufgabe angegeben haben.
Wählen Sie im Browserfenster, in dem das Azure-Portal mit dem Blatt Azure Database for PostgreSQL-Einzelserver angezeigt wird, im vertikalen Menü im Abschnitt Einstellungen die Option Verbindungszeichenfolgen aus.
Kopieren Sie in der Liste der Verbindungszeichenfolgen den Wert der psql-Verbindungszeichenfolge in die Zwischenablage, und notieren Sie den Wert, damit Sie ihn später in dieser Übung verwenden können.

Hinweis

Die Verbindungszeichenfolge hat die folgende Syntax, wobei der Platzhalter <server_name> den Namen des Servers darstellt, den Sie zuvor in dieser Aufgabe identifiziert haben:
```
psql "host=<server_name>.postgres.database.azure.com port=5432 dbname={your_database} user=student@<server_name> password={your_password} sslmode=require"
```
Öffnen Sie im Azure-Portal eine Bash-Sitzung von Cloud Shell, indem Sie auf der Symbolleiste das entsprechende Symbol neben dem Textfeld für die Suche auswählen.
Fügen Sie in der Bash-Sitzung im Bereich Cloud Shell den Wert der psql-Verbindungszeichenfolge aus der Zwischenablage ein. Ändern Sie ihn so, dass er dem folgenden Befehl entspricht, und führen Sie ihn dann aus, um eine Verbindung mit der postgres-Datenbank herzustellen, die auf der neu bereitgestellten Serverinstanz von Azure Database for PostgreSQL gehostet wird. Der Wert des Platzhalters <server_name> ist bereits in der Verbindungszeichenfolge enthalten, die Sie aus der Zwischenablage eingefügt haben:
```
psql "host=<server_name>.postgres.database.azure.com port=5432 dbname=postgres user=student@<server_name>.postgres.database.azure.com password=Pa55w0rd1234 sslmode=require"
```
Hinweis

Wenn Sie erfolgreich eine Verbindung hergestellt haben, wird die postgres=>-Eingabeaufforderung angezeigt.

Erstellen von Datenbank und Beispieltabellen

Führen Sie im Bereich Cloud Shell in der postgres=>-Eingabeaufforderung den folgenden Befehl aus, um eine neue Datenbank mit dem Namen cnamtinventory zu erstellen:
```
CREATE DATABASE cnamtinventory;
```
Führen Sie den folgenden Befehl aus, um die Verbindung mit der neu erstellten Datenbank herzustellen:
```
\c cnamtinventory
```

Führen Sie den folgenden Befehl aus, um eine Mandantentabelle zu erstellen:

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

Führen Sie den folgenden Befehl aus, um eine Bestandstabelle zu erstellen:

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;

Hinweis

Die Daten werden basierend auf dem Wert der Datumsspalte partitioniert.

Führen Sie den folgenden Befehl aus, um sicherzustellen, dass die Tabelle erfolgreich erstellt wurde:
```
\dt
```

Führen Sie den folgenden Befehl aus, um Beispieldaten in die Mandantentabelle zu laden:

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

Führen Sie den folgenden Befehl aus, um Beispieldaten in die Bestandstabelle zu laden:

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

Führen Sie den folgenden Befehl aus, um sicherzustellen, dass die Bestandstabelle die eingefügten Daten enthält:
```
SELECT * FROM inventory;
```
Schließen Sie den Cloud Shell-Bereich.

Integrieren des Azure Database for PostgreSQL-Servers mit Microsoft Entra ID

Um die Azure Database for PostgreSQL-Serverinstanz mit Microsoft Entra ID zu integrieren, müssen Sie ein Microsoft Entra-Benutzerkonto als den designierten Active Directory-Administrator des Servers bereitstellen. Zu diesem Zweck verwenden Sie das Benutzerkonto adatumadmin1, das Sie in der vorherigen Aufgabe erstellt haben. Sie müssen sich mit diesem Benutzerkonto beim Server anmelden. An diesem Punkt werden Sie in der Lage sein, Microsoft Entra ID-basierte Datenbankbenutzer zu erstellen und ihnen Datenbankrollen zuzuweisen. Sie werden für adatumuser1, adatumgroup1 und contosouser1 die Microsoft Entra-Objekte verwenden, die Sie in der vorherigen Übung erstellt haben.

Wählen Sie im Browserfenster, in dem das Azure-Portal mit dem Blatt „Azure Database for PostgreSQL-Server“ angezeigt wird, im vertikalen Menü im Abschnitt Einstellungen die Option Active Directory-Administrator aus. Wählen Sie dann auf der Symbolleiste Administrator festlegen aus.
Wählen Sie auf dem Blatt Active Directory-Administrator in der Liste der Microsoft Entra-Benutzerkonten das Benutzerkonto adatumadmin1 aus, das Sie in der vorherigen Übung erstellt haben. Wählen Sie anschließend Auswählen und dann Speichern aus.
Öffnen Sie ein weiteres Webbrowserfenster im Inkognito-/InPrivate-Modus, navigieren Sie zum Azure-Portal und melden Sie sich mit dem Benutzerkonto adatumadmin1 (mit dem Kennwort Pa55w.rd1234) an, das Sie in der vorherigen Übung erstellt haben.
Öffnen Sie Cloud Shell im Azure-Portal, indem Sie auf der Symbolleiste das entsprechende Symbol neben dem Textfeld für die Suche auswählen.
Wenn Sie aufgefordert werden, entweder Bash oder PowerShell auszuwählen, wählen Sie Bash und dann Speicher erstellen aus, wenn die Meldung Für Sie wurde kein Speicher bereitgestellt angezeigt wird.
Führen Sie in der Bash-Sitzung im Bereich Cloud Shell die folgenden Befehle aus, um ein Microsoft Entra-Zugriffstoken abzurufen und anzuzeigen, das für den Zugriff auf Azure Database for PostgreSQL erforderlich ist:
```
FULL_TOKEN=$(az account get-access-token --resource-type oss-rdbms)
echo $FULL_TOKEN
```
Hinweis

Der Befehl generiert eine Ausgabe, die ein Base64-codiertes Token enthält, das den authentifizierten Benutzer für die Azure Database for PostgreSQL-Ressource identifiziert.

Die Ausgabe verwendet das folgende 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"
}
```
Führen Sie den folgenden Befehl aus, um den Wert der Variablen PGPASSWORD auf den Wert des Zugriffstokens aus der Ausgabe des Befehls festzulegen, den Sie im vorherigen Schritt ausgeführt haben:
```
export PGPASSWORD=$(echo $FULL_TOKEN | jq -r '.accessToken')
```
Führen Sie den folgenden Befehl aus, um eine Verbindung mit der Datenbank cnamtinventory herzustellen, indem Sie das Tool psql und die Microsoft Entra-Authentifizierung verwenden (ersetzen Sie den Platzhalter <server_name> durch den Namen des Servers, den Sie zuvor in dieser Übung identifiziert haben):
```
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"
```
Hinweis

Wenn Sie erfolgreich eine Verbindung hergestellt haben, sollte die cnamtinventory=>-Eingabeaufforderung angezeigt werden.
Führen Sie an der cnamtinventory=>-Eingabeaufforderung den folgenden Befehl aus, um eine Datenbankrolle zu erstellen, die der Microsoft Entra-Gruppe adatumgroup1 entspricht, die Sie in der vorherigen Übung erstellt haben:
```
CREATE ROLE "adatumgroup1" WITH LOGIN IN ROLE azure_ad_user;
```
Führen Sie den folgenden Befehl aus, um sicherzustellen, dass die Rollen erfolgreich erstellt wurden.
```
SELECT rolname FROM pg_roles;
```
Führen Sie den folgenden Befehl aus, um der Gruppe adatumgroup1, die Sie in der vorherigen Übung erstellt haben, die SELECT-Berechtigungen für die Bestandstabelle zu gewähren:
```
GRANT SELECT ON inventory TO adatumgroup1;
```
Melden Sie sich mit dem adatumadmin1-Benutzerkonto ab, und schließen Sie das Webbrowserfenster im Inkognito-/InPrivate-Modus.

Registrieren einer Anwendung mit Microsoft Entra ID

Um eine Node.js-basierte Beispielanwendung zu implementieren, welche die Microsoft Entra-Authentifizierung für den Zugriff auf eine Azure Database for PostgreSQL-Datenbank verwendet, müssen Sie ein Microsoft Entra-Anwendungsobjekt und den entsprechenden Sicherheitsprinzipal erstellen. Dadurch kann die Node.js-basierte Anwendung beim Zugriff auf Datenbankobjekte zur Identität von Microsoft Entra-Benutzern wechseln.

Verwenden Sie im Azure-Portal das Textfeld Ressourcen, Dienste und Dokumente suchen, um nach Microsoft Entra ID zu suchen, und wählen Sie in der Liste der Ergebnisse Microsoft Entra ID aus.
Wählen Sie auf dem Microsoft Entra-Blatt im vertikalen Menü im Abschnitt Verwalten die Option App-Registrierungen aus.
Wählen Sie auf dem Blatt App-Registrierungen die Option + Neue Registrierung aus.
Geben Sie auf dem Blatt Anwendung registrieren im Textfeld Name den Namen cna-app ein. Stellen Sie im Abschnitt Unterstützte Kontotypen sicher, dass die Option Nur Konten in diesem Organisationsverzeichnis (nur Standardverzeichnis – Einzelmandant) ausgewählt ist. Legen Sie im Abschnitt Umleitungs-URI (optional) den Eintrag Web auf http://localhost:8080/redirect fest, und wählen Sie dann Registrieren aus.

Hinweis

Sie haben die Möglichkeit, die Unterstützung für Mandantenfähigkeit für Ihre registrierten Microsoft Entra-Anwendungen zu konfigurieren. Eine ausführliche Beschreibung dieses Ansatzes würde jedoch den Rahmen dieses Moduls sprengen.

Hinweis

Nachdem Sie Ihre Anwendung bereitgestellt haben, müssen Sie den Wert für Umleitungs-URI (optional) ändern, um die tatsächliche URL widerzuspiegeln.
Überprüfen Sie auf dem Blatt cna-app die resultierenden Einstellungen und notieren Sie die Werte der Eigenschaften Anwendungs-ID (Client) und Verzeichnis-ID (Mandant).
Wählen Sie auf dem Blatt cna-app im Abschnitt Verwalten die Option Zertifikate und Geheimnisse und dann + Neues Clientgeheimnis aus.
Geben Sie auf dem Blatt Clientgeheimnis hinzufügen im Textfeld Beschreibung den Wert cna-secret-0 ein. Belassen Sie für den Dropdownlisteneintrag Läuft ab den Standardwert, und wählen Sie Hinzufügen aus.
Wenn Sie sich wieder auf dem Blatt cna-app | Zertifikate und Geheimnisse befinden, kopieren Sie den Wert des neu generierten Geheimnisses.

Hinweis

Stellen Sie sicher, dass Sie den Wert des Geheimnisses kopieren, bevor Sie das Blatt verlassen, denn dann können Sie ihn nicht mehr abrufen. Erstellen Sie in diesem Fall ein weiteres Geheimnis.
Wählen Sie auf dem Blatt cna-app | Zertifikate und Geheimnisse im vertikalen Menü im Abschnitt Verwalten die Option API-Berechtigungen aus.
Wählen Sie auf dem Blatt cna-app | API-Berechtigungen die Option + Berechtigung hinzufügen aus. Wählen Sie auf dem Blatt API-Berechtigung anfordern die Registerkarte Von meiner Organisation verwendete APIs aus, geben Sie in das Suchtextfeld Azure OSSRDBMS-Datenbank ein, und wählen Sie dann in der Ergebnisliste Azure OSSRDBMS-Datenbank aus.
Wählen Sie auf dem Blatt API-Berechtigung anfordern die Option Delegierte Berechtigungen aus. Aktivieren Sie das Kontrollkästchen user_impersonation, und wählen Sie dann Berechtigungen hinzufügen aus.
Wählen Sie auf dem Blatt cna-app | API-BerechtigungenGrant admin consent for Default Directory (Administratorzustimmung für das Standardverzeichnis erteilen) aus. Wenn Sie zur Bestätigung aufgefordert werden, wählen Sie Ja aus.
Überprüfen Sie auf dem Blatt cna-app | API-Berechtigungen, ob die Berechtigungen erteilt wurden.

Implementieren einer einfachen, in Microsoft Entra integrierten Node.js-basierten Anwendung

Wenn die Anwendung im Microsoft Entra-Mandanten registriert ist, können Sie mit ihrer Implementierung fortfahren.

Starten Sie im Azure-Portal eine Bash-Sitzung in Cloud Shell, indem Sie auf der Symbolleiste das entsprechende Symbol neben dem Textfeld für die Suche auswählen.
Führen Sie in der Bash-Sitzung im Cloud Shell-Bereich die folgenden Befehle aus, um ein Node.js-Projekt in einem neuen Verzeichnis zu initialisieren:
```
mkdir -p cna-aadexpress && cd cna-aadexpress
npm init -y
```
Führen Sie die folgenden Befehle aus, um der Abhängigkeit des Projekts erforderliche Pakete hinzuzufügen:
```
npm install express
npm install pg
npm install @azure/msal-node
```
Führen Sie den folgenden Befehl aus, um eine Datei namens index.js im Stammverzeichnis des Projekts zu erstellen:
```
touch ./index.js
```

Verwenden Sie den Nano-Editor, um die Datei index.js zu öffnen, und fügen Sie den folgenden Inhalt hinzu. Sie werden später in dieser Lerneinheit einen App-Namen erstellen, um den Platzhalter <webapp_name> zu ersetzen. Ersetzen Sie <client_id>, <tenant_id>, <client_secret> und <server_name> (mit Ausnahme des Suffixes .postgres.database.azure.com) durch ihre tatsächlichen Werte, die Sie sich zuvor in dieser Übung notiert haben:

Hinweis

Die Platzhalter <client_id> und <tenant_id> entsprechen den Eigenschaften Anwendungs-ID (Client) und Verzeichnis-ID (Mandant), auf die in dieser Übung bereits verwiesen wurde.

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

Hinweis

Eine mandantenfähige, in Microsoft Entra registrierte Anwendung verwendet die generische Autorität-URL authority: "https://login.microsoftonline.com/common", aber in Ihrem Fall müssen Sie eine Einzelmandanten-URL verwenden, die Ihre Mandanten-ID enthält.

Hinweis

Denken Sie daran, dass Sie nach der Bereitstellung der Anwendung den Wert von REDIRECT URL mit der tatsächlichen Umleitungs-URL ersetzen müssen.

Verwenden Sie den Nano-Editor, um die Datei package.json im Stammverzeichnis des Projekts zu bearbeiten, und ersetzen Sie diese mit dem folgenden Inhalt:

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

Überprüfen der Funktionalität der Next.js-basierten Anwendung

Jetzt können Sie endlich die Funktionalität Ihrer Web-App testen. Sie könnten sie zwar auch in einen Container integrieren, aber der Einfachheit halber werden Sie sie in einer Azure App Service-Instanz bereitstellen. So erhalten Sie eine schnelle Möglichkeit, die Funktionalität zu überprüfen und sicherzustellen, dass Containerisierung eine sinnvolle Option ist.

Führen Sie in der Bash-Sitzung im Bereich Cloud Shell die folgenden Befehle aus, um eine Ressourcengruppe zu erstellen, welche die Azure-Webanwendung hostet, in der Sie die Node.js Express-App bereitstellen:
```
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
```
Führen Sie die folgenden Befehle aus, um einen Azure App Service-Plan im Free-Tarif zu erstellen, der die neue Azure-Web-App hostet:
```
SPNAME=aadexpress-sp
az appservice plan create --name $SPNAME --resource-group $RG2NAME --sku F1 --is-linux
```

Führen Sie die folgenden Befehle aus, um die neue Node.js-basierte Azure-Web-App zu erstellen:

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

Führen Sie die folgenden Befehle aus, um den Namen der Web-App zu identifizieren:
```
echo $WEBAPPNAME
```
Verwenden Sie den Nano-Editor, um die Datei index.js zu öffnen, ersetzen Sie zwei <webapp_name>-Platzhalter durch den Namen, den Sie im vorherigen Schritt ermittelt haben, speichern Sie Ihre Änderungen, und schließen Sie die Datei.

Hinweis

Stellen Sie sicher, dass Sie beide <webapp_name>-Platzhalter ersetzen.
Öffnen Sie eine weitere Registerkarte im Webbrowserfenster, in dem das Azure-Portal angezeigt wird, navigieren Sie zum Azure-Portal und melden Sie sich bei entsprechender Aufforderung an, um auf das Azure-Abonnement zuzugreifen, das Sie in diesem Modul verwenden werden.
Verwenden Sie im Azure-Portal das Textfeld Ressourcen, Dienste und Dokumente suchen, um nach Microsoft Entra ID zu suchen, und wählen Sie in der Ergebnisliste Microsoft Entra ID aus.
Navigieren Sie auf dem Microsoft Entra-Blatt zum Blatt App-Registrierungen, wählen Sie den Eintrag cna-app und dann im vertikalen Menü im Abschnitt Verwalten die Option Authentifizierung aus.
Ändern Sie auf dem Blatt cna-app | Authentifizierung den Wert für Umleitungs-URI so, dass er dem Eintrag entspricht, den Sie in der Datei index.js aktualisiert haben, und speichern Sie die Änderung.
Wechseln Sie zurück zur Registerkarte des Webbrowsers, die die Bash-Sitzung im Bereich Cloud Shell anzeigt, und führen Sie die folgenden Befehle aus, um das lokale Git-Repository zu initialisieren und alle Änderungen im Mainbranch zu übertragen:
```
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"
```

Führen Sie die folgenden Befehle aus, um die Anmeldeinformationen für die Bereitstellung auf Benutzerebene einzurichten:

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

Führen Sie die folgenden Befehle aus, um die Anmeldeinformationen für die Bereitstellung auf Benutzerebene zu ermitteln und ihren Wert aufzuzeichnen, da Sie sie später in dieser Aufgabe benötigen werden:
```
echo $DEPLOYMENTUSER
echo $DEPLOYMENTPASS
```

Führen Sie die folgenden Befehle aus, um die Bereitstellungs-URL für die Azure-Web-App zu identifizieren, die Sie als Ziel des git push-Befehls verwenden werden:

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)

Führen Sie den folgenden Befehl aus, um das Remoterepository mit dem Namen azure zu konfigurieren, das die Bereitstellungs-URL darstellt, die Sie im vorherigen Schritt identifiziert haben:
```
git remote add azure $DEPLOYMENTURL
```
Führen Sie die folgenden Befehle aus, um den Test-Branch basierend auf dem Main-Branch zu erstellen und den Inhalt an die Azure-Webanwendung zu pushen (wenn Sie zur Eingabe des Kennworts aufgefordert werden, das Teil der Anmeldeinformationen für die Bereitstellung auf Benutzerebene ist, die Sie sich zuvor in dieser Aufgabe notiert haben):
```
git checkout -b test
git commit -a -m "testing"
git push --set-upstream azure test
```
Schließen Sie den Cloud Shell-Bereich.
Öffnen Sie ein weiteres Webbrowserfenster im Inkognito-/InPrivate-Modus, navigieren Sie zum Azure-Portal und melden Sie sich mit dem Benutzerkonto adatumuser1 an, das Sie in der vorherigen Übung erstellt haben.
Verwenden Sie im Azure-Portal das Textfeld Ressourcen, Dienste und Dokumente durchsuchen am Anfang der Azure-Portalseite, um nach App Services zu suchen.
Wählen Sie auf dem Blatt App Services in der Liste der App Service-Instanzen den Eintrag aus, der die neu bereitgestellte Azure-Web-App darstellt.
Kopieren Sie auf dem Blatt, das die Eigenschaften der Webanwendung anzeigt, im Abschnitt Essentials den Wert der URL der Standarddomäne.
Öffnen Sie eine weitere Registerkarte im gleichen Browserfenster, geben Sie in ihrem Suchfeld https:// ein, fügen Sie die soeben kopierte URL in die Zwischenablage ein, fügen Sie das Suffix /auth hinzu, und wählen Sie die EINGABETASTE aus.

Hinweis

Das Format der URL muss wie folgt aussehen: https://<webapp_name>.azurewebsites.net/auth
Überprüfen Sie, ob die resultierende Webseite aus den Microsoft Entra-Authentifizierungsinformationen für den aktuell angemeldeten Benutzer besteht (die Ausgabe kann abweichen).

Ergebnisse

Herzlichen Glückwunsch! Sie haben die zweite Übung dieses Moduls abgeschlossen. In dieser Übung haben Sie Azure Database for PostgreSQL im Bereitstellungsmodell „Einzelserver“ installiert, eine Datenbank mit Beispielbestandsdaten erstellt, den Server mit Microsoft Entra ID integriert und eine einfache Node.js-basierte Anwendung implementiert, welche die Datenbank abfragt, indem sie sich auf die Microsoft Entra-Authentifizierung verlässt.

Weiter

Voraussetzungen

Erstellen Sie eine Instanz von Azure Database for PostgreSQL-Server.

Herstellen einer Verbindung mit dem Azure Database for PostgreSQL-Server

Erstellen von Datenbank und Beispieltabellen

Integrieren des Azure Database for PostgreSQL-Servers mit Microsoft Entra ID

Registrieren einer Anwendung mit Microsoft Entra ID

Implementieren einer einfachen, in Microsoft Entra integrierten Node.js-basierten Anwendung

Überprüfen der Funktionalität der Next.js-basierten Anwendung

Ergebnisse

Feedback