Forem: nasa9084

TOTPを実装する

nasa9084 — Fri, 30 Mar 2018 17:03:45 +0000

ここ数年で多くのサービスで採用されてきている二要素認証ですが、皆さん使っているでしょうか。

私は実は最近までは面倒であまり使っていなかったのですが、ようやく重い腰を上げてあちこち設定しました。

そのうち、近年特によく使われているのがTOTP(Time-Based One-Time Password)と呼ばれるアルゴリズムです。

TOTPアルゴリズムはRFC6238で定義されたアルゴリズムで、サーバとクライアントが共有する秘密鍵および現在時刻から確認用のコードを生成するものです。

RFCやWikipediaを見てわかるよう、かなり簡素なアルゴリズムで、一つ一つ理解していけば比較的簡単に実装することができます。

Go言語のコードを実例に、サンプルコードを実装してみます。

HOTPとTOTP

TOTPアルゴリズムとよく似たものに、HOTP(HMAC-Based One-Time Password)と呼ばれるアルゴリズムがあります。

これは、サーバとクライアントが共有する秘密鍵と、「何回目の認証か」から確認用のコードを生成するアルゴリズムです。

HOTPアルゴリズムは(勿論)アルゴリズムですから、ある計算手順であり、秘密鍵と認証回数を引数にとって認証用コードを返す関数として表すことができます。

この、認証回数という引数に対して、現在時刻を入力したものがTOTPです。

認証「回数」というくらいですから、値は正の整数値です。時刻を整数として入力するため、UnixTimeを使用します。

実際にはUnixTimeそのままで入力すると1秒ごとに認証用コードが変わってしまい実用できではありませんから、ある秒数を一周期として、現在が何周期目なのか、という値を入力します。

TOTPを実装する

扨、前置きはこれくらいにしてTOTPアルゴリズムを実装します。

次の式で表されます。

$$TOTP(K, T_0, X) = HOTP(K, T(T_0, X))$$

$$T(T_0, X) = \frac{(CurrentUnixTime - T_0)}{X}$$

$K$は共有秘密鍵です。
$T_0$は数えはじめの時間で、通常はUnix epoch、すなわち0を使用します。
$X$は一周期の秒数で、規定値は30秒です。(実際、多くのサービスが30秒ベースです)

プログラム実装は以下の様に書いてみます。

func TOTP(k string, t0, x int) int {
    return HOTP(k, T(t0, x))
}

func T(t0, x int) int {
    return (time.Now().Unix - t0)/x
}

簡単ですね。上記の内、定義されていないのはHOTP(K, T)だけとなりました。

HOTPを実装する

TOTPのコードではHOTPアルゴリズム部分が実装されていませんので、ここを実装すれば実際に使用できるはずです。

HOTPアルゴリズムはRFC4226で定義されているので、これを読みながら実装します。

RFCを読むと、HOTPは大きく次の3ステップで求められることがわかります。

共有秘密鍵と認証回数からHMAC-SHA1の値を求める
4byteの文字列を生成する
HOTPの値を計算する

何が何やらですね。もう少し詳しく見ていきましょう。

1. HMAC-SHA1の値を求める

HMACはメッセージ認証コードの一種で、ハッシュ関数を使用し、秘密鍵とメッセージから認証コードを生成します。

ここでは、その名の通り、ハッシュ関数としてSHA1を使用します。

また、メッセージとして認証回数を使用します。

HMAC-SHA1の値を$HS$として、式で表すと次のような形です。

[

HS = HMAC-SHA1(K, C)

]

$K$は秘密鍵
$C$はメッセージ(ここでは認証回数)

Go言語では、HMACもSHA1も標準パッケージに入ってますので、こちらを使用します。

HMACはcrypto/hmacパッケージ、SHA1はcrypto/sha1パッケージです。

実装してみます。

func HMACSHA1(k, c []byte) []byte {
    mac := hmac.New(sha1.New, k)
    mac.Write(c)
    return mac.Sum(nil)
}

Go言語で、HMACはhash.Hashとして実装されており、hmac.New(func() hash.Hash, []byte)でハッシュ関数オブジェクトを得て使用します。

SHA1のブロック長^[1]は160bitですから、文字列でいうと20文字の文字列を得ることになります。

2. 4byteの文字列を生成する

次に、先に計算した$HS$から4byteの文字列を作ります。

RFCの6ページ目に、計算方法が書かれていますので、その通り計算します。

[

Sbits = DT(HS)

]]

まず、offsetbitsを求めます。

offsetbitsは$HS$の20文字目(つまり最後の文字)の下位4bitです。

Go言語で扱うのはbyte列ですから、20文字目を8bitまるごと取り出して、上位4bitを0で埋める($00001111_{(2)}$でマスクをかける)ことで下位4bitを取り出したこととします。

なお、Python等では2進数のリテラルもありますが、Goでは2進数のリテラルはありませんので、16進数で表記します($00001111_{(2)}$は$F_{(16)}$です)。

offsetbits := hs[19] & 0xF

次に、offsetを求めます。

offsetは、offsetbitsを数値として取り出します。

これは、特別変換を行うわけでは無く、byte列を直接intとして読みます(4bitなので、0〜15の値)。

offset := int(offsetbits)

続いて、$HS$のoffset番目の文字から4文字を抜き出し、これをpとします。

p := hs[offset:offset+4]

pの終端31bitを抜き出します。

これも、offsetbitsの時の計算同様、マスクをかけることで同様の処理とします($01111111111111111111111111111111_{(2)}$は$7FFFFFFF_{(16)}$)。

尚、byte列に直接マスクをかけるのは少々面倒ですし、次のステップで数値への変換を行いますので、一旦数値にしてからマスクをかけます。

[]byteからintへは直接キャストできないため、encoding/binaryパッケージを使用します。

ここまでをまとめると以下の様になります。

func DT(hs []byte) int {
    offsetbits := hs[19] & 0xF
    offset := int(offsetbits)
    p := hs[offset:offset+4]
    return int(binary.BigEndian.Uint32(p)) & 0x7FFFFFFF
}

3. HOTPの値を計算する

前のステップで出た値の数値表現と、$10^{Digit}$の剰余をとり、所定の桁数に納めます。

幸い、前のステップの出力値はintとなっていますから、ほとんどそのまま使えます。

func ReductionModulo(snum int) int {
    return int(int64(snum) % int64(math.Pow10(g.Digit)))
}

HOTPアルゴリズムまとめ

ここまでに見てきたステップを合わせて、HOTPを得る関数を作成しましょう。

改めてRFCを眺めると、HOTPは次のように定義されています。

[

HOTP(K, C) = Truncate(HMAC-SHA-1(K, C))

]

$Truncate$はDTのことです。

これをGo言語で書き直すと次のようになります。

func HOTP(k, c []byte) int {
    return DT(HMACSHA1(k, c))
}

TOTPに併せてHOTPを修正する

扨、本記事の目標はTOTPアルゴリズムの実装でした。

本記事の冒頭で作成したTOTP関数は、次のようなものでした。

func TOTP(k string, t0, x int) int {
    return HOTP(k, T(t0, x))
}

func T(t0, x int) int {
    return (time.Now().Unix - t0)/x
}

T(t0, x)の返り値はintですから、func HOTP(k, c []byte) intに渡すことができません。

ここはHOTP関数をちょっと修正してみます。

func HOTP(k []byte, c int) int {
    cb := make([]byte, 8)
    binary.BigEndian.PutUint64(cb, c)
    return DT(HMACSHA1(k, cb))
}

引数をTOTP関数で与えたい形に合わせ、関数内で型変換ロジックを入れました。

これで、無事TOTPアルゴリズムを実装することができました。

(本文中のソースコードはテストされていません。 本番では使用しないでください )

出力の長さのこと ↩︎

Let's Encryptでワイルドカード証明書を取得する

nasa9084 — Wed, 14 Mar 2018 02:31:55 +0000

先日twitterでサポートされたと発表されたLet's Encryptのワイルドカード証明書ですが、本日未明、正式にcertbotがワイルドカード証明書に対応したと発表されました!^[1]

早速ですが、実際にワイルドカード証明書を取得してみます。

尚、今回対象とした環境は以下のとおりです。

CentOS 7
リバースプロキシとしてnginx
DNSはGehirn DNS

では、作業していきます。

CentOS 7でcertbotを使用する場合、大抵はyumでcertbotをインストールしていると思いますので、まずはアップデートします。

$ sudo yum update

出力は省略しますが、certbotが0.22.0にアップデートされます。

0.22.0はワイルドカード対応バージョンですので、問題ないですね！

公式のマニュアルでは、dns-pluginを使うよう書いてありますが、Gehirn DNSのプラグインは無いため、今回は手動で行きます。

以下のコマンドを実行します。

# certbot certonly --manual --preferred-challenges dns -d *.web-apps.tech --server https://acme-v02.api.letsencrypt.org/directory
Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator manual, Installer None
Enter email address (used for urgent renewal and security notices) (Enter 'c' to
cancel): nasa.9084.bassclarinet@gmail.com
Starting new HTTPS connection (1): acme-v02.api.letsencrypt.org

-------------------------------------------------------------------------------
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server at
https://acme-v02.api.letsencrypt.org/directory
-------------------------------------------------------------------------------
(A)gree/(C)ancel: a

-------------------------------------------------------------------------------
Would you be willing to share your email address with the Electronic Frontier
Foundation, a founding partner of the Let's Encrypt project and the non-profit
organization that develops Certbot? We'd like to send you email about EFF and
our work to encrypt the web, protect its users and defend digital rights.
-------------------------------------------------------------------------------
(Y)es/(N)o: y
Starting new HTTPS connection (1): supporters.eff.org
Obtaining a new certificate
Performing the following challenges:
dns-01 challenge for web-apps.tech

-------------------------------------------------------------------------------
NOTE: The IP of this machine will be publicly logged as having requested this
certificate. If you're running certbot in manual mode on a machine that is not
your server, please ensure you're okay with that.

Are you OK with your IP being logged?
-------------------------------------------------------------------------------
(Y)es/(N)o: y

-------------------------------------------------------------------------------
Please deploy a DNS TXT record under the name
_acme-challenge.web-apps.tech with the following value:

qiGA8Vep17l0nYJ1O1AdF68D9iT7bL5Mpoe3j7-Caag

Before continuing, verify the record is deployed.
-------------------------------------------------------------------------------
Press Enter to Continue

上記のようにTXTレコードを追加するようにメッセージが出たら、指定された値をDNSに追加します。

Gehirnでは以下のような形になります。

追加したら、digコマンドを使用してDNSレコードが浸透()したことを確認できるまで待ちます。

$ dig -t txt _acme-challenge.web-apps.tech

(前略)

;; ANSWER SECTION:
_acme-challenge.web-apps.tech. 30 IN    TXT "qiGA8Vep17l0nYJ1O1AdF68D9iT7bL5Mpoe3j7-Caag"

(以下略)

certbotを実行している端末に戻り、Enterで進みます。

Waiting for verification...
Cleaning up challenges

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/web-apps.tech/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/web-apps.tech/privkey.pem
   Your cert will expire on 2018-06-12. To obtain a new or tweaked
   version of this certificate in the future, simply run certbot
   again. To non-interactively renew *all* of your certificates, run
   "certbot renew"
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate
   Donating to EFF: https://eff.org/donate-le

上手くいくと、上記のように Congratulations!が含まれたメッセージが出力されます。

fullchainが/etc/letsencrypt/live/<ドメイン名>/fullchain.pemに、キーファイルが/etc/letsencrypt/live/<ドメイン名>/privkey.pemに保存されます。

自動更新の設定はまた別の記事で。

実際は一週間ほど前にリリースはされていたようです ↩︎

graceful shutdown server with syg

nasa9084 — Sat, 10 Mar 2018 15:42:54 +0000

originally posted to blob.web-apps.tech

Using github.com/nasa9084/syg, you can map signal to callback function easily.(c.f. syg: simply signal to callback mapping in Go)

Now, let's implement a HTTP server which shuts down gracefully when catch SIGINT.

package app

import (
    "context"
    "net/http"
    "os"
    "time"

    "github.com/nasa9084/syg"
)

type Server struct {
    server *http.Server
    closed chan struct{}
}

func NewServer() *Server {
    http.HandleFunc("/", longlongHandler)
    return &Server{
        server: &http.Server{
            Addr: ":8080",
        },
        closed: make(chan struct{}),
    }
}

func (s *Server) Run() error {
    // os.Interrupt　= syscall.SIGINT
    cancel := syg.Listen(s.shutdown, os.Interrupt)
    defer cancel()

    err := s.server.ListenAndServe()
    <-s.closed
    return err
}

func (s *Server) shutdown(os.Signal) {
    s.Shutdown(context.Background())
    close(s.closed)
}

func longlongHandler(w http.ResponseWriter, r *http.Request) {
    // a very long process!
    time.Sleep(10 * time.Second)
    w.Write([]byte("hello"))
}

call from main:

package main

import (
    "log"

    "foo/bar/app" // assume the app package above is in $GOPATH/foo/bar/app
)

func main() {
    s := app.NewServer()
    if err := s.Run(); err != http.ErrServerClosed {
        log.Print(err)
    }
}

In main, you don't need to think goroutine, graceful shutdown, or signal listening.

Check the server is running well.

At first, build and run the server:

$ go build main.go
$ ./main

Then launch one more Terminal, and send a request:

$ curl localhost:8080
hello

after 10 seconds, message "hello" is returned.

Now, send request once again, type Ctrl-C(this means SIGINT) in the first terminal before returned the response.
The server will shut down after return the response, not suddenly.

We did it!

syg: simply signal to callback mapping in Go

nasa9084 — Wed, 07 Mar 2018 04:24:11 +0000

When you want to catch system signals in Go, you can use os package, os/signal package, and syscall package.

Here's an example of catching a system signal then shutdown the HTTP server gracefully:

func main() {
    sigCh := make(chan os.Signal, 1)
    signal.Notify(sigCh, syscall.SIGINT)

    s := &http.Server{
        // configure server properties
    }

    go func() {
        <-sigCh
        s.Shutdown(context.Background())
    }()

    if err := s.ListenAndServe(); err != http.ErrServerClosed {
        // error handling
    }
}

Yes, this is a very simple pattern.
If server downed with some error before signal is sent, the goroutine which listening the signal will leak.
So, we use context and for-select loop.

func main() {
    sigCh := make(chan os.Signal, 1)
    signal.Notify(sigCh, syscall.SIGINT)

    s := &http.Server{
        // configure server properties
    }
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    go func() {
        for {
            select {
                case <-sigCh:
                    s.Shutdown(context.Background())
                case <-ctx.Done():
                    return
            }
        }
    }()

    if err := s.ListenAndServe(); err != http.ErrServerClosed {
        // error handling
    }
}

Hmmm.... This is also a very simple pattern, there's no error handling code, no server configure, or no flag parsing.
However, the code is so complex. I cannot remember this signal catch idiom.

So I created github.com/nasa9084/syg package for listen signals and call a callback function.

github.com/nasa9084/syg

Rethink the example code.
I rewrite the example code with syg package:

func main() {
    s := &http.Server{
        // configure server properties
    }

    cancel := syg.Listen(func(os.Signal) {
        s.Shutdown(context.Background())
    }, syscall.SIGINT)
    defer cancel()

    if err := s.ListenAndServe(); err != http.ErrServerClosed {
        // error handling
    }
}

Wow, very shortened.

The syg package has only two function, Listen() and ListenContext().
As you thought, these are essentially same function.
ListenContext() takes context.Context, but Listen() is not.
Listen() calls context.Background() inside the function, and calls ListenContext() with that context.

These functions calls signal.Notify() and generates goroutine which waits the signal, and returns the cancel function.

syg package is very small package, but it is very useful.
Please use this package and make issues or PR if you find problems or enhancements!

Goでコマンドラインオプションを処理する

nasa9084 — Sat, 24 Feb 2018 03:22:28 +0000

this post originally appears on blog.web-apps.tech

TL;DR

github.com/jessevdk/go-flagsが便利

flagパッケージ

コマンドライン・ツールを作ろうと考えたとき、避けては通れないのがコマンドラインオプションを如何に処理するか、ということです。

Go言語では、標準パッケージにflagというパッケージが存在し、これを用いることでコマンドラインオプションをパースすることが出来ます。

しかし、flagパッケージでは、ロングオプションとショートオプションを一度に定義することが出来ず、また、ロングオプションであろうとショートオプションであろうと-XXXという、ハイフンが一つつく形式のオプションとなります。

これはあまり一般的ではなく^[1]、便利とも言いにくいでしょう。

そこで便利なのが、jessevdk/go-flagsパッケージです。

go-flagsパッケージ

jessevdk/go-flagsパッケージは、その名の通り、コマンドラインオプションを取り扱うパッケージです。

ショートオプション、ロングオプションはもちろんのこと、ショートオプションをまとめて指定する、同じオプションを違う引数で複数回指定する、環境変数からの読み込み、デフォルト値の指定などに対応していて、一般的なオプションの処理に幅広く対応出来ます。

オプションは構造体として定義出来るため、パースした後の処理で取り回すのも簡単です。

簡単な例を見てみましょう。

type options struct {
    Name string `short:"n" long:"name" description: "listen address"`
}

func main() {
    var opts options
    if _, err := flags.Parse(&opts); err != nil {
        // some error handling
        return
    }
    fmt.Printf("Hello, %s\n", opts.name)
}

パッケージ宣言やインポートの節は省略していますが、上記をmain.goとして実行すると、以下の様に出力されます。

$ go run main.go -h
Usage:
  main [OPTIONS]

Application Options:
  -n, --name= listen address

Help Options:
  -h, --help Show this help message

$ go run main.go -n Foo
Hello, Foo

フィールドの設定

jessevdk/go-flagsパッケージでは、オプションを定義するために構造体を作ります。

構造体の各フィールドがオプション一つ一つに当たります。

そのため、細かい設定はタグで行うことになります。

以下で、このパッケージで使用できる、主なタグを紹介します。

short
- ショートオプションの名前を決定します。ショートオプションですので、一文字をしていします。
long
- ロングオプションを指定します。
description
- ヘルプで表示される、オプションの説明文を指定します。
no-flag
- フィールドをオプションとして扱わないときに指定します。値は空値以外とします。
env
- 読み込む環境変数を指定します。環境変数から読み込まれた値は、オプションの規定値となります。(オプションで指定されたものが優先されます)
env-delim
- sliceやmapのオプションに環境変数から値を読み込む場合、このタグで指定した値で分割されます。
default
- 規定値を設定します。mapやsliceの値の場合は複数回指定することもできます。
default-mask
- ヘルプで規定値の欄に表示される値を指定します。指定しなかった場合はdefaultの値が表示されますが、このタグを指定すると表示を上書きできます。-を指定すると、規定値を表示しない設定となります。
choice
- オプションに指定可能な値を定義できます。複数の選択肢を定義する場合は複数回指定します。
required
- オプションが必須な場合に指定します。値は空値以外とします。このタグが指定されたオプションが実行時に与えられなかった場合、ErrRequiredを返します。
positional-args
- 構造体に対してこのタグを指定することで、位置引数を定義できます。

このほか、オプショングループ、オプションの名前空間、サブコマンドの定義などに対応しています。

javaのオプションなど、全く見ないわけではありませんが ↩︎

kubesprayを使用してkubernetes clusterを構築する(2)

nasa9084 — Fri, 23 Feb 2018 14:45:49 +0000

this post originally appears on blog.web-apps.tech

3ヶ月ほど前に、kubesprayを使用してkubernetes clusterを構築するという、kubesprayとkubespray-cliを使用してKubernetesクラスタを構築する記事を書きました。

しかし、kubespray-cliはすでにdeprecatedだということなので、kubespray-cliを使用せずにkubesprayでクラスタを構築する手順をまとめておきます。

要件

kubesprayを使用してkubernetesクラスタを構築するための要件は以下のようになっています。

ansible 2.4以降とpython-netaddr (python-netaddrを忘れがちなので注意)
- pip install ansible netaddr
Jinja 2.9以降(ansibleの依存でインストールされると思います)
構築先サーバがインターネットに接続できること
構築先サーバでIPv4 forwardingが有効になっていること
- sysctl -w net.ipv4.ip_forward=1する(再起動するまで)
- /etc/sysctl.confにnet.ipv4.ip_forward = 1と記入する(再起動後)
Ansibleを実行するマシンから構築先サーバにSSH鍵が渡されていること
ファイアウォールが無効化されていること
- ファイアウォールの設定をしっかりできる人は有効でも

また、kubesprayには(kubespray-cliのような)inventory生成ツールが付属されており、これを利用する場合はpython3系である必要が有ります。

構成

前回の記事同様、以下のIPを持った三台のサーバを対象として構築してみます。

192.168.1.11
192.168.1.12
192.168.1.13

それぞれ、IPv4 forwardingが有効化され、firewalldを無効化し、Python 3をインストール済みのCentOS 7のサーバとします。また、kubesprayを実行するローカルマシンから、各サーバのrootユーザにSSH鍵を配置^[1]済みとします。

手順

準備

まず、kubesprayをダウンロードします。

$ git clone https://github.com/kubernetes-incubator/kubespray
$ cd kubespray

リポジトリのクローンが完了したら、ansibleなどの依存モジュールを導入します^[2]。

kubespray$ pip install -r requirements.txt

次に、ansible用のインベントリを作成します。

kubespray$ cp -rfp inventory/sample inventory/mycluster
kubespray$ declare -a IPS=(192.168.1.11 192.168.1.12 192.168.1.13)
CONFIG_FILE=inventory/mycluster/hosts.ini python3 contrib/inventory\builder/inventory.py ${IPS[@]}

IPSは対象サーバのIPに合わせて定義をします。

また、環境によっては、python3コマンドではなく、pythonコマンドでPython 3が実行される場合も有ります。適宜読み替えてください。

最後に、構成するkubernetesクラスタの設定をします。inventory/mycluster/group_varsディレクトリにある、all.ymlとk8s-cluster.ymlを適宜変更します。

特に、k8s-cluster.ymlに含まれる、以下の項目は確認しておく必要があるでしょう。

kube_version
- kubernetesのバージョンを指定します。
kube_network_plugin
- kubernetesのnetwork pluginを指定します。初期値はcalicoですが、flannelが一般的です。^[3]
kube_service_addresses, kube_pods_subnet
- kubernetes内部で使用するIPの範囲をCIDR形式で指定します。LAN内のネットワークとかぶらないよう注意しましょう。
dashboard_enabled
- kubernetes dashboardを用意するかどうかの真偽値です。初期値はtrueです。trueの場合、RBACが有効になっている必要があります。
helm_enabled, istio_enabled, registry_enabled
- それぞれ、kubernetes Helm、Istio、Docker registryをデプロイするかどうかの真偽値です。インストールする予定ならここでtrueにしておくと楽です。

設定が完了したら、準備は終了です。

デプロイする

準備ができたら、デプロイしましょう！

とはいっても、ココまで来たら後は普通にansible playbookを流し込むだけです。

次のコマンドを実行します。

kubespray$ ansible-playbook -i inventory/mycluster/hosts.ini cluster.yml

エラーを出さずに終了したら、kubernetesのデプロイは完了です！

kubernetesを操作する

デプロイできたら、kubernetesを操作してみましょう。

一番前に指定したサーバにSSHで接続し、kubectlを使って操作します。

$ kubectl get nodes
NAME STATUS ROLES AGE VERSION
node1 Ready master,node 10d v1.9.2+coreos.0
node2 Ready master,node 10d v1.9.2+coreos.0
node3 Ready node 10d v1.9.2+coreos.0

また、LAN内の他のマシンから操作できるように、管理者アカウントを追加してみましょう。

$ kubectl create serviceaccount nasa
serviceaccount "nasa" created
$ kubectl create clusterrolebinding nasa --clusterrole cluster-admin --serviceaccount=default:nasa
clusterrolebinding "nasa" created

追加できたら、トークンを確認します。

$ kubectl describe serviceaccount nasa
Name: nasa
Namespace: default
Labels: <none>
Annotations: <none>
Image pull secrets: <none>
Mountable secrets: nasa-token-pcn8j
Tokens: nasa-token-pcn8j
Events: <none>
$ kubectl describe secret nasa-token-pcn8j
Name: nasa-token-pcn8j
Namespace: default
Labels: <none>
Annotations: kubernetes.io/service-account.name=nasa
              kubernetes.io/service-account.uid=8916621a-1010-11e8-8bf3-0200c0a80130

Type: kubernetes.io/service-account-token

Data
====
ca.crt: 1090 bytes
namespace: 7 bytes
token: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJkZWZhdWx0Iiwaa3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZWNyZXQubmFtZSI6Im5yc2EtdG9rZW4tcGNuOGoiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoibmFzYSIsImt1YmVybmV0ZXMuaW8dc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6Ijg5MTY2MjFhLTEwMTAtMTFlOC04YmYzLTAyMDBjMGE4MDEfMCIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDgkZWZhdWx0Om5hc2FifQ.D1o3Jvko91dX6pk2qG505dd2zaXW468GGc9RT6eSzJlrjEG7UEtjF9vlhy7c3BegjPddpPpHsc_ouMx5BAmFdWh74v-PvxnX0IKsCVt_9dlSAcxbbk2PSOloqiwMxTs5q-j6y0Tx64zKzq5e520cNBQrkjJV96-f_riRHHXCrLXQKh2vroh_kpVDViQPqM-e4UKLU4zINGHnraouc7T95ib5wIMcVHEejgsZvF-hLgItxiMAhu4NQXzJ2gM4tMhXupgQZLL1-N_oqoTCNFssPQcoE9Ziyj9_RBkUoodhizpxGOKMFogUgG07DRae4OkEjywoR5xDAuQSJMPihTPqzw

kubectlコマンドをインストールした、別のマシンにトークンを設定します。

$ kubectl config set-cluster mycluster --server=https://192.168.1.11:6443 --insecure-skip-tls-verify=true
$ kubectl config set-credentials mycluster --token=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJkZWZhdWx0Iiwaa3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZWNyZXQubmFtZSI6Im5yc2EtdG9rZW4tcGNuOGoiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoibmFzYSIsImt1YmVybmV0ZXMuaW8dc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6Ijg5MTY2MjFhLTEwMTAtMTFlOC04YmYzLTAyMDBjMGE4MDEfMCIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDgkZWZhdWx0Om5hc2FifQ.D1o3Jvko91dX6pk2qG505dd2zaXW468GGc9RT6eSzJlrjEG7UEtjF9vlhy7c3BegjPddpPpHsc_ouMx5BAmFdWh74v-PvxnX0IKsCVt_9dlSAcxbbk2PSOloqiwMxTs5q-j6y0Tx64zKzq5e520cNBQrkjJV96-f_riRHHXCrLXQKh2vroh_kpVDViQPqM-e4UKLU4zINGHnraouc7T95ib5wIMcVHEejgsZvF-hLgItxiMAhu4NQXzJ2gM4tMhXupgQZLL1-N_oqoTCNFssPQcoE9Ziyj9_RBkUoodhizpxGOKMFogUgG07DRae4OkEjywoR5xDAuQSJMPihTPqzw
$ kubectl config set-context mycluster --cluster=mycluster --user=mycluster
$ kubectl config use-context mycluster
$ kubectl get nodes
NAME STATUS ROLES AGE VERSION
node1 Ready master,node 10d v1.9.2+coreos.0
node2 Ready master,node 10d v1.9.2+coreos.0
node3 Ready node 10d v1.9.2+coreos.0

無事、アクセスすることができました！

今回はclusterの設定で--insecure-skip-tls-verify=trueとし、TLSの確認を省略しましたが、マスターノードの/etc/kubernetes/ssl/apiserver.pemをコピーしてきて、kubectl config set-clusterの--certificate-authority=に指定することで、TLSを確認した上で使用することができます。

楽しいkubernetesライフを送りましょう！

ssh-copy-idコマンドを利用すると便利です。 ↩︎
環境によってはsudoが必要かもしれません。 ↩︎
個人的にはcontivで構成しています。深い意味はありませんが、Web UIがついているのが気に入っています。 ↩︎

Generates LICENSE file: git-license

nasa9084 — Wed, 21 Feb 2018 04:56:49 +0000

this post originally appears on blog.web-apps.tech

When we create a new repository on GitHub, we can choose an open source license.

We choose an OSS license, then, LICENSE file is put into the new repository.

Now, I'm usually using hub command to create a new repository.

I'll do below to create:

$ mkdir my_new_repository
$ cd my_new_repository
$ git init
#
# ... some code writing and commit ...
#
$ git create # git command is aliased to hub
$ git push -u origin master

In this flow, I can write description for repository^[1], set homepage^[2], make the repository private^[3], but I CANNOT choose LICENSE.

I can choose and create LICENSE file on the GitHub web page, or I can copy from my other repositories because its content is fixed.

However, I don't do that.

Thus I created git-license, which is subcommand for git.

As you know, when you put git-XXX executable into your PATH, you can use git-XXX command as subcommand of git like git XXX.

git-license is written in Go.

So its executable is only one binary, and it means very easy to start using.

If you have already had Go environment, you can install with:

$ go get github.com/nasa9084/go-license

If not, you can download binary for your os from Releases page.

The command creates LICENSE file you choose using GitHub Licenses API, so network connection is required.

If there's some bugs, comment, or enhancement, please feel free to make issues or make Pull Request.

with -d option ↩︎
with -h option ↩︎
with -p option ↩︎

container-upというツールを書いた

nasa9084 — Fri, 22 Dec 2017 04:23:39 +0000

container-upというツールを書いたのでご紹介。

背景

このブログはghostというブログエンジンで動いています。動作環境としてDockerを使用していて、Ghostの公式イメージを使用しています。

過去の経緯から、単体のDockerコンテナで動作させており、永続データはDockerボリュームとしてマウントしている形です。

扨、Docker ComposeやKubernetesなどのオーケストレーションツールを使っている場合、コンテナのバージョンアップは比較的簡単に行うことができます。

たとえば、Docker Composeを使用している場合、docker-compose upで、新しいイメージで作成したコンテナに差し替えることができます。

しかし、Dockerを単体で使っている場合、基本的には手作業で差し替えを行う必要があります。

Ghostコンテナの更新時は手作業でBlue-Greenアップグレードを行ってきたのですが、Ghostはかなりアップデートのペースが速く、毎度コンテナを差し替えるのが面倒になってきました。

それを楽にするため、 container-up を作りました。

インストール

Go環境がある人

Go言語の環境がすでにある人は、以下のコマンドで使用できるようになります。

$ go get github.com/nasa9084/container-up

それ以外の人

Go言語の環境がない人は、Releasesページから自分のOSに併せてバイナリをダウンロード、パスを通してください。

windows, linux, macos向け、それぞれamd64版のバイナリを用意してあります。

動作確認はmacos、linux(CentOS 7)のみ行っています。

これら以外の環境の人は、予めdepをインストールした上で以下のコマンドでコンパイルしてください。

$ git clonse https://github.com/nasa9084/container-up.git
$ cd container-up
$ dep ensure
$ go build -o container-up main.go

コンパイルしたら、任意の場所にバイナリを移動し、パスを通してください。

使い方

基本的な使い方は、引数にコンテナ名またはコンテナIDを渡すだけです。

$ container-up CONTAINER_NAME

与えられたコンテナと同じ名称のイメージを使用して、ボリュームやネットワークなどの設定はそのままに新しいコンテナを作成し、差し替えます。

:latestなイメージを使用している場合、docker pullした後にこのコマンドを実行することで、最新のイメージから作られたコンテナに差し替わるということです。

もとのコンテナは--rmオプションをつけて起動していた場合を除いて、_oldContainerというサフィックスが付いた状態でstopします。

なにか問題があった場合は、このコンテナに戻すと良いでしょう。

もし、元のコンテナが必要ない場合は、--rmオプションをつけると、差し替え時に削除します。

$ container-up --rm CONTAINER_NAME

:latestではないような、バージョンタグが付いたイメージを使用していて、新しいバージョンのイメージを使いたい場合などのため、新しいイメージ名を指定して実行することもできます。

$ container-up -i IMAGE_NAME CONTAINER_NAME

この場合、差し替えるコンテナは指定されたイメージで作成されます。

これらのコマンドでは、ボリュームのマウント設定は引き継ぎますが、それ以外のファイルはすべて新しいイメージに差し替わります。

もし、ボリュームマウントしているところ以外に引き継ぎたいファイルなどがある場合^[1]、-fオプションにファイルパスを指定することで新しいコンテナにコピーすることができます。

$ container-up -f /path/to/file.ex CONTAINER_NAME

-fオプションは複数指定することができますので、複数のファイルをコピーしたい場合には複数回指定してください。

$ container-up -f /path/to/file1 -f /path/to/file2 CONTAINER_NAME

現状実装されている機能は以上です。

ヘルプは-hオプションをつけることで見られます。

たとえば設定ファイルなど ↩︎

Kubernetes-powered Docker for mac is released!

nasa9084 — Thu, 14 Dec 2017 05:03:01 +0000

DockerCon EU 2017で、DockerがKubernetesを統合・サポートすると発表されましたが、本日ついにKubernetesサポート版Docker for macが(Edgeリリースですが)リリースされました！

これにより、macを使用している場合は(おそらく過去最も簡単に)開発用Kubernetesクラスタを起動することができるようになりました！

この記事では、Docker for macでKubernetesを立ちあげる手順をまとめておきます。

Kubernetesの起動手順

Docker for macのStable版を利用している場合、Edge版をインストールする必要があります。

Install Docker for macのページから、Edge Channelのインストーラをダウンロードし、インストールします。

Dockerを終了させておけば、Stable版を自分でアンインストールする必要はありません^[1]。

Edge版をインストールし、Dockerの設定画面を開くと、以下の様にKubernetesタブが追加されています！！

Kubernetesタブで、Kubernetesの有効化・無効化を簡単に切り替えることができます。

Enable Kubernetesにチェックを入れ(Show system containersはお好みで)、Apply & Restartボタンを押すと、「Kubernetesの初回インストールは少し時間かかるけど、インストールする？」という確認画面が出るので、Installを押します。

一応プログレスバーが出るのですが、余り意味はありませんでした・・・

数分でインストールが終わります。

無事インストールが終了したら、Closeを押したあと、設定画面を閉じます。

この時点で、DockerメニューにもKubernetesのステータスが表示されています。

今回私はShow system containersをオンにしたので、docker ps^[2]するとKubernetesの動作に必要なコンテナが起動しています。

DNS、API Server、Etcd、Scheduler、Proxyと最小限の構成ですね。

kubectlが自動でインストールされるのかどうかは・・・・わかりませんでした。(すでにインストール済みだったため)

kubectlがインストール済みの場合、自動でコンフィグが追加され、以下のコマンドでcontextを選択することで操作できるようになります。

$ kubectl config use-context docker-for-desktop

kubectl get nodesすると、確かに1ノード構成でクラスタが立ち上がっているのがわかります。

Edge版の初回起動時にアンインストールされます ↩︎
docker container lsと打つのは面倒ですね ↩︎

Parcel + Riot.js

nasa9084 — Tue, 12 Dec 2017 15:00:00 +0000

tl;dr

ParcelというJavaScriptのモジュールバンドラを触ってみた
webpackなどと比べて設定ファイルなどもいらずとても簡単
ホットリロードな開発サーバを簡単に実行できる
Riotと組み合わせるのもそれほど難しくない

Parcel + Riot.js

ParcelというJavaScriptのモジュールバンドラが話題なのでさわってみました。

国内で話題になっている元の記事は「webpack時代の終わりとparcel時代のはじまり」。

Reactとの組み合わせで記事を書かれています。

個人的にはRiot.jsが好みなので、Riot.jsとの組み合わせで触ってみました。

尚、webpackは挫折したため比較できません。

Parcel/Riot.jsのインストール

npmを使ってインストールします。

$ npm install -g parcel-bundler riot

source code

ディレクトリ構造

以下の様なディレクトリ構造だとします。

なお、練習用のため、動作確認に関係ない部分は適当に削っています。

src/
|- index.html
|- index.js
|- package.json
|- app/
| |- App.tag

index.html

<!doctype html>
<html lang="ja">
  <head></head>
  <body>
    <App></App>
    <script src="index.js"></script>
  </body>
</html>

index.js

import riot from 'riot'
import './app/tags'

riot.mount('App')

App.tag

<App>
  <h1>Hello, parcel world!</h1>

  <script>
  import riot from 'riot' 
  </script>
</App>

package.json

package.jsonはnpm init -yで作成しました。

compile/bundle & run

$ riot app/ app/tags.js
$ parcel index.html

上記のコマンドで http://localhost:1234 でホットリロードのサーバが動作します。

最終的な成果物を作る場合は parcel build index.htmlとすれば良いようです。

しかし、riot.jsのコンパイルはparcelの前段で別途行っているため、tagファイルの変更はwatchされません。riotコマンドに-wオプションをつけることでウォッチできますが、そのままだと二つのコマンドを別々の端末で開くなどする必要があり、若干面倒です。

package.jsonのscriptsに以下の三つのコマンドを追加します。

{
"watch": "npm run watch:riot & npm run watch:parcel",
"watch:riot": "riot -w app/ app/tags.js",
"watch:parcel": "parcel index.html"
}

追加したら、以下のコマンドを実行します。

$ npm run watch

これでコマンド一つでホットリロードの開発サーバを動作させることができます。

Application Specific Context

nasa9084 — Tue, 21 Nov 2017 04:21:58 +0000

元ネタは@lestrratさんの「Abusing type aliases to augment context.Context」。

golangを用いてHTTPサーバを作る場合、ルーティングを定義するのに以下の様な関数を用います。

http.HandleFunc(path string, handler func(w http.ResponseWriter, r *http.Request)

もちろん、http.Handleを用いる場合もありますし、gorilla/muxなどのライブラリを用いることもあると思います。

ここで重要なのは、func(w http.ResponseWriter, r *http.Request)という引数の方です。

多くの場合、アプリケーションのハンドラ内ではデータベースなどの外部アプリケーション・ミドルウェアを用いることになります。

しかし、golangのHTTPアプリケーションでは、ハンドラ関数の形式がfunc (w http.ResponseWriter, r *http.Request)と決まっています。引数の追加はできないため、引数以外の方法でDB接続情報などを渡す必要があります。

これまで、golangでWebアプリケーション開発を行う場合によく用いられていたデータベースコネクションの保持方法は、dbパッケージを作成し、そこにパッケージ変数として持つ方法かと思います。が、グローバルな変数はできるだけ持ちたくないですよね。

そこで、Go 1.8から追加されたcontextを使うことができます。http.Requestにはcontext.Contextが入っていて、Request.Context()でget、Request.WithContext()でsetできます。

context.Contextに値を持たせる方法で最初に思いつくのはContext.WithValue()を用いる方法ですが、これは値を取得する度にtype assertionをする必要があり、あまりよくありません。

これを解消するため、自分で型を定義するのがよいでしょう。

package context // internal context subpackage

import (
    "context"
    "errors"
)

type withSomethingContext struct {
    context.Context
    something *Something
}

func WithSomething(ctx context.Context, something *Something) context.Context {
    return &withSomethingContext{
        Context: ctx,
        something: something,
    }
}

func Something(ctx context.Context) (*Something, error) {
    if sctx, ok := ctx.(*withSomethingContext); ok {
        if sctx.something != nil {
            return sctx.something, nil
        }
    }
    return nil, errors.New(`no asscosiated something`)
}

このように定義をすることで、毎回type assertionをする必要もなくなり、すっきりします。

扨、このパッケージとcontextパッケージを両方読み込むためには、どちらかの読み込み名称を変更する必要があります。

たとえば、以下の様な具合です。

import (
    "context"
    mycontext "github.com/hoge/fuga/context"

また、ソースコード中でもcontextとmycontextを使い分ける必要があり、煩雑です。

この問題は、Go 1.9で導入されたType Aliasを使うときれいに書くことができます。

import "context"

type Context = context.Context

このように書くと、標準パッケージのcontext.Contextと、このアプリケーションにおけるcontext.Contextが同一のものとして扱われます。

そのため、一つのパッケージのインポートだけで良くなります。

最終的なcontextサブパッケージのコードは以下の様になるでしょう。

package context // internal context subpackage

import (
    "context"
    "errors"
)

type Context = context.Context
/*
** some more definition
*/

type withSomethingContext struct {
    Context
    something *Something
}

func WithSomething(ctx Context, something *Something) Context {
    return &withSomethingContext{
        Context: ctx,
        something: something,
    }
}

func Something(ctx Context) (*Something, error) {
    if sctx, ok := ctx.(*withSomethingContext); ok {
        if sctx.something != nil {
            return sctx.something, nil
        }
    }
    return nil, errors.New(`no asscosiated something`)
}

実際には、標準パッケージのcontextと同等に使用するにはその他の定義の再定義や、複数のwithXXXContextを定義した場合には再帰的に値を読み出す処理が必要になりますが、基本的にはこの形を使用すると便利です。

このようにcontextを定義しておき、以下の様に使用します。

func withSomethingMiddleware(h http.Handler) http.Handler {
    return http.Handler(func(w http.ResponseWriter, r *http.Request) {
        something := &Something{}
        r = r.WithContext(context.WithSomething(r.Context(), something))
        h.ServeHTTP(w, r)
    })
}

http.Handlerのmiddlewareについてはまたの機会に。