Erstellen eines Lasttests in Apache JMeter gegen einen zwischengespeicherten Map Service (Fortgeschritten)

AaronLopez

Warum einen Cached Map Service testen<\/SPAN>?<\/SPAN><\/H1>Cached Map Services sind eine beliebte und empfohlene Methode, um eine leistungsfähige Darstellung statischer Daten bereitzustellen. Der Cache-Service-Typ ist eine bewährte Technologie, aber es kann dennoch erforderlich sein, ihn unter Last zu testen, um seine Skalierbarkeit aus erster Hand auf einer bestimmten Bereitstellungsarchitektur zu beobachten. Obwohl Cached Map Services gut funktionieren, kann das gleichzeitige Bereitstellen von Tausenden von <\/SPAN>gleichzeitigen Kachelanforderungen ressourcenintensiv für die Serverhardware sein.<\/SPAN><\/P>Hinweis: Aufgrund der schnellen Rate der Bereitstellung und Nutzung der Ressource kann das Lasttesten von Cached Map Services auch die Hardwareauslastung des Testclient-Arbeitsplatzes stark beanspruchen.<\/STRONG><\/FONT><\/P>Herausforderungen beim Testen von Cached Map Services<\/H1>Im Vergleich zum Lasttest der Export-Kartenfunktion bringt das richtige<\/EM> Testen eines Cached Map Service mehrere Herausforderungen mit sich, da sich die Anforderungszusammensetzung mit jedem Kartenbildschirm ändert. Da das zugrunde liegende Cache-Schema ein Rasterdesign verwendet, können die Kartenausschnitte einiger Verschiebungen oder Zooms mehr oder weniger Kachelbilder abrufen als andere. Die Berücksichtigung dieses realen Verhaltens des Cache-Services macht die Testlogik komplexer als bei der Ausführung der Export-Kartenfunktion.<\/SPAN><\/P>Die Testlogik sollte außerdem dynamisch sein und ein angemessenes Interessengebiet abdecken. Das Konvertieren einer HAR-Datei mit erfassten Cache-Kachelanforderungen in einen Test mag schnell und einfach sein, zeigt jedoch keine realistische Skalierbarkeit des Dienstes. Dies liegt daran, dass eine kleine Stichprobe von Kachelanforderungen immer wieder verwendet wird.<\/SPAN><\/P>Generell sind Anfragen für einzelne Cache-Kacheln schnell...sehr<\/EM> schnell. Aufgrund dieses Verhaltens muss die Testlogik ebenfalls gut funktionieren, mit dem Service skalieren und minimale Overhead auf dem Testclient haben.<\/SPAN><\/P>Wie testet man einen <\/SPAN>Cached Map Service?<\/SPAN><\/H1>Die Schritte in diesem Artikel sollten mit jedem vorhandenen Cached Map Service in Ihrer lokalen ArcGIS Enterprise-Bereitstellung funktionieren. Falls keiner verfügbar ist, wird empfohlen, sich den Natural Earth-Datensatz für diese Aufgabe anzusehen.<\/SPAN><\/P>Der Natural Earth-Datensatz<\/H2>Obwohl die Schritte mit beliebigen Daten funktionieren sollten, könnte die Schritt-für-Schritt-Anleitung in diesem Artikel effektiver sein, wenn sie direkt nachvollzogen werden kann. In solchen Fällen ist es ideal, auf die Natural Earth-Datensätze<\/A> zurückzugreifen, die einige angemessene Kartendetails (in kleineren Maßstäben) für die ganze Welt bieten.<\/SPAN><\/P>

Laden Sie den Natural Earth-Datensatz hier herunter<\/A><\/STRONG> 

• Der oben genannte Download ist ein Teil des größeren <\/LI>

Natural_Earth_quick_start.zip<\/A> und enthält ein modifiziertes MXD für ArcMap 10.8.1 und ArcGIS Pro 2.8 Projekt

• Beide können verwendet werden, um einen Cached Map Service in ArcGIS Enterprise zu veröffentlichen und zu erstellen<\/li><\/ul>
  • Das Natural Earth-Datenunterset sollte ähnlich wie folgt aussehen, wenn es in ArcGIS Pro (oder ArcMap) geöffnet wird<\/li>

<\/span><\/SPAN><\/P>Dieser Artikel wird nicht<\/EM> <\/STRONG>die Details zur Erstellung, Konfiguration oder Veröffentlichung eines Cached Map Service in ArcGIS Enterprise behandeln. Für Informationen zu solchen Aktionen siehe:

Tutorial: Erstellen eines Cached Map Service<\/A><\/STRONG>  <\/LI><\/UL>

Hinweis: Es wird empfohlen, sich mit einigen Metadaten-Details des Cached Map Service vertraut zu machen, da der Lasttest einige dieser Informationen erfordert (z.B. xorigin, yorigin, tileCols, tileRows und räumliche Referenz sowie die Maßstäbe, die Kacheln enthalten).<\/STRONG>

Testdatengenerierung<\/SPAN>

Sobald ein Cached Map Service verfügbar ist, besteht der nächste Schritt darin, Testdaten über ein Interessengebiet zu generieren.

Wie bei anderen JMeter-Artikeln in der Community benötigen wir gute Testdaten, um den größten Nutzen aus den Ergebnissen zu ziehen. Und wie zuvor macht das <\strong>Load Testing Tools<\a> Package (für ArcGIS Pro) diese Aufgabe kurz und bündig. Es gibt sogar ein spezielles Tool zum Erstellen von Bounding Box-Daten zur Verwendung mit Cached Map Services.

Hinweis: Version 1.3.0 der Load Testing Tools hat das Tool "Generate Bounding Boxes (Precision)" hinzugefügt.

Laden Sie das Paket herunter und entpacken Sie es, dann machen Sie diesen Ordner in Ihrem ArcGIS Pro-Projekt verfügbar.

Das Tool Generate Bounding Boxes (Precision)

• 
  
  Das Starten des Tools Generate Bounding Boxes (Precision) sollte eine Benutzeroberfläche ähnlich der folgenden anzeigen:
  
  

• 
  Vor dem Ausführen des Tools passen wir die Eingaben an, um den Datengenerierungsprozess auf folgende Punkte auszurichten:
  • Spezifische Kartenmaßstäbe (in diesem Fall drei verschiedene Maßstäbe)
    • Die Maßstäbe 4622324.434309 und 1155581.108577 wurden beibehalten
      
    • Der Maßstab 2311162.217155 wurde hinzugefügt
      
    • Die Anzahl der zu generierenden Datensätze wurde angepasst, um größere Kartenmaßstäbe widerzuspiegeln
      • Je kleiner die Maßstabszahl wird, desto mehr Boxen soll das Tool generieren
        
  • Ein spezifisches Interessengebiet (optional)
    • Ein Polygon der Vereinigten Staaten wurde einer neuen Karte hinzugefügt
      
    • Dieses Feature wurde als Constraining Polygon festgelegt
      

• Klicken Sie auf Ausführen
  • Die Ausführung des Tools kann einige Momente dauern
    

Visualisierung der generierten Daten in ArcGIS Pro

• Der Inhaltsbildschirm wird durch Hinzufügen einer neuen Feature-Class gefüllt, die die generierten Daten visuell darstellt
  • Nicht alle generierten Kartenmaßstäbe werden sofort sichtbar sein
    

Datenvisualisierung im Texteditor

• Mithilfe des Dateisystem-Explorers navigieren Sie zum verwendeten ArcGIS Pro-Projekt zur Datengenerierung und öffnen eine der CSV-Dateien mit Ihrem bevorzugten Texteditor
  • Der Dateiinhalt sollte ähnlich wie folgt aussehen:
    

• Der Apache JMeter-Test wird so konfiguriert, dass jede dieser Begrenzungsboxen in die entsprechenden Cache-Kartenkacheln umgewandelt wird
  

Der Testplan für den Cached Map Service 

• Um den Apache JMeter-Testplan zu laden, der in diesem Artikel verwendet wird, siehe: cache_tiles1.zip 
• Das Öffnen des Testplans in Apache JMeter sollte ungefähr wie folgt aussehen:
  • Passen Sie die benutzerdefinierten Variablen an Ihre Umgebung an
    • Xorigin, Yorigin, TileCols, TileRows sind Eigenschaften des erstellten Map Cache, die auf der REST-Endpunktseite des Dienstes zu finden sind
      • TileCols und TileRows befinden sich typischerweise unter Tile Info Höhe und Breite

Komponenten des Testplans

CSV Data Set Config

Die CSV Data Set Config-Elemente in JMeter werden verwendet, um auf die neu generierten Testdaten aus dem Dateisystem zu verweisen. Die aktuelle Version des Testplans ist so aufgebaut, dass sie 3 verschiedene CSV-Dateien verwendet (je eine für jede Map Scale Data Datei).

Hinweis: Abgesehen von den User Defined Variables und der Einstellung des Dateinamens in den CSV Data Set Config-Elementen sollte im Testplan nichts anderes bearbeitet oder geändert werden. Die Testlogik wird unten aufgeführt, nur um zu erklären, wie die Werte in der HTTP Request befüllt werden.

Levels Of Detail List Logic

Um komplexere JMeter-Testlogik zu vermeiden, sind 24 feste Map Cache Levels of Detail in einer Klasse innerhalb eines JSR223 Sampler Testelements platziert. Die „komplexe Alternative“ wäre, den Endpunkt des Dienstes zu Beginn des Tests zu verbinden und die Cache-Tile-Metadaten herunterzuladen. HTTP-Logik in JSR223 Samplern zu verwenden ist technisch möglich, aber nicht der Weg, den ich gewählt habe.

• Es gibt nur einen JSR223 Sampler innerhalb der Levels Of Detail Transaction
• Dieses Element wird nur einmal ausgeführt, zu Beginn jedes Testthreads
  • Das Element enthält 24 feste Cache Levels of Detail, wobei Level 0 bei Maßstab 591657527.591555 beginnt
    • Wenn Ihr Cache-Schema bei einem anderen Maßstab für 0 beginnt, muss der JSR223 Sampler manuell angepasst werden
• Dieser JSR223 Sampler muss nicht bearbeitet werden, um den Test auszuführen
  • Dies setzt voraus, dass der gecachte Map Service eine Spatial Reference von 102100 (3857) hat

Levels Of Detail -- JSR223 Sampler (Vollständige Logik):

 

 

 

 

 

// FileServer-Klasse
import org.apache.jmeter.services.FileServer

public class Lod{
   int level
   double resolution
   double scale
   double tolerance 
}

public class MyLodList1{
	public List<Lod> LodList = new ArrayList()	
	
	MyLodList1(){
		// Basierend auf ArcGIS Online Map Scales
		// https://services.arcgisonline.com/arcgis/rest/services/World_Street_Map/MapServer
		//
		// Spatial Reference: 102100 (3857)
		Lod lod = new Lod()

		lod = new Lod()
		lod.level = 0
		lod.resolution = 156543.03392800014 //11
		lod.scale = 591657527.591555
		lod.tolerance = 0.5
		this.LodList.add(lod)
		
		lod = new Lod()
		lod.level = 1
		lod.resolution = 78271.51696399994 //11
		lod.scale = 295828763.795777
		lod.tolerance = 0.5
		this.LodList.add(lod)
		
		lod = new Lod()
		lod.level = 2
		lod.resolution = 39135.75848200009 //11
		lod.scale = 147914381.897889
		lod.tolerance = 0.25
		this.LodList.add(lod)
		
		lod = new Lod()
		lod.level = 3
		lod.resolution = 19567.87924099992 //11
		lod.scale = 73957190.948944
		lod.tolerance = 0.5
		this.LodList.add(lod)
		
		lod = new Lod()
		lod.level = 4
		lod.resolution = 9783.93962049996 //11
		lod.scale = 36978595.474472
		lod.tolerance = 0.5
		this.LodList.add(lod)
		
		lod = new Lod()
		lod.level = 5
		lod.resolution = 4891.96981024998 //11
		lod.scale = 18489297.737236
		lod.tolerance = 0.5
	the.LodList.add(lod)
    
    lod = new Lod()
    lod.level = 6
    lod.resolution = 2445.98490512499 //11
    lod.scale = 9244648.868618
    lod.tolerance = 0.5
    this.LodList.add(lod)
    
    lod = new Lod()
    lod.level = 7
    lod.resolution = 1222.9924525624949 //13
    lod.scale = 4622324.434309
    lod.tolerance = 0.5
    this.LodList.add(lod)
    
    lod = new Lod()
    lod.level = 8
    lod.resolution = 611.49622628137968 //14
    lod.scale = 2311162.217155
    lod.tolerance = 0.5
    this.LodList.add(lod)

    lod = new Lod()
    lod.level = 9
    lod.resolution = 305.74811314055756 //14
    lod.scale = 1155581.108577
    lod.tolerance = 0.5
    this.LodList.add(lod)

    lod = new Lod()
    lod.level = 10
    lod.resolution = 152.87405657041106 //14
    lod.scale = 577790.554289
    lod.tolerance = 0.5
    this.LodList.add(lod)

    lod = new Lod()
    lod.level = 11
    lod.resolution = 76.437028285073239 //15
    lod.scale = 288895.277144
    lod.tolerance = 0.5
    this.LodList.add(lod)

    lod = new Lod()
    lod.level = 12
    lod.resolution = 38.21851414253662 //14
    lod.scale = 144447.638572
    lod.tolerance = 0.5
    this.LodList.add(lod)

    lod = new Lod()
    lod.level=13 
   	lod.resolution=19.10925707126831 //15 
lod.scale=72223.819286 
lod.tolerance=0.5 
th.is.LodList.add(lod) 
 
lod=new Lod() 
l.od.level=14 
l.od.resolution=9.5546285356341549 //16 
l.od.scale=36111.909643 
l.od.tolerance=0.5 
th.is.LodList.add(lod) 
 
l.od=new Lod() 
l.od.level=15 
l.od.resolution=4.77731426794937 //14 
l.od.scale=18055.954822 
l.od.tolerance=0.05 
th.is.LodList.add(lod) 
 
l.od=new Lod() 
l.od.level=16 
l.od.resolution=2.388657133974685 //15 
l.od.scale=9027.977411 
l.od.tolerance=0.025 
th.is.LodList.add(lod) 
 
l.od=new Lod() 
l.od.level=17 
l.od.resolution=1.1943285668550503 //16 
l.od.scale=4513.988705 
l.od.tolerance=0.025 
th.is.LodList.add(lod) 
t.lod=new Lod() 
t.l.od.level=18 
t.l.od.resolution=0 .5971642835598172 //16
t.l.od.scale=2256 .994353
t.l.od.tolerance=0 .005
t.h.is.L odList.ad d(lo d) 
nl.o d=new L od() nlo d.leve l=19 nlo d.re solution=0 .29858214164761665 / /17 nlo d.sc ale=1128 .497176 nlo d.to lerance=0 .005 nth.is.Lo dLis t.ad d(lo d) nlo d=new L od() nlo d.leve l=20 nlo d.re solution=0 .14929107082380833 / /17 nlo d.sc ale=564 .248588 nlo d.to lerance=0 .0025 nth.is.Lo dLis t.ad d(lo d) nlo d=new L od() nlo d.leve l=21 nlo d.re solution=0 .07464553541190416 / /17 nlo d.sc ale=282 .124294 nlo d.to lerance=0 .0005 nth.is.Lo dLis t.ad d(lo d) nlo d=new L od() nlo d.leve l=22 nlo d.re solution=0 .03732276770595208 / /17 nlo d.sc ale=141 .062147 nlo d.to lerance=0 .0005 nth.is.Lo dLis t.ad d(lo d) nlo d=new L od() nlo d.leve l=23 nlo d.re solution=0 .01866138385297604 / /17 nlo d.sc ale=70 .5310735 nlo d.to lerance=0 .0005 nth.is.Lo dLis t.ad d(lo d) } } MyL odLi st1 myl ods=n ew MyL odLi st1 () Li st<L od> Lo dLi st=m yl ods.Lo dLi st vars.putObject("L odLi st",Lo dLi st)

 

 

 

 

 

GetMapTile Logic

Die JSR223 Sampler innerhalb der GetMapTile Transaction sind die Logik, die dafür verantwortlich ist, eine Bounding Box zu nehmen und sie in die entsprechenden Cache Tiles umzuwandeln. 

• Es gibt einen JSR223 Sampler für jeden Map Scale (z.B., einen für jede entsprechende CSV Data Set Config)
  • CSV Data Set Config A --> JSR223 Sampler A1
• Dies wird bei jeder Iteration eines Testthreads ausgeführt
  • Dies wird häufig ausgeführt... jedes Mal wenn eine neue Bounding Box eingelesen wird
• Diese JSR223 Sampler müssen nicht bearbeitet werden, um den Test auszuführen

Hinweis: JSR223 Sampler mit Groovy werden im Allgemeinen schnell ausgeführt und fügen dem Test nur sehr wenig Overhead hinzu

 GetMapTile -- JSR223 Sampler A1 (Vollständige Logik):

 

 

 

 

 

// Skript zur Verarbeitung einer CSV-Datei (von Load Testing Tools) mit Zeilen im folgenden Format:
// bbox,width,height,mapUnits,sr,scale
// FileServer-Klasse
import org.apache.jmeter.services.FileServer;
import org.apache.commons.math3.util.Precision;
//import java.math.BigDecimal;
// GetMapTile     
bbox_var = vars.get("bbox_A");
String[] bboxParts=bbox_var.split(",");
double xmin=Double.parseDouble(bboxParts[0]);
double ymin=Double.parseDouble(bboxParts[1]);
double xmax=Double.parseDouble(bboxParts[2]);
double ymax=Double.parseDouble(bboxParts[3]);
width_var=vars.get("width_A");
height_var=vars.get("height_A");
// Verwenden Sie die Kartenmaßstabsauflösung (Karten-Einheiten pro Pixel), um das Tile-Level zu bestimmen
double mapresolution=0;
int resolutionprecision=10;
mapresolution=Precision.round((Math.abs(xmax-xmin)/Double.parseDouble(width_var)),resolutionprecision);
scale_var=vars.get("scale_A");
double  bbox_scale_double = Double.parseDouble(scale_var)

// Karteneinheiten pro Pixel
double tileresolution = 0
double lod_resolution = 0
double scale = 0
int tilelevel = 0
LodList = vars.getObject("LodList") // Es wird angenommen, dass der zwischengespeicherte Kartendienst eine räumliche Referenz von 102100 (3857) hat
boolean firstIteration = true;
for(int i = 0; i < LodList.size; i++)
{
     lod_resolution = Precision.round(LodList[i].resolution, resolutionprecision)
	tileresolution = lod_resolution
	tilelevel = LodList[i].level
	scale = LodList[i].scale		
	
     if (mapresolution >= lod_resolution)
     {
     	break
	}
}

tileCols_var = vars.get("TileCols")
cols = Double.parseDouble(tileCols_var)
tileRows_var = vars.get("TileRows")
rows = Double.parseDouble(tileRows_var)
// Ursprung des Caches (obere linke Ecke)
xorigin_var = vars.get("Xorigin")
xorigin = Double.parseDouble(xorigin_var)
yorigin_var = vars.get("Yorigin")
yorigin = Double.parseDouble(yorigin_var)

// Minimum Kachelspalte ermitteln
double minxtile = (xmin - xorigin) / (cols * tileresolution)
// Minimum Kachelreihe ermitteln
// Vom Ursprung aus ist maxy das minimale y
double minytile = (yorigin - ymax) / (rows * tileresolution)
// Maximum Kachelspalte ermitteln
double maxxtile = (xmax - xorigin) / (cols * tileresolution)
// Maximum Kachelreihe ermitteln
// Vom Ursprung aus ist miny das maximale y
double maxytile = (yorigin - ymin) / (rows * tileresolution)

// Ganzzahlige Werte für min und max, Reihe und Spalte zurückgeben
int mintilecolumn = (int)Math.floor(minxtile)
int mintilerow = (int)Math.floor(minytile)
int maxtilecolumn = (int)Math.floor(maxxtile)
int maxtilerow = (int)Math.floor(maxytile)

Scheme_var = vars.get("Scheme")
WebServerName_var = vars.get("WebServerName")
ServerInstanceName_var = vars.get("ServerInstanceName")
ServiceName_var = vars.get("ServiceName")
ServiceType_var = vars.get("ServiceType")
def cacheRequest
def tilePaths = []
int count = 0
for (int row = mintilerow; row <= maxtilerow; row++)
{
	// für jede Spalte in der Reihe im Kartenbereich
     for (int col = mintilecolumn; col <= maxtilecolumn; col++)
     {
          cacheRequest = ("/").concat(ServerInstanceName_var).concat("/rest/services/").concat(ServiceName_var).concat("/").concat(ServiceType_var)
          cacheRequest = cacheRequest.concat("/tile").concat("/").concat(tilelevel.toString()).concat("/").concat(row.toString()).concat("/").concat(col.toString())
          count++
          tilePaths.add(cacheRequest)
     }
}


def requestCount = count.toString()
vars.putObject("RequestCount_A",requestCount) 
vars.putObject("TilePaths_A",tilePaths)

 

 

 

 

 

Cache Tile Loop und Pfadbefüllung

Für diesen Teil des Testplans sind mehrere Komponenten erforderlich. Mit dem in die entsprechenden Cache-Kacheln übersetzten Begrenzungsrahmen und der Zusammenstellung in einer Liste von URLs wird ein drittes JSR223 benötigt, um jede URL innerhalb einer Schleife in eine Variable zu setzen. Die Schleifenlogik findet innerhalb der Cache Tiles-Transaktion statt.

• Es gibt einen JSR223 Sampler für jeden Kartenmaßstab
  • CSV Data Set Config A --> JSR223 Sampler A2
• Diese JSR223 Sampler müssen nicht bearbeitet werden, um den Test auszuführen
• Ein Loop Controller wurde hinzugefügt, um nur die tatsächliche Anzahl der Kacheln pro Begrenzungsrahmen abzufragen, da diese Menge je nach Bereich variieren kann
  • Die Anzahl der Kacheln, die jedem Begrenzungsrahmen entsprechen, variiert je nach Bereich, aber auch nach der Kartenauflösung (1920x1080)
    • Höhere Bildschirmauflösungen erfordern mehr Kacheln
  • Der Loop Controller enthält folgende Elemente:
  • Zähler
  • JSR223 Sampler
  • HTTP Request

Loop Controller

Zähler

JSR223 Sampler

HTTP Request

Die gesamte oben beschriebene Testlogik existiert nur für diese Komponente des Tests. Für jeden Kartenmaßstab gibt es nur eine HTTP-Anfrage! Dieses einfache Design fördert die Lesbarkeit und Wartbarkeit.

Hinweis: Die HTTP-Anfragen enthalten ein Response Assertion-Element zur Validierung der vom Server zurückgegebenen Elemente. Wenn der Inhaltstyp der Antwort image/jpeg oder image/png ist, wird die Anfrage bestanden. Einige VectorTileServer-Caches können jedoch eine Protocolbuffer Binary Format (*.pbf)-Datei zurückgeben. In diesen Fällen müssten die zu testenden Muster manuell auf Folgendes erweitert werden: image/jpeg || image/png || application/octet-stream || application/x-protobuf

Die Thread Group-Konfiguration

Der JMeter-Testplan ist derzeit für einen relativ kurzen Test von 20 Minuten konfiguriert. Zwischengespeicherte Kartendienste funktionieren gut, daher wird viel Durchsatz innerhalb jedes Schritts (2 Minuten pro Schritt) und insgesamt im Test stattfinden.

• Verschiedene Umgebungen können eine alternative Druckkonfiguration erfordern, um die gewünschten Testergebnisse zu erzielen, passen Sie diese bei Bedarf an

Validierung des Testplans

Als bewährte Praxis ist es immer eine gute Idee, die zurückkommenden Ergebnisse vor der Ausführung des eigentlichen Lasttests zu validieren.

• Verwenden Sie den View Results Tree Listener zur Unterstützung bei der Validierung
  • Der Testplan enthält einen View Results Tree Listener, dieser ist jedoch standardmäßig deaktiviert
    • Aktivieren Sie ihn, um die Ergebnisse anzuzeigen
• Starten Sie den Test über die GUI

Transaktionen

• Wählen Sie eine der "Cache Tiles"-Transaktionen aus
  • Die Ergebnisse sollten wie folgt aussehen:

• In diesem Beispiel wurden alle Transaktionen erfolgreich abgeschlossen (z.B. das grüne Häkchen)
  • Cache Tiles (Kartenmaßstab: 4622324.434309)
  • Cache Tiles (Kartenmaßstab: 2311162.217155)
  • Cache Tiles (Kartenmaßstab: 1155581.108577)
• Wenn man eine der Transaktionen auswählt, listet das Sampler-Ergebnis einige wichtige Informationen auf
  • Blick auf die Größe in Bytes werfen
    • Im obigen Beispiel betrug die Transaktionsgröße über 50 KB, was darauf hindeutet, dass vernünftige Kacheldaten (für diesen Datensatz) zurückgegeben wurden und die Antworten nicht alle "leere" Bilder waren
  • Anzahl der Samples in der Transaktion war 80
    • Da es für jede Kachelanfrage einen JSR223 Sampler gibt, wurden tatsächlich 40 Kacheln heruntergeladen
  • Die Ladezeit zeigt 62 ms an, was bedeutet, dass es nur 0,062 Sekunden dauerte, um 40 Kachelbilder herunterzuladen

Anfragen

• Klappen Sie die ausgewählte Transaktion auf
  • In diesem Beispiel Cache Tiles (Kartenmaßstab: 1155581.108577)
• Wählen Sie eine der HTTPS-Anfragen aus
  • Die Ergebnisse sollten wie folgt aussehen:

<\/span><\/SPAN><\/P>In diesem Beispiel wurde die Select-Anfrage <\/SPAN>erfolgreich abgeschlossen (z. B. das grüne Häkchen)<\/SPAN><\/LI>Werfen Sie einen kurzen Blick auf die Ladezeit<\/SPAN>In diesem Beispiel dauerte der einzelne Kachelabruf nur 2 ms (0,002 Sekunden) zum Herunterladen<\/SPAN><\/LI><\/UL><\/LI>Ein Klick auf den Tab Antwortdaten ermöglicht eine Vorschau der angeforderten Kachel:<\/SPAN><\/LI><\/UL><\/span><\/SPAN><\/P>Hinweis: Sobald die visuelle Validierung und Fehlerbehebung abgeschlossen ist, wird empfohlen, das Element View Results Tree vor der Ausführung des Lasttests zu deaktivieren<\/STRONG><\/FONT><\/P>Testausführung<\/H1>Der Lasttest sollte auf die gleiche Weise ausgeführt werden wie ein typischer JMeter-Testplan.<\/P>Siehe das mit dem Projekt cache_tiles1.zip mitgelieferte Skript runMe.bat als Beispiel dafür, wie ein Test gemäß den Empfehlungen von Apache JMeter ausgeführt wird.<\/P>Das Skript runMe.bat enthält eine Variable jmeterbin<\/EM>, die auf den entsprechenden Wert für Ihre Umgebung gesetzt werden muss<\/LI><\/UL>Hinweis: Es wird immer empfohlen, den Startzeitpunkt und die Dauer des Lasttests mit den zuständigen Personen Ihrer Organisation abzustimmen. Dies gewährleistet minimale Auswirkungen auf Benutzer und andere Kollegen, die möglicherweise ebenfalls Ihre lokale ArcGIS Enterprise-Site nutzen müssen. Außerdem hilft dies, Systemrauschen durch andere Aktivitäten und Nutzung zu vermeiden, das Ihre Testergebnisse "verunreinigen" könnte.<\/STRONG><\/FONT><\/P>Hinweis: Aus mehreren Gründen wird dringend davon abgeraten, ArcGIS Online niemals einem Lasttest zu unterziehen.<\/STRONG><\/FONT><\/P>JMeter-Bericht<\/H1>Der automatisch generierte JMeter-Bericht kann Einblicke in den Durchsatz des zwischengespeicherten Kartendienstes unter Last gebenDieser Bericht wird automatisch aus den Befehlszeilenoptionen generiert, die vom Skript runMe.bat übergeben werden<\/LI><\/UL><\/LI><\/UL>Durchsatzkurve<\/H2>Der JMeter-Bericht für einen Lasttest eines zwischengespeicherten Kartendienstes kann beim Anzeigen im Webbrowser träge und langsam wirkenDies liegt an der Standardzusammensetzung, die versucht, jede eindeutige Anfrage in einigen Diagrammen darzustellenBei einem solchen Test gibt es viele davon<\/LI>Wählen Sie in der Diagrammlegende alle JSR223 Sampler-Elemente aus, um deren Darstellung zu deaktivieren (da sie die Skala verzerren könnten)<\/LI><\/UL><\/LI><\/UL><\/LI>In diesem Fall lag der Spitzen-Durchsatz für eine der gegebenen Maßstabs-Transaktionen zwischengespeicherter Kacheln bei etwa 15 Transaktionen pro SekundeDa 3 Maßstäbe getestet wurden, betrug die Gesamtzahl der Transaktionen pro Sekunde 45 Transaktionen pro SekundeDies entspricht etwa 162.000 Cache-Transaktionen pro Stunde<\/LI><\/UL><\/LI>Der Spitzen-Durchsatz scheint bei der Marke 10:34 aufzutreten<\/LI><\/UL><\/LI><\/UL>

Leistungskurve<\/H2>Die Leistung des Cache-Durchsatzes war gut bei ungefähr 120 ms oder 0,12 SekundenDiese Beobachtung wurde dort gemacht, wo die Spitzen-Transaktionen pro Sekunde bei der Marke 10:34 auftraten<\/LI><\/UL>Hinweis: "Spitzen-Durchsatz" ist ein Punkt in einem Test, an dem kein höherer Durchsatz erreicht werden kann. Dies bedeutet nicht, dass dies der maximale Druck ist, den der Dienst ohne "Ausfall" aushält. Allgemein gesprochen, wenn nach Erreichen des Spitzen-Durchsatzes weitere Benutzer Cache-Kacheln anfordern (z. B. wenn Sie die Stufenlastkonfiguration erhöhen), erfüllt der Dienst weiterhin ihre Anfragen, aber sie müssen länger auf die Rückgabe der Antworten warten (aufgrund von Warteschlangenbildung).<\/FONT>Abschließende Gedanken<\/H1>Der Apache JMeter-Testplan in diesem Artikel stellt einen programmatischen Ansatz dar, um Last auf einen ArcGIS zwischengespeicherten Kartendienst anzuwenden. Eine Stärke dieses Tests ist, dass er einfach zu erstellen, zu konfigurieren und zu warten ist.<\/P>Der automatisch generierte JMeter-Bericht bietet Diagramme und Zusammenfassungen, die zur Analyse der Leistung und Skalierbarkeit des zwischengespeicherten Kartendienstes verwendet werden können.<\/P>Um den in diesem Artikel verwendeten Apache JMeter-Testplan herunterzuladen, siehe: cache_tiles1.zip<\/<A\/><\/<STRONG\/><\/<LI\/><\/<UL\/><\/<H2 id=\"toc-hId--599044696\">Weitere erwähnenswerte Punkte<\/<H2\/>

Jeder zwischengespeicherte Dienst ist anders. Aber allgemein gesprochen kann die Leistung und Skalierbarkeit eines zwischengespeicherten Dienstes durch verschiedene Faktoren beeinflusst werden:<\/<P\/>

Einsatzarchitektur

• Lage der Cache-Daten in Bezug auf die ArcGIS-Kachelhandler(s)<\/<LI>Laufwerkstechnologie und Geschwindigkeit der Cache-Datenspeicherung<\/<UL\/><\/<LI>Nettobandbreite
  • Zwischen Cache-Datenspeicherung und ArcGIS-Kachelhandler(s)<\/<LI>Zwischen ArcGIS-Kachelhandler(s) und ArcGIS Web Adaptor(s)<\/<LI>Zwischen ArcGIS Web Adaptor(s) und Testclient<\/<UL\/><\/<LI>Taktfrequenz und Anzahl der Prozessorkerne
    • Die Bereitstellung von Cache-Kacheln erfolgt schnell, aber unter hoher Last nutzt der gesamte Prozess CPU-Ressourcen vom ArcGIS-Kachelhandler und ArcGIS Web Adaptor (sofern vorhanden) Hosting-Technologie (z.B. Microsofts Internet Information Services Service)<\/<UL\/><\/<LI>Daten können unterschiedlich performen
      • Die durchschnittliche Kachelgröße (z.B. Größe auf Datenträger)
        • Kleinere Kachelgrößen mit weniger Daten können sich anders verhalten als größere detailliertere Kacheln<\/<UL\/><\/<LI>Getestete Kartenmaßstäbe
          • Sogar für denselben Datensatz kann Kartenmaßstab 36111.909643 schwerere Cache-Kacheln haben als Kartenmaßstab 1155581.108577<\/<UL\/><\/<UL\/>

Annahmen und Einschränkungen<\/<H2\/>JDK 17 oder höher funktioniert nicht mit diesem (JMeter 5.4.x) TestplanLäuft man mit diesen JDK-Versionen, tritt folgender Fehler auf: org.codehaus.groovy.GroovyBugError: BUG! Ausnahme in Phase 'semantic analysis' in Quelleneinheit 'Script161.groovy' Unsupported class file major version 61Verwendung von JDK 16 oder früher vermeidet diesen FehlerDer Grund ist, dass JMeter 5.4.x nur JDK 16 (oder früher) unterstütztWenn JDK 17 oder höher für Ihre Umgebung erforderlich ist, müssen Sie JMeter 5.5 verwenden (das JDK 17 unterstützt)On-Demand Cache ist nicht aktiviertKönnte funktionieren wurde aber nicht getestetSinge Fused Map Cache ist TRUEThe cache Storage Format is COMPACTBildformat der Kacheln ist JPG oder PNGAufgrund der Response Assertion-Regel zur Validierung der ServerantwortDer enthaltene Testplan sollte mit einem zwischengespeicherten Dienst fürKarteBildDie Variable ServiceType (unter User Defined Variables) müsste geändert werdenNicht intensiv getestetVektorDie Variable ServiceType (unter User Defined Variables) müsste geändert werdenBilder von VectorTile-Servicekacheln können im Protocolbuffer Binary Format (*.pbf) vorliegenDie Response Assertion-Regel müsste erweitert werden um application/octet-stream oder application/x-protobufDie JSR223 Sampler innerhalb der GetMapTile-Transaktion müssten angepasst werden um ".pbf" am Ende der cacheRequest-Variable hinzuzufügenNicht intensiv getestet   <a href="https://jmeter.apache.org/index.html"; target="_blank" rel="noopener nofollow noreferrer">Apache JMeter</a><span> veröffentlicht unter der </span><a href="https://apache.org/"; target="_blank" rel="noopener nofollow noreferrer">Apache</a><span> </span><a href="https://www.apache.org/licenses/"; target="_blank rel="noopener nofollow noreferrer">Lizenz 2.0.<\/A> Apache, Apache JMeter, JMeter, die Apache-Feder und das Apache JMeter-Logo sind Marken der Apache Software Foundation.<\/SPAN><\/P>

AaronLopez

The Assumptions and Constraints section of the Article has been updated to include some environment details that might be helpful for certain conditions.