Csatlakozás az Azure SQL Database-hez Node.js és mssql npm-csomag használatával

A következőkre vonatkozik:Azure SQL Database

Ez a rövid útmutató bemutatja, hogyan csatlakoztathat egy alkalmazást egy Adatbázishoz az Azure SQL Database-ben, és hogyan hajthat végre lekérdezéseket Node.js és mssql használatával. Ez a rövid útmutató az adatbázishoz való csatlakozás ajánlott jelszó nélküli megközelítését követi.

Jelszó nélküli kapcsolatok fejlesztőknek

A jelszó nélküli kapcsolatok biztonságosabb mechanizmust biztosítanak az Azure-erőforrások eléréséhez. A következő magas szintű lépések használatával csatlakozhat az Azure SQL Database-hez jelszó nélküli kapcsolatok használatával ebben a cikkben:

A környezet előkészítése jelszó nélküli hitelesítésre.
- Helyi környezet esetén: A rendszer az Ön személyes identitását használja. Ez az azonosító IDE-ből, CLI-ből vagy más helyi fejlesztési eszközből lekérhető.
- Felhőkörnyezet esetén: A rendszer egy felügyelt identitást használ.
Autentikáljon a környezetben az Azure Identity könyvtár DefaultAzureCredential használatával egy ellenőrzött hitelesítő adat megszerzéséhez.
Az ellenőrzött hitelesítő adatok használatával Azure SDK-ügyfélobjektumokat hozhat létre az erőforrás-hozzáféréshez.

További információt találhatsz a jelszó nélküli kapcsolatokról a jelszó nélküli platformon.

Előfeltételek

Egy Azure-előfizetés
Az Azure SQL Database-ben a Microsoft Entra ID-val való hitelesítésre konfigurált adatbázis (korábban Azure Active Directory). Létrehozhat egyet az Adatbázis rövid útmutató létrehozásasegítségével.
Bash-kompatibilis rendszerhéj
Node.js LTS-
Visual Studio Code
Visual Studio Code App Service-bővítmény
Az Azure CLI legújabb verziója

Az adatbázis-kiszolgáló konfigurálása

Az Azure SQL Database biztonságos, jelszó nélküli kapcsolataihoz bizonyos adatbázis-konfigurációk szükségesek. Ellenőrizze a következő beállításokat a logikai kiszolgálón az Azure-ben, hogy megfelelően csatlakozzon az Azure SQL Database-hez helyi és üzemeltetett környezetekben is:

Helyi fejlesztési kapcsolatok esetén győződjön meg arról, hogy a logikai kiszolgáló úgy van konfigurálva, hogy a helyi gép IP-címe és más Azure-szolgáltatások kapcsolódhassanak:
- Lépjen a kiszolgáló hálózatkezelési lapjára.
- A Kijelölt hálózatok rádiógomb bekapcsolásával további konfigurációs beállításokat jelenít meg.
- Válassza Adja hozzá az ügyfél IPv4-címét (xx.xx.xx.xx.xx) egy tűzfalszabály hozzáadásához, amely engedélyezi a helyi gép IPv4-címéről érkező kapcsolatokat. Másik lehetőségként választhatja a + Tűzfalszabály hozzáadása lehetőséget is egy tetszőleges IP-cím megadásához.
- Győződjön meg arról, hogy a Az Azure-szolgáltatások és -erőforrások hozzáférésének engedélyezése a kiszolgálóhoz jelölőnégyzet be van jelölve.
  Figyelmeztetés
  
  A „Az Azure-szolgáltatások és -erőforrások hozzáférésének engedélyezése ehhez a kiszolgálóhoz” beállítás engedélyezése nem ajánlott biztonsági gyakorlat éles helyzetekben. A valós alkalmazásoknak biztonságosabb megközelítéseket kell implementálniuk, például erősebb tűzfalkorlátozásokat vagy virtuális hálózati konfigurációkat.
  
  Az adatbázis biztonsági konfigurációiról az alábbi forrásokban olvashat bővebben:
  - Azure SQL Database tűzfalszabályok konfigurálása.
  - Virtuális hálózat konfigurálása privát végpontokkal.
A kiszolgálónak engedélyeznie kell a Microsoft Entra-hitelesítést is, és hozzá kell rendelnie egy Microsoft Entra rendszergazdai fiókot. Helyi fejlesztési kapcsolatok esetén a Microsoft Entra rendszergazdai fióknak olyan fióknak kell lennie, amellyel helyileg is bejelentkezhet a Visual Studióba vagy az Azure CLI-be. Ellenőrizheti, hogy a kiszolgálón engedélyezve van-e a Microsoft Entra-hitelesítés a logikai kiszolgáló Microsoft Entra-azonosító lapján.
Ha személyes Azure-fiókot használ, győződjön meg arról, hogy Microsoft Entra-t állította be és konfigurálta az Azure SQL Database- a fiók kiszolgálói rendszergazdaként való hozzárendeléséhez. Ha vállalati fiókot használ, a Microsoft Entra-azonosító valószínűleg már konfigurálva lesz Az Ön számára.

A projekt létrehozása

A szakasz lépései létrehoznak egy Node.js REST API-t.

Hozzon létre egy új könyvtárat a projekthez, és navigáljon bele.
A projekt inicializálásához futtassa a következő parancsot a terminálban:
```
npm init -y
```
Telepítse az ebben a cikkben szereplő mintakódban használt szükséges csomagokat:
```
npm install mssql express swagger-ui-express yamljs dotenv
```
Nyissa meg a projektet a Visual Studio Code-ban.
```
code .
```
Nyissa meg a package.json fájlt, és adja hozzá a következő tulajdonságot és értéket a név tulajdonság után az ESM-modulok projektjének konfigurálásához.
```
"type": "module",
```

Express.js alkalmazáskód létrehozása

Az Express.js OpenAPI-alkalmazás létrehozásához több fájlt is létre kell hoznia:

Fájl	Leírás
`.env.development`	Csak helyi fejlesztésű környezeti fájl.
`index.js`	Fő alkalmazásfájl, amely elindítja a Express.js alkalmazást a 3000-s porton.
`person.js`	Express.js /person útvonal API-fájl a CRUD műveletek kezelésére.
`openapi.js`	Express.js /api-docs útvonal az OpenAPI Explorer felhasználói felületéhez. A gyökér erre az útvonalra irányít át.
`openApiSchema.yml`	A Person API-t meghatározó OpenAPI 3.0 sémafájl.
`config.js`	Konfigurációs fájl a környezeti változók olvasásához és a megfelelő mssql kapcsolati objektum létrehozásához.
`database.js`	Adatbázisosztály az Azure SQL CRUD-műveletek kezeléséhez az mssql npm-csomag használatával.
`./vscode/settings.json`	A fájlok figyelmen kívül hagyása globális mintázat alapján a telepítés során.

Hozzon létre egy index.js fájlt, és adja hozzá a következő kódot:

import express from 'express';

// Import App routes
import person from './person.js';
import openapi from './openapi.js';

const port = process.env.PORT || 3000;

const app = express();

// Connect App routes
app.use('/api-docs', openapi);
app.use('/persons', person);
app.use('*', (_, res) => {
  res.redirect('/api-docs');
});

// Start the server
app.listen(port, () => {
  console.log(`Server started on port ${port}`);
});

Hozzon létre egy person.js útvonalfájlt, és adja hozzá a következő kódot:

import express from 'express';
import { 
  passwordConfig as SQLAuthentication, 
  noPasswordConfig as PasswordlessConfig 
} from './config.js';
import { createDatabaseConnection } from './database.js';

const router = express.Router();
router.use(express.json());

const database = await createDatabaseConnection(SQLAuthentication);

router.get('/', async (req, res) => {
  try {
    // Return a list of persons

    const persons = await database.readAll();
    console.log(`persons: ${JSON.stringify(persons)}`);
    res.status(200).json(persons);
  } catch (err) {
    res.status(500).json({ error: err?.message });
  }
});

router.post('/', async (req, res) => {
  try {
    // add a person
    const person = req.body;
    console.log(`person: ${JSON.stringify(person)}`);
    const rowsAffected = await database.create(person);
    res.status(201).json({ rowsAffected });
  } catch (err) {
    res.status(500).json({ error: err?.message });
  }
});

router.get('/:id', async (req, res) => {
  try {
    // Get the person with the specified ID
    const personId = req.params.id;
    console.log(`personId: ${personId}`);
    if (personId) {
      const result = await database.read(personId);
      console.log(`persons: ${JSON.stringify(result)}`);
      res.status(200).json(result);
    } else {
      res.status(404);
    }
  } catch (err) {
    res.status(500).json({ error: err?.message });
  }
});

router.put('/:id', async (req, res) => {
  try {
    // Update the person with the specified ID
    const personId = req.params.id;
    console.log(`personId: ${personId}`);
    const person = req.body;

    if (personId && person) {
      delete person.id;
      console.log(`person: ${JSON.stringify(person)}`);
      const rowsAffected = await database.update(personId, person);
      res.status(200).json({ rowsAffected });
    } else {
      res.status(404);
    }
  } catch (err) {
    res.status(500).json({ error: err?.message });
  }
});

router.delete('/:id', async (req, res) => {
  try {
    // Delete the person with the specified ID
    const personId = req.params.id;
    console.log(`personId: ${personId}`);

    if (!personId) {
      res.status(404);
    } else {
      const rowsAffected = await database.delete(personId);
      res.status(204).json({ rowsAffected });
    }
  } catch (err) {
    res.status(500).json({ error: err?.message });
  }
});

export default router;

A jelszó nélküli hitelesítéshez módosítsa a createDatabaseConnection-ba átadott paramétert SQLAuthentication-ről PasswordlessConfig-re.

const database = await createDatabaseConnection(PasswordlessConfig);

Hozzon létre egy openapi.js útvonalfájlt, és adja hozzá a következő kódot az OpenAPI felhasználói felület kezelőjéhez:

import express from 'express';
import { join, dirname } from 'path';
import swaggerUi from 'swagger-ui-express';
import yaml from 'yamljs';
import { fileURLToPath } from 'url';

const __dirname = dirname(fileURLToPath(import.meta.url));

const router = express.Router();
router.use(express.json());

const pathToSpec = join(__dirname, './openApiSchema.yml');
const openApiSpec = yaml.load(pathToSpec);

router.use('/', swaggerUi.serve, swaggerUi.setup(openApiSpec));

export default router;

Hozzon létre egy openApiSchema.yml fájlt, és adja hozzá a következő kódot, hogy az OpenAPI felhasználói felület kezelője tudja, milyen API-k és modellek jelenjenek meg:

openapi: 3.0.0
info:
  version: 1.0.0
  title: Persons API
paths:
  /persons:
    get:
      summary: Get all persons
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Person'
    post:
      summary: Create a new person
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Person'
      responses:
        '201':
          description: Created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Person'
  /persons/{id}:
    parameters:
      - name: id
        in: path
        required: true
        schema:
          type: integer
    get:
      summary: Get a person by ID
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Person'
        '404':
          description: Person not found
    put:
      summary: Update a person by ID
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Person'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Person'
        '404':
          description: Person not found
    delete:
      summary: Delete a person by ID
      responses:
        '204':
          description: No Content
        '404':
          description: Person not found
components:
  schemas:
    Person:
      type: object
      properties:
        id:
          type: integer
          readOnly: true
        firstName:
          type: string
        lastName:
          type: string

Az mssql kapcsolati objektum konfigurálása

Az mssql csomag egy hitelesítési típus konfigurációs beállításával valósítja meg az Azure SQL Database-hez való kapcsolatot.

A Visual Studio Code-ban hozzon létre egy config.js fájlt, és adja hozzá a következő mssql-konfigurációs kódot az Azure SQL Database-hitelesítéshez.

import * as dotenv from 'dotenv';

if(process.env.NODE_ENV === 'development') {
  dotenv.config({ path: `.env.${process.env.NODE_ENV}`, debug: true });
}

// TIP: Port must be a number, not a string!
const server = process.env.AZURE_SQL_SERVER;
const database = process.env.AZURE_SQL_DATABASE;
const port = +process.env.AZURE_SQL_PORT;
const type = process.env.AZURE_SQL_AUTHENTICATIONTYPE;
const user = process.env.AZURE_SQL_USER;
const password = process.env.AZURE_SQL_PASSWORD;

export const noPasswordConfig = {
  server,
  port,
  database,
  authentication: {
    type
  },
  options: {
    encrypt: true
  }
};

export const passwordConfig = {
  server,
  port,
  database,
  user,
  password,
  options: {
    encrypt: true
  }
};

Helyi környezeti változófájl létrehozása

.env.development fájl létrehozása a helyi környezeti változókhoz

jelszó nélküli (ajánlott)
SQL-hitelesítés

Adja hozzá a következő szöveget, és frissítse a <YOURSERVERNAME> és <YOURDATABASENAME>értékeit.

AZURE_SQL_SERVER=<YOURSERVERNAME>.database.windows.net
AZURE_SQL_DATABASE=<YOURDATABASENAME>
AZURE_SQL_PORT=1433
AZURE_SQL_AUTHENTICATIONTYPE=azure-active-directory-default

Jegyzet

A jelszó nélküli konfigurációs objektumok biztonságosan véglegesítik a forrásvezérlést, mivel nem tartalmaznak titkos kódokat, például felhasználóneveket, jelszavakat vagy hozzáférési kulcsokat.

Adja hozzá a következő szöveget, és frissítse a <YOURSERVERNAME>, <YOURDATABASENAME>, <YOURUSERNAME>és <YOURPASSWORD>értékeit.

AZURE_SQL_SERVER=<YOURSERVERNAME>.database.windows.net
AZURE_SQL_DATABASE=<YOURDATABASENAME>
AZURE_SQL_PORT=1433
AZURE_SQL_USER=<YOURUSERNAME>
AZURE_SQL_PASSWORD=<YOURPASSWORD>

Figyelmeztetés

Az Azure SQL Database-hez való csatlakozáshoz használt kód hozzáadása

Hozzon létre egy database.js fájlt, és adja hozzá a következő kódot:

import sql from 'mssql';

let database = null;

export default class Database {
  config = {};
  poolconnection = null;
  connected = false;

  constructor(config) {
    this.config = config;
  }

  async connect() {
    try {
      this.poolconnection = await sql.connect(this.config);
      this.connected = true;
      console.log('Database connected successfully.');
      return this.poolconnection;
    } catch (error) {
      console.error('Error connecting to the database:', error);
      this.connected = false;
    }
  }

  async disconnect() {
    try {
      if (this.connected) {
        await this.poolconnection.close();
        this.connected = false;
        console.log('Database disconnected successfully.');
      }
    } catch (error) {
      console.error('Error disconnecting from the database:', error);
    }
  }

  async executeQuery(query) {
    const request = this.poolconnection.request();
    const result = await request.query(query);

    return result.rowsAffected[0];
  }

  async create(data) {
    const request = this.poolconnection.request();

    request.input('firstName', sql.NVarChar(255), data.firstName);
    request.input('lastName', sql.NVarChar(255), data.lastName);

    const result = await request.query(
      `INSERT INTO Person (firstName, lastName) VALUES (@firstName, @lastName)`
    );

    return result.rowsAffected[0];
  }

  async readAll() {
    const request = this.poolconnection.request();
    const result = await request.query(`SELECT * FROM Person`);

    return result.recordsets[0];
  }

  async read(id) {
    const request = this.poolconnection.request();
    const result = await request
      .input('id', sql.Int, +id)
      .query(`SELECT * FROM Person WHERE id = @id`);

    return result.recordset[0];
  }

  async update(id, data) {
    const request = this.poolconnection.request();

    request.input('id', sql.Int, +id);
    request.input('firstName', sql.NVarChar(255), data.firstName);
    request.input('lastName', sql.NVarChar(255), data.lastName);

    const result = await request.query(
      `UPDATE Person SET firstName=@firstName, lastName=@lastName WHERE id = @id`
    );

    return result.rowsAffected[0];
  }

  async delete(id) {
    const idAsNumber = Number(id);

    const request = this.poolconnection.request();
    const result = await request
      .input('id', sql.Int, idAsNumber)
      .query(`DELETE FROM Person WHERE id = @id`);

    return result.rowsAffected[0];
  }

  async createTable() {
    if (process.env.NODE_ENV === 'development') {
      this.executeQuery(
        `IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Person')
         BEGIN
           CREATE TABLE Person (
             id int NOT NULL IDENTITY, 
             firstName varchar(255), 
             lastName varchar(255)
           );
         END`
      )
        .then(() => {
          console.log('Table created');
        })
        .catch((err) => {
          // Table may already exist
          console.error(`Error creating table: ${err}`);
        });
    }
  }
}

export const createDatabaseConnection = async (passwordConfig) => {
  database = new Database(passwordConfig);
  await database.connect();
  await database.createTable();
  return database;
};

Az alkalmazás helyi tesztelése

Az alkalmazás készen áll a helyi tesztelésre. Győződjön meg arról, hogy ugyanazzal a fiókkal jelentkezett be az Azure Cloudba a Visual Studio Code-ban, mint az adatbázis rendszergazdája.

Futtassa az alkalmazást a következő paranccsal. Az alkalmazás a 3000-s porton kezdődik.
```
NODE_ENV=development node index.js
```
A Person tábla az alkalmazás futtatásakor jön létre az adatbázisban.
Egy böngészőben lépjen az OpenAPI-felfedezőre a http://localhost:3000-n.
A Swagger felhasználói felületén bontsa ki a POST metódust, és válassza a Kipróbáláslehetőséget.
Módosítsa a JSON-mintát úgy, hogy a tulajdonságok értékeit is tartalmazza. Az azonosító tulajdonság figyelmen kívül lesz hagyva.
Válassza a Végrehajtás lehetőséget, ha új rekordot szeretne hozzáadni az adatbázishoz. Az API sikeres választ ad vissza.
Bontsa ki a GET metódust a Swagger felhasználói felületén, és válassza a Próbálja kilehetőséget. Válassza a Végrehajtáslehetőséget, és a rendszer visszaadja az imént létrehozott személyt.

Projekt konfigurálása zip-alapú üzembe helyezéshez

Hozzon létre egy .vscode mappát, és hozzon létre egy settings.json fájlt a mappában.
Adja hozzá az alábbiakat a környezeti változók és függőségek figyelmen kívül hagyásához a zip-telepítés során.
```
{
    "appService.zipIgnorePattern": ["./.env*","node_modules{,/**}"]
}
```

Üzembe helyezés az Azure App Service-ben

Az alkalmazás készen áll az Azure-ban való üzembe helyezésre. A Visual Studio Code létrehozhat egy Azure App Service-t, és egyetlen munkafolyamatban telepítheti az alkalmazást.

Győződjön meg arról, hogy az alkalmazás le van állítva.
Ha még nem tette meg, jelentkezzen be az Azure-ba, a Azure: Bejelentkezés az Azure Cloud parancsot kiválasztva a Parancspalettában (Ctrl + Shift + P)
A Visual Studio Code Azure Explorer ablakában kattintson a jobb gombbal az App Services csomópontra, és válassza az Új webalkalmazás létrehozása (Speciális)lehetőséget.

Az App Service létrehozásához használja az alábbi táblázatot:

Haladéktalan	Érték
Adjon meg egy globálisan egyedi nevet az új webalkalmazásnak.	Írjon be egy utasítást, például `azure-sql-passwordless`. Fűzzön hozzá egy egyedi karakterláncot, például `123`.
Válasszon egy erőforráscsoportot az új erőforrásokhoz.	Válassza +Új erőforráscsoport létrehozása majd válassza ki az alapértelmezett nevet.
Válasszon ki egy futtatási környezetet.	Válassza ki a Node.js köteg LTS verzióját.
Válasszon ki egy operációs rendszert.	Válassza Linuxlehetőséget.
Válasszon egy helyet az új erőforrásokhoz.	Válasszon egy Önhöz közeli helyet.
Válasszon egy Linux App Service-csomagot.	Válassza Új App Service-csomag létrehozása lehetőséget. majd válassza ki az alapértelmezett nevet.
Válasszon egy tarifacsomagot.	Válassza az Ingyenes (F1)lehetőséget.
Válasszon egy Application Insights-erőforrást az alkalmazáshoz.	Válassza Kihagyás egyelőrelehetőséget.

Várjon, amíg értesítést kap arról, hogy az alkalmazás elkészült, mielőtt folytatja.
Az Azure Exploreralkalmazásban bontsa ki a App Services csomópontot, és kattintson a jobb gombbal az új alkalmazásra.
Válassza a Webalkalmazásba történő üzembe helyezéslehetőséget.
Válassza ki a JavaScript-projekt gyökérmappáját.
Amikor megjelenik a Visual Studio Code előugró ablaka, válassza a Üzembe helyezéslehetőséget.

Amikor az üzembe helyezés befejeződik, az alkalmazás nem működik megfelelően az Azure-ban. Az adatok lekéréséhez továbbra is konfigurálnia kell az App Service és az SQL-adatbázis közötti biztonságos kapcsolatot.

Az App Service csatlakoztatása az Azure SQL Database-hez

jelszó nélküli (ajánlott)
SQL-hitelesítés

Az App Service-példány azure SQL Database-hez való csatlakoztatásához a következő lépések szükségesek:

Felügyelt identitás létrehozása az App Service-hez.
Hozzon létre egy SQL-adatbázis-felhasználót, és társítsa azt az App Service által felügyelt identitáshoz.
Sql-szerepkörök hozzárendelése az adatbázis-felhasználóhoz, amely lehetővé teszi az olvasási, írási és potenciálisan egyéb engedélyeket.

A lépések végrehajtásához több eszköz is rendelkezésre áll:

Szolgáltatáskapcsoló (ajánlott)
Azure Portál

A Service Connector egy olyan eszköz, amely leegyszerűsíti a hitelesített kapcsolatokat az Azure különböző szolgáltatásai között. A Service Connector jelenleg támogatja az App Service azure SQL-adatbázishoz való csatlakoztatását az Azure CLI-vel a az webapp connection create sql paranccsal. Ez az egyetlen parancs végrehajtja a fent említett három lépést.

Felügyelt identitás létrehozása a Service Connector használatával

Futtassa a következő parancsot az Azure Portal Cloud Shelljében. A Cloud Shell az Azure CLI legújabb verzióját használja. Cserélje le a <> változóit a saját értékeire.

az webapp connection create sql \
    -g <app-service-resource-group> \
    -n <app-service-name> \
    --tg <database-server-resource-group> \
    --server <database-server-name> \
    --database <database-name> \
    --system-identity

Az App Service alkalmazásbeállításainak ellenőrzése

A Service Connector által végzett módosításokat az App Service beállításai között ellenőrizheti.

A Visual Studio Code-ban az Azure Explorerben kattintson a jobb gombbal az App Service-re, és válassza a Megnyitás a portálonlehetőséget.
Navigáljon az App Service Identity oldalára. A Rendszer által hozzárendelt lapon az Állapot beállítása legyen On. Ez az érték azt jelenti, hogy a rendszer által hozzárendelt felügyelt identitás engedélyezve lett az alkalmazás számára.
Lépjen az App Service Konfigurációs lapjára. Az Alkalmazásbeállítások lapon számos környezeti változónak kell megjelennie, amelyek már szerepeltek az mssql konfigurációs objektumban.
- AZURE_SQL_SERVER
- AZURE_SQL_DATABASE
- AZURE_SQL_PORT
- AZURE_SQL_AUTHENTICATIONTYPE
Ne törölje vagy módosítsa a tulajdonságneveket vagy értékeket.

Az Azure Portalon felügyelt identitásokkal dolgozhat, és lekérdezéseket futtathat az Azure SQL Database-en. Hajtsa végre az alábbi lépéseket, hogy jelszó nélküli kapcsolatot hozzon létre az App Service-példányból az Azure SQL Database-be:

A felügyelt identitás létrehozása

Az Azure portálon keresse meg az App Service szolgáltatását, és válassza a Identitás lehetőséget a bal oldali navigációs sávban.
Az identitás lapon változtassa meg a rendszer által hozzárendelt állapotot be, és válassza a Mentés lehetőséget.
Amikor az identitás engedélyezésére kérik, válassza az Igenlehetőséget.

Ha ez a beállítás engedélyezve van, egy rendszer által hozzárendelt felügyelt identitás jön létre ugyanazzal a névvel, mint az App Service. A rendszer által hozzárendelt identitások a szolgáltatáspéldányhoz vannak kötve, és törléskor az alkalmazással együtt megsemmisülnek.

Az adatbázis-felhasználó létrehozása és szerepkörök hozzárendelése

Az Azure Portalon keresse meg az SQL-adatbázist, és válassza Lekérdezésszerkesztő (előzetes verzió)lehetőséget.
Válassza a képernyő jobb oldalán a Folytatás <your-username> lehetőséget, hogy a fiókjával bejelentkezzen az adatbázisba.
A lekérdezésszerkesztő nézetben futtassa a következő T-SQL-parancsokat. Cserélje le <your-app-service-name> az App Service-erőforrás nevére.
```
CREATE USER "<your-app-service-name>" FROM EXTERNAL PROVIDER;
ALTER ROLE db_datareader ADD MEMBER "<your-app-service-name>";
ALTER ROLE db_datawriter ADD MEMBER "<your-app-service-name>";
ALTER ROLE db_ddladmin ADD MEMBER "<your-app-service-name>";
GO
```
Ez az SQL-szkript létrehoz egy SQL-adatbázis-felhasználót, amely az App Service példány felügyelt identitásához tartozik. Emellett hozzárendeli a szükséges SQL-szerepköröket a felhasználóhoz, hogy lehetővé tegye az alkalmazás számára az adatbázis adatainak és sémájának olvasását, írását és módosítását. A lépés befejezése után a szolgáltatások csatlakoztatva lesznek.

Fontos

Bár ez a megoldás egyszerű módja a kezdésnek, nem legjobb gyakorlat a termelési szintű környezetekben. Ezekben az esetekben az alkalmazás nem végezhet el minden műveletet egyetlen emelt szintű identitás használatával. Próbálja meg implementálni a minimális jogosultság elvét úgy, hogy több identitást konfigurál bizonyos feladatokhoz adott engedélyekkel.

Az adatbázis-szerepkörök és a biztonság konfigurálásáról az alábbi forrásokban olvashat bővebben:

Az App Service alkalmazásbeállításainak létrehozása

Az Azure portálon lépjen az App Service szolgáltatásához, és válassza a bal oldali navigációs sávon a Konfiguráció lehetőséget.
Az alábbi környezeti változókhoz válassza az + Új alkalmazásbeállítás lehetőséget. Adjon hozzá saját megfelelő értéket az App Service-példányhoz szükséges környezeti változók létrehozásához az adatbázishoz való csatlakozáshoz.
```
AZURE_SQL_SERVER=<YOURSERVERNAME>.database.windows.net
AZURE_SQL_DATABASE=<YOURDATABASENAME>
AZURE_SQL_PORT=1433
AZURE_SQL_AUTHENTICATIONTYPE=azure-active-directory-default
```
Ha befejezte a beállítások hozzáadását, válassza a Mentéslehetőséget.

A Visual Studio Code-ban az Azure Explorerben kattintson a jobb gombbal az App Service-re, és válassza a Megnyitás a portálonlehetőséget.
Lépjen az App Service Konfigurációs lapjára. Az Alkalmazásbeállítások lapon hozzon létre környezeti változókat az alábbi táblázatban szereplő egyes tulajdonságokhoz saját értékekkel.
```
AZURE_SQL_SERVER=<YOURSERVERNAME>.database.windows.net
AZURE_SQL_DATABASE=<YOURDATABASENAME>
AZURE_SQL_PORT=1433
AZURE_SQL_USER=<YOURUSERNAME>
AZURE_SQL_PASSWORD=<PASSWORD>
NODE_ENV=development
```

Figyelmeztetés

Óvatosan kezelje a titkos kódokat, például felhasználóneveket, jelszavakat vagy hozzáférési kulcsokat tartalmazó kapcsolatobjektumokat. Ezeket a titkos kulcsokat nem szabad a forráskezelésre kötelezni, és nem biztonságos helyekre helyezni, ahol nem szándékos felhasználók férhetnek hozzá. Éles üzemű Azure-környezetben valós alkalmazás esetén biztonságos helyen tárolhatja a kapcsolati adatokat, például az App Service konfigurációs beállításait vagy az Azure Key Vaultot. A helyi fejlesztés során általában olyan helyi adatbázishoz fog csatlakozni, amely nem igényel titkos kulcsok tárolását vagy közvetlenül az Azure-hoz való csatlakozást.

Az üzembe helyezett alkalmazás tesztelése

Keresse meg az alkalmazás URL-címét, és ellenőrizze, hogy működik-e a kapcsolat az Azure SQL Database-hez. Az alkalmazás URL-címét az App Service áttekintési oldalán találja.

A helyileg létrehozott személynek meg kell jelennie a böngészőben. Gratulálok! Az alkalmazás mostantól helyi és üzemeltetett környezetben is csatlakozik az Azure SQL Database-hez.

Borravaló

Ha a tesztelés során 500 belső kiszolgálóhiba jelenik meg, annak oka az adatbázis hálózati konfigurációja lehet. Ellenőrizze, hogy a logikai kiszolgáló a Az adatbázis konfigurálása szakaszban ismertetett beállításokkal van-e konfigurálva.

Az erőforrások törlése

Ha befejezte az Azure SQL Database használatát, törölje az erőforrást a nem tervezett költségek elkerülése érdekében.

Azure Portál
Azure CLI

Az Azure Portal keresősávjában keressen Azure SQL-, és válassza ki a megfelelő találatot.
Keresse meg és jelölje ki az adatbázist az adatbázisok listájában.
Az Azure SQL Database Áttekintés lapján válassza a Törléslehetőséget.
Biztosan törölni szeretné az Azure... a lapon, amely megnyílik, írja be az adatbázis nevét a művelet megerősítéséhez, majd válassza a Törléslehetőséget.

Törölje az adatbázist a az sql db delete paranccsal. Cserélje le a helyőrző paramétereket a saját értékeire.

az sql db delete --name <database-name> --resource-group <resource-group-name> --server <logical-server-name>

Mintakód

Az alkalmazás mintakódja elérhető:

Következő lépések

oktatóanyag: Adatbázis védelme az Azure SQL Database-ben
Engedélyezz adatbázis-hozzáférést az SQL-adatbázis--hez
Az Azure SQL Database biztonsági képességeinek áttekintése
Az Azure SQL Database biztonsági ajánlott eljárásainak

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-03-05