Ćwiczenie — implementowanie danych wielodostępnych

30 min

To ćwiczenie przeprowadzi Cię przez proces wykonywania następujących czynności:

Instalowanie usługi Azure Database for PostgreSQL w modelu wdrażania serwera.
Tworzenie bazy danych z przykładowymi danymi spisu.
Integrowanie serwera z identyfikatorem Entra firmy Microsoft.
Implementowanie prostej aplikacji opartej na Node.js, która wysyła zapytanie do bazy danych, korzystając z uwierzytelniania firmy Microsoft Entra.

Uwaga

W tym ćwiczeniu przedstawiono uproszczone podejście do zapewniania obsługi wielu dzierżaw przez emulowanie funkcji wielodostępności modelu wdrażania usługi Azure Database for the PostgreSQL w warstwie Hiperskala. Zapewnia również uproszczone podejście do implementowania uwierzytelniania firmy Microsoft Entra w scenariuszach wielodostępnych, korzystając z funkcji Microsoft Entra B2B. Identyfikator entra firmy Microsoft obsługuje bezpośrednio aplikacje wielodostępne, ale ich szczegółowe pokrycie wykracza poza zakres tego modułu.

W tym ćwiczeniu wykonasz następujące czynności:

Utwórz wystąpienie serwera usługi Azure Database for PostgreSQL.
Połącz się z serwerem usługi Azure Database for PostgreSQL.
Utwórz bazę danych i przykładowe tabele.
Zintegruj serwer usługi Azure Database for PostgreSQL z identyfikatorem Entra firmy Microsoft.
Rejestrowanie aplikacji usługi Tożsamości Microsoft Entra.
Zaimplementuj prostą zintegrowaną aplikację Node.js firmy Microsoft.
Zweryfikuj funkcjonalność aplikacji opartej na Node.js.

Wymagania wstępne

Aby wykonać to ćwiczenie, potrzebne są następujące elementy:

Aby ukończyć ćwiczenie Konfigurowanie identyfikatora entra firmy Microsoft w ramach subskrypcji platformy Azure.
Konto Microsoft lub konto Microsoft Entra z rolą administratora globalnego w dzierżawie Microsoft Entra skojarzonej z subskrypcją platformy Azure oraz z rolą Właściciel lub Współautor w subskrypcji platformy Azure.

Ostrzeżenie

Użyj środowiska testowego, ponieważ ćwiczenia w tym module wykonują poufne operacje, które wymagają podniesionych uprawnień administracyjnych.

Tworzenie wystąpienia serwera usługi Azure Database for PostgreSQL

Zaczniesz od utworzenia wystąpienia serwera usługi Azure Database for PostgreSQL:

W razie potrzeby uruchom przeglądarkę internetową, przejdź do witryny Azure Portal i zaloguj się, aby uzyskać dostęp do subskrypcji platformy Azure, której będziesz używać w tym module.
Użyj pola tekstowego Wyszukaj zasoby, usługi i dokumenty na początku strony witryny Azure Portal, aby wyszukać usługę Azure Database for PostgreSQL, a następnie na liście wyników w sekcji Usługi wybierz pozycję Azure Database for PostgreSQL.
W bloku Serwery usługi Azure Database for PostgreSQL wybierz pozycję + Utwórz.
W bloku Wybierz opcję wdrażania usługi Azure Database for PostgreSQL na kafelku Azure Database for PostgreSQL w polu Typ zasobu wybierz pozycję Pojedynczy serwer.
Wybierz pozycję Utwórz.

Na karcie Podstawy bloku Pojedynczy serwer skonfiguruj następujące ustawienia, a następnie wybierz pozycję Przejrzyj i utwórz, pozostawiając wszystkie inne ustawienia z ich wartościami domyślnymi:

Ustawienie	Konfigurowanie
Subskrypcja	Wybierz nazwę subskrypcji platformy Azure, której będziesz używać w tym module.
Grupa zasobów	Utwórz nową grupę zasobów o nazwie postgresql-db-RG.
Nazwa serwera	Wprowadź unikatową nazwę składającą się z małych liter, cyfr lub kreski oraz zaczynając od litery.
Źródło danych	Wybierz pozycję Brak.
Lokalizacja	Wybierz region świadczenia usługi Azure najbliżej lokalizacji środowiska laboratoryjnego, w którym można utworzyć wystąpienia usługi Azure Database for PostgreSQL.
Wersja	Wybierz pozycję 11.
Obliczenia i magazyn	Wybierz link Konfiguruj serwer. W bloku Konfiguruj wybierz pozycję Podstawowa, ustaw wartość rdzenia wirtualnegona 1, a pozycję Magazyn na 5 GB, a następnie wybierz przycisk OK.
Nazwa użytkownika administratora	Wprowadź studenta.
Hasło	Wprowadź wartość `<password>`.

Zrzut ekranu przedstawiający kartę Podstawowe w bloku serwera w witrynie Azure Portal.

Na karcie Przeglądanie i tworzenie bloku Pojedynczy serwer wybierz pozycję Utwórz.
Poczekaj na zakończenie aprowizacji. Może to potrwać około pięciu minut.

Uwaga

Proces aprowizacji automatycznie tworzy bazę danych o nazwie postgres na serwerze docelowym.

Nawiązywanie połączenia z serwerem usługi Azure Database for PostgreSQL

Po aprowizacji serwera usługi Azure Database for PostgreSQL połączysz się z nim przy użyciu narzędzia psql .

W bloku Microsoft.PostgreSQLServer.createPostgreSqlServer Overview (Omówienie serwera Microsoft.PostgreSQLServer) wybierz pozycję Przejdź do zasobu.
W bloku Wdrożenie w menu pionowym w sekcji Ustawienia wybierz pozycję Zabezpieczenia połączeń.
W bloku Zabezpieczenia połączenia ustaw opcję Zezwalaj na dostęp do usług platformy Azure na wartość Tak, wybierz pozycję + Dodaj adres IP klienta, ustaw pozycję Wymuszaj połączenie SSL na wartość WYŁĄCZONE, a następnie wybierz pozycję Zapisz.

Uwaga

Te ustawienia umożliwią łączność z bazą danych z komputera i z aplikacji działających na platformie Azure.

Uwaga

Wyłączenie wymuszania protokołu SSL ma na celu uproszczenie kolejnych ćwiczeń. Ogólnie rzecz biorąc, to ustawienie powinno być włączone.
W oknie przeglądarki wyświetlającym witrynę Azure Portal z blokiem Wdrażanie w menu pionowym wybierz pozycję Przegląd.
W sekcji Podstawy zidentyfikuj wpisy obok etykiet Nazwa serwera i Nazwa użytkownika administratora oraz zapisz ich wartości.

Uwaga

Pamiętaj, że nazwa użytkownika zawiera @ symbol, po którym następuje nazwa serwera określona w poprzednim zadaniu.
W oknie przeglądarki wyświetlającym witrynę Azure Portal z blokiem pojedynczego serwera usługi Azure Database for PostgreSQL w menu pionowym w sekcji Ustawienia wybierz pozycję Parametry połączenia.
Na liście parametry połączenia skopiuj wartość parametry połączenia psql i zapisz ją, aby można było jej użyć w dalszej części tego ćwiczenia.

Uwaga

Parametry połączenia ma następującą składnię, gdzie <server_name> symbol zastępczy reprezentuje nazwę serwera zidentyfikowanego wcześniej w tym zadaniu:
```
psql "host=<server_name>.postgres.database.azure.com port=5432 dbname={your_database} user=student@<server_name> password={your_password} sslmode=require"
```
W witrynie Azure Portal otwórz sesję powłoki Bash usługi Cloud Shell , wybierając jej ikonę na pasku narzędzi obok pola tekstowego wyszukiwania.
W sesji powłoki Bash w okienku usługi Cloud Shell wklej wartość parametry połączenia psql ze schowka, zmodyfikuj ją tak, aby była zgodna z poniższym poleceniem, a następnie uruchom ją, aby nawiązać połączenie z bazą danych postgres hostowaną w nowo wdrożonym wystąpieniu serwera usługi Azure Database for PostgreSQL. Wartość symbolu <server_name> zastępczego zostanie już uwzględniona w parametry połączenia wklejonym ze schowka:
```
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"
```
Uwaga

Po pomyślnym nawiązaniu połączenia zostanie wyświetlony postgres=> monit.

Tworzenie bazy danych i przykładowych tabel

W okienku postgres=> w wierszu polecenia uruchom następujące polecenie, aby utworzyć nową bazę danych o nazwie cnamtinventory:
```
CREATE DATABASE cnamtinventory;
```
Uruchom następujące polecenie, aby przełączyć połączenie z nowo utworzoną bazą danych:
```
\c cnamtinventory
```

Uruchom następujące polecenie, aby utworzyć tabelę dzierżaw:

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

Uruchom następujące polecenie, aby utworzyć tabelę spisu:

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;

Uwaga

Dane są partycjonowane na podstawie wartości kolumny daty.

Uruchom następujące polecenie, aby sprawdzić, czy tabela została pomyślnie utworzona:
```
\dt
```

Uruchom następujące polecenie, aby załadować przykładowe dane do tabeli dzierżaw:

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

Uruchom następujące polecenie, aby załadować przykładowe dane do tabeli spisu:

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

Uruchom następujące polecenie, aby sprawdzić, czy tabela spisu zawiera wstawione dane:
```
SELECT * FROM inventory;
```
Zamknij okienko usługi Cloud Shell.

Integrowanie serwera usługi Azure Database for PostgreSQL z identyfikatorem Entra firmy Microsoft

Aby zintegrować wystąpienie serwera usługi Azure Database for PostgreSQL z identyfikatorem Entra firmy Microsoft, musisz podać konto użytkownika usługi Microsoft Entra jako wyznaczonego administratora usługi Active Directory serwera. W tym celu użyjesz konta użytkownika adatumadmin1 utworzonego w poprzednim zadaniu. Musisz zalogować się na serwerze przy użyciu tego konta użytkownika. W tym momencie będzie można utworzyć użytkowników bazy danych opartych na identyfikatorze Entra firmy Microsoft i przypisać do nich role bazy danych. Będziesz używać dla obiektów adatumuser1, adatumgroup1 i contosouser1 Microsoft Entra utworzonych w poprzednim ćwiczeniu.

W oknie przeglądarki wyświetlającym witrynę Azure Portal z blokiem serwera usługi Azure Database for PostgreSQL w menu pionowym w sekcji Ustawienia wybierz pozycję Administrator usługi Active Directory, a następnie na pasku narzędzi wybierz pozycję Ustaw administratora.
W bloku administratora usługi Active Directory na liście kont użytkowników usługi Microsoft Entra wybierz konto użytkownika adatumadmin1 utworzone w poprzednim ćwiczeniu, wybierz pozycję Wybierz, a następnie wybierz pozycję Zapisz.
Otwórz inne okno przeglądarki internetowej w trybie Incognito/InPrivate, przejdź do witryny Azure Portal i zaloguj się przy użyciu konta użytkownika adatumadmin1 z hasłem utworzonym w poprzednim ćwiczeniu.
W witrynie Azure Portal otwórz usługę Cloud Shell , wybierając jej ikonę na pasku narzędzi obok pola tekstowego wyszukiwania.
Po wyświetleniu monitu o wybranie powłoki Bash lub programu PowerShell wybierz pozycję Bash, a następnie po wyświetleniu komunikatu Brak zainstalowanego magazynu wybierz pozycję Utwórz magazyn.
W sesji powłoki Bash w okienku usługi Cloud Shell uruchom następujące polecenia, aby pobrać i wyświetlić token dostępu firmy Microsoft Entra wymagany do uzyskania dostępu do usługi Azure Database for PostgreSQL:
```
FULL_TOKEN=$(az account get-access-token --resource-type oss-rdbms)
echo $FULL_TOKEN
```
Uwaga

Polecenie generuje dane wyjściowe zawierające token zakodowany w formacie Base 64, który identyfikuje uwierzytelnionego użytkownika w zasobie usługi Azure Database for PostgreSQL.

Dane wyjściowe używają następującego formatu:
```
{
  "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"
}
```
Uruchom następujące polecenie, aby ustawić wartość zmiennej PGPASSWORD na wartość tokenu dostępu z danych wyjściowych polecenia uruchomionego w poprzednim kroku:
```
export PGPASSWORD=$(echo $FULL_TOKEN | jq -r '.accessToken')
```
Uruchom następujące polecenie, aby nawiązać połączenie z bazą danych cnamtinventory przy użyciu narzędzia psql i przy użyciu uwierzytelniania Microsoft Entra (zastąp <server_name> symbol zastępczy nazwą serwera zidentyfikowanego wcześniej w tym ćwiczeniu):
```
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"
```
Uwaga

Po pomyślnym nawiązaniu połączenia powinien zostać wyświetlony cnamtinventory=> monit.
cnamtinventory=> W wierszu polecenia uruchom następujące polecenie, aby utworzyć rolę bazy danych odpowiadającą grupie adatumgroup1 firmy Microsoft Entra utworzonej w poprzednim ćwiczeniu:
```
CREATE ROLE "adatumgroup1" WITH LOGIN IN ROLE azure_ad_user;
```
Uruchom następujące polecenie, aby sprawdzić, czy role zostały pomyślnie utworzone:
```
SELECT rolname FROM pg_roles;
```
Uruchom następujące polecenie, aby udzielić uprawnień SELECT w tabeli spisudo grupy adatumgroup1 utworzonej w poprzednim ćwiczeniu:
```
GRANT SELECT ON inventory TO adatumgroup1;
```
Wyloguj się jako konto użytkownika adatumadmin1 i zamknij okno przeglądarki internetowej trybu Incognito/InPrivate.

Rejestrowanie aplikacji przy użyciu identyfikatora Entra firmy Microsoft

Aby zaimplementować przykładową aplikację opartą na Node.js, która używa uwierzytelniania Firmy Microsoft Entra w celu uzyskania dostępu do bazy danych usługi Azure Database for PostgreSQL, należy utworzyć obiekt aplikacji Entra firmy Microsoft i odpowiedni podmiot zabezpieczeń. Umożliwi to aplikacji opartej na Node.js personifikację użytkowników firmy Microsoft Entra podczas uzyskiwania dostępu do obiektów bazy danych.

W witrynie Azure Portal użyj pola tekstowego Wyszukaj zasoby, usługi i dokumenty, aby wyszukać identyfikator Entra firmy Microsoft, a następnie na liście wyników wybierz pozycję Microsoft Entra ID.
W bloku Microsoft Entra w menu pionowym w sekcji Zarządzanie wybierz pozycję Rejestracje aplikacji.
W bloku Rejestracje aplikacji wybierz pozycję + Nowa rejestracja.
W bloku Rejestrowanie aplikacji w polu tekstowym Nazwa wprowadź can-app. W sekcji Obsługiwane typy kont upewnij się, że wybrano opcję Konta tylko w tym katalogu organizacyjnym (tylko katalog domyślny — pojedyncza dzierżawa). W sekcji Identyfikator URI przekierowania (opcjonalnie) ustaw wpis internetowy na http://localhost:8080/redirect, a następnie wybierz pozycję Zarejestruj.

Uwaga

Istnieje możliwość skonfigurowania obsługi wielodostępnej dla zarejestrowanych aplikacji firmy Microsoft. Jednak szczegółowe pokrycie tego podejścia wykracza poza zakres tego modułu.

Uwaga

Po wdrożeniu aplikacji należy zmodyfikować wartość Identyfikator URI przekierowania (opcjonalnie), aby odzwierciedlić jej rzeczywisty adres URL.
W bloku can-app przejrzyj wynikowe ustawienia i zarejestruj wartości identyfikatora aplikacji (klienta) i właściwości identyfikatora katalogu (dzierżawy).
W bloku can-app w sekcji Zarządzanie wybierz pozycję Certyfikaty i wpisy tajne, a następnie wybierz pozycję + Nowy wpis tajny klienta.
W bloku Dodawanie wpisu tajnego klienta w polu tekstowym Opis wprowadź wartość can-secret-0. Pozostaw wpis listy rozwijanej Wygasa z wartością domyślną i wybierz pozycję Dodaj.
Powrót do aplikacji can-app | Blok Certyfikaty i wpisy tajne skopiuj wartość nowo wygenerowanego wpisu tajnego.

Uwaga

Pamiętaj, aby skopiować wartość wpisu tajnego przed przejściem z tego bloku, ponieważ w tym momencie nie będzie już można go pobrać. W takim przypadku utwórz kolejny wpis tajny.
W aplikacji can-app | Blok Certyfikaty i wpisy tajne w menu pionowym w sekcji Zarządzanie wybierz pozycję Uprawnienia interfejsu API.
W aplikacji can-app | Blok uprawnień interfejsu API, wybierz pozycję + Dodaj uprawnienie, w bloku Uprawnienia interfejsu API żądania wybierz kartę Interfejsy API używane przez moją organizację, w polu tekstowym wyszukiwania wprowadź wartość Azure OSSRDBMS Database, a następnie na liście wyników wybierz pozycję Azure OSSRDBMS Database.
W bloku Uprawnienia interfejsu API żądania wybierz pozycję Uprawnienia delegowane, zaznacz pole wyboru user_impersonation, a następnie wybierz pozycję Dodaj uprawnienia.
Powrót do aplikacji can-app | W bloku Uprawnienia interfejsu API wybierz pozycję Udziel zgody administratora dla katalogu domyślnego, a po wyświetleniu monitu o potwierdzenie wybierz pozycję Tak.
W aplikacji can-app | Blok uprawnień interfejsu API— sprawdź, czy udzielono uprawnień.

Implementowanie prostej zintegrowanej aplikacji Node.js firmy Microsoft

Aplikacja zarejestrowana w dzierżawie microsoft Entra umożliwia teraz kontynuowanie jej implementacji.

W witrynie Azure Portal uruchom sesję powłoki Bash w usłudze Cloud Shell , wybierając jej ikonę na pasku narzędzi obok pola tekstowego wyszukiwania.
W sesji powłoki Bash w okienku usługi Cloud Shell uruchom następujące polecenia, aby zainicjować projekt Node.js w nowym katalogu:
```
mkdir -p cna-aadexpress && cd cna-aadexpress
npm init -y
```
Uruchom następujące polecenia, aby dodać wymagane pakiety do zależności projektu:
```
npm install express
npm install pg
npm install @azure/msal-node
```
Uruchom następujące polecenie, aby utworzyć plik o nazwie index.js w katalogu głównym projektu:
```
touch ./index.js
```

Użyj edytora nano, aby otworzyć plik index.js i dodać następującą zawartość. W dalszej części tej lekcji utworzysz nazwę aplikacji, aby zastąpić symbol zastępczy <webapp_name>. Zastąp <client_id>wartości , <tenant_id>, <client_secret>i <server_name> (z wyłączeniem sufiksu .postgres.database.azure.com ) wartościami rzeczywistymi zarejestrowanymi wcześniej w tym ćwiczeniu:

Uwaga

Symbole <client_id> zastępcze i <tenant_id> odpowiadają identyfikatorowi aplikacji (klienta) oraz właściwościom identyfikatora katalogu (dzierżawy) przywołanych wcześniej w tym ćwiczeniu.

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

Uwaga

Aplikacja zarejestrowana w wielu dzierżawach firmy Microsoft używa adresu URL authority: "https://login.microsoftonline.com/common"urzędu ogólnego, ale w Twoim przypadku należy użyć adresu URL z jedną dzierżawą, który zawiera identyfikator dzierżawy.

Uwaga

Pamiętaj, że po wdrożeniu aplikacji należy zastąpić wartość adresu URL przekierowania rzeczywistym adresem URL przekierowania.

Użyj edytora nano, aby edytować plik package.json w katalogu głównym projektu i zastąpić go następującą zawartością:

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

Weryfikowanie funkcjonalności aplikacji opartej na Node.js

Na koniec możesz przetestować funkcje aplikacji internetowej. Chociaż można go konteneryzować, ze względu na prostotę, wdrożysz go w usłudze aplikacja systemu Azure. Zapewni to szybki sposób weryfikacji jego funkcjonalności i upewnienia się, że konteneryzowanie jej jest opłacalną opcją.

W sesji powłoki Bash w okienku usługi Cloud Shell uruchom następujące polecenia, aby utworzyć grupę zasobów, która będzie hostować aplikację internetową platformy Azure, w której wdrożysz aplikację 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
```
Uruchom następujące polecenia, aby utworzyć plan usługi aplikacja systemu Azure w warstwie Bezpłatna, który będzie hostować nową aplikację internetową platformy Azure:
```
SPNAME=aadexpress-sp
az appservice plan create --name $SPNAME --resource-group $RG2NAME --sku F1 --is-linux
```

Uruchom następujące polecenia, aby utworzyć nową aplikację internetową platformy Azure opartą na Node.js:

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

Uruchom następujące polecenia, aby zidentyfikować nazwę aplikacji internetowej:
```
echo $WEBAPPNAME
```
Użyj edytora nano, aby otworzyć plik index.js , zastąpić dwa <webapp_name> symbole zastępcze nazwą zidentyfikowaną w poprzednim kroku, zapisać zmiany i zamknąć plik.

Uwaga

Pamiętaj, aby zastąpić oba <webapp_name> symbole zastępcze.
Otwórz inną kartę w oknie przeglądarki internetowej z wyświetloną witryną Azure Portal, przejdź do witryny Azure Portal i, jeśli zostanie wyświetlony monit, zaloguj się, aby uzyskać dostęp do subskrypcji platformy Azure, której będziesz używać w tym module.
W witrynie Azure Portal użyj pola tekstowego Wyszukaj zasoby, usługi i dokumenty, aby wyszukać identyfikator Entra firmy Microsoft, a następnie na liście wyników wybierz pozycję Microsoft Entra ID.
W bloku Microsoft Entra przejdź do bloku Rejestracje aplikacji, wybierz wpis can-app w menu pionowym w sekcji Zarządzanie wybierz pozycję Uwierzytelnianie.
W aplikacji can-app | Blok uwierzytelniania zmodyfikuj wartość identyfikatora URI przekierowania, aby był zgodny z wpisem zaktualizowanym w pliku index.js i zapisz zmianę.
Wróć do karty przeglądarki internetowej wyświetlającej sesję powłoki Bash w okienku usługi Cloud Shell i uruchom następujące polecenia, aby zainicjować lokalne repozytorium Git i zatwierdzić wszystkie zmiany w gałęzi głównej:
```
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"
```

Uruchom następujące polecenia, aby skonfigurować poświadczenia wdrożenia na poziomie użytkownika:

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

Uruchom następujące polecenia, aby zidentyfikować poświadczenia wdrożenia na poziomie użytkownika i zarejestrować ich wartość, ponieważ będą one potrzebne w dalszej części tego zadania:
```
echo $DEPLOYMENTUSER
echo $DEPLOYMENTPASS
```

Uruchom następujące polecenia, aby zidentyfikować adres URL wdrożenia aplikacji internetowej platformy Azure, który będzie używany jako element docelowy git push polecenia:

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)

Uruchom następujące polecenie, aby skonfigurować repozytorium zdalne o nazwie azure reprezentujące adres URL wdrożenia zidentyfikowany w poprzednim kroku:
```
git remote add azure $DEPLOYMENTURL
```
Uruchom następujące polecenia, aby utworzyć gałąź testową na podstawie głównej gałęzi i wypchnąć jej zawartość do aplikacji internetowej platformy Azure (po wyświetleniu monitu o hasło będące częścią poświadczeń wdrożenia na poziomie użytkownika zarejestrowanych wcześniej w tym zadaniu):
```
git checkout -b test
git commit -a -m "testing"
git push --set-upstream azure test
```
Zamknij okienko usługi Cloud Shell.
Otwórz inne okno przeglądarki internetowej w trybie Incognito/InPrivate, przejdź do witryny Azure Portal i zaloguj się przy użyciu konta użytkownika adatumuser1 utworzonego w poprzednim ćwiczeniu.
W witrynie Azure Portal użyj pola tekstowego Wyszukaj zasoby, usługi i dokumenty na początku strony witryny Azure Portal, aby wyszukać usługę App Services.
W bloku App Services na liście wystąpień usługi App Service wybierz wpis reprezentujący nowo wdrożona aplikację internetową platformy Azure.
W bloku wyświetlającym właściwości aplikacji internetowej w sekcji Podstawy skopiuj wartość domyślnego adresu URL domeny .
Otwórz inną kartę w tym samym oknie przeglądarki i w polu wyszukiwania wprowadź https://, wklej właśnie skopiowany adres URL do schowka, dodaj sufiks /auth i wybierz Enter.

Uwaga

Adres URL powinien mieć następujący format: https://<webapp_name>.azurewebsites.net/auth
Sprawdź, czy wynikowa strona internetowa składa się z informacji o uwierzytelnianiu firmy Microsoft dla aktualnie zalogowanego użytkownika (dane wyjściowe mogą się różnić).

Wyniki

Gratulacje! Wykonano drugie ćwiczenie tego modułu. W tym ćwiczeniu zainstalowano usługę Azure Database for PostgreSQL w modelu wdrażania pojedynczego serwera, utworzono bazę danych z przykładowymi danymi spisu, zintegrowano serwer z identyfikatorem Microsoft Entra ID i zaimplementowano prostą aplikację opartą na Node.js, która wysyła zapytanie do bazy danych, opierając się na uwierzytelnianiu firmy Microsoft Entra.

Ćwiczenie — implementowanie danych wielodostępnych

Wymagania wstępne

Tworzenie wystąpienia serwera usługi Azure Database for PostgreSQL

Nawiązywanie połączenia z serwerem usługi Azure Database for PostgreSQL

Tworzenie bazy danych i przykładowych tabel

Integrowanie serwera usługi Azure Database for PostgreSQL z identyfikatorem Entra firmy Microsoft

Rejestrowanie aplikacji przy użyciu identyfikatora Entra firmy Microsoft

Implementowanie prostej zintegrowanej aplikacji Node.js firmy Microsoft

Weryfikowanie funkcjonalności aplikacji opartej na Node.js

Wyniki

Opinia