Le 25 migliori domande e risposte su MongoDB per i colloqui nel 2026

Domande base su MongoDB per i colloqui

In questa sezione ci concentreremo sulle domande fondamentali spesso poste nei colloqui su MongoDB.

Spiega il formato di archiviazione BSON.

BSON sta per Binary JavaScript Object Notation. Memorizza documenti JSON serializzati in un formato codificato binario ed estende le capacità di JSON supportando tipi di dati aggiuntivi come Date, ObjectId ed espressioni regolari. 

Un documento BSON in genere contiene tre componenti: la dimensione del documento, gli elementi di campo (come tipo di dato, nome e valore) e un terminatore nullo, tutti codificati in formato binario.

La seguente tabella illustra le differenze tra BSON e JSON, soprattutto poiché BSON estende le funzionalità di JSON:

Che cos'è una collezione in MongoDB?

Una collezione MongoDB è un gruppo di documenti archiviati in un unico database. È simile a una tabella in un database relazionale, dove ogni documento in una collezione rappresenta una riga in una tabella. Tuttavia, la collezione non ha uno schema fisso, il che significa che i documenti all'interno di una collezione possono avere tipi di dati diversi. 

Come si interroga un documento in MongoDB?

In MongoDB puoi interrogare i documenti usando il metodo find(). Per interrogare tutti i documenti in una collezione, usa db.collection_name.find(). Il metodo find ha due parametri di input: query e projection. Il parametro query viene usato per filtrare i documenti che corrispondono a una condizione specifica. 

Sintassi per il parametro query:

db.collection_name.find({condition}) 

Il secondo è un parametro di proiezione che indica le colonne da includere o escludere nell'output. Assegna 1 alle colonne che vuoi recuperare. Ecco la sintassi:

db.collection_name.find({},{column1: 1, column2: 1})

Qual è la differenza tra find() e findOne()?

Il metodo find() restituisce un cursore a più documenti che corrispondono ai criteri della query. Funziona iterando su tutti i risultati e recuperando i documenti corrispondenti. Il metodo findOne(), invece, restituisce il primo documento corrispondente.

Che cos'è il campo _id in MongoDB?

Ogni documento archiviato in una collezione richiede un identificatore univoco. Questo campo _id funge da chiave primaria per identificare in modo univoco i documenti in una collezione. 

Domande intermedie su MongoDB per i colloqui

Ora passiamo ad alcuni concetti chiave di MongoDB che l'intervistatore potrebbe aspettarsi che tu conosca. 

Come archivia MongoDB immagini e video di grandi dimensioni?

Tradizionalmente, MongoDB non consente l'archiviazione di documenti più grandi di 16 MB. Tuttavia, ha una specifica speciale chiamata GridFS per archiviare e recuperare file superiori a 16 MB. Divide il file in blocchi più piccoli e uguali e li archivia internamente come documenti separati. 

La tabella seguente riassume come MongoDB archivia file di grandi dimensioni usando GridFS:

Come garantisce MongoDB l'alta disponibilità?

MongoDB raggiunge l'alta disponibilità tramite la replica. I replica set memorizzano copie diverse dei dati sui nodi, così che se un nodo fallisce, un altro possa subentrare.

Che cos'è lo sharding in MongoDB?

Lo sharding abilita lo scaling orizzontale in MongoDB. Quando una singola istanza non riesce a gestire un dataset di grandi dimensioni, MongoDB divide i dati in chunk più piccoli e li distribuisce su più server, noti come shard. 

La tabella seguente chiarisce le differenze tra replica e sharding:

Che cos'è un replica set in MongoDB?

Un replica set in MongoDB è un gruppo di istanze che mantengono lo stesso dataset. Vengono distribuiti in applicazioni che richiedono alta disponibilità perché, se un'istanza ha problemi, il sistema passa automaticamente al nodo successivo disponibile nel replica set. 

Spiega il concetto di aggregazione in MongoDB.

MongoDB aggrega i dati da più documenti e li elabora per restituire un risultato unico. Ciò avviene tramite una pipeline di aggregazione, in cui i documenti passano attraverso più stadi: l'output di ogni stadio diventa l'input per il successivo. Una pipeline tipica potrebbe includere stadi come match, group e sort:

• Match: filtra i documenti in base ai criteri forniti.
• Group: esegue l'operazione di aggregazione.
• Sort: ordina i risultati finali nel modo desiderato. 

Che cos'è una collezione capped in MongoDB? 

Una collezione capped ha una dimensione fissa e un limite per il numero di documenti. Quando si raggiunge il limite, sovrascrive automaticamente il documento più vecchio e memorizza le informazioni più recenti. Questo concetto la rende adatta a casi d'uso come logging e caching. 

Domande avanzate su MongoDB per i colloqui

In questa sezione esaminiamo alcune popolari domande e risposte avanzate su MongoDB.

MongoDB supporta le transazioni ACID?

Fino alla versione 4.0, MongoDB supportava transazioni ACID solo per singoli documenti. Con le transazioni ACID multi-documento, gli sviluppatori possono ora garantire le proprietà ACID su più documenti all'interno di una collezione. 

Che cos'è il map-reduce in MongoDB?

Il map-reduce è un paradigma di elaborazione dei dati che esegue operazioni su grandi dataset e produce risultati aggregati. MongoDB offre una funzione integrata mapReduce() composta da due fasi: map e reduce. 

Durante la fase di map, la funzione elabora ogni documento nella collezione e genera coppie chiave-valore. Queste coppie chiave-valore vengono aggregate nella fase di reduce, dove vengono eseguite le operazioni. 

Per esempio, se hai una collezione di documenti di testo, la funzione map convertirebbe ogni parola in una chiave e le assegnerebbe un valore pari a 1. La funzione reduce quindi somma i valori di ciascuna chiave per contare le occorrenze di ogni parola nell'intera collezione.

Spiega gli indici TTL in MongoDB.

I dati generati dovrebbero essere rivisti costantemente e rimossi quando non sono più necessari; altrimenti, finirai le risorse per accogliere le informazioni più recenti. 

MongoDB fornisce indici Time-to-Live (TTL), che semplificano l'eliminazione dei documenti scaduti. Tutto ciò che devi fare è specificare per quanto tempo un documento deve essere conservato e TTL lo rimuoverà automaticamente una volta trascorso il periodo di tempo specificato.

La seguente tabella spiega i tipi di indici disponibili in MongoDB e i loro casi d'uso:

MongoDB offre funzionalità di backup e ripristino?

MongoDB consente il backup dei dati tramite l'utility mongodump. Questo strumento crea backup binari dei tuoi dati, che puoi importare quando necessario. Un'altra opzione è usare soluzioni cloud di terze parti o MongoDB Atlas(servizio cloud) per automatizzare il processo di backup. 

MongoDB fornisce l'utility mongorestore per importare i dati dai file BSON di backup. Inoltre, soluzioni cloud di terze parti offrono funzionalità di ripristino automatico, riducendo al minimo i tempi di inattività. 

Come puoi ottimizzare le query MongoDB?

Ecco alcune soluzioni applicabili per ottimizzare le tue query MongoDB:

• Gli indici memorizzano informazioni sui documenti, aiutando a trovare rapidamente i dati giusti. Quindi, creare indici può migliorare le prestazioni delle query.
• Se sai quali colonne ti servono, usa i metodi di proiezione per restituire solo quei campi e migliorare le prestazioni.
• Evita operazioni costose come le espressioni regolari; usa invece ricerche per prefisso o campi indicizzati.
• Scegli la chiave di shard giusta, soprattutto quando lavori con carichi prevalentemente di lettura.

Spiega il journaling in MongoDB.

Quando viene eseguita un'operazione di scrittura, MongoDB la registra nei file di journal prima che venga incisa nei file del database. Questi log garantiscono che le operazioni di scrittura confermate possano essere recuperate rapidamente in caso di guasti o arresti anomali del sistema. 

Domande di programmazione su MongoDB per i colloqui

Le domande di programmazione nei colloqui spesso si concentrano sulla tua capacità di implementare concetti di MongoDB tramite il codice. Mettono alla prova la tua sintassi, le pratiche di codifica e l'efficienza con cui sai usare strumenti e funzioni di MongoDB. 

Come creare un indice in MongoDB?

MongoDB ha una funzione createIndex() per creare vari tipi di indici, come indici su singolo campo, indici di testo e indici 2D. Il metodo ha due parametri di input: le chiavi che definiscono le colonne da indicizzare e altre opzioni.

Sintassi:

db.collection.createIndex(keys, options)

• Keys: { field1: 1, field2: -1, ... }, 1 per ordine crescente e -1 per ordine decrescente
• Options: {unique: true}, {sparse: true}, { expireAfterSeconds: 3600 }

Esempio:

db.users.createIndex({ email: 1 }, { unique: true });

Come implementare l'aggregazione in MongoDB?

L'aggregazione contiene tipicamente tre stadi: match, group e sort. Vediamo come possiamo implementarli nel codice.

Esempio di documento “products”:

[
  { "_id": 1, "product_id": "t2409", "amount": $250, "status": "done" },
  { "_id": 2, "product_id": "t2009", "amount": $300, "status": "done" },
  { "_id": 3, "product_id": "t1309", "amount": $150, "status": "pending" },
  { "_id": 4, "product_id": "t1919", "amount": $480, "status": "done" },
  { "_id": 5, "product_id": "t5459", "amount": $120, "status": "pending" },
  { "_id": 6, "product_id": "t3829", "amount": $280, "status": "done" }
]

• $match: per filtrare i documenti in base a una condizione
• $group: raggruppa i dati e applica l'operazione di aggregazione
• $sort: ordina i documenti di output come necessario

Esempio:

db.products.aggregate([
  { $match: { status: "completed" } },
  { $group: { _id: "$product_id", totalAmount: { $sum: "$amount" },
  { $sort
]);

Come esegui l'equivalente di una join SQL in MongoDB?

MongoDB fornisce operatori di aggregazione come $lookup per eseguire join equivalenti a SQL.

Sintassi:

db.collection_1_name.aggregate([
  {
    $lookup: {
      from: "collection_2_name",  // The other collection to join with
      localField: "field_in_collection_1", // The field on which you want to join
      foreignField: "field_in_collection_2", // The field from the second collection you want to perform join operation
      as: "result_field" // The name of the new field to store the joined result
    }
  }
])

Esempio: 

Supponi di avere collezioni di ordini e prodotti con i seguenti dati:

Collezione “Orders”:

[
  { "_id": 1, "product_id": 101, "order_amount": 250 },
  { "_id": 2, "product_id": 102, "order_amount": 300 },
  { "_id": 3, "product_id": 101, "order_amount": 150 }
]

Collezione “Products”:

[
   { "_id": 3789, "product_id": 102, "product_price": $100},
   { "_id": 3970, "product_id": 103, "product_price": $297},
   { "_id": 3509, "product_id": 101, "product_price": $300},
]

Operazione di join:

db.orders.aggregate([
  {
    $lookup: {
      from: "products",              
      localField: "customer_id",       
      foreignField: "_id",             
      as: "customer_info"             
    }
  }
])

Come modelli una relazione one-to-many in MongoDB?

Puoi creare un modello di dati che utilizza documenti incorporati per descrivere una relazione uno-a-molti. Per esempio, un singolo team può avere più dipendenti, quindi puoi incorporarli come segue:

Dati:

// team details
{
    _id: "Datascience"
   company_name: "DataCamp"
   team_name: "Data leaders"
}

// employee one
{
   name: "John"
   employee_id: "t009456"
email: johnsmith@datacamp.com
}
// employee two
{
  name: "Emily"
  employee_id: "t8068ms"
  email: emilyjones@datacamp.com
}

Documento incorporato one-to-many:

{
    "_id": "Datascience",
    "company_name": "DataCamp",
    "team_name": "Data leaders",
    "employees": [
        {
            "name": "John",
            "employee_id": "t009456",
            "email": "johnsmith@datacamp.com"
        },
        {
            "name": "Emily",
            "employee_id": "t8068ms",
            "email": "emilyjones@datacamp.com"
        }
    ]
}

Domande da colloquio su scenari MongoDB per DBA

Gli intervistatori ti porranno in situazioni impegnative e valuteranno come le affronteresti. Questo li aiuta a capire la tua capacità di gestire problemi in tempo reale mentre lavori con MongoDB. 

Immagina di eseguire un'operazione di ricerca sul database “orders” come segue. Come effettui il debug del motivo per cui la query è lenta?

df.orders.find({
	customer_id: 'yop89'
	ordered_items: {
		product_id: 'toi45'
		product_id: 'tac87'
	}
});

Per prima cosa, dovresti impostare il livello di profiling a 1 per selezionare solo le query lente:

db.setProfilingLevel(1, { slowms: 100 }); // Logs queries slower than 100ms

Ora, il seguente codice ci fornisce dettagli extra come il tipo di operazione, il tempo impiegato e le chiavi o i documenti scansionati. Queste informazioni aiutano a trovare le query lente:

db.system.profile.find({ millis: { $gt: 100 } }).sort({ millis: -1 }).limit(10);

Nello scenario sopra, come migliori le prestazioni delle query lente?

Dall'output del codice precedente, se la query scansiona l'intera collezione, crea indici su customer_id e ordered_items. Gli indici possono ridurre il numero di documenti scansionati, migliorando i tempi di esecuzione della query.

db.orders.createIndex({ customer_id: 1, "ordered_items.product_id": 1});

Nel caso di sharding, se uno shard è sovraccarico e gli altri restano inattivi, come bilanci questo?

Due potenziali problemi potrebbero essere la selezione inappropriata della chiave di shard e una distribuzione dei dati non uniforme tra gli shard.

Soluzione 1: scegli la chiave di shard giusta

• Scegli colonne ad alta cardinalità come chiavi di shard. Cioè, una chiave di shard dovrebbe avere molti valori univoci.
• Se il tuo carico è principalmente di scrittura, assicurati che la chiave di shard non indirizzi tutte le scritture a un singolo shard.
• Scegli una chiave di shard che sia allineata con le tue query più frequenti. Per esempio, se le tue query spesso effettuano join su un campo specifico, quel campo potrebbe essere una chiave di shard efficace.

Soluzione 2: riequilibra la distribuzione non uniforme

Il comando seguente fornisce una panoramica dei dati distribuiti tra gli shard. Se i chunk non sono ben distribuiti, abilita il balancer.

sh.status()

Il comando seguente ottiene lo stato del balancer. Se è disabilitato, usa il comando successivo per abilitarlo.

sh.getBalancerState()
sh.enableBalancing("db_name.collection_name")

Quali sfide potresti affrontare durante la migrazione da RDBMS a MongoDB?

Mappare le operazioni dei database relazionali ai loro corrispettivi in NoSQL può essere complesso.

• Per esempio, le join SQL non sono immediate in MongoDB; devi invece usare il framework di aggregazione per ottenere funzionalità simili.
• Un'altra sfida è che i dati archiviati in tabelle strutturate richiederanno trasformazioni per adattarsi al formato di archiviazione BSON di MongoDB. 
• Inoltre, mentre gli RDBMS offrono una solida conformità ACID, MongoDB fornisce proprietà ACID a livello di documento, il che significa che transazioni ACID complesse possono richiedere un'attenzione extra.

Consigli per prepararti a un colloquio su MongoDB

Superare un colloquio su MongoDB richiede una profonda comprensione dei concetti e una pratica esperta sull'argomento. È essenziale potenziare le tue conoscenze sui database NoSQL, padroneggiare la sintassi di MongoDB, ed essere esposto a molteplici scenari di guasto in MongoDB imparando a risolverli. 

Ecco i miei migliori consigli per aiutarti a superare il prossimo colloquio su MongoDB:

• Solide basi: che tu stia puntando a un ruolo entry-level o a una posizione senior, le basi vengono sempre testate. Quindi, comprendi l'architettura di MongoDB, il tipo di archiviazione, la sintassi e le operazioni supportate. 
• Argomenti avanzati: dovresti conoscere come funzionano in MongoDB concetti avanzati come replica, aggregazione, sharding e indicizzazione ed essere in grado di implementarli se necessario.
• Scenari reali: gli intervistatori spesso testano come gestisci i database MongoDB in vari scenari sul posto di lavoro. Per esempio, potresti essere chiamato a spiegare come migrare un database RDBMS esistente a MongoDB. Nei colloqui più avanzati, potresti ricevere uno scenario e dover scrivere codice per affrontarlo.
• Leggi esperienze passate: informarti sulle esperienze di colloquio precedenti in azienda ti dà un'idea del tipo di domande da aspettarti e dei loro schemi di intervista, permettendoti di prepararti di conseguenza. Personalmente uso piattaforme come Glassdoor, Blind, YouTube e LinkedIn per le esperienze di colloquio precedenti.
• Mock interview: le simulazioni di colloquio ti aiutano a valutare punti di forza e debolezze. Ti preparano anche all'ambiente del colloquio, aiutandoti a sentirti sicuro e a tuo agio durante quello reale. 
• Soft skill: la capacità di comunicare argomenti complessi è essenziale per impressionare l'intervistatore. Quindi, lavora sulle tue abilità di comunicazione e presentazione.
• Certificazioni: le certificazioni MongoDB fungono da prova della tua competenza. Approfondiscono la comprensione dell'argomento e aumentano le tue possibilità di essere assunto. Ecco una guida completa per ottenere una certificazione MongoDB.

Conclusione

MongoDB è un potente database NoSQL con uno schema flessibile che supporta le applicazioni moderne. Per questo motivo, la sua competenza è molto richiesta nello sviluppo software. 

In questo articolo abbiamo esplorato domande essenziali da colloquio, dalle basi alla programmazione fino alle domande basate su scenari. Inoltre, i consigli finali aumenteranno le tue probabilità di successo nei colloqui.

Per approfondire la tua comprensione di MongoDB, valuta di esplorare corsi come MongoDB in Python e concetti NoSQL.