Avançar

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

15 minutos

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

Conectar-se a uma conta do Azure Cosmos DB
Criar um banco de dados
Criar um contêiner

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Caso ainda não tenha uma, inscreva-se em uma avaliação gratuita em https://azure.com/free.
Visual Studio Code em uma das plataformas compatíveis.
O .NET 6 é a estrutura de destino para o exercício.
A Extensão do C# para Visual Studio Code.
As ferramentas mais recentes da CLI do Azure instaladas localmente.

Configurando

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

Como conectar-se ao Azure

Inicie o Visual Studio Code e abra uma janela do terminal selecionando Terminal na barra de aplicativos superior. Depois escolha Novo Terminal.
Entre no Azure usando o comando a seguir. Uma janela do navegador será aberta para que você escolha com qual conta fará logon.
```
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 pode conter apenas letras minúsculas, números e o caractere de hífen (-). Ela deve ter entre 3 e 31 caracteres. Esse 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, ele é usado posteriormente no exercício.
Recupere a chave primária da conta usando o comando abaixo. Registre a primaryMasterKey dos resultados do comando, que será usada 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 estão implantados no Azure, a próxima etapa é configurar o aplicativo de console usando a mesma janela do terminal no Visual Studio Code.

Crie uma pasta para o projeto e acesse-a.
```
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 comando abaixo. A opção -r abrirá 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.

Compilar o aplicativo de console

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

Adicionar pacotes e instruções using

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

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

Adicione o snippet de código abaixo após a instrução using. O snippet de código adiciona constantes e variáveis à classe e uma certa verificação de erro. Substitua os valores de espaço reservado EndpointUri e PrimaryKey seguindo as instruções nos comentários do 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 Main, adicione uma nova tarefa assíncrona chamada CosmosAsync, que instancia nossa nova CosmosClient e adiciona código para chamar os métodos que você adicionará 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 um banco de dados

Copie o método CreateDatabaseAsync e cole-o após o método CosmosAsync. CreateDatabaseAsync cria um banco de dados com a ID az204Database, quando ele ainda não 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);
}

Criar um contêiner

Copie o método CreateContainerAsync e cole-o abaixo do 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);
}

Executar o aplicativo

Salve o trabalho e, em um terminal no Visual Studio Code, execute o comando dotnet build para verificar se há algum erro. Se o build for bem-sucedido, execute o comando dotnet run. O console exibe as mensagens a seguir.
```
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é o recurso Azure Cosmos DB e usando 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 conta executando o comando a seguir.

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

Continuar