Richtlijnen voor het afstemmen van prestaties voor Spark in HDInsight en Azure Data Lake Storage Gen1

  • Artikel

Bij het afstemmen van de prestaties op Spark moet u rekening houden met het aantal apps dat op uw cluster wordt uitgevoerd. Standaard kunt u vier apps tegelijk uitvoeren op uw HDI-cluster (opmerking: de standaardinstelling kan worden gewijzigd). U kunt besluiten om minder apps te gebruiken, zodat u de standaardinstellingen kunt overschrijven en meer van het cluster voor deze apps kunt gebruiken.

Vereisten

Parameters

Bij het uitvoeren van Spark-taken zijn dit de belangrijkste instellingen die kunnen worden afgestemd om de prestaties op Data Lake Storage Gen1 te verbeteren:

  • Num-executors : het aantal gelijktijdige taken dat kan worden uitgevoerd.

  • Uitvoerder-geheugen : de hoeveelheid geheugen die aan elke uitvoerder is toegewezen.

  • Uitvoerderkernen : het aantal kernen dat aan elke uitvoerder is toegewezen.

Aantal-uitvoerders Met Num Executors wordt het maximum aantal taken ingesteld dat parallel kan worden uitgevoerd. Het werkelijke aantal taken dat parallel kan worden uitgevoerd, wordt bepaald door het geheugen en de CPU-resources die beschikbaar zijn in uw cluster.

Uitvoerder-geheugen Dit is de hoeveelheid geheugen die aan elke uitvoerder wordt toegewezen. Het geheugen dat nodig is voor elke uitvoerder is afhankelijk van de taak. Voor complexe bewerkingen moet het geheugen hoger zijn. Voor eenvoudige bewerkingen, zoals lezen en schrijven, zijn de geheugenvereisten lager. De hoeveelheid geheugen voor elke uitvoerder kan worden weergegeven in Ambari. Ga in Ambari naar Spark en bekijk het tabblad Configuraties .

Uitvoerderskernen Hiermee wordt het aantal kernen per uitvoerder ingesteld, waarmee het aantal parallelle threads wordt bepaald dat per uitvoerder kan worden uitgevoerd. Als executeor-cores bijvoorbeeld = 2 zijn, kan elke uitvoerder 2 parallelle taken uitvoeren in het uitvoerder. De uitvoerderkernen die nodig zijn, zijn afhankelijk van de taak. I/O-zware taken vereisen geen grote hoeveelheid geheugen per taak, zodat elke uitvoerder meer parallelle taken kan verwerken.

Standaard worden twee virtuele YARN-kernen gedefinieerd voor elke fysieke kern bij het uitvoeren van Spark in HDInsight. Dit getal biedt een goede balans tussen gelijktijdigheid en de hoeveelheid contextoverschakeling van meerdere threads.

Hulp

Tijdens het uitvoeren van analytische Spark-workloads om te werken met gegevens in Data Lake Storage Gen1, raden we u aan de meest recente HDInsight-versie te gebruiken om de beste prestaties te krijgen met Data Lake Storage Gen1. Wanneer uw taak meer I/O-intensief is, kunnen bepaalde parameters worden geconfigureerd om de prestaties te verbeteren. Data Lake Storage Gen1 is een zeer schaalbaar opslagplatform dat hoge doorvoer kan verwerken. Als de taak voornamelijk uit lees- of schrijfbewerkingen bestaat, kan het verhogen van de gelijktijdigheid voor I/O van en naar Data Lake Storage Gen1 de prestaties verbeteren.

Er zijn enkele algemene manieren om de gelijktijdigheid voor I/O-intensieve taken te verhogen.

Stap 1: Bepalen hoeveel apps er worden uitgevoerd op uw cluster : u moet weten hoeveel apps er op het cluster worden uitgevoerd, inclusief de huidige. Bij de standaardwaarden voor elke Spark-instelling wordt ervan uitgegaan dat er vier apps gelijktijdig worden uitgevoerd. Daarom hebt u slechts 25% van het cluster beschikbaar voor elke app. Voor betere prestaties kunt u de standaardinstellingen overschrijven door het aantal uitvoerders te wijzigen.

Stap 2: uitvoerder-geheugen instellen : het eerste wat u moet instellen, is het uitvoergeheugen. Het geheugen is afhankelijk van de taak die u gaat uitvoeren. U kunt de gelijktijdigheid verhogen door minder geheugen per uitvoerder toe te wijzen. Als u uitzonderingen voor onvoldoende geheugen ziet wanneer u uw taak uitvoert, moet u de waarde voor deze parameter verhogen. Een alternatief is om meer geheugen te krijgen met behulp van een cluster met grotere hoeveelheden geheugen of het vergroten van de grootte van uw cluster. Met meer geheugen kunnen meer uitvoerders worden gebruikt, wat meer gelijktijdigheid betekent.

Stap 3: uitvoerderskernen instellen : voor I/O-intensieve workloads die geen complexe bewerkingen hebben, is het goed om te beginnen met een groot aantal uitvoerderskernen om het aantal parallelle taken per uitvoerder te verhogen. Het instellen van uitvoerderskernen op 4 is een goed begin.

executor-cores = 4

Als u het aantal uitvoerderskernen verhoogt, krijgt u meer parallellisme, zodat u kunt experimenteren met verschillende uitvoerderkernen. Voor taken met complexere bewerkingen moet u het aantal kernen per uitvoerder verminderen. Als uitvoerderkernen hoger is ingesteld dan 4, kan garbagecollection inefficiënt worden en de prestaties verslechteren.

Stap 4: Bepaal de hoeveelheid YARN-geheugen in het cluster : deze informatie is beschikbaar in Ambari. Ga naar YARN en bekijk het tabblad Contigs. Het YARN-geheugen wordt weergegeven in dit venster. Terwijl u zich in het venster bevindt, ziet u ook de standaardgrootte van de YARN-container. De yarn-containergrootte is hetzelfde als het geheugen per uitvoerderparameter.

Totaal YARN-geheugen = knooppunten * YARN-geheugen per knooppunt

Stap 5: aantal uitvoerders berekenen

Geheugenbeperking berekenen : de parameter num-executors wordt beperkt door het geheugen of de CPU. De geheugenbeperking wordt bepaald door de hoeveelheid beschikbaar YARN-geheugen voor uw toepassing. Neem het totale YARN-geheugen en deel dat door uitvoerder-geheugen. De beperking moet worden gedeschaald voor het aantal apps, zodat we delen door het aantal apps.

Geheugenbeperking = (totaal YARN-geheugen/ uitvoergeheugen) / aantal apps

CPU-beperking berekenen : de CPU-beperking wordt berekend als het totale aantal virtuele kernen gedeeld door het aantal kernen per uitvoerder. Er zijn twee virtuele kernen voor elke fysieke kern. Net als bij de geheugenbeperking delen we door het aantal apps.

virtuele kernen = (knooppunten in cluster * aantal fysieke kernen in knooppunt * 2) CPU-beperking = (totaal aantal virtuele kernen / aantal kernen per uitvoerder) / aantal apps

Aantal-uitvoerders instellen : de parameter num-executors wordt bepaald door het minimum van de geheugenbeperking en de CPU-beperking te nemen.

num-executors = Min (totaal aantal virtuele kernen / aantal kernen per uitvoerder, beschikbaar YARN-geheugen/ uitvoerder-geheugen) Het instellen van een hoger aantal uitvoerders leidt niet noodzakelijkerwijs tot betere prestaties. Houd er rekening mee dat het toevoegen van meer uitvoerders extra overhead voor elk extra uitvoerder toevoegt, wat de prestaties mogelijk kan verminderen. Num-executors is gebonden door de clusterresources.

Voorbeeldberekening

Stel dat u momenteel een cluster hebt dat bestaat uit 8 D4v2-knooppunten waarop twee apps worden uitgevoerd, waaronder de app die u gaat uitvoeren.

Stap 1: Bepaal hoeveel apps op uw cluster worden uitgevoerd . U weet dat er twee apps in uw cluster zijn, waaronder de apps die u gaat uitvoeren.

Stap 2: uitvoerdergeheugen instellen : voor dit voorbeeld bepalen we dat 6 GB uitvoergeheugen voldoende is voor een intensieve I/O-taak.

executor-memory = 6GB

Stap 3: uitvoerderskernen instellen : omdat dit een I/O-intensieve taak is, kunnen we het aantal kernen voor elke uitvoerder instellen op vier. Het instellen van kernen per uitvoerder op meer dan vier kan problemen met garbagecollection veroorzaken.

executor-cores = 4

Stap 4: Bepaal de hoeveelheid YARN-geheugen in het cluster : we gaan naar Ambari om erachter te komen dat elke D4v2 25 GB YARN-geheugen heeft. Omdat er 8 knooppunten zijn, wordt het beschikbare YARN-geheugen vermenigvuldigd met 8.

Totaal YARN-geheugen = knooppunten * YARN-geheugen* per knooppunt Totaal YARN-geheugen = 8 knooppunten * 25 GB = 200 GB

Stap 5: num-executors berekenen : de parameter num-executors wordt bepaald door het minimum van de geheugenbeperking en de CPU-beperking te nemen, gedeeld door het aantal apps dat wordt uitgevoerd in Spark.

Geheugenbeperking berekenen : de geheugenbeperking wordt berekend als het totale YARN-geheugen gedeeld door het geheugen per uitvoerder.

Geheugenbeperking = (totaal YARN-geheugen/uitvoergeheugen) / aantal apps Geheugenbeperking = (200 GB / 6 GB) / 2 Geheugenbeperking = 16 (afgerond) CPU-beperking berekenen : de CPU-beperking wordt berekend als het totale aantal yarn-kernen gedeeld door het aantal kernen per uitvoerder.

YARN-kernen = knooppunten in cluster * aantal kernen per knooppunt * 2 YARN-kernen = 8 knooppunten * 8 kernen per D14 * 2 = 128 CPU-beperking = (totaal AANTAL YARN-kernen / aantal kernen per uitvoerder) / aantal apps CPU-beperking = (128 / 4) / 2 CPU-beperking = 16

Aantal-uitvoerders instellen

num-executors = Min (geheugenbeperking, CPU-beperking) num-executors = Min (16, 16) num-executors = 16