Skip to content

## Remembering Jaakko Pesonen

MySQL community secondary September 9, 2017

I was sorrowed to hear that Jaakko Pesonen has passed away after battling cancer.

I first met Jaakko a few years back, during a Percona Live conference, and as community goes, our paths crossed again a few times. He spoke at and attended conferences where we’d have casual chats.

We were both expats in the Netherlands for a period. As I moved in from Israel, he was already working at Spil Games, having relocated from Finland, his home country. We shared expat experiences and longings to our homes. One day he pinged me that he was planning a trip to Israel – and the next few days were all about planning the best culinary experience of his travel (he approved of the results).

He was happy for the opportunity to work for Percona, as this allowed him to move back home to Finland.

Jaakko had the biggest, widest, most consuming smile, and this smile will sure be the most vivid memory of him that I’ll keep.

> I do not have personal pictures of Jaakko. This picture was taken by Julian Cash at Percona Live. A rare non-smiling appearance.

## Speaking at August Penguin, MySQL Track, GitHub sponsored

MySQL gh-ost GitHub Open Source orchestrator Speaking September 3, 2017September 3, 2017

This Thursday I’ll be presenting at August Penguin, conveniently taking place September 7th, 8th, Ramat Gan, Israel.

I will be speaking as part of the MySQL track, 2nd half of Thursday. The (Hebrew) schedule is here.

My talk is titled Reliable failovers, safe schema migrations: open source solutions to MySQL problems. I will describe some of the open source MySQL infrastructure work we run at GitHub ; how it solves reliability, availability and usability. I’ll describe some of our internal workflows and our use of chat and chatops.

I’m proud to announce GitHub sponsors the event. We won’t have a booth, but please do grab me in the hallways or over lunch to chat!

And, yes, octocat stickers will be made available 🙂

## orchestrator/raft: Pre-Release 3.0

MySQL Failover High availability Open Source orchestrator raft Replication August 3, 2017August 3, 2017

`orchestrator` 3.0 Pre-Release is now available. Most notable are Raft consensus, SQLite backend support, orchestrator-client no-binary-required client script.

### TL;DR

You may now set up high availability for `orchestrator` via `raft` consensus, without need to set up high availability for `orchestrator`‘s backend MySQL servers (such as Galera/InnoDB Cluster). In fact, you can run a `orchestrator/raft` setup using embedded `SQLite` backend DB. Read on.

`orchestrator` still supports the existing shared backend DB paradigm; nothing dramatic changes if you upgrade to 3.0 and do not configure `raft`.

### orchestrator/raft

Raft is a consensus protocol, supporting leader election and consensus across a distributed system. In an `orchestrator/raft` setup `orchestrator` nodes talk to each other via raft protocol, form consensus and elect a leader. Each `orchestrator` node has its own dedicated backend database. The backend databases do not speak to each other; only the `orchestrator` nodes speak to each other.

No MySQL replication setup needed; the backend DBs act as standalone servers. In fact, the backend server doesn’t have to be MySQL, and `SQLite` is supported. `orchestrator` now ships with `SQLite` embedded, no external dependency needed. Continue reading » “orchestrator/raft: Pre-Release 3.0”

## What’s so complicated about a master failover?

MySQL High availability orchestrator Replication June 29, 2017

The more work on orchestrator, the more user input and the more production experience, the more insights I get into MySQL master recoveries. I’d like to share the complexities in correctly running general-purpose master failovers; from picking up the right candidates to finalizing the promotion.

The TL;DR is: we’re often unaware of just how things can turn at the time of failover, and the impact of every single decision we make. Different environments have different requirements, and different users wish to have different policies. Understanding the scenarios can help you make the right choice.

The scenarios and considerations below are ones I picked while browsing through the `orchestrator` code and through Issues and questions. There are more. There are always more scenarios.

I discuss “normal replication” scenarios below; some of these will apply to synchronous replication setups (Galera, XtraDB Cluster, InnoDB Cluster) where using cross DC, where using intermediate masters, where working in an evolving environment.

`orchestrator`-wise, please refer to “MySQL High Availability tools” followup, the missing piece: orchestrator, an earlier post. Some notions from that post are re-iterated here. Continue reading » “What’s so complicated about a master failover?”

## Observations on the hashicorp/raft library, and notes on RDBMS

Development MySQL freno golang MySQL orchestrator raft June 20, 2017

The hashicorp/raft library is a Go library to provide consensus via Raft protocol implementation. It is the underlying library behind Hashicorp’s Consul.

I’ve had the opportunity to work with this library a couple projects, namely freno and orchestrator. Here are a few observations on working with this library:

- TL;DR on Raft: a group communication protocol; multiple nodes communicate, elect a leader. A leader leads a consensus (any subgroup of more than half the nodes of the original group, or hopefully all of them). Nodes may leave and rejoin, and will remain consistent with consensus.
- The hashicorp/raft library is an implementation of the Raft protocol. There are other implementations, and different implementations support different features.
- The most basic premise is leader election. This is pretty straightforward to implement; you set up nodes to communicate to each other, and they elect a leader. You may query for the leader identity via Leader(), VerifyLeader(), or observing LeaderCh.
- You have no control over the identity of the leader. You cannot “prefer” one node to be the leader. You cannot grab leadership from an elected leader, and you cannot demote a leader unless by killing it.
- The next premise is gossip, sending messages between the raft nodes. With `hashicorp/raft`, only the leader may send messages to the group. This is done via the Apply() function.
- Messages are nothing but blobs. Your app encodes the messages into `[]byte` and ships it via raft. Receiving ends need to decode the bytes into a meaningful message.
- You will check the result of Apply(), an ApplyFuture. The call to Error() will wait for consensus.
- Just what is a message consensus? It’s a guarantee that the consensus of nodes has received and registered the message.
- Messages form the raft log.
- Messages are guaranteed to be handled in-order across all nodes.
- The leader is satisfied when the followers receive the messages/log, but it cares not for their interpretation of the log.
- The leader does not collect the output, or return value, of the followers applying of the log.
- Consequently, your followers may not abort the message. They may not cast an opinion. They must adhere to the instruction received from the leader.
- `hashicorp/raft` uses either an LMDB-based store or BoltDB for persisting your messages. Both are transactional stores.
- Messages are expected to be idempotent: a node that, say, happens to restart, will request to join back the consensus (or to form a consensus with some other node). To do that, it will have to reapply historical messages that it may have applied in the past.
- Number of messages (log entries) will grow infinitely. Snapshots are taken so as to truncate the log history. You will implement the snapshot dump & load.
- A snapshot includes the log index up to which it covers.
- Upon startup, your node will look for the most recent snapshot. It will read it, then resume replication from the aforementioned log index.
- `hashicorp/raft` provides a file-system based snapshot implementation.

One of my use cases is completely satisfied with the existing implementations of `BoltDB` and of the filesystem snapshot.

However in another (`orchestrator`), my app stores its state in a relational backend. To that effect, I’ve modified the logstore and snapshot store. I’m using either MySQL or `sqlite` as backend stores for my app. How does that affect my `raft` use? Continue reading » “Observations on the hashicorp/raft library, and notes on RDBMS”

## Practical Orchestrator, BoF, GitHub and other talks at Percona Live 2017

MySQL GitHub orchestrator PerconaLive April 19, 2017April 19, 2017

Next week I will be presenting Practical Orchestrator at Percona Live, Santa Clara.

As opposed to previous `orchestrator` talks I gave, and which were either high level or algorithmic talks, Practical Orchestrator will be, well… practical.

The objective for this talk is that attendees leave the classroom with a good grasp of `orchestrator`‘s powers, and know how to set up `orchestrator` in their environment.

We will walk through discovery, refactoring, recovery, HA. I will walk through the most important configuration settings, share advice on what makes a good deployment, and tell you how we and others run `orchestrator`. We’ll present a few scripting/automation examples. We will literally set up `orchestrator` on my computer.

It’s a 50 minute talk and it will be fast paced!

### ProxySQL & Orchestrator BoF

ProxySQL is all the rage, and throughout the past 18 months René Cannaò and myself discussed a few times the potential for integration between ProxySQL and Orchestrator. We’ve also received several requests from the community.

We will run a BoF, a very informal session where we openly discuss our thoughts on possible integration, what makes sense and what doesn’t, and above all else would love to hear the attendees’ thoughts. We might come out of this session with some plan to pick low hanging fruit, who knows?

The current link to the BoF sessions is this. It seems terribly broken, and hopefully I’ll replace it later on.

### GitHub talks

GitHub engineers will further present these talks: Continue reading » “Practical Orchestrator, BoF, GitHub and other talks at Percona Live 2017”

## “MySQL High Availability tools” followup, the missing piece: orchestrator

MySQL High availability orchestrator Replication April 6, 2017April 6, 2017

I read with interest MySQL High Availability tools – Comparing MHA, MRM and ClusterControl by SeveralNines. I thought there was a missing piece in the comparison: orchestrator, and that as result the comparion was missing scope and context.

I’d like to add my thoughts on topics addressed in the post. I’m by no means an expert on MHA, MRM or ClusterControl, and will mostly focus on how `orchestrator` tackles high availability issues raised in the post.

### What this is

This is to add insights on the complexity of failovers. Over the duration of three years, I always think I’ve seen it all, and then get hit by yet a new crazy scenario. Doing the right thing automatically is difficult.

In this post, I’m not trying to convince you to use `orchestrator` (though I’d be happy if you did). To be very clear, I’m not claiming it is better than any other tool. As always, each tool has pros and cons.

This post does not claim other tools are not good. Nor that `orchestrator` has all the answers. At the end of the day, pick the solution that works best for you. I’m happy to use a solution that reliably solves 99% of the cases as opposed to an unreliable solution that claims to solve 99.99% of the cases.

### Quick background

`orchestrator` is actively maintained by GitHub. It manages automated failovers at GitHub. It manages automated failovers at Booking.com, one of the largest MySQL setups on this planet. It manages automated failovers as part of Vitess. These are some names I’m free to disclose, and browsing the issues shows a few more users running failovers in production. Otherwise, it is used for topology management and visualization in a large number of companies such as Square, Etsy, Sendgrid, Godaddy and more.

Let’s now follow one-by-one the observations on the SeveralNines post. Continue reading » ““MySQL High Availability tools” followup, the missing piece: orchestrator”

## MySQL Community Awards 2017: Call for Nominations!

MySQL March 16, 2017March 21, 2017

The 2017 MySQL Community Awards event will take place, as usual, in Santa Clara, during the Percona Live Data Performance Conference, April 2017.

The MySQL Community Awards is a community based initiative. The idea is to publicly recognize contributors to the MySQL ecosystem. The entire process of discussing, voting and awarding is controlled by an independent group of community members, typically based of past winners or their representatives, as well as known contributors.

It is a self-appointed, self-declared, self-making-up-the-rules-as-it-goes committee. It is also very aware of the importance of the community; a no-nonsense, non-political, adhering to tradition, self criticizing committee.

The Call for Nominations is open. We are seeking the community’s assistance in nominating candidates in the following categories:

#### MySQL Community Awards: Community Contributor of the year 2017

This is a personal award; a winner would a person who has made contribution to the MySQL ecosystem. This could be via development, advocating, blogging, speaking, supporting, etc. All things go.

#### MySQL Community Awards: Application of the year 2017

An application, project, product etc. which supports the MySQL ecosystem by either contributing code, complementing its behavior, supporting its use, etc. This could range from a one man open source project to a large scale social service.

#### MySQL Community Awards: Corporate Contributor of the year 2017

A company who made contribution to the MySQL ecosystem. This might be a corporate which released major open source code; one that advocates for MySQL; one that help out community members by… anything.

For a list of previous winners, please see MySQL Hall of Fame. Continue reading » “MySQL Community Awards 2017: Call for Nominations!”

## orchestrator Puppet module now available

MySQL orchestrator puppet February 1, 2017February 1, 2017

We have just open sourced and published an orchestrator puppet module. This module is authored by Tom Krouper of GitHub’s database infrastructure team, and is what we use internally at GitHub for deploying `orchestrator`.

The module manages the `orchestrator` service, the config file (inherit to override values), etc (pun intended). Check it out!

## Some observations on MySQL to sqlite migration & compatibility

MySQL SQL sqlite January 30, 2017January 30, 2017

I’m experimenting with sqlite as backend database for orchestrator. While `orchestrator` manages MySQL replication topologies, it also uses MySQL as backend. For some deployments, and I’m looking into such one, having MySQL as backend is a considerable overhead.

This sent me to the route of looking into a self contained `orchestrator` binary + backend DB. I would have `orchestrator` spawn up its own backend database instead of connecting to an external one.

### Why even relational?

Can’t `orchestrator` just use a key-value backend?

Maybe it could. But frankly I enjoy the power of relational databases, and the versatility they offer has proven itself multiple times with `orchestrator`, being able to answer interesting, new, complex questions about one’s topology by crafting SQL queries.

Moreover, `orchestrator` is already heavily invested in the relational model. At this time, replacing all SQL queries with key-value reads seems to me as a significant investment in time and risk. So I was looking for a relational, SQL accessible embeddable database for `orchestrator`.

### Why sqlite?

I am in particular looking at two options: sqlite (via the go-sqlite3 binding) and TiDB. sqlite does not need much introduction, and I’ll just say it’s embeddable within the golang-built binary. Continue reading » “Some observations on MySQL to sqlite migration & compatibility”