Snabbstart: Skapa en Tabell-API-app med .NET SDK och Azure Cosmos DB

GÄLLER för: tabell-API

Den här snabbstarten visar hur du kommer Azure Cosmos DB Tabell-API från ett .NET-program. Den Cosmos DB Tabell-API är ett schemalöst datalager som gör att program kan lagra strukturerade NoSQL-data i molnet. Eftersom data lagras i en schemalös design läggs nya egenskaper (kolumner) automatiskt till i tabellen när ett objekt med ett nytt attribut läggs till i tabellen.

.NET-program kan komma åt Cosmos DB Tabell-API med hjälp av NuGet-paketet Azure.Data.Tables. Azure.Data.Tables-paketet är ett .NET Standard 2.0-bibliotek som fungerar med både .NET Framework-program (4.7.2 och senare) och .NET Core-program (2.0 och senare).

Förutsättningar

Exempelprogrammet är skrivet i .NET Core 3.1, men principerna gäller för både .NET Framework- och .NET Core-program. Du kan använda antingen Visual Studio, Visual Studio för Maceller Visual Studio Code som en IDE.

Om du inte har en Azure-prenumerationkan du skapa ett kostnads fritt konto innan du börjar.

Exempelprogram

Exempelprogrammet för den här självstudien kan klonas eller hämtas från lagringsplatsen https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-dotnet . Både en startapp och en färdig app ingår i exempeldatabasen.

git clone https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-dotnet

Exempelprogrammet använder väderdata som exempel för att demonstrera funktionerna i Tabell-API. Objekt som representerar väderobservationer lagras och hämtas med hjälp av Tabell-API, inklusive lagring av objekt med ytterligare egenskaper för att demonstrera de schemalösa funktionerna i Tabell-API.

1 – Skapa ett Azure Cosmos DB konto

Du måste först skapa ett Cosmos DB-API-konto för tabeller som innehåller de tabeller som används i ditt program. Detta kan göras med hjälp av Azure Portal, Azure CLI eller Azure PowerShell.

• Azure Portal
• Azure CLI
• Azure PowerShell

Logga in på Azure Portal och följ dessa steg för att skapa ett Cosmos DB konto.

Instruktioner	Skärmbild
I Azure-portalen: I sökfältet högst upp i Azure Portal anger du "cosmos db". På menyn som visas under sökfältet under Tjänster väljer du det objekt som är märkt Azure Cosmos DB.
På sidan Azure Cosmos DB väljer du +Skapa.
På sidan Välj API-alternativ väljer du alternativet Azure-tabell.
På sidan Skapa Azure Cosmos DB-konto – Azure-tabell fyller du i formuläret på följande sätt. Skapa en ny resursgrupp för lagringskontot med namnet rg-msdocs-tables-sdk-demo genom att välja länken Skapa ny under Resursgrupp. Ge lagringskontot ett namn där cosmos-msdocs-tables-sdk-demo-XYZ XYZ är tre slumpmässiga tecken för att skapa ett unikt kontonamn. Azure Cosmos DB måste vara mellan 3 och 44 tecken långa och får bara innehålla gemener, siffror eller bindestreck (-). Välj regionen för ditt lagringskonto. Välj Standardprestanda. Välj Etablerat dataflöde för det här exemplet under Kapacitetsläge. Välj Tillämpa under Tillämpa rabatt på kostnadsfri nivå för det här exemplet. Välj knappen Granska + skapa längst ned på skärmen och välj sedan "Skapa" på sammanfattningsskärmen för att skapa ditt Azure Cosmos DB konto. Det här kan ta flera minuter.

2 – Skapa en tabell

Därefter måste du skapa en tabell i ditt Cosmos DB som programmet ska använda. Till skillnad från en traditionell databas behöver du bara ange namnet på tabellen, inte egenskaperna (kolumnerna) i tabellen. När data läses in i tabellen skapas egenskaperna (kolumnerna) automatiskt efter behov.

• Azure Portal
• Azure CLI
• Azure PowerShell

I Azure Portaldu följande steg för att skapa en tabell i ditt Cosmos DB konto.

Instruktioner	Skärmbild
I Azure Portal navigerar du till översiktssidan för Azure Cosmos DB konto. Du kan gå till översiktssidan för ditt Cosmos DB-konto genom att skriva namnet (cosmos-msdocs-tables-sdk-demo-XYZ) på ditt Cosmos DB-konto i det övre sökfältet och titta under rubriken resurser.Välj namnet på ditt Azure Cosmos DB för att gå till översiktssidan.
På översiktssidan väljer du +Lägg till tabell. Dialogrutan Ny tabell visas från höger på sidan.
I dialogrutan Ny tabell fyller du i formuläret på följande sätt. Ange namnet WeatherData för tabell-ID:t. Det här är namnet på tabellen. Välj Manuellt under Tabellgenomflöde (autoskalning) för det här exemplet. Använd standardvärdet 400 under dina uppskattade RU/s. Välj knappen OK för att skapa tabellen.

3 – Hämta Cosmos DB-anslutningssträng

För att komma åt dina tabeller i Cosmos DB behöver appen tabellanslutningssträngen för CosmosDB-Storage kontot. Anslutningssträngen kan hämtas med hjälp av Azure Portal, Azure CLI eller Azure PowerShell.

• Azure Portal
• Azure CLI
• Azure PowerShell

Instruktioner	Skärmbild
På vänster sida av Azure Cosmos DB kontosidan letar du upp menyalternativet Anslutningssträng under Inställningar och väljer det. Du kommer till en sida där du kan hämta anslutningssträngen för lagringskontot.
Kopiera värdet PRIMÄR ANSLUTNINGSSTRÄNG som ska användas i ditt program.

Anslutningssträngen för ditt Cosmos DB-konto betraktas som en apphemlighet och måste skyddas precis som andra apphemligheter eller lösenord. I det här exemplet används verktyget Secret Manager för att lagra anslutningssträngen under utvecklingen och göra den tillgänglig för programmet. Secret Manager-verktyget kan nås från antingen Visual Studio eller .NET CLI.

{
  "ConnectionStrings": {
    "CosmosTableApi": "<cosmos db table connection string>"
  }  
}

dotnet user-secrets init

dotnet user-secrets set "ConnectionStrings:CosmosTableApi" "<cosmos db table connection string>"

4 – Installera NuGet-paketet Azure.Data.Tables

Om du vill Cosmos DB Tabell-API från ett .NET-program installerar du NuGet-paketet Azure.Data.Tables.

Install-Package Azure.Data.Tables

dotnet add package Azure.Data.Tables

5 – Konfigurera tabellklienten i Startup.cs

Azure SDK kommunicerar med Azure med hjälp av klientobjekt för att köra olika åtgärder mot Azure. TableClient-objektet är det objekt som används för att kommunicera med Cosmos DB Tabell-API.

Ett program skapar vanligtvis ett enda TableClient-objekt per tabell som ska användas i hela programmet. Vi rekommenderar att du använder beroendeinjektion (DI) och registrerar TableClient-objektet som en singleton för att åstadkomma detta. Mer information om hur du använder DI med Azure SDK finns i Dependency injection with the Azure SDK for .NET (Beroendeinjektion med Azure SDK för .NET).

Redigera metoden Startup.cs ConfigureServices() i filen för programmet så att den matchar följande kodfragment:

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages()
        .AddMvcOptions(options =>
        {
            options.Filters.Add(new ValidationFilter());
        });
    
    var connectionString = Configuration.GetConnectionString("CosmosTableApi");
    services.AddSingleton<TableClient>(new TableClient(connectionString, "WeatherData"));
    
    services.AddSingleton<TablesService>();
}

Du måste också lägga till följande using-instruktion överst i filen Startup.cs.

using Azure.Data.Tables;

6 – Implementera Cosmos DB tabellåtgärder

Alla Cosmos DB tabellåtgärder för exempelappen implementeras i TableService klassen som finns i katalogen Services. Du måste importera namnrymderna och överst i den här filen för Azure att arbeta med objekt i Azure.Data.Tables Azure.Data.Tables SDK-paketet.

using Azure;
using Azure.Data.Tables;

I början av klassen lägger du till en medlemsvariabel för TableClient-objektet och en konstruktor så att TableService TableClient-objektet kan matas in i klassen.

private TableClient _tableClient;

public TablesService(TableClient tableClient)
{
    _tableClient = tableClient;
}

Hämta rader från en tabell

Klassen TableClient innehåller en metod med namnet Query som gör att du kan välja rader från tabellen. Eftersom inga parametrar skickas till metoden i det här exemplet väljs alla rader från tabellen.

Metoden tar också en generisk parameter av typen ITableEntity som anger att modellklassdata returneras som. I det här fallet används den inbyggda klassen TableEntity, vilket innebär Query att metoden returnerar en samling som Pageable<TableEntity> resultat.

public IEnumerable<WeatherDataModel> GetAllRows()
{
    Pageable<TableEntity> entities = _tableClient.Query<TableEntity>();

    return entities.Select(e => MapTableEntityToWeatherDataModel(e));
}

Klassen TableEntity som definieras i Azure.Data.Tables paketet har egenskaper för partitionsnyckeln och radnyckelvärdena i tabellen. Tillsammans ger dessa två värden en unik nyckel för raden i tabellen. I det här exempelprogrammet lagras namnet på väderstationen (stad) i partitionsnyckeln och datum/tid för observationen lagras i radnyckeln. Alla andra egenskaper (temperatur, luftfuktighet, vindhastighet) lagras i en ordlista i TableEntity objektet.

Det är vanligt att mappa ett TableEntity-objekt till ett objekt med en egen definition. Exempelprogrammet definierar en klass WeatherDataModel i katalogen Models för detta ändamål. Den här klassen har egenskaper för stationsnamn och observationsdatum som partitionsnyckeln och radnyckeln mappas till, vilket ger mer meningsfulla egenskapsnamn för dessa värden. Sedan används en ordlista för att lagra alla andra egenskaper i objektet. Det här är ett vanligt mönster när du arbetar med Table Storage eftersom en rad kan ha valfritt antal godtyckliga egenskaper och vi vill att våra modellobjekt ska kunna samla in alla. Den här klassen innehåller också metoder för att lista egenskaperna för klassen.

public class WeatherDataModel 
{
    // Captures all of the weather data properties -- temp, humidity, wind speed, etc
    private Dictionary<string, object> _properties = new Dictionary<string, object>();

    public string StationName { get; set; }

    public string ObservationDate { get; set; }

    public DateTimeOffset? Timestamp { get; set; }

    public string Etag { get; set; }

    public object this[string name] 
    { 
        get => ( ContainsProperty(name)) ? _properties[name] : null; 
        set => _properties[name] = value; 
    }
    
    public ICollection<string> PropertyNames => _properties.Keys;

    public int PropertyCount => _properties.Count;

    public bool ContainsProperty(string name) => _properties.ContainsKey(name);       
}

Metoden MapTableEntityToWeatherDataModel används för att mappa ett TableEntity-objekt till ett WeatherDataModel -objekt. Objektet TableEntity innehåller egenskapen Nycklar för att hämta alla egenskapsnamn som finns i tabellen för objektet (effektivt kolumnnamnen för den här raden i tabellen). Metoden mappar egenskaperna , , och direkt och använder sedan egenskapen för att iterera över de andra egenskaperna i objektet och mappa dem till objektet, minus de egenskaper som redan har MapTableEntityToWeatherDataModel PartitionKey RowKey Timestamp Etag Keys TableEntity WeatherDataModel mappats direkt.

Redigera koden i metoden MapTableEntityToWeatherDataModel så att den matchar följande kodblock.

public WeatherDataModel MapTableEntityToWeatherDataModel(TableEntity entity)
{
    WeatherDataModel observation = new WeatherDataModel();
    observation.StationName = entity.PartitionKey;
    observation.ObservationDate = entity.RowKey;
    observation.Timestamp = entity.Timestamp;
    observation.Etag = entity.ETag.ToString();

    var measurements = entity.Keys.Where(key => !EXCLUDE_TABLE_ENTITY_KEYS.Contains(key));
    foreach (var key in measurements)
    {
        observation[key] = entity[key];
    }
    return observation;            
}

Filtrera rader som returneras från en tabell

Om du vill filtrera de rader som returneras från en tabell kan du skicka en sträng för OData-formatfilter till frågemetoden. Om du till exempel vill hämta alla väderavläsningar för Chicago mellan midnatt 1 juli 2021 och midnatt 2 juli 2021 (inklusive) skickar du följande filtersträng.

PartitionKey eq 'Chicago' and RowKey ge '2021-07-01 12:00 AM' and RowKey le '2021-07-02 12:00 AM'

Du kan visa alla OData-filteroperatorer på OData-webbplatsen i avsnittet Filter System Query Option (Filtrera systemfrågealternativet).

I exempelprogrammet är -objektet FilterResultsInputModel utformat för att avbilda eventuella filterkriterier som tillhandahålls av användaren.

public class FilterResultsInputModel : IValidatableObject
{
    public string PartitionKey { get; set; }
    public string RowKeyDateStart { get; set; }
    public string RowKeyTimeStart { get; set; }
    public string RowKeyDateEnd { get; set; }
    public string RowKeyTimeEnd { get; set; }
    [Range(-100, +200)]
    public double? MinTemperature { get; set; }
    [Range(-100,200)]
    public double? MaxTemperature { get; set; }
    [Range(0, 300)]
    public double? MinPrecipitation { get; set; }
    [Range(0,300)]
    public double? MaxPrecipitation { get; set; }
}

När det här objektet skickas till metoden i klassen skapas en GetFilteredRows TableService filtersträng för varje egenskapsvärde som inte är null. Den skapar sedan en kombinerad filtersträng genom att koppla ihop alla värden med en "and"-sats. Den här kombinerade filtersträngen skickas till frågemetoden i TableClient-objektet och endast rader som matchar filtersträngen returneras. Du kan använda en liknande metod i koden för att skapa lämpliga filtersträngar som krävs av ditt program.

public IEnumerable<WeatherDataModel> GetFilteredRows(FilterResultsInputModel inputModel)
{
    List<string> filters = new List<string>();

    if (!String.IsNullOrEmpty(inputModel.PartitionKey))
        filters.Add($"PartitionKey eq '{inputModel.PartitionKey}'");
    if (!String.IsNullOrEmpty(inputModel.RowKeyDateStart) && !String.IsNullOrEmpty(inputModel.RowKeyTimeStart))
        filters.Add($"RowKey ge '{inputModel.RowKeyDateStart} {inputModel.RowKeyTimeStart}'");
    if (!String.IsNullOrEmpty(inputModel.RowKeyDateEnd) && !String.IsNullOrEmpty(inputModel.RowKeyTimeEnd))
        filters.Add($"RowKey le '{inputModel.RowKeyDateEnd} {inputModel.RowKeyTimeEnd}'");
    if (inputModel.MinTemperature.HasValue)
        filters.Add($"Temperature ge {inputModel.MinTemperature.Value}");
    if (inputModel.MaxTemperature.HasValue)
        filters.Add($"Temperature le {inputModel.MaxTemperature.Value}");
    if (inputModel.MinPrecipitation.HasValue)
        filters.Add($"Precipitation ge {inputModel.MinTemperature.Value}");
    if (inputModel.MaxPrecipitation.HasValue)
        filters.Add($"Precipitation le {inputModel.MaxTemperature.Value}");

    string filter = String.Join(" and ", filters);
    Pageable<TableEntity> entities = _tableClient.Query<TableEntity>(filter);

    return entities.Select(e => MapTableEntityToWeatherDataModel(e));
}

Infoga data med ett TableEntity-objekt

Det enklaste sättet att lägga till data i en tabell är att använda ett TableEntity-objekt. I det här exemplet mappas data från ett indatamodellobjekt till ett TableEntity-objekt. Egenskaperna för indataobjektet som representerar väderstationens namn och observationsdatum/tid mappas till egenskaperna PartitionKey respektive RowKey, som tillsammans utgör en unik nyckel för raden i tabellen. Sedan mappas de ytterligare egenskaperna för indatamodellobjektet till ordlisteegenskaper i TableEntity-objektet. Slutligen används metoden AddEntity i TableClient-objektet för att infoga data i tabellen.

Ändra klassen InsertTableEntity i exempelprogrammet så att den innehåller följande kod.

public void InsertTableEntity(WeatherInputModel model)
{
    TableEntity entity = new TableEntity();
    entity.PartitionKey = model.StationName;
    entity.RowKey = $"{model.ObservationDate} {model.ObservationTime}";

    // The other values are added like a items to a dictionary
    entity["Temperature"] = model.Temperature;
    entity["Humidity"] = model.Humidity;
    entity["Barometer"] = model.Barometer;
    entity["WindDirection"] = model.WindDirection;
    entity["WindSpeed"] = model.WindSpeed;
    entity["Precipitation"] = model.Precipitation;

    _tableClient.AddEntity(entity);
}

Upsert-data med ett TableEntity-objekt

Om du försöker infoga en rad i en tabell med en kombination av partitionsnyckel/radnyckel som redan finns i tabellen får du ett felmeddelande. Därför är det ofta bättre att använda UpsertEntity i stället för metoden AddEntity när du lägger till rader i en tabell. Om den angivna kombinationen av partitionsnyckel/radnyckel redan finns i tabellen uppdaterar UpsertEntity-metoden den befintliga raden. Annars läggs raden till i tabellen.

public void UpsertTableEntity(WeatherInputModel model)
{
    TableEntity entity = new TableEntity();
    entity.PartitionKey = model.StationName;
    entity.RowKey = $"{model.ObservationDate} {model.ObservationTime}";

    // The other values are added like a items to a dictionary
    entity["Temperature"] = model.Temperature;
    entity["Humidity"] = model.Humidity;
    entity["Barometer"] = model.Barometer;
    entity["WindDirection"] = model.WindDirection;
    entity["WindSpeed"] = model.WindSpeed;
    entity["Precipitation"] = model.Precipitation;

    _tableClient.UpsertEntity(entity);
}

Infoga eller upsert-data med variabelegenskaper

En av fördelarna med att använda Cosmos DB Tabell-API är att om ett objekt som läses in i en tabell innehåller nya egenskaper läggs dessa egenskaper automatiskt till i tabellen och de värden som lagras i Cosmos DB. Du behöver inte köra DDL-instruktioner som ALTER TABLE för att lägga till kolumner som i en traditionell databas.

Den här modellen ger ditt program flexibilitet när du hanterar datakällor som kan lägga till eller ändra vilka data som behöver samlas in över tid eller när olika indata ger olika data till ditt program. I exempelprogrammet kan vi simulera en väderstation som inte bara skickar grundläggande väderdata, utan även några ytterligare värden. När ett objekt med dessa nya egenskaper lagras i tabellen för första gången läggs motsvarande egenskaper (kolumner) automatiskt till i tabellen.

I exempelprogrammet är klassen ExpandableWeatherObject byggd runt en intern ordlista för att stödja alla egenskaper i objektet. Den här klassen representerar ett typiskt mönster för när ett objekt behöver innehålla en godtycklig uppsättning egenskaper.

public class ExpandableWeatherObject
{
    public Dictionary<string, object> _properties = new Dictionary<string, object>();

    public string StationName { get; set; }

    public string ObservationDate { get; set; }

    public object this[string name]
    {
        get => (ContainsProperty(name)) ? _properties[name] : null;
        set => _properties[name] = value;
    }

    public ICollection<string> PropertyNames => _properties.Keys;

    public int PropertyCount => _properties.Count;

    public bool ContainsProperty(string name) => _properties.ContainsKey(name);
}

Om du vill infoga eller upsertera ett sådant objekt med hjälp av Tabell-API mappar du egenskaperna för det expanderbara objektet till ett TableEntity-objekt och använder metoderna AddEntity eller UpsertEntity på TableClient-objektet efter behov.

public void InsertExpandableData(ExpandableWeatherObject weatherObject)
{
    TableEntity entity = new TableEntity();
    entity.PartitionKey = weatherObject.StationName;
    entity.RowKey = weatherObject.ObservationDate;

    foreach (string propertyName in weatherObject.PropertyNames)
    {
        var value = weatherObject[propertyName];
        entity[propertyName] = value;
    }
    _tableClient.AddEntity(entity);
}

        
public void UpsertExpandableData(ExpandableWeatherObject weatherObject)
{
    TableEntity entity = new TableEntity();
    entity.PartitionKey = weatherObject.StationName;
    entity.RowKey = weatherObject.ObservationDate;

    foreach (string propertyName in weatherObject.PropertyNames)
    {
        var value = weatherObject[propertyName];
        entity[propertyName] = value;
    }
    _tableClient.UpsertEntity(entity);
}

Uppdatera en entitet

Entiteter kan uppdateras genom att anropa metoden UpdateEntity i TableClient-objektet. Eftersom en entitet (rad) som lagras med hjälp av Tabell-API kan innehålla valfri godtycklig uppsättning egenskaper, är det ofta användbart att skapa ett uppdateringsobjekt baserat på ett Dictionary-objekt som liknar det som diskuterats ExpandableWeatherObject tidigare. I det här fallet är den enda skillnaden att en egenskap har Etag tillägg som används för samtidighetskontroll under uppdateringar.

public class UpdateWeatherObject
{
    public Dictionary<string, object> _properties = new Dictionary<string, object>();

    public string StationName { get; set; }
    public string ObservationDate { get; set; }
    public string Etag { get; set; }

    public object this[string name]
    {
        get => (ContainsProperty(name)) ? _properties[name] : null;
        set => _properties[name] = value;
    }

    public ICollection<string> PropertyNames => _properties.Keys;

    public int PropertyCount => _properties.Count;

    public bool ContainsProperty(string name) => _properties.ContainsKey(name);
}

I exempelappen skickas det här objektet till UpdateEntity metoden i TableService klassen . Den här metoden läser först in den befintliga entiteten Tabell-API med hjälp av metoden GetEntity på TableClient. Den uppdaterar sedan entitetsobjektet och UpdateEntity använder metoden för att spara uppdateringarna till databasen. Observera att updateEntity-metoden tar objektets aktuella Etag för att försäkra att objektet inte har ändrats sedan det först läses in. Om du vill uppdatera entiteten oavsett kan du skicka ett värde Etag.Any för till UpdateEntity metoden .

public void UpdateEntity(UpdateWeatherObject weatherObject)
{
    string partitionKey = weatherObject.StationName;
    string rowKey = weatherObject.ObservationDate;

    // Use the partition key and row key to get the entity
    TableEntity entity = _tableClient.GetEntity<TableEntity>(partitionKey, rowKey).Value;

    foreach (string propertyName in weatherObject.PropertyNames)
    {
        var value = weatherObject[propertyName];
        entity[propertyName] = value;
    }

    _tableClient.UpdateEntity(entity, new ETag(weatherObject.Etag));
}

Ta bort en entitet

Om du vill ta bort en entitet från en tabell anropar du metoden DeleteEntity i TableClient-objektet med partitionsnyckeln och radnyckeln för objektet.

public void RemoveEntity(string partitionKey, string rowKey)
{
    _tableClient.DeleteEntity(partitionKey, rowKey);           
}

7 – Kör koden

Kör exempelprogrammet för att interagera med Cosmos DB Tabell-API. Första gången du kör programmet finns det inga data eftersom tabellen är tom. Använd någon av knapparna längst upp i programmet för att lägga till data i tabellen.

Om du väljer knappen Infoga med tabellentitet öppnas en dialogruta där du kan infoga eller upserta en ny rad med hjälp av ett TableEntity -objekt.

Om du väljer knappen Infoga med expanderbara data visas en dialogruta där du kan infoga ett objekt med anpassade egenskaper, som visar hur Cosmos DB Tabell-API automatiskt lägger till egenskaper (kolumner) i tabellen när det behövs. Använd knappen Lägg till anpassat fält för att lägga till en eller flera nya egenskaper och demonstrera den här funktionen.

Använd knappen Infoga exempeldata för att läsa in exempeldata i Cosmos DB tabell.

Välj objektet Filterresultat på den översta menyn för att gå till sidan Filterresultat. På den här sidan fyller du i filtervillkoren för att demonstrera hur en filtersats kan byggas och skickas till Cosmos DB Tabell-API.

Rensa resurser

När du är klar med exempelprogrammet bör du ta bort alla Azure-resurser som är relaterade till den här artikeln från ditt Azure-konto. Du kan göra detta genom att ta bort resursgruppen.

• Azure Portal
• Azure CLI
• Azure PowerShell

En resursgrupp kan tas bort med hjälp Azure Portal genom att göra följande.

Instruktioner	Skärmbild
Gå till resursgruppen genom att skriva namnet på resursgruppen i sökfältet. På fliken Resursgrupper väljer du sedan namnet på resursgruppen.
Välj Ta bort resursgrupp i verktygsfältet längst upp på resursgruppsidan.
En dialogruta visas till höger på skärmen där du uppmanas att bekräfta borttagningen av resursgruppen. Skriv det fullständiga namnet på resursgruppen i textrutan för att bekräfta borttagningen enligt anvisningarna. Välj knappen Ta bort längst ned på sidan.

Nästa steg

I den här snabbstarten har du fått lära dig att skapa ett Azure Cosmos DB-konto, skapa en tabell med datautforskaren och att köra en app. Du kan nu ställa frågor mot dina data med tabell-API:t.