[ArgoCD] アーキテクチャ内部分析：ソースコードレベルディープダイブ

ユーザー (Web UI / CLI / CI)
       |
       v
  API Server (gRPC/REST)
       |
       +-------> Repository Server (gRPC)
       |                |
       +-------> Application Controller
       |                |
       +-------> Redis (TCP)
       |
       +-------> Dex (OIDC)

// API ServerのgRPCサービス登録
func (s *ArgoCDServer) Run(ctx context.Context, listeners ...net.Listener) {
    grpcServer := grpc.NewServer(grpcOpts...)
    application.RegisterApplicationServiceServer(grpcServer, s.appService)
    repository.RegisterRepositoryServiceServer(grpcServer, s.repoService)
    project.RegisterProjectServiceServer(grpcServer, s.projectService)
    session.RegisterSessionServiceServer(grpcServer, s.sessionService)
}

1. ユーザーがログインリクエストを送信
2. API ServerがDexにOIDC認証を委任（SSOの場合）
3. Dexが外部IdP（GitHub、LDAPなど）に認証リクエスト
4. 認証成功時にJWTトークンを発行
5. 以降のリクエストでJWTトークンをBearerヘッダーで送信
6. API ServerがJWTを検証しRBACポリシーで認可を実行

# 基本ポリシーフォーマット
p, ROLE, RESOURCE, ACTION, OBJECT, EFFECT

# 例：proj-admin役割にmy-projectのすべてのapplication権限を付与
p, role:proj-admin, applications, *, my-project/*, allow

# グループマッピング
g, my-github-team, role:proj-admin

1. Application Controllerがrepo-serverにマニフェスト生成をリクエスト
2. repo-serverがGitリポジトリをクローン（shallow cloneがデフォルト）
3. 指定されたリビジョン（branch、tag、commit）にcheckout
4. パス内のマニフェストを検出し適切なツールでレンダリング
5. 結果をApplication Controllerに返却しRedisにキャッシュ

// マニフェスト生成ツール検出ロジック（簡略化）
func detectTool(path string) string {
    if fileExists(path, "Chart.yaml") {
        return "helm"
    }
    if fileExists(path, "kustomization.yaml") ||
       fileExists(path, "kustomization.yml") ||
       fileExists(path, "Kustomization") {
        return "kustomize"
    }
    return "directory" // plain YAML
}

1. Chart.yamlをパースしてチャートメタデータを確認
2. dependenciesがあればhelm dependency buildを実行
3. valuesファイルをロード（デフォルトvalues.yaml + ユーザーオーバーライド）
4. helm templateコマンドで最終マニフェストを生成
5. 生成されたYAMLをパースしてバリデーション

1. kustomization.yamlをパース
2. bases/resources参照を解決
3. patches、overlaysを適用
4. namePrefix、nameSuffix、labels、annotations変換
5. 最終YAMLを出力

# CMP設定例 - plugin.yaml
apiVersion: argoproj.io/v1alpha1
kind: ConfigManagementPlugin
metadata:
  name: custom-jsonnet
spec:
  version: v1.0
  generate:
    command: [jsonnet]
    args: [main.jsonnet]
  discover:
    fileName: main.jsonnet

キャッシュキー：HASH(git-url + revision + path + tool + params)
キャッシュTTL：デフォルト24時間（ARGOCD_REPO_SERVER_CACHE_EXPIRATION）
キャッシュ無効化：Gitリビジョン変更時

// Informer基盤リソース監視（簡略化）
func (c *ApplicationController) watchResources() {
    factory := informers.NewSharedInformerFactory(clientset, resyncPeriod)

    factory.Apps().V1().Deployments().Informer().AddEventHandler(
        cache.ResourceEventHandlerFuncs{
            AddFunc:    c.onResourceAdd,
            UpdateFunc: c.onResourceUpdate,
            DeleteFunc: c.onResourceDelete,
        },
    )
}

ループ：
  1. すべてのApplicationリソースを照会
  2. 各Applicationに対して：
     a. Repository Serverに望ましい状態（マニフェスト）をリクエスト
     b. 対象クラスタから実際の状態を照会
     c. 望ましい状態と実際の状態を比較（Diff）
     d. Sync Statusを更新（Synced / OutOfSync）
     e. Health Statusを更新（Healthy / Degraded / Progressingなど）
     f. Auto-Syncが有効であれば自動同期を実行
  3. 次のサイクルまで待機（デフォルト180秒）

比較対象：
  - Last Applied Configuration（annotationに保存）
  - Live State（クラスタの実際の状態）
  - Desired State（Gitから生成されたマニフェスト）

Diffプロセス：
  1. Live StateとDesired Stateを正規化（normalization）
  2. デフォルト値を除去（Kubernetesが自動追加するフィールド）
  3. 無視フィールドを除外（resourceVersion、generationなど）
  4. 残りのフィールド間で構造的比較を実行

// 正規化の例
func normalizeResource(resource *unstructured.Unstructured) {
    // metadataから管理フィールドを除去
    removeFields(resource, "metadata.managedFields")
    removeFields(resource, "metadata.resourceVersion")
    removeFields(resource, "metadata.uid")
    removeFields(resource, "metadata.generation")
    removeFields(resource, "metadata.creationTimestamp")

    // statusフィールドを除去（宣言的状態ではない）
    removeFields(resource, "status")
}

-- argocd-cm ConfigMapに定義するカスタムhealth check
hs = {}
if obj.status ~= nil then
    if obj.status.conditions ~= nil then
        for _, condition in ipairs(obj.status.conditions) do
            if condition.type == "Ready" and condition.status == "True" then
                hs.status = "Healthy"
                hs.message = condition.message
                return hs
            end
        end
    end
end
hs.status = "Progressing"
hs.message = "Waiting for resource to become ready"
return hs

1. ユーザーまたはAuto-SyncがSyncをトリガー
2. Application ControllerがRepository Serverに最新マニフェストをリクエスト
3. マニフェスト生成完了後にSync作業を開始
4. PreSync Hookを実行（ある場合）
5. メインリソースの同期（kubectl apply相当の作業）
6. PostSync Hookを実行（ある場合）
7. Health Checkでリソース状態を確認
8. Sync Statusを更新

# Sync Waveの例
metadata:
  annotations:
    argocd.argoproj.io/sync-wave: '-1' # 小さい番号が先に実行

Prune対象の判別：
  1. クラスタに存在するリソース一覧を照会
  2. ArgoCDのtracking label/annotationがあるリソースをフィルタ
  3. 現在のGitマニフェストに存在しないリソースを識別
  4. cascadeまたはforeground削除ポリシーに従って削除

app|resources|CLUSTER_URL|NAMESPACE: リソースツリーキャッシュ
git|manifest|REPO_URL|REVISION|PATH: マニフェストキャッシュ
repo|connection|REPO_URL: 接続状態キャッシュ

1. ユーザーがArgoCD UIでSSOログインをクリック
2. API ServerがDexのauthorization endpointにリダイレクト
3. Dexが設定されたコネクタ（GitHubなど）に認証を委任
4. ユーザーが外部IdPで認証を実行
5. 外部IdPがDex callback URLにリダイレクト
6. DexがID Tokenを生成（ユーザー情報、グループを含む）
7. API ServerがID Tokenを検証しArgoCD JWTを発行
8. JWTにユーザーグループ情報を含む（RBACに活用）

apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-alpha
  namespace: argocd
spec:
  description: 'Team Alphaのプロジェクト'
  # 許可ソースリポジトリ
  sourceRepos:
    - 'https://github.com/org/team-alpha-*'
  # 許可対象クラスタ/ネームスペース
  destinations:
    - server: 'https://kubernetes.default.svc'
      namespace: 'team-alpha-*'
  # 作成可能なクラスタリソース（制限）
  clusterResourceWhitelist:
    - group: ''
      kind: Namespace
  # ネームスペースリソース拒否リスト
  namespaceResourceBlacklist:
    - group: ''
      kind: ResourceQuota
    - group: ''
      kind: LimitRange
  # 役割定義
  roles:
    - name: developer
      description: '開発チーム役割'
      policies:
        - p, proj:team-alpha:developer, applications, get, team-alpha/*, allow
        - p, proj:team-alpha:developer, applications, sync, team-alpha/*, allow
      groups:
        - team-alpha-devs

Application Controller
  --gRPC--> Repository Server（マニフェスト生成リクエスト）
  --gRPC--> API Server（状態更新）

API Server
  --gRPC--> Repository Server（リポジトリ検証）
  --HTTP--> Dex（認証）
  --TCP---> Redis（キャッシュ/セッション）

Repository Server
  --TCP---> Redis（マニフェストキャッシュ）
  --HTTPS--> Git Server（リポジトリクローン）

- API ServerがTLS証明書を生成し管理
- 各コンポーネントはargocd-server-tls Secretから証明書をロード
- mTLS（相互TLS）はオプションで有効化可能