A component represents an element of a system. Typically, systems are made up of different entities and layers which can be modeled by components. In other words, a system can be considered a collection of related components.

Notice that a component is a black-box definition of each entity involved in an optimization study, so detailed modeling of the entities being involved in the optimization is not required. The only relevant elements are the parameters that are involved in the optimization and the metrics that are collected to evaluate the results of such an optimization.

Notice that only the entities that are directly involved in the optimization need to be modeled and defined within Akamas. An entity is involved in an optimization study if it is optimized or monitored by Akamas, where "optimized" means that Akamas is optimizing at least one of its parameters, and "monitored" means that Akamas is monitoring at least one of its metrics.

Construct

A component is described by the following mandatory properties (other properties can be defined but are not mandatory):

• a name that uniquely identifies the component within the system

• a description that clarifies what the component refers to

• a component type that identifies the technology of the component (see component type)

In general, a component contains a set of each of the following:

• parameter(s) in the scope of the optimization

• metric(s) needed to define the optimization goal

• metric(s) needed to define the optimization constraints

• metric(s) that are not needed to either define the optimization goal or constraints, and hence not used by Akamas to perform the optimization, but are collected in order to support the analysis (and which can be possibly added at a later time as part of optimization goal or constraint when refining the optimization).

The construct to be used to define a component is described on the Component template page.

Commands

A component is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows more details about components by drilling down their respective system.

A component type is a blueprint for a component that describes the type of entity the component refers to. In Akamas, a component needs to be associated with a component type, from which the component inherits its metrics and parameters.

Component types are platform entities (i.e.: shared among all the users) usually provided off the shelf and shipped within the . Typically, different component types within the same optimization pack are used to model different versions/releases of the same technology.

Akamas' users with appropriate privileges can create custom component types and optimization packs, as described on the page.

Construct

A component type is described by the following mandatory properties (other properties can be defined but are not mandatory):

• a name that uniquely identifies the component type within the system

• a description that clarifies what the component type refers to

• a parameter definitions array (more on Parameters later)

• a metrics array (more on Metrics later)

The construct to be used to define a component type is described on the page.

Commands

A component type is an that can be managed via CLI using the

User Interface

When visualizing system components the component type is displayed.

The following figure shows the out-of-the-box JVM component types related to the JVM optimization pack.

This guide provides a describing Akamas key concepts with their associated construct templates, command line commands, and user interfaces.

This guide also provides references to:

• structure and operators

• metric mapping

• metrics and parameters

• to administer Akamas, manage users, authenticate and manage its resources

A system represents of the entire system which is the target of optimization.

A system is a single object irrespective of the number or type of entities or layers that are in the scope of the optimization. It can be used to model and describe a wide set of entities like:

• An N-layers application

• A single micro-service

• A single (or a collection of) batch job(s)

A System is made of one or more components. Each component represents one of the elements in the system, whose parameters are involved in the optimization or whose metrics are collected to evaluate the results of such optimization.

Construct

A system is described by the following properties:

• The full micro-services stack of an application

• a name that uniquely identifies the system

• a description that clarifies what the system refers to

The construct to be used to define a system is described on the System template page.

Commands

A system is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI displays systems (depending on the user privileges on the defined workspaces) in a specific top-level menu.

A telemetry instance is an instance of a telemetry provider that collects data from a specific instance of the data source.

A telemetry instance is an instance of a telemetry provider, providing the required information on how to connect and collect a given set of metrics from a specific data source.

While telemetry providers are platform-wide entities, telemetry instances are defined at each system level.

Construct

The construct to be used to define a telemetry instance is described on the Telemetry Instance template page.

Commands

A telemetry provider is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

Telemetry instances are displayed in the Akamas UI when drilling down each system component.

A parameter is a property of the system that can be applied and tuned to change the system's behavior. Akamas optimizes systems by changing parameters to achieve the stated goal while respecting the defined constraints.

Examples of a parameter include:

• Configuration knobs (e.g. JVM garbage collection type)

• Resource settings (e.g. amount of memory allocated to a Spark job)

• Algorithms settings (e.g. learning rate of a neural network)

• Architectural properties (e.g. how many caching layers in an enterprise application)

• Type of resources (e.g. AWS EC2 instance or EBS volume type)

• Any other thing (e.g. amount of sugar in your cookies)

The following table describes the parameter types:

Construct

A parameter is described by the following properties:

• a name that uniquely identifies the parameter

• a description that clarifies the semantics of the parameter

• a unit that defines the unit of measurement used by the parameter

Although users can create parameters with any name, we suggest using the naming convention context_parameter where

• context refers to the technology or more general environment in which that metric is defined (e.g. elasticsearch, jvm, mysql, spark)

• parameter is the parameter name in the original context (e.g. gcType, numberOfExecutors)

This makes it possible to identify parameters more easily and avoid any potential name clash.

The construct to be used to define a parameter is described on the Parameter template page.

User Interface

Parameters are displayed in the Akamas UI when drilling down to each system component.

For each optimization study, the optimization scope is the set of parameters that Akamas can change to achieve the defined optimization goal.

An optimization study (or study for short) represents an optimization initiative aimed at optimizing a goal on a target system. A study instructs Akamas about the space to explore and the KPIs used to evaluate whether a con configuration is good or bad

Akamas supports two types of optimizations:

• Offline Optimization Studies are optimization studies where the workload is simulated by leveraging a load-testing tool.

• Live Optimization Studies are applied to systems that need to be optimized in production with respect to varying workloads observed while running live. For example, a microservices application can be optimized live by having Kubernetes and JVM parameters dynamically tuned for multiple microservices so as to minimize costs while matching response time objectives.

Construct

A study is described by the following properties

• system: the system under optimization

• parameters: the set of parameters being optimized

• metrics: the set of metrics to be collected

• workflow: the workflow describing tasks to perform experiments/trials

• goal: the desired optimization goal to be achieved

• constraints: the optimization constraints that any configuration needs to satisfy

• steps: the steps that are executed to run specific configurations (e.g. the baseline) and run the optimization

The construct to be used to define an optimization is described on the Study template page.

Commands

An optimization study is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows optimization studies in 2 specific top-level menus: one for offline optimization studies and another for live optimization studies.

A metric is a measured property of a system.

Examples of a metric include:

• the response time of an application

• the utilization of a CPU

• the amount of time spent in garbage collection

• the cost of a cloud service

Metrics are used to both specify the optimization goal and constraints (e.g. minimize the heap size while keeping response time < 1000 and error rate <= 10% of a baseline value), and to assess the behavior of the system with respect to each specific configuration applied.

Construct

A metric is described by the following properties:

• a name that uniquely identifies the metric

• a description that clarifies the semantics of the metric

• a unit that defines the unit of measurement used by the metric

The construct to be used to define a metric is described on the Metric template page.

User Interface

Metrics are displayed in the Akamas UI when drilling down to each system component.

and are represented in metric charts for each specific optimization study

Please notice that in order for a metric to be displayed in the Akamas UI, it has to be collected from a Telemetry Provider by means of a specific Telemetry Instance defined for each specific target system.

A workflow is a set of tasks that run in sequence to evaluate a configuration as part of an optimization study. A task is a single action performed within a workflow.

Workflows allow you to automate Akamas optimization studies, by automatically executing a sequence of tasks such as initializing an environment, triggering load testing, restoring a database, applying configurations, and much more.

These are examples of common tasks:

• Launch remote commands via SSH

• Apply parameter values in configuration files

• Execute Spark jobs via spark-submit API

• Start performance tests by integrating with external tools such as Neoload

Workflows are first-class entities that can be defined globally and then used in multiple optimization studies.

Akamas provides several workflow operators that can be used to perform tasks in a workflow. Some operators are general-purpose, such as those executing a command or script on a specific host, while others provide native integrations with specific technologies and tools, such as Spark History Server or load testing tools.

Construct

The construct to be used to define a workflow is described on the Workflow template page.

Commands

A telemetry provider is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows systems in a specific top-level menu.

The list of tasks is displayed when drilling down to each specific workflow.

This section provides a definition of Akamas' key concepts and terms and also provides references to the related construct properties, commands, and user interfaces.

A telemetry provider is a software object that represents a data source of metrics. A telemetry instance is a specific instance of a telemetry provider that refers to a specific data source.

Examples of telemetry providers are:

• monitoring tools (e.g. Prometheus or Dynatrace)

• load testing tools (e.g. LoadRunner or Neoload)

• CSV files

A telemetry provider is a platform-wide entity that can be reused across systems to ease the integration with metrics sources.

Akamas provides a number of out-of-the-box telemetry providers. Custom telemetry providers can also be created.

Construct

The construct to be used to define a telemetry provider is described on the Telemetry Provider template page.

Commands

A telemetry provider is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows systems in a specific top-level menu.

An optimize step generates optimized configurations according to the defined optimization strategy. During this step, Akamas AI is used to generate such optimized configurations.

The optimize step has the following structure:

Optimizer

The optimizer field allows selecting the desired optimizer:

• AKAMAS identifies the standard AI optimizer used by Akamas

• SOBOL identifies an optimizer that generates configurations using Sobol sequences

• RANDOM identifies an optimization that generates configurations using random numbers

Notice that SOBOL and RANDOM optimizers do not perform initialization experiments, hence the field numberOfInitExperiments is ignored.

Refer to page Optimizer Options for more configuration options for the optimizer

Failures

The optimize step is fault-tolerant and tries to relaunch experiments on failure. Nevertheless, the step imposes a limit on the number of failed experiments: if too many experiments fail, then the entire step fails too. By default, at most 30 experiments can fail while Akamas is optimizing systems. An experiment is considered failed when it either failed to run (i.e., there is an error in the workflow) or violated some constraint.

Initializations

The optimize step launches some initialization experiments (by default 10) that do not apply the AI optimizer and are used to find good configurations. By default, the step performs 10 initialization experiments.

Initialization experiments take into account bootstrapped experiments, experiments executed in preset steps, and baseline experiments.

Example

The following snippet shows an optimization step that runs 50 experiments using the SOBOL optimizer:

name: "my_optimize" # name of the step
type: "optimize" # type of the step (optimize)
optimizer: "SOBOL"
numberOfExperiments: 50 # amount of experiments to execute
numberOfTrials: 2 # amount of trials for each experiment

The optimization goal defines the objective of an to be achieved by changing the system parameters to modify the system behavior while also satisfying any defined optimization constraints on the system metrics, possibly representing SLOs.

Construct

A goal is defined by:

• an optimization objective: either maximize or minimize

• a scoring function (scalar): either a single metric or a formula defined by one or more metrics

One or more constraints can be associated with a goal

• a formula defined on one or more metrics, referring to either absolute values (absolute constraints) or relative to a baseline value (relative constraints)

Notice that relative constraints are only supported by while absolute constraints are supported by both offline and .

Goals and constraints are not an as they are defined as part of an optimization study. The construct to be used to define a goal and its constraints are described in the page of the section.

Commands

Goals and constraints are not an and are always defined as part of an optimization study.

User Interface

Goals and constraints are displayed in the Akamas UI when drilling down each optimization study.

The detail of the formula used to define the goal may also be displayed:

The WindowsExecutor operator executes a command on a target Windows machine using WinRM.

The command can be anything that runs on a Windows Command Prompt.

Operator arguments

host structure and arguments

Here follows the structure of the host argument

with its arguments:

Get operator arguments from component

The component argument can refer to a Component by name and use its properties as the arguments of the operator. In case the mapped arguments are already provided to the operator, there is no override.

Here is an example of a component that overrides the host and the command arguments:

Examples

Execute a dir command with explicit host information

Execute a dir command with host information taken from a Component

The LinuxConfigurator operator allows configuring systems tuned by Akamas by applying parameters related to the Linux kernel using different strategies.

The operator can configure provided Components or can configure every Component which has parameters related to the Linux kernel.

The parameters are applied via SSH protocol.

Using

In the most basic use of the Operator, it is sufficient to add a task of type LinuxConfigurator in the workflow.

The operator makes use of properties specified in the component to identify which instance should be configured, how to access it, and any other information required to apply the configuration.

Operator arguments

If no component is provided, this operator will try to configure every parameter defined for the Components of the System under test

Supported Component Properties

The following table highlights the properties that can be specified on components and are used by this operator.

Filter parameters and block/network devices

The properties blockDevices and networkDevices allow specifying which parameters to apply to each block/network-device associated with the Component, as well as which block/network-device should be left untouched by the LinuxConfigurator.

If the properties are omitted, then all block/network-devices associated with the Component will be configured will all the available related parameters.

All block-devices called loopN (where N is an integer number greater or equal to 0) are automatically excluded from the Component’s block-devices

The properties blockDevices and networkDevices are lists of objects with the following structure:

Examples

In this example, only the parameters os_StorageReadAhead and os_StorageQeueuScheduler are applied to all the devices that match the regex "xvd[a-z]" (i.e. xvda, xvdb, …, xvdc).

In these examples, only the parameter os_StorageMaxSectorKb is applied to block device xvdb and loop0.

In this example, no parameters are applied to the wlp4s0 network device, which is therefore excluded from the optimization.

How are parameters applied to the system?

To support the scenario in which some configuration parameters related to the Linux kernel may be applied using the strategies supported by this operator, while others with other strategies (e.g, using a file to be written on a remote machine), it is necessary to specify which parameters should be applied with the LinuxConfigurator, and this is done at the ComponentType level; moreover, still at the ComponentType level, it is necessary to specify which strategy should be used to configure each parameter. This information is already embedded in the Linux Optimization pack and, usually, no customization is required.

Sysctl strategy

With this strategy, a parameter is configured by leveraging the sysctl utility. The sysctl variable to map to the parameter that needs to be configured is specified using the key argument.

Echo strategy

With this strategy, a parameter is configured by echoing and piping its value into a provided file. The path of the file is specified using the file argument.

Map strategy

With this strategy, each possible value of a parameter is mapped to a command to be executed on the machine the LinuxConfigurator operates on(this is especially useful for categorical parameters).

Command strategy

With this strategy, a parameter is configured by executing a command into which the parameter value is interpolated.

A workspace is a virtual environment that groups systems, workflows, and studies to restrict user access to them: a user can access these resources only when granted the required permissions to that workspace.

Akamas defines two user roles according to the assigned permission on the workspace:

• Contributors (write permission) can create and manage workspace resources (studies, telemetry instances, systems, and workflows) and can also do exports/imports, view all global resources (Optimization Packs, and Telemetry Providers), and see remaining credits;

• Viewers (read permission) can only access optimization results but cannot create or modify workspace resources.

Workspaces and accesses are managed by users with administrative privileges. A user with administrator privileges can manage licenses, users, workspaces, and install/deinstall Optimization Packs, and Telemetry Providers.

Workspaces can be defined according to different criteria, such as:

• By department (e.g. Performance, Development)

• By initiative (e.g. Poc, Training)

• By application (e.g. Registry, Banking..)

A workspace is described by the following property:

• a name that uniquely identifies the workspace

Commands

A workspace is an Akamas resource that can be managed via CLI using the resource management commands. See also this page devoted to commands on how to define users and workspaces.

User Interface

The workspace a study belongs to is always displayed. Filters can be used to select only studies belonging to specific workspaces

An optimization pack is a software object that provides a convenient facility for encapsulating all the knowledge (e.g. metrics, parameters with their default values and domain ranges) required to apply Akamas optimizations to a set of entities associated with the same technology.

Notice that while optimization packs are very convenient for modeling systems and creating studies, it is not required for these entities to be covered by an optimization pack.

Akamas provides a library of out-the-box optimization packs and new custom optimization packs can be easily added (no coding is required).

Construct

An optimization pack needs to include the entities that encapsulate technology-specific information related to the supported component types:

• supported component types

• parameters and metrics for each component type

• supported telemetry providers (optional)

Commands

An optimization pack is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows systems in a specific top-level menu.

An optimization pack encapsulates one or more of the following technology-specific elements:

• Component Types: these represent the type of the component(s) included, each with its associated parameters and metrics

• Telemetry Providers: that define where to collect metrics

An optimization pack enables Akamas users to optimize a technology without necessarily being an expert in that technology and to code their knowledge about a technology or a specific application to be reused in multiple optimization studies to ease the modeling process.

This section describes all the structures that can be used to define resources and objects in Akamas.

Systems are defined using a YAML manifest with the following structure:

# General section
name: Analytical functions
description: A collection of analytical functions

with the following properties:

Example

The following represents a system (for Cassandra related system)

name: system1
description: my system with 3 nodes of cassandra

Offline optimization studies are optimization studies where the workload is simulated by leveraging a load-testing tool.

Offline optimization studies are typically used to optimize systems in pre-production environments, with respect to planned and what-if scenarios that cannot be directly run in production. Scenarios include new application releases, planned technology changes (e.g. new JVM or DB), cloud migration or new provider, expected workload growth, and resilience under failure scenarios (from chaos engineering).

The following figure represents the iterative process associated with offline optimizations:

The following 5 phases can be identified for each iteration (also known as experiment):

1. Apply configuration: Akamas applies the parameter configuration (one or more parameters) to the target system by leveraging a set of workflow operators

2. Apply workload: Akamas triggers a workload on the target system by also leveraging a set of workflow operators

3. Collect KPIs: Akamas collects the metrics related to the target system - only those metrics that are specified by each telemetry instance defined in the system

4. Score vs goal: Akamas scores the applied parameter configuration against the defined goal and constraints - the score is the value of the goal function

5. Recommend Conf: Akamas AI engine identifies the configuration for the next iteration until a termination condition for the study is met (e.g. number of experiments).

Thanks to its patented AI (reinforcement learning) algorithms, Akamas can find the optimal configuration without having to explore all the possible configurations.

Trials

For each experiment, Akamas allows multiple trials to be executed. A trial is a repetition of the same experiment to reduce the impact of noise on the result of an experiment.

Environments can be noisy for several reasons such as:

• External conditions (e.g. background jobs, "noisy neighbors" in the cloud)

• Measurement errors (e.g. monitoring tools not always 100% accurate)

This approach is consistent with scientific and engineering practices, where the strategy to minimize the impact of noise is to repeat the same experiment multiple times.

Steps

An offline optimization study can include multiple steps.

Typically there are at least two steps:

• Baseline step: a single experiment that is run by applying the already deployed configuration before the Akamas optimization is applied - the results of this experiment are used as a reference (baseline) for assessing the optimization and as such is a mandatory step for each study

• Optimize step: a defined number of experiments used to identify the optimal configuration by leveraging Akamas AI.

Other steps are:

• Bootstrap step: imported experiments from other optimization studies

• Preset step: a single experiment with a defined configuration

The steps to be executed can be specified when defining an offline optimization study.

Commands

An offline optimization study is an Akamas resource that can be managed via CLI using the resource management commands.

User Interface

The Akamas UI shows offline optimization studies in a specific top-level menu.

The details and results of an offline optimization study are displayed when drilling down (there are multiple tabs and sections).

A KPI is a metric that is worth considering when analyzing the result of an offline optimization study, looking for (sub)optimal configurations generated by Akamas AI to be applied.

Akamas automatically considers any metric referred to in the defined optimization goal and constraints for an offline optimization study as a KPI. Moreover, any other metrics of the system component can be specified as a KPI for an offline optimization study.

Construct

A KPI is defined as follows (from the UI or the CLI):

KPIs are not an Akamas resource as they are defined as part of an optimization study. The construct to define KPIs is described on the KPIs page of the Study template section.

Commands

KPIs are not an Akamas resource and are always defined as part of an optimization study.

User Interface

The number and first KPIs are displayed in the Akamas UI in the header of each offline optimization study.

The full list of KPIs is displayed by drilling down to the KPIs section.

From this section, it is possible to modify the list of KPIs and change their names and other attributes.

Live Optimization studies are optimization studies where the workload is real: the system that needs to be optimized operates with respect to varying workloads observed while running live.

Live optimization studies are typically used to optimize systems in production environments. For example, a microservices application can be optimized while running in production by having Kubernetes and JVM parameters dynamically tuned for multiple microservices so as to minimize costs while matching response time objectives.

The following figure represents the iterative process associated with offline optimizations:

The following 5 phases can be identified for each iteration:

1. Collect KPIs: Akamas collects the metrics of the system required to observe its behavior under the current parameter configuration by leveraging the associated telemetry provider - here Akamas is also observing and categorizing the different workload contexts that are used to recommend configurations that are appropriate for each specific workload context

2. Score vs Goal: Akamas scores the applied parameter configuration under the specific workload context against the defined goal and constraints

3. Recommend Conf: Akamas provides a recommendation for parameter configuration based on the observed behavior under the specific workload context and leveraging the Akamas AI

4. Human Approval: this is an optional step as there are two operational modes:

   • autonomous mode: no human intervention is required

   • human-approval mode: recommendations need to be approved by users before configuration changes get applied - recommendations can be changed by users

5. Apply Conf: Akamas applies the recommended (and possibly revisited) configuration, by leveraging the defined workflow.

Notice that configurations can be applied by Akamas via integrations with native interfaces (e.g. Kubectl), by leveraging any orchestration and automation tool in place (e.g. OpenShift), or by triggering a pull request to a configuration repository (e.g. Git). This can be applied to either the entire target system or to a canary deployment.

Safety Policies

Akamas provides several customizable policies for live optimization studies to ensure that recommended configuration changes to production environments are as safe as possible. Akamas safety policies include gradual optimization, smart constraints, and outlier detection. For more details, see settings safety policies.

Commands

A live optimization study is an Akamas resource that can be managed via CLI using resource management commands.

User Interface

The Akamas UI shows live optimization studies in a specific top-level menu.

The details and results of an offline optimization study are displayed when drilling down.

Telemetry instances are defined using a YAML manifest with the following structure:

provider: Provider Name
name: My Telemetry
config:
  providerSpecificConfig1: "<value>"
  providerSpecificConfig2: 123
metrics:
- name: metric_name
  datasourceName: datsource_metric_name
  defaultValue: 1.23
  labels:
    - label1
    - label2
  staticLabels:
    staticLabel1: staticValue1
    staticLabel2: staticValue2

with the following properties for the global section

and the metrics section

Components are defined using a YAML manifest with the following structure:

name: branin
description: The branin analytical function
componentType: function_branin
properties:
  hostname: function-server

and properties:

Examples

Example of a component for OpenJDK11:

name: JVM_1
description: The first jvm of the system
componentType: java-openjdk-11
properties:
  hostname: ycsb1.dev.akamas.io
  username: ubuntu

Example of a component for the Linux operating system:

name: os_1
description: The operating system of team 1
componentType: Ubuntu-20.04
properties:
  hostname: ycsb1.dev.akamas.io
  username: ubuntu

Parameters are defined using a YAML manifest with the following structure:

with the following properties:

Notice that parameter definitions are shared across all the workspaces on the same Akamas installation, and require an account with administrative privileges to manage them.

Example

The following represents a set of parameters for a JVM component

The following represents a set of CPU-related parameters for the Linux operating system

Metrics are defined using a YAML manifest with the following structure:

and properties:

Supported units of measure

The supported units of measure for metrics are:

Notice that supported units of measure are automatically scaled for visualization purposes. In particular, for units of information, Akamas uses a base 2 scaling for bytes, i.e., 1 kilobyte = 1024 bytes, 1 megabyte = 1024 kilobytes, and so on. Other units of measure are only scaled up using millions or billions (e.g., 124000000 custom units become 124 Mln custom units).

Workflow are defined using a YAML manifest with the following structure:

with the following properties:

The full list of Operators and related options is provided on the pages.

Example

A workflow for the java-based renaissance benchmark application

Optimization goals and constraints are defined using a YAML manifest with the following structure:

where:

Function

The function field of the Goal of a Study details the characteristics of the function Akamas should minimize or maximize to reach the desired performance objective.

The function field has the following structure:

Where:

Formula

The formula field represents the mathematical expression of the performance objective for the Study and contains variables and operators with the following characteristics:

• Valid operators are: + - * / ^ sqrt(variable) log(variable) max(variable1, variable2) min(variable1, variable2)

• Valid variables are in the form:

  • <component_name>.<metric_name>, which correspond directly to metrics of Components of the System under test

  • <variable_name>, which should match variables specified in the variables field

Variables

The variables field contains the specification of additional variables present in the formula, variables that can offer more flexibility with respect to directly specifying each metric of each Component in the formula.

Notice: each subfield of variables specifies a variable with its characteristics, the name of the subfield is the name of the variable.

The variable subfield has the following structure:

It is possible to use the notation <component_name>.<metric_name> in the metric field to automatically filter the metric’s data point by that component name is applied.

Constraints

The constraints field specifies constraints on the metrics of the system under test. For a configuration to be valid with respect to the defined goal, such constraints must be satisfied. Constraints can be defined as absolute or relativeToBaseline.

Each constraint has the form of:

mathematical_operationcomparison_operatorvalue_to_compare

where valid mathematical operations include:

• + - * / ^

• min max

• sqrt log (log is a natural logarithm)

valid comparison operators include:

• > < <= >=

• == != (equality, inequality)

and valid values to compare include:

• absolute values (e.g, 104343)

• percentage values relative to the baseline (e.g, 20%)

As an example, you could define an absolute constraint with the following snippet:

Relative constraints can be defined by adding other constraints under the relativeToBaseline section. In the example below, for the configuration to be considered valid, it's required that the metric jvm.memory_used does not exceed by 80% the value measured in the baseline.

Aggregations

Variables used in the study formula specification and in the constraints definition can include an aggregation. The following aggregations are available: avg, min, max, sum, p90, p95, p99.

Examples

The following example refers to a study whose goal is to optimize the throughput of a Java service (jpetstore), that is to maximize the throughput (measured as elements_per_second) while keeping errors (error_rate) and latency (avg_duration, max_duration) under control (absolute values):

The following example refers to a study whose goal is to optimize the memory consumption of Docker containers in a microservices application, that is to minimize the average memory consumption of Docker containers within the application of appId="app1" by observing memory limits, also normalizing by the maximum duration of a benchmark (containers_benchmark_duration).

Component types are defined using a YAML manifest with the following structure:

and properties for the general section:

The parameter section describes the relationship between the component type and already defined parameters with the following properties:

The metric section describes the relationship between the component type and already defined metrics with the following properties:

Notice that component type definitions are shared across all the workspaces on the same Akamas installation, and require an account with administrative privileges to manage them.

Examples

Example of a component for the Cassandra component type:

Example of a component for the Linux operating component type:

Optimization studies are defined using a YAML manifest with the following structure:

with the following mandatory properties:

Some of these optional properties depend on whether the study is an offline or live optimization study.

Number of trials

It is possible to perform more than one trial per experiment in order to validate the score of a configuration under test, e.g. to take into account noisy environments.

The following fragment of the YAML definition of a study sets the number of trials to 3:

Notice: This is a global property of the study which can be overwritten for each step.

Trial aggregation

The trial aggregation policy defines how trial scores are aggregated to form experiment scores.

There are three different types of strategies to aggregate trial scores:

• AVG: the score of an experiment is the average of the scores of its trials - this is the default

• MIN: the score of an experiment is the minimum among the scores of its trials

• MAX: the score of an experiment is the maximum among the scores of its trial

The following fragment of the YAML definition of a study sets the trial aggregation to MAX:

Examples

The following system refers to an offline optimization study for a system modeling an e-commerce service, where a windowing strategy is specified:

The following offline study refers to a tuning initiative for a Cassandra-based system (ID 2)

The following offline study is for tuning another Cassandra-based system (ID 3) by acting only on JVM and Linux parameters