WEBVTT

00:00:00.000 --> 00:00:04.780
今日のトピックはほとんどの人が聞いたことはあるものの実際に説明できる人はごくわずかというものです

00:00:04.780 --> 00:00:05.780
GitOpsです

00:00:05.780 --> 00:00:09.460
求人情報やカンファレンスの講演あるいはAzureのドキュメントなどで目にしたことがあるかもしれません

00:00:09.460 --> 00:00:11.540
しかし正確には一体何なのでしょうか

00:00:11.540 --> 00:00:14.920
単なるDevOpsの流行語なのかそれとも根本的に異なるものなのでしょうか

00:00:14.920 --> 00:00:16.360
簡潔に説明しましょう

00:00:16.360 --> 00:00:19.280
GitOpsとはGitをインフラストラクチャ全体の唯一の信頼源

00:00:19.280 --> 00:00:21.460
シングルソーシューオフトルースとする運用モデルであり

00:00:21.460 --> 00:00:24.240
アプリケーションコードだけでなくそれを実行するすべてを管理します

00:00:24.240 --> 00:00:27.220
このエピソードの終わりにはGitOpsが実際にどのようなものか

00:00:27.220 --> 00:00:29.540
なぜAzure上のKubernetes管理の標準となったのか

00:00:29.540 --> 00:00:32.960
そしてどのようにしてコマンド一つで簡単にロールバックできるのかを理解できるはずです

00:00:32.960 --> 00:00:36.440
従来のやり方手動デプロイそして構成の乖離コンフィギュレーションドリフト

00:00:36.440 --> 00:00:38.680
まずはGitOpsが解決する問題から始めましょう

00:00:38.680 --> 00:00:41.360
Azure上でKubernetesクラスターを管理していると想像してください

00:00:41.360 --> 00:00:44.620
開発者がコードをプッシュしCIパイプラインがコンテナイメージを構築し

00:00:44.620 --> 00:00:47.220
誰かがクベクトラップラインを実行してそれらのイメージをデプロイします

00:00:47.220 --> 00:00:49.260
あなたかもしれないしチームメイトかもしれません

00:00:49.260 --> 00:00:51.200
あるいはAzure DevOpsのボタンを押すかもしれません

00:00:51.200 --> 00:00:52.860
いずれにせよデプロイは実行されます

00:00:52.860 --> 00:00:54.860
それはうまく機能しますが機能しなくなる時がきます

00:00:54.860 --> 00:00:56.440
次に何が起こるか見てみましょう

00:00:56.440 --> 00:00:58.400
チームの誰かがバグを急いで修正する必要があり

00:00:58.400 --> 00:01:00.860
ノードにSSH接続したりAzureポータルを使ったり

00:01:00.860 --> 00:01:03.120
あるいはデプロイに対して直接クベクトルジットを実行したりします

00:01:03.120 --> 00:01:06.800
彼らは設定マップの調整や環境変数の変更といった小さな修正を行いますが

00:01:06.800 --> 00:01:08.180
それは一見無害に見えます

00:01:08.180 --> 00:01:09.980
少なくとも彼らはそう考えます

00:01:09.980 --> 00:01:12.740
問題はその変更がGitに反映されないことであり

00:01:12.740 --> 00:01:15.800
クラスターの設定がリポジトリの内容と一致しなくなってしまうことです

00:01:15.800 --> 00:01:18.140
これが構成の乖離と呼ばれるものです

00:01:18.140 --> 00:01:19.920
この乖離は静かなる破壊者です

00:01:19.920 --> 00:01:22.500
次のデプロイで誰かが元のマニフェストでクベクトラップライを実行し

00:01:22.500 --> 00:01:25.540
その場しのぎの修正を上書きするまでは何事もなく動いてしまうからです

00:01:25.540 --> 00:01:29.220
さらに悪いことにこの乖離が誰にも説明できない予期せぬ動作を引き起こすこともあります

00:01:29.220 --> 00:01:33.120
デバッグを始めログを確認しGit内のYAMLを見ても何も問題ないように見えますが

00:01:33.120 --> 00:01:34.460
クラスターは異なる挙動をしています

00:01:34.460 --> 00:01:37.360
何がいつ誰によって変更されたのか全く分かりません

00:01:37.360 --> 00:01:39.320
私は実際にこれを目にしたことがあります

00:01:39.320 --> 00:01:42.740
チームメイトがノードにSSHで入りテストのために設定をいじったものの

00:01:42.740 --> 00:01:44.620
元に戻すのを忘れて帰宅してしまったのです

00:01:44.620 --> 00:01:48.040
翌日デプロイが失敗し誰もその理由を説明できません

00:01:48.040 --> 00:01:50.700
Gitリポジトリは正常に見えるのにクラスターはめちゃくちゃで

00:01:50.700 --> 00:01:53.280
何が起きたのかを突き止めるために何時間も費やすことになります

00:01:53.280 --> 00:01:54.620
そこで質問です

00:01:54.620 --> 00:01:58.600
クラスターの状態を常にGitの内容と強制的に一致させる方法があったとしたらどうでしょうか

00:01:58.600 --> 00:02:02.300
リポジトリにあるものこそが本番環境で実行されているものだと保証できるとしたら

00:02:02.300 --> 00:02:04.420
それがGitOpsの核となる考え方です

00:02:04.420 --> 00:02:06.240
GitOpsの本質について解説します

00:02:06.240 --> 00:02:08.220
ではGitOpsとは一体何でしょうか

00:02:08.220 --> 00:02:10.280
最もシンプルな定義をご紹介しましょう

00:02:10.280 --> 00:02:13.700
Gitが単なるコードだけでなくインフラの実行に必要な全ての情報の

00:02:13.700 --> 00:02:15.460
唯一の信頼できる情報源となります

00:02:15.460 --> 00:02:20.120
あらゆる構成、デプロイメントマニフェスト、環境変数が全てGitに集約されます

00:02:20.120 --> 00:02:23.000
Gitで定義されていないものはクラスター上では何も実行されません

00:02:23.000 --> 00:02:25.360
GitOpsは購入できるようなツールではありません

00:02:25.360 --> 00:02:28.140
DevOpsやDevSecOpsのような運用モデルです

00:02:28.140 --> 00:02:30.640
インフラ管理を導く一連の原則です

00:02:30.640 --> 00:02:33.340
オープンGitOps標準には4つの核となる原則があり

00:02:33.340 --> 00:02:35.060
それぞれ順を追って説明します

00:02:35.060 --> 00:02:37.480
第一にシステムは宣言的でなければなりません

00:02:37.480 --> 00:02:41.060
つまり到達までの手順ではなく最終的な状態を記述するということです

00:02:41.060 --> 00:02:43.380
デプロイメントを作成しレプリカを5つにスケールし

00:02:43.380 --> 00:02:45.700
8080ポートを公開するといったスクリプトを書く代わりに

00:02:45.700 --> 00:02:48.480
8080ポートで5つのレプリカが欲しいというYAMLファイルを書き

00:02:48.480 --> 00:02:50.200
システムがその手順を自動的に判断します

00:02:50.200 --> 00:02:51.860
これが宣言的であるということです

00:02:51.860 --> 00:02:53.560
第二にバージョン管理されている必要があります

00:02:53.560 --> 00:02:56.480
クラスターの状態に対する全ての変更はGitへのコミットとして記録されます

00:02:56.480 --> 00:02:59.280
そのため誰がいつなぜ変更したかという完全な履歴が残ります

00:02:59.280 --> 00:03:01.400
推測したりログを掘り返したりする必要はありません

00:03:01.400 --> 00:03:03.120
第三に変更は自動的にプルされます

00:03:03.120 --> 00:03:05.620
クラスター側がGitにアクセスし新しい変更を確認しに行きます

00:03:05.620 --> 00:03:07.640
これがいかに重要かについては後ほど説明します

00:03:15.700 --> 00:03:17.880
これが調整ループです

00:03:17.880 --> 00:03:19.340
このように考えてみてください

00:03:19.340 --> 00:03:21.140
Gitは建築家の設計図です

00:03:21.140 --> 00:03:23.540
建物がどうあるべきかを正確に記述しています

00:03:23.540 --> 00:03:25.220
Kubernetesは建設現場です

00:03:25.220 --> 00:03:27.640
そしてGitOpsオペレーターは現場監督です

00:03:27.640 --> 00:03:31.020
彼は設計図を手に歩き回り壁、量、窓の一つ一つを確認します

00:03:31.020 --> 00:03:33.100
不一致があれば彼はそれを修正します

00:03:33.100 --> 00:03:36.680
もし誰かが許可なく変更を加えても彼がそれを見つけて元に戻します

00:03:36.680 --> 00:03:39.360
設計図こそが常に唯一の信頼できる情報源なのです

00:03:39.360 --> 00:03:41.200
しかし真の変化はここから起こります

00:03:41.200 --> 00:03:42.920
デプロイがどのように行われるかです

00:03:42.920 --> 00:03:45.540
従来のCI、CDではクラスターに変更をプッシュします

00:03:45.540 --> 00:03:47.580
GitOpsではクラスター側がプルします

00:03:47.580 --> 00:03:50.060
この違いは言葉の響き以上に重要です

00:03:50.060 --> 00:03:52.120
プル型デプロイとプッシュ型の違いです

00:03:52.120 --> 00:03:54.360
デプロイが実際どのように機能するか話しましょう

00:03:54.360 --> 00:03:56.740
ここがGitOpsの最大の革新ポイントだからです

00:03:56.740 --> 00:03:59.880
従来のプッシュ型モデルではCIパイプラインが全てを行います

00:03:59.880 --> 00:04:03.100
Azureパイプライン、Jenkins、GitHub Actionsなどです

00:04:03.100 --> 00:04:08.060
コンテナをビルドし、テストを実行し、そのイメージを直接Kubernetesクラスターにプッシュします

00:04:08.060 --> 00:04:11.680
パイプラインはクラスターAPIに直接アクセスするための認証情報を保持しています

00:04:11.680 --> 00:04:13.880
それは、これが新しいデプロイです、と言います

00:04:13.880 --> 00:04:15.380
今すぐ適用して、と

00:04:15.380 --> 00:04:18.000
これでも機能しますが、セキュリティ上の問題が生じます

00:04:18.000 --> 00:04:21.740
重要なのは、もしパイプラインが侵害され、誰かが悪意のあるステップを注入したり

00:04:21.740 --> 00:04:24.100
トークンが漏洩したり、依存関係が乗っ取られたりした場合

00:04:24.100 --> 00:04:26.960
そのパイプラインは本番環境のクラスターに直接繋がっているということです

00:04:26.960 --> 00:04:30.520
それはデプロイを破壊し、名前空間を削除し、構成を変更することができます

00:04:30.520 --> 00:04:33.220
すべては、本来の作業のために与えられた権限で行われるのです

00:04:33.220 --> 00:04:34.960
では、GitOpsモデルを見てみましょう

00:04:34.960 --> 00:04:36.340
流れの始まりは同じです

00:04:36.340 --> 00:04:39.260
CIがコンテナをビルドし、Azureコンテナレジストリのようなレジストリにプッシュします

00:04:39.260 --> 00:04:40.800
CIの役割はそこまでです

00:04:40.800 --> 00:04:42.220
クラスターには一切触れません

00:04:42.220 --> 00:04:45.540
その代わりに、CIはGitリポジトリの新しいイメージタグを更新します

00:04:45.540 --> 00:04:49.700
YAMLファイル内の一行、つまりイメージバージョンを変更し、その変更をコミットします

00:04:49.700 --> 00:04:50.540
これだけです

00:04:50.540 --> 00:04:52.280
直接のクラスターアクセスはありません

00:04:52.280 --> 00:04:55.340
次に、クラスター内で実行されているGitOpsオペレーターがその変更を検知します

00:04:55.340 --> 00:04:57.760
最新の状態をGitからプルし、それを適用します

00:04:57.760 --> 00:05:00.340
クラスターがGitにアクセスするのであって、その逆ではありません

00:05:00.340 --> 00:05:01.820
これがプルベースのモデルです

00:05:01.820 --> 00:05:04.600
クラスターは、そのAPIを外部システムに対して決して公開しません

00:05:04.600 --> 00:05:06.020
Gitからプルするだけです

00:05:06.020 --> 00:05:09.640
誰かがCIパイプラインを侵害しても、せいぜいリポジトリ内のマニフェストを変更することしかできません

00:05:09.640 --> 00:05:11.460
クラスターに直接触れることはできないのです

00:05:11.460 --> 00:05:13.600
何を守るか、いつ適用するかはオペレーターが判断します

00:05:13.600 --> 00:05:14.840
他にもメリットがあります

00:05:14.840 --> 00:05:16.660
ビルドとデプロイを分離できることです

00:05:16.660 --> 00:05:19.260
CIはビルド、テスト、スキャンといった得意なことに専念します

00:05:19.260 --> 00:05:21.160
デプロイはGitOpsオペレーターが担当します

00:05:21.160 --> 00:05:23.000
それぞれのシステムが一つの仕事に集中します

00:05:23.000 --> 00:05:25.300
ビルドが失敗しても、クラスターには何も変更が加えられません

00:05:25.300 --> 00:05:28.000
デプロイが失敗した場合、オペレーターが再施行するか、通知を送ります

00:05:28.000 --> 00:05:29.140
明確な分離です

00:05:29.140 --> 00:05:31.680
つまり、パイプラインがクラスターに変更をプッシュするのではなく

00:05:31.680 --> 00:05:33.980
クラスターがGitから望ましい状態をプルするのです

00:05:33.980 --> 00:05:39.640
この単純な逆転が、インフラをより安全で監査しやすくし、誤った破壊を防ぎます

00:05:39.640 --> 00:05:41.260
調整ループ

00:05:41.260 --> 00:05:44.300
では、オペレーターはどうやって更新のタイミングを知るのでしょうか?

00:05:44.440 --> 00:05:45.900
通知を待つわけではありません

00:05:45.900 --> 00:05:52.120
継続的なループを実行し、Gitを監視し、クラスターと比較し、必要に応じて変更を適用し、それを永遠に繰り返します

00:05:52.120 --> 00:05:53.920
これは調整ループと呼ばれます

00:05:53.920 --> 00:05:57.560
設定に応じて、数秒または数分ごとに常に実行されます

00:05:57.560 --> 00:05:59.500
オペレーターは監視を決して止めません

00:05:59.500 --> 00:06:01.580
家のサーモスタットを想像してみてください

00:06:01.580 --> 00:06:04.280
希望する温度、例えば21度に設定します

00:06:04.280 --> 00:06:06.820
サーモスタットは常に実際の室温をチェックします

00:06:06.820 --> 00:06:09.220
21度を下回れば、暖房が入ります

00:06:09.220 --> 00:06:10.960
上回れば、暖房が切れます

00:06:10.960 --> 00:06:12.980
設定に合わせて調整し続けるのです

00:06:12.980 --> 00:06:14.980
GitOpsオペレーターも同じように動作します

00:06:14.980 --> 00:06:17.840
Gitが目的の状態を保持し、クラスターが実際の状態を保持します

00:06:17.840 --> 00:06:20.480
オペレーターはそれらを継続的に比較し、調整を行います

00:06:20.480 --> 00:06:23.540
では、誰かがクラスター内のデプロイメントを手動で編集するとどうなるでしょうか?

00:06:23.660 --> 00:06:26.460
例えば、クベクトルジットを実行してレプリカ数を変更したとします

00:06:26.460 --> 00:06:29.280
オペレーターは次の調整サイクルでその際を検出します

00:06:29.280 --> 00:06:32.500
クラスターは現在3つのレプリカを持っていますが、Gitは5つであるべきだとしています

00:06:32.500 --> 00:06:35.900
そこでオペレーターはGitで定義された状態を適用し、クラスターはレプリカ数5に戻ります

00:06:35.900 --> 00:06:37.620
許可されていない変更は消去されます

00:06:37.620 --> 00:06:39.580
Gitに変更をプッシュした場合はどうなるでしょうか?

00:06:39.680 --> 00:06:40.700
プロセスは同じです

00:06:40.700 --> 00:06:43.060
オペレーターが際を検出し、それを適用します

00:06:43.060 --> 00:06:47.320
開発者が画像バージョンをV1、2からV1、3に更新するPRをマージします

00:06:47.320 --> 00:06:51.740
オペレーターが新しいマニフェストを確認し、新しいイメージをプルして新しいPodを起動します

00:06:51.740 --> 00:06:54.460
数秒以内にクラスターは再びGitと一致します

00:06:54.460 --> 00:06:56.160
ここで重要な区別があります

00:06:56.160 --> 00:06:58.540
Podがクラッシュしてもオペレーターは感知しません

00:06:58.540 --> 00:07:01.540
それはKubernetesの仕事であり、レプリカセットコントローラーが処理します

00:07:01.540 --> 00:07:04.180
GitOpsオペレーターは構成のみに関心を持ちます

00:07:04.180 --> 00:07:11.700
デプロイメントマニフェストでレプリカ数5、イメージV1、3と指定されており、クラスターでV1、3を実行するレプリカが5つあれば、オペレーターは問題なしと判断します

00:07:11.700 --> 00:07:14.020
特定のPodが再起動したかどうかは気にしません

00:07:14.020 --> 00:07:16.060
それは通常のKubernetesの動作だからです

00:07:16.060 --> 00:07:21.240
しかし、誰かがGitのマニフェストを変更したり、直接クラスターを変更して際、ドリフトが生じたりした場合はオペレーターが対処します

00:07:21.240 --> 00:07:23.380
それこそがGitOpsの自己修復の正体です

00:07:23.380 --> 00:07:27.480
単に変更をデプロイするだけでなく、定義された状態からインフラストラクチャが乖離することを能動的に防ぎます

00:07:27.480 --> 00:07:30.380
そのため、クラスター内で動作するGitOpsオペレーターが必要になるのです

00:07:30.380 --> 00:07:32.720
そこで登場するのがArgoCDとFluxです

00:07:32.720 --> 00:07:34.440
ArgoCDとFluxの比較

00:07:34.440 --> 00:07:39.320
GitOpsオペレーターが必要な場合、主に2つの選択肢がありますが、どちらも非常に優れています

00:07:39.320 --> 00:07:46.220
ArgoCDとFluxはどちらもCNCFの卒業プロジェクトであり、安定性、コミュニティ、本番環境への対応において最高水準の基準を満たしています

00:07:46.220 --> 00:07:49.280
しかし、両者は同じ仕事に対して異なるアプローチを取っています

00:07:49.280 --> 00:07:52.860
ArgoCDは元々Intuitによって構築され、WebUIが付属しています

00:07:52.860 --> 00:07:59.500
ArgoCDをインストールすると、すべてのアプリケーション、その同期ステータス、健全性、デプロイ履歴を確認できるダッシュボードが手に入ります

00:07:59.500 --> 00:08:04.680
クリック操作でGitとクラスター間の差分を確認したり、手動で処理をトリガーしたり、変更を承認したりできます

00:08:04.680 --> 00:08:08.540
これは、視覚的なダッシュボードと手動の制御ポイントを求めるチーム向けに設計されています

00:08:08.540 --> 00:08:11.500
FluxはWebworksから生まれたもので、よりモジュール化されています

00:08:11.500 --> 00:08:13.120
デフォルトではUIはありません

00:08:13.120 --> 00:08:16.860
コマンドラインから操作を行い、すべてをKubernetesのカスタムリソースとして定義します

00:08:16.860 --> 00:08:20.260
このリポジトリを監視せよという指示を出すGitリポジトリオブジェクトを作成するのです

00:08:20.260 --> 00:08:23.120
そして、このパスを適用せよと指示するカスタマイズオブジェクトです

00:08:23.120 --> 00:08:25.640
Fluxがそれを検知し、調整、リコンサイルを行います

00:08:25.640 --> 00:08:29.140
ダッシュボードがないため、必然的にGitネイティブなワークフローを採用することになります

00:08:29.140 --> 00:08:31.520
さて、ここからがAzureユーザーにとって重要な点です

00:08:31.520 --> 00:08:34.560
FluxはAzure Kubernetesサービスにおける標準のGitOpsオプションです

00:08:34.560 --> 00:08:37.620
マイクロソフトはFlux V2を軸にネイティブ統合を構築しました

00:08:37.620 --> 00:08:42.080
AzureポータルからAxクラスターでGitOpsを有効にすると、内部的にはFluxが動いています

00:08:42.080 --> 00:08:44.920
Azure Arcもマルチクラスター管理にFluxを使用しています

00:08:44.920 --> 00:08:47.880
そのため、AzureエンジニアにとってFluxは自然な出発点となります

00:08:47.880 --> 00:08:50.160
しかし、Argo CDには独自の強みがあります

00:08:50.160 --> 00:08:54.700
複数のクラスターを一元管理するプラットフォームエンジニアリングのシナリオでは、こちらの方が人気です

00:08:54.700 --> 00:08:58.260
UIがあるため、コマンドラインに慣れていないチームでも扱いやすくなっています

00:08:58.260 --> 00:09:03.960
また、Argoロールアウツと密接に連携し、カナリアデプロイやブルー、グリーンデプロイといった段階的なデリバリーが可能です

00:09:03.960 --> 00:09:09.560
アーキテクチャ上の主な違いは、Argo CDが独自のAPIサーバーを持つ独立したアプリケーションとして動作する点です

00:09:09.560 --> 00:09:14.020
FluxはKubernetesコントローラーの集合体として動作し、クラスターにより深く組み込まれています

00:09:14.020 --> 00:09:20.060
FluxはKubernetesのコントロールプレーンの一部のように感じられますが、Argo CDはその上に乗る別のプラットフォームのように感じられます

00:09:20.060 --> 00:09:23.980
FluxはKubernetesネイティブなテンプレートツールであるカスタマイズにも大きく依存しています

00:09:23.980 --> 00:09:27.440
Argo CDはカスタマイズ、Helm、あるいは単純なYAMLを使用できます

00:09:27.440 --> 00:09:31.740
どちらもHelmをサポートしていますが、FluxにはHelmリリースをネイティブに処理する専用のHelmコントローラーがあります

00:09:31.740 --> 00:09:33.500
どちらを選んでも間違いではありません

00:09:33.500 --> 00:09:35.300
どちらのツールも同じ目的を果たします

00:09:35.300 --> 00:09:38.500
しかし、Azureエンジニアにとっては、Fluxが最も手軽な選択肢です

00:09:38.500 --> 00:09:43.720
Azureポータルから数クリックでFluxによるGitOpsを有効にし、Gitリポジトリを指定するだけで同期が始まります

00:09:43.720 --> 00:09:46.900
追加のインストールや、管理すべき個別のサーバーは不要です

00:09:46.900 --> 00:09:50.500
Azure、AX、AzureArc、そしてAzureDevOpsでのGitOpsです

00:09:50.500 --> 00:09:53.380
では、実際にAzureと連携させるとどうなるのでしょうか

00:09:53.380 --> 00:09:55.000
まずはAXから見ていきましょう

00:09:55.000 --> 00:09:59.040
Azure Kubernetesサービスには、Flux V2を使用したGitOpsが組み込まれています

00:09:59.040 --> 00:10:04.800
AzureポータルでクラスターのGitOpsセクションを開き、Gitリポジトリを指定して構成するだけです

00:10:04.800 --> 00:10:07.640
Azure LuposでもGitHubでも、どこでも構いません

00:10:07.640 --> 00:10:12.380
Fluxが監視を開始し、そのリポジトリに配置したマニフェストが自動的にクラスターへ適用されます

00:10:12.380 --> 00:10:14.480
しかし、AXはほんの一部に過ぎません

00:10:14.480 --> 00:10:19.860
AzureArcを使えば、Azure外のクラスター、オンプレミス、他のクラウド、あるいはエッジ環境にもGitOpsを拡張できます

00:10:19.860 --> 00:10:23.280
それらをAzureArcに接続すれば、同じGitOps構成で全てを管理できます

00:10:23.280 --> 00:10:26.260
一つのリポジトリで多数のクラスターを管理し、どこでも一貫した状態を保てます

00:10:26.260 --> 00:10:27.500
それがArcの役割です

00:10:27.500 --> 00:10:29.100
次にパイプラインについてお話ししましょう

00:10:29.100 --> 00:10:31.140
Azure DevOpsはこのモデルと自然に統合されます

00:10:31.140 --> 00:10:33.000
一般的なパターンは次の通りです

00:10:33.000 --> 00:10:37.420
ソースコードはAzure LuposまたはGitHubに保存し、CIはAzureパイプラインが処理します

00:10:37.420 --> 00:10:43.260
コンテナイメージのビルド、テストの実行、脆弱性スキャンを行い、Azureコンテナレジストリにプッシュします

00:10:43.260 --> 00:10:46.600
次にパイプラインがGitOpsリポジトリ内のマニフェストを更新します

00:10:46.600 --> 00:10:50.120
イメージタグをV1、2からV1、3に変更し、コミットしてプッシュします

00:10:50.120 --> 00:10:50.940
これだけです

00:10:50.940 --> 00:10:53.200
パイプラインがクラスターに直接触れることはありません

00:10:53.200 --> 00:10:59.200
アクス内で実行されるフラックスがGitの変更を検出し、新しいマニフェストを取得して更新されたイメージタグを認識し、デプロイを適用します

00:10:59.200 --> 00:11:01.880
新しいポッドが起動し、クラスターの状態が調整されます

00:11:01.880 --> 00:11:05.380
必要に応じて、Azureパイプラインの代わりにGitHub Actionsを使うこともできます

00:11:05.380 --> 00:11:06.680
パターンは同じです

00:11:06.680 --> 00:11:11.040
CIがビルドとマニフェストの更新を担い、GitOpsオペレーターがデプロイを担います

00:11:11.040 --> 00:11:13.500
ツールは重要ではなく、モデルが重要なのです

00:11:13.500 --> 00:11:15.160
ここで重要な詳細があります

00:11:15.160 --> 00:11:19.640
APIキー、接続文字列、証明書など、シークレットをGitに直接保存してはいけません

00:11:19.640 --> 00:11:22.760
プライベートリポジトリであっても、Gitにシークレットを置くのはリスクです

00:11:22.760 --> 00:11:26.120
代わりに、Azureキーファウルトや外部シークレットオペレーターを使用してください

00:11:26.120 --> 00:11:31.320
マニフェストはシークレットを名前で参照し、オペレーターがデプロイ時にファウルトから実際の値を取得します

00:11:31.320 --> 00:11:33.860
さらに、ポリシーを適用することも可能です

00:11:33.860 --> 00:11:40.080
ゲートキーパーと連携したAzureポリシーで、特権コンテナの禁止や承認済みレジストリの使用といったルールを強制できます

00:11:40.080 --> 00:11:45.420
ポリシーに違反するマニフェストがデプロイされようとすると、ゲートキーパーがクラスターに到達する前にブロックします

00:11:45.420 --> 00:11:47.820
ここで得られる真のメリットは、スケールです

00:11:47.820 --> 00:11:51.240
50個のアクスクラスターがあっても、個別に管理する必要はありません

00:11:51.240 --> 00:11:56.680
単一のGitリポジトリで目的の状態を定義すれば、すべてのクラスターがその状態に自動調整されます

00:11:56.680 --> 00:12:00.400
新しいクラスターを追加してリポジトリを指定するだけで、自動的に構成されます

00:12:00.400 --> 00:12:03.000
すべてのクラスターで構成を更新する必要がありますか?

00:12:03.160 --> 00:12:06.080
Git内のファイルを一つ変更すれば、あとはオペレーターが処理します

00:12:06.080 --> 00:12:08.380
これがAzureにおけるGitOpsの約束です

00:12:08.380 --> 00:12:11.700
真実はただ一つ、クラスターは多数、構成のドリフトもありません

00:12:11.700 --> 00:12:13.160
主なメリットについてです

00:12:13.160 --> 00:12:16.700
理論上は良さそうに聞こえますが、チームにとって実際に何を意味するのでしょうか?

00:12:16.800 --> 00:12:18.720
みんなが注目する点から始めましょう

00:12:18.720 --> 00:12:20.760
ロールバックが非常に簡単になります

00:12:20.760 --> 00:12:25.080
誤ったデプロイが行われ、アプリがエラーを吐き出し、ユーザーから苦情が来ているとします

00:12:25.080 --> 00:12:30.920
従来の方法なら、最後に正常だった構成を探して慌てて手動コマンドを実行し、ミスがないことを祈るしかありませんでした

00:12:30.920 --> 00:12:33.640
GitOpsなら、Gitのコミットを元に戻すだけです

00:12:33.640 --> 00:12:34.560
それだけです

00:12:34.560 --> 00:12:35.800
コマンドは一つです

00:12:35.800 --> 00:12:40.240
オペレーターが変更を検知し、以前の状態を取得して、クラスターは正常に動作していた状態に戻ります

00:12:40.240 --> 00:12:43.820
SSHによるログインも、キューベクトルも、そしてパニックになる必要も一切ありません

00:12:43.820 --> 00:12:45.880
監査証跡は自動的に組み込まれます

00:12:45.880 --> 00:12:48.300
インフラへのあらゆる変更がコミットとして記録されます

00:12:48.300 --> 00:12:51.240
誰が、いつ、何を変更したのかが完全に把握できます

00:12:51.240 --> 00:12:55.020
誰かが深夜2時にデプロイを編集して報告を忘れたのでは、と推測する必要もありません

00:12:55.020 --> 00:12:57.780
履歴はそこに残り、普遍であり、いつでも確認可能です

00:12:57.780 --> 00:13:00.960
自己修復機能も、実際に目にするまでは魔法のように聞こえるかもしれません

00:13:00.960 --> 00:13:03.560
誰かがクラスター内のデプロイを直接手動で編集したとします

00:13:03.560 --> 00:13:06.240
例えばジュニアエンジニアが急いで修正を試みた場合などです

00:13:06.240 --> 00:13:09.580
オペレーターが次回の調整サイクルでサイを検出し、元の状態に差し戻します

00:13:09.580 --> 00:13:13.240
クラスターは自己修復し、ログを確認しない限り、何が起きたのかすら気づかないでしょう

00:13:13.240 --> 00:13:15.600
環境間の整合性は自動的に持たれます

00:13:15.600 --> 00:13:19.300
開発、テスト、ステージング、本番のすべてが同じGitリポジトリから取得されます

00:13:19.300 --> 00:13:22.400
ブランチやホルダーは異なっても、信頼できる唯一の情報源は共通です

00:13:22.400 --> 00:13:26.860
ステージング環境が本番環境と何週間も乖離していて、自分の環境では動く、という問題も発生しません

00:13:26.860 --> 00:13:30.140
クラスターがGitへプルに行く構成になるため、セキュリティも向上します

00:13:30.140 --> 00:13:33.700
CIパイプラインは、本番環境への直接アクセス権を持つ資格情報を保持しません

00:13:33.700 --> 00:13:36.560
もし誰かがパイプラインに侵入しても、クラスターには一切触れられません

00:13:36.560 --> 00:13:38.800
何をいつ適用するかは、オペレーターが決定します

00:13:38.800 --> 00:13:40.900
設計段階から最小権限の原則が適用されています

00:13:40.900 --> 00:13:42.700
これを裏付けるデータも存在します

00:13:42.700 --> 00:13:50.760
ドラの調査によると、GitOpsを採用したチームではデプロイエラーが約25%減少し、適切に実装された環境では平均復旧時間が2分未満に短縮されています

00:13:50.760 --> 00:13:54.100
これは理論ではなく、実際に多くの組織から報告されている成果です

00:13:54.100 --> 00:13:57.120
そして、見落とされがちですが、コラボレーション面での利点もあります

00:13:57.120 --> 00:14:02.600
インフラの変更は、アプリケーションコードと同様にプルリクエスト、コードレビュー、自動テストを経て行われます

00:14:02.600 --> 00:14:05.820
運用チームと開発チームが、Gitという共通言語で会話できるようになります

00:14:05.820 --> 00:14:08.340
受け渡し作業やこれを代わりにデプロイしておいて、という依頼も不要です

00:14:08.340 --> 00:14:10.300
誰もが同じ方法で業務を進められます

00:14:10.300 --> 00:14:13.400
しかし、まだ解明しておくべき共通の誤解もいくつか存在します

00:14:13.400 --> 00:14:15.440
よくある神話と始め方についてです

00:14:15.440 --> 00:14:18.340
まずは、GitOpsに関する一般的な誤解を解くところから始めましょう

00:14:18.340 --> 00:14:21.200
まず、多くの人がGitOpsはKubernetes専用だと思っています

00:14:21.200 --> 00:14:24.000
確かにKubernetesで最も効果を発揮するのは間違いありません

00:14:24.000 --> 00:14:28.360
Kubernetesは宣言的な状態管理と調整に基づいて構築されているため、非常に相性が良いのです

00:14:28.360 --> 00:14:32.380
ですが、同じ原則は宣言的な構成を持つあらゆる場所で適用可能です

00:14:32.380 --> 00:14:35.600
テラフォームやプルミ、さらにはアンシブルでもGitOpsを利用できます

00:14:35.600 --> 00:14:38.820
構成をGitに保存しパイプラインを通じて適用するだけです

00:14:38.820 --> 00:14:43.720
自己修復はKubernetes以外では難しいですが、信頼できる唯一の情報源という原則はどこでも機能します

00:14:43.720 --> 00:14:48.220
もう一つの神話として、GitOpsを行うには必ずアルゴCDかフラックスが必要だという思い込みがあります

00:14:48.220 --> 00:14:54.520
プルベースのデプロイや継続的な調整、ドリフト検知といった完全なモデルを求めるなら、確かに何らかのGitOpsオペレーターが必要です

00:14:54.520 --> 00:14:56.660
しかし、もっと手軽に始めることもできます

00:14:56.660 --> 00:14:59.760
マニフェストをすべてGitに置き、プルリクエストを使って変更を加えるだけです

00:14:59.760 --> 00:15:02.620
それだけでも、監査やコラボレーションのメリットの大部分を得ることができます

00:15:02.620 --> 00:15:05.620
自動化が必要になった段階で、後からオペレーターを追加すれば良いのです

00:15:05.620 --> 00:15:08.660
最後に、GitOpsがCI、CDを完全に置き換えるという誤解があります

00:15:08.660 --> 00:15:09.800
そんなことはありません

00:15:09.800 --> 00:15:11.900
GitOpsが置き換えるのは、CDの部分だけです

00:15:11.900 --> 00:15:16.540
CIはこれまで通りコードをビルドし、テストを実行し、脆弱性をスキャンして、コンテナイメージをレジストリにプッシュします

00:15:16.540 --> 00:15:18.000
そのプロセスは変わりません

00:15:18.000 --> 00:15:20.680
変わるのは、それらのイメージがデプロイされる仕組みです

00:15:20.680 --> 00:15:25.500
CIパイプラインがクラスターへプッシュする代わりに、GitOpsオペレーターが更新されたマニフェストをGitからプルします

00:15:25.500 --> 00:15:28.780
つまり、CIとGitOpsは互いに置き換わるものではなく、連携して動作するのです

00:15:28.780 --> 00:15:30.540
導入は実際とてもシンプルです

00:15:30.540 --> 00:15:34.060
小さなアクスクラスターを選び、AzureポータルからFlaxを有効にするだけです

00:15:34.060 --> 00:15:35.640
数クリックで完了します

00:15:35.640 --> 00:15:41.360
あとは単純なデプロイ用YAMLを含むGitリポジトリを指定して同期を待てば、すぐに準備完了です

00:15:41.360 --> 00:15:44.940
YAMLの値を変更してコミットし、クラスターが更新される様子を確認してみてください

00:15:44.940 --> 00:15:47.180
それがあなたの最初のGitOpsワークフローです

00:15:47.180 --> 00:15:54.460
そこから環境を追加し、Flaxで多用されるカスタマイズを学び、リノベートやディペンダボットといったツールで自動イメージ更新を設定していくことができます

00:15:54.460 --> 00:15:56.360
GitOpsの概要は以上です

00:15:56.360 --> 00:16:02.220
インフラをGitリポジトリに変換することで、すべてが追跡可能、復元可能、そして自己修復可能な状態になります

00:16:02.220 --> 00:16:06.220
AzureでKubernetesを管理しているなら、ぜひ今日AXのGitOps統合を試してみてください

00:16:06.220 --> 00:16:09.560
セットアップは10分で済み、デプロイに対する考え方が変わるはずです

00:16:09.560 --> 00:16:13.340
マイクロソフトのクラウドツールに関するわかりやすい解説を今後も配信しますので、ぜひチャンネル登録をお願いします
