Esercizio: Eseguire la migrazione di carichi di lavoro MongoDB a Cosmos DB

  • 50 minuti

Si lavora per un'azienda di utilità che dispone di sensori IoT che raccolgono i dati sulla temperatura. Le temperature vengono registrate in un database MongoDB, insieme a un timestamp. Ogni dispositivo ha un ID univoco. Si eseguirà un'applicazione MongoDB che simula questi dispositivi e archivierà i dati nel database. Si userà anche una seconda applicazione che consente a un utente di eseguire query statistiche su ogni dispositivo. Dopo la migrazione del database da MongoDB a Cosmos DB, entrambe le applicazioni verranno configurate per connettersi a Cosmos DB e verificare che funzionino ancora correttamente.

In questo esercizio si userà un database MongoDB esistente ed eseguirà la migrazione a Cosmos DB. Si userà il Servizio Migrazione del database di Azure. Si vedrà anche come riconfigurare le applicazioni esistenti che usano il database MongoDB per connettersi al database Cosmos DB.

Importante

Il Servizio Migrazione del database di Azure non è supportato nell'ambiente sandbox di Azure gratuito. È possibile eseguire questi passaggi nella propria sottoscrizione o semplicemente leggere la procedura per comprendere come eseguire la migrazione del database.

Creare un database MongoDB in Azure

Prima di tutto si creerà il database MongoDB per contenere i dati acquisiti dai dispositivi di temperatura.

Creare un gruppo di risorse e una rete virtuale

  1. Usando un Web browser, aprire una nuova scheda e passare al portale di Azure.

  2. Nel portale di Azure selezionare Gruppi di risorse e quindi +Aggiungi.

  3. Nella pagina Crea un gruppo di risorse immettere i dettagli seguenti:

    Proprietà Valore
    Abbonamento <sottoscrizione>
    Gruppo di risorse mongodbrg
    Area geografica Selezionare la posizione più vicina

  4. Selezionare Rivedi e crea e quindi Crea. Attendere la creazione del gruppo di risorse.

  5. Nel menu del portale di Azure selezionare + Crea una risorsa.

  6. Nella casella Cerca nel Marketplace della pagina Nuovo digitare Rete virtuale e premere INVIO.

  7. Nella pagina Rete virtuale selezionare Crea.

  8. Nella pagina Crea rete virtuale immettere i dettagli seguenti e quindi selezionare Avanti: Indirizzi IP:

    Proprietà Valore
    Gruppo di risorse mongodbrg
    Nome databasevnet
    Area geografica Selezionare la stessa località specificata per il gruppo di risorse

  9. Nella pagina Indirizzi IP impostare lo spazio indirizzi IPv4 su 10.0.0.0/24.

  10. Selezionare la subnet predefinita e quindi selezionare Rimuovi subnet.

  11. Selezionare + Aggiungi subnet. Nel riquadro Aggiungi subnet impostare il nome subnet su predefinito, impostare l'intervallo di indirizzi subnetsu 10.0.0.0/28 e quindi selezionare Aggiungi.

  12. Nella pagina Indirizzi IP selezionare Avanti: Sicurezza.

  13. Nella pagina Sicurezza verificare che Protezione di rete DDoS di Azure sia impostata su Disabilita e Firewall sia impostato su Disabilita. Selezionare Rivedi e crea.

  14. Nella pagina Crea rete virtuale, selezionare Crea. Attendere la creazione della rete virtuale prima di continuare.

Creare un server di database MongoDB

  1. Nel menu del portale di Azure selezionare + Crea una risorsa.

  2. Nella casella Cerca nel Marketplace digitare Ubuntu e quindi premere INVIO.

  3. Nella pagina Marketplace selezionare Ubuntu Server 18.04 LTS.

  4. Nella pagina Ubuntu Server 18.04 LTS selezionare Crea.

  5. Nella pagina Crea una macchina virtuale immettere i dettagli seguenti:

    Proprietà Valore
    Gruppo di risorse mongodbrg
    Nome della macchina virtuale mongodbserver
    Area geografica Selezionare la stessa località specificata per il gruppo di risorse
    Opzioni di disponibilità La ridondanza dell'infrastruttura non è richiesta
    Immagine Ubuntu Server 18.04 LTS - Gen1
    Istanza Spot di Azure Deselezionata
    Misura Standard A1_v2
    Tipo di autenticazione Parola chiave
    Nome utente azureuser
    Parola chiave Pa55w.rdPa55w.rd
    Conferma la password Pa55w.rdPa55w.rd
    Porte di ingresso pubbliche Consenti porte selezionate
    Selezionare le porte in ingresso SSH (22)

  6. Selezionare Avanti: Dischi >.

  7. Nella pagina Dischi lasciare le impostazioni predefinite e quindi selezionare Avanti: Rete >.

  8. Nella pagina Rete immettere i dettagli seguenti:

    Proprietà Valore
    Rete virtuale databasevnet
    Subnet predefinito (10.0.0.0/28)
    IP pubblico (nuovo) mongodbserver-ip
    Gruppo di sicurezza della rete NIC Avanzato
    Configura gruppo di sicurezza di rete (nuovo) mongodbserver-nsg
    Rete accelerata Deselezionata
    Bilanciamento del carico Deselezionata

  9. Selezionare Rivedi e crea >.

  10. Nella pagina di convalida selezionare Crea.

  11. Attendere la distribuzione della macchina virtuale prima di continuare

  12. Nel menu del portale di Azure selezionare Tutte le risorse.

  13. Nella pagina Tutte le risorse selezionare mongodbserver-nsg.

  14. Nella pagina mongodbserver-nsg , in Impostazioni selezionare Regole di sicurezza in ingresso.

  15. Nella pagina mongodbserver-nsg - Regole di sicurezza in ingresso selezionare + Aggiungi.

  16. Nel riquadro Aggiungi regola di sicurezza in ingresso immettere i dettagli seguenti:

    Proprietà Valore
    Fonte Qualunque
    Intervalli di porte sorgente *
    Destinazione Qualunque
    Intervalli di porte di destinazione 8080
    Protocollo Qualunque
    Azione Consentire
    Priorità 1030
    Nome Porta Mongodb
    Descrizione Porta usata dai client per connettersi a MongoDB

  17. Seleziona Aggiungi.

Annotazioni

In questo esercizio si configurerà MongoDB per l'uso della porta 8080. Questa operazione deve essere eseguita solo a causa di vincoli di sicurezza in questo ambiente. In genere si usa la porta MongoDB predefinita 27017.

Installare MongoDB

  1. Nel menu del portale di Azure selezionare Tutte le risorse.

  2. Nella pagina Tutte le risorse selezionare mongodbserver-ip.

  3. Nella pagina mongodbserver-ip prendere nota dell'indirizzo IP.

  4. Nella barra degli strumenti nella parte superiore del portale di Azure selezionare Cloud Shell.

  5. Se viene visualizzata la finestra di messaggio Non è stata montata alcuna risorsa di archiviazione , selezionare Crea archiviazione.

  6. All'avvio di Cloud Shell, nell'elenco a discesa sopra la finestra di Cloud Shell selezionare Bash.

  7. In Cloud Shell immettere il comando seguente per connettersi alla macchina virtuale mongodbserver. Sostituire <l'indirizzo> IP con il valore dell'indirizzo IP mongodbserver-ip:

    ssh azureuser@<ip address>

  8. Al prompt digitare sì per continuare la connessione.

  9. Immettere la password Pa55w.rdPa55w.rd.

  10. Per ricaricare il database del pacchetto, immettere questo comando:

    sudo apt-get update

  11. Per installare MongoDB, immettere questo comando:

    sudo apt-get install -y mongodb

    L'installazione deve procedere con i messaggi relativi all'installazione, alla preparazione e alla decompressione dei pacchetti. Il completamento dell'installazione può richiedere alcuni minuti.

Configurare il database MongoDB

Per impostazione predefinita, l'istanza di Mongo DB è configurata per l'esecuzione senza autenticazione. In questa attività si configurerà MongoDB per l'associazione all'interfaccia di rete locale in modo che possa accettare connessioni da altri computer. Si abiliterà anche l'autenticazione e si creerà l'account utente necessario per eseguire la migrazione. Infine, si aggiungerà un account che un'applicazione di test può usare per eseguire query sul database.

  1. Per aprire il file di configurazione di MongoDB, eseguire questo comando:

    sudo nano /etc/mongodb.conf

  2. Nel file individuare l'impostazione bind_ip e impostarla su 0.0.0.0.0.

  3. Individuare l'impostazione della porta e impostarla su 8080.

  4. Per salvare il file di configurazione, premere ESC e quindi premere CTRL+X. Premere y e quindi INVIO per salvare il buffer modificato.

  5. Per riavviare il servizio MongoDB e applicare le modifiche, immettere questo comando:

    sudo service mongodb restart

  6. Per connettersi al servizio MongoDB, immettere questo comando:

    mongo --host 127.0.0.1:8080

  7. > Al prompt, per passare al database di amministrazione, eseguire questo comando:

    use admin;

  8. Per creare un nuovo utente denominato administrator, eseguire il comando seguente. È possibile immettere il comando su una riga o su più righe per migliorare la leggibilità. Il comando viene eseguito quando il mongo programma raggiunge il punto e virgola:

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

  9. Per uscire dal mongo programma, immettere questo comando;

    exit;

  10. Per connettersi a MongoDB con l'account del nuovo amministratore, eseguire questo comando:

    mongo admin -u "administrator" -p "Pa55w.rd" --host 127.0.0.1:8080

  11. Per passare al database DeviceData , eseguire questo comando:

    use DeviceData;

  12. Per creare un utente denominato deviceadmin, che verrà usato dall'app per connettersi al database, eseguire questo comando:

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

  13. Per uscire dal mongo programma, immettere questo comando;

    exit;

  14. Eseguire il comando seguente per riavviare il servizio mongodb. Verificare che il servizio venga riavviato senza messaggi di errore:

    sudo service mongodb restart

  15. Eseguire il comando seguente per verificare che sia ora possibile accedere a mongodb come utente deviceadmin:

    mongo DeviceData -u "deviceadmin" -p "Pa55w.rd" --host 127.0.0.1:8080

  16. > Al prompt eseguire il comando seguente per uscire dalla shell mongo:

    exit;

  17. Al prompt di bash eseguire il comando seguente per disconnettersi dal server MongoDB e tornare a Cloud Shell:

    exit

Popolare ed eseguire query sul database MongoDB

È stato creato un server e un database MongoDB. Il passaggio successivo consiste nel illustrare le applicazioni di esempio che possono popolare ed eseguire query sui dati in questo database.

Compilare ed eseguire un'app per popolare il database MongoDB

  1. In Azure Cloud Shell eseguire il comando seguente per scaricare il codice di esempio:

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

  2. Passare alla cartella migration-workshop-apps/MongoDeviceDataCapture/MongoDeviceCapture :

    cd ~/migration-workshop-apps/MongoDeviceDataCapture/MongoDeviceDataCapture

  3. Usare l'editor di codice per esaminare il file TemperatureDevice.cs :

    code TemperatureDevice.cs

    Il codice in questo file contiene una classe denominata TemperatureDevice che simula un dispositivo di temperatura che acquisisce i dati e lo salva in un database MongoDB. Usa la libreria MongoDB per .NET Framework. Il costruttore TemperatureDevice si connette al database usando le impostazioni archiviate nel file di configurazione dell'applicazione. Il metodo RecordTemperatures genera una lettura e la scrive nel database.

  4. Chiudere l'editor di codice e quindi aprire il file ThermometerReading.cs :

    code ThermometerReading.cs

    Questo file mostra la struttura dei documenti archiviati dall'applicazione nel database. Ogni documento contiene i campi seguenti:

    • ID oggetto. è il campo "_id" generato da MongoDB per identificare in modo univoco ogni documento.
    • ID dispositivo. Ogni dispositivo ha un numero con il prefisso "Device".
    • Temperatura registrata dal dispositivo.
    • Data e ora in cui è stata registrata la temperatura.

  5. Chiudere l'editor di codice e quindi aprire il file App.config :

    code App.config

    Questo file contiene le impostazioni per la connessione al database MongoDB.

  6. Impostare il valore per la chiave di indirizzo sull'indirizzo IP del server MongoDB registrato in precedenza.

  7. Modificare la porta usata dall'app in 8080.

  8. Salvare il file e chiudere l'editor usando CTRL + s, quindi CTRL + Q.

  9. Eseguire il comando seguente per ricompilare l'applicazione:

    dotnet build

    Questa operazione può richiedere circa 5 minuti.

  10. Eseguire l'applicazione:

    dotnet run

    L'applicazione simula 100 dispositivi in esecuzione contemporaneamente. Consentire l'esecuzione dell'applicazione per un paio di minuti e quindi premere INVIO per arrestarla.

Compilare ed eseguire un'altra app per eseguire query sul database MongoDB

  1. Passare alla cartella DP160T00A-Migrateing-your-Database-to-Cosmos-DB/MongoDeviceDataCapture/DeviceDataQuery :

    cd ~/migration-workshop-apps/MongoDeviceDataCapture/DeviceDataQuery

    Questa cartella contiene un'altra applicazione che è possibile usare per analizzare i dati acquisiti da ogni dispositivo.

  2. Usare l'editor di codice per esaminare il file Program.cs :

    code Program.cs

    L'applicazione si connette al database (usando il metodo ConnectToDatabase nella parte inferiore del file) e quindi richiede all'utente un numero di dispositivo. L'applicazione usa la libreria MongoDB per .NET Framework per creare ed eseguire una pipeline di aggregazione che calcola le statistiche seguenti per il dispositivo specificato:

    • Numero di letture registrate.
    • Temperatura media registrata.
    • La lettura più bassa.
    • La lettura più alta.
    • La lettura più recente.

  3. Chiudere l'editor di codice e quindi aprire il file App.config :

    code App.config

  4. Impostare il valore per la chiave di indirizzo sull'indirizzo IP del server MongoDB registrato in precedenza.

  5. Modificare la porta usata dall'app in 8080.

  6. Salvare il file e chiudere l'editor usando CTRL + s, quindi CTRL + Q.

  7. Compilare ed eseguire l'applicazione:

    dotnet build
dotnet run

  8. Al prompt Enter Device Number (Immetti numero dispositivo ) immettere un valore compreso tra 0 e 99. L'applicazione eseguirà query sul database, calcolerà le statistiche e visualizzerà i risultati. Premere Q per chiudere l'applicazione.

Eseguire la migrazione del database MongoDB a Cosmos DB

Il passaggio successivo consiste nell'eseguire il database MongoDB e trasferirlo in Cosmos DB.

Creare un account e un database Cosmos

  1. Tornare al portale di Azure.

  2. Nel menu selezionare + Crea una risorsa.

  3. Nella casella Cerca nel Marketplace della pagina Nuovo digitare *Azure Cosmos DB, quindi premere INVIO.

  4. Nella pagina Azure Cosmos DB selezionare Crea.

  5. Nella pagina Crea account Azure Cosmos DB immettere le impostazioni seguenti:

    Proprietà Valore
    Gruppo di risorse mongodbrg
    Nome dell'account mongodb*nnn*, dove nnn è un numero casuale selezionato dall'utente
    API (Interfaccia di Programmazione delle Applicazioni) API Azure Cosmos DB per MongoDB
    Taccuini Disattivato
    Posizione Specificare la stessa posizione usata per il server MongoDB e la rete virtuale
    Modalità di capacità Provisioning velocità effettiva
    Applica sconto per il livello gratuito Applica
    Tipo di conto Non produzione
    Versione 3.6
    Ridondanza geografica Disabilitare
    Scritture in più aree Disabilitare
    Zone di disponibilità Disabilitare

  6. Selezionare Rivedi e crea.

  7. Nella pagina di convalida selezionare Crea e attendere la distribuzione dell'account Cosmos DB.

  8. Nel menu del portale di Azure selezionare Tutte le risorse e quindi selezionare il nuovo account Cosmos DB (mongodbnnn).

  9. Nella pagina mongodb nnn selezionare Esplora dati.

  10. Nel riquadro Esplora dati selezionare Nuova raccolta.

  11. Nel riquadro Aggiungi raccolta specificare le impostazioni seguenti:

    Proprietà Valore
    ID del database Selezionare Crea nuovo e quindi digitare DeviceData
    Effettuare il provisioning della velocità effettiva del database selezionato
    Capacità di produzione 10000
    ID di raccolta Temperature
    Capacità di archiviazione Illimitato
    Chiave di partizione deviceID
    La chiave di partizione è maggiore di 100 byte lasciare deselezionata
    Creare un indice con caratteri jolly in tutti i campi lasciare deselezionata
    Archivio analitico Disattivato

  12. Seleziona OK.

Creare il Servizio Migrazione del database

  1. Tornare al portale di Azure.

  2. Fare clic su Tutti i servizi, fare clic su Sottoscrizioni e quindi fare clic sulla sottoscrizione.

  3. Nella pagina della sottoscrizione, in Impostazioni, fare clic su Provider di risorse.

  4. Nella casella Filtra per nome digitare DataMigration e quindi fare clic su Microsoft.DataMigration.

  5. Se Microsoft.DataMigration non è registrato, fare clic su Registra e attendere che lo stato cambi in Registrato. Potrebbe essere necessario fare clic su Aggiorna per visualizzare la modifica dello stato.

  6. Nel menu del portale di Azure selezionare + Crea una risorsa.

  7. Nella casella Cerca nel Marketplace della pagina Nuovo digitare Servizio Migrazione del database di Azure e quindi premere INVIO.

  8. Nella pagina Servizio Migrazione del database di Azure selezionare Crea.

  9. Nella pagina Crea servizio migrazione immettere le impostazioni seguenti:

    Proprietà Valore
    Gruppo di risorse mongodbrg
    Nome servizio MongoDBMigration
    Posizione Selezionare la stessa posizione usata in precedenza
    Modalità di servizio Azure
    Livello tariffario Standard: 1 vCore

  10. Selezionare Avanti: Rete.

  11. Nella pagina Rete selezionare databasevnet/default, quindi selezionare Rivedi e crea.

  12. Selezionare Crea e attendere che il servizio venga distribuito prima di continuare. Questa operazione può richiedere circa 10 minuti.

Creare ed eseguire un nuovo progetto di migrazione

  1. Nel menu del portale di Azure selezionare Gruppi di risorse.

  2. Nella finestra Gruppi di risorse selezionare mongodbrg.

  3. Nella finestra mongodbrg selezionare MongoDBMigration.

  4. Nella pagina MongoDBMigration selezionare + Nuovo progetto di migrazione.

  5. Nella pagina Nuovo progetto di migrazione immettere le impostazioni seguenti:

    Proprietà Valore
    Nome progetto MigrateTemperatureData
    Tipo del server di origine MongoDB
    Tipo di server di destinazione Cosmos DB (API MongoDB)
    Scegli il tipo di attività Migrazione dei dati offline

  6. Selezionare Crea ed esegui attività.

  7. All'avvio della Migrazione guidata immettere i dettagli seguenti nella pagina Dettagli origine :

    Proprietà Valore
    Modalità Modalità Standard
    Nome del server di origine Specificare il valore dell'indirizzo IP mongodbserver-ip registrato in precedenza
    Porta server 8080
    Nome utente amministratore
    Parola chiave Pa55w.rd
    Richiesta SSL de-selected

  8. Selezionare Avanti: Selezionare la destinazione.

  9. Nella pagina Seleziona destinazione immettere i dettagli seguenti:

    Proprietà Valore
    Modalità Selezionare la destinazione Cosmos DB
    Selezionare Comos DB name (Nome database Comos) mongodb*nnn*
    stringa di connessione Accettare la stringa di connessione generata per l'account Cosmos DB

  10. Selezionare Avanti: Impostazione database.

  11. Nella pagina Impostazione database immettere i dettagli seguenti:

    Proprietà Valore
    Database di origine DeviceData
    Database di destinazione DeviceData
    Velocità effettiva (UR/sec) 1000
    Pulire le raccolte Deselezionare questa casella

  12. Selezionare Avanti: impostazione raccolta.

  13. Nella pagina Impostazione raccolta selezionare la freccia a discesa in base al database DeviceData, immettere i dettagli seguenti:

    Proprietà Valore
    Nome Temperature
    Raccolta di destinazione Temperature
    Velocità effettiva (UR/sec) 1000
    Chiave di partizione deviceID
    Unico Lasciare vuoto

  14. Selezionare Avanti: Riepilogo della migrazione.

  15. Nella pagina Riepilogo migrazione immettere mongodb-migration nel campo Nome attività e quindi selezionare Avvia migrazione.

  16. Nella pagina mongodb-migration selezionare Aggiorna ogni 30 secondi fino al completamento della migrazione. Si noti il numero di documenti elaborati.

Verificare che la migrazione sia stata completata correttamente

  1. Nel menu del portale di Azure selezionare Tutte le risorse.

  2. Nella pagina Tutte le risorse selezionare mongodbnnn.

  3. Nella pagina mongodb*nnn selezionare Esplora dati.

  4. Nel riquadro Esplora dati espandere il database DeviceData , espandere la raccolta Temperature e quindi selezionare Documenti.

  5. Nel riquadro Documenti scorrere l'elenco dei documenti. Verrà visualizzato un ID documento (_id) e la chiave di partizione (/deviceID) per ogni documento.

  6. Selezionare qualsiasi documento. Verranno visualizzati i dettagli del documento. Un documento tipico è simile al seguente:

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

  7. Nella barra degli strumenti del riquadro Esplora documenti selezionare Nuova shell.

  8. Nel riquadro Shell 1 , al > prompt immettere il comando seguente e quindi premere INVIO:

    db.Temperatures.count()

    Questo comando visualizza il numero di documenti nell'insieme Temperature. Deve corrispondere al numero segnalato dalla Migrazione guidata.

  9. Immettere il comando seguente e quindi premere INVIO:

    db.Temperatures.find({deviceID: "Device 99"})

    Questo comando recupera e visualizza i documenti per Device 99.

Riconfigurare ed eseguire applicazioni esistenti per l'uso di Cosmos DB

Il passaggio finale consiste nel riconfigurare le applicazioni MongoDB esistenti per connettersi a Cosmos DB e verificare che funzionino ancora. Ciò richiede di modificare il modo in cui le applicazioni si connettono al database, ma la logica delle applicazioni deve rimanere invariata.

  1. Nel riquadro mongodb nnn, in Impostazioni selezionare Stringa di connessione.

  2. Nella pagina stringa di connessionemongodb nnn prendere nota delle impostazioni seguenti:

    • Padrone di casa / Ospitante / Conduttore (depending on the intended context)
    • Nome utente
    • Password primaria

  3. Tornare alla finestra di Cloud Shell (riconnettersi se la sessione è scaduta) e passare alla cartella migration-workshop-apps/MongoDeviceDataCapture/DeviceDataQuery :

    cd ~/migration-workshop-apps/MongoDeviceDataCapture/DeviceDataQuery

  4. Aprire il file App.config nell'editor di codice:

    code App.config

  5. Nella sezione Impostazioni per MongoDB del file impostare come commento le impostazioni esistenti.

  6. Rimuovere il commento dalle impostazioni nella sezione Impostazioni per l'API Mongo di Cosmos DB e impostare i valori per queste impostazioni come indicato di seguito:

    Impostazione Valore
    Indirizzo HOST dalla pagina mongodb nnn Connection String (Stringa di connessionemongodb nnn)
    Porto PORTA dalla pagina stringa di connessionemongodb nnn
    Nome utente NOME UTENTE dalla pagina mongodb nnn Connection String (Stringa di connessionemongodb nnn)
    Parola chiave LA PASSWORD PRIMARIA dalla pagina stringa di connessionemongodb nnn

    Il file completato dovrebbe essere simile al seguente:

    <?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>

  7. Salvare il file e quindi chiudere l'editor di codice.

  8. Aprire il file Program.cs usando l'editor di codice:

    code Program.cs

  9. Scorrere verso il basso fino al metodo ConnectToDatabase .

  10. Impostare come commento la riga che imposta le credenziali per la connessione a MongoDB e rimuovere il commento dalle istruzioni che specificano le credenziali per la connessione a Cosmos DB. Il codice dovrebbe essere simile al seguente:

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

    Queste modifiche sono necessarie perché il database MongoDB originale non usava una connessione SSL. Cosmos DB usa sempre SSL.

  11. Salvare il file e quindi chiudere l'editor di codice.

  12. Ricompilare ed eseguire l'applicazione:

    dotnet build
dotnet run

  13. Al prompt Enter Device Number (Immetti numero dispositivo ) immettere un numero di dispositivo compreso tra 0 e 99. L'applicazione deve essere eseguita esattamente come in precedenza, tranne questa volta che usa i dati contenuti nel database Cosmos DB.

Migliorare le prestazioni delle query in Cosmos DB

Cosmos DB consente di aggiungere altri indici per migliorare le prestazioni delle query. Poiché l'aggregazione su deviceID aggiunge tale campo come indice velocizza le query.

  1. Tornare al portale di Azure.

  2. A sinistra selezionare Esplora dati.

  3. Nel riquadro Esplora dati espandere il database DeviceData , espandere la raccolta Temperature e quindi selezionare Impostazioni.

    Screenshot che mostra l'aggiunta di un criterio di indicizzazione di Cosmos DB.

  4. Selezionare Criteri di indicizzazione.

  5. In _id aggiungere un nuovo indice immettere deviceID per definizione e selezionare Campo singolo per Tipo.

  6. Selezionare Salva per aggiungere il nuovo indice.

  7. Tornare a Cloud Shell per ritentare la query e prendere nota della risposta migliorata nell'applicazione.

  8. Testare l'applicazione con altri numeri di dispositivo. Immettere Q per terminare.

È stata eseguita la migrazione di un database MongoDB a Cosmos DB ed è stata riconfigurata un'applicazione MongoDB esistente per connettersi al nuovo database Cosmos DB.

Eseguire la pulizia delle risorse create

Importante

Se questi passaggi sono stati eseguiti nella sottoscrizione personale, è possibile eliminare le singole risorse oppure il gruppo, per rimuovere l'intero set di risorse. Le risorse lasciate in funzione possono costarti denaro.

  1. Usando Cloud Shell, eseguire il comando seguente per eliminare il gruppo di risorse:

    az group delete --name mongodbrg