Cómo seguir los benchmarks en CI con Bencher

La mayoría de los resultados de los benchmarks son efímeros. Desaparecen tan pronto como su terminal alcanza su límite de desplazamiento. Algunos sistemas de benchmark permiten cachear los resultados, pero la mayoría solo lo hacen localmente. Bencher le permite rastrear sus benchmarks tanto de ejecuciones locales como de CI y comparar los resultados, mientras sigue utilizando su sistema de benchmark favorito.

Hay dos maneras populares de comparar resultados de benchmarks cuando se hace Benchmarking Continuo, es decir, benchmarking en CI:

• Benchmarking Continuo Estadístico
  1. Rastrear los resultados de los benchmarks a lo largo del tiempo para crear una línea base
  2. Usar esta línea base junto con Umbrales Estadísticos para crear un límite estadístico
  3. Comparar los nuevos resultados contra este límite estadístico para detectar regresiones de rendimiento
• Benchmarking Continuo Relativo
  1. Ejecutar los benchmarks para el código base actual
  2. Usar Umbrales Porcentuales para crear un límite para el código base
  3. Cambiar a la nueva versión del código
  4. Ejecutar los benchmarks para la nueva versión del código
  5. Comparar los resultados de la nueva versión del código contra los resultados del código base para detectar regresiones de rendimiento

Benchmarking Continuo Estadístico

Continuando donde nos quedamos en los tutoriales Inicio Rápido y Docker Autogestionado, agreguemos Benchmarking Continuo Estadístico a nuestro proyecto Save Walter White.

🐰 Asegúrate de haber creado un token de API y establecerlo como la variable de entorno BENCHER_API_TOKEN antes de continuar.

Primero, necesitamos crear un nuevo Testbed para representar nuestros ejecutores de CI, con el nombre adecuado ci-runner.

bencher testbed create \
--name ci-runner \
save-walter-white-1234abcd

1. Utiliza el subcomando CLI bencher testbed create. Consulta los documentos de testbed create para más detalles. (ej: bencher testbed create)
2. Establece la opción --name con el nombre deseado para el Testbed. (ej: --name ci-runner)
3. Especifica el argumento del proyecto como el slug del proyecto Save Walter White. (ej: save-walter-white-1234abcd)

A continuación, necesitamos crear un nuevo Umbral para nuestro Testbed ci-runner:

bencher threshold create \
--branch main \
--testbed ci-runner \
--measure Latency \
--test t-test \
--upper-boundary 0.95 \
save-walter-white-1234abcd

1. Utiliza el subcomando CLI bencher threshold create. Consulta los documentos de threshold create para más detalles. (ej: bencher threshold create)
2. Establece la opción --branch en la rama main por defecto. (ej: --branch main)
3. Establece la opción --testbed en el nuevo Testbed ci-runner. (ej: --testbed ci-runner)
4. Establece la opción --measure en la Medida Latency incorporada que se genera por bencher mock. Consulta la definición de Medida para más detalles. (ej: --measure Latency)
5. Establece la opción --test a un umbral de t-test. Consulta Umbrales y Alertas para una visión completa. (ej: --test t-test)
6. Establece la opción --upper-boundary a un Límite Superior de 0.95. Consulta Umbrales y Alertas para una visión completa. (ej: --upper-boundary 0.95)
7. Especifica el argumento del proyecto como el slug del proyecto Save Walter White. (ej: save-walter-white-1234abcd)

Ahora estamos listos para ejecutar nuestros benchmarks en CI. Dado que cada entorno de CI es un poco diferente, el siguiente ejemplo está destinado a ser más ilustrativo que práctico. Para ejemplos más específicos, ver Benchmarking Continuo en GitHub Actions y Benchmarking Continuo en GitLab CI/CD.

Necesitamos crear y mantener una línea base histórica para nuestra rama main al realizar benchmarks de cada cambio en CI:

bencher run \
--project save-walter-white-1234abcd \
--branch main \
--testbed ci-runner \
--adapter json \
--err \
bencher mock

1. Utiliza el subcomando CLI bencher run para ejecutar los benchmarks de tu rama feature-branch. Consulta el subcomando CLI bencher run para una visión completa. (ej: bencher run)
2. Establece la opción --project al slug del proyecto. Consulta los documentos de --project para más detalles. (ej: --project save-walter-white-1234abcd)
3. Establece la opción --branch al nombre de la Rama por defecto. Consulta selección de rama para una visión completa. (ej: --branch main)
4. Establece la opción --testbed al nombre del Testbed. Consulta los documentos de --testbed para más detalles. (ej: --testbed ci-runner)
5. Establece la opción --adapter al adaptador de arnés de benchmark deseado. Consulta adaptadores de arnés de benchmark para una visión completa. (ej: --adapter json)
6. Establece la bandera --err para fallar el comando si se genera una Alerta. Consulta Umbrales y Alertas para una visión completa. (ej: --err)
7. Especifica los argumentos del comando de benchmark. Consulta comando de benchmark para una visión completa. (ej: bencher mock)

Finalmente, estamos listos para detectar regresiones de rendimiento en CI. Así es como rastrearíamos el rendimiento de una nueva rama de característica, llamada feature-branch, en CI:

bencher run \
--project save-walter-white-1234abcd \
--branch feature-branch \
--branch-start-point main \
--branch-start-point-hash 32aea434d751648726097ed3ac760b57107edd8b \
--testbed ci-runner \
--adapter json \
--err \
bencher mock

1. Utiliza el subcomando CLI bencher run para ejecutar los benchmarks de tu rama feature-branch. Consulta el subcomando CLI bencher run para una visión completa. (ej: bencher run)
2. Establece la opción --project al slug del proyecto. Consulta los documentos de --project para más detalles. (ej: --project save-walter-white-1234abcd)
3. Establece la opción --branch al nombre de la rama de característica. Consulta selección de rama para una visión completa. (ej: --branch feature-branch)
4. Establece la opción --branch-start-point al punto de inicio de la rama de característica. Consulta selección de rama para una visión completa. (ej: --branch-start-point main)
5. Establece la opción --branch-start-point-hash al hash git del punto de inicio de la rama de característica. Consulta selección de rama para una visión completa. (ej: --branch-start-point-hash 32ae...dd8b)
6. Establece la opción --testbed al nombre del Testbed. Consulta los documentos de --testbed para más detalles. (ej: --testbed ci-runner)
7. Establece la opción --adapter al adaptador de arnés de benchmark deseado. Consulta adaptadores de arnés de benchmark para una visión completa. (ej: --adapter json)
8. Establece la bandera --err para fallar el comando si se genera una Alerta. Consulta Umbrales y Alertas para una visión completa. (ej: --err)
9. Especifica los argumentos del comando de benchmark. Consulta comando de benchmark para una visión completa. (ej: bencher mock)

La primera vez que este comando se ejecute en CI, creará la rama feature-branch ya que aún no existe. La nueva rama feature-branch usará la rama main en el hash 32aea434d751648726097ed3ac760b57107edd8b como su punto de inicio. Esto significa que feature-branch tendrá una copia de todos los datos y Umbrales de la rama main para comparar los resultados de bencher mock contra, para la primera y todas las ejecuciones subsiguientes.

Benchmarking Continuo Relativo

Retomando donde lo dejamos en los tutoriales Inicio Rápido y Docker Autohospedado, vamos a añadir Benchmarking Continuo Relativo a nuestro proyecto Save Walter White.

🐰 Asegúrate de haber creado un token de API y establecerlo como la variable de entorno BENCHER_API_TOKEN antes de continuar.

Primero, necesitamos crear un nuevo Testbed para representar nuestros corredores de CI, con el nombre apropiado de ci-runner.

bencher testbed create \
--name ci-runner \
save-walter-white-1234abcd

1. Usa el subcomando CLI de bencher testbed create. Consulta los documentos de testbed create para más detalles. (ej: bencher testbed create)
2. Establece la opción --name al nombre de Testbed deseado. (ej: --name ci-runner)
3. Especifica el argumento de proyecto como el slug del proyecto Save Walter White. (ej: save-walter-white-1234abcd)

El Benchmarking Continuo Relativo ejecuta una comparación lado a lado de dos versiones de tu código. Esto puede ser útil al tratar con ambientes CI/CD ruidosos, donde los recursos disponibles pueden variar mucho entre ejecuciones. En este ejemplo estaremos comparando los resultados de ejecutar en la rama main con resultados de ejecutar en una rama de características llamada feature-branch. Dado que cada ambiente CI es un poco diferente, el siguiente ejemplo está destinado a ser más ilustrativo que práctico. Para ejemplos más específicos, consulta Benchmarking Continuo en GitHub Actions y Benchmarking Continuo en GitLab CI/CD.

Primero, necesitamos hacer checkout de la rama main con git en CI:

git checkout main

Luego necesitamos ejecutar nuestros benchmarks en la rama main en CI:

bencher run \
--project save-walter-white-1234abcd \
--branch feature-branch \
--branch-reset \
--testbed ci-runner \
--adapter json \
bencher mock

1. Usa el subcomando CLI de bencher run para ejecutar tus benchmarks de la rama main. Consulta el subcomando CLI bencher run para una visión general completa. (ej: bencher run)
2. Establece la opción --project al slug del Proyecto. Consulta los documentos de --project para más detalles. (ej: --project save-walter-white-1234abcd)
3. Establece la opción --branch al nombre de la rama de característica. Consulta selección de rama para una visión general completa. (ej: --branch feature-branch)
4. Activa la bandera --branch-reset. Consulta selección de rama para una visión general completa. (ej: --branch-reset)
5. Establece la opción --testbed al nombre del Testbed. Consulta los documentos de --tested para más detalles. (ej: --testbed ci-runner)
6. Establece la opción --adapter al adaptador de arnés de benchmark deseado. Consulta adaptadores de arnés de benchmark para una visión general completa. (ej: --adapter json)
7. Especifica los argumentos del comando de benchmark. Consulta comando de benchmark para una visión general completa. (ej: bencher mock)

La primera vez que este comando se ejecute en CI, creará la rama feature-branch ya que aún no existe. La nueva feature-branch no tendrá un punto de inicio, datos existentes, ni Umbrales. En las ejecuciones subsiguientes, la versión antigua de feature-branch será renombrada y se creará una nueva feature-branch sin un punto de inicio, datos existentes, ni Umbrales.

A continuación, necesitamos crear un nuevo Umbral en CI para nuestra nueva rama feature-branch:

bencher threshold create \
--branch feature-branch \
--testbed ci-runner \
--measure Latency \
--test percentage \
--upper-boundary 0.25 \
save-walter-white-1234abcd

1. Usa el subcomando CLI de bencher threshold create. Consulta los documentos de threshold create para más detalles. (ej: bencher threshold create)
2. Establece la opción --branch a la nueva rama feature-branch. (ej: --branch feature-branch)
3. Establece la opción --branch al Testbed ci-runner. (ej: --testbed ci-runner)
4. Establece la opción --measure a la Medida Latency incorporada que es generada por bencher mock. Consulta la definición de Medida para detalles. (ej: --measure Latency)
5. Establece la opción --test a un Umbral de percentage. Consulta Umbrales & Alertas para una visión general completa. (ej: --test t-test)
6. Establece la opción --upper-boundary a un Límite Superior de 0.25 (es decir, 25%). Consulta Umbrales & Alertas para una visión general completa. (ej: --upper-boundary 0.25)
7. Especifica el argumento de proyecto como el slug del proyecto Save Walter White. (ej: save-walter-white-1234abcd)

Luego, necesitamos hacer checkout de la rama feature-branch con git en CI:

git checkout feature-branch

Finalmente, estamos listos para ejecutar nuestros benchmarks de feature-branch en CI:

bencher run \
--project save-walter-white-1234abcd \
--branch feature-branch \
--testbed ci-runner \
--adapter json \
--err \
bencher mock

1. Usa el subcomando CLI de bencher run para ejecutar tus benchmarks de feature-branch. Consulta el subcomando CLI bencher run para una visión general completa. (ej: bencher run)
2. Establece la opción --project al slug del Proyecto. Consulta los documentos de --project para más detalles. (ej: --project save-walter-white-1234abcd)
3. Establece la opción --branch al nombre de la rama de característica. Consulta selección de rama para una visión general completa. (ej: --branch feature-branch)
4. Establece la opción --testbed al nombre del Testbed. Consulta los documentos de --tested para más detalles. (ej: --testbed ci-runner)
5. Establece la opción --adapter al adaptador de arnés de benchmark deseado. Consulta adaptadores de arnés de benchmark para una visión general completa. (ej: --adapter json)
6. Activa la bandera --err para fallar el comando si se genera una Alerta. Consulta Umbral & Alertas para una visión general completa. (ej: --err)
7. Especifica los argumentos del comando de benchmark. Consulta comando de benchmark para una visión general completa. (ej: bencher mock)

Cada vez que este comando se ejecute en CI, está comparando los resultados de feature-branch solo con los resultados más recientes de main.

🐰 ¡Felicidades! Has aprendido cómo seguir los benchmarks en CI con Bencher! 🎉

Agregar Bencher a GitHub Actions ➡

Agregar Bencher a GitLab CI/CD ➡