作ると整えるは別の仕事 — PulumiとIaCの地図

PulumiとIaC。コードの書類とインフラの設計図、組み立てるサーバーと設定の歯車。

Terraform・Ansible・Pulumiは競合していません。作るのか整えるのかという軸で並べると、役割の違いがはっきりします。

前回: CIはどれも同じ3つ — JenkinsとGitLab CI

はじめに のカリキュラムでは 第6段階「運用する」 にあたります。

作業場所は VM の中(Ubuntu Server)です。 Windows 側では何もしません。

この記事は、お金が動く操作を一切しません。 Terraformでインフラをコード化する|手作業との違いと基本操作とは違い、AWSには何も作りません。 手を動かすのは自分のVMの中だけで完結する部分と、「実行しない確認」までです。 クラウドの認証情報も要りません。

Terraform の回でAWSにEC2を作って消し、Ansible の回で2台のVMに同じ設定を入れました。

2本とも「ファイルに状態を書く」道具でした。 そして2本とも「べき等」という同じ言葉が出てきました。

だから、正直こう思っていました。

やってることが同じに見える。結局どっちを使えばいいんだ。

さらに調べ始めると、名前が増えます。Pulumi、CloudFormation、AWS CDK、Chef、Puppet、Salt、OpenTofu、Crossplane。 どれも「IaC」と説明されています。

ここで手が止まりました。 全部が同じ棚に並んでいるように見えて、選ぶ基準がないからです。

この記事でやるのは、道具を増やすことではありません。地図を作ることです。

そして、地図の一番大事な線は最初に引きます。

Terraform と Ansible は、そもそも別の仕事をしています。 「作る」と「整える」です。 比べる対象ですらありません。

ここが分かっていないと、Pulumi を「Ansible の代わり」だと思って調べ始めて、1時間無駄にします。 私はしました。

対象レベル: 中級 / 区分: 必修

目次

この記事でわかること

  • Terraform と Ansible は競合していないこと。作る(プロビジョニング)と整える(構成管理)で層が違うこと
  • IaC の道具は 「何を管理するか」×「どう書くか」の2軸で並ぶこと。この2軸で、名前の大半は片付く
  • 「宣言的」とは「書いてある状態にする」であって、「YAMLで書く」という意味ではないこと
  • Ansible の state: present は宣言的だが、Ansible 全体が宣言的とは限らないこと。上から順に実行される
  • Pulumi は「設定ファイルではなくプログラム」で、ループ・条件・IDEの補完・テストが手に入ること
  • その代償は「何でも書けてしまう」こと。設定ファイルは読めるが、プログラムは読めなくなる
  • CloudFormation と CDK はそのクラウド専用で、ロックインは「悪」ではなく取引だということ
  • Chef / Puppet / Salt はエージェントが要ること。Ansible が広まったのは、SSHだけで済んだから
  • 一番大きな違いは state(台帳)を持つかどうかで、道具の名前より、この一点で性格が決まること
  • 1台しかないなら、シェルスクリプトで足りること

この記事でやること

  1. Terraform と Ansible の担当範囲を2軸の表に置き直す(ここまで手は動かしません)
  2. Ansible の state: present と Terraform の差を、実際のコードを並べて確認する
  3. 山場:Pulumi を入れて、同じことを TypeScript で書く(ローカルバックエンドのみ。AWSには適用しません)
  4. ループと条件を実際に書き、件数を変えて preview の差分を見る
  5. Pulumi の state ファイルを開いて、terraform.tfstate と同じものだと確かめる
  6. 選び方の表を作り、後片づけまでやる

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
プロビジョニング(provisioning)箱そのものを用意すること。 サーバーを1台立てる、ネットワークを作る。Terraform の担当
構成管理(configuration management)用意された箱の中身をそろえること。 パッケージを入れる、設定ファイルを置く。Ansible の担当
宣言的(declarative)「こうなっていてほしい」を書く書き方。手順は道具が考える
手続き的(imperative)「これをやれ」を順番に書く書き方。シェルスクリプトがこれ
べき等(idempotent)何回実行しても結果が同じという性質。Ansible の回の主題
PulumiIaC の道具。設定ファイルではなく、TypeScript や Python などのプログラムで書く
CloudFormationAWS 純正の IaC。YAML か JSON でAWSのリソースを書く
AWS CDKプログラムを書くと CloudFormation のテンプレートを吐く道具。Pulumi と発想が近い
Chef / Puppet / SaltAnsible より前の世代の構成管理の道具。対象サーバーに常駐プログラム(エージェント)を入れる
エージェント(agent)対象サーバーに入れっぱなしにする常駐プログラム。 定期的に「あるべき状態」を取りに行く
state(ステート)「自分が何を作ったか」の台帳。 Terraform の terraform.tfstate がこれ
バックエンド(backend)state をどこに置くか。 Pulumi は既定でクラウドに置くが、ローカルにも置ける
プレビュー(preview)実行せずに、何が起きるかだけ出すこと。terraform plan と同じ位置づけ
ロックイン(lock-in)その会社の製品から離れられなくなること。良し悪しではなく取引として考える
OpenTofuTerraform から分かれた同じ仕組みの道具。 ライセンス変更をきっかけに生まれた

① の前に — Terraform と Ansible は競合していない

ここを間違えたまま先へ進むと、全部の道具の位置が狂います。

私が最初にやった誤解はこれです。

❌ 「IaC の道具」という1つの棚があって、Terraform / Ansible / Pulumi / Chef はその棚のライバルである

違います。少なくとも2つの棚があります。

作る(プロビジョニング)と、整える(構成管理)

   ┌──────────────────────────────────────┐
   │  ① 作る(プロビジョニング)           │
   │     サーバーという箱を、この世に出す   │
   │     相手:クラウドのAPI               │
   │     例:EC2を1台、SGを1個             │
   └──────────────────────────────────────┘
                    ↓ 箱ができた
   ┌──────────────────────────────────────┐
   │  ② 整える(構成管理)                 │
   │     箱の中身をあるべき状態にする       │
   │     相手:サーバーのOSの中             │
   │     例:nginxを入れる、ufwを開ける     │
   └──────────────────────────────────────┘

Terraform は①しかやりません。 EC2 を作れますが、その中に nginx を入れることは仕事ではありません。

Ansible は②しかやりません。 nginx を入れられますが、EC2 という箱そのものを作るのは仕事ではありません。

だから「Terraform か Ansible か」という問いは、最初から成立していません。 「まず箱を作る。次に中身をそろえる」で、両方使います。

実際、私はもう両方やっています

  • Terraform の回で、AWSにEC2を1台とセキュリティグループを作りました → ①
  • Ansible の回で、VM 2台のタイムゾーンとパッケージとufwをそろえました → ②

別の記事だったのは、別の仕事だからです。 順番が逆でもありません。①のあとに②です。

ただし、境界はきれいではありません

正直に書きます。この線は、実務ではよくにじみます。

にじむ例何が起きているか
Terraform の user_data で起動時にシェルスクリプトを流す①の道具で②をやっている。 楽だが、2回目に流れない(起動時だけ)
Ansible で AWS のリソースを作るモジュールを使う②の道具で①をやっている。 できるが、destroy にあたるものが無い
Docker イメージに設定を焼き込む②を「作る時点」に押し込んだ。 コンテナではこれが主流

にじむこと自体は悪くありません。 ただ、「いまどっちの仕事をしているか」を自分で言えないまま道具を選ぶと、後で困ります。

とくに user_data に長いシェルスクリプトを書き始めたら、それは②に足を踏み入れた合図です。 Ansible の回で見たとおり、シェルスクリプトはべき等ではありません。 起動時に1回しか流れないので、そのときは動きます。設定を変えたくなったときに、行き場がなくなります。


② 2軸で並べる — これが地図です

線を1本引いただけでは、まだ Pulumi の置き場所が決まりません。もう1本引きます。

  • 縦軸:何を管理するか — クラウドの資源(箱)か、サーバーの中身か
  • 横軸:どう書くか — 宣言的(状態を書く)か、手続き的(手順を書く)か
宣言的(状態を書く)手続き的(手順を書く)
クラウド資源を管理<br>(作る)Terraform / OpenTofu<br>CloudFormation(AWS専用)<br>Crossplane(Kubernetes上)Pulumi<br>AWS CDK(AWS専用)<br>AWS CLI をシェルで叩く
サーバーの中身を管理<br>(整える)Ansible(の大部分)<br>Puppet<br>SaltChef(Rubyで書く)<br>シェルスクリプト

これで名前が片付きます。

  • Pulumi は Terraform の隣です。Ansible の代わりではありません。 ← 私が1時間無駄にした場所
  • CloudFormation も Terraform の隣です。違うのは「AWSしか相手にできない」こと
  • Chef / Puppet / Salt は Ansible の隣です。違うのは「エージェントが要る」こと

「Pulumi が手続き的」は言いすぎです

表を単純にするために、あえて片側に置きました。 正確にはこうです。

Pulumi は「宣言的な結果を、手続き的な書き方で組み立てる」道具です。

TypeScript の for ループで3個のリソースを書いても、Pulumi が最終的にクラウドへ送るのは「3個ある状態」という宣言です。「3回作れ」ではありません。

AWS CDK も同じです。 プログラムを書きますが、出てくるのは CloudFormation のテンプレート(宣言)です。

段階Pulumi / CDK
あなたが書くとき手続き的(ループ、条件、関数)
道具がクラウドへ送るとき宣言的(あるべき状態の一覧)

この2段構えが、③以降の話の全部につながります。 利点も代償も、ここから出てきます。


③ 「宣言的」とは何か — state: present の話

言葉の定義だけ読んでも入ってきませんでした。自分が書いた2つのコードを並べたら分かりました。

手続き的に書くとこうなる

Ansible の回で、最初にわざと書いて壊したやつです。

bash
$ apt-get install -y nginx

これは命令です。 「nginx を入れろ」。

問題は、2回目に何が起きるか読めないことです。 すでに入っていたら? 何もしないかもしれないし、バージョンが上がるかもしれません。 書いた側は「入っているかどうか」を気にしていません。

宣言的に書くとこうなる

- name: nginx が入っていること
  ansible.builtin.apt:
    name: nginx
    state: present

これは命令ではありません。状態の宣言です。

「nginx は入っている状態であってほしい」

state: present の present が、その宣言です。 入っていなければ入れる。入っていれば何もしない。判断するのは Ansible です。

そして、これがべき等の正体でした。

べき等は、道具が魔法をかけているのではありません。 「あるべき状態」を書かせたから、道具が現状と比べられるようになった、というだけです。

書き方道具にできること
手順を書く実行するだけ。 現状と比べようがない(比べる相手が「手順」なので)
状態を書く現状を見て、差があるときだけ動く。 ← べき等

逆に言うと、state を持たない書き方をした瞬間にべき等は消えます。 Ansible の command モジュールが毎回 changed になったのは、まさにそれでした。

では、Ansible と Terraform の差はどこか

両方とも state を書いています。それでも性格が違います。

# Ansible: タスクが上から順に実行される
- name: nginx が入っていること
  ansible.builtin.apt:
    name: nginx
    state: present

- name: 設定ファイルが置かれていること
  ansible.builtin.copy:
    src: nginx.conf
    dest: /opt/nginx.conf
# Terraform: 依存関係から順番を道具が決める
resource "aws_security_group" "web" {
  name = "web-sg"
}

resource "aws_instance" "web" {
  ami                    = data.aws_ami.ubuntu.id
  instance_type          = "t3.micro"
  vpc_security_group_ids = [aws_security_group.web.id]
}

違いはここです。

AnsibleTerraform / Pulumi
1つ1つのタスク宣言的(state: present)宣言的
全体の実行順上から順。書いた順に実行される書いた順は無関係。依存から道具が決める
全体を1つの状態として見るか見ない。 タスクの集まり見る。 構成そのものが1つの宣言
要らなくなったものを消せるか消せない。 消すことを自分で書く消せる(destroy)

上の Terraform のコードで、セキュリティグループを後ろに書いても結果は同じです。 aws_instance が aws_security_group.web.id を参照しているので、Terraform が「SGが先だ」と自分で判断します。

Ansible で順番を入れ替えると、結果が変わります。 設定ファイルを先に置いてから nginx を入れたら、上書きされるかもしれません。

だから Ansible は「宣言的な道具」と紹介されますが、正確には「宣言的なタスクを、手続き的に並べる道具」です。 この違いを知らないと、「Ansible も Terraform も同じ」で止まります。私は止まっていました。


④ Pulumi を入れて、同じことを TypeScript で書く

ここから手を動かします。

もう一度書きます。この節で AWS には何も作りません。 Pulumi はローカルにだけ state を置く設定で使い、クラウドの認証情報は一切設定しません。 万一 AWS を相手にするコードを書いてしまっても、認証情報が無いので実行できません。 これは安全弁として、わざとそうしています。

4-1. 前提の確認

打つ場所: VM の中(Ubuntu Server)

bash
$ node --version
$ npm --version

バージョンが2つとも返れば大丈夫です。 npm の回で入れたものがそのまま使えます。

何も返らない、command not found になる人は、npm の回に戻って Node.js を入れてから来てください。 Pulumi の TypeScript は Node.js の上で動きます。

4-2. Pulumi を入れる

打つ場所: VM の中(Ubuntu Server)

bash
$ curl -fsSL https://get.pulumi.com | sh

curl | sh は、取ってきたスクリプトをそのまま実行する形です。 本来は中身を見ないまま実行すべきではありません。 これは公式が案内している入れ方ですが、 気になる人は先に中身を見てください。

bash
$ curl -fsSL https://get.pulumi.com -o /tmp/get-pulumi.sh
$ less /tmp/get-pulumi.sh

入れ終わると、パスの案内が出ます。 ~/.pulumi/bin に入るので、そこを通します。

打つ場所: VM の中(Ubuntu Server)

bash
$ export PATH=$PATH:$HOME/.pulumi/bin
$ pulumi version

バージョンが返れば成功です。

このターミナルを閉じると export は消えます。 毎回打ちたくなければ、~/.bashrc の末尾に足します。

bash
$ echo 'export PATH=$PATH:$HOME/.pulumi/bin' >> ~/.bashrc
$ source ~/.bashrc

[スクリーンショット: 01_pulumi_version.png] VM の中で pulumi version を実行して、バージョンが表示された画面を撮ってください。

4-3. state の置き場所を、先にローカルへ固定する

これを先にやります。順番を間違えるとブラウザのログインを求められます。

打つ場所: VM の中(Ubuntu Server)

bash
$ pulumi login --local
Logged in to <ホスト名> as <ユーザー名> (file://~)

file://~ と出れば成功です。 state が ~/.pulumi の中のファイルになりました。

--local を付けないと、Pulumi は既定でクラウドのサービス(Pulumi Cloud)に state を置こうとします。 ブラウザが開いてアカウント作成を求められます。 学習でそこまで要りません。 そして、これは⑦の state の話にそのままつながる分岐です。 覚えておいてください。

4-4. プロジェクトを作る

打つ場所: VM の中(Ubuntu Server)

bash
$ mkdir -p ~/pulumi-study
$ cd ~/pulumi-study
$ pulumi new typescript --name pulumi-study --stack dev --yes

npm install が走るので、1〜3分かかります。

途中でパスフレーズを聞かれます。

Enter your passphrase to protect config/secrets:

ここで入れたパスフレーズは、この記事の最後まで必要です。忘れないでください。 ローカルに state を置くとき、Pulumi は秘密情報を自分で暗号化します。その鍵になります。 忘れると、作ったスタックを消すこともできなくなります。 私は1回やりました(つまずいた話に書きます)。

毎回聞かれるのが面倒なら、環境変数で渡せます。

bash
$ export PULUMI_CONFIG_PASSPHRASE='ここに自分で決めた文字列'

この行は履歴に残ります。 本番の秘密には使わないでください。この記事の学習用です。

できたものを見ます。

bash
$ ls -1
Pulumi.yaml
index.ts
node_modules
package.json
package-lock.json
tsconfig.json

.tf ファイルが1枚あるだけだった Terraform と、見た目からして違います。 package.json があります。これは普通の Node.js のプロジェクトです。

4-5. 何を作るか — お金の動かないリソースを選ぶ

AWS のリソースは使いません。 代わりに、random というプロバイダを使います。

何をするものか。 ランダムな名前を生成して、それを「リソース」として管理するだけの道具です。

bash
$ npm install @pulumi/random

なぜこれで学習になるのか。 random は「作る・変える・消す」「state に記録する」「2回目は変わらない」という IaC の性質を全部持っています。 違うのは、作られる先がクラウドではなく手元だ、という点だけです。 つまり、お金は1円も動きません。 認証情報も要りません。

4-6. ループと条件を書く

打つ場所: VM の中(Ubuntu Server)

index.ts を丸ごと書き換えます。

bash
$ nano ~/pulumi-study/index.ts
import * as pulumi from "@pulumi/pulumi";
import * as random from "@pulumi/random";

// 設定を読む。指定が無ければ 2
const config = new pulumi.Config();
const nodeCount = config.getNumber("nodeCount") ?? 2;
const withIndex = config.getBoolean("withIndex") ?? false;

// ⚠️ ここが「プログラムである」ということ
const names: pulumi.Output<string>[] = [];

for (let i = 1; i <= nodeCount; i++) {
  const pet = new random.RandomPet(`node-${i}`, {
    length: 2,
    separator: "-",
  });

  // 条件で出力を変える
  if (withIndex) {
    names.push(pulumi.interpolate`${pet.id}-${i}`);
  } else {
    names.push(pet.id);
  }
}

export const nodeNames = names;
export const howMany = nodeCount;

保存は Ctrl+O → Enter、終了は Ctrl+X です。

読み方を5つだけ。

書いたもの意味
new random.RandomPet("node-1", {...})リソースを1個作る宣言。 Terraform の resource ブロック1つに相当
node-${i}リソースの名前。 これが state 上の識別子になる。ここが変わると「別物」扱いになる
config.getNumber("nodeCount")外から件数を渡す。 Terraform の variable に相当
pulumi.Output<string>「まだ値が決まっていない値」。 作ってみないと分からないので、直接は読めない
export const nodeNames実行後に外へ出す値。 Terraform の output に相当

4-7. preview — 実行しない確認

Terraform の plan と同じ位置づけです。

打つ場所: VM の中(Ubuntu Server)

bash
$ cd ~/pulumi-study
$ pulumi preview
Previewing update (dev):

     Type                      Name              Plan
 +   pulumi:pulumi:Stack       pulumi-study-dev  create
 +   ├─ random:index:RandomPet node-1            create
 +   └─ random:index:RandomPet node-2            create

Outputs:
    howMany  : 2
    nodeNames: output<string>

Resources:
    + 3 to create

+ 3 to create が予告です。この時点では何も起きていません。

preview は必ず読んでください。 Terraform の回で plan を読まずに apply して作り直しになりかけた話を書きました。同じです。 とくに -(削除)と ~(置き換え)が出ていないかを見ます。

4-8. 件数を変えて、差分を見る

まだ何も作っていない状態で、件数だけ変えます。

bash
$ pulumi config set nodeCount 4
$ pulumi preview
Resources:
    + 5 to create

for ループの回数が変わっただけで、リソースが2個増えました。

これが Terraform だとこう書きます。

resource "random_pet" "node" {
  count     = var.node_count
  length    = 2
  separator = "-"
}

Terraform にも count はあります。同じことはできます。

では、何が違うのか。次で見ます。

4-9. 実際に作ってみる(お金は動きません)

bash
$ pulumi up --yes
Updating (dev):

     Type                      Name              Status
 +   pulumi:pulumi:Stack       pulumi-study-dev  created
 +   ├─ random:index:RandomPet node-1            created
 +   ├─ random:index:RandomPet node-2            created
 +   ├─ random:index:RandomPet node-3            created
 +   └─ random:index:RandomPet node-4            created

Outputs:
    howMany  : 4
    nodeNames: [
        [0]: "informed-crawdad"
        [1]: "sacred-ram"
        [2]: "quality-marmot"
        [3]: "star-moth"
    ]

Resources:
    + 5 created

名前は毎回違います。 4つ出ていれば成功です。

もう一度打ってください。

bash
$ pulumi up --yes
Resources:
    5 unchanged

unchanged。名前は変わりません。 べき等です。

ここが random を選んだ理由です。 「ランダムなのに、2回目は変わらない」 — これが state を持つということです。 1回目で決めた値を台帳に書いたので、2回目は台帳を見て「もう決まっている」と判断しています。

[スクリーンショット: 02_pulumi_up_unchanged.png] 2回目の pulumi up --yes で unchanged と出ている画面を撮ってください。

4-10. 減らすと、消える

bash
$ pulumi config set nodeCount 2
$ pulumi preview
     Type                      Name    Plan
 -   ├─ random:index:RandomPet node-3  delete
 -   └─ random:index:RandomPet node-4  delete

Resources:
    - 2 to delete
    3 unchanged

for ループの回数を減らしただけで、「消す」と言っています。

これが宣言的ということです。 私は「2個作れ」とは書いていません。「2個ある状態」と書いただけです。 4個あったので、Pulumi が「2個減らす」と判断しました。 Ansible には無かった動きです。Ansible は要らなくなったものを自分で消しません。

この差が、⑦の state の話の核心です。

preview だけ見て、まだ実行しないでおきます。 戻します。

bash
$ pulumi config set nodeCount 4

⑤ 「設定ファイルではなくプログラム」だと何が変わるか

4-6 で書いたのは、ただの TypeScript でした。 そこから何が手に入ったのかを、はっきりさせます。

手に入るもの1 — ループと条件が、言語の機能として書ける

Terraform にも count と for_each と dynamic ブロックと三項演算子があります。 できないわけではありません。

違うのは、書き方が「言語」か「設定ファイルの拡張」かです。

# Terraform: 条件は三項演算子で書く
instance_type = var.is_production ? "t3.large" : "t3.micro"

# 繰り返しの中で、さらに繰り返したくなると dynamic ブロックになる
dynamic "ingress" {
  for_each = var.allowed_ports
  content {
    from_port = ingress.value
    to_port   = ingress.value
    protocol  = "tcp"
  }
}
// Pulumi: ただの if と for
const instanceType = isProduction ? "t3.large" : "t3.micro";

const ingress = allowedPorts.map(p => ({
  fromPort: p,
  toPort: p,
  protocol: "tcp",
}));

単純な条件なら、どちらでも大差ありません。

差が出るのは、条件が入れ子になったときです。 HCL は入れ子の繰り返しが読みにくくなります。 dynamic ブロックが3階層になった HCL を読んだことがあれば分かります。

手に入るもの2 — エディタが補完する

これは実際にやると一番効きます。

打つ場所: Windows の VS Code(VS Code Remote SSH の回の接続で、VM の ~/pulumi-study を開く)

index.ts で new random. まで打つと、候補が出ます。 RandomPet、RandomPassword、RandomInteger。

{ を打つと、そのリソースに渡せる項目が出ます。 length、prefix、separator。

綴りを間違えると、実行する前に赤い波線が出ます。

TypeScript の回でやった「型は実行時には消える」が、そのまま効いています。 消えるのは実行時であって、書いている間はずっと効いています。 HCL でプロパティ名を間違えると、terraform plan を打つまで気づきません。

手に入るもの3 — テストが書ける

IaC のコードをテストする、という発想自体が新しいかもしれません。

Pulumi のプログラムは普通の TypeScript なので、Vitest の回で使ったテストの道具がそのまま使えます。

たとえば「本番環境では必ずインスタンスタイプが t3.micro でないこと」を、実行せずに確かめられます。

この記事ではテストは書きません。 「書ける」という事実だけ持って帰ってください。 設定ファイルではできないことです。

手に入るもの4(そして最大の罠) — 何でも書けてしまう

ここが、この節で一番言いたいことです。

Pulumi のプログラムは、普通のプログラムです。だから、こういうものが全部書けます。

// ⚠️ 全部「書けてしまう」もの
const res = await fetch("https://example.com/config.json");   // 外部APIを叩く
const data = JSON.parse(fs.readFileSync("secrets.json", "utf8")); // ファイルを読む
if (new Date().getHours() < 12) { /* 午前だけ違う構成 */ }      // 時刻で分岐
const size = Math.random() > 0.5 ? "large" : "small";           // 乱数で決める

Terraform の .tf ファイルで、これらは書けません。書けないから、読む側は安心して読めます。

設定ファイルの「書けることが少ない」は、欠点ではなく機能です。 .tf を読むとき、私は「ここに書いてあることが全部だ」と信じられます。 index.ts を読むとき、それは信じられません。 上の4行のどれかが混ざっているかもしれないからです。

具体的に何が起きるか。

起きることなぜ困るか
同じコードを2回実行して、違う結果になるべき等が壊れる。 IaC の土台が消える
preview の結果が、実行する時刻や環境で変わる予告が予告にならない
抽象化が進んで、誰も読めない社内フレームワークになる実際によくある。 「うちのIaCは魔法」状態
依存パッケージが増えるnpm audit の対象がインフラのコードにも来る

私の結論です。

Pulumi を使うなら、「Terraform で書けることしか書かない」を自分に課すのが安全です。 手に入れた自由のうち、使っていいのは「ループ・条件・型・テスト」までです。 外部APIも、乱数も、時刻分岐も、使わないほうがいい。 使えるからといって、使う理由にはなりません。

これは「Pulumi が悪い」ではありません。 強い道具は、線を自分で引く必要がある、というだけです。


⑥ CloudFormation と AWS CDK — そのクラウド専用

手は動かしません。読むだけです。

CloudFormation は AWS 純正の Terraform

Terraform で書いたセキュリティグループを、CloudFormation で書くとこうなります。

Resources:
  WebSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: web
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 203.0.113.10/32

やっていることは同じです。 状態を宣言していて、AWS が現状と比べて差分を埋めます。

「変更セット(change set)」が terraform plan にあたります。 予告を出してから実行する、という型も同じです。

TerraformCloudFormation
相手AWS、Google Cloud、Azure、その他多数AWS だけ
書き方HCLYAML / JSON
予告terraform plan変更セット
state を誰が持つか自分(tfstate を自分で守る)AWS が持つ(スタックとして)
新機能への追従プロバイダの更新待ち純正なので早いことが多い
料金無料(道具として)無料(作ったリソースには課金)

state を AWS が持ってくれる、というのは実は大きな利点です。 tfstate を消して詰む事故が起きません。 ⑦でもう一度触れます。

AWS CDK は「CloudFormation を書くプログラム」

CDK は Pulumi とよく似ています。 TypeScript や Python でインフラを書きます。

違いは出口です。

Pulumi   : TypeScript → Pulumi が直接クラウドのAPIを叩く
AWS CDK  : TypeScript → CloudFormation のYAMLを生成 → AWS がそれを実行

CDK が生成した YAML は、cdk synth で見られます。 中間物が見えるのは、CDK の分かりやすいところです。

そして、CDK の state は CloudFormation のスタックです。 自分では持ちません。

ロックインの話

「CloudFormation や CDK は AWS 専用だから避けるべき」と言われることがあります。私はそこまで単純ではないと思っています。

取引として見ます。

差し出すもの受け取るもの
他のクラウドへ移せなくなるAWS の新機能が最初に使える
知識が AWS 固有になるstate を自分で守らなくていい
道具の選択肢が減るAWS のサポートに聞ける

そして、正直に書いておくべきことがあります。

Terraform を使っていても、クラウドは簡単には移せません。 書いてあるのは aws_instance であって、汎用の「サーバー」ではないからです。 AWS から Google Cloud へ移すときは、ほぼ全部書き直しです。 「Terraform だからマルチクラウド」は、思っているほど成立しません。

Terraform の本当の利点は「移せること」ではなく、「AWSもGCPも同じ書き方・同じ手順で扱えること」です。 道具を1つ覚えれば済む、という話です。

個人が1つのクラウドしか使わないなら、CloudFormation でも困りません。 このサイトが Terraform を選んだのは、他のクラウドや、クラウドですらないもの(後述)も同じ書き方で扱えるからです。


⑦ Chef / Puppet / Salt — Ansible の前の世代

これも読むだけです。入れません。

構成管理の道具は Ansible が最初ではありません。 むしろ後発です。

道具出た時期書き方エージェント
Puppet2005年ごろ独自の宣言的な言語要る
Chef2009年ごろRuby(手続き的に書ける)要る
Salt2011年ごろYAML + Python基本は要る(無しの方式もある)
Ansible2012年ごろYAML要らない(SSHだけ)

エージェントが要る、とはどういうことか

Ansible の回で、エージェントレスの図を描きました。

Ansible(エージェントレス)

  制御ノード ──SSHで入る──> 対象ノード
                             常駐するものは何も残らない

Chef や Puppet はこうです。

Chef / Puppet(エージェント方式)

  ① 対象ノードに、エージェントを入れる(常駐)
  ② サーバー(Chef Server / Puppet Server)を1台立てる
  ③ エージェントが定期的にサーバーへ「私はどうあるべきですか」と取りに行く
  ④ 受け取った内容に自分を合わせる

  対象ノード ──30分ごとに取りに行く──> Chef Server

これは GitOps(ArgoCD)の回で見た「pull型」とまったく同じ形です。

エージェント方式の、本当の利点

エージェントレスのほうが常に優れている、ということではありません。

エージェント方式が勝つところ中身
手で変えても勝手に戻る30分ごとに自分で合わせに行くので、ドリフトが自動で直る。 Ansible は打った人しか気づかない
台数が非常に多いときに速い各ノードが自分で処理する。制御ノード1台から数千台へSSHする必要がない
中央で全台の状態が見えるサーバーに報告が集まる

ArgoCD が self-heal で勝手に戻したのと、同じ性質です。 Ansible にはこれがありません。

では、なぜ Ansible が広まったのか

理由ははっきりしています。

始めるコストが、桁違いに低かったからです。

Chef や Puppet を始めるには、こうなります。

  1. サーバーを1台立てる(Chef Server / Puppet Server)
  2. 対象の全台にエージェントを入れる
  3. 証明書を配って、サーバーと信頼関係を作る
  4. 独自の言語(Puppet)か Ruby(Chef)を覚える
  5. やっと1台目の設定ができる

Ansible はこうでした。

  1. 手元に apt install ansible
  2. SSHで入れることを確認
  3. YAMLを1枚書く
  4. 終わり

「SSHで入れるなら、もう使える」 — これが決定打でした。 Ansible の回で、私は準備に何分かかったでしょうか。鍵を配って、apt install して、それだけです。 サーバーは立てていません。エージェントも入れていません。

そして、Chef の書き方は Ruby でした。 プログラムで書けるということは、⑤で見たとおり「何でも書けてしまう」ということでもあります。

Chef で起きたこと(何でも書けて読めなくなる)は、Pulumi で起きうることと同じです。 歴史は繰り返します。だから⑤で線を引きました。

いま学ぶべきか

正直に書きます。

  • 新しく始めるなら、Chef / Puppet / Salt を選ぶ理由はほとんどありません
  • ただし、既にそれで動いている現場は今もたくさんあります。 転職して「うちは Puppet です」と言われる可能性は普通にあります
  • その場合も、考え方は同じです。 「あるべき状態を書く」「べき等」「ドリフト」— 全部この記事とAnsibleの回でやったことです

そして、既に動いている構成管理を、勝手に別の道具へ置き換えないでください。 道具を移すのは、機能を1つも増やさない作業です。


⑧ 一番大きな違いは state を持つかどうか

この記事で一番大事な節です。

道具の名前を10個覚えるより、この1つの軸を持っているほうが役に立ちます。

道具をまたいで並べる

道具state を持つか誰が持っているかdestroy にあたる操作
Terraform持つ自分(terraform.tfstate)ある(terraform destroy)
Pulumi持つ自分(--local)か Pulumi Cloudある(pulumi destroy)
CloudFormation持つAWS(スタック)ある(スタックの削除)
AWS CDK持つAWS(CloudFormation 経由)ある(cdk destroy)
Ansible持たない—無い
Chef / Puppet / Salt持たない—無い
Kubernetes / ArgoCD持つ(別の形)クラスタ(etcd)ある(マニフェストを消す)

この1本の線で、性格が全部決まります。

state を持つ道具の性格

できること。

  • 消せます。 「自分が作ったもの」を知っているからです。terraform destroy の破壊力は、台帳があるから成立しています
  • 「作った覚えのないもの」を無視できます。 台帳に無いものは自分の管轄外だと判断できます
  • 差分が正確です。 前回の値を知っているので、「何が変わるか」を出せます

代償。

  • state を失うと詰みます。 Terraform の回で、tfstate を消して実物だけが残った話を書きました。Pulumi も同じです
  • state に秘密が入ります。 だから Git に入れてはいけません。SOPS の回の話と直結します
  • 複数人で同時に触ると壊れます。 だから「state をどこに置くか」が必ず問題になります

state を持たない道具の性格

できること。

  • 台帳を失う事故が起きません。 そもそも無いからです
  • 毎回、相手を見に行って判断します。 人が手で変えても、次の実行で正しく直ります
  • 既にあるサーバーに、いきなり使えます。 「このサーバーは自分が作ったものではない」が問題になりません

代償。

  • 要らなくなったものを、自分で消せません。 Ansible の回で書いたとおり、消すなら「消す」と書きます
  • 「いま何を管理しているか」の一覧がありません
  • 毎回、全部を確認しに行くので遅くなります

なぜ Terraform は state が要って、Ansible は要らないのか

私はここが長い間分かりませんでした。答えは「相手が違うから」でした。

Ansible が知りたいこと
  「このサーバーに nginx は入っているか?」
   → SSHで入って dpkg に聞けば、その場で分かる
   → ⚠️ 台帳は要らない

Terraform が知りたいこと
  「私が作った EC2 は、AWS 上のどのインスタンスか?」
   → AWS には EC2 が50台あるかもしれない
   → ⚠️ そのうちどれが「私のもの」かは、AWS に聞いても分からない
   → だから、自分で控えておくしかない = 台帳

state は、「現状を知るため」ではなく「自分が作ったものを見分けるため」に要ります。 現状はクラウドに聞けば分かります。分からないのは「どれが自分のか」です。

そして CloudFormation は、そこを AWS 側が引き受けています。 「このスタックが作ったもの」を AWS が覚えています。 だから利用者は台帳を守らなくていい。代わりに AWS から離れられません。 ⑥で書いた取引は、実はこの話でした。


⑨ 選び方の表

状況から引ける形にしました。

こういう状況ならこの道具理由
クラウドの資源を作る・消すTerraform(または OpenTofu)相手を選ばない。情報が一番多い
AWS しか使わない。新機能をすぐ使いたいCloudFormation / CDK純正。state を AWS が持ってくれる
ループや条件が多く、HCL が読めなくなってきたPulumi言語の機能でそのまま書ける。ただし線を自分で引く
IaC のコードにテストを書きたいPulumi / CDK普通の言語なので、既存のテストの道具が使える
サーバーの中身をそろえたいAnsibleSSHで入れるならもう使える
手で変えたら勝手に戻ってほしいPuppet / Salt / ArgoCDエージェントが定期的に自分で合わせに行く
既に Chef / Puppet が動いている現場それに従う道具の移行は機能を1つも増やさない
Kubernetes の中の話ArgoCD(GitOps)GitOps の回でやったとおり
サーバーが1台しかない。壊れたら作り直せるシェルスクリプト⑩で書きます

このサイトが進める道

方針をはっきりさせておきます。

このサイトは、Terraform(作る)+ Ansible(整える)で進めます。

理由は3つです。

  1. 2つで、作ると整えるの両方が埋まる。 層が違うので競合しない
  2. どちらも特定のクラウドに縛られない。 学んだことが移せる
  3. 情報が一番多い。 詰まったときに答えが見つかる

Pulumi は「読めるようにしておく」までにします。 CloudFormation と CDK は、AWS の現場に入ったときに読めれば十分です。 Chef / Puppet は、出会ったときに調べれば足ります。

道具を増やすのは、いま困っていることを解決するときだけにしてください。 「Pulumi のほうが新しいから」は理由になりません。


⑩ やりすぎない — 1台ならシェルスクリプトで足りる

ここまで9つの節を使って IaC の道具を並べておいて、最後にこれを書きます。

サーバーが1台しかないなら、シェルスクリプトで足ります。

なぜそう言えるのか

Ansible の回で、シェルスクリプトの問題は「べき等でないこと」だと書きました。それは事実です。

でも、べき等が要るのは「同じスクリプトを2回流す」からです。

2回流さない前提なら、べき等は要りません。

  サーバーが壊れた
    → 直すのではなく、まっさらから作り直す
    → スクリプトは常に「1回目」しか流れない
    → ⚠️ べき等でなくても壊れない

これは「使い捨て(immutable)」という考え方で、Docker の回でやったコンテナがまさにこれです。 コンテナに Ansible を流す人はいません。イメージを作り直します。

判断の線

状況十分な道具
VM 1台。壊れたら作り直せる。手順は20行くらいシェルスクリプトで十分
VM 1台だが、壊せない。少しずつ設定を足していくAnsible(べき等が効く)
VM が2台以上で、同じ設定を入れるAnsible
クラウドの資源を作る。作った一覧を持ちたいTerraform
クラウドの資源が3個以下で、二度と触らない画面でクリックでも構わない

私が正直に思っていること

Terraform の回で、EC2 を1台作るのに .tf を2枚書きました。

画面でクリックしたほうが速かったです。 実際そう書きました。

それでも書いた理由は、速さではありませんでした。

「作ったものの一覧が、ファイルとして残る」ことに価値がありました。 消し忘れが怖かったからです。

逆に言えば、消し忘れが怖くない状況では、IaC の価値は小さいです。

  • 自分のVMは、止めても課金されません。 だから Ansible の価値は「べき等」と「台数」に限られます
  • クラウドは止め忘れると課金されます。 だから Terraform の価値が大きい

道具の価値は、状況が決めます。 「IaC は正義」ではありません。


つまずいたところ

pulumi と打っても command not found

入れた直後に一番出るやつです。

入るのは ~/.pulumi/bin で、そこは既定でパスが通っていません。

bash
$ export PATH=$PATH:$HOME/.pulumi/bin

そして、私はこれを打ったターミナルとは別のターミナルで作業を続けて、また command not found を出しました。 export はそのターミナルの中だけです。~/.bashrc に足すまで、開き直すたびに消えます。

pulumi new でブラウザのログインを求められた

4-3 を飛ばしたときに起きます。

Manage your Pulumi stacks by logging in.
Run `pulumi login --help` for alternative login options.
Enter your access token from https://app.pulumi.com/account/tokens

ここでアカウントを作りにいかないでください。 Ctrl+C で抜けて、先に打ちます。

bash
$ pulumi login --local

これは事故ではなく、Pulumi の既定が「state をクラウドに置く」だというだけです。 そして、そこが Terraform との思想の違いです。 Terraform の既定は手元のファイルです。 どちらも「state をどこに置くか」を必ず決めなければいけない、という点は同じです。

パスフレーズを忘れて、消せなくなりかけた

この記事で一番痛かったやつです。

4-4 で決めたパスフレーズを、翌日に忘れました。

bash
$ pulumi destroy
error: constructing secrets manager of type "passphrase": incorrect passphrase

作ったものを消すことすらできません。

思い出せたので助かりましたが、思い出せなかった場合の逃げ道は、~/.pulumi/stacks/ の中のファイルを直接消すことです。

ただしそれは「台帳を捨てる」ことです。 Terraform で tfstate を消したときとまったく同じ状態になります。 今回は random なので実物がクラウドに残りません。だから被害ゼロで済みました。 これが AWS だったら、消せないリソースが残って課金され続けます。

学習用のスタックでこれを経験できたのは、正直よかったです。

pulumi up が「created」と言うのに、AWS に何も無い

当たり前でした。random プロバイダは AWS を触っていません。

でも、最初は本気で「認証情報なしで作れてしまったのか」と焦りました。

random.RandomPet が作っている「リソース」は、手元で生成した文字列を state に記録しただけのものです。 クラウドには何も存在しません。

それでも「作る・変わらない・消す」が全部再現できます。 IaC の性質は、相手がクラウドでなくても成立するということです。

Output<string> を console.log したら警告が出た

console.log(pet.id);
warning: Calling [toString] on an [Output<T>] is not supported.

Output は「まだ値が決まっていない値」です。 リソースを作ってみないと分からないので、その場では読めません。

文字列に混ぜたいときは pulumi.interpolate を使います(4-6 で使ったやつです)。

const label = pulumi.interpolate`${pet.id}-web`;

これは Pulumi 特有の、一番引っかかるところです。 「普通の TypeScript が書ける」と言われて始めると、ここで「普通ではない」に当たります。 ⑤で「プログラムだから自由」と書きましたが、完全に自由なわけでもありません。

リソース名を変えたら、作り直しになった

4-6 の node-${i} を server-${i} に変えて preview を打ったら、こう出ました。

Resources:
    + 4 to create
    - 4 to delete

中身は何も変えていないのに、全部作り直しです。

Pulumi も Terraform も、state 上の「名前」でリソースを見分けています。 名前を変えると、道具から見れば「前のものが消えて、別のものができた」です。 random なら名前が変わるだけですが、これが本番のデータベースだったら消えます。

名前は、後から気軽に変えないでください。

nodeCount を減らしたときに、どれが消えるか読み違えた

4個から2個に減らしたとき、私は「どれが消えるか分からない」と思っていました。

preview を読んだら、node-3 と node-4 でした。

当然でした。 for (let i = 1; i <= 2; i++) なので、残るのは node-1 と node-2 です。

ここで「プログラムだから読める」の利点が出ます。 どのリソースが残るかは、ループの書き方から論理的に決まります。 逆に、ループの条件が複雑になると、ここが読めなくなります。 ⑤で書いた代償が、こういう形で出ます。

npm install が終わらない

VM のメモリが少ないと、pulumi new typescript の npm install で数分止まったように見えます。

別のターミナルで確認します。

bash
$ free -h
$ top

node が動いていれば、待てば終わります。 途中で Ctrl+C すると node_modules が壊れることがあります。 その場合は消してやり直します。

bash
$ cd ~/pulumi-study
$ rm -rf node_modules package-lock.json
$ npm install

後片づけ

この記事で作ったのは、VM の中のファイルだけです。AWS には何もありません。

それでも、pulumi destroy は必ず打ってください。 練習です。

① スタックを消す

打つ場所: VM の中(Ubuntu Server)

bash
$ cd ~/pulumi-study
$ pulumi destroy --yes
     Type                      Name              Status
 -   pulumi:pulumi:Stack       pulumi-study-dev  deleted
 -   ├─ random:index:RandomPet node-1            deleted
 -   ├─ random:index:RandomPet node-2            deleted
 -   ├─ random:index:RandomPet node-3            deleted
 -   └─ random:index:RandomPet node-4            deleted

Resources:
    - 5 deleted

パスフレーズを聞かれたら、4-4 で決めたものを入れます。

② state ファイルを、消す前に1回見る

順番が大事です。スタックを消す前に見ておきたい人は、①より先にここをやってください。

bash
$ ls -1 ~/.pulumi/stacks/pulumi-study/
dev.json
dev.json.bak

これが Pulumi の台帳です。

bash
$ head -c 600 ~/.pulumi/stacks/pulumi-study/dev.json

terraform.tfstate と同じものです。 JSON で、リソースの一覧と、作られた実際の値が入っています。 Git に入れてはいけない理由も、まったく同じです。

③ スタックの登録自体を消す

bash
$ pulumi stack rm dev --yes

これで ~/.pulumi/stacks/pulumi-study/ の中身が消えます。

④ 作業ファイルを消す

bash
$ cd ~
$ rm -rf ~/pulumi-study

rm -rf は確認を出しません。 パスをよく見てから Enter を押してください。

⑤ Pulumi 自体を消したいなら

順番を守ってください。③④を先にやってからです。

bash
$ rm -rf ~/.pulumi

そして ~/.bashrc に足した行を消します。

bash
$ nano ~/.bashrc

末尾の export PATH=$PATH:$HOME/.pulumi/bin の行を消して保存します。

~/.pulumi を先に消すと、pulumi コマンドごと消えるので、destroy も stack rm もできなくなります。 今回は random なので実害はありませんが、AWS を相手にしていたら、消せないリソースが残ります。

⑥ パスフレーズを環境変数で渡した人

そのターミナルを閉じれば消えます。 ただし ~/.bash_history には残ります。

bash
$ history | grep PULUMI_CONFIG_PASSPHRASE

出てきたら、消します。

bash
$ history -d <行番号>
$ history -w

SOPS の回でやった「秘密をどこに置くか」の話が、そのまま効いています。

⑦ AWS の確認は要りません

この記事は AWS に一切触っていません。 請求を見に行く必要はありません。

ただし、Terraform の回の後片づけをまだやっていない人は、そちらを先に済ませてください。


まとめ

  • Terraform と Ansible は競合していない。 作る(プロビジョニング)と整える(構成管理)で層が違う
  • 「Terraform か Ansible か」という問いは成立しない。 両方使う。順番は①作る → ②整える
  • user_data に長いシェルスクリプトを書き始めたら、①の道具で②をやっている合図
  • IaC の道具は「何を管理するか」×「どう書くか」の2軸で並ぶ。 Pulumi は Terraform の隣。Ansible の隣ではない
  • 「宣言的」は「YAMLで書くこと」ではない。 「あるべき状態を書くこと」
  • べき等は魔法ではない。 状態を書かせたから、道具が現状と比べられるようになっただけ
  • Ansible は「宣言的なタスクを、手続き的に並べる道具」。 タスクは上から順に実行される
  • Terraform は書いた順を無視する。 依存関係から順番を自分で決める
  • Pulumi は「設定ファイルではなくプログラム」。 ループ・条件・IDEの補完・テストが手に入る
  • その代償は「何でも書けてしまう」。 外部APIも乱数も時刻分岐も書けてしまい、べき等が壊れる
  • 設定ファイルの「書けることが少ない」は欠点ではなく機能。 読む側が「これで全部だ」と信じられる
  • Pulumi を使うなら「Terraform で書けることしか書かない」を自分に課すのが安全
  • CloudFormation / CDK は AWS 専用。 state を AWS が持ってくれるのが最大の利点
  • ロックインは悪ではなく取引。 そして Terraform でもクラウドは簡単には移せない
  • Terraform の本当の利点は「移せること」ではなく「どのクラウドも同じ手順で扱えること」
  • Chef / Puppet / Salt はエージェントが要る。 サーバーを立て、証明書を配って、やっと1台目
  • エージェント方式の利点は「手で変えても勝手に戻る」。 ArgoCD の self-heal と同じ性質
  • Ansible が広まったのは「SSHで入れるなら、もう使える」から。 始めるコストが桁違いに低かった
  • 一番大きな違いは state(台帳)を持つかどうか。 道具の名前より、この1点で性格が決まる
  • state を持つ道具は「消せる」。 destroy は台帳があるから成立している
  • state を持つ道具は、state を失うと詰む。 そして state には秘密が入る
  • state を持たない道具(Ansible / Chef / Puppet)は詰まないが、要らなくなったものを自分で消せない
  • state は「現状を知るため」ではなく「自分が作ったものを見分けるため」に要る
  • このサイトは Terraform + Ansible で進める。 他は読めれば十分
  • 道具を増やすのは、いま困っていることを解決するときだけ。 「新しいから」は理由にならない
  • 1台しかなく、壊れたら作り直せるなら、シェルスクリプトで足りる。 2回流さないなら、べき等は要らない
  • 道具の価値は状況が決める。 止め忘れが怖くない場所では、IaC の価値は小さい

参考リンク


次に読む

この記事は 【第6段階】インフラとコンテナ の 20 / 25 本目です。

記事
← 前の記事CIはどれも同じ3つ — JenkinsとGitLab CI
→ 次の記事監視は自前かSaaSか — 替えられるのは道具だけ

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

DevOps›Infrastructure as Code
  • Pulumi / CloudFormation / AWS CDK — Terraform 以外の選択肢
  • Chef / Puppet / Salt — Ansible の前の世代

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次