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

50 minutos

Você trabalha para uma empresa de utilitários que tem sensores IoT que coletam dados de temperatura. As temperaturas são registradas em um banco de dados MongoDB, junto com um carimbo de data/hora. Cada dispositivo tem uma ID exclusiva. Você executará um aplicativo do MongoDB que simula esses dispositivos e os armazena 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 Cosmos DB, você configurará os dois 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. Prepare o Serviço de Migração de Banco de Dados do Azure. Você também verá como reconfigurar os aplicativos existentes que usam o banco de dados MongoDB para se conectar ao banco de dados do Cosmos DB em vez disso.

Importante

O Serviço de Migração de Dados do Azure não tem suporte no ambiente de área restrita gratuito do Azure. Você pode executar essas etapas em sua própria assinatura ou apenas acompanhar para aprender como ativar a ASC.

Criar um banco de dados MongoDB no Azure

Primeiro, você criará o banco de dados do MongoDB para manter o dado capturado dos dispositivos de temperatura.

Criar um Grupo de Recursos e uma Rede Virtual

Abra uma nova guia e navegue até o portal do Azure.
Na portal do Azure, selecione Grupos de recursos e escolha +Adicionar.
Na página Criar um grupo de recursos, insira os seguintes detalhes:

Propriedade Valor

Subscription <your-subscription>

Grupo de recursos mongodbrg

Região Selecione sua localização mais próxima
Selecione Examinar + Criar e Criar. Aguarde até o recurso ser criado.
No 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, em seguida, selecione Avançar: endereços IP:

Propriedade Valor

Grupo de recursos mongodbrg

Name databasevnet

Região Selecione o mesmo local que você especificou 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 escolha 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 contra DDoS do Azure está configurada como Desabilitar e se o Firewall está configurado como Desabilitar. Selecione Examinar + criar.
Na página Criar rede virtual, selecione Criar. Aguarde até que a rede virtual seja criada antes de continuar.

Propriedade	Valor
Subscription	<your-subscription>
Grupo de recursos	mongodbrg
Região	Selecione sua localização mais próxima

Criar um servidor do banco de dados do MongoDB

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

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

Propriedade	Valor
Grupo de recursos	mongodbrg
Nome da máquina virtual	mongodbserver
Região	Selecione o mesmo local que você especificou para o grupo de recursos
Opções de disponibilidade	Sem necessidade de redundância de infraestrutura
Imagem	Ubuntu Server 18.04 LTS – Gen1
Instância do Azure Spot	Desmarcado
Tamanho	Standard A1_v2
Tipo de autenticação	Senha
Nome de Usuário	azureuser
Senha	Pa55w.rdPa55w.rd
Confirmar senha	Pa55w.rdPa55w.rd
Porta de entrada públicas	Permitir portas selecionadas
Selecione as portas de entrada	SSH (22)

Selecione Avançar: Discos>.
Na página Avançado, deixe todas as configurações com os valores padrão e selecione Avançar: Discos>.

Na página Rede, insira os seguintes detalhes:

Propriedade	Valor
Rede virtual	databasevnet
Sub-rede	(10.0.0.0/28) padrão
IP público	(novo) mongodbserver-ip
Grupo de segurança de rede da NIC	Avançado
Configurar um grupo de segurança de rede	(novo) mongodbserver-nsg
Redes aceleradas	Desmarcado
Balanceamento de carga	Desmarcado

Selecione Examinar + criar>.
Na página validação aprovada, selecione Criar.
Aguardar o aplicativo de função ser implantado antes de continuar
No 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:

Propriedade	Valor
Fonte	Qualquer
Intervalos de portas de origem	*
Destino	Qualquer
Intervalos de portas de destino	8080
Protocolo	Qualquer
Ação	Permitir
Prioridade	1030
Name	Mongodb-port
Descrição	Porta que os clientes usam para se conectar ao MongoDB

Selecione Adicionar.

Observação

Neste exercício, você configurará o MongoDB para usar a porta 8080. Só é necessário fazer isso devido a restrições de segurança nesse ambiente. Normalmente, você usaria a porta padrão do MongoDB de 27017.

Instalar o MongoDB

No 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 da portal do Azure, selecione Cloud Shell.
Se a caixa de mensagem Você não tem nenhum armazenamento montado for exibida, clique em Criar armazenamento.
Quando o Cloud Shell for iniciado, na lista suspensa acima da janela Cloud Shell, selecione Bash.
Na janela do Cloud Shell, execute o comando a seguir para se conectar à máquina virtual do Ubuntu. Substitua <ip address> pelo valor do endereço IP mongodbserver-ip:
```
ssh azureuser@<ip address>
```
No prompt, digite sim para continuar a conexão.
Insira a senha Pa55w.rdPa55w.rd.
Para recarregar o banco de dados do pacote, digite este comando:
```
sudo apt-get update
```
Para instalar o MongoDB, digite este comando:
```
sudo apt-get install -y mongodb
```
A instalação deve continuar com mensagens sobre instalação, preparação e descompactação de pacotes. A instalação pode demorar alguns minutos.

Configurar o banco de dados MongoDB

Por padrão, a instância do Mongo DB é configurada para ser executada sem autenticação. Nesta tarefa, você configurará o MongoDB para associar à interface de rede local para que ela 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. Por fim, 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 de bind_ip e defina-a como 0.0.0.0.
Localize a configuração de porta e defina-a como 8080.
Para salvar o arquivo de configuração, pressione Esc e, em seguida, CTRL + X. Pressione y e, em seguida, Enter para salvar o buffer modificado.
Para reiniciar o serviço MongoDB e aplicar suas 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 de >, execute este comando:
```
use admin;
```

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

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

Para sair do programa mongo, 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 será usado pelo aplicativo 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 programa mongo, digite este comando;
```
exit;
```
Execute o comando a seguir para reiniciar o serviço MongoDB. Verifique se o serviço é reiniciado sem nenhuma mensagem de erro:
```
sudo service mongodb restart
```
Execute o comando a seguir para verificar se agora você pode fazer logon 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 do bash, execute o seguinte comando para se desconectar do servidor MongoDB e retornar para a Cloud Shell:
```
exit
```

Popular e consultar o banco de dados MongoDB

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

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

Na janela do Cloud Shell, execute o seguinte comando para baixar o código-fonte de exemplo:

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

Mova para a pasta migration-workshop-apps/MongoDeviceDataCapture/MongoDeviceCapture:
```
cd ~/migration-workshop-apps/MongoDeviceDataCapture/MongoDeviceDataCapture
```
Use o editor de Código para examinar o arquivo TemperatureDevice.cs:
```
code TemperatureDevice.cs
```
O código nesse arquivo contém uma classe chamada TemperatureDevice que simula um dispositivo de temperatura capturando dados e salvando-os em um banco de dado MongoDB. Ele usa a biblioteca do MongoDB para o .NET Framework. O construtor TemperatureDevice se conecta ao banco de dados usando as configurações armazenadas no arquivo de configuração de 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:
- Uma ID do objeto. O é o campo "_id" gerado pelo MongoDB para identificar exclusivamente cada documento.
- Uma ID do dispositivo. Cada dispositivo tem um número com o prefixo "dispositivo".
- A temperatura registrada pelo dispositivo.
- A data e a hora em que a temperatura foi registrada.
Feche o editor de código e, em seguida, abra o arquivo App.config:
```
code App.config
```
Esse arquivo contém as configurações para se conectar ao banco de dados MongoDB.
Defina o valor da chave de Endereço 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 recompilar o aplicativo:
```
dotnet build
```
Isso pode demorar cerca de 5 minutos.
Execute o aplicativo:
```
dotnet run
```
O aplicativo simula 100 dispositivos em execução simultaneamente. Deixe o aplicativo ser executado por dois ou três minutos e pressione ENTER para interrompê-lo.

Compilar e executar outro aplicativo para consultar o banco de dados MongoDB

Mova para a pasta DP160T00A-Migration-Your-Database-to-Cosmos-DB/MongoDeviceDataCapture/DeviceDataQuery:
```
cd ~/migration-workshop-apps/MongoDeviceDataCapture/DeviceDataQuery
```
Essa 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 Program.cs:
```
code Program.cs
```
O aplicativo se conecta ao banco de dados (usando o método ConnectToDatabase na parte inferior do arquivo) e solicita ao usuário um número de dispositivo. O aplicativo usa a biblioteca do MongoDB para a .NET Framework criar e executar um pipeline agregado que calcula as seguintes estatísticas para o dispositivo especificado:
- O número de leituras registradas.
- A temperatura média do ano seguinte.
- A leitura mais baixa.
- A leitura mais alto.
- A leitura mais recente.
Feche o editor de código e, em seguida, abra o arquivo App.config:
```
code App.config
```
Defina o valor da chave de Endereço 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.
Crie e execute o aplicativo:
```
dotnet build
dotnet run
```
No prompt Inserir número de dispositivo, 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 um banco de dados MongoDB para Cosmos DB

A próxima etapa é pegar o banco de dados do MongoDB e transferi-lo para Cosmos DB.

Criar uma conta e um banco de dados do Cosmos

Retorne ao portal do Azure.
No menu esquerdo, selecione + Criar um recurso.
Na página novo, na caixa Pesquisar no Marketplace, digite *Azure Cosmos DB, em seguida, pressione Enter.
Na página Azure Cosmos DB, selecione Criar.

No assistente Criar conta do Azure Cosmos DB, insira os valores a seguir:

Propriedade	Valor
Resource group	mongodbrg
Nome da Conta	mongodbnnn, em que nnn é um número aleatório selecionado por você
API	Azure Cosmos DB para a API do MongoDB
Notebooks	Desativado
Local	Especifique o mesmo local que você usou para o servidor e a rede virtual do MongoDB
Modo de capacidade	Taxa de transferência provisionada
Aplicar desconto por nível gratuito	Aplicar
Tipo de Conta	Aplicativos de não Produção
Versão	3,6
Redundância geográfica	Desabilitar
Gravações de várias regiões	Desabilitar
Zonas de Disponibilidades	Desabilitar

Selecione Examinar + criar.
Na página de validação, selecione Criar e aguarde até a conta de armazenamento ser implantada.
No menu do portal do Azure, selecione Todos os recursos e escolha a nova conta do Cosmos DB (mongodbnnn).
Na página mongodbnnn, selecione Data Explorer.
Abra o painel Data Explorer e selecione Nova Coleção.

No painel Adicionar conta de armazenamento do Edge, especifique as seguintes configurações:

Propriedade	Valor
ID do banco de dados	Selecione Criar novoe digite DeviceData
Aprovisionar a taxa de transferência de bancos de dados	selecionado
Produtividade	10000
ID da coleção	Temperaturas
Capacidade de armazenamento	Ilimitado
Chave de fragmentação	deviceID
Minha chave de fragmento é maior que 100 bytes	deixar de-selecionado
Criar um índice curinga em todos os campos	deixar sem seleção
Repositório analítico	Desativado

Selecione OK.

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

Alterne novamente para o portal do Azure.
Clique em Todos os serviços, em Assinaturas e na sua assinatura.
Na página da sua assinatura, em Configurações, clique em Provedores 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 o Status mudar para Registrado. Pode ser necessário clicar em Atualizar para ver a alteração do status.
No portal do Azure, selecione + Criar um recurso.
Na página Novo, na caixa Pesquisar no Marketplace, digite o Serviço de Migração de Banco de Dados do Azure e pressione Enter.
Na tela 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:

Propriedade	Valor
Resource group	mongodbrg
Nome do serviço	MongoDBMigration
Location	Selecionar o mesmo local usado anteriormente
Modo de serviço	Azure
Camada de preços	Standard: 1 vCores

Selecione Avançar: Rede.
Na página Rede, selecione databasevnet/default e clique em Examinar + criar.
Selecione Criar e aguarde o aplicativo de função ser implantado antes de continuar. Esta operação pode levar 10 minutos ou mais.

Criar e executar um 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:

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

Selecione Criar e executar uma atividade.

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

Propriedade	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 do Usuário	administrador
Senha	Pa55w.rd
Exigir SSL	de-selecionado

Selecione Avançar: Selecione o destino.
Na página Selecionar destino, insira os seguintes detalhes:

Propriedade Valor

Modo Selecionar o destino do Cosmos DB

Selecionar o nome do Cosmos DB mongodb*nnn*

Cadeia de conexão Aceite a cadeia de conexão gerada para sua conta Cosmos DB
Selecione Avançar: Configuração de banco de dados.
Na página Configuração do banco de dados, insira os seguintes detalhes:

Propriedade Valor

Banco de Dados de Origem DeviceData

Banco de Dados de Destino DeviceData

Taxa de Transferência (RU/s) 1000

Limpar coleções Desmarque essa caixa
Selecione Avançar: Configuração da coleção.
Na página Configuração da coleção, selecione a seta suspensa do banco de dados DeviceData, insira os seguintes detalhes:

Propriedade Valor

Nome Temperaturas

Coleção de destino Temperaturas

Taxa de Transferência (RU/s) 1000

Chave de fragmentação deviceID

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

Propriedade	Valor
Modo	Selecionar o destino do Cosmos DB
Selecionar o nome do Cosmos DB	mongodbnnn
Cadeia de conexão	Aceite a cadeia de conexão gerada para sua conta Cosmos DB

Propriedade	Valor
Banco de Dados de Origem	DeviceData
Banco de Dados de Destino	DeviceData
Taxa de Transferência (RU/s)	1000
Limpar coleções	Desmarque essa caixa

Propriedade	Valor
Nome	Temperaturas
Coleção de destino	Temperaturas
Taxa de Transferência (RU/s)	1000
Chave de fragmentação	deviceID
Exclusivo	Deixar em branco

Verifique se a migração foi bem-sucedida

No 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 de Data Explorer, expanda o banco de dados DeviceData, expanda a coleção Temperaturas e, em seguida, selecione Documentos.
No painel Documentos, percorra a lista de documentos. Você deve ver uma ID do documento (_id) e a chave de fragmentação (/deviceID) para cada documento.

Selecione qualquer documento. Você deve ver os detalhes do documento exibido. Um documento típico é semelhante a:

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

Na barra de ferramentas do painel Gerenciador de documentos, selecione Novo Shell.
No painel Shell 1, no prompt >, insira o seguinte comando e pressione Enter:
```
db.Temperatures.count()
```
Este comando exibe o número de documentos na coleção temperaturas. Ele deve corresponder ao número relatado pelo assistente de migração.
Insira o comando a seguir e pressione Enter:
```
db.Temperatures.find({deviceID: "Device 99"})
```
Este comando efetua fetch e exibe os documentos do Dispositivo 99.

Reconfigurar e executar aplicativos existentes para usar Cosmos DB

A etapa final é reconfigurar os aplicativos MongoDB existentes para se conectarem ao Cosmos DB e verificar se eles ainda funcionam. Isso exige 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 Cadeia de conexão do mongodbnnn, anote as seguintes configurações:
- Host
- Nome de Usuário
- Senha Primária
Retorne à janela de Cloud Shell (reconectar 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ódigos:
```
code App.config
```
Na seção configurações do MongoDB do arquivo, comente as configurações existentes.

Remova a marca de comentário das configurações na seção Configurações para API Mongo do Cosmos DB e defina os valores para essas configurações da seguinte maneira:

Configuração	Valor
Endereço	O HOST da página Cadeia de conexão do mongodbnnn
Porta	A PORTA da página Cadeia de conexão do mongodbnnn
Nome de Usuário	O NOME DE USUÁRIO da página Cadeia de conexão do mongodbnnn
Senha	A SENHA PRINCIPAL da página Cadeia de Conexão do mongodbnnn

O arquivo concluído será semelhante ao mostrado abaixo:

<?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 Program.cs usando o editor de Código.
```
code Program.cs
```
Role para baixo o método ConnectToDatabase.

Comente a linha que define as credenciais para se conectar ao MongoDB e remova os comentários das instruções que especificam as credenciais para se conectar ao Cosmos DB. Seu código deve ficar assim:

// 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.
Compile novamente e execute o aplicativo:
```
dotnet build
dotnet run
```
No prompt Inserir número de dispositivo, insira um valor 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 Cosmos DB.

Melhorar o desempenho de consulta no Cosmos DB

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

Alterne novamente para o portal do Azure.
No menu à esquerda, selecione Data Explorer.
No painel de Data Explorer, expanda o banco de dados DeviceData, expanda a coleção Temperaturas e, em seguida, selecione Configurações.
Selecione a Política de indexação.
Em _id adicionar um novo índice, insira deviceID para a Definição e selecione um Único Campo para o Tipo.
Selecione Salvar para adicionar o novo índice.
Retorne ao Cloud Shell para tentar a 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 Cosmos DB e reconfigurou um aplicativo MongoDB existente para se conectar ao novo banco de dados do Cosmos DB.

Limpar os recursos que você criou