Mostrando entradas con la etiqueta RPS. Mostrar todas las entradas
Mostrando entradas con la etiqueta RPS. Mostrar todas las entradas

miércoles, 6 de agosto de 2014

Evaluando nuestro RPS actual de los servicios de Sharepoint - Parte 2

Parte 1 - Realizando un capacity planning efectivo definiendo correctamente el RPS

Part 2   - Evaluando nuestro RPS actual de los servicios de Sharepoint (acá estamos)

La segunda parte de esta serie de post, es evaluar los RPS reales sobre una ambiente actual. Por ej: nos podría servir si estamos migrando de una granja de Sharepoint 2010 a 2013.

Vamos a usar el siguiente script: http://1drv.ms/1okT5Kg (al final del post también se los dejo)

Guardar los archivos del archivo descargado, y dejar todos los logs del IIS en la misma carpeta. Por ej: u_ex14081.log está en el mismo directorio que el script.

image

El script tomará cada archivo .log y lo procesará para generar por hora el valor más alto (peak) de RPS, y lo guardará en el archivo resultadosrpsTemp.csv. Después se toma los datos del archivo generado, y los cargas en el archivo ResultadosRPS.xlsx.

image

Como pueden ver se generó el archivo resultadosrpsTemp.csv

image

Abro el archivo resultadosrpsTemp.csv y ResultadosRPS.xlsx. Copio los datos de un archivo al otro.

image

En el gráfico veo que el máximo pico de RPS fue a las 11 hs. Las horas con más througput fueron desde las 6 am hasta las 18 hs, lo que da 12 hs de trabajo (recuerdan la variable D de la fórmula para calcular los RPS en el post anterior)

image

Si vemos el promedio de RPS en esas horas de trabajo, vemos que no da 100.30 RPS en promedio. Si lo comparamos con la estimación inicial de RPS del post anterior, vemos que nos quedamos corto con los RPS que iba a soporta la plataforma (60 RPS)

image

image

Ya con 100 RPS, estamos en el límite de los RPS soportados por un sólo WFE. Obviamente dependerá mucho de su plataforma (ej: Blob cache, cantidad de recursos del servidor, etc).

Ahora lo que voy a calcular es la cantidad de usuarios por minuto que tengo, de esta manera podré sacar la concurrencia del sistema (variable B de nuestra fórmula). La ejecución es muy similar al script anterior, dejo los logs del IIS en el mismo folder donde está el script.

Descargar Script powershell: http://1drv.ms/1qUD54O

image

Una vez ejecutado nos dejará el archivo resultadosUsuarios.csv

image

Copio los resultados al excel ResultadosUsuariosXHora.xlsx, y obtengo el peak de usuarios por hora.En este ejemplo: 197 usuarios de forma concurrente. Se podría obtener por minutos, pero prefiero por hora, así obtenemos un pico más alto de usuarios y estimamos hacia arriba.

image

Para finalizar, les dejo la querie para obtener la cantidad de usuarios que accedieron a la plataforma:

SELECT cs-username As User FROM c:\inetpub\logs\LogFiles\W3SVC1\*.log WHERE User Is Not Null GROUP BY User

Si tienes varios web applications, deberás ejecutar este script por cada folder del IIS (asociados a un web application) y consolidar resultados (Ej: en el excel es muy simple: http://office.microsoft.com/en-us/excel-help/filter-for-unique-values-or-remove-duplicate-values-HP010073943.aspx)

Con estos scripts ya tenemos todas las variables necesarias para hacer un capacity planning continuo.

En el próximo post, estaré realizando load testing con Visual Studio 2013, para ver si realmente la infraestructura soporta el nivel de usuarios/RPS planificados.

SCRIPTS UTILIZADOS

GET RPS FROM IIS LOGS

$programfiles = (Get-Childitem 'Env:\ProgramFiles(x86)').Value
$logParser = $programfiles + "\Log Parser 2.2\LogParser.exe"
$psScriptRoot = Split-Path -Parent -Path (Get-Item -Path $MyInvocation.MyCommand.Path).FullName;

Write-Host "Step 1 - Processing log files to single source for querying..." -ForegroundColor Cyan
Start-Process -FilePath $logParser -ArgumentList "-i:IISW3C file:'rpsquery1.txt' -o:csv -q" -WorkingDirectory $psScriptRoot -RedirectStandardOutput "$psScriptRoot\rps1.csv" -Wait -WindowStyle Hidden
Write-Host "Done" -ForegroundColor Green

Write-Host "Step 2 - Calculating per second distribution..." -ForegroundColor Cyan
Start-Process -FilePath $logParser -ArgumentList "-i:CSV –o:CSV `"select count(*) as ct,secs,max(ss) as ss,max(mi) as mi,max(hh) as hh from rps1.csv group by secs order by secs`" -q" -WorkingDirectory $psScriptRoot -RedirectStandardOutput "$psScriptRoot\rps2.csv" -Wait -WindowStyle Hidden
Write-Host "Done" -ForegroundColor Green

Write-Host "Step 3 - Calculating per minute distribution..." -ForegroundColor Cyan
Start-Process -FilePath $logParser -ArgumentList "-i:CSV –o:CSV `"select count(*) as ct,div(secs,60) as minu,max(ss) as ss,max(mi) as mi,max(hh) as hh from rps1.csv group by minu order by minu`" -q" -WorkingDirectory $psScriptRoot -RedirectStandardOutput "$psScriptRoot\rps3.csv" -Wait -WindowStyle Hidden
Write-Host "Done" -ForegroundColor Green

Write-Host "Step 4 - Calculating hourly average, per minute peak and per second peak..." -ForegroundColor Cyan
Start-Process -FilePath $logParser -ArgumentList "-i:CSV –o:CSV `"select hh,avg(ct) from rps3.csv group by hh order by hh`" -q" -WorkingDirectory $psScriptRoot -RedirectStandardOutput "$psScriptRoot\Havg.csv" -Wait -WindowStyle Hidden
Start-Process -FilePath $logParser -ArgumentList "-i:CSV –o:CSV `"select hh,max(div(ct,60)) from rps3.csv group by hh order by hh`" -q" -WorkingDirectory $psScriptRoot -RedirectStandardOutput "$psScriptRoot\Mpeak.csv" -Wait -WindowStyle Hidden
Start-Process -FilePath $logParser -ArgumentList "-i:CSV –o:CSV `"select hh,max(ct) from rps2.csv group by hh order by hh`" -q" -WorkingDirectory $psScriptRoot -RedirectStandardOutput "$psScriptRoot\Speak.csv" -Wait -WindowStyle Hidden
Write-Host "Done" -ForegroundColor Green

Write-Host "Step 5 - Combining outputs..." -ForegroundColor Cyan
$results = @{}
$results["Havg"] = @{}
$results["Mpeak"] = @{}
$results["Speak"] = @{}

$havg = Import-Csv $psScriptRoot\havg.csv
$i = 0
while ($i -le 23) {
    $results["Havg"][$i] = $havg[$i].'AVG(ALL ct)'
    $i++
}
$Mpeak = Import-Csv $psScriptRoot\Mpeak.csv
$i = 0
while ($i -le 23) {
    $results["Mpeak"][$i] = $Mpeak[$i].'MAX(ALL DIV(ct, 60))'
    $i++
}
$Speak = Import-Csv $psScriptRoot\Speak.csv
$i = 0
while ($i -le 23) {
    $results["Speak"][$i] = $Speak[$i].'MAX(ALL ct)'
    $i++
}

$newline = [System.Environment]::NewLine
$output = "Hour`tHavg`tMpeak`tSpeak" + $newline
$i = 0
while ($i -le 23) {
    $output = $output + [String]::Format("{3}`t{0}`t{1}`t{2}" + $newline, $results["Havg"][$i], $results["Mpeak"][$i], $results["Speak"][$i], $i)
    $i++
}
$output | Out-File $psScriptRoot\results.csv
Write-Host "Done" -ForegroundColor Green

Write-Host "Step 6 - Cleaning up temp files..." -ForegroundColor Cyan
Remove-Item $psScriptRoot\rps1.csv
Remove-Item $psScriptRoot\rps2.csv
Remove-Item $psScriptRoot\rps3.csv
Remove-Item $psScriptRoot\Havg.csv
Remove-Item $psScriptRoot\Mpeak.csv
Remove-Item $psScriptRoot\Speak.csv
Write-Host "Done" -ForegroundColor Green

 

GET USER PER MINUTE FROM IISLOGS

$logParserPath = "C:\Program Files (x86)\Log Parser 2.2\LogParser.exe"
$pathScript = Split-Path -Parent -Path (Get-Item -Path $MyInvocation.MyCommand.Path).FullName;

Write-Host "Paso 1 - Proceso los logs..." -ForegroundColor Red
Start-Process -FilePath $logParserPath -ArgumentList "-i:IISW3C file:'query.txt' -o:csv -q" -WorkingDirectory $pathScript -RedirectStandardOutput "$pathScript\usuariosTemp.csv" -Wait -WindowStyle Hidden
Write-Host "Finalizado" -ForegroundColor Green

Write-Host "Paso 2 - Calculo la distribucion de usuarios..." -ForegroundColor Red
Start-Process -FilePath $logParserPath -ArgumentList "-i:CSV –o:CSV `"select count(*) as ct,cs-username,secs,max(ss) as ss,max(mi) as mi,max(hh) as hh from usuariosTemp.csv group by secs,cs-username order by secs,cs-username`" -q" -WorkingDirectory $pathScript -RedirectStandardOutput "$pathScript\usuariosTemp1.csv" -Wait -WindowStyle Hidden
Write-Host "Finalizado" -ForegroundColor Green
 
Write-Host "Paso 3 - Consolido hora..." -ForegroundColor Red
Start-Process -FilePath $logParserPath -ArgumentList "-i:CSV –o:CSV `"select hh,cs-username,sum(ct) as req from usuariosTemp1.csv group by hh,cs-username order by hh,cs-username`" -q" -WorkingDirectory $pathScript -RedirectStandardOutput "$pathScript\MaximosUsersTemp.csv" -Wait -WindowStyle Hidden
Write-Host "Finalizado" -ForegroundColor Green

Write-Host "Paso 4 - Agrupo hora x usuarios" -ForegroundColor Red
Start-Process -FilePath $logParserPath -ArgumentList "-i:CSV –o:CSV `"select hh,count(*) from MaximosUsersTemp.csv group by hh`" -q" -WorkingDirectory $pathScript -RedirectStandardOutput "$pathScript\UsuariosXHora.csv" -Wait -WindowStyle Hidden
Write-Host "Finalizado" -ForegroundColor Green


Write-Host "Paso 5 - Genero el excel..." -ForegroundColor Red
$results = @{}
$results["UsuariosXHora"] = @{}

$PicoXHora = Import-Csv $pathScript\UsuariosXHora.csv

$i = 0
while ($i -le 23) {
    $results["UsuariosXHora"][$i] = $PicoXHora[$i].'COUNT(ALL *)'
    $i++
}

$newline = [System.Environment]::NewLine
$output = "Hora`tUsuariosXHora" + $newline
$i = 0
while ($i -le 23) {
    $output = $output + [String]::Format("{1}`t{0}" + $newline, $results["UsuariosXHora"][$i], $i)
    $i++
}
$output | Out-File $pathScript\resultadosUsuarios.csv


Remove-Item $pathScript\usuariosTemp.csv
Remove-Item $pathScript\usuariosTemp1.csv
Remove-Item $pathScript\MaximosUsersTemp.csv
Remove-Item $pathScript\UsuariosXHora.csv
Write-Host "Finalizado" -ForegroundColor Green 

domingo, 3 de agosto de 2014

Realizando un capacity planning efectivo definiendo correctamente el RPS– Parte 1

Este artículo se dividirá en 3 post:

Un capacity planning es el conjunto de actividades que planea el arquitecto de Sharepoint para obtener una arquitectura de implementación adecuada para un deployment de Sharepoint. Debe ser un proceso continuo, donde se evalue de forma continua y planificada la arquitectura de Sharepoint.

Capacity Management Model

Cuando hacemos un capacity planning, una de las cosas que hay que planear es la cantidad de usuarios que va a soportar la granja de Sharepoint. Para ello usaremos RPS (request per second) cómo una métrica del capacity. Es el número de request recibidos por una granja o server en un segundo. Para este post, no tomaré en cuenta los request 401 (que suelen ser de authentication handshake). También se lo suele llamar throughput.EL RPS es una de las estadísticas a conocer para planificar el capacity planning, pero hay muchas más que no abordaré en este post (Ej: storage)

Definamos dos conceptos primero: Green Zone y Red Zone. Una green zone es un conjunto de características del servicio de Sharepoint sobre condiciones normales de uso. Puede llegar hasta picos altos de uso (daily peaks loads), pero si se opera sobre esta rango se obtiene tiempos de respuestas y/o latencia estables o aceptables. En cambio una red zone es un conjunto de características del servicio de Sharepoint bajo condiciones de uso intensivos, en esta zona se experimenta demanda de recursos muy altos, donde puede ocurrir sobre un período de tiempo constante hasta la falla del sistema. En la hoja 2 del excel que linkeo, tendrá condiciones de estas zonas.

Para estimar suponemos lo siguiente, después veremos de refinar un poco esta estimación:

  • 10.000 usuarios en nuestra organización
  • 30% de concurrencia –> 3000 usuarios concurrentes

Podemos hacer una estimación de alto nivel (en inglés “rough”) para evaluar los RPS:

(Número de Usuarios X Porcentaje de usuarios que están activos) ÷ Request rate

Donde Request rate es el promedio de solicitudes por hora () que un usuario puede generar.

En este caso: (10.000 x 30%) / 60 RPH = 50 RPS (aproximadamente, “rough” estimación)

Estos datos son promedios, lo que voy a hacer es afinar este valor, ya que puede haber varios tipos de usuarios (light, medium, extreme) que acceden a la granja.

A. Número de usuarios: número total de usuarios que acceden a Sharepoint, en este ejemplo 10.000 usuarios.

B. Porcentaje de usuarios activos: En este ejemplo, 30% = 3000 usuarios activos

C. Operaciones por usuario por día: una operación puede ser una búsqueda, descargar un documento, bajar una imagen/banner, descargar javascript, etc. Se supone en general entorno a 45 x hora (puede variar dependiendo de su organización, en un segundo post voy a evaluar este punto, junto a la cantidad de usuarios activos)

D. Horas de trabajo (business day): en entornos distribuidos (varios países), suele ser de 8 hs (depende de tu organización y distribución)

E. Factor de carga máxima: es una proporción de cuanto se excede el uso promedio de la plataforma. Suele ser 3:1, si quieres asegurarte que no tendrás problemas de performance lo puedes subir 5:1

Fórmula: (A x B x C x E) ÷ (3600 x D)

image

Decargar excel: http://1drv.ms/1qIHyHN

Cómo se muestra la imagen, la granja soportará 60 RPS, lo cual nos lleva a implementar un sólo WFE. Recuerda evaluar este número cada 3 meses dependiendo de tu workload (carga de trabajo) de la granja.

También se suele elevar un poco el % de concurrencia, para mostrar un “pico” concurrencia, ej: 60% para evitar problemas futuros de concurrencia. Yo suelo dejarlo en 30%, pero como siempre les digo, depende mucho de cada ambiente.

En el siguiente gráfico  ofrecido por Microsoft podemos ver como escala los RPS agregando más WFE. Fuente: http://technet.microsoft.com/en-us/library/ff758657%28v=office.15%29.aspx

This graph shows the RPS baseline for both Green and Red zones.

Ahora extrapolamos el gráfico anterior con los valores que nos surgió del capacity planning sobre la granja nuestra y concluimos que:

0-60 RPS –> Green Zone

>60 RPS –> Red Zone

Fuentes:

http://technet.microsoft.com/en-us/library/ff758645%28v=office.15%29.aspx

http://technet.microsoft.com/en-us/library/ff608068%28v=office.15%29.aspx

http://technet.microsoft.com/en-us/library/ff758657%28v=office.15%29.aspx