Ejercicio: Creación de recursos mediante el SDK de Microsoft .NET v3

15 minutos

En este ejercicio se crea una aplicación de consola para realizar las siguientes operaciones en Azure Cosmos DB:

Conexión a una cuenta de Azure Cosmos DB
Crear una base de datos
Crear un contenedor

Prerrequisitos

Una cuenta de Azure con una suscripción activa. Si aún no tiene una, puede solicitar una prueba gratuita en https://azure.com/free.
Visual Studio Code en una de las plataformas admitidas.
.NET 8 es el marco de destino para el ejercicio.
La extensión de C# para Visual Studio Code.
Las herramientas más recientes de la CLI de Azure instaladas localmente.

Instalación

Realice las siguientes acciones para preparar Azure y su entorno local para el ejercicio.

Conexión con Azure

Inicie Visual Studio Code y abra una ventana de terminal. Para ello, seleccione Terminal en la barra de aplicaciones superior y elija Nuevo terminal.
Inicie sesión en Azure con el siguiente comando. Se debería abrir una ventana del explorador que le permite elegir con qué cuenta iniciar sesión.
```
az login
```

Creación de recursos en Azure

Cree un grupo de recursos para los recursos necesarios para este ejercicio. Reemplace <myLocation> por una región cercana.
```
az group create --location <myLocation> --name az204-cosmos-rg
```
Cree la cuenta de Azure Cosmos DB. Reemplace <myCosmosDBacct> por un nombre único para identificar su cuenta de Azure Cosmos DB. El nombre solo puede contener letras minúsculas, números y el carácter de guion (-). Debe tener una longitud de entre 3 y 31 caracteres. Este comando tarda unos minutos en completarse.
```
az cosmosdb create --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```
Registre documentEndpoint, que se muestra en la respuesta JSON; para usarlo más adelante en el ejercicio.
Recupere la clave principal de la cuenta mediante el comando siguiente. Registre primaryMasterKey de los resultados del comando para usarlo en el código.
```
# Retrieve the primary key
az cosmosdb keys list --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```

Configuración de la aplicación de consola

Ahora que los recursos necesarios están implementados en Azure, el siguiente paso consiste en configurar la aplicación de consola con la misma ventana de terminal de Visual Studio Code.

Cree una carpeta para el proyecto y vaya a la carpeta.
```
md az204-cosmos
cd az204-cosmos
```
Cree la aplicación de consola de .NET.
```
dotnet new console
```
Abra la carpeta actual en Visual Studio Code con el comando siguiente. La opción -r abre la carpeta sin iniciar una nueva ventana de Visual Studio Code.
```
code . -r
```
Haga clic en el archivo Program.cs en el panel del Explorador para abrir el archivo en el editor.

Compilación de la aplicación de consola

Es el momento de empezar a agregar los paquetes y el código al proyecto.

Adición de paquetes e instrucciones using

Abra el terminal en Visual Studio Code y use el comando siguiente para agregar el paquete Microsoft.Azure.Cosmos al proyecto.
```
dotnet add package Microsoft.Azure.Cosmos
```
Elimine cualquier código existente en el archivo Program.cs y agregue la instrucción using Microsoft.Azure.Cosmos.
```
using Microsoft.Azure.Cosmos;
```

Adición de código para conectarse a una cuenta de Azure Cosmos DB

Agregue el fragmento de código que se encuentra a continuación después de la instrucción using. El fragmento de código agrega constantes y variables a la clase y agrega alguna comprobación de errores. Asegúrese de reemplazar los valores de marcadores de posición por EndpointUri y PrimaryKey siguiendo las instrucciones en los comentarios del código.

public class Program
{
    // Replace <documentEndpoint> with the information created earlier
    private static readonly string EndpointUri = "<documentEndpoint>";

    // Set variable to the Primary Key from earlier.
    private static readonly string PrimaryKey = "<your primary key>";

    // The Cosmos client instance
    private CosmosClient cosmosClient;

    // The database we will create
    private Database database;

    // The container we will create.
    private Container container;

    // The names of the database and container we will create
    private string databaseId = "az204Database";
    private string containerId = "az204Container";

    public static async Task Main(string[] args)
    {
        try
        {
            Console.WriteLine("Beginning operations...\n");
            Program p = new Program();
            await p.CosmosAsync();

        }
        catch (CosmosException de)
        {
            Exception baseException = de.GetBaseException();
            Console.WriteLine("{0} error occurred: {1}", de.StatusCode, de);
        }
        catch (Exception e)
        {
            Console.WriteLine("Error: {0}", e);
        }
        finally
        {
            Console.WriteLine("End of program, press any key to exit.");
            Console.ReadKey();
        }
    }
    //The sample code below gets added below this line
}

Debajo del método Main, agregue una nueva tarea asincrónica denominada CosmosAsync, que crea una instancia de nuestro nuevo CosmosClient y agrega código para llamar a los métodos que agregará más adelante para crear una base de datos y un contenedor.

public async Task CosmosAsync()
{
    // Create a new instance of the Cosmos Client
    this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);

    // Runs the CreateDatabaseAsync method
    await this.CreateDatabaseAsync();

    // Run the CreateContainerAsync method
    await this.CreateContainerAsync();
}

Crear una base de datos

Copie y pegue el método CreateDatabaseAsync después del método CosmosAsync. CreateDatabaseAsync crea una base de datos con el identificador az204Database si aún no existe.

private async Task CreateDatabaseAsync()
{
    // Create a new database using the cosmosClient
    this.database = await this.cosmosClient.CreateDatabaseIfNotExistsAsync(databaseId);
    Console.WriteLine("Created Database: {0}\n", this.database.Id);
}

Crear un contenedor

Copie y pegue el método CreateContainerAsync bajo el método CreateDatabaseAsync.

private async Task CreateContainerAsync()
{
    // Create a new container
    this.container = await this.database.CreateContainerIfNotExistsAsync(containerId, "/LastName");
    Console.WriteLine("Created Container: {0}\n", this.container.Id);
}

Ejecución de la aplicación

Guarde el trabajo y, en un terminal de Visual Studio Code, ejecute el comando dotnet build para comprobar si hay algún error. Si la compilación se realiza correctamente, ejecute el comando dotnet run. La consola muestra los mensajes siguientes.
```
Beginning operations...

Created Database: az204Database

Created Container: az204Container

End of program, press any key to exit.
```
Para comprobar los resultados, abra el portal de Azure, vaya al recurso de Azure Cosmos DB y use el Explorador de datos para ver la base de datos y el contenedor.

Limpieza de los recursos de Azure

Ahora puede eliminar de forma segura el grupo de recursos az204-cosmos-rg de su cuenta mediante la ejecución del comando siguiente.

az group delete --name az204-cosmos-rg --no-wait