Amazon Kinesisをプログラマフレンドリにするフレームワークを考える


この記事は[AWS Advent Calandar](http://qiita.com/advent-calendar/2014/aws)の21日目の記事です。

これは個人のメモ/意見であり、私の所属する組織を代表するものではありません。また、記事中のコード片はすべてMITライセンスにて提供されるものとします。

## サマリと背景

テーマとしては、Amazon Kinesisとのプログラマとしての付き合い方について考えてみたという話。「Kinesisでリアルタイム分析だ！」とか「IoTだ！」とか「ストリーム処理だ！」みたいな感じにマジックワードが飛び交っていて、実際の実装の話があまり世に出てこないのに違和感を感じたのがこの記事を書こうと思った発端。

違和感を書き連ねるだけだとアレなので、Kinesisをもっとプログラマフレンドリにするにはどうしたらいいんだろう、というのを考えてみた。

あと、RxJSを触りたかったというのもある笑

## Amazon Kinesis

2013年のRe:Inventで発表されたサービスで、おおまかに以下のような特徴を持っている

- 高い信頼性とスケーラビリティを持ったストリームデータの受け取りと保存
- 受け取ったデータをPartition Keyによってシャッフル&ソートしてコンシューマーに渡してくれる
- MapReduceモデルに当てはめると、リアルタイム案なMapperのような動きをしてくれる
- IoTやリアルタイム分析の文脈の中で取り上げられることが多い

## 現時点で感じていること: まだまだインフラサービスだよね

見出しの通りなのだが、Kinesisはインフラの文脈で語られていることが多い。機能や性能など、Whatについては多く語られているのだが、どう使うのかというHowについてはぼんやりとしている。もっとアプリケーションの話をしたいんだけど、じゃあそこに足りないものは何なのか。

いろいろあると思うが、サービスをうまく抽象化してプログラムの一モデルとして取り扱うための抽象化ライブラリが足りていないのでは、とう点について今回は考えたい。

例えば下記のようにひとつのShardを持ったKinesis Streamからデータを受け取って処理をするConsumerプロセスをEC2上にひとつ起動する、という非常に単純なことをやるにしても
![figure1.png](https://qiita-image-store.s3.amazonaws.com/0/10292/34400979-f98d-4dc9-55e4-598e21a5e634.png "figure1.png")

必要な作業手順としては

1. Kinesisのストリームをつくる
2. Consumerのコードを書く
3. EC2を起動して必要なランタイムやライブラリをインストールする
4. ConsumerのコードをEC2にデプロイ
5. Shard-0を狙ってConsumer-0を起動する

となってくる。アプリケーションを書きたいのに、実はやっていることのほとんどがインフラの準備という状態になってしまっていて、ちょっとめんどくさいよね。Shardが複数になってきたり、Streamが多段になってきたりするとこの手間は指数関数的に増えていくわけだし。「アプリケーション書いたらあとはKinesisやEC2、その上で動くコードはよしなにデプロイしてくれる」みたいな状態にしていきたいなーと思っている。

## インフラじゃなくてモデルやオブジェクトとして扱おう。フレームワークでサービスを隠蔽しよう

じゃあどうしたらいいのという話。

例えばAmazonから提供されているKinesis Client Library(以下、KCL)([Java](https://github.com/awslabs/amazon-kinesis-client), [Python](https://github.com/awslabs/amazon-kinesis-client-python))というものがある。今回はKCLとは別路線を考えたいと思っているが、その前にKCLが提供してくれる/してくれないことを整理すると以下のとおり。

### KCLが提供してくれること

- 直接Kinesisを触る部分の隠蔽。IRecordProcessorというクラスのInitialize、ProcessRecords、Shutdownという3つのインターフェイスを実装するだけでOK。
- チェックポイント処理の隠蔽。CheckpointerというクラスのCheckpointというメソッドを呼ぶだけでDynamoDBに「どこまで処理をしたのか」という冒険の書を作ってくれる
- 横方向のスケールとコーディネーション。KinesisのStreamが複数になってきた時に、KCLは起動するConsumerのプロセス数を自動調整してくれる。また、複数のホストでKCLが起動していても、前述のDynamoDBのテーブルを使って処理の重複などが起こらないようなコーディネーションをしてくれる。

### KCLが提供してくれないこと

- 縦方向（ステップ）の連続性は自分で考慮しなければならない。KCLを多段にするときはKCLアプリケーションを複数作ってそれぞれ別物として扱う必要がある。
- デプロイも自分で面倒を見なければならない（[AWSのビッグデータ番長のIan MeyersがElastic Beanstalkでデプロイしようぜ！といういいブログポストをしてくれている](http://blogs.aws.amazon.com/bigdata/post/Tx2AS1MWDUK5DUK/Hosting-Amazon-Kinesis-Applications-on-AWS-Elastic-Beanstalk)ので興味ある方はそちらを是非。）

感覚的にいうと「マッシブなShard数/流量を持ったStreamをConsumeするアプリケーションをいかに楽に実装/運用できるようにするか」というのがKCLのコンセプトのように思う。

一方今回は「縦に長いパイプラインをいかに楽に実装してデプロイできるか」というのを考えたい。HadoopのMapReduceみたいな感じで「一枚のファイルに連続する処理ステップを書いたらあとはクラスタ上でコードが動く。しかも横方向のスケールも考慮してくれるぜ」みたいな感じのものがほしい。

ここから先は、実際にそんなかんじのフレームワークを書くにあたって（リリースできるかどうかはわかりません）のブレインストーミングをしてみる。言語はnode.jsで。

## リアクティブプログラミング: Kinesisはデータストリーム

Kinesisは受け取ったデータを(Shuffle & Sortしたうえで)後続のConsumerにストリームのようなイメージで渡してくれる。なのでConsumerの実装は、基本的には[GoFのObserverパターン](http://ja.wikipedia.org/wiki/Observer_%E3%83%91%E3%82%BF%E3%83%BC%E3%83%B3)のような実装にするのが自然だと考えられる。リアクティブ！

## RxJSの話。

それで、リアクティブなプログラミングモデルを提供するフレームワークを書くにあたって、今回はRxJSをいろいろ調べてみた。

JavaScriptにはPromiseやJSDeffered、RxJSなど、データストリームを処理するためのフレームワークがいろいろある。以前、[社内で行われたハッカソン](http://aws.typepad.com/sajp/2014/11/tech-hack-a-thon.html)ではPromiseっぽいものを自分で実装してこの仕組に近いものを作ってみた。今回はRxJSに興味があったので（遅っ！）RxJSベースで考えてみる。

RxJSの正式な名前は[The Reactive Extentions for JavaScript](https://github.com/Reactive-Extensions/RxJS)で、[Microsoft Open Technologies, Inc](http://msopentech.com/)によってホストされているプロジェクト。

このライブラリを使うことによってFRP(Funcitonal Reactive Programming)を簡単に実現できますよというのがウリなのだが、Functional ProgrammingもReactive Programmingもちゃんと語れるほど知識があるわけではないのでこれはまたこんどまとめたい。(いろいろドキュメントは読み漁ってみた。)

で、RxJSを使うとこんな感じにイベント処理が書ける。([サンプルコードは上記githubプロジェクトページのREADMEより引用](https://github.com/Reactive-Extensions/RxJS/blob/master/readme.md))

```javascript
var source = getStockData();

source
  .filter(function (quote) {
      return quote.price > 30;
  })
  .map(function (quote) {
      return quote.price;
  })
  .forEach(function (price) {
    console.log('Prices higher than $30: $' + price);
  });

```

## KinesisのStreamをどう隠蔽するか

さっきでてきた下記のような単純な処理を書く場合。
![figure1.png](https://qiita-image-store.s3.amazonaws.com/0/10292/34400979-f98d-4dc9-55e4-598e21a5e634.png "figure1.png")

こんなフレームワークがあれば
![figure2.png](https://qiita-image-store.s3.amazonaws.com/0/10292/a202ac30-e215-c973-323f-71a9ce079104.png "figure2.png")

こんな感じにコードが書ける。

```consumer1.js(擬似コード)
var stream1 = new ObservableStream({stream: 'stream-1'});
stream1.Subscribe(
  function(data){
    doSomeWork(data)
  }
);
```

これによりKinesisを直接扱うというよりはRxJSのコードを書く流れでKinesisを扱えるようになる。

## ノード内での横方向のスケール

先ほどの擬似コードではKinesisの隠蔽をしただけで他にも課題が残っている。では、まず横方向のスケールをどう扱えばいいのか。イメージとしては下記のような状況。
![figure3.png](https://qiita-image-store.s3.amazonaws.com/0/10292/6b767aae-8f7f-dbbf-aca2-2aee764402b7.png "figure3.png")

で、僕としてはこんな感じにしてやればいいのかなと思っている。
![figure4.png](https://qiita-image-store.s3.amazonaws.com/0/10292/ea74eecb-fe0b-0f4c-7979-0bd92f03681a.png "figure4.png")

このアプローチであれば先ほどとコードを変える必要はなく、フレームワーク側での処理を単純なEvent Loopの生成から、子プロセスをForkした上でそれぞれEvent Loopを生成、という処理に書き換えてやればよさそう。そうすれば取り扱うShardが増えても問題なさげ。

```consumer2.js(擬似コード)
var stream1 = new ObservableStream({stream: 'stream-1'});
stream1.Subscribe(
  function(data){
    doSomeWork(data)
  } 
);//実はここでFork処理が挟まっている
```

![figure5.png](https://qiita-image-store.s3.amazonaws.com/0/10292/e6134e91-c78c-6d41-84c7-c13ca82e069c.png "figure5.png")

## ノードをまたいだ横方向のスケール

先ほどはひとつのノードの中でConsumerプロセスを増やす方法を考えたが、今度はノードをまたいでプロセスを増やす方法を考えたい。こういう感じ。
![figure6.png](https://qiita-image-store.s3.amazonaws.com/0/10292/0b8ba7e8-b653-9b8a-cb8a-fb506475774a.png "figure6.png")


事前に定義されたリソースプールから、必要な分だけリソース（ノード）をshiftしてきてタスクに割り当ててくれる、YARNみたいなサービスがほしいなぁと思っていたところにちょうどECS(Elastic Container Service)がプレビューリリースされたので、これをプロビジョナに使えば以下のようなイメージにできそう。もちろん、EC2のAPIを使って実装することもできるが、リソースプールの仕組みを実装するのが手間（？）なのでECSが手っ取り早そう。あと、勉強不足でアレだけど、YARNそのものもこういう用途に使えたりするんだろうか。

![figure7.png](https://qiita-image-store.s3.amazonaws.com/0/10292/a66686ab-d74f-6b03-2fda-6d835ce92ca6.png "figure7.png")

ただし、この実装方法だと、実際のConsumerプロセスをManagerから直接Forkするわけではないので、関数の渡し方に工夫の必要が出てくる。どうしたらいいんだろう・・・ 関数をtoString()しちゃう・・？ｗ

という課題はあるもののこの時点でもまだアプリケーションコードは下記のままで動くように作れるはず。

```consumer3.js(擬似コード)
var stream1 = new ObservableStream({stream: 'stream-1'});
stream1.Subscribe(
  function(data){
    doSomeWork(data)
  } 
);//実はここでリソースプロビジョン処理が挟まっている
stream1.run(); //リソースプロビジョンがあるので、ヨーイドンのトリガーがあったほうがよさげ
```

## 縦方向のスケール

ここまでは横方向のスケールについて考えてきたが、次に縦方向のスケール、というかKinesisを挟んだ処理のチェインのさせ方について考えたい。のだが、今回はだいぶ長くなってきたので次回じっくり考えることにする。

いまのところは

```javascript
var stream1 = new ObservableStream({stream: 'stream-1'});
var stream2 = new ObservableStream({stream: 'stream-2'});

stream1                // Stream1
.Subscribe(            // Task1
  function(data){
    doSomeWork(data)
  } 
)
.toStream(stream2)     // Stream2
.Subscribe(            // Task2
  function(data){
    doAnotherWork(data)
  } 
).run();
```
みたいな感じに、RxJSの書き方の中で実現できればいいなぁと思っている。しかし、toStream()でKinesisを挟み、そこを分岐点にして前後の関数を別々にTaskとしてComposeしてノードに配る、のは大変そう、というかかなりトリッキーな実装になってしまいそう。なので下記のようなApache StormのTopologyっぽい書き方が割りと現実的かも、と現時点では思っている。

```javascript
var stream1 = new ObservableStream({stream: 'stream-1'});
var stream2 = new ObservableStream({stream: 'stream-2'});
var tasks = new ChainedTasks([
  {
    stream: stream1,
    task: function(){
      this.source.Subscribe(function(data){
        doSomeWork(data)
      }
    }
  },
  {
    stream: stream2,
    task: function(){
      this.source.Subscribe(function(data){
        doAnotherWork(data)
      }
    }
  }
]);
tasks.run();

```
これならTaskをステップごとに切り分けてComposeがしやすそう。RxJSの書き方からはかけ離れてしまうけれども。

## ローカルのテスタビリティ

あとはローカルでのテスタビリティが非常に大事だと思っている。実際に書いたコードを、分散環境にデプロイしないと試せないというのは非常にアレなので、以下のようにできるといいかな。

```javascript:driver.js
tasks.run({
  kinesis:     'local',   //本物のKinesisを使うかMockするかのフラグ
  distributed: 'local'    //ノード分散をするかlocalhostだけで動かすかのフラグ
});
```

## まとめ

まだブレインストーミングの途中なのでまとまっているわけではないが、このポストのまとめとしては、Kinesisをもっとプログラマフレンドリに使うためのライブラリについて考えてみた、という話でした。もうちょっと考えを進めていって、冬休みの宿題的に実装・・・・したいなぁ。

あと、今回はKinesisを話の出発点にしているのでKinesisベースで話をしているが、LambdaやSWFも抽象化できるようにしてもよさげ。

## 参考文献

- [The Reactive Extensions for JavaScript (RxJS)](https://github.com/Reactive-Extensions/RxJS#the-reactive-extensions-for-javascript-rxjs-23)
- [RxJS Design Guidelines](https://github.com/Reactive-Extensions/RxJS/tree/master/doc/designguidelines)
- [FRP and RxJS with Matthew Podwysocki - Javascript Jabber](http://devchat.tv/js-jabber/083-jsj-frp-and-rxjs-with-matthew-podwysocki)
- [Storm Tutorial](https://storm.apache.org/documentation/Tutorial.html)
- [2015年に備えて知っておきたいリアクティブアーキテクチャの潮流](http://qiita.com/hirokidaichi/items/9c1d862099c2e12f5b0f)
- [linq.js & Reactive Extensions for JavaScript(RxJS)入門](http://neue.cc/2010/12/20_290.html)
- [やさしいFunctional reactive programming（概要編）](http://maoe.hatenadiary.jp/entry/20100109/1263059731)