Exercício: Migrar cargas de trabalho do MongoDB para o Cosmos DB

50 minutos

Você trabalha para uma empresa de serviços públicos que tem sensores IoT que coletam dados de temperatura. As temperaturas são registradas em um banco de dados MongoDB, juntamente com um carimbo de data/hora. Cada dispositivo tem um ID exclusivo. Você executará um aplicativo MongoDB que simula esses dispositivos e armazena os dados no banco de dados. Você também usará um segundo aplicativo que permite que um usuário consulte informações estatísticas sobre cada dispositivo. Depois de migrar o banco de dados do MongoDB para o Cosmos DB, você configurará ambos os aplicativos para se conectarem ao Cosmos DB e verificará se eles ainda funcionam corretamente.

Neste exercício, você pegará um banco de dados MongoDB existente e o migrará para o Cosmos DB. Você usará o Serviço de Migração de Banco de Dados do Azure. Você também verá como reconfigurar aplicativos existentes que usam o banco de dados MongoDB para se conectar ao banco de dados do Cosmos DB.

Importante

O Serviço de Migração de Dados do Azure não é suportado no ambiente seguro gratuito do Azure. Você pode executar essas etapas em sua própria assinatura pessoal ou apenas acompanhar para entender como migrar seu banco de dados.

Criar um banco de dados MongoDB no Azure

Primeiro, você criará o banco de dados MongoDB para armazenar os dados capturados dos dispositivos de temperatura.

Criar um Grupo de Recursos e uma Rede Virtual

Usando um navegador da Web, abra uma nova guia e navegue até o portal do Azure.
No portal do Azure, selecione Grupos de recursos e, em seguida, selecione +Adicionar.
Na página Criar um grupo de recursos, insira os seguintes detalhes:

Property valor

Subscrição <a sua subscrição>

Grupo de Recursos Mongodbrg

Região Selecione a localização mais próxima de si
Selecione Rever + Criar e, em seguida, selecione Criar. Aguarde até que o grupo de recursos seja criado.
No menu do portal do Azure, selecione + Criar um recurso.
Na página Novo, na caixa Pesquisar no Marketplace, digite Rede Virtual e pressione Enter.
Na página Rede Virtual, selecione Criar.
Na página Criar rede virtual, insira os seguintes detalhes e selecione Avançar: Endereços IP:

Property valor

Grupo de Recursos Mongodbrg

Nome Banco de dadosVNET

Região Selecione o mesmo local especificado para o grupo de recursos
Na página Endereços IP, defina o espaço de endereço IPv4 como 10.0.0.0/24.
Selecione a sub-rede padrão e, em seguida, selecione Remover sub-rede.
Selecione + Adicionar sub-rede. No painel Adicionar sub-rede, defina o nome da sub-rede como padrão, defina o intervalo de endereços da sub-rede como 10.0.0.0/28 e selecione Adicionar.
Na página Endereços IP, selecione Avançar: Segurança.
Na página Segurança, verifique se a Proteção de Rede DDoS do Azure está definida como Desativar e se o Firewall está definido como Desabilitar. Selecione Rever + criar.
Na página Criar rede virtual, selecione Criar. Aguarde a criação da rede virtual antes de continuar.

Property	valor
Subscrição	<a sua subscrição>
Grupo de Recursos	Mongodbrg
Região	Selecione a localização mais próxima de si

Criar um servidor de banco de dados MongoDB

No menu do portal do Azure, selecione + Criar um recurso.
Na caixa Pesquisar no Marketplace, digite Ubuntu e pressione Enter.
Na página Marketplace, selecione Ubuntu Server 18.04 LTS.
Na página Ubuntu Server 18.04 LTS, selecione Criar.

Na página Criar uma máquina virtual, insira os seguintes detalhes:

Property	valor
Grupo de Recursos	Mongodbrg
Virtual machine name	MongoDBerver
Região	Selecione o mesmo local especificado para o grupo de recursos
Opções de disponibilidade	Não existem redundâncias de infraestruturas necessárias
Image	Ubuntu Server 18.04 LTS – Gen1
Instância do Azure Spot	Desselecionado
Tamanho	A1_v2 padrão
Authentication type	Password
Nome de Utilizador	azureuser
Password	Pa55w.rdPa55w.rd
Confirme a palavra-passe	Pa55w.rdPa55w.rd
Portas de entrada públicas	Permitir as portas selecionadas
Selecione as portas de entrada	SSH (22)

Selecione Next: Discos >.
Na página Discos, deixe as configurações como padrão e selecione Avançar: Rede >.

Na página Rede, insira os seguintes detalhes:

Property	valor
Rede virtual	Banco de dadosVNET
Sub-rede	padrão (10.0.0.0/28)
IP público	(novo) mongodbserver-ip
Grupo de segurança de rede NIC	Avançado
Configurar grupo de segurança de rede	(novo) mongodbserver-nsg
Rede acelerada	Desselecionado
Balanceamento de carga	Desselecionado

Selecione Rever + criar>.
Na página de validação, selecione Criar.
Aguarde a implantação da máquina virtual antes de continuar
No menu do portal do Azure, selecione Todos os recursos.
Na página Todos os recursos, selecione mongodbserver-nsg.
Na página mongodbserver-nsg, em Configurações, selecione Regras de segurança de entrada.
Na página mongodbserver-nsg - Regras de segurança de entrada, selecione + Adicionar.

No painel Adicionar regra de segurança de entrada, insira os seguintes detalhes:

Property	Value
Source	Qualquer
Intervalo de portas de origem	*
Destino	Qualquer
Intervalos de portas de destino	8080
Protocolo	Qualquer
Ação	Permitir
Prioridade	1030
Nome	Mongodb-porto
Descrição	Porta que os clientes usam para se conectar ao MongoDB

Selecione Adicionar.

Nota

Você configurará o MongoDB para usar a porta 8080 neste exercício. Você só precisa fazer isso devido a restrições de segurança nesse ambiente. Você normalmente usaria a porta padrão do MongoDB de 27017.

Instalar o MongoDB

No menu do portal do Azure, selecione Todos os recursos.
Na página Todos os recursos, selecione mongodbserver-ip.
Na página mongodbserver-ip, anote o endereço IP.
Na barra de ferramentas na parte superior do portal do Azure, selecione Cloud Shell.
Se a caixa de mensagem Você não tem armazenamento montado for exibida, selecione Criar armazenamento.
Quando o Cloud Shell for iniciado, na lista suspensa acima da janela do Cloud Shell, selecione Bash.
No Cloud Shell, digite o seguinte comando para se conectar à máquina virtual mongodbserver. Substitua <o endereço ip pelo valor do endereço> IP mongodbserver-ip:
```
ssh azureuser@<ip address>
```
No prompt, digite yes para continuar se conectando.
Digite a senha Pa55w.rdPa55w.rd.
Para recarregar o banco de dados de pacotes, digite este comando:
```
sudo apt-get update
```
Para instalar o MongoDB, digite este comando:
```
sudo apt-get install -y mongodb
```
A instalação deve prosseguir com mensagens sobre a instalação, preparação e descompactação de pacotes. Pode levar alguns minutos para que a instalação seja concluída.

Configurar o banco de dados MongoDB

Por padrão, a instância de banco de dados Mongo é configurada para ser executada sem autenticação. Nesta tarefa, você configurará o MongoDB para se vincular à interface de rede local para que ele possa aceitar conexões de outros computadores. Você também habilitará a autenticação e criará a conta de usuário necessária para executar a migração. Finalmente, você adicionará uma conta que um aplicativo de teste pode usar para consultar o banco de dados.

Para abrir o arquivo de configuração do MongoDB, execute este comando:
```
sudo nano /etc/mongodb.conf
```
No arquivo, localize a configuração bind_ip e defina-a como 0.0.0.0.
Localize a configuração da porta e defina-a como 8080.
Para salvar o arquivo de configuração, pressione Esc e, em seguida, pressione CTRL + X. Pressione y e, em seguida, Enter para salvar o buffer modificado.
Para reiniciar o serviço MongoDB e aplicar as alterações, digite este comando:
```
sudo service mongodb restart
```
Para se conectar ao serviço MongoDB, digite este comando:
```
mongo --host 127.0.0.1:8080
```
> No prompt, para alternar para o banco de dados admin, execute este comando:
```
use admin;
```

Para criar um novo usuário chamado administrador, execute o seguinte comando. Você pode inserir o comando em uma linha ou em várias linhas para melhor legibilidade. O comando é executado quando o programa atinge o mongo ponto-e-vírgula:

db.createUser(
    {
        user: "administrator",
        pwd: "Pa55w.rd",
        roles: [
            { role: "userAdminAnyDatabase", db: "admin" },
            { role: "clusterMonitor", db:"admin" },
            "readWriteAnyDatabase"
        ]
    }
);

Para sair do mongo programa, digite este comando;
```
exit;
```
Para se conectar ao MongoDB com a conta do novo administrador, execute este comando:
```
mongo admin -u "administrator" -p "Pa55w.rd" --host 127.0.0.1:8080
```
Para alternar para o banco de dados DeviceData , execute este comando:
```
use DeviceData;    
```

Para criar um usuário chamado deviceadmin, que o aplicativo usará para se conectar ao banco de dados, execute este comando:

db.createUser(
    {
        user: "deviceadmin",
        pwd: "Pa55w.rd",
        roles: [ { role: "readWrite", db: "DeviceData" } ]
    }
);

Para sair do mongo programa, digite este comando;
```
exit;
```
Execute o seguinte comando: reinicie o serviço mongodb. Verifique se o serviço é reiniciado sem mensagens de erro:
```
sudo service mongodb restart
```
Execute o seguinte comando para verificar se agora você pode fazer login no mongodb como o usuário deviceadmin:
```
mongo DeviceData -u "deviceadmin" -p "Pa55w.rd" --host 127.0.0.1:8080
```
No prompt, execute o > seguinte comando para sair do shell mongo:
```
exit;
```
No prompt bash, execute o seguinte comando para se desconectar do servidor MongoDB e retornar ao Cloud Shell:
```
exit
```

Preencher e consultar o banco de dados MongoDB

Agora você criou um servidor MongoDB e um banco de dados. A próxima etapa é demonstrar os aplicativos de exemplo que podem preencher e consultar os dados nesse banco de dados.

Criar e executar um aplicativo para preencher o banco de dados MongoDB

No Azure Cloud Shell, execute o seguinte comando para baixar o código de exemplo:

git clone https://github.com/MicrosoftLearning/DP-060T00A-Migrating-your-Database-to-Cosmos-DB migration-workshop-apps

Vá para a pasta migration-workshop-apps/MongoDeviceDataCapture/MongoDeviceCapture :
```
cd ~/migration-workshop-apps/MongoDeviceDataCapture/MongoDeviceDataCapture
```
Use o editor de códigos para examinar o arquivo TemperatureDevice.cs:
```
code TemperatureDevice.cs
```
O código neste arquivo contém uma classe chamada TemperatureDevice que simula um dispositivo de temperatura capturando dados e salvando-os em um banco de dados MongoDB. Ele usa a biblioteca MongoDB para o .NET Framework. O construtor TemperatureDevice se conecta ao banco de dados usando as configurações armazenadas no arquivo de configuração do aplicativo. O método RecordTemperatures gera uma leitura e a grava no banco de dados.
Feche o editor de código e, em seguida, abra o arquivo ThermometerReading.cs :
```
code ThermometerReading.cs
```
Esse arquivo mostra a estrutura dos documentos que o aplicativo armazena no banco de dados. Cada documento contém os seguintes campos:
- Um ID de objeto. O é o campo "_id" gerado pelo MongoDB para identificar exclusivamente cada documento.
- Um ID de dispositivo. Cada dispositivo tem um número com o prefixo "Dispositivo".
- A temperatura registada pelo dispositivo.
- A data e a hora em que a temperatura foi registada.
Feche o editor de código e, em seguida, abra o arquivo App.config :
```
code App.config
```
Este arquivo contém as configurações para se conectar ao banco de dados MongoDB.
Defina o valor da chave Address para o endereço IP do servidor MongoDB que você registrou anteriormente.
Altere a porta que o aplicativo usa para 8080.
Salve o arquivo e feche o editor usando CTRL s e, em seguida, CTRL + + q.
Execute o seguinte comando para reconstruir o aplicativo:
```
dotnet build
```
Isto pode demorar cerca de 5 minutos.
Execute a aplicação:
```
dotnet run
```
O aplicativo simula 100 dispositivos rodando simultaneamente. Permita que o aplicativo seja executado por alguns minutos e pressione Enter para pará-lo.

Crie e execute outro aplicativo para consultar o banco de dados MongoDB

Mova para a pasta DP160T00A-Migrating-your-Database-to-Cosmos-DB/MongoDeviceDataCapture/DeviceDataQuery :
```
cd ~/migration-workshop-apps/MongoDeviceDataCapture/DeviceDataQuery
```
Esta pasta contém outro aplicativo que você pode usar para analisar os dados capturados por cada dispositivo.
Use o editor de código para examinar o arquivo .cs programa:
```
code Program.cs
```
O aplicativo se conecta ao banco de dados (usando o método ConnectToDatabase na parte inferior do arquivo) e, em seguida, solicita ao usuário um número de dispositivo. O aplicativo usa a biblioteca MongoDB para o .NET Framework para criar e executar um pipeline agregado que calcula as seguintes estatísticas para o dispositivo especificado:
- O número de leituras registadas.
- A temperatura média registada.
- A leitura mais baixa.
- A leitura mais alta.
- A última leitura.
Feche o editor de código e, em seguida, abra o arquivo App.config :
```
code App.config
```
Defina o valor da chave Address para o endereço IP do servidor MongoDB que você registrou anteriormente.
Altere a porta que o aplicativo usa para 8080.
Salve o arquivo e feche o editor usando CTRL s e, em seguida, CTRL + + q.
Compile e execute o aplicativo:
```
dotnet build
dotnet run
```
No prompt Enter Device Number, insira um valor entre 0 e 99. O aplicativo consultará o banco de dados, calculará as estatísticas e exibirá os resultados. Pressione Q para sair do aplicativo.

Migrar o banco de dados MongoDB para o Cosmos DB

O próximo passo é pegar o banco de dados MongoDB e transferi-lo para o Cosmos DB.

Criar uma conta e um banco de dados do Cosmos

Regresse ao portal do Azure.
No menu, selecione + Criar um recurso.
Na página Novo, na caixa Pesquisar no Marketplace, digite *Azure Cosmos DB, end e pressione Enter.
Na página Azure Cosmos DB, selecione Criar.

Na página Criar Conta do Azure Cosmos DB, insira as seguintes configurações:

Property	valor
Grupo de recursos	Mongodbrg
Nome da Conta	mongodbnnn, onde nnn é um número aleatório selecionado por você
API	Azure Cosmos DB para MongoDB API
Notebooks	Desativado
Localização	Especifique o mesmo local que você usou para o servidor MongoDB e a rede virtual
Modo de capacidade	Taxa de transferência provisionada
Aplicar Desconto de Escalão Gratuito	Aplicar
Tipo de Conta	Não Produção
Versão	3.6
Georredundância	Desativar
Escritas de várias regiões	Desativar
Zonas de Disponibilidade	Desativar

Selecione Rever + criar.
Na página de validação, selecione Criar e aguarde a implantação da conta do Cosmos DB.
No menu do portal do Azure, selecione Todos os recursos e, em seguida, selecione sua nova conta do Cosmos DB (mongodbnnn).
Na página mongodbnnn, selecione Data Explorer.
No painel Data Explorer, selecione Nova Coleção.

No painel Adicionar coleção, especifique as seguintes configurações:

Property	valor
ID da Base de Dados	Selecione Criar novo e, em seguida, digite DeviceData
Aprovisionar o débito da base de dados	selecionados
Débito	10000
ID da coleção	Temperaturas
Capacidade de armazenamento	Ilimitado
Chave de estilhaços	ID do dispositivo
Minha chave de estilhaço é maior que 100 bytes	Deixar desmarcado
Criar um índice curinga em todos os campos	Deixar desmarcado
Loja analítica	Desativado

Selecione OK.

Criar o Serviço de Migração de Banco de Dados

Regresse ao portal do Azure.
Clique em Todos os serviços, clique em Subscrições e, em seguida, clique na sua subscrição.
Na página da sua subscrição, em Definições, clique em Fornecedores de recursos.
Na caixa Filtrar por nome, digite DataMigration e clique em Microsoft.DataMigration.
Se o Microsoft.DataMigration não estiver registrado, clique em Registrar e aguarde até que o Status mude para Registrado. Pode ser necessário clicar em Atualizar para ver a alteração de status.
No menu do portal do Azure, selecione + Criar um recurso.
Na página Novo, na caixa Pesquisar no Marketplace, digite Serviço de Migração de Banco de Dados do Azure e pressione Enter.
Na página Serviço de Migração de Banco de Dados do Azure, selecione Criar.

Na página Criar Serviço de Migração, insira as seguintes configurações:

Property	valor
Grupo de recursos	Mongodbrg
Nome do Serviço	MongoDBMigration
Localização	Selecionar a mesma localização que utilizou anteriormente
Modo de serviço	Azure
Escalão de Preço	Padrão: 1 vCores

Selecione Next: Networking.
Na página Rede, selecione databasevnet/default e, em seguida, selecione Rever + criar.
Selecione Criar e aguarde a implantação do serviço antes de continuar. Esta operação pode demorar cerca de 10 minutos.

Criar e executar um novo projeto de migração

No menu do portal do Azure, selecione Grupos de recursos.
Na janela Grupos de recursos , selecione mongodbrg.
Na janela mongodbrg, selecione MongoDBMigration.
Na página MongoDBMigration, selecione + Novo projeto de migração.

Na página Novo projeto de migração, insira as seguintes configurações:

Property	valor
Nome do projeto	MigrateTemperatureData
Tipo do servidor de origem	MongoDB
Tipo de servidor de destino	Cosmos DB (API do MongoDB)
Escolher tipo de atividade	Migração de dados offline

Selecione Criar e executar atividade.

Quando o Assistente de Migração for iniciado, na página Detalhes da fonte, insira os seguintes detalhes:

Property	valor
Modo	Modo padrão
Nome do servidor de origem	Especifique o valor do endereço IP mongodbserver-ip que você registrou anteriormente
Porta do servidor	8080
Nome de Utilizador	administrador
Password	Pa55w.rd
Exigir SSL	desmarcada

Selecione Avançar: Selecione o destino.

Na página Selecionar destino, insira os seguintes detalhes:

Property	valor
Modo	Selecionar destino do Cosmos DB
Selecione o nome do banco de dados Comos	MongoDBNNN
Cadeia de ligação	Aceitar a cadeia de conexão gerada para sua conta do Cosmos DB

Selecione Next: Database setting.
Na página Configuração do banco de dados , insira os seguintes detalhes:

Property valor

Base de Dados de Origem Dados do dispositivo

Base de Dados de Destino Dados do dispositivo

Taxa de transferência (RU/s) 1000

Limpar coleções Desmarque esta caixa
Selecione Next: Collection setting.
Na página Configuração da coleção , selecione a seta suspensa ao lado do banco de dados DeviceData, insira os seguintes detalhes:

Property valor

Name Temperaturas

Recolha de Destino Temperaturas

Taxa de transferência (RU/s) 1000

Chave de estilhaços ID do dispositivo

Exclusivo Deixar em branco
Selecione Next: Migration summary.
Na página Resumo da migração, no campo Nome da atividade, digite mongodb-migration e selecione Iniciar migração.
Na página mongodb-migration, selecione Atualizar a cada 30 segundos, até que a migração seja concluída. Observe o número de documentos processados.

Property	valor
Base de Dados de Origem	Dados do dispositivo
Base de Dados de Destino	Dados do dispositivo
Taxa de transferência (RU/s)	1000
Limpar coleções	Desmarque esta caixa

Property	valor
Name	Temperaturas
Recolha de Destino	Temperaturas
Taxa de transferência (RU/s)	1000
Chave de estilhaços	ID do dispositivo
Exclusivo	Deixar em branco

Verificar se a migração foi bem-sucedida

No menu do portal do Azure, selecione Todos os Recursos.
Na página Todos os recursos, selecione mongodbnnn.
Na página mongodb*nnn, selecione Data Explorer.
No painel Data Explorer, expanda o banco de dados DeviceData, expanda a coleção Temperatures e selecione Documents.
No painel Documentos, percorra a lista de documentos. Você verá uma ID do documento (_id) e a chave de estilhaço (/deviceID) para cada documento.

Selecione qualquer documento. Você deve ver os detalhes do documento exibido. Um documento típico tem esta aparência:

{
    "_id" : ObjectId("5ce8104bf56e8a04a2d0929a"),
    "deviceID" : "Device 83",
    "temperature" : 19.65268837271849,
    "time" : 636943091952553500
}

Na barra de ferramentas no painel Explorador de Documentos, selecione Novo Shell.
No painel Shell 1, no > prompt, digite o seguinte comando e pressione Enter:
```
db.Temperatures.count()
```
Este comando exibe o número de documentos na coleção Temperatures. Ele deve corresponder ao número relatado pelo Assistente de Migração.
Digite o seguinte comando e pressione Enter:
```
db.Temperatures.find({deviceID: "Device 99"})
```
Este comando busca e exibe os documentos para o dispositivo 99.

Reconfigurar e executar aplicativos existentes para usar o Cosmos DB

A etapa final é reconfigurar seus aplicativos MongoDB existentes para se conectar ao Cosmos DB e verificar se eles ainda funcionam. Isso requer que você modifique a maneira como seus aplicativos se conectam ao banco de dados, mas a lógica de seus aplicativos deve permanecer inalterada.

No painel mongodbnnn, em Configurações, selecione Cadeia de Conexão.
Na página mongodbnnn Connection String, anote as seguintes configurações:
- Host
- Nome de Utilizador
- Palavra-passe principal
Retorne à janela do Cloud Shell (reconecte-se se a sessão tiver expirado) e vá para a pasta migration-workshop-apps/MongoDeviceDataCapture/DeviceDataQuery :
```
cd ~/migration-workshop-apps/MongoDeviceDataCapture/DeviceDataQuery
```
Abra o arquivo App.config no editor de código:
```
code App.config
```
Na seção Configurações do MongoDB do arquivo, comente as configurações existentes.

Descomente as configurações na seção Configurações da API Mongo do Cosmos DB e defina os valores para essas configurações da seguinte maneira:

Definição	Valor
Endereço	O HOST da página mongodbnnn Connection String
Porta	A PORTA da página mongodbnnn Connection String
Nome de Utilizador	O USERNAME da página mongodbnnn Connection String
Password	A SENHA PRIMÁRIA da página Cadeia de Conexão mongodbnnn

O arquivo concluído deve ser semelhante a este:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <appSettings>
        <add key="Database" value="DeviceData" />
        <add key="Collection" value="Temperatures" />

        <!-- Settings for MongoDB 
        <add key="Address" value="nn.nn.nn.nn" />
        <add key="Port" value="27017" />
        <add key="Username" value="deviceadmin" />
        <add key="Password" value="Pa55w.rd" />
        End of settings for MongoDB -->

        <!-- Settings for CosmosDB Mongo API -->
        <add key="Address" value="mongodbnnn.documents.azure.com"/>
        <add key="Port" value="10255"/>
        <add key="Username" value="mongodbnnn"/>
        <add key="Password" value="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=="/>
        <!-- End of settings for CosmosDB Mongo API -->
    </appSettings>
</configuration>

Salve o arquivo e feche o Editor de códigos.
Abra o arquivo .cs programa usando o editor de código:
```
code Program.cs
```
Role para baixo até o método ConnectToDatabase .

Comente a linha que define as credenciais para se conectar ao MongoDB e remova o comentário das instruções que especificam as credenciais para se conectar ao Cosmos DB. O código deve ter esta aparência:

// Connect to the MongoDB database
MongoClient client = new MongoClient(new MongoClientSettings
{
    Server = new MongoServerAddress(address, port),
    ServerSelectionTimeout = TimeSpan.FromSeconds(10),

    //
    // Credential settings for MongoDB
    //

    // Credential = MongoCredential.CreateCredential(database, azureLogin.UserName, azureLogin.SecurePassword),

    //
    // Credential settings for CosmosDB Mongo API
    //

    UseTls = true,
    Credential = new MongoCredential("SCRAM-SHA-1", new MongoInternalIdentity(database, azureLogin.UserName), new PasswordEvidence(azureLogin.SecurePassword))

    // End of Mongo API settings
});

Essas alterações são necessárias porque o banco de dados MongoDB original não estava usando uma conexão SSL. O Cosmos DB sempre usa SSL.

Salve o arquivo e feche o Editor de códigos.
Reconstrua e execute o aplicativo:
```
dotnet build
dotnet run
```
No prompt Enter Device Number (Inserir número do dispositivo), insira um número de dispositivo entre 0 e 99. O aplicativo deve ser executado exatamente como antes, exceto que desta vez ele está usando os dados mantidos no banco de dados do Cosmos DB.

Melhorar o desempenho da consulta no Cosmos DB

O Cosmos DB permite adicionar mais índices para melhorar o desempenho da consulta. Como estamos agregando sobre deviceID, adicionar esse campo como um índice acelerará suas consultas.

Regresse ao portal do Azure.
À esquerda, selecione Data Explorer.
No painel Data Explorer, expanda o banco de dados DeviceData, expanda a coleção Temperaturas e selecione Configurações.
Selecione Política de indexação.
Em _id adicionar um novo índice, insira deviceID para a Definição e selecione Campo Único para o Tipo.
Selecione Salvar para adicionar o novo índice.
Retorne ao Cloud Shell para tentar sua consulta novamente e observe a resposta aprimorada em seu aplicativo.
Teste o aplicativo com outros números de dispositivo. Digite Q para concluir.

Você migrou com êxito um banco de dados MongoDB para o Cosmos DB e reconfigurou um aplicativo MongoDB existente para se conectar ao novo banco de dados do Cosmos DB.

Limpe os recursos que você criou