Quickstart: Een Java-app bouwen om Azure Cosmos DB SQL API-gegevens te beheren

Artikel
11/25/2021
16 minuten om te lezen

VAN TOEPASSING OP: SQL-API

In deze quickstart maakt en beheert u een SQL API-account van Azure Cosmos DB via de Azure-portal en met een Java-app die is gekloond van GitHub. Eerst maakt u een Azure Cosmos DB SQL API-account via de Azure-portal, dan maakt u een Java-app met behulp van de SQL Java SDK en dan voegt u met de Java-toepassing resources toe aan uw Cosmos DB-account. Met Azure Cosmos DB, een databaseservice met meerdere modellen, kunt u snel databases met documenten, tabellen, sleutelwaarden en grafieken maken en hier query's op uitvoeren. Deze databases hebben wereldwijde distributie en horizontale schaalmogelijkheden.

Belangrijk

Deze quickstart geldt alleen voor Azure Cosmos DB Java SDK v4. Bekijk de release-opmerkingen bij Azure Cosmos DB Java SDK v4, de Maven-opslagplaats, prestatietips voor Azure Cosmos DB Java SDK v4 en de probleemoplossingsgids voor Azure Cosmos DB Java SDK v4 voor meer informatie. Als u momenteel een oudere versie dan v4 gebruikt, raadpleegt u de gids Migreren naar Azure Cosmos DB Java SDK v4 voor hulp om te upgraden naar v4.

Vereisten

Een Azure-account met een actief abonnement. Maak er gratis een. Of probeer Azure Cosmos DB gratis zonder Azure-abonnement. U kunt ook de Azure Cosmos DB Emulator gebruiken met een URI van https://localhost:8081 en de sleutel C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==.
Java Development Kit (JDK) 8+. Verwijs uw omgevingsvariabele JAVA_HOME naar de map waarin de JDK is geïnstalleerd.
Een binair Maven-archief. Voer op Ubuntu apt-get install maven uit om Maven te installeren.
Git. Voer op Ubuntu sudo apt-get install git uit om Git te installeren.

Inleidende opmerkingen

De structuur van een Cosmos DB-account. Ongeacht de API- of programmeer taal, bevat een Cosmos DB-account nul of meer databases, een database (DB) bevat nul of meer containers en een container bevat nul of meer items, zoals in het onderstaande diagram wordt weer gegeven:

Entiteiten van Azure Cosmos-account

Vind hier meer informatie over databases, containers en items. Enkele belangrijke eigenschappen worden op het niveau van de container gedefinieerd, onder andere ingerichte doorvoer en partitiesleutel.

De ingerichte doorvoer wordt gemeten in de aanvraageenheden (RU’s) die een monetaire prijs hebben en die een substantiële bepaling van de bedrijfskosten van het account zijn. Ingerichte doorvoer kan worden geselecteerd bij granulatie op basis van een container of nauwkeurigheid per database, maar de specificatie voor doorvoer op containerniveau verdient doorgaans de voorkeur. U kunt hier meer lezen over het inrichten van de doorvoer.

Naarmate items worden ingevoegd in een Cosmos DB-container, groeit de database horizontaal door meer opslag en rekenkracht toe te voegen voor het afhandelen van aanvragen. Opslag-en rekencapaciteit worden toegevoegd aan discrete eenheden die partities worden genoemd en u moet één veld in uw documenten selecteren als partitiesleutel die elk document aan een partitie toewijst. De manier waarop partities worden beheerd, is dat aan elke partitie een ongeveer gelijk segment uit het bereik van partitiesleutelwaarden wordt toegewezen. Daarom wordt u aangeraden een partitiesleutel te kiezen die relatief willekeurig of gelijkmatig gedistribueerd is. Als dat niet het geval is, zien sommige partities aanzienlijk meer aanvragen (dynamische partitie), terwijl andere partities aanzienlijk minder aanvragen (statische partitie) zien. Dit moet vermeden worden. U vind hier meer informatie over partitionering.

Een databaseaccount maken

Voordat u een documentdatabase kunt maken, moet u een SQL-API-account maken met Azure Cosmos DB.

Selecteer vanuit het menu van Azure Portal of op de startpagina de optie Een resource maken.
Zoek op de pagina Nieuw naar Azure Cosmos DB en selecteer dit.
Selecteer op de pagina Azure Cosmos DB Maken.

Voer op de Azure Cosmos DB account maken de basisinstellingen in voor het nieuwe Azure Cosmos-account.

Instelling	Waarde	Beschrijving
Abonnement	Abonnementsnaam	Selecteer het Azure-abonnement dat u voor dit Azure Cosmos-account wilt gebruiken.
Resourcegroep	Naam van de resourcegroep	Selecteer een resourcegroep of selecteer Nieuwe maken en voer vervolgens een unieke naam in voor de nieuwe resourcegroep.
Accountnaam	Een unieke naam	Voer een naam in om uw Azure Cosmos-account te identificeren. Gebruik een unieke naam omdat documents.azure.com is toegevoegd aan de naam die u hebt opgegeven om uw URI te maken. De naam mag alleen kleine letters, cijfers en het koppelteken (-) bevatten. De naam moet tussen de 3 en 44 tekens lang zijn.
API	Het type account dat moet worden gemaakt	Selecteer Core(SQL) om een documentdatabase en query's aan te maken met SQL-syntaxis. De API bepaalt het type te maken account. Azure Cosmos DB heeft vijf API's: Core (SQL) en MongoDB voor documentgegevens, Gremlin voor grafiekgegevens, Azure Table en Cassandra. Op dit moment moet u voor elke API een afzonderlijk account maken. Meer informatie over de SQL-API.
Locatie	De regio het dichtst bij uw gebruikers	Selecteer een geografische locatie waar u het Azure Cosmos DB-account wilt hosten. Gebruik de locatie die zich het dichtst bij uw gebruikers bevindt, zodat ze de snelst mogelijke toegang tot de gegevens hebben.
Capaciteitsmodus	Ingerichte doorvoer of serverloos	Selecteer Ingerichte doorvoer om een account te maken in de modus Ingerichte doorvoer. Selecteer Serverloos om een account te maken in de modus serverloos.
Niveaukorting op gratis laag van Azure Cosmos DB toepassen	Toepassen of niet toepassen	Met Azure Cosmos DB gratis laag krijgt u de eerste 1000 RU/s en 25 GB aan opslagruimte gratis in een account. Meer informatie over de gratis laag.

Notitie

U kunt per Azure-abonnement maximaal één gratis laag voor het Azure Cosmos DB-account hebben, en u moet zich aanmelden wanneer u het account maakt. Als u de optie voor het toepassen van de korting voor gratis lagen niet ziet, betekent dit dat er al een ander account in het abonnement is ingeschakeld met een gratis laag.

De pagina Nieuw account voor Azure Cosmos DB

Configureer de volgende gegevens op het tabblad Globale distributie. U kunt de standaardwaarden voor deze quickstart laten staan:

Instelling	Waarde	Beschrijving
Georedundantie	Uitschakelen	Schakel globale distributie voor uw account in of uit door uw regio te koppelen met een koppelingsregio. U kunt later meer regio's aan uw account toevoegen.
Schrijven voor meerdere regio's	Uitschakelen	Dankzij de mogelijkheid voor schrijfbewerkingen in meerdere regio's kunt over de hele wereld profiteren van de ingerichte doorvoer voor uw databases en containers.

Notitie

De volgende opties zijn niet beschikbaar als u Serverloos als Capaciteitsmodus selecteert:

Korting voor gratis lagen toepassen
Geografische redundantie
Schrijven voor meerdere regio's

Optioneel kunt u aanvullende details configureren op de volgende tabbladen:
- Netwerken: configureer de toegang vanuit een virtueel netwerk.
- Back-upbeleid: configureer het periodieke of continue back-upbeleid.
- Versleuteling: gebruik een door de service beheerde sleutel of een door de klant beheerde sleutel.
- Tags: tags zijn naam/waarde-paren waarmee u resources kunt categoriseren en geconsolideerde facturering kunt weergeven door dezelfde tag toe te passen op meerdere resources en resourcegroepen.
Selecteer Controleren + maken.
Controleer de accountinstellingen en selecteer vervolgens Maken. Het duurt een paar minuten om het account te maken. Wacht tot de portal-pagina Uw implementatie is voltooid weergeeft.
Selecteer Ga naar resource om naar de Azure Cosmos DB-accountpagina te gaan.

Een container toevoegen

U kunt nu het hulpprogramma Data Explorer in de Azure-portal gebruiken om een database en een container te maken.

Selecteer Data Explorer > Nieuwe container.

Uiterst rechts wordt het gedeelte Container toevoegen weergegeven. Mogelijk moet u naar rechts scrollen om het te kunnen zien.

Geef op de pagina Container toevoegen de instellingen voor de nieuwe container op.

Instelling	Voorgestelde waarde	Beschrijving
Database-id	Takenlijst	Voer Taken in als de naam voor de nieuwe database. Databasenamen moeten tussen de 1 en 255 tekens zijn en mogen geen `/, \\, #, ?` bevatten en mogen niet eindigen met een spatie. Controleer de optie Doorvoer tussen containers delen. Hiermee kunt u de doorvoer die is ingericht op de database delen in alle containers in de database. Met deze optie bespaart u bovendien op de kosten.
Databasedoorvoer	U kunt automatisch schalen of handmatige doorvoer inrichten. Met handmatige doorvoer kunt u RU/s zelf schalen, terwijl de doorvoer automatisch schalen het systeem in staat stelt RU/s te schalen op basis van gebruik. Selecteer Handmatig voor dit voorbeeld. Wijzig de doorvoer in 400 aanvraageenheden per seconde (RU/s). Als u de latentie wilt verminderen, kunt u de doorvoer later omhoog schalen door de vereiste RU/s te schatten met de capaciteitscalculator. Opmerking: Deze instelling is niet beschikbaar bij het maken van een nieuwe container in een serverloos account.
Container-id	Items	Voer Items in als de naam voor de nieuwe container. Voor id's van containers gelden dezelfde tekenvereisten als voor databasenamen.
Partitiesleutel	/category	In het voorbeeld dat in dit artikel wordt beschreven, wordt /category als de partitiesleutel gebruikt.

Voeg voor dit voorbeeld geen unieke sleutels toe of schakel Analytische opslag niet in. Met unieke sleutels kunt u een laag van gegevensintegriteit toevoegen aan de database door de uniekheid van een of meer waarden per partitiesleutel te garanderen. Zie Unieke sleutels in Azure Cosmos DB. Analytische opslag wordt gebruikt om grootschalige analyses in te stellen op basis van operationele gegevens zonder dat dit van invloed is op uw transactionele workloads.

Selecteer OK. In Data Explorer worden de nieuwe database en container weergegeven.

Voorbeeldgegevens toevoegen

U kunt nu gegevens aan uw nieuwe container toevoegen met behulp van Data Explorer.

Vouw in Data Explorer de database Taken uit en vouw de container Items uit. Selecteer Items en vervolgens Nieuw item.

Voeg nu een document met de volgende structuur aan de container toe.

{
    "id": "1",
    "category": "personal",
    "name": "groceries",
    "description": "Pick up apples and strawberries.",
    "isComplete": false
}

Zodra u de JSON hebt toegevoegd aan het tabblad Documenten, selecteert u Opslaan.
Maak nog één document en sla dit op. In het document voegt u een unieke waarde toe voor de eigenschap id. Wijzig de andere eigenschappen naar eigen inzicht. De nieuwe documenten kunnen elke gewenste structuur hebben, omdat in Azure Cosmos DB uw gegevens geen schema krijgen opgelegd.

Uw gegevens opvragen

U kunt query's in Data Explorer gebruiken om uw gegevens op te halen en te filteren.

Controleer bovenaan het tabblad Items in Data Explorer de standaardquery SELECT * FROM c. Met deze query worden alle documenten opgehaald uit de container en weergegeven op volgorde van id.
Als u de query wilt wijzigen, selecteert u Filter bewerken, vervangt u de standaardquery door ORDER BY c._ts DESC en selecteert u Filter toepassen.

De gewijzigde query sorteert de documenten in aflopende volgorde op basis van hun tijdstempel. Uw tweede document wordt nu dus als eerste weergegeven.

Als u bekend bent met SQL-syntaxis, kunt u een van de ondersteunde SQL-query's in het vak Querypredicaat invoeren. U kunt Data Explorer ook gebruiken voor het maken van opgeslagen procedures, UDF's en triggers om bedrijfslogica aan de serverzijde uit te voeren.

Data Explorer biedt eenvoudige toegang via Azure Portal tot alle ingebouwde programmatische datatoegangsfuncties die in de API's beschikbaar zijn. U gebruikt de portal ook om de doorvoer te schalen, sleutels en verbindingsreeksen op te halen en metrische gegevens en SLA's voor uw Azure Cosmos DB-account te bekijken.

De voorbeeldtoepassing klonen

Nu gaan we werken met code. We gaan nu een SQL API-app klonen vanaf GitHub, de verbindingsreeks instellen en de app uitvoeren. U zult zien hoe gemakkelijk het is om op een programmatische manier met gegevens te werken.

Voer de volgende opdracht uit om de voorbeeldopslagplaats te klonen. Deze opdracht maakt een kopie van de voorbeeld-app op uw computer.

git clone https://github.com/Azure-Samples/azure-cosmos-java-getting-started.git

De code bekijken

Deze stap is optioneel. Als u wilt weten hoe de databaseresources in de code worden gemaakt, kunt u de volgende codefragmenten bekijken. Sla dit anders over en ga naar De app uitvoeren.

API synchroniseren
Async-API

Database resources beheren met behulp van de synchrone API

Initialisatie van CosmosClient. De CosmosClient biedt een logische weergave aan de clientzijde voor de databaseservice van Azure Cosmos. Deze client wordt gebruikt om aanvragen aan de service te configureren en uitvoeren.

client = new CosmosClientBuilder()
    .endpoint(AccountSettings.HOST)
    .key(AccountSettings.MASTER_KEY)
    //  Setting the preferred location to Cosmos DB Account region
    //  West US is just an example. User should set preferred location to the Cosmos DB region closest to the application
    .preferredRegions(Collections.singletonList("West US"))
    .consistencyLevel(ConsistencyLevel.EVENTUAL)
    .buildClient();

CosmosDatabase maken.

CosmosDatabaseResponse cosmosDatabaseResponse = client.createDatabaseIfNotExists(databaseName);
database = client.getDatabase(cosmosDatabaseResponse.getProperties().getId());

CosmosContainer maken.

CosmosContainerProperties containerProperties =
    new CosmosContainerProperties(containerName, "/lastName");

//  Create container with 400 RU/s
CosmosContainerResponse cosmosContainerResponse =
    database.createContainerIfNotExists(containerProperties, ThroughputProperties.createManualThroughput(400));
container = database.getContainer(cosmosContainerResponse.getProperties().getId());

Items maken met behulp van de createItem-methode.

//  Create item using container that we created using sync client

//  Use lastName as partitionKey for cosmos item
//  Using appropriate partition key improves the performance of database operations
CosmosItemRequestOptions cosmosItemRequestOptions = new CosmosItemRequestOptions();
CosmosItemResponse<Family> item = container.createItem(family, new PartitionKey(family.getLastName()), cosmosItemRequestOptions);

Puntleesbewerkingen worden uitgevoerd met behulp van readItem-methode.

try {
    CosmosItemResponse<Family> item = container.readItem(family.getId(), new PartitionKey(family.getLastName()), Family.class);
    double requestCharge = item.getRequestCharge();
    Duration requestLatency = item.getDuration();
    logger.info("Item successfully read with id {} with a charge of {} and within duration {}",
        item.getItem().getId(), requestCharge, requestLatency);
} catch (CosmosException e) {
    logger.error("Read Item failed with", e);
}

SQL-query's via JSON worden uitgevoerd met behulp van de methode queryItems.

// Set some common query options
CosmosQueryRequestOptions queryOptions = new CosmosQueryRequestOptions();
//queryOptions.setEnableCrossPartitionQuery(true); //No longer necessary in SDK v4
//  Set query metrics enabled to get metrics around query executions
queryOptions.setQueryMetricsEnabled(true);

CosmosPagedIterable<Family> familiesPagedIterable = container.queryItems(
    "SELECT * FROM Family WHERE Family.lastName IN ('Andersen', 'Wakefield', 'Johnson')", queryOptions, Family.class);

familiesPagedIterable.iterableByPage(10).forEach(cosmosItemPropertiesFeedResponse -> {
    logger.info("Got a page of query result with {} items(s) and request charge of {}",
            cosmosItemPropertiesFeedResponse.getResults().size(), cosmosItemPropertiesFeedResponse.getRequestCharge());

    logger.info("Item Ids {}", cosmosItemPropertiesFeedResponse
        .getResults()
        .stream()
        .map(Family::getId)
        .collect(Collectors.toList()));
});

Database resources beheren met behulp van de asynchrone API

Asynchrone API-aanroepen worden direct geretourneerd zonder dat er wordt gewacht op een reactie van de server. In het licht hiervan geven de volgende codefragmenten goede ontwerppatronen weer voor het uitvoeren van alle voorgaande beheertaken met behulp van asynchrone API.

Initialisatie van CosmosAsyncClient. De CosmosAsyncClient biedt een logische weergave aan de clientzijde voor de databaseservice van Azure Cosmos. Deze client wordt gebruikt om asynchrone aanvragen aan de service te configureren en uitvoeren.

client = new CosmosClientBuilder()
    .endpoint(AccountSettings.HOST)
    .key(AccountSettings.MASTER_KEY)
    //  Setting the preferred location to Cosmos DB Account region
    //  West US is just an example. User should set preferred location to the Cosmos DB region closest to the application
    .preferredRegions(Collections.singletonList("West US"))
    .consistencyLevel(ConsistencyLevel.EVENTUAL)
    //  Setting content response on write enabled, which enables the SDK to return response on write operations.
    .contentResponseOnWriteEnabled(true)
    .buildAsyncClient();

CosmosAsyncDatabase maken.

CosmosDatabaseResponse cosmosDatabaseResponse = client.createDatabaseIfNotExists(databaseName);
database = client.getDatabase(cosmosDatabaseResponse.getProperties().getId());

CosmosAsyncContainer maken.

CosmosContainerProperties containerProperties =
    new CosmosContainerProperties(containerName, "/lastName");

//  Create container with 400 RU/s
CosmosContainerResponse cosmosContainerResponse =
    database.createContainerIfNotExists(containerProperties, ThroughputProperties.createManualThroughput(400));
container = database.getContainer(cosmosContainerResponse.getProperties().getId());

Net als bij de synchrone API wordt het maken van items uitgevoerd met behulp van de createItem-methode. Dit voorbeeld laat zien hoe u op efficiënte wijze talloze asynchrone createItem aanvragen verstrekt door een reactieve stroom te gebruiken die de aanvragen verstrekt en meldingen verzendt. Aangezien dit eenvoudige voorbeeld wordt uitgevoerd om te worden voltooid en beëindigd, worden CountDownLatch-exemplaren gebruikt om ervoor te zorgen dat het programma niet wordt beëindigd tijdens het maken van het item. De juiste asynchrone programmeringsprocedure is om niet blokkeren op asynchrone aanroepen. In werkelijkheid worden gebruiksvoorbeeldaanvragen gegenereerd op basis van een hoofd()-lus die voor onbepaalde tijd wordt uitgevoerd, waardoor men niet afhankelijk is van asynchrone aanroepen.


try {

    //  Combine multiple item inserts, associated success println's, and a final aggregate stats println into one Reactive stream.
    double charge = families.flatMap(family -> {
        return container.createItem(family);
    }) //Flux of item request responses
            .flatMap(itemResponse -> {
                logger.info("Created item with request charge of {} within" +
                                " duration {}",
                        itemResponse.getRequestCharge(), itemResponse.getDuration());
                logger.info("Item ID: {}\n", itemResponse.getItem().getId());
                return Mono.just(itemResponse.getRequestCharge());
            }) //Flux of request charges
            .reduce(0.0,
                    (charge_n, charge_nplus1) -> charge_n + charge_nplus1
            ) //Mono of total charge - there will be only one item in this stream
            .block(); //Preserve the total charge and print aggregate charge/item count stats.

    logger.info("Created items with total request charge of {}\n", charge);

} catch (Exception err) {
    if (err instanceof CosmosException) {
        //Client-specific errors
        CosmosException cerr = (CosmosException) err;
        logger.error("Read Item failed with CosmosException\n", cerr);
    } else {
        //General errors
        logger.error("Read Item failed with error\n", err);
    }
}

Net als met de synchrone API, worden puntleesbewerkingen uitgevoerd met behulp van readItem-methode.


try {

    familiesToCreate.flatMap(family -> {
        Mono<CosmosItemResponse<Family>> asyncItemResponseMono = container.readItem(family.getId(), new PartitionKey(family.getLastName()), Family.class);
        return asyncItemResponseMono;
    }).flatMap(itemResponse -> {
        double requestCharge = itemResponse.getRequestCharge();
        Duration requestLatency = itemResponse.getDuration();
        logger.info("Item successfully read with id {} with a charge of {} and within duration {}",
                itemResponse.getItem().getId(), requestCharge, requestLatency);
        return Flux.empty();
    }).blockLast();

} catch (Exception err) {
    if (err instanceof CosmosException) {
        //Client-specific errors
        CosmosException cerr = (CosmosException) err;
        logger.error("Read Item failed with CosmosException\n", cerr);
    } else {
        //General errors
        logger.error("Read Item failed\n", err);
    }
}

Net als met de synchrone API, worden SQL-query's via JSON uitgevoerd met behulp van de methode queryItems.

// Set some common query options

int preferredPageSize = 10; // We'll use this later

CosmosQueryRequestOptions queryOptions = new CosmosQueryRequestOptions();

//  Set populate query metrics to get metrics around query executions
queryOptions.setQueryMetricsEnabled(true);

CosmosPagedFlux<Family> pagedFluxResponse = container.queryItems(
        "SELECT * FROM Family WHERE Family.lastName IN ('Andersen', 'Wakefield', 'Johnson')", queryOptions, Family.class);

try {

    pagedFluxResponse.byPage(preferredPageSize).flatMap(fluxResponse -> {
        logger.info("Got a page of query result with " +
                fluxResponse.getResults().size() + " items(s)"
                + " and request charge of " + fluxResponse.getRequestCharge());

        logger.info("Item Ids " + fluxResponse
                .getResults()
                .stream()
                .map(Family::getId)
                .collect(Collectors.toList()));

        return Flux.empty();
    }).blockLast();

} catch(Exception err) {
    if (err instanceof CosmosException) {
        //Client-specific errors
        CosmosException cerr = (CosmosException) err;
        logger.error("Read Item failed with CosmosException\n", cerr);
    } else {
        //General errors
        logger.error("Read Item failed\n", err);
    }
}

De app uitvoeren

Ga nu terug naar de Azure-portal om de verbindingsreeksgegevens op te halen en start de app met uw eindpuntgegevens. Hierdoor kan de app communiceren met de gehoste database.

Ga met de opdracht cd in het git-terminalvenster naar de map met voorbeeldcode.
```
cd azure-cosmos-java-getting-started
```
Gebruik in het git-terminalvenster de volgende opdracht om de vereiste Java-pakketten te installeren.
```
mvn package
```
Start in het git-terminalvenster met de volgende opdracht de Java-toepassing (vervang SYNCASYNCMODE door sync of async afhankelijk van welke voorbeeldcode u uit wilt voeren, vervang YOUR_COSMOS_DB_HOSTNAME door de URI-waarde van de portal tussen aanhalingstekens, en vervang YOUR_COSMOS_DB_MASTER_KEY door de primaire sleutel van de portal tussen aanhalingstekens)
```
mvn exec:java@SYNCASYNCMODE -DACCOUNT_HOST=YOUR_COSMOS_DB_HOSTNAME -DACCOUNT_KEY=YOUR_COSMOS_DB_MASTER_KEY
```
Het terminalvenster geeft een melding dat de database FamilyDB is gemaakt.
De app maakt een database met de naam AzureSampleFamilyDB
De app maakt een container met de naam FamilyContainer
De app voert puntleesbewerkingen uit met behulp van object-id's en de partitiesleutelwaarde (in het voorbeeld lastName).
Met de app worden items gezocht voor het ophalen van alle families met achternaam in ("Andersen", "Wakefield", "Johnson")
De resources die zijn gemaakt, worden niet verwijderd door de app. Ga terug naar de portal om de resources te verwijderen. uit uw account zodat u daarvoor geen kosten in rekening worden gebracht.

SLA’s bekijken in Azure Portal

De doorvoer, opslag, beschikbaarheid, latentie en consistentie van uw Cosmos DB-account worden in Azure Portal bewaakt. Grafieken voor metrische gegevens die zijn gekoppeld aan een Azure Cosmos DB Service Level Agreement (SLA) tonen de SLA-waarde in vergelijking met de werkelijke prestaties. Deze suite van metrische gegevens zorgt voor een transparante bewaking van uw SLA's.

Metrische gegevens en SLA's weergeven:

Selecteer Metrische gegevens in het navigatiemenu van uw Cosmos DB-account.
Selecteer een tabblad, bijvoorbeeld Latentie, en selecteer aan de rechterkant een tijdsbestek. Vergelijk de lijnen Werkelijk en SLA in de grafieken met elkaar.
Bekijk de metrische gegevens op de andere tabbladen.

Resources opschonen

Wanneer u uw app en Azure Cosmos DB-account niet meer nodig hebt, kunt u de Azure-resources die u hebt gemaakt, verwijderen zodat er geen kosten meer voor in rekening worden gebracht. Om de resources te verwijderen:

Zoek en selecteer Resourcegroepen in de zoekbalk op Azure Portal.
Selecteer de resourcegroep die u eerder voor deze quickstart hebt gemaakt uit de lijst.
Selecteer Resourcegroep verwijderen op de pagina Overzicht van de resourcegroep.
Selecteer in het volgende venster de naam van de resourcegroep die u wilt verwijderen en selecteer vervolgens Verwijderen.

Volgende stappen

In deze snelstart hebt u geleerd hoe u een Azure Cosmos DB SQL API-account, een documentdatabase maakt en een container kunt maken met behulp van Data Explorer, en hoe u een Java-app kunt uitvoeren die hetzelfde doet via een programma. Nu kunt u aanvullende gegevens in uw Azure Cosmos DB-account importeren.

Probeert u capaciteitsplanning uit te Azure Cosmos DB? U kunt informatie over uw bestaande databasecluster gebruiken voor capaciteitsplanning.

Als u alleen het aantal vcores en servers in uw bestaande databasecluster weet, leest u over het schatten van aanvraageenheden met behulp van vCores of vCCPUs
Als u de gebruikelijke aanvraagsnelheden voor uw huidige databaseworkload kent, leest u over het schatten van aanvraageenheden met behulp Azure Cosmos DB capacity planner

Gegevens importeren in Azure Cosmos DB