Paginafouten in MongoDB oplossen

Paginafouten zijn een veel voorkomende fout die meestal optreedt in een grote applicatie met veel gegevens. Het vindt plaats wanneer de MongoDB-database gegevens uit het fysieke geheugen leest in plaats van uit het virtuele geheugen. Paginafoutfouten treden op op het moment dat MongoDB gegevens wil ophalen die niet beschikbaar zijn in het actieve geheugen van de database en daarom gedwongen worden om van schijf te lezen. Dit zorgt voor een grote latentie voor doorvoerbewerkingen, waardoor query's eruitzien alsof ze achterblijven.

Het aanpassen van de prestaties van MongoDB door middel van afstemming is een essentieel onderdeel dat de uitvoering van een toepassing optimaliseert. Databases zijn verbeterd om te werken met informatie die op de schijf wordt bewaard, maar gewoonlijk cachen ze grote hoeveelheden gegevens in het RAM-geheugen in een poging toegang te krijgen tot de schijf. Het is duur om gegevens uit de database op te slaan en te openen, daarom moet de informatie eerst op de schijf worden opgeslagen voordat toepassingen er toegang toe krijgen. Vanwege het feit dat schijven langzamer zijn in vergelijking met RAM-gegevenscache, kost het proces daarom veel tijd. Daarom is MongoDB ontworpen om het optreden van paginafouten te rapporteren als een samenvatting van alle incidenten in één seconde

De dataverplaatsingtopologie in MongoDB

Gegevens van de client worden verplaatst naar het virtuele geheugen waar de paginacache ze leest terwijl ze worden geschreven. De gegevens worden vervolgens op de schijf opgeslagen, zoals weergegeven in het onderstaande diagram.

MongoDB-paginafouten vinden

Paginafouten kunnen worden gedetecteerd door middel van vergrendelingsprestaties die gegevensconsistentie in MongoDB garanderen. Wanneer een bepaalde bewerking in de wachtrij staat of lange tijd wordt uitgevoerd, nemen de MongoDB-prestaties af en wordt de bewerking langzamer terwijl deze wacht op vergrendeling. Dit leidt tot een vertraging omdat vergrendelingsgerelateerde vertragingen sporadisch zijn en soms de prestaties van de applicatie beïnvloeden. Lock beïnvloedt de prestaties van een toepassing wanneer sloten worden verdeeld (locks.timeAcquiringMicros door locks.acquireWaitCount), dit geeft de gemiddelde wachttijd voor een bepaalde vergrendelingsmodus. Locks.deadLockCount geeft het totaal van alle ervaren impasse bij het verwerven van sloten. Aangezien de globalLock.totalTime harmonieus hoog is, zijn er talloze verzoeken die een slot verwachten. Naarmate meer verzoeken wachten op slot, wordt meer RAM verbruikt en dit leidt tot paginafouten.

Je kunt ook mem.mapped gebruiken, waarmee ontwikkelaars het totale geheugen dat mongod gebruikt, kunnen onderzoeken. Mem.mapped is een serveroperator voor het controleren van de hoeveelheid geheugen in megabyte (MB) in een MMAPv1-opslagengine. Als de operator mem.mapped een waarde weergeeft die groter is dan de totale hoeveelheid systeemgeheugen, zal er een paginafout optreden omdat een dergelijk groot geheugengebruik zal leiden tot een paginafout in de database.

Hoe paginafouten optreden in MongoDB

Het laden van pagina's in MongoDB hangt af van de beschikbaarheid van vrij geheugen. In het geval dat er geen vrij geheugen is, moet het besturingssysteem:

Zoek naar een pagina die de database niet meer gebruikt en schrijf de pagina op de geheugenschijf.
Laad de gevraagde pagina in het geheugen nadat deze van de schijf is gelezen.

Deze twee activiteiten vinden plaats wanneer pagina's worden geladen en nemen dus veel tijd in beslag in vergelijking met het lezen in een actief geheugen, wat leidt tot paginafouten.

MongoDB-paginafouten oplossen

Hier volgen enkele manieren waarop u paginafouten kunt oplossen:

Verticaal schalen naar apparaten met voldoende RAM of horizontaal schalen:als er onvoldoende RAM is voor een bepaalde dataset, is de juiste aanpak om het RAM-geheugen te vergroten door verticaal te schalen naar apparaten met meer RAM om meer bronnen aan de server toe te voegen. Verticaal schalen is een van de beste en moeiteloze manieren om de MongoDB-prestaties te verbeteren door de belasting niet over meerdere servers te verdelen. Aangezien verticaal schalen meer RAM toevoegt, maakt horizontaal schalen het mogelijk om meer shards aan een shard-cluster toe te voegen. In eenvoudige bewoordingen is horizontale schaling waar de database wordt opgedeeld in verschillende delen en wordt opgeslagen op meerdere servers. Horizontale schaling stelt de ontwikkelaar in staat om meer servers toe te voegen en dit verhoogt de databaseprestaties aanzienlijk omdat er geen downtime is. Verticale schaling en horizontale schaling verminderen het optreden van paginafouten door het vergroten van het geheugen waarmee men werkt terwijl men met de database werkt.
Gegevens correct indexeren:gebruik de juiste indexen om ervoor te zorgen dat er efficiënte zoekopdrachten zijn die geen verzamelingsscans veroorzaken. Een goede indexering zorgt ervoor dat de database niet elk document in een verzameling herhaalt en lost zo het mogelijke optreden van een paginafout op. Verzamelingscan veroorzaakt een paginafoutfout omdat de hele verzameling wordt geïnspecteerd door de query-engine terwijl deze in het RAM wordt ingelezen. De meeste documenten in de collectiescan komen niet terug in de app en veroorzaken dus onnodige paginafouten bij elke volgende zoekopdracht die niet gemakkelijk te omzeilen is. Bovendien kunnen overmatige indexen ook leiden tot inefficiënt gebruik van RAM, wat kan leiden tot paginafoutfouten. Daarom is een goede indexering van het grootste belang als een ontwikkelaar van plan is om paginafoutfouten op te lossen. MongoDB biedt hulp bij het bepalen van de indexen die men moet inzetten bij het gebruik van de database. Ze bieden zowel Slow Query Analyzer die de benodigde informatie geeft over hoe te indexeren voor gebruikers en gedeelde gebruikers.
Migreren naar de nieuwste versie van MongoDB en vervolgens de toepassing verplaatsen naar WiredTiger. Dit is nodig als u van plan bent om paginafoutfouten te voorkomen, aangezien paginafouten alleen gebruikelijk zijn in MMAPv1-opslagengines in tegenstelling tot nieuwere versies en WiredTiger. MMAPv1-opslagengine is verouderd en MongoDB ondersteunt deze niet langer. WiredTiger is de huidige standaard opslagengine in MongoDB en het heeft MultiVersion Concurrency Control, waardoor het veel beter is in vergelijking met de MMAPv1-opslagengine. Met WiredTiger kan MongoDB zowel de cache van het bestandssysteem als de interne cache van WiredTiger gebruiken, die een zeer grote omvang heeft van 1GB (50% 0f (RAM - 1GB)) of 256 MB.
Houd het totale RAM-geheugen bij dat beschikbaar is voor gebruik in uw systeem. Dit kan door gebruik te maken van diensten zoals New Relic monitoring Google Cloud Monitoring. Bovendien kan BindPlane worden gebruikt met de genoemde cloudmonitoringservices. Het gebruik van een bewakingssysteem is een proactieve maatregel waarmee u paginafouten kunt tegengaan voordat ze optreden, in plaats van te reageren op optredende paginafouten. Met BindPlane kan de monitor constante waarschuwingen instellen voor het optreden van paginafouten, de waarschuwingen maken u ook bewust van het aantal indexen, indexgrootte en bestandsgrootte.
Ervoor zorgen dat gegevens worden geconfigureerd in de bestaande werkset en niet meer RAM gebruiken dan aanbevolen. MongoDB is een databasesysteem dat het beste werkt wanneer veelgebruikte gegevens en indexen perfect in het toegewezen geheugen passen. RAM-grootte is een essentieel aspect bij het optimaliseren van de prestaties van de database, daarom moet men ervoor zorgen dat er altijd voldoende RAM-geheugen is voordat de app wordt geïmplementeerd.
Belasting verdelen tussen mongod-instanties door shards toe te voegen of een shard-cluster te implementeren. Het is van vitaal belang om schaduw mogelijk te maken waar de beoogde collectie zich bevindt. Maak eerst verbinding met mongo's in de mongo-shell en gebruik de onderstaande methode.
1. ```
sh.shardCollection()
```
  Maak vervolgens een index met deze methode.
```
db.collection.createIndex(keys, options)
```
  De gemaakte index ondersteunt de Shard-sleutel, dat wil zeggen als de gemaakte verzameling al gegevens heeft ontvangen of opgeslagen. Als de verzameling echter geen gegevens (leeg) bevat, gebruikt u de onderstaande methode om deze te indexeren als onderdeel van de ssh.shardCollection: sh.shardCollection()
2. Dit wordt gevolgd door een van de twee strategieën van mongoDB.
  1. Hashed shading
```
sh.shardCollection("<database>.<collection>", { <shard key field> : "hashed" } )
```
  2. Op bereik gebaseerde arcering
```
sh.shardCollection("<database>.<collection>", { <shard key field> : 1, ... } )
```

Hoe MongoDB-paginafouten te voorkomen

Shards toevoegen of shard-cluster implementeren om de belasting te verdelen
Zorg voor voldoende RAM voor uw toepassing voordat u deze implementeert
Ga naar MongoDB nieuwere versies en ga dan verder naar WiredTiger
Verticaal of horizontaal schalen voor een apparaat met meer RAM
Gebruik het aanbevolen RAM-geheugen en houd de gebruikte RAM-ruimte bij

Conclusie

Een aantal paginafouten (Alleen) duurt echter even, maar in een situatie waarin er veel paginafouten zijn (geaggregeerd), is dit een indicatie dat de database een groot aantal gegevens inleest in de schijf. Wanneer aggregatie plaatsvindt, zullen er meer MongoBD-leesvergrendelingen zijn die tot een paginafout zullen leiden.

Bij gebruik van MongoDB kunnen de grootte van het RAM-geheugen voor het systeem en het aantal query's de prestaties van de applicatie sterk beïnvloeden. De prestaties van een applicatie in MongoDB zijn sterk afhankelijk van de beschikbare RAM in het fysieke geheugen, wat van invloed is op de tijd die de applicatie nodig heeft om een enkele query uit te voeren. Met voldoende RAM wordt het optreden van paginafouten verminderd en de prestaties van de applicatie verbeterd.