Skapa en Node.js-konsolapp med Azure DocumentDB

Den här guiden hjälper dig att skapa ett Node.js-konsolprogram för att ansluta till ett Azure DocumentDB-kluster. Du förbereder utvecklingsmiljön, använder @azure/identity paketet från Azure SDK för JavaScript för att autentisera och utför vanliga åtgärder på dokument i databasen.

Förutsättningar

En prenumeration på Azure
- Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto

Ett befintligt Azure DocumentDB-kluster
- Om du inte har något kluster skapar du ett nytt kluster

Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Kom igång med Azure Cloud Shell.
Om du föredrar att köra CLI-referenskommandon lokalt installerar du Azure CLI. Om du kör på Windows eller macOS, överväg att köra Azure CLI i en Docker-container. För mer information, se Hur man kör Azure CLI i en Docker-container.
- Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. För att avsluta autentiseringsprocessen, följ stegen som visas i din terminal. Andra inloggningsalternativ finns i Autentisera till Azure med Azure CLI.
- När du blir uppmanad, installera Azure CLI-tillägget vid första användning. Mer information om tillägg finns i Använda och hantera tillägg med Azure CLI.
- Kör az version för att ta reda på versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

Microsoft Entra-autentisering har konfigurerats för klustret och din identitet har tilldelats root roll.
- Om du vill aktivera Microsoft Entra-autentisering läser du konfigurationsguiden.
Senaste versionen av långsiktig support (LTS) av Node

Senaste versionen av TypeScript.

Konfigurera konsolprogrammet

Skapa sedan ett nytt konsolprogramprojekt och importera de bibliotek som behövs för att autentisera till klustret.

Skapa en ny katalog för projektet och initiera den med npm init.
```
mkdir mongodb-app
cd mongodb-app
npm init -y
```

Konfigurera TypeScript i projektet.

npm install typescript ts-node @types/node --save-dev
npx tsc --init

Skapa den huvudsakliga app.ts TypeScript-filen för ditt program.
```
touch app.ts
```
@azure/identity Installera biblioteket för autentisering.
```
npm install @azure/identity
```
mongodb Installera biblioteket.
```
npm install mongodb
```

Anslut till klustret

Använd nu Azure.Identity biblioteket för att få en TokenCredential som du kan använda för att ansluta till din kluster. Den officiella MongoDB-drivrutinen har ett särskilt gränssnitt som måste implementeras för att hämta token från Microsoft Entra för användning vid anslutning till klustret.

Importera nödvändiga moduler överst i JavaScript-filen.

import { MongoClient } from 'mongodb';
import { DefaultAzureCredential } from '@azure/identity';

Skapa en återanropsfunktion för token som hämtar token från instansen TokenCredential vid behov.

const azureIdentityTokenCallback = async (_, credential) => {
    const tokenResponse = await credential.getToken(['https://ossrdbms-aad.database.windows.net/.default']);

    if (!tokenResponse || !tokenResponse.token) {
        throw new Error('Failed to retrieve a valid access token.');
    }

    return {
        accessToken: tokenResponse.token,
        expiresInSeconds: Math.floor((tokenResponse.expiresOnTimestamp - Date.now()) / 1000),
    };
};

Ange klusternamnvariabeln så att den ansluter till ditt Azure DocumentDB-kluster.
```
const clusterName = '<azure-documentdb-cluster-name>';
```

Skapa en instans av DefaultAzureCredential.

const credential = new DefaultAzureCredential();

Skapa en MongoDB-klient som konfigurerats med OIDC-autentisering (OpenID Connect).

client = new MongoClient(`mongodb+srv://${clusterName}.global.mongocluster.cosmos.azure.com/`, {
    connectTimeoutMS: 120000,
    tls: true,
    retryWrites: true,
    authMechanism: 'MONGODB-OIDC',
    authMechanismProperties: {
        OIDC_CALLBACK: (params) => azureIdentityTokenCallback(params, credential),
        ALLOWED_HOSTS: ['*.azure.com']
    }
});

console.log('Client created');

Importera nödvändiga moduler överst i TypeScript-filen.

import { AccessToken, DefaultAzureCredential, TokenCredential } from '@azure/identity';
import { Collection, Db, Filter, FindCursor, MongoClient, OIDCCallbackParams, OIDCResponse, UpdateFilter, UpdateOptions, UpdateResult, WithId } from 'mongodb';

Skapa en återanropsfunktion för token som hämtar token från instansen TokenCredential vid behov.

const AzureIdentityTokenCallback = async (params: OIDCCallbackParams, credential: TokenCredential): Promise<OIDCResponse> => {
    const tokenResponse: AccessToken | null = await credential.getToken(['https://ossrdbms-aad.database.windows.net/.default']);
    return {
        accessToken: tokenResponse?.token || '',
        expiresInSeconds: (tokenResponse?.expiresOnTimestamp || 0) - Math.floor(Date.now() / 1000)
    };
};

Ange klusternamnvariabeln så att den ansluter till ditt Azure DocumentDB-kluster.
```
const clusterName: string = '<azure-documentdb-cluster-name>';
```

Skapa en instans av DefaultAzureCredential.

const credential: TokenCredential = new DefaultAzureCredential();

Skapa en MongoDB-klient som konfigurerats med OIDC-autentisering (OpenID Connect).

const client = new MongoClient(
    `mongodb+srv://${clusterName}.global.mongocluster.cosmos.azure.com/`, {
    connectTimeoutMS: 120000,
    tls: true,
    retryWrites: true,
    authMechanism: 'MONGODB-OIDC',
    authMechanismProperties: {
        OIDC_CALLBACK: (params: OIDCCallbackParams) => AzureIdentityTokenCallback(params, credential),
        ALLOWED_HOSTS: ['*.azure.com']
    }
});

console.log('Client created');

Utföra vanliga åtgärder

Använd slutligen det officiella biblioteket för att utföra vanliga uppgifter med databaser, samlingar och dokument. Här använder du samma klasser och metoder som du skulle använda för att interagera med MongoDB eller DocumentDB för att hantera dina samlingar och objekt.

Hämta en referens till din databas med namn.

const databaseName = process.env.SETTINGS__DATABASENAME ?? 'cosmicworks';

console.log('Database pointer created');

Hämta en referens till din samling.

const collectionName = process.env.SETTINGS__COLLECTIONNAME ?? 'products';

console.log('Collection pointer created');

Skapa ett dokument med och collection.updateOneupsert det till samlingen.

const filter = { _id: request.params._id };
const payload = {
    $set: document
};
const options = {
    upsert: true
};

var response = await collection.updateOne(filter, payload, options);

if (response.acknowledged) {
    console.log(`Documents upserted count:\t${response.matchedCount}`);
}

Använd collection.findOne för att hämta ett specifikt dokument från samlingen.

const filter = { _id: request.params.id };

var document = await collection.findOne(filter, options);

console.log(`Read document _id:\t${document._id}`);

Fråga efter flera dokument som matchar ett filter med hjälp av collection.find.

var filter = {
    category: 'gear-surf-surfboards'
};

var documents = collection.find(filter);

for await (const document of documents) {
    console.log(`Found document:\t${JSON.stringify(document)}`);
}

Stäng MongoDB-klientanslutningen när du är klar.
```
await client.close();
```

Hämta en referens till din databas med namn.

const database: Db = client.db('<database-name>');

console.log('Database pointer created');

Hämta en referens till din samling.

const collection: Collection<Product> = database.collection<Product>('<collection-name>');

console.log('Collection pointer created');

Definiera ett gränssnitt som representerar dina produktdokument.

interface Product {
    _id: string;
    category: string;
    name: string;
    quantity: number;
    price: number;
    clearance: boolean;
}

Skapa ett dokument med och collection.updateOneupsert det till samlingen.

var document: Product = {
    _id: 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb',
    category: 'gear-surf-surfboards',
    name: 'Yamba Surfboard',
    quantity: 12,
    price: 850.00,
    clearance: false
};

var query: Filter<Product> = {
    _id: 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb'
};
var payload: UpdateFilter<Product> = {
    $set: document
};
var options: UpdateOptions = {
    upsert: true
};
var response: UpdateResult<Product> = await collection.updateOne(query, payload, options);

if (response.acknowledged) {
    console.log(`Documents upserted count:\t${response.matchedCount}`);
}

Använd collection.findOne för att hämta ett specifikt dokument från samlingen.

var query: Filter<Product> = {
    _id: 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb',
    category: 'gear-surf-surfboards'
};

var response: WithId<Product> | null = await collection.findOne(query);

var read_item: Product = response as Product;

console.log(`Read document _id:\t${read_item._id}`);

Fråga efter flera dokument som matchar ett filter med hjälp av collection.find.

var query: Filter<Product> = {
    category: 'gear-surf-surfboards'
};

var response: FindCursor<WithId<Product>> = collection.find(query);

for await (const document of response) {
    console.log(`Found document:\t${JSON.stringify(document)}`);
}

Stäng MongoDB-klientanslutningen när du är klar.
```
await client.close();
```

Feedback

Var den här sidan till hjälp?

Last updated on 2025-11-19