Group items tagged

When you combine a custom resource with a custom controller, custom resources provide a true declarative API.

A declarative API allows you to declare or specify the desired state of your resource and tries to keep the current state of Kubernetes objects in sync with the desired state.

Custom controllers can work with any kind of resource, but they are especially effective when combined with custom resources.

the API represents a desired state, not an exact state.

define configuration of applications or infrastructure.

The main operations on the objects are CRUD-y (creating, reading, updating and deleting).

You want to put the entire config file into one key of a configMap.

You want to perform rolling updates via Deployment, etc., when the file is updated.

You want to build new automation that watches for updates on the new object, and then CRUD other objects, or vice versa.

You want the object to be an abstraction over a collection of controlled resources, or a summarization of other resources.

CRDs are simple and can be created without any programming.

CRDs allow users to create new types of resources without adding another API server

Defining a CRD object creates a new custom resource with a name and schema that you specify.

The name of a CRD object must be a valid DNS subdomain name

each resource in the Kubernetes API requires code that handles REST requests and manages persistent storage of objects.

The main API server delegates requests to you for the custom resources that you handle, making them available to all of its clients.

The new endpoints support CRUD basic operations via HTTP and kubectl

Custom resources consume storage space in the same way that ConfigMaps do.

Aggregated API servers may use the same storage as the main API server

CRDs always use the same authentication, authorization, and audit logging as the built-in resources of your API server.

most RBAC roles will not grant access to the new resources (except the cluster-admin role or any role created with wildcard rules).

Lock-related slowdowns can be intermittent.

If globalLock.currentQueue.total is consistently high, then there is a chance that a large number of requests are waiting for a lock.

If globalLock.totalTime is high relative to uptime, the database has existed in a lock state for a significant amount of time.

For write-heavy applications, deploy sharding and add one or more shards to a sharded cluster to distribute load among mongod instances.

Unless constrained by system-wide limits, the maximum number of incoming connections supported by MongoDB is configured with the maxIncomingConnections setting.

When logLevel is set to 0, MongoDB records slow operations to the diagnostic log at a rate determined by slowOpSampleRate.

At higher logLevel settings, all operations appear in the diagnostic log regardless of their latency with the following exception

Full Time Diagnostic Data Collection (FTDC) mechanism. FTDC data files are compressed, are not human-readable, and inherit the same file access permissions as the MongoDB data files.

mongod processes store FTDC data files in a diagnostic.data directory under the instances storage.dbPath.

SysBench is not a tool which you can use to tune configurations of your MySQL servers (unless you prepared LUA scripts with custom workload or your workload happen to be very similar to the benchmark workloads that SysBench comes with)

it is great for is to compare performance of different hardware.

Every new server acquired should go through a warm-up period during which you will stress it to pinpoint potential hardware defects

by executing OLTP workload which overloads the server, or you can also use dedicated benchmarks for CPU, disk and memory.

bulk_insert.lua. This test can be used to benchmark the ability of MySQL to perform multi-row inserts.

All oltp_* scripts share a common table structure. First two of them (oltp_delete.lua and oltp_insert.lua) execute single DELETE and INSERT statements.

oltp_point_select, oltp_update_index and oltp_update_non_index. These will execute a subset of queries - primary key-based selects, index-based updates and non-index-based updates.

you can run different workload patterns using the same benchmark.

Warmup helps to identify “regular” throughput by executing benchmark for a predefined time, allowing to warm up the cache, buffer pools etc.

By default SysBench will attempt to execute queries as fast as possible. To simulate slower traffic this option may be used. You can define here how many transactions should be executed per second.

SysBench gives you ability to generate different types of data distribution.

decide if SysBench should use prepared statements (as long as they are available in the given datastore - for MySQL it means PS will be enabled by default) or not.

sysbench ./sysbench/src/lua/oltp_read_write.lua  help

By default, SysBench will attempt to execute queries in explicit transaction. This way the dataset will stay consistent and not affected: SysBench will, for example, execute INSERT and DELETE on the same row, making sure the data set will not grow (impacting your ability to reproduce results).

specify error codes from MySQL which SysBench should ignore (and not kill the connection).

the two most popular benchmarks - OLTP read only and OLTP read/write.

1 million rows will result in ~240 MB of data. Ten tables, 1000 000 rows each equals to 2.4GB

by default, SysBench looks for ‘sbtest’ schema which has to exist before you prepare the data set. You may have to create it manually.

pass ‘--histogram’ argument to SysBench

~48GB of data (20 tables, 10 000 000 rows each).

if you don’t understand why the performance was like it was, you may draw incorrect conclusions out of the benchmarks.