Démarrage rapide : Créer une application API pour Table avec le SDK Java et Azure Cosmos DB
S’APPLIQUE À : 
Table
Ce guide de démarrage rapide montre comment accéder à l’API Table Azure Cosmos DB à partir d’une application Java. L’API Tables d’Azure Cosmos DB est un magasin de données sans schéma qui permet aux applications de stocker des données NoSQL structurées dans le cloud. Étant donné que les données sont stockées dans une conception sans schéma, de nouvelles propriétés (colonnes) sont automatiquement ajoutées à la table lorsqu’un objet doté d’un nouvel attribut est ajouté à la table.
Les applications Java peuvent accéder à l’API Tables Azure Cosmos DB à l’aide de la bibliothèque de client azure-data-tables.
Prérequis
L’exemple d’application est écrit en Spring Boot 2.6.4. Vous pouvez utiliser Visual Studio Code ou IntelliJ IDEA comme environnement de développement intégré (IDE).
Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Exemple d’application
L’exemple d’application de ce tutoriel peut être cloné ou téléchargé à partir du dépôt https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-java. Une application de démarrage et une application terminée sont incluses dans l’exemple de dépôt.
git clone https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-java
L’exemple d’application utilise des données météorologiques comme modèle pour illustrer les fonctionnalités de l’API Tables. Les objets représentant les observations météorologiques sont stockés et récupérés à l’aide de l’API Table, entre autres le stockage d’objets avec des propriétés supplémentaires pour mettre en évidence les fonctionnalités sans schéma de l’API Tables.
1 – Créer un compte Azure Cosmos DB
Vous devez d’abord créer un compte API Tables Azure Cosmos DB qui contiendra la ou les tables utilisées dans votre application. Pour cela, utilisez le portail Azure, Azure CLI ou Azure PowerShell.
Connectez-vous au portail Azure et suivez les étapes ci-dessous pour créer un compte Cosmos DB.
| Instructions | Capture d'écran |
|---|---|
Dans le portail Azure :
|
|
| Dans la page Azure Cosmos DB, sélectionnez +Créer. | 
|
| Sur la page Sélectionner l'option API, choisissez l'option Azure Table. | 
|
Dans la page Créer un compte Azure Cosmos DB : tableau Azure, remplissez le formulaire comme suit.
|
|
2 – Créer une table
Ensuite, vous devez créer une table dans votre compte Azure Cosmos DB, qui servira à votre application. Contrairement à une base de données classique, il vous suffit de spécifier le nom de la table, et non les propriétés (colonnes) de la table. À mesure que les données sont chargées dans votre table, les propriétés (colonnes) sont automatiquement créées en fonction des besoins.
Dans le portail Azure, effectuez les étapes suivantes pour créer une table dans votre compte Azure Cosmos DB.
| Instructions | Capture d'écran |
|---|---|
| Dans le portail Azure, accédez à la page Vue d’ensemble du compte Azure Cosmos DB. Vous pouvez accéder à la page Vue d’ensemble de votre compte Azure Cosmos DB en tapant son nom (cosmos-msdocs-tables-sdk-demo-XYZ) dans la barre de recherche supérieure et en regardant sous l’en-tête des ressources. Sélectionnez le nom de votre compte Azure Cosmos DB pour accéder à la page Vue d’ensemble correspondante. | 
|
| Dans la page Vue d’ensemble, sélectionnez + Ajouter une table. La boîte de dialogue Nouveau tableau sort du côté droit de la page. | 
|
Dans la boîte de dialogue Nouvelle table, remplissez le formulaire comme ci-dessous.
|
|
3 - Obtenir la chaîne de connexion Azure Cosmos DB
Pour accéder à une de vos tables dans Azure Cosmos DB, votre application a besoin de la chaîne de connexion de la table pour le compte de stockage CosmosDB. La chaîne de connexion peut être récupérée à l’aide du portail Azure, de l’interface Azure CLI ou d’Azure PowerShell.
| Instructions | Capture d'écran |
|---|---|
| Sur le côté gauche de la page du compte Azure Cosmos DB, localisez l'élément de menu nommé Chaîne de connexion sous l'en-tête Paramètres et sélectionnez-le. Vous êtes alors dirigé vers une page où récupérer la chaîne de connexion du compte de stockage. | 
|
| Copiez la valeur PRIMARY CONNECTION STRING à utiliser dans votre application. | 
|
La chaîne de connexion de votre compte Azure Cosmos DB est considérée comme un secret d’application, et doit être protégée comme tout autre secret ou mot de passe d’application. Cet exemple utilise le fichier POM pour stocker la chaîne de connexion pendant le développement et la mettre à disposition de l’application.
<profiles>
<profile>
<id>local</id>
<properties>
<azure.tables.connection.string>
<![CDATA[YOUR-DATA-TABLES-SERVICE-CONNECTION-STRING]]>
</azure.tables.connection.string>
<azure.tables.tableName>WeatherData</azure.tables.tableName>
</properties>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
</profiles>
4 - Inclure le package azure-data-tables
Pour accéder à l’API Tables Azure Cosmos DB à partir d’une application Java, incluez le package azure-data-tables.
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-data-tables</artifactId>
<version>12.2.1</version>
</dependency>
5 - Configurer le client Table dans TableServiceConfig.java
Le kit SDK Azure communique avec Azure à l’aide d’objets de client pour exécuter différentes opérations sur Azure. L’objet TableClient est l’objet utilisé pour communiquer avec l’API Tables Azure Cosmos DB.
En général, une application crée un seul objet TableClient par table à utiliser dans toute l’application. Il est recommandé d’indiquer qu’une méthode produit un bean d’objet TableClient à gérer par le conteneur Spring et en tant que singleton pour y parvenir.
Dans le fichier TableServiceConfig.java de l’application, modifiez la méthode tableClientConfiguration() pour qu’elle corresponde à l’extrait de code suivant :
@Configuration
public class TableServiceConfiguration {
private static String TABLE_NAME;
private static String CONNECTION_STRING;
@Value("${azure.tables.connection.string}")
public void setConnectionStringStatic(String connectionString) {
TableServiceConfiguration.CONNECTION_STRING = connectionString;
}
@Value("${azure.tables.tableName}")
public void setTableNameStatic(String tableName) {
TableServiceConfiguration.TABLE_NAME = tableName;
}
@Bean
public TableClient tableClientConfiguration() {
return new TableClientBuilder()
.connectionString(CONNECTION_STRING)
.tableName(TABLE_NAME)
.buildClient();
}
}
Vous devez également ajouter l’instruction suivante en haut du fichier TableServiceConfig.java.
import com.azure.data.tables.TableClient;
import com.azure.data.tables.TableClientBuilder;
6 – Mettre en œuvre les opérations de table Azure Cosmos DB
Toutes les opérations de table Azure Cosmos DB pour l’exemple d’application sont implémentées dans la classe TablesServiceImpl située dans le répertoire Services. Vous devez importer le package du kit de développement logiciel (SDK) com.azure.data.tables.
import com.azure.data.tables.TableClient;
import com.azure.data.tables.models.ListEntitiesOptions;
import com.azure.data.tables.models.TableEntity;
import com.azure.data.tables.models.TableTransactionAction;
import com.azure.data.tables.models.TableTransactionActionType;
Au début de la classe TableServiceImpl, ajoutez une variable membre pour l’objet TableClient, et un constructeur pour permettre l’injection de l’objet TableClient dans la classe.
@Autowired
private TableClient tableClient;
Obtenir les lignes d’une table
La classe TableClient contient une méthode nommée listEntities qui vous permet de sélectionner des lignes de la table. Dans cet exemple, étant donné qu’aucun paramètre n’est passé à la méthode, toutes les lignes sont sélectionnées dans la table.
La méthode accepte également un paramètre générique de type TableEntity qui spécifie que les données de la classe de modèle seront renvoyées en tant que telles. En l’occurrence, la classe intégrée TableEntity est utilisée, ce qui signifie que la méthode listEntities retournera une collection PagedIterable<TableEntity> comme résultats.
public List<WeatherDataModel> retrieveAllEntities() {
List<WeatherDataModel> modelList = tableClient.listEntities().stream()
.map(WeatherDataUtils::mapTableEntityToWeatherDataModel)
.collect(Collectors.toList());
return Collections.unmodifiableList(WeatherDataUtils.filledValue(modelList));
}
La classe TableEntity définie dans le package com.azure.data.tables.models dispose de propriétés pour la valeur de la clé de partition et celle de la clé de ligne dans la table. Ensemble, ces deux valeurs représentent une clé unique pour la ligne de la table. Dans cet exemple d’application, le nom de la station météo (ville) est stocké dans la clé de partition, et la date/l’heure de l’observation l’est dans la clé de ligne. Toutes les autres propriétés (température, humidité, vitesse du vent) sont stockées dans un dictionnaire, dans l’objet TableEntity.
Il est courant de mapper un objet TableEntity à un objet de votre propre définition. L’exemple d’application définit une classe WeatherDataModel dans le répertoire Models à cet effet. Cette classe possède des propriétés pour le nom de la station et pour la date d’observation auxquels la clé de partition et la clé de ligne sont mappés, fournissant ainsi des noms de propriétés plus significatifs pour ces valeurs. Elle utilise ensuite un dictionnaire pour stocker toutes les autres propriétés sur l’objet. Il s’agit d’un schéma courant lors de l’utilisation du stockage de tables, car une ligne peut comporter un certain nombre de propriétés arbitraires, et nous voulons que nos objets de modèle puissent les capturer tous. Cette classe contient également des méthodes permettant de lister les propriétés de la classe.
public class WeatherDataModel {
public WeatherDataModel(String stationName, String observationDate, OffsetDateTime timestamp, String etag) {
this.stationName = stationName;
this.observationDate = observationDate;
this.timestamp = timestamp;
this.etag = etag;
}
private String stationName;
private String observationDate;
private OffsetDateTime timestamp;
private String etag;
private Map<String, Object> propertyMap = new HashMap<String, Object>();
public String getStationName() {
return stationName;
}
public void setStationName(String stationName) {
this.stationName = stationName;
}
public String getObservationDate() {
return observationDate;
}
public void setObservationDate(String observationDate) {
this.observationDate = observationDate;
}
public OffsetDateTime getTimestamp() {
return timestamp;
}
public void setTimestamp(OffsetDateTime timestamp) {
this.timestamp = timestamp;
}
public String getEtag() {
return etag;
}
public void setEtag(String etag) {
this.etag = etag;
}
public Map<String, Object> getPropertyMap() {
return propertyMap;
}
public void setPropertyMap(Map<String, Object> propertyMap) {
this.propertyMap = propertyMap;
}
}
La méthode mapTableEntityToWeatherDataModel est utilisée pour mapper un objet TableEntity à un objet WeatherDataModel. La méthode mapTableEntityToWeatherDataModel mappe directement les propriétés PartitionKey, RowKey, Timestamp et Etag, puis utilise properties.keySet pour effectuer une itération sur les autres propriétés de l’objet TableEntity et les mapper à l’objet WeatherDataModel, sans les propriétés qui ont déjà été mappées directement.
Modifiez le code dans la méthode mapTableEntityToWeatherDataModel pour qu’il corresponde au bloc de code suivant.
public static WeatherDataModel mapTableEntityToWeatherDataModel(TableEntity entity) {
WeatherDataModel observation = new WeatherDataModel(
entity.getPartitionKey(), entity.getRowKey(),
entity.getTimestamp(), entity.getETag());
rearrangeEntityProperties(observation.getPropertyMap(), entity.getProperties());
return observation;
}
private static void rearrangeEntityProperties(Map<String, Object> target, Map<String, Object> source) {
Constants.DEFAULT_LIST_OF_KEYS.forEach(key -> {
if (source.containsKey(key)) {
target.put(key, source.get(key));
}
});
source.keySet().forEach(key -> {
if (Constants.DEFAULT_LIST_OF_KEYS.parallelStream().noneMatch(defaultKey -> defaultKey.equals(key))
&& Constants.EXCLUDE_TABLE_ENTITY_KEYS.parallelStream().noneMatch(defaultKey -> defaultKey.equals(key))) {
target.put(key, source.get(key));
}
});
}
Filtrer les lignes retournées à partir d’une table
Pour filtrer les lignes renvoyées à partir d’une table, vous pouvez transmettre une chaîne de filtre de style OData à la méthode listEntities. Par exemple, si vous souhaitez obtenir tous les relevés météorologiques pour Chicago entre le 1er juillet 2021 et le 2 juillet 2021 (inclus), vous devez passer la chaîne de filtre suivante.
PartitionKey eq 'Chicago' and RowKey ge '2021-07-01 12:00 AM' and RowKey le '2021-07-02 12:00 AM'
Vous pouvez afficher tous les opérateurs de filtre OData sur le site web OData à la section Filter System Query Option (Filtrer dans l’option de requête système).
Dans l’exemple d’application, l’objet FilterResultsInputModel est conçu pour capturer tous les critères de filtre fournis par l’utilisateur.
public class FilterResultsInputModel implements Serializable {
private String partitionKey;
private String rowKeyDateStart;
private String rowKeyTimeStart;
private String rowKeyDateEnd;
private String rowKeyTimeEnd;
private Double minTemperature;
private Double maxTemperature;
private Double minPrecipitation;
private Double maxPrecipitation;
public String getPartitionKey() {
return partitionKey;
}
public void setPartitionKey(String partitionKey) {
this.partitionKey = partitionKey;
}
public String getRowKeyDateStart() {
return rowKeyDateStart;
}
public void setRowKeyDateStart(String rowKeyDateStart) {
this.rowKeyDateStart = rowKeyDateStart;
}
public String getRowKeyTimeStart() {
return rowKeyTimeStart;
}
public void setRowKeyTimeStart(String rowKeyTimeStart) {
this.rowKeyTimeStart = rowKeyTimeStart;
}
public String getRowKeyDateEnd() {
return rowKeyDateEnd;
}
public void setRowKeyDateEnd(String rowKeyDateEnd) {
this.rowKeyDateEnd = rowKeyDateEnd;
}
public String getRowKeyTimeEnd() {
return rowKeyTimeEnd;
}
public void setRowKeyTimeEnd(String rowKeyTimeEnd) {
this.rowKeyTimeEnd = rowKeyTimeEnd;
}
public Double getMinTemperature() {
return minTemperature;
}
public void setMinTemperature(Double minTemperature) {
this.minTemperature = minTemperature;
}
public Double getMaxTemperature() {
return maxTemperature;
}
public void setMaxTemperature(Double maxTemperature) {
this.maxTemperature = maxTemperature;
}
public Double getMinPrecipitation() {
return minPrecipitation;
}
public void setMinPrecipitation(Double minPrecipitation) {
this.minPrecipitation = minPrecipitation;
}
public Double getMaxPrecipitation() {
return maxPrecipitation;
}
public void setMaxPrecipitation(Double maxPrecipitation) {
this.maxPrecipitation = maxPrecipitation;
}
}
Lorsque cet objet est passé à la méthode retrieveEntitiesByFilter dans la classe TableServiceImpl, il crée une chaîne de filtre pour chaque valeur de propriété qui n’est pas Null. Il crée ensuite une chaîne de filtre combinée en joignant toutes les valeurs avec une clause « and ». Cette chaîne de filtre combinée est transmise à la méthode listEntities sur l’objet TableClient, et seules les lignes correspondant à la chaîne de filtre sont renvoyées. Vous pouvez utiliser une méthode similaire dans votre code pour élaborer des chaînes de filtre appropriées en fonction des besoins de votre application.
public List<WeatherDataModel> retrieveEntitiesByFilter(FilterResultsInputModel model) {
List<String> filters = new ArrayList<>();
if (!StringUtils.isEmptyOrWhitespace(model.getPartitionKey())) {
filters.add(String.format("PartitionKey eq '%s'", model.getPartitionKey()));
}
if (!StringUtils.isEmptyOrWhitespace(model.getRowKeyDateStart())
&& !StringUtils.isEmptyOrWhitespace(model.getRowKeyTimeStart())) {
filters.add(String.format("RowKey ge '%s %s'", model.getRowKeyDateStart(), model.getRowKeyTimeStart()));
}
if (!StringUtils.isEmptyOrWhitespace(model.getRowKeyDateEnd())
&& !StringUtils.isEmptyOrWhitespace(model.getRowKeyTimeEnd())) {
filters.add(String.format("RowKey le '%s %s'", model.getRowKeyDateEnd(), model.getRowKeyTimeEnd()));
}
if (model.getMinTemperature() != null) {
filters.add(String.format("Temperature ge %f", model.getMinTemperature()));
}
if (model.getMaxTemperature() != null) {
filters.add(String.format("Temperature le %f", model.getMaxTemperature()));
}
if (model.getMinPrecipitation() != null) {
filters.add(String.format("Precipitation ge %f", model.getMinPrecipitation()));
}
if (model.getMaxPrecipitation() != null) {
filters.add(String.format("Precipitation le %f", model.getMaxPrecipitation()));
}
List<WeatherDataModel> modelList = tableClient.listEntities(new ListEntitiesOptions()
.setFilter(String.join(" and ", filters)), null, null).stream()
.map(WeatherDataUtils::mapTableEntityToWeatherDataModel)
.collect(Collectors.toList());
return Collections.unmodifiableList(WeatherDataUtils.filledValue(modelList));
}
Insérer les données à l’aide d’un objet TableEntity
Le moyen le plus simple d’ajouter des données à une table consiste à utiliser un objet TableEntity. Dans cet exemple, les données sont mappées à partir d’un objet de modèle d’entrée sur un objet TableEntity. Les propriétés de l’objet d’entrée représentant le nom de la station météo et la date/l’heure de l’observation sont respectivement mappées aux propriétés PartitionKey et RowKey, formant ensemble une clé unique pour la ligne de la table. Ensuite, les propriétés supplémentaires de l’objet de modèle d’entrée sont mappées aux propriétés du dictionnaire de l’objet TableClient. Enfin, la méthode createEntity de l’objet TableClient est utilisée pour insérer les données dans la table.
Modifiez la classe insertEntity de l’exemple d’application pour qu’elle contienne le code suivant.
public void insertEntity(WeatherInputModel model) {
tableClient.createEntity(WeatherDataUtils.createTableEntity(model));
}
Faire un upsert des données à l’aide d’un objet TableEntity
Si vous essayez d’insérer une ligne dans une table avec une combinaison clé de partition/clé de ligne qui existe déjà dans cette table, vous recevez une erreur. Ainsi, il est souvent préférable d’utiliser upsertEntity plutôt que la méthode insertEntity lors de l’ajout de lignes à une table. Si la combinaison clé de partition/clé de ligne déterminée existe déjà dans la table, la méthode upsertEntity met à jour la ligne existante. Dans le cas contraire, la ligne est ajoutée à la table.
public void upsertEntity(WeatherInputModel model) {
tableClient.upsertEntity(WeatherDataUtils.createTableEntity(model));
}
Insérer ou faire un upsert des données avec des propriétés de variable
Un des avantages de l’utilisation de l’API Tables Azure Cosmos DB réside dans le fait que si un objet chargé dans une table contient de nouvelles propriétés, celles-ci sont automatiquement ajoutées à la table et les valeurs sont stockées dans Cosmos DB. Il n’est pas nécessaire d’exécuter des instructions DDL, telles que ALTER TABLE, pour ajouter des colonnes, comme c’est le cas dans une base de données classique.
Ce modèle offre de la flexibilité à votre application lors de la gestion de sources de données pouvant ajouter ou modifier des éléments nécessaires aux données pour leur capture au fil du temps, ou lorsque plusieurs entrées fournissent différentes données à votre application. Dans l’exemple d’application, nous pouvons simuler une station météorologique qui envoie non seulement les données météorologiques de base, mais également quelques valeurs supplémentaires. Lorsqu’un objet doté de ces nouvelles propriétés est stocké dans la table pour la première fois, les propriétés correspondantes (colonnes) sont automatiquement ajoutées à la table.
Dans l’exemple d’application, la classe ExpandableWeatherObject est élaborée autour d’un dictionnaire interne afin de prendre en charge n’importe quel jeu de propriétés sur l’objet. Cette classe représente un schéma classique lorsqu’un objet doit contenir un ensemble arbitraire de propriétés.
public class ExpandableWeatherObject {
private String stationName;
private String observationDate;
private Map<String, Object> propertyMap = new HashMap<String, Object>();
public String getStationName() {
return stationName;
}
public void setStationName(String stationName) {
this.stationName = stationName;
}
public String getObservationDate() {
return observationDate;
}
public void setObservationDate(String observationDate) {
this.observationDate = observationDate;
}
public Map<String, Object> getPropertyMap() {
return propertyMap;
}
public void setPropertyMap(Map<String, Object> propertyMap) {
this.propertyMap = propertyMap;
}
public boolean containsProperty(String key) {
return this.propertyMap.containsKey(key);
}
public Object getPropertyValue(String key) {
return containsProperty(key) ? this.propertyMap.get(key) : null;
}
public void putProperty(String key, Object value) {
this.propertyMap.put(key, value);
}
public List<String> getPropertyKeys() {
List<String> list = Collections.synchronizedList(new ArrayList<String>());
Iterator<String> iterators = this.propertyMap.keySet().iterator();
while (iterators.hasNext()) {
list.add(iterators.next());
}
return Collections.unmodifiableList(list);
}
public Integer getPropertyCount() {
return this.propertyMap.size();
}
}
Pour insérer un tel objet ou en faire un upsert à l’aide de l’API Table, mappez les propriétés de l’objet extensible dans un objet TableEntity et utilisez les méthodes createEntity ou upsertEntity sur l’objet TableClient, si nécessaire.
public void insertExpandableEntity(ExpandableWeatherObject model) {
tableClient.createEntity(WeatherDataUtils.createTableEntity(model));
}
public void upsertExpandableEntity(ExpandableWeatherObject model) {
tableClient.upsertEntity(WeatherDataUtils.createTableEntity(model));
}
Mise à jour d'une entité
Les entités peuvent être mises à jour en appelant la méthode updateEntity sur l’objet TableClient. Étant donné qu’une entité (ligne) stockée à l’aide de l’API Tables peut contenir n’importe quel ensemble arbitraire de propriétés, il est souvent utile de créer un objet de mise à jour basé sur un objet dictionnaire similaire au ExpandableWeatherObject abordé précédemment. Dans ce cas, la seule différence est l’ajout d’une propriété etag, qui est utilisée pour le contrôle d’accès concurrentiel lors des mises à jour.
public class UpdateWeatherObject {
private String stationName;
private String observationDate;
private String etag;
private Map<String, Object> propertyMap = new HashMap<String, Object>();
public String getStationName() {
return stationName;
}
public void setStationName(String stationName) {
this.stationName = stationName;
}
public String getObservationDate() {
return observationDate;
}
public void setObservationDate(String observationDate) {
this.observationDate = observationDate;
}
public String getEtag() {
return etag;
}
public void setEtag(String etag) {
this.etag = etag;
}
public Map<String, Object> getPropertyMap() {
return propertyMap;
}
public void setPropertyMap(Map<String, Object> propertyMap) {
this.propertyMap = propertyMap;
}
}
Dans l’exemple d’application, cet objet est passé à la méthode updateEntity dans la classe TableServiceImpl. Cette méthode charge d’abord l’entité existante à partir de l’API Tables à l’aide de la méthode getEntity sur TableClient. Elle met ensuite à jour cet objet d’entité, et utilise la méthode updateEntity pour enregistrer les mises à jour dans la base de données. Remarquez de quelle façon la méthode updateEntity prend l’étiquette d’entité actuelle de l’objet pour s’assurer que celui-ci n’a pas changé depuis son chargement initial. Si vous souhaitez mettre à jour l’entité indépendamment, vous pouvez passer une valeur de etag à la méthode updateEntity.
public void updateEntity(UpdateWeatherObject model) {
TableEntity tableEntity = tableClient.getEntity(model.getStationName(), model.getObservationDate());
Map<String, Object> propertiesMap = model.getPropertyMap();
propertiesMap.keySet().forEach(key -> tableEntity.getProperties().put(key, propertiesMap.get(key)));
tableClient.updateEntity(tableEntity);
}
Supprimer une entité
Pour supprimer une entité d’une table, appelez la méthode deleteEntity sur l’objet TableClient avec la clé de partition et la clé de ligne de l’objet.
public void deleteEntity(WeatherInputModel model) {
tableClient.deleteEntity(model.getStationName(),
WeatherDataUtils.formatRowKey(model.getObservationDate(), model.getObservationTime()));
}
7 – Exécuter le code
Exécutez l’exemple d’application pour interagir avec l’API Tables Azure Cosmos DB. La première fois que vous exécuterez l’application, il n’y aura aucune donnée affichée, car la table est vide. Utilisez l’un des boutons situés en haut de l’application pour ajouter des données à la table.
En sélectionnant le bouton Insert using Table Entity (Insérer à l’aide d’une entité de table), vous ouvrez une boîte de dialogue dans laquelle vous pouvez insérer une nouvelle ligne ou en faire un upsert en utilisant un objet TableEntity.
La sélection du bouton Insert using Expandable Data (Insérer à l’aide de données extensibles) affiche une boîte de dialogue qui vous permet d’insérer un objet avec des propriétés personnalisées, illustrant ainsi comment l’API Tables Azure Cosmos DB ajoute automatiquement des propriétés (colonnes) à la table, si nécessaire. Utilisez le bouton Add Custom Field (Ajouter un champ personnalisé) pour ajouter une ou plusieurs nouvelles propriétés et illustrer cette fonctionnalité.
Utilisez le bouton Insert Sample Data (Insérer des exemples de données) pour charger des exemples de données dans votre table Cosmos DB.
Sélectionnez l’élément Filter Results (Filtrer les résultats) dans le menu supérieur pour atteindre la page de filtre des résultats. Sur cette page, renseignez les critères de filtre pour démontrer comment une clause de filtre peut être générée et transmise à l’API Tables Azure Cosmos DB.
Nettoyer les ressources
Lorsque vous n’avez plus besoin de l’exemple d’application, supprimez de votre compte Azure toutes les ressources Azure associées à cet article. Vous effectuez cette opération en supprimant le groupe de ressources.
Il est possible de supprimer un groupe de ressources dans le portail Azure en procédant comme indiqué ici.
| Instructions | Capture d'écran |
|---|---|
| Pour accéder au groupe de ressources, dans la barre de recherche, tapez le nom du groupe de ressources. Ensuite, sous l’onglet Groupes de ressources, sélectionnez le nom du groupe de ressources. | 
|
| Sélectionnez Supprimer un groupe de ressources dans la barre d’outils en haut de la page Groupes de ressources. | 
|
Une boîte de dialogue s’affiche à droite de l’écran vous demandant de confirmer la suppression du groupe de ressources.
|
|
Étapes suivantes
Dans ce guide de démarrage rapide, vous avez appris à créer un compte Azure Cosmos DB, à créer une table à l’aide de l’Explorateur de données, et à exécuter une application. Maintenant, vous pouvez interroger vos données à l’aide de l’API pour Table.