Exercício: Criar recursos usando o Microsoft .NET SDK v3

15 minutos

Neste exercício, você cria um aplicativo de console para executar as seguintes operações no Azure Cosmos DB:

Conectar-se a uma conta do Azure Cosmos DB
Criar uma base de dados
Criar um contentor

Pré-requisitos

Uma conta do Azure com uma subscrição ativa. Se ainda não tiver uma, pode inscrever-se numa avaliação gratuita em https://azure.com/free.
Visual Studio Code numa das plataformas suportadas.
O .NET 8 é a estrutura de destino para o exercício.
A extensão C# para o Visual Studio Code.
As ferramentas mais recentes da CLI do Azure, instaladas localmente.

Configuração

Execute as seguintes ações para preparar o Azure e seu ambiente local para o exercício.

Conectando-se ao Azure

Inicie o Visual Studio Code e abra uma janela de terminal selecionando Terminal na barra de aplicativos superior e, em seguida, escolhendo Novo Terminal.
Entre no Azure usando o comando a seguir. Uma janela do navegador deve ser aberta permitindo que você escolha com qual conta entrar.
```
az login
```

Criar recursos no Azure

Crie um grupo de recursos para os recursos necessários para este exercício. Substitua <myLocation> por uma região perto de você.
```
az group create --location <myLocation> --name az204-cosmos-rg
```
Crie a conta do Azure Cosmos DB. Substitua <myCosmosDBacct> por um nome exclusivo para identificar sua conta do Azure Cosmos DB. O nome só pode conter letras minúsculas, números e o caráter de hífen (-). Tem de ter entre 3 e 31 carateres. Este comando leva alguns minutos para ser concluído.
```
az cosmosdb create --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```
Registre o documentEndpoint mostrado na resposta JSON para uso posterior no exercício.
Recupere a chave primária da conta usando o comando a seguir. Registre os primaryMasterKey resultados do comando from para uso no código.
```
# Retrieve the primary key
az cosmosdb keys list --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```

Configurar o aplicativo de console

Agora que os recursos necessários são implantados no Azure, a próxima etapa é configurar o aplicativo de console usando a mesma janela de terminal no Visual Studio Code.

Crie uma pasta para o projeto e mude para a pasta.
```
md az204-cosmos
cd az204-cosmos
```
Crie o aplicativo de console .NET.
```
dotnet new console
```
Abra a pasta atual no Visual Studio Code usando o seguinte comando. A -r opção abre a pasta sem iniciar uma nova janela do Visual Studio Code.
```
code . -r
```
Selecione o arquivo Program.cs no painel Explorer para abrir o arquivo no editor.

Criar o aplicativo de console

É hora de começar a adicionar os pacotes e o código ao projeto.

Adicionar pacotes e usar instruções

Abra o terminal no Visual Studio Code e use o seguinte comando para adicionar o Microsoft.Azure.Cosmos pacote ao projeto.
```
dotnet add package Microsoft.Azure.Cosmos
```
Exclua Program.cs qualquer código existente no arquivo e adicione a using Microsoft.Azure.Cosmos instrução.
```
using Microsoft.Azure.Cosmos;
```

Adicionar código para se conectar a uma conta do Azure Cosmos DB

Adicione o seguinte trecho de código após a using instrução. O trecho de código adiciona constantes e variáveis à classe e adiciona alguma verificação de erros. Certifique-se de substituir os valores de espaço reservado para EndpointUri e PrimaryKey seguindo as instruções nos comentários de 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
}

Abaixo do método, adicione uma nova tarefa assíncrona Main chamada CosmosAsync, que instancia nosso novo CosmosClient código e adiciona código para chamar os métodos adicionados posteriormente para criar um banco de dados e um contêiner.

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();
}

Criar uma base de dados

Copie e cole o CreateDatabaseAsync método após o CosmosAsync método. CreateDatabaseAsync cria um novo banco de dados com ID az204Database se ele ainda não existir.

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);
}

Criar um contentor

Copie e cole o CreateContainerAsync método abaixo do CreateDatabaseAsync método.

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);
}

Executar a aplicação

Salve seu trabalho e, em um terminal no Visual Studio Code, verifique se há erros executando o dotnet build comando. Execute o dotnet run comando se a compilação for bem-sucedida. O console exibe as seguintes mensagens.
```
Beginning operations...

Created Database: az204Database

Created Container: az204Container

End of program, press any key to exit.
```
Verifique os resultados abrindo o portal do Azure, navegando até seu recurso do Azure Cosmos DB e use o Data Explorer para exibir o banco de dados e o contêiner.

Limpar recursos do Azure

Agora você pode excluir com segurança o grupo de recursos az204-cosmos-rg da sua conta executando o seguinte comando.

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