Criando um Teste de Carga no Apache JMeter Contra um Serviço de Mapa em Cache (Avançado)

AaronLopez

Por que testar <\/SPAN>um Serviço de Mapa em Cache?<\/SPAN><\/H1>Serviços de mapa em cache são uma forma popular e recomendada para fornecer uma apresentação de dados estáticos com bom desempenho. O tipo de serviço em cache é uma tecnologia comprovada, mas ainda pode haver requisitos para testá-lo sob carga para observar sua escalabilidade diretamente em uma arquitetura de implantação específica. Embora os serviços de mapa em cache tenham bom desempenho, atender a milhares de <\/SPAN>requisições simultâneas de tiles pode ser intensivo em recursos no hardware do servidor.<\/SPAN><\/P>Nota: Devido à rápida taxa de entrega e consumo do recurso, o teste de carga em serviços de mapa em cache também pode ser intensivo na utilização do hardware da estação de trabalho do cliente de teste.<\/STRONG><\/FONT><\/P>Desafios no Teste de Serviços de Mapa em Cache<\/SPAN><\/H1>Comparado ao teste de carga da função exportar mapa, o teste adequado<\/EM> de um serviço de mapa em cache introduz vários desafios, pois a composição das requisições muda a cada tela do mapa. Como o esquema subjacente do cache usa um design em grade, as extensões do mapa em alguns pans ou zooms podem puxar mais ou menos imagens de tiles do que outros. Levar em conta esse comportamento real do serviço em cache torna a lógica do teste mais complexa do que se estivesse exercitando a função exportar mapa.<\/SPAN><\/P>A lógica do teste também deve ser dinâmica e cobrir uma área decente de interesse. Converter um arquivo HAR com requisições capturadas dos tiles do cache em um teste pode ser rápido e fácil, mas não mostra uma escalabilidade realista do serviço. Isso ocorre devido à pequena amostra das requisições dos tiles sendo usada repetidamente.<\/SPAN><\/P>De modo geral, as requisições para tiles individuais do cache são rápidas...muito<\/EM> rápidas. Devido a esse comportamento, a lógica do teste também precisa ter bom desempenho, escalar com o serviço e ter sobrecarga mínima no cliente de teste.<\/SPAN><\/P>Como testar um <\/SPAN>Serviço de Mapa em Cache?<\/SPAN><\/H1>Os passos neste Artigo devem funcionar com qualquer serviço de mapa em cache existente na sua implantação local do ArcGIS Enterprise. No entanto, se não houver nenhum disponível, recomenda-se dar uma olhada no conjunto de dados Natural Earth para essa tarefa.<\/SPAN><\/P>O Conjunto de Dados Natural Earth<\/H2>Embora os passos devam funcionar com quaisquer dados, o passo a passo deste Artigo pode ser mais eficaz se puderem ser seguidos diretamente. Nesses casos, é ótimo recorrer aos conjuntos de dados Natural Earth<\/A> que fornecem algum detalhe decente do mapa (em escalas menores) cobrindo o mundo todo.<\/SPAN><\/P>

Baixe o conjunto Natural Earth aqui<\/A><\/STRONG> 

• O download<\/SPAN> acima é um subconjunto do maior <\/SPAN>

Natural_Earth_quick_start.zip<\/A> e inclui um MXD modificado para ArcMap 10.8.1 e projeto ArcGIS Pro 2.8

• Qualquer um deles pode ser usado para publicar e criar um serviço de mapa em cache no ArcGIS Enterprise<\/SPAN><\/LI><\/UL><\/LI><\/UL><\/LI>O subconjunto Natural Earth deve parecer semelhante ao seguinte quando aberto no ArcGIS Pro (ou ArcMap)<\/SPAN><\/LI><\/UL><\/span><\/SPAN><\/P>Este Artigo não<\/EM> <\/STRONG>abrangerá os detalhes da criação, configuração ou publicação de um serviço de mapa em cache no ArcGIS Enterprise. <\/SPAN>Para informações sobre essas ações, veja:

Tutorial: Criando um serviço de mapa em cache<\/A><\/STRONG>  <\/LI><\/UL><\/LI><\/UL>

Nota: Recomenda-se familiarizar-se com alguns detalhes dos metadados do serviço de mapa em cache, pois o esforço de teste de carga exigirá conhecimento dessas informações (por exemplo, xorigin, yorigin, tileCols, tileRows e referência espacial, bem como as escalas que contêm tiles).<\/STRONG><\/FONT><\/P>

Geração dos Dados para Teste<\/SPAN><\/H2>Com um serviço de mapa em cache disponível, o próximo passo seria gerar dados para teste sobre uma área de interesse.<\/SPAN><\/P>Como nos outros Artigos sobre JMeter na Comunidade, precisamos de bons dados para obter o máximo valor dos resultados. E como antes, o Load Testing Tools<\/A> (para ArcGIS Pro) facilita muito esse trabalho. Há até uma ferramenta específica para criar dados bounding box para usar com serviços de mapa em cache.<\/SPAN>




Ao iniciar a ferramenta Generate Bounding Boxes (Precision), deve aparecer uma interface semelhante à seguinte:Ajuste as entradas para direcionar o processo de geração dos dados para:Escalas específicas do mapa (neste caso três escalas diferentes)Mantiveram-se as escalas 4622324.434309 e 1155581.108577
A escala 2311162.217155 foi adicionada
A quantidade de registros a serem gerados foi ajustada para refletir escalas maiores
À medida que o número da escala diminui, queremos que a ferramenta gere mais caixas


Uma área específica de interesse (opcional)

Um polígono dos Estados Unidos foi adicionado a um novo mapa
Esse recurso foi definido como Polígono Restritivo








Clique em ExecutarA execução da ferramenta pode levar alguns instantes

Visualizando os Dados Gerados no ArcGIS Pro

A tela Conteúdo será preenchida adicionando novas classes de feição que representam visualmente os dados geradosNem todas as escalas geradas serão imediatamente visíveis




Visualizando os Dados Gerados em um Editor de Texto

Usando o explorador do sistema de arquivos, navegue até o projeto ArcGIS Pro usado para gerar os dados e abra um dos arquivos csv usando seu editor favoritoO conteúdo do arquivo deve ser semelhante ao seguinte:





O teste Apache JMeter será configurado para converter cada uma dessas caixas delimitadoras nos tiles correspondentes do mapa em cache

O Plano de Teste do Serviço de Mapa em Cache 

Para baixar o Plano de Teste Apache JMeter usado neste Artigo veja: cache_tiles1.zip 
A abertura do Plano de Teste no Apache JMeter deve parecer semelhante ao seguinte:Ajuste as Variáveis Definidas pelo Usuário para adequar ao seu ambienteXorigin, Yorigin, TileCols, TileRows são propriedades do cache de mapa criado que podem ser encontradas na página do endpoint REST do serviçoTileCols e TileRows geralmente são encontrados sob Informações do Tile Altura e LarguraComponentes do Plano de Teste

Configuração de Conjunto de Dados CSV

Os elementos CSV Data Set Config no JMeter são usados para referenciar os dados de teste recém-gerados a partir do sistema de arquivos. A versão atual do Plano de Teste é construída para utilizar 3 arquivos CSV diferentes (um para cada arquivo de dados de escala de mapa).

Nota: Além das Variáveis Definidas pelo Usuário e da configuração do Nome do Arquivo nos elementos CSV Data Set Config, não deve haver mais nada que exija edição ou alteração no Plano de Teste. A lógica do teste está listada abaixo apenas para explicar como os valores na Requisição HTTP são preenchidos.

Lógica da Lista de Níveis de Detalhe

Para evitar uma lógica de teste JMeter mais complexa, 24 níveis fixos de detalhe do cache do mapa são colocados dentro de uma classe em um elemento de teste JSR223 Sampler. Essa "alternativa complexa" seria conectar o endpoint do serviço no início do teste e baixar os metadados dos tiles do cache. Colocar lógica HTTP em JSR223 Samplers é tecnicamente possível, mas não foi o caminho que escolhi.

• Há apenas um JSR223 Sampler dentro da Transação Níveis de Detalhe
• Este item é executado apenas uma vez, no início de cada thread de teste
  • O elemento contém 24 níveis fixos de detalhe do cache, com o nível 0 começando na escala 591657527.591555
    • Se seu esquema de cache começar em uma escala diferente para 0, então o JSR223 Sampler precisará ser ajustado manualmente
• Este JSR223 Sampler não precisa ser editado para executar o teste
  • Isto assume que o serviço de mapa em cache tem uma Referência Espacial 102100 (3857)

Níveis de Detalhe -- JSR223 Sampler (Lógica Completa):

 

 

 

 

 

// Classe FileServer
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(){
		// Baseado nas Escalas de Mapa ArcGIS Online
		// https://services.arcgisonline.com/arcgis/rest/services/World_Street_Map/MapServer
		//
		// Referência Espacial: 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
	this.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
        this.LodList.add(lod)
    
    	lod = new Lod()
    	lod.level=14 
    	lod.resolution=9.5546285356341549 //16 
    	lod.scale=36111.909643 
    	lod.tolerance=0.5 
    	this.LodList.add(lod) 
    	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	     }
}
MyLodList1 mylods=new MyLodList1();
List<Lod>LodList=mylods.LodList;
vars.putObject("LodList",LodList);

 

 

 

 

 

Lógica GetMapTile

Os JSR223 Samplers dentro da Transação GetMapTile são a lógica responsável por pegar uma caixa delimitadora e transformá-la nos tiles correspondentes do cache. 

• Há um JSR223 Sampler para cada escala de mapa (por exemplo, um para cada CSV Data Set Config correspondente)
  • CSV Data Set Config A --> JSR223 Sampler A1
• Isto é executado a cada iteração da thread de teste
  • Isto é executado frequentemente... toda vez que uma nova caixa delimitadora é lida
• Estes JSR223 Samplers não precisam ser editados para executar o teste

Nota: JSR223 Samplers usando Groovy geralmente são executados rapidamente e adicionam muito pouco overhead ao teste

 GetMapTile -- JSR223 Sampler A1 (Lógica Completa):

 

 

 

 

 

// Script para processar um arquivo CSV (de Ferramentas de Teste de Carga) com linhas no seguinte formato:
// bbox,width,height,mapUnits,sr,scale
// Classe FileServer
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");
// Use a resolução da escala do mapa (unidades do mapa por pixel) para determinar o nível do tile
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)

// Unidades do mapa por pixel
double tileresolution = 0
double lod_resolution = 0
double scale = 0
int tilelevel = 0
LodList = vars.getObject("LodList") // Assumindo que o serviço de mapa em cache tem uma Referência Espacial de 102100 (3857)
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)
// Origem do cache (canto superior esquerdo)
xorigin_var = vars.get("Xorigin")
xorigin = Double.parseDouble(xorigin_var)
yorigin_var = vars.get("Yorigin")
yorigin = Double.parseDouble(yorigin_var)

// Obter coluna mínima do tile
double minxtile = (xmin - xorigin) / (cols * tileresolution)
// Obter linha mínima do tile
// A partir da origem, maxy é o y mínimo
double minytile = (yorigin - ymax) / (rows * tileresolution)
// Obter coluna máxima do tile
double maxxtile = (xmax - xorigin) / (cols * tileresolution)
// Obter linha máxima do tile
// A partir da origem, miny é o y máximo
double maxytile = (yorigin - ymin) / (rows * tileresolution)

// Retornar valor inteiro para min e max, linha e coluna
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++)
{
	// para cada coluna na linha, na extensão do mapa
     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)

 

 

 

 

 

Loop de Tiles do Cache e População dos Caminhos

Existem vários componentes necessários para esta parte do Plano de Teste. Com a bounding box traduzida nos tiles correspondentes do cache e montada em uma lista de URLs, um terceiro JSR223 é necessário para colocar cada URL em uma variável dentro de um loop. A lógica do loop ocorre dentro da transação Cache Tiles.

• Há um JSR223 Sampler para cada escala de mapa
  • CSV Data Set Config A --> JSR223 Sampler A2
• Esses JSR223 Samplers não precisam ser editados para executar o teste
• Há um Loop Controller adicionado para solicitar apenas o número real de tiles por bounding box, já que essa quantidade pode variar conforme a extensão
  • O número de tiles que correspondem a cada bounding box varia por extensão mas também pela resolução do mapa (1920x1080)
    • Resoluções de tela mais altas exigem mais tiles
  • O Loop Controller contém os seguintes elementos:
  • Contador
  • JSR223 Sampler
  • HTTP Request

Loop Controller

Contador

JSR223 Sampler

HTTP Request

Toda a lógica de teste acima existe apenas para este componente do teste. Para cada escala de mapa, há apenas um HTTP Request! Este design simples favorece a legibilidade e a manutenção.

Nota: Os HTTP Requests contêm um elemento Response Assertion para validar os itens retornados do servidor. Se o tipo de conteúdo da resposta for image/jpeg ou image/png, então a requisição será aprovada. No entanto, alguns caches VectorTileServer podem retornar um arquivo Protocolbuffer Binary Format (*.pbf). Nesses casos, os Patterns to Test precisariam ser manualmente expandidos para o seguinte: image/jpeg || image/png || application/octet-stream || application/x-protobuf

A Configuração do Thread Group

O Plano de Teste JMeter está atualmente configurado para um teste relativamente curto de 20 minutos. Serviços de mapas em cache têm bom desempenho, então muito throughput ocorrerá dentro de cada etapa (2 minutos por etapa) e no teste como um todo.

• Diferentes ambientes podem requerer uma configuração alternativa de pressão para alcançar os resultados desejados, ajuste conforme necessário

Validando o Plano de Teste

Como boa prática, é sempre uma boa ideia validar os resultados retornados antes de executar o teste real de carga.

• Use o listener View Results Tree para ajudar na validação
  • O Plano de Teste inclui um View Results Tree Listener mas ele está desabilitado por padrão
    • Ative-o para visualizar os resultados
• No GUI, inicie o teste

Transações

• Selecione uma das Transações "Cache Tiles"
  • Os resultados devem se assemelhar ao seguinte:

• Neste exemplo, todas as transações foram concluídas com sucesso (ex.: o check verde)
  • Cache Tiles (escala do mapa: 4622324.434309)
  • Cache Tiles (escala do mapa: 2311162.217155)
  • Cache Tiles (escala do mapa: 1155581.108577)
• Selecionar uma das transações e o elemento resultado Sampler lista algumas informações chave
  • Dê uma olhada rápida no Tamanho em bytes
    • No exemplo acima, o tamanho da Transação foi superior a 50KB, o que sugere que dados decentes dos tiles (para este conjunto de dados) estavam sendo retornados e as respostas não eram todas imagens "em branco"
  • O Número de amostras na transação foi 80
    • Como há um JSR223 Sampler com cada requisição de tile, isso resultou na verdade em 40 tiles sendo baixados
  • O Tempo de carregamento mostra 62 (ms), significando que levou apenas 0.062 segundos para baixar 40 imagens dos tiles

Requisições

• Expanda a Transação selecionada
  • Neste exemplo, Cache Tiles (escala do mapa: 1155581.108577)
• Selecione uma das requisições HTTPS
  • Os resultados devem se assemelhar ao seguinte:

<\/span><\/SPAN><\/P>Neste exemplo, a solicitação select foi concluída <\/SPAN>com sucesso (por exemplo, o check verde)<\/SPAN><\/LI>Dê uma olhada rápida no Tempo de carregamento<\/SPAN>Neste exemplo, a solicitação individual do tile levou apenas 2 ms (0,002 segundos) para baixar<\/SPAN><\/LI><\/UL><\/LI>Clicar na aba Dados da resposta permite visualizar o tile solicitado:<\/SPAN><\/LI><\/UL><\/span><\/SPAN><\/P>Nota: Após a validação visual e depuração estarem completas, recomenda-se desabilitar o elemento View Results Tree antes de executar o teste de carga<\/STRONG><\/FONT><\/P>Execução do Teste<\/H1>O teste de carga deve ser executado da mesma forma que um Plano de Teste JMeter típico.<\/P>Veja o script runMe.bat incluído no projeto cache_tiles1.zip  como exemplo de como executar um teste conforme recomendado pelo Apache JMeter. <\/P>O script runMe.bat contém uma variável jmeterbin<\/EM> <\/SPAN>que precisará ser configurada com o valor apropriado para seu ambiente<\/LI><\/UL>Nota: É <\/SPAN>sempre recomendado<\/U><\/EM> <\/SPAN>coordenar o horário de início e duração do teste de carga com as pessoas apropriadas da sua organização. Isso garante impacto mínimo aos usuários e outros colegas que também possam precisar usar seu Site ArcGIS Enterprise on-premise. Além disso, isso ajuda a evitar ruído do sistema<\/EM> de outras atividades e usos que podem "poluir" seus resultados de teste.<\/STRONG><\/FONT><\/P>Nota: Por vários motivos, é fortemente aconselhado <\/SPAN>nunca realizar teste de carga no ArcGIS Online<\/EM><\/U>.<\/STRONG><\/FONT><\/P>Relatório JMeter<\/H1>O Relatório JMeter auto-gerado pode fornecer insights sobre a taxa de transferência do serviço de mapa em cache sob cargaEste relatório é gerado automaticamente a partir das opções de linha de comando passadas pelo script runMe.bat<\/LI><\/UL><\/LI><\/UL>Curva de Taxa de Transferência<\/H2>O Relatório JMeter para um teste de carga em serviço de mapa em cache pode parecer lento e demorado quando visualizado em um navegador webIsso se deve à natureza padrão da sua composição, que tenta renderizar cada solicitação única em alguns dos gráficosEm um teste como este, haverá muitas delas<\/LI>No legenda do gráfico, selecione todos os itens JSR223 Sampler para desabilitar sua renderização (pois podem distorcer a escala)<\/LI><\/UL><\/LI><\/UL><\/LI>Neste caso, a taxa máxima para qualquer uma das transações na escala do mapa dos tiles em cache foi cerca de 15 transações por segundoComo 3 escalas do mapa foram testadas, o total de transações por segundo alcançado foi 45 transações por segundoIsto equivale a cerca de 162.000 transações em cache por hora <\/LI><\/UL><\/LI>A taxa máxima parece ocorrer no marco 10:34<\/LI><\/UL><\/LI><\/UL>

Curva de Desempenho<\/H2>O desempenho da taxa de transferência do cache foi bom, aproximadamente 120 ms ou 0,12 segundosEsta observação foi feita onde as transações máximas por segundo ocorreram no marco 10:34<\/LI><\/UL>PPNota: "Taxa máxima" é um ponto em um teste onde nenhuma taxa maior pode ser alcançada. Isso não significa que seja a quantidade máxima de pressão que o serviço suportará sem "falhar". De modo geral, se usuários adicionais solicitarem tiles em cache após o sistema ter atingido a taxa máxima (por exemplo, você aumentar a configuração step load), o serviço ainda atenderá suas solicitações, mas eles apenas esperarão mais tempo pelas respostas retornarem (devido à fila).<\font strong P<H1 id=\"toc-hId-1079327048\">Considerações Finais<\H1 P>O Plano de Teste Apache JMeter neste Artigo representa uma abordagem programática para aplicar carga a um serviço de mapa em cache ArcGIS. Uma das forças deste teste é que ele é fácil de construir, configurar e manter.<\P P>O relatório JMeter auto-gerado fornece gráficos e resumos que podem ser usados para analisar o desempenho e escalabilidade do serviço de mapa em cache.<\P UL LI>Para baixar o Plano de Teste Apache JMeter usado neste Artigo veja: A href=\"https:\/\community.esri.com\ccqpr47374\attachments\ccqpr47374\implementing-arcgis-blog\287.24\3\cache_tiles1.zip\" target=\"_self\">cache_tiles1.zipItens Adicionais que Merecem Menção

Cada serviço em cache é diferente. Mas geralmente falando, o desempenho e escalabilidade de um serviço em cache podem ser afetados por vários fatores:<\p ul li>Arquitetura de implantação

• A localização dos dados do cache com respeito ao(s) manipulador(es) ArcGIS tile
Tecnologia e velocidade do disco onde os dados do cache são armazenadosLargura de banda da rede
• Entre o armazenamento dos dados do cache e os manipuladores ArcGIS tile
Entre os manipuladores ArcGIS tile e os Adaptadores Web ArcGISEntre os Adaptadores Web ArcGIS e o Cliente TesteA velocidade do processador e número de núcleos
• A entrega dos tiles em cache é rápida mas sob carga pesada o processo geral utiliza recursos CPU dos manipuladores ArcGIS tile e Adaptadores Web ArcGIS (se existir na implantação) tecnologia hospedeira (por exemplo, serviço Internet Information Services da Microsoft)
Diferentes dados podem performar diferente
• Tamanho médio dos tiles (por exemplo, tamanho no disco)
  • Tamanhos menores dos tiles que contêm menos dados podem performar diferente dos tiles maiores mais detalhados
  Escalas testadas do mapa
  • Mesmo para o mesmo conjunto de dados, escala do mapa 36111.909643 pode ter tiles "mais pesados" que escala do mapa 1155581.108577
  Suposições e RestriçõesJDK 17 ou superior não funcionará com este Plano de Teste (JMeter 5.4.x)Executar nestas versões JDK lançará o seguinte erro: org.codehaus.groovy.GroovyBugError: BUG! exceção na fase 'semantic analysis' na unidade fonte 'Script161.groovy' Unsupported class file major version 61
Usar JDK 16 ou anterior evita este erroA razão é porque JMeter 5.4.x suporta apenas JDK 16 (ou anterior)Se JDK 17 ou superior for necessário para seu ambiente, você deve usar JMeter 5.5 (que suporta JDK 17)Cache On-Demand não está habilitado
• Pode funcionar mas não foi testado
Single Fused Map Cache está VERDADEIROO Formato de Armazenamento do cache é COMPACTOFormato da imagem dos tiles é JPG ou PNG
• Devido à regra Response Assertion para validar o retorno do servidor
O Plano de Teste incluído deve funcionar com um serviço em cache para
• Mapa
Imagem
• A variável ServiceType (sob Variáveis Definidas pelo Usuário) precisaria ser alterada
Não muito testadoVetor
• A variável ServiceType (sob Variáveis Definidas pelo Usuário) precisaria ser alterada
Imagens dos tiles do serviço VectorTile podem estar no Formato Binário Protocolbuffer (*.pbf)
• A regra Response Assertion precisaria expandir para incluir application/octet-stream ou application/x-protobuf
Os Samplers JSR223 dentro da transação GetMapTile precisariam ser ajustados para adicionar ".pbf" ao final da variável cacheRequestNão muito testado < /p p > < /p p > < /p p >Apache JMeter < /a > lançado sob a licença < /span >Apache < /a > < /span >Licença 2.0.<\/A> Apache, Apache JMeter, JMeter, a pena Apache e o logotipo do Apache JMeter são marcas registradas da 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.