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.

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

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

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:

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. In order 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:

You can now create the metrics by issuing the following command:

Finally, create a file named sysbench.yaml with the following definition of the component:

You can now create the component by issuing the following command:

Model the system

Here’s the definition of our system (system.yaml):

Here’s the definition of our mysql component (mysql.yaml):

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):

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. Reset Sysbench data

2. Configure MySQL

3. Restart MySQL

4. Launch the benchmark

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

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.