Wprowadzenie do baz danych na platformie Azure

  • Artykuł

Platforma w chmurze platformy Azure umożliwia korzystanie z dowolnych baz danych platformy Azure (jako usług) lub korzystanie z własnej bazy danych. Po skonfigurowaniu serwera i bazy danych istniejący kod będzie musiał zmienić tylko ustawienia połączenia.

W przypadku korzystania z bazy danych na platformie Azure istnieje kilka typowych zadań, które należy wykonać w celu korzystania z bazy danych z poziomu aplikacji JavaScript. Dowiedz się więcej na temat uzyskiwania i używania bazy danych na platformie Azure.

Wybieranie bazy danych do użycia na platformie Azure

Firma Microsoft udostępnia usługi zarządzane dla następujących baz danych:

Przewodnik deweloperski bazy danych Usługa platformy Azure
Cassandra Azure Cosmos DB
Gremlin Azure Cosmos DB
MongoDB Azure Cosmos DB
MariaDB/MySQL Azure Database for MariaDB
PostgreSQL Azure Database for PostgreSQL
Redis Azure Cache for Redis
No-SQL Azure Cosmos DB
SQL Azure SQL DB
Tabele Azure Cosmos DB
Azure SQL DB

Wybierz typ bazy danych:

Nie znaleziono bazy danych? Przełącz bazę danych jako kontener lub maszynę wirtualną. Możesz przenieść dowolny typ bazy danych z tymi usługami i mieć wysoką dostępność i zabezpieczenia do innych zasobów platformy Azure. Kompromis polega na tym, że musisz samodzielnie zarządzać infrastrukturą (kontenerem lub maszyną wirtualną). Pozostała część tego dokumentu może pomóc w pracy z kontenerem lub maszyną wirtualną, ale jest bardziej przydatna podczas wybierania usługi bazy danych platformy Azure.

Tworzenie serwera

Tworzenie serwera zostało ukończone przez utworzenie zasobu dla określonej usługi platformy Azure w ramach subskrypcji, w której jest hostowana baza danych.

Tworzenie zasobu odbywa się za pomocą:

Narzędzie Przeznaczenie
Azure Portal Użyj polecenia dla pierwszej lub rzadko używanej bazy danych to witryna Azure Portal.
Interfejs wiersza polecenia platformy Azure Służy do powtarzalnych/skryptowych scenariuszy.
Rozszerzenie programu Visual Studio Code (dla tej usługi) Użyj polecenia , aby pozostać w środowisku IDE programowania.
Biblioteka npm usługi Azure Resource Manager (dla tej usługi) Użyj polecenia , aby pozostać w języku JavaScript.

Po utworzeniu serwera w zależności od usługi może być konieczne:

  • Konfigurowanie ustawień zabezpieczeń, takich jak zapora i wymuszanie protokołu SSL
  • Uzyskiwanie informacji o połączeniu
  • Tworzenie bazy danych

Konfigurowanie ustawień zabezpieczeń dla bazy danych

Typowe ustawienia zabezpieczeń do skonfigurowania dla usługi obejmują:

  • Otwieranie zapory dla adresu IP klienta
  • Konfigurowanie wymuszania protokołu SSL
  • Akceptowanie żądań publicznych lub wymaganie, aby wszystkie żądania pochodziły z innej usługi platformy Azure

Tworzenie bazy danych na serwerze platformy Azure

Informacje o połączeniu można uzyskać przy użyciu tego samego narzędzia, które zostało utworzone na serwerze. Użyj informacji o połączeniu, aby uzyskać dostęp do serwera. Nadal musisz utworzyć bazę danych specyficzną dla aplikacji.

Uzyskaj dostęp do serwera:

  • Użyj narzędzia specyficznego dla tego typu bazy danych, takiego jak pg Administracja, SQL Server Management Studio i MySQL Workbench.
  • Kontynuuj korzystanie z narzędzi firmy Microsoft
    • Usługa Azure Cloud Shell obejmuje wiele interfejsów WIERSZA bazy danych, takich jak psql i mysql.
    • Rozszerzenia programu Visual Studio Code
    • Pakiety npm dla języka JavaScript
    • Azure Portal

Programowy dostęp do serwera i bazy danych przy użyciu języka JavaScript

Po uzyskaniu informacji o połączeniu możesz uzyskać dostęp do serwera przy użyciu standardowych pakietów npm branżowych i języka JavaScript.

Po utworzeniu lub przeprowadzeniu migracji bazy danych należy zmienić tylko informacje o połączeniu z nowym serwerem i bazą danych.

Konfigurowanie połączenia aplikacji internetowej platformy Azure z bazą danych

Jeśli aplikacja internetowa platformy Azure łączy się z bazą danych, musisz zmienić ustawienie Aplikacji dla informacji o połączeniu.

Niezależne od bazy danych języki zapytań

Języki zapytań dotyczących danych, niezależne od określonej bazy danych, umożliwiają korzystanie z funkcji języków zapytań z danymi. Języki zapytań niezależne od bazy danych mogą być używane na platformie Azure i wymagają wprowadzenia warstwy tłumaczenia.

Warstwa danych GraphQL

GraphQL to język zapytań dla interfejsów API i środowisko uruchomieniowe do wypełniania tych zapytań przy użyciu istniejących danych. Narzędzie GraphQL udostępnia pełny i zrozumiały opis danych w interfejsie API, daje klientom możliwość zapytań o dokładnie to, czego potrzebują, i nic więcej, ułatwia rozwijanie interfejsów API w czasie i umożliwia zaawansowane narzędzia deweloperskie.

Statyczne aplikacje internetowe z językiem GraphQL

Usługa Azure Functions z językiem GraphQL

Usługa Azure API Management z językiem GraphQL

System Cassandra na platformie Azure

Do tworzenia, przenoszenia lub używania bazy danych Cassandra DB na platformę Azure potrzebny jest zasób usługi Azure Cosmos DB .

Tworzenie zasobu dla usługi Azure Cosmos DB dla bazy danych Apache Cassandra

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az cosmosdb create w usłudze Azure Cloud Shell , aby utworzyć nowy zasób dla bazy danych Cassandra.

az cosmosdb create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE_NAME \
    --capabilities EnableCassandra

Wykonanie tego polecenia może potrwać kilka minut i utworzenie publicznie dostępnego zasobu. Nie musisz konfigurować reguł zapory, aby zezwolić na korzystanie z adresu IP klienta.

Wyświetlanie i używanie bazy danych Cassandra w usłudze Azure Cosmos DB

Podczas tworzenia bazy danych Cassandra DB przy użyciu języka JavaScript użyj eksploratora usługi Azure Cosmos DB do pracy z bazą danych.

Use the Azure Cosmos DB explorer, found at `https://cosmos.azure.com/`, to view and work with your Cassandra DB database.

Eksplorator usługi Azure Cosmos DB jest również dostępny w witrynie Azure Portal dla zasobu jako Eksplorator danych.

Tworzenie przestrzeni kluczy na serwerze przy użyciu interfejsu wiersza polecenia platformy Azure

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az cosmosdb cassandra keyspace create w usłudze Azure Cloud Shell , aby utworzyć nową przestrzeń kluczy Cassandra na serwerze.

az cosmosdb cassandra keyspace create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --account-name YOUR-RESOURCE_NAME \
    --name YOUR-KEYSPACE-NAME

Tworzenie tabeli w przestrzeni kluczy za pomocą interfejsu wiersza polecenia platformy Azure

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az cosmosdb cassandra table create w usłudze Azure Cloud Shell , aby utworzyć nową przestrzeń kluczy Cassandra na serwerze.

az cosmosdb cassandra table create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --account-name YOUR-RESOURCE_NAME \
    --keyspace-name YOUR-KEYSPACE-NAME \
    --name YOUR-TABLE-NAME \
    --schema @schema.json

Pobieranie parametry połączenia Cassandra za pomocą interfejsu wiersza polecenia platformy Azure

Pobierz parametry połączenia bazy danych MongoDB dla tego wystąpienia za pomocą polecenia az cosmosdb keys list:

az cosmosdb keys list \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE-NAME \
    --type connection-strings

Połączenie do bazy danych Cassandra z parametry połączenia. Nazwa użytkownika rozwiązania Cassandra to nazwa zasobu.

Nawiązywanie połączenia z bazą danych Cassandra DB na platformie Azure przy użyciu natywnych pakietów SDK

Baza danych Cassandra DB w usłudze Azure Cosmos DB używa już dostępnych pakietów npm, takich jak:

localDataCenter przy użyciu sterownika cassandra:

  • W wersji 3 użyj wartości domyślnej dataCenter1
  • W wersji 4 należy określić centrum danych, na przykład Central US w poniższym bloku kodu.
  let client = new cassandra.Client({
    contactPoints: [`${config.contactPoint}:10350`],
    authProvider: authProvider,
    localDataCenter: 'Central US',
    sslOptions: {
      secureProtocol: 'TLSv1_2_method',
      rejectUnauthorized: false,
    },
  });

Jeśli nie masz pewności co do właściwości localDataCenter, usuń właściwość, uruchom przykładowy kod, a wartość właściwości zostanie zwrócona w tekście błędu.

NoHostAvailableError: All host(s) tried for query failed. First host tried, xxx.xxx.xxx.xxx:10350: ArgumentError: localDataCenter was configured as 'dataCenter1', but only found hosts in data centers: [Central US]

Nawiązywanie połączenia z bazą danych Cassandra DB na platformie Azure przy użyciu zestawu CASSandra-driver SDK

Aby nawiązać połączenie z bazą danych Cassandra DB i używać jej w usłudze Azure Cosmos DB przy użyciu języka JavaScript i sterownika cassandra, wykonaj poniższą procedurę.

  1. Upewnij się, że zainstalowano środowisko Node.js LTS i narzędzie npm.

  2. Utwórz projekt Node.js w nowym folderze:

    mkdir DataDemo && \
    cd DataDemo && \
    npm init -y && \
    npm install cassandra-driver && \
    touch index.js && \
    code .

    Polecenie :

    • tworzy folder projektu o nazwie DataDemo
    • zmienia terminal powłoki Bash w tym folderze
    • inicjuje projekt, który tworzy package.json plik
    • dodaje zestaw NPM sterownika cassandra do projektu
    • tworzy plik skryptu index.js
    • Otwiera projekt w programie Visual Studio Code

  3. Skopiuj następujący kod JavaScript do index.jspliku :

    // install cassandra-driver SDK
// run at command line
// npm install cassandra-driver

const cassandra = require('cassandra-driver');

const config = {
  username: 'YOUR-USERNAME', // Your Cassandra user name is the resource name 
  password:
    'YOUR-PASSWORD',
  contactPoint: 'YOUR-RESOURCE-NAME.cassandra.cosmos.azure.com',
};

let client = null;

const callCassandra = async () => {

  // authentication 
  const authProvider = new cassandra.auth.PlainTextAuthProvider(
    config.username,
    config.password
  );

  // create client
  client = new cassandra.Client({
    contactPoints: [`${config.contactPoint}:10350`],
    authProvider: authProvider,
    localDataCenter: 'Central US',
    sslOptions: {
      secureProtocol: 'TLSv1_2_method',
      rejectUnauthorized: false,
    },
  });

  await client.connect();
  console.log("connected");
  
  // create keyspace
  let query =
    "CREATE KEYSPACE IF NOT EXISTS uprofile WITH replication = {\'class\': \'NetworkTopologyStrategy\', \'datacenter\' : \'1\' }";
  await client.execute(query);
  console.log('created keyspace');

  // create table
  query =
    'CREATE TABLE IF NOT EXISTS uprofile.user (name text, alias text, region text Primary Key)';
  await client.execute(query);
  console.log('created table');

  // insert 3 rows
  console.log('insert');
  const arr = [
    "INSERT INTO uprofile.user (name, alias , region) VALUES ('Tim Jones', 'TJones', 'centralus')",
    "INSERT INTO uprofile.user (name, alias , region) VALUES ('Joan Smith', 'JSmith', 'northus')",
    "INSERT INTO uprofile.user (name, alias , region) VALUES ('Bob Wright', 'BWright', 'westus')"
  ];
  for (const element of arr) {
    await client.execute(element);
  }

  // get all rows
  query = 'SELECT * FROM uprofile.user';
  const resultSelect = await client.execute(query);

  for (const row of resultSelect.rows) {
    console.log(
      'Obtained row: %s | %s | %s ',
      row.name,
      row.alias,
      row.region
    );
  }

  // get filtered row
  console.log('Getting by region');
  query = 'SELECT * FROM uprofile.user where region=\'westus\'';
  const resultSelectWhere = await client.execute(query);

  for (const row of resultSelectWhere.rows) {
    console.log(
      'Obtained row: %s | %s | %s ',
      row.name,
      row.alias,
      row.region
    );
  }

  client.shutdown();
};

callCassandra()
  .then(() => {
    console.log('done');
  })
  .catch((err) => {
    if (client) {
      client.shutdown();
    }
    console.log(err);
  });

  4. Zastąp następujące elementy w skrypcie informacjami o połączeniu usługi Azure Cosmos DB dla systemu Apache Cassandra:

    • NAZWA ZASOBU
    • YOUR-USERNAME — zastąp ciąg YOUR-RESOURCE-NAME
    • TWOJE HASŁO

  5. Uruchom skrypt.

    node index.js

    Wyniki są następujące:

    connected
created keyspace
created table
insert
Obtained row: Joan Smith | JSmith | northus 
Obtained row: Tim Jones | TJones | centralus 
Obtained row: Bob Wright | BWright | westus
Getting by region
Obtained row: Bob Wright | BWright | westus 
done

Zasoby bazy danych Cassandra

MariaDB i MySQL na platformie Azure

Bazy danych MariaDB i MySQL mają wspólne pochodzenie i utrzymują zgodność za pośrednictwem protokołu MySQL. Klienci MySQL mogą łączyć się z bazą danych MariaDB i odwrotnie.

Aby utworzyć, przenieść lub użyć bazy danych MySQL lub MariaDB, potrzebny jest zasób platformy Azure . Dowiedz się, jak utworzyć zasób i używać bazy danych.

Tworzenie zasobu usługi Azure Database for MySQL

Zasób można utworzyć za pomocą:

Tworzenie zasobu usługi Azure Database for MySQL przy użyciu interfejsu wiersza polecenia platformy Azure

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az mysql server create w usłudze Azure Cloud Shell , aby utworzyć nowy zasób MySQL dla bazy danych.

az mysql server create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOURRESOURCENAME \
    --location eastus \
    --admin-user YOUR-ADMIN-NAME \
    --ssl-enforcement Disabled \
    --enable-public-network Enabled

Wykonanie tego polecenia może potrwać kilka minut i utworzenie publicznie dostępnego zasobu w eastus regionie.

Odpowiedź zawiera szczegóły konfiguracji serwera, w tym:

  • automatycznie wygenerowane hasło dla konta administratora
  • polecenie nawiązywania połączenia z serwerem za pomocą interfejsu wiersza polecenia mysql

Aby programowo nawiązać połączenie z serwerem, należy skonfigurować reguły zapory, aby zezwolić na korzystanie z adresu IP klienta.

Dodawanie reguły zapory dla adresu IP klienta do zasobu MySQL

Domyślnie reguły zapory nie są skonfigurowane. Należy dodać adres IP klienta, aby połączenie klienta z serwerem za pomocą języka JavaScript powiodło się.

az mysql server firewall-rule create \
--resource-group YOUR-RESOURCE-GROUP \
--server YOURRESOURCENAME \
--name AllowMyIP --start-ip-address 123.123.123.123 \
--end-ip-address 123.123.123.123

Jeśli nie znasz adresu IP klienta, użyj jednej z następujących metod:

  • Użyj witryny Azure Portal, aby wyświetlić i zmienić reguły zapory, które obejmują dodawanie wykrytego adresu IP klienta
  • Uruchom kod Node.js. Błąd dotyczący naruszenia reguł zapory obejmuje adres IP klienta

Chociaż można dodać pełny zakres adresów internetowych jako regułę zapory, 0.0.0.0-255.255.255.255, pozostawia to serwer otwarty na ataki.

Tworzenie bazy danych na serwerze przy użyciu interfejsu wiersza polecenia platformy Azure

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az mysql db create w usłudze Azure Cloud Shell , aby utworzyć nową bazę danych MySQL na serwerze.

az mysql db create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --server-name YOURRESOURCENAME \
    --name YOURDATABASENAME

Pobieranie parametry połączenia MySql za pomocą interfejsu wiersza polecenia platformy Azure

Pobierz parametry połączenia MySql dla tego wystąpienia za pomocą polecenia az mysql server show-connection-string:

az mysql server show-connection-string \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --server-name YOURRESOURCENAME

Spowoduje to zwrócenie parametry połączenia dla popularnych języków jako obiektu JSON. Przed użyciem parametry połączenia należy zastąpić {database}wartości , {username}i {password} własnymi wartościami.

Wyświetlanie i używanie bazy danych MySQL na platformie Azure

Podczas tworzenia bazy danych MySQL za pomocą języka JavaScript użyj jednego z następujących narzędzi:

Tworzenie bazy danych MySQL na platformie Azure przy użyciu pakietów SDK

Usługa Azure MySQL używa już dostępnych pakietów npm, takich jak:

Nawiązywanie połączenia z bazą danych MySQL na platformie Azure przy użyciu zestawu PROMISE-mysql SDK

Aby nawiązać połączenie z bazą danych MySQL na platformie Azure i korzystać z niego za pomocą języka JavaScript, wykonaj poniższą procedurę.

Uwaga

Ten artykuł zawiera odwołania do terminu slave (element podrzędny), który nie jest już używany przez firmę Microsoft. Po usunięciu tego terminu z oprogramowania usuniemy go również z artykułu.

  1. Upewnij się, że zainstalowano środowisko Node.js i narzędzie npm.

  2. Utwórz projekt Node.js w nowym folderze:

    mkdir MySQLDemo && \
    cd MySQLDemo && \
    npm init -y && \
    npm install promise-mysql && \
    touch index.js && \
    code .

    Polecenie :

    • tworzy folder projektu o nazwie MySQLDemo
    • zmienia terminal powłoki Bash w tym folderze
    • inicjuje projekt, który tworzy package.json plik
    • instaluje pakiet npm promise-mysql — aby użyć narzędzia async/await
    • tworzy plik skryptu index.js
    • Otwiera projekt w programie Visual Studio Code

  3. Skopiuj następujący kod JavaScript do index.jspliku :

    // To install npm package,
// run following command at terminal
// npm install promise-mysql

// get MySQL SDK
const MySQL = require('promise-mysql');

// query server and close connection
const query = async (config) => {
  // creation connection
  const connection = await MySQL.createConnection(config);

  // show databases on server
  const databases = await connection.query('SHOW DATABASES;');
  console.log(databases);

  // show tables in the mysql database
  const tables = await connection.query('SHOW TABLES FROM mysql;');
  console.log(tables);

  // show users configured for the server
  const rows = await connection.query('select User from mysql.user;');
  console.log(rows);

  // close connection
  connection.end();
};

const config = {
  host: 'YOUR-RESOURCE_NAME.mysql.database.azure.com',
  user: 'YOUR-ADMIN-NAME@YOUR-RESOURCE_NAME',
  password: 'YOUR-ADMIN-PASSWORD',
  port: 3306,
};

query(config)
  .then(() => console.log('done'))
  .catch((err) => console.log(err));

  4. Zastąp host, użytkownik i hasło wartościami w skrypcie dla obiektu konfiguracji połączenia. config

  5. Uruchom skrypt.

Zasoby mySql

Baza danych MongoDB na platformie Azure

Aby utworzyć, przenieść lub użyć bazy danych mongoDB na platformę Azure, potrzebny jest zasób usługi Azure Cosmos DB. Dowiedz się, jak utworzyć zasób i używać bazy danych.

Tworzenie zasobu dla usługi Azure Cosmos DB dla bazy danych MongoDB za pomocą interfejsu wiersza polecenia platformy Azure

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az cosmosdb create w usłudze Azure Cloud Shell , aby utworzyć nowy zasób usługi Azure Cosmos DB dla bazy danych mongoDB.

az cosmosdb create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE_NAME \
    --locations regionName=eastus \
    --kind MongoDB \
    --enable-public-network true \
    --ip-range-filter 123.123.123.123

Zastąp 123.123.123.123 ciąg własnym adresem IP klienta lub całkowicie usuń parametr .

Wykonanie tego polecenia może potrwać kilka minut i utworzenie publicznie dostępnego zasobu w eastus regionie.

{
  "apiProperties": {
    "serverVersion": "3.6"
  },
  "capabilities": [
    {
      "name": "EnableMongo"
    }
  ],
  "connectorOffer": null,
  "consistencyPolicy": {
    "defaultConsistencyLevel": "Session",
    "maxIntervalInSeconds": 5,
    "maxStalenessPrefix": 100
  },
  "cors": [],
  "databaseAccountOfferType": "Standard",
  "disableKeyBasedMetadataWriteAccess": false,
  "documentEndpoint": "https://mongo-2.documents.azure.com:443/",
  "enableAnalyticalStorage": false,
  "enableAutomaticFailover": false,
  "enableCassandraConnector": null,
  "enableFreeTier": false,
  "enableMultipleWriteLocations": false,
  "failoverPolicies": [
    {
      "failoverPriority": 0,
      "id": "mongodb-2",
      "locationName": "East US"
    }
  ],
  "id": "/subscriptions/.../resourceGroups/my-resource-group/providers/Microsoft.DocumentDB/databaseAccounts/mongo-2",
  "ipRules": [
    {
      "ipAddressOrRange": "123.123.123.123"
    }
  ],
  "isVirtualNetworkFilterEnabled": false,
  "keyVaultKeyUri": null,
  "kind": "MongoDB",
  "location": "Central US",
  "locations": [
    {
      "documentEndpoint": "https://mongodb-2.documents.azure.com:443/",
      "failoverPriority": 0,
      "id": "mongodb-2",
      "isZoneRedundant": false,
      "locationName": "East US",
      "provisioningState": "Succeeded"
    }
  ],
  "name": "mongo-2",
  "privateEndpointConnections": null,
  "provisioningState": "Succeeded",
  "publicNetworkAccess": "Enabled",
  "readLocations": [
    {
      "documentEndpoint": "https://mongodb-2.documents.azure.com:443/",
      "failoverPriority": 0,
      "id": "mongodb-2",
      "isZoneRedundant": false,
      "locationName": "East US",
      "provisioningState": "Succeeded"
    }
  ],
  "resourceGroup": "my-resource-group",
  "systemData": {
    "createdAt": "2021-02-08T20:21:05.9519342Z"
  },
  "tags": {},
  "type": "Microsoft.DocumentDB/databaseAccounts",
  "virtualNetworkRules": [],
  "writeLocations": [
    {
      "documentEndpoint": "https://mongodb-2.documents.azure.com:443/",
      "failoverPriority": 0,
      "id": "mongodb-2",
      "isZoneRedundant": false,
      "locationName": "East US",
      "provisioningState": "Succeeded"
    }
  ]
}

Dodawanie reguły zapory dla adresu IP klienta przy użyciu interfejsu wiersza polecenia platformy Azure

Domyślnie reguły zapory nie są skonfigurowane. Należy dodać adres IP klienta, aby połączenie klienta z serwerem za pomocą języka JavaScript powiodło się.

Użyj polecenia az cosmosdb update, aby zaktualizować reguły zapory.

az cosmosdb update \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE_NAME \
    --ip-range-filter 123.123.123.123

Aby skonfigurować wiele adresów IP, użyj listy rozdzielanej przecinkami.

az cosmosdb update \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE_NAME \
    --ip-range-filter 123.123.123.123,456.456.456.456

Uzyskiwanie parametry połączenia bazy danych MongoDB dla zasobu za pomocą interfejsu wiersza polecenia platformy Azure

Pobierz parametry połączenia bazy danych MongoDB dla tego wystąpienia za pomocą polecenia az cosmosdb keys list:

az cosmosdb keys list \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE-NAME \
    --type connection-strings

Spowoduje to zwrócenie 4 parametry połączenia, 2 odczyt-zapis i 2 tylko do odczytu. Istnieją dwa, dzięki czemu można dać 2 różne systemy lub deweloperom parametry połączenia do użycia indywidualnie.

Połączenie do bazy danych mongoDB z parametry połączenia. Upewnij się, że Twoja usługa jest dostępna z jedną z następujących opcji:

  • publicznie dostępne
  • ustawienia zapory dla adresu IP klienta

Konfigurowanie aplikacji internetowej platformy Azure przy użyciu parametry połączenia za pomocą interfejsu wiersza polecenia platformy Azure

Dodaj zmienną środowiskową aplikacji internetowej platformy Azure MONGODB_URL za pomocą zestawu az webapp config appsettings, aby aplikacja internetowa łączyła się z zasobem usługi Azure Cosmos DB:

az webapp config appsettings set \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE_NAME \
    --settings MONGODB_URL=YOUR-CONNECTION-STRING

Używanie emulatora usługi Azure Cosmos DB do programowania lokalnego

Dowiedz się więcej o emulatorze usługi Azure Cosmos DB:

Nawiązywanie połączenia z bazą danych MongoDB na platformie Azure przy użyciu natywnych pakietów SDK

Baza danych mongoDB w usłudze Azure Cosmos DB używa już dostępnych pakietów npm, takich jak:

Zasoby bazy danych Mongo DB

NoSQL na platformie Azure

Aby utworzyć lub użyć usługi Azure Cosmos DB for NoSQL, utwórz zasób usługi Azure Cosmos DB. Dowiedz się, jak utworzyć zasób usługi Azure Cosmos DB i używać bazy danych.

Programowanie lokalne za pomocą emulatora usługi Azure Cosmos DB

Dowiedz się, jak zainstalować emulator usługi Azure Cosmos DB i uruchomić emulator na potrzeby programowania w usłudze Azure Cosmos DB for NoSQL.

Tworzenie zasobu dla bazy danych NoSQL usługi Azure Cosmos DB

Zasób można utworzyć za pomocą:

Tworzenie zasobu dla usługi Azure Cosmos DB for NoSQL

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az cosmosdb create w usłudze Azure Cloud Shell , aby utworzyć nowy zasób usługi Azure Cosmos DB. Wykonanie tego polecenia może potrwać kilka minut.

az cosmosdb create \
--subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
--resource-group YOUR-RESOURCE-GROUP \
--name YOUR-RESOURCE-NAME \
--kind YOUR-DB-KIND \
--ip-range-filter YOUR-CLIENT-IP

Aby włączyć dostęp zapory z komputera lokalnego do zasobu, zastąp 123.123.123.123 ciąg własnym adresem IP klienta. Aby skonfigurować wiele adresów IP, użyj listy rozdzielanej przecinkami.

Dodawanie reguły zapory dla adresu IP klienta

Jeśli musisz dodać adres IP klienta do zasobu po jego utworzeniu, aby połączenie klienta z serwerem za pomocą języka JavaScript powiodło się, użyj tej procedury. Użyj polecenia az cosmosdb update, aby zaktualizować reguły zapory.

az cosmosdb update \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE_NAME \
    --ip-range-filter 123.123.123.123

Aby skonfigurować wiele adresów IP, użyj listy rozdzielanej przecinkami.

az cosmosdb update \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE_NAME \
    --ip-range-filter 123.123.123.123,456.456.456.456

Pobieranie kluczy usługi Azure Cosmos DB dla zasobu

Pobierz klucze dla tego wystąpienia za pomocą polecenia az cosmosdb keys list :

az cosmosdb keys list \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE-NAME

Zwraca ono 4 klucze, 2 operacje odczytu i zapisu i 2 tylko do odczytu. Istnieją dwa, dzięki czemu można dać 2 różne systemy lub deweloperom klucz do używania i recyklingu indywidualnie.

Nawiązywanie połączenia z bazą danych przy użyciu zestawu @azure/cosmos SDK

Połączenie do bazy danych Azure Cosmos DB for NoSQL przy użyciu następującego zestawu Azure SDK:

Aby nawiązać połączenie z bazą danych Azure Cosmos DB for NoSQL i używać jej za pomocą języka JavaScript, wykonaj poniższą procedurę.

  1. Upewnij się, że zainstalowano środowisko Node.js i narzędzie npm.

  2. Utwórz projekt Node.js w nowym folderze:

    mkdir dataDemo && \
    cd dataDemo && \
    npm init -y && \
    npm install @azure/cosmos && \
    touch index.js && \
    code .

    Polecenie :

    • tworzy folder projektu o nazwie dataDemo
    • zmienia terminal powłoki Bash w tym folderze
    • inicjuje projekt, który tworzy package.json plik
    • tworzy plik skryptu index.js
    • Otwiera projekt w programie Visual Studio Code

  3. Skopiuj następujący kod JavaScript do index.jspliku :

    const CosmosClient = require("@azure/cosmos").CosmosClient;

// CHANGE THESE VALUES
const COSMOS_DB_RESOURCE_NAME = "YOUR-RESOURCE-NAME";
const COSMOS_DB_RESOURCE_KEY = "YOUR-RESOURCE-KEY";

let client = null;      // Azure Cosmos DB connection object
let db = null;          // DB object
let container = null;   // Container object

// data
const DATABASE_DOCS = [
    { name: "Joe", job: "banking" },
    { name: "Jack", job: "security" },
    { name: "Jill", job: "pilot" }];

const ALL_DOCS = null;

// Azure Cosmos DB config
const config = {
    COSMOSDB_SQL_API_URI: `https://${COSMOS_DB_RESOURCE_NAME}.documents.azure.com:443/`,
    COSMOSDB_SQL_API_KEY: COSMOS_DB_RESOURCE_KEY,
    COSMOSDB_SQL_API_DATABASE_NAME: "DemoDb",
    COSMOSDB_SQL_API_CONTAINER_NAME: "DemoContainer"
}

// Unique Id = Guid
const newGuid = () => {
    const s4 = () => Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
    return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4() + s4() + s4()}`;
}

// insert array
const insert = async (newItems) => {

    const results = [];
    for (const item of newItems) {

        item.id = newGuid();
        const result = await container.items.create(item);
        results.push(result.item);
    }
    return results;
};
// find all or by id
const find = async (query) => {

    if (query == null) {
        query = "SELECT * from c"
    } else {
        query = `SELECT * from c where c.id = ${query}`
    }

    const result = await container.items
        .query(query)
        .fetchAll();

    return result && result.resources ? result.resources : [];
}
// remove all or by id
const remove = async (id) => {

    // remove 1
    if (id) {
        await container.item(id).delete();
    } else {

        // get all items
        const items = await find();

        // remove all
        for await (const item of items) {
            await container.item(item.id).delete();
        }
    }

    return;
}
// connection with SDK
const connect = () => {
    try {

        const connectToCosmosDB = {
            endpoint: config.COSMOSDB_SQL_API_URI,
            key: config.COSMOSDB_SQL_API_KEY
        }

        return new CosmosClient(connectToCosmosDB);

    } catch (err) {
        console.log('Azure Cosmos DB - can\'t connect - err');
        console.log(err);
    }
}
const connectToDatabase = async () => {

    client = connect();

    if (client) {

        // get DB
        const databaseResult = await client.databases.createIfNotExists({ id: config.COSMOSDB_SQL_API_DATABASE_NAME });
        db = databaseResult.database;

        if (db) {
            // get Container
            const containerResult = await db.containers.createIfNotExists({ id: config.COSMOSDB_SQL_API_CONTAINER_NAME });
            container = containerResult.container;
            return !!db;
        }
    } else {
        throw new Error("can't connect to database");
    }


}

// use Database
const dbProcess = async (docs) => {

    // connect
    const db = await connectToDatabase();
    if (!db) throw Error("db not working")
    console.log("connected to " + config.COSMOSDB_SQL_API_DATABASE_NAME + "/" + config.COSMOSDB_SQL_API_CONTAINER_NAME)

    // insert new docs
    const insertResult = await insert(docs);
    console.log("inserted " + insertResult.length)

    // get all docs
    const findResult = await find(ALL_DOCS);
    console.log("found " + findResult.length);

    // remove all then make sure they are gone
    await remove(ALL_DOCS);
    const findResult3 = await find(ALL_DOCS);
    console.log("removed all, now have " + findResult3.length);

    return;

}

dbProcess(DATABASE_DOCS)
.then(() => {
    console.log("done")
}).catch(err => {
    console.log(err)
})

  4. Zastąp następujące zmienne w skrypcie:

    • YOUR-RESOURCE-NAME — nazwa użyta podczas tworzenia zasobu usługi Azure Cosmos DB
    • YOUR-RESOURCE-KEY — jeden z kluczy odczytu/zapisu dla zasobu

  5. Uruchom skrypt.

    node index.js

    Wyniki są następujące:

    connected to DemoDb/DemoContainer4
inserted 3
found 3
removed all, now have 0
done

Zasoby NoSQL

Baza danych PostgreSQL na platformie Azure

Aby utworzyć, przenieść lub użyć bazy danych PostgreSQL na platformę Azure, potrzebujesz zasobu serwera usługi Azure Database for PostgreSQL. Dowiedz się, jak utworzyć zasób i używać bazy danych.

Tworzenie zasobu usługi Azure Database for PostgreSQL

Utwórz zasób za pomocą:

Tworzenie zasobu serwera usługi Azure Database for PostgreSQL za pomocą interfejsu wiersza polecenia platformy Azure

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az postgres server create w usłudze Azure Cloud Shell , aby utworzyć nowy zasób serwera PostgreSQL dla bazy danych.

az postgres server create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --location eastus \
    --name YOURRESOURCENAME \
    --admin-user YOUR-ADMIN-USER \
    --ssl-enforcement Disabled \
    --enable-public-network Enabled

Wykonanie tego polecenia może potrwać kilka minut i utworzenie publicznie dostępnego zasobu w eastus regionie.

Odpowiedź zawiera szczegóły konfiguracji serwera, w tym:

  • Automatycznie wygenerowane hasło dla konta administratora
  • Parametry połączenia

Przed nawiązaniem połączenia z serwerem należy skonfigurować reguły zapory, aby zezwolić na korzystanie z adresu IP klienta.

Dodawanie reguły zapory dla adresu IP klienta do zasobu PostgreSQL

Domyślnie reguły zapory nie są skonfigurowane. Należy dodać adres IP klienta, aby połączenie klienta z serwerem za pomocą języka JavaScript powiodło się.

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az postgres server firewall-rule create w usłudze Azure Cloud Shell , aby utworzyć nową regułę zapory dla bazy danych.

az postgres server firewall-rule create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --server YOURRESOURCENAME \
    --name AllowMyIP \
    --start-ip-address 123.123.123.123 \
    --end-ip-address 123.123.123.123

Jeśli nie znasz adresu IP klienta, użyj jednej z następujących metod:

  • Użyj witryny Azure Portal, aby wyświetlić i zmienić reguły zapory, które obejmują dodawanie wykrytego adresu IP klienta
  • Uruchom kod Node.js. Błąd dotyczący naruszenia reguł zapory obejmuje adres IP klienta

Chociaż można dodać pełny zakres adresów internetowych jako regułę zapory, 0.0.0.0-255.255.255.255, pozostawia to serwer otwarty na ataki.

Tworzenie bazy danych PostgreSQL na serwerze przy użyciu interfejsu wiersza polecenia platformy Azure

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az postgres db create w usłudze Azure Cloud Shell , aby utworzyć nową bazę danych PostgreSQL na serwerze.

az postgres db create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --server-name YOURRESOURCENAME \
    --name YOURDATABASENAME

Pobieranie parametry połączenia PostgreSQL za pomocą interfejsu wiersza polecenia platformy Azure

Pobierz parametry połączenia PostgreSQL dla tego wystąpienia za pomocą polecenia az postgres server show-connection-string:

az postgres server show-connection-string \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --server-name YOURRESOURCENAME

Spowoduje to zwrócenie parametry połączenia dla popularnych języków jako obiektu JSON. Przed użyciem parametry połączenia należy zastąpić {database}wartości , {username}i {password} własnymi wartościami. Zastąp YOURRESOURCENAME ciąg nazwą zasobu.

Wyświetlanie i używanie serwera PostgreSQL na platformie Azure

Podczas tworzenia bazy danych PostgreSQL za pomocą języka JavaScript użyj jednego z następujących narzędzi:

Tworzenie serwera PostgreSQL na platformie Azure przy użyciu pakietów SDK

Usługa Azure PostgreSQL używa już dostępnych pakietów npm, takich jak:

Nawiązywanie połączenia z bazą danych PostgreSQL na platformie Azure przy użyciu zestawu PG SDK

Aby nawiązać połączenie i użyć bazy danych PostgreSQL na platformie Azure przy użyciu języka JavaScript, użyj poniższej procedury.

  1. Upewnij się, że zainstalowano środowisko Node.js i narzędzie npm.

  2. Utwórz projekt Node.js w nowym folderze:

    mkdir DbDemo && \
    cd DbDemo && \
    npm init -y && \
    npm install pg && \
    touch index.js && \
    code .

    Polecenie :

    • Tworzy folder projektu o nazwie DbDemo
    • Zmienia terminal powłoki Bash w tym folderze
    • Inicjuje projekt, który tworzy package.json plik
    • Instaluje pakiet pg npm — aby użyć narzędzia async/await
    • Tworzy plik skryptu index.js
    • Otwiera projekt w programie Visual Studio Code

  3. Skopiuj następujący kod JavaScript do index.jspliku :

    const { Client } = require('pg')
    
const query = async (connectionString) => {
    
    // create connection
    const connection = new Client(connectionString);
    connection.connect();
    
    // show tables in the postgres database
    const tables = await connection.query('SELECT table_name FROM information_schema.tables where table_type=\'BASE TABLE\';');
    console.log(tables.rows);

    // show users configured for the server
    const users = await connection.query('select pg_user.usename FROM pg_catalog.pg_user;');
    console.log(users.rows);
    
    // close connection
    connection.end();
}

const server='YOURRESOURCENAME';
const user='YOUR-ADMIN-USER';
const password='YOUR-PASSWORD';
const database='postgres';

const connectionString = `postgres://${user}@${server}:${password}@${server}.postgres.database.azure.com:5432/${database}`;

query(connectionString)
.then(() => console.log('done'))
.catch((err) => console.log(err));

  4. Zastąp wartości YOUR-ADMIN-USER, YOURRESOURCENAMEi YOUR-PASSWORD wartościami w skrypcie dla parametry połączenia.

  5. Uruchom skrypt, aby nawiązać połączenie z serwerem postgres i wyświetlić tabele podstawowe i użytkowników.

    node index.js

  6. Przejrzyj wyniki.

    [
  { table_name: 'pg_statistic' },
  { table_name: 'pg_type' },
  { table_name: 'pg_authid' },
  { table_name: 'pg_user_mapping' },
  ...removed for brevity
  { table_name: 'sql_languages' },
  { table_name: 'sql_packages' },
  { table_name: 'sql_parts' },
  { table_name: 'sql_sizing' },
  { table_name: 'sql_sizing_profiles' }
]
[ { usename: 'azure_superuser' }, { usename: 'YOUR-ADMIN-USER' } ]
done

Zasoby bazy danych PostgreSQL

Usługa Redis na platformie Azure

Do tworzenia, przenoszenia lub używania bazy danych Redis na platformę Azure potrzebny jest zasób usługi Azure Cache for Redis . Dowiedz się, jak utworzyć zasób i używać bazy danych.

Tworzenie zasobu dla bazy danych Redis

Zasób można utworzyć za pomocą:

Tworzenie zasobu usługi Azure Cache for Redis przy użyciu interfejsu wiersza polecenia platformy Azure

Użyj następującego polecenia interfejsu wiersza polecenia platformy Azure az redis create w usłudze Azure Cloud Shell , aby utworzyć nowy zasób usługi Redis dla bazy danych.

az redis create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE-NAME \
    --location eastus \
    --sku Basic \
    --vm-size c0 \
    --enable-non-ssl-port

Wykonanie tego polecenia może potrwać kilka minut i utworzenie publicznie dostępnego zasobu w eastus regionie.

Odpowiedź zawiera szczegóły konfiguracji serwera, w tym:

  • wersja usługi Redis: redisVersion
  • porty: sslPort i port

Dodawanie reguły zapory dla adresu IP klienta do zasobu usługi Redis

Dodaj reguły zapory za pomocą polecenia az redis firewall-rules create , aby zdefiniować dostęp do pamięci podręcznej z adresu IP klienta lub adresu IP aplikacji.

az redis firewall-rules create \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE-NAME \
    --rule-name AllowMyIP \
    --start-ip 123.123.123.123 \
    --end-ip 123.123.123.123

Jeśli nie znasz adresu IP klienta, użyj jednej z następujących metod:

  • Użyj witryny Azure Portal, aby wyświetlić i zmienić reguły zapory, które obejmują dodawanie wykrytego adresu IP klienta.
  • Po uruchomieniu kodu Node.js zostanie wyświetlony błąd dotyczący naruszenia reguł zapory, który obejmuje adres IP klienta. Skopiuj adres IP i użyj go, aby ustawić regułę zapory.

Uzyskiwanie kluczy usługi Redis za pomocą interfejsu wiersza polecenia platformy Azure

Pobierz parametry połączenia redis dla tego wystąpienia za pomocą polecenia az redis list-keys:

az redis list-keys \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE-NAME

Spowoduje to zwrócenie dwóch kluczy:

{
    "primaryKey": "5Uey0GHWtCs9yr1FMUMcu1Sv17AJA2QMqPm9CyNKjAA=",
    "secondaryKey": "DEPr+3zWbL6d5XwxPajAriXKgoSeCqraN8SLSoiMWhM="
  }

Połączenie usługi Azure Cache for Redis do aplikacji internetowej usługi App Service

Dodaj informacje o połączeniu do aplikacji internetowej usługi App Service za pomocą polecenia az webapp config appsettings set .

az webapp config appsettings set \
--subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
--resource-group YOUR-RESOURCE-GROUP \
--name YOUR-APP-SERVICE-RESOURCE-NAME \
--settings "REDIS_URL=YOUR-REDIS-HOST-NAME" "REDIS_PORT=YOUR-REDIS-PORT" "REDIS_KEY=YOUR-REDIS-KEY"

Zastąp następujące ustawienia w poprzednim kodzie:

  • YOUR-SUBSCRIPTION-ID-OR-NAME
  • GRUPA ZASOBÓW
  • TWOJA-APP-SERVICE-RESOURCE-NAME
  • NAZWA-HOSTA-USŁUGI REDIS
  • TWÓJ PORT REDIS
  • TWÓJ KLUCZ REDIS

Nawiązywanie połączenia z usługą Redis na platformie Azure przy użyciu natywnych pakietów SDK

Baza danych Redis używa pakietów npm, takich jak:

Instalowanie zestawu ioredis SDK

Użyj poniższej procedury, aby zainstalować ioredis pakiet i zainicjować projekt.

  1. Upewnij się, że zainstalowano środowisko Node.js i narzędzie npm.

  2. Utwórz projekt Node.js w nowym folderze:

    mkdir DataDemo && \
    cd DataDemo && \
    npm init -y && \
    npm install ioredis \
    code .

    Polecenie :

    • Tworzy folder projektu o nazwie DataDemo
    • Zmienia terminal powłoki Bash w tym folderze
    • Inicjuje projekt, który tworzy package.json plik
    • Dodaje zestaw SDK npm ioredis do projektu
    • Otwiera projekt w programie Visual Studio Code

Tworzenie pliku JavaScript w celu zbiorczego wstawiania danych do usługi Redis

  1. W programie Visual Studio Code utwórz bulk_insert.js plik.

  2. Pobierz plik MOCK_DATA.csv i umieść go w tym samym katalogu co bulk_insert.js.

  3. Skopiuj następujący kod JavaScript do bulk_insert.jspliku :

    const Redis = require('ioredis');
const fs = require('fs');
const parse = require('csv-parser')
const { finished } = require('stream/promises');
const { config } = require('./config')

// Create Redis config object
const configuration = {
    host: config.HOST,
    port: 6380,
    password: config.KEY,
    tls: {
        servername: config.HOST
    },
    database: 0,
    keyPrefix: config.KEY_PREFIX
}
var redis = new Redis(configuration);

// insert each row into Redis
async function insertData(readable) {
    for await (const row of readable) {
        await redis.set(`bar2:${row.id}`, JSON.stringify(row))
    }
}

/* 
id,first_name,last_name,email,gender,ip_address
1,Rodrigo,Lock,rlock0@eventbrite.com,Agender,73.93.61.37
2,Nikos,Gutierrez,ngutierrez1@yahoo.com,Genderfluid,213.54.40.210
3,Eada,Sotham,esotham2@yellowpages.com,Bigender,28.236.183.89
4,Ana,Brazil,abrazil3@who.int,Polygender,142.30.140.225
5,Roman,Rohmer,rrohmer4@admin.ch,Genderqueer,235.197.52.85
6,Elyn,Sute,esute5@ftc.gov,Genderqueer,171.151.109.188
7,Omero,Childers,ochilders6@stanford.edu,Bigender,133.21.192.66
8,Stephana,Pipet,spipet7@parallels.com,Genderfluid,177.48.129.213
9,Anthiathia,Ulster,aulster8@weebly.com,Genderfluid,175.1.59.106
10,Yard,Pyson,ypyson9@jalbum.net,Non-binary,0.8.135.151
*/

// read file, parse CSV, each row is a chunck
const readable = fs
    .createReadStream('./MOCK_DATA.csv')
    .pipe(parse());

// Pipe rows to insert function
insertData(readable)
    .then(() => {
        console.log('succeeded');
        redis.disconnect();
    })
    .catch(console.error);

  4. Zastąp następujące elementy w skrypcie informacjami o zasobie usługi Redis:

    • NAZWA ZASOBU
    • YOUR-AZURE-REDIS-RESOURCE-KEY

  5. Uruchom skrypt.

    node bulk_insert.js

Tworzenie kodu JavaScript do korzystania z usługi Redis

  1. W programie Visual Studio Code utwórz index.js plik.

  2. Skopiuj następujący kod JavaScript do index.jspliku :

    const redis = require('ioredis');
const { config } = require('./config')

// Create Redis config object
const configuration = {
    host: config.HOST,
    port: 6380,
    password: config.KEY,
    timeout: config.TIMEOUT,
    tls: {
        servername: config.HOST
    },
    database: 0,
    keyPrefix: config.KEY_PREFIX
}

const connect = () => {
    return redis.createClient(configuration);
}

const set = async (client, key, expiresInSeconds=configuration.timeout, stringify=true, data) => {
    return await client.setex(key, expiresInSeconds, stringify? JSON.stringify(data): data);
}

const get = async (client, key, stringParse=true) => {
    const value = await client.get(key);
    return stringParse ? JSON.parse(value) : value;
}

const remove = async (client, key) => {
      return await client.del(key);
}

const disconnect = (client) => {
    client.disconnect();
}

const test = async () => {
    
    // connect
    const dbConnection = await connect();
    
    // set
    const setResult1 = await set(dbConnection, "r1", "1000000", false, "record 1");
    const setResult2 = await set(dbConnection, "r2", "1000000", false, "record 2");
    const setResult3 = await set(dbConnection, "r3", "1000000", false, "record 3");

    // get
    const val2 = await get(dbConnection, "r2", false);
    console.log(val2);
    
    // delete
    const remove2 = await remove(dbConnection, "r2");
    
    // get again = won't be there
    const val2Again = await get(dbConnection, "r2", false);
    console.log(val2Again);
    
    // done
    disconnect(dbConnection)
}

test()
.then(() => console.log("done"))
.catch(err => console.log(err))

  3. Zastąp następujące elementy w skrypcie informacjami o zasobie usługi Redis:

    • NAZWA ZASOBU
    • HASŁO ZASOBU

  4. Uruchom skrypt.

    node index.js

    Skrypt wstawia 3 klucze, a następnie usuwa środkowy klucz. Wyniki konsoli to:

    record 2
null
done

Zasoby usługi Redis

SQL na platformie Azure

Do tworzenia, przenoszenia lub używania bazy danych SQL na platformę Azure potrzebny jest zasób z rodziny usług Azure SQL, takich jak Azure SQL Database. Dowiedz się, jak utworzyć zasób usługi Azure SQL Database i używać bazy danych.

Tworzenie zasobu usługi Azure SQL Database

Utwórz zasób z dołączonymi przykładowymi danymi:

Wyświetlanie i używanie serwera Azure SQL na platformie Azure

Podczas tworzenia bazy danych Azure SQL Database za pomocą języka JavaScript użyj jednego z następujących narzędzi:

Tworzenie bazy danych Azure SQL Database na platformie Azure przy użyciu pakietów ZESTAWU SDK

Baza danych Azure SQL Database używa już dostępnych pakietów npm, takich jak:

Nawiązywanie połączenia z usługą Azure SQL na platformie Azure przy użyciu zestawu SDK mssql

Aby nawiązać połączenie i użyć bazy danych SQL na platformie Azure przy użyciu języka JavaScript, wykonaj poniższą procedurę.

  1. Upewnij się, że zainstalowano środowisko Node.js i narzędzie npm.

  2. Utwórz projekt Node.js w nowym folderze:

    mkdir DbDemo && \
    cd DbDemo && \
    npm init -y && \
    npm install mssql && \
    touch index.js && \
    code .

    Polecenie :

    • Tworzy folder projektu o nazwie DbDemo
    • Zmienia terminal w tym folderze
    • Inicjuje projekt, który tworzy package.json plik
    • Instaluje pakiet npm mssql — do używania async/await
    • Tworzy plik skryptu index.js
    • Otwiera projekt w programie Visual Studio Code

  3. Skopiuj następujący kod JavaScript do index.jspliku :

const sql = require('mssql')

const query = async (connString) => {

    // connect 
    const pool = await sql.connect(connString);

   // show tables in database
   const tables = await pool.query('SELECT table_name FROM information_schema.tables where table_type=\'BASE TABLE\';');
   console.log(tables.recordset);

   // show users configured for the server
   const users = await pool.query('SELECT USER_NAME() AS user_name');
   console.log(users.recordset);
    
    // close connection
    pool.close();
}

const SERVER_ADDRESS='YOUR_SERVER.database.windows.net'
const DATABASE_NAME='YOUR_DB'
const USER_ID='YOUR_USER_ID'
const USER_PASSWORD='YOUR_USER_PASSWORD'

var connString = `Server=${SERVER_ADDRESS},1433;Database=${DATABASE_NAME};User Id=${USER_ID};Password=${USER_PASSWORD};Encrypt=true`

query(connString)
    .catch((err) => console.log(err));

  1. Zastąp następujące wartości swoimi wartościami:

    • YOUR_SERVER
    • YOUR_DB
    • YOUR_USER_ID
    • YOUR_USER_PASSWORD

  2. Uruchom skrypt, aby nawiązać połączenie z bazą danych SQL i wyświetlić wyniki.

    node index.js

  3. Przejrzyj wyniki. Następujące dane są odpytywane z przykładowej bazy danych dostarczonej przez usługę Azure SQL.

    [ { table_name: 'Persons' } ]
[ { user_name: 'dbo' } ]

Zasoby usługi Azure SQL