Akamas Docs
3.4.0
Ask or search…
K

Optimizing a MySQL server database running Sysbench

In this example study, we are going to optimize a MySQL instance by setting the performance goal of maximizing the throughput of operations towards the database.
As regards the workload generation, in this example we are going to use Sysbench, a popular open-source benchmarking suite.
To import the results of the benchmark into Akamas, we are going to use a custom script to convert its output to a CSV file that can be parsed by the CSV provider.

Environment Setup

In order to run the Sysbench suite against a MySQL installation, you need to first install and configure the two software. In the following , we will assume that both MySQL and Sysbench will run on the same machine, to obtain more significant results in terms of performance you might want to run them on separate hosts.
A set of scripts is provided to support all the setup steps.

MySQL Installation

To install MySQL please follow the official documentation. In the following, we will make a few assumptions on the location of the configuration files, the user running the server, and the location of the datafiles. These assumptions are based on a default installation of MySQL on an Ubuntu instance performed via apt.
  • Configuration file: /etc/mysql/conf.d/mysql.cnf
  • MySQL user: mysql
  • MySQL root user password: root
This is a template for the configuration file mysql.cnf.template
[mysqld]
socket=/tmp/mysql.sock
ssl=0
innodb_buffer_pool_size = ${mysql.mysql_innodb_buffer_pool_size}
innodb_thread_sleep_delay = ${mysql.mysql_innodb_thread_sleep_delay}
innodb_flush_method = ${mysql.mysql_innodb_flush_method}
innodb_log_file_size = ${mysql.mysql_innodb_log_file_size}
innodb_thread_concurrency = ${mysql.mysql_innodb_thread_concurrency}
innodb_max_dirty_pages_pct = ${mysql.mysql_innodb_max_dirty_pages_pct}
innodb_read_ahead_threshold = ${mysql.mysql_innodb_read_ahead_threshold}
If your installation of MySQL has different default values for these parameters please update the provided scripts accordingly.

Sysbench Installation

To install Sysbench on an ubuntu machine run the following command
sudo apt install sysbench
To verify your installation of Sysbench and initialize the database you can use the scripts provided here below and place them in the /home/ubuntu/scripts folder. Move in the folder, make sure MySQL is already running, and run the init-db.sh script.
This is the init-db.sh script:
#!/bin/bash
set -e
cd "$(dirname "$0")"
mysql -u root -proot -e "CREATE DATABASE IF NOT EXISTS sbtest"
HOST="--mysql-host=127.0.0.1 --mysql-port=3306 --mysql-user=root --mysql-password=root"
sysbench oltp_read_only --tables=10 --table_size=1000000 --threads=100 $HOST --time=300 --max-requests=0 --report-interval=1 --rand-type=uniform --db-driver=mysql --mysql-db=sbtest --mysql-ssl=off prepare| tee -a res.warmup.ro.txt
#sleep 5
#sudo systemctl stop mysql
#
##Create the backup
#echo "Backing up the database"
#sudo rm -rf /tmp/backup
#sudo mkdir /tmp/backup
#sudo rsync -r --progress /var/lib/mysql /tmp/backup/
#sleep 2
#
#sudo systemctl start mysql
#sudo systemctl status mysql
This script will:
  • connect to your MySQL installation
  • create a sbtest database for the test
  • run the Sysbench data generation phase to populate the database
The init-db.sh script contains some information on the amount of data to generate. The default setting is quite small and should be used for testing purposes. You can then modify the test to suit your benchmarking needs. If you update the script please also update the run_benchmark.sh script accordingly.

Optimization Setup

Here follow a step by step explanation of all the required configuration for this example. You can find attached a zip file that contains all of the YAML files for your convenience.

System

In this example, we are interested in optimizing MySQL settings and measuring the peak throughput measured using Sysbench. Hence, we are going to create two components:
  • A mysql component which represents the MySQL instance, including all the configuration parameters
  • A Sysbenchcomponent which represents Sysbench and contains the custom metrics reported by the benchmark

The Sysbench component

MySQL is a widespread technology and Akamas provides a specific Optimization Pack to support its optimization. Sysbench, on the other hand, is a benchmark application and is not yet supported by a specific optimization pack. To use it in our study, we will need to define its metrics first. This operation can be done once and the created component type can be used across many systems.
First, build a metrics.yamlfile with the following content:
metrics:
- name: throughput
description: The throughput of the database
unit: tps
- name: response_time_avg
description: The average response time of the database
unit: milliseconds
- name: response_time_95th
description: The response time 95th percentile of the database
unit: milliseconds
- name: duration
description: The duration of the task (load or benchmark execution)
unit: seconds
You can now create the metrics by issuing the following command:
akamas create metrics metrics.yaml
Finally, create a file named sysbench.yaml with the following definition of the component:
name: Sysbench
description: >
Sysbench benchmark. It is a purely synthetic benchmark that can create isolated contention on system resources. Each of the benchmark’s transaction imposes some load on three specific resources: CPU, disk I/O, and locks. It is also used to simulate a database workload.
parameters: []
metrics:
- name: throughput
- name: response_time_avg
- name: response_time_95th
- name: duration
You can now create the component by issuing the following command:
akamas create component-type sysbench.yaml

Model the system

Here’s the definition of our system (system.yaml):
1
name: MySQL-Sysbench
2
description: A system for optimizing MySQL with Sysbench
Here’s the definition of our mysql component (mysql.yaml):
name: mysql
description: MySQL
componentType: MySQL 8.0
properties:
hostname: gibbo.dev.akamas.io
sshPort: "22"
username: ubuntu
sourcePath: /home/ubuntu/scripts/my.cnf.template
targetPath: /home/ubuntu/scripts/my.cnf
prometheus:
instance: gibbo
job: mysql_exporter
key: |
-----BEGIN RSA PRIVATE KEY-----
...
-----END RSA PRIVATE KEY-----
Please make sure the component properties are correct for your environment (e.g. hostname, username, key, file paths, etc.).
Here’s the definition of our Sysbench component (sysbench.yaml):
name: Sysbench
description: Sysbench Benchmark for database systems
componentType: Sysbench
We can create the system by running:
akamas create system system.yaml
We can then create the components by running the following commands:
akamas create component mysql.yaml MySQL-Sysbench
akamas create component sysbench.yaml MySQL-Sysbench

Workflow

A workflow for optimizing MySQL can be structured in 6 tasks:
  1. 1.
    Reset Sysbench data
  2. 2.
    Configure MySQL
  3. 3.
    Restart MySQL
  4. 4.
    Launch the benchmark
  5. 5.
    Parse the benchmark results
Here below you can find the scripts that codify these tasks.
This is the restart-mysql.sh script:
#!/usr/bin/env bash
set -e
cd "$(dirname "$0")"
#Stop the DB
echo "Stopping MySQL"
sudo systemctl stop mysql &> /dev/null
#sudo systemctl status mysql
#Apply Configuration
echo "Copying the configuration"
sudo cp my.cnf /etc/mysql/conf.d/mysql.cnf
sync; sudo sh -c "echo 3 > /proc/sys/vm/drop_caches"; sync
#Restart DB
echo "Restarting the database"
sudo systemctl start mysql &> /dev/null
#sudo systemctl status mysql
sleep 2
This is the clean_bench.sh script:
#!/usr/bin/env bash
set -e
cd "$(dirname "$0")"
if ! test -d results || [[ -z "$(ls -A results)" ]]; then
echo "First iteration"
mkdir -p results
exit 0
fi
rm -rf results
mkdir -p results
This is the run_test.sh script:
#!/bin/bash
set -e
cd "$(dirname "$0")"
HOST="--mysql-host=127.0.0.1 --mysql-port=3306 --mysql-user=root --mysql-password=root"
sysbench oltp_read_only --tables=10 --table_size=1000000 --threads=100 $HOST --time=60 --max-requests=0 --report-interval=1 --rand-type=uniform --db-driver=mysql --mysql-db=sbtest --mysql-ssl=off run | tee -a results/res.txt
This file parse_csv.sh script:
#!/bin/bash
set -e
cd "$(dirname "$0")"
OUTFILE=$(pwd)/results/output.csv
INFILE=$(pwd)/results/res.txt
COMPONENT=Sysbench
epoch_now=$(date +"%s")
num_samples=$(grep -c "thds" ${INFILE})
epoch_start=$(($epoch_now - $num_samples))
cat $INFILE | while read line
do
ts_sysbench=$(echo $line | cut -d' ' -f2)
# CSV header
[ "$ts_sysbench" == "started!" ] && echo "component,ts,throughput,response_time_95pct" > ${OUTFILE} && continue
# CSV body
tps=$(echo $line | cut -d' ' -f7)
lat_95pct=$(echo $line | cut -d' ' -f14)
# skip unless it's a metric line
echo $line | grep -q "thds" || continue
ts_seconds=$(echo $ts_sysbench | sed 's/s//')
epoch_current=$(($epoch_start + $ts_seconds))
ts=$(date -d @$(($epoch_current)) "+%Y-%m-%d %H:%M:%S")
echo "${COMPONENT},$ts,$tps,$lat_95pct" >> ${OUTFILE}
done
Here is the complete Akamas workflow for this example (workflow.yaml):
name: MySQL-Sysbench
tasks:
- name: Reset Sysbench data
operator: Executor
arguments:
command: "bash /home/ubuntu/scripts/clean_bench.sh"
component: mysql
- name: Configure MySQL
operator: FileConfigurator
arguments:
component: mysql
- name: Restart MySQL
operator: Executor
arguments:
command: "bash /home/ubuntu/scripts/restart-mysql.sh"
component: mysql
- name: test
operator: Executor
arguments:
command: "bash /home/ubuntu/scripts/run_test.sh"
component: mysql
- name: Parse CSV results
operator: Executor
arguments:
command: "bash /home/ubuntu/scripts/parse_csv.sh"
component: mysql
You can create the workflow by running:
akamas create workflow workflow.yaml

Telemetry

We are going to use Akamas telemetry capability to import the metrics related to Sysbench benchmark results, in particular, the transaction throughput and latency. To achieve this we can leverage the Akamas CSV provider, which extracts metrics from CSV files. The CSV file is the one produced in the last task of the workflow of the study.
This telemetry provider can be installed running:
akamas install telemetry-provider telemetry/providers/csv.yaml
To start using the provider, we need to define a telemetry instance (csv.yaml):
provider: csv
config:
protocol: scp
address: gibbo.dev.akamas.io
username: ubuntu
authType: key
auth: |
-----BEGIN RSA PRIVATE KEY-----
-----END RSA PRIVATE KEY-----
remoteFilePattern: /home/ubuntu/scripts/results/output.csv
csvFormat: horizontal
componentColumn: component
timestampColumn: ts
timestampFormat: yyyy-MM-dd HH:mm:ss
metrics:
- metric: throughput
datasourceMetric: throughput
- metric: response_time_95th
datasourceMetric: response_time_95pct
Please make sure the telemetry configuration is correct for your environment (e.g. hostname, username, key, file paths, etc.).
You can create the telemetry instance and attach it to the system by running:
akamas create telemetry-instance csv.yaml MySQL-Sysbench

Study

In this example, we are going to leverage Akamas AI-driven optimization capabilities to maximize MySQL database transaction throughput, as measured by the Sysbench benchmark.
Here is the Akamas study definition (study.yaml):
name: MySQL Sysbench Tuning
description: Tuning of mysql-8 with Sysbench benchmark
system: MySQL-Sysbench
workflow: MySQL-Sysbench
goal:
objective: maximize
function:
formula: Sysbench.throughput
constraints: []
# Akamas score automatically trim 1m of warm-up and 1m of tear-down
windowing:
task: test
type: trim
trim: [1m, 1m]
# We optimize some common MySQL parameters
parametersSelection:
- name: mysql.mysql_innodb_buffer_pool_size
domain: [5242880, 10485760]
- name: mysql.mysql_innodb_thread_sleep_delay
domain: [1,3000]
- name: mysql.mysql_innodb_flush_method
- name: mysql.mysql_innodb_log_file_size
- name: mysql.mysql_innodb_thread_concurrency
domain: [0, 4]
- name: mysql.mysql_innodb_max_dirty_pages_pct
- name: mysql.mysql_innodb_read_ahead_threshold
# The metrics we are interested in
metricsSelection:
- Sysbench.throughput
- Sysbench.response_time_95th
# Each experiment can run multiple trials to evaluate stability
numberOfTrials: 1
steps:
# We first run a baseline experiment with default values
- name: baseline
type: baseline
renderParameters: ["mysql.*"]
# We then optimize for 200 experiments
- name: optimize
type: optimize
optimizer: AKAMAS
numberOfExperiments: 200
maxFailedExperiments: 200
renderParameters: ["mysql.*"]
You may need to update some parameter domains based on your environment (e.g. InnoDB buffer pool size maximum value depends on your server available memory)
You can create the study by running:
akamas create study study.yaml
You can then start it by running:
akamas start study "MySQL Sysbench Tuning"
You can now follow the study progress using the UI and explore the results using the Analysis and Metrics tabs.
Last modified 1mo ago