PnR: Go&#s プラットフォーム抽象化による構成意図主導のコンテナ オーケストレーション

コンテナ オーケストレーションが静的依存関係チェーンよりも柔軟で、Kubernetes よりもシンプルであればいいのにと思ったことはありませんか? PnR (プロンプト アンド レスポンス) をご紹介します。これは、Go の強力なプラットフォーム抽象化機能を活用して、単純な依存関係ではなく実際の準備状態に基づいてコンテナを調整する構成主導のアプローチです。

Go のプラットフォーム抽象化の力

PnR について説明する前に、Go がクロスプラットフォームのコンテナ オーケストレーションに特に適している理由を理解しましょう。

1. 統合 Docker API インターフェイス: Go の Docker クライアント ライブラリは、プラットフォーム固有のソケット接続を通じて、Windows、Linux、macOS 全体で一貫したインターフェイスを提供します。

   • Unix システムは /var/run/docker.sock を使用します
   • Windows は名前付きパイプを使用します
   • client.NewClientWithOpts() 関数はこれらの違いを自動的に処理します

2. ネイティブ同時実行サポート: Go の goroutine とチャネルにより、効率的なコンテナ監視が可能になります:

   • 各コンテナのヘルスチェックは同時に実行されます
   • インテンション ループはブロックせずに複数のコンテナを調整します
   • ミューテックス保護された状態の更新により競合状態が防止されます

3. クロスプラットフォーム ネットワーク処理: Go の net パッケージは、プラットフォーム固有のネットワークの詳細を抽象化します:

   • TCP ヘルスチェックはどのオペレーティング システムでも同様に機能します
   • HTTP クライアントはプラットフォーム固有の DNS 解決を処理します
   • ポート バインディングはプラットフォームに関係なく一貫した構文を使用します

中心となる概念: コードよりも構成

PnR は、次の 3 つの主要なコンポーネントを通じてコン​​テナを調整します。

1. ドメイン構成 (JSON)
2. プラットフォームに依存しないヘルスチェック
3. 実行時状態管理

これを典型的な Web スタック (MongoDB、API サーバー、Web クライアント) で実際に動作させてみます。

ドメイン構成構造

{
    "name": "dev_stack",
    "cpuxs": {
        "stack_startup": {
            "design_chunks": [
                {
                    "name": "mongodb",
                    "gatekeeper": {
                        "system_ready": {
                            "prompt": "Is system ready?",
                            "response": ["yes"],
                            "tv": "Y"
                        }
                    },
                    "flowout": {
                        "mongodb_ready": {
                            "prompt": "Is MongoDB ready?",
                            "response": ["yes"],
                            "tv": "Y"
                        }
                    },
                    "health_check": {
                        "type": "tcp",
                        "port_key": "27017",
                        "timeout_seconds": 2,
                        "status_mapping": {
                            "success": {
                                "key": "mongodb_ready",
                                "response": ["yes"],
                                "tv": "Y"
                            },
                            "failure": {
                                "key": "mongodb_ready",
                                "response": ["no"],
                                "tv": "N"
                            }
                        }
                    },
                    "container": {
                        "name": "pnr_mongodb",
                        "image": "mongo:latest",
                        "ports": {
                            "27017": "27017"
                        }
                    }
                }
            ]
        }
    }
}

プラットフォームに依存しないコンテナ管理

PnR の核心は、プラットフォームに依存しないコンテナ管理です。仕組みは次のとおりです:

func (il *ContainerIntentionLoop) Execute() error {
    // Create platform-specific network
    _, err := il.dockerClient.NetworkCreate(il.ctx, "pnr_network", types.NetworkCreate{})
    if err != nil {
        return fmt.Errorf("failed to create network: %v", err)
    }

    for {
        // Update runtime state
        if err := il.updateRTStateFromRuntime(); err != nil {
            return err
        }

        allCompleted := true
        anyExecuting := false

        // Process each container
        for i := range il.cpux.DesignChunks {
            chunk := &il.cpux.DesignChunks[i]

            // Container state machine
            switch chunk.Status {
            case "completed":
                continue
            case "executing":
                anyExecuting = true
                allCompleted = false
                if il.checkChunkCompletion(chunk) {
                    chunk.Status = "completed"
                }
            case "", "ready":
                allCompleted = false
                if il.checkGatekeeper(chunk) {
                    if err := il.startContainer(chunk); err != nil {
                        return err
                    }
                    chunk.Status = "executing"
                    anyExecuting = true
                }
            }
        }

        // Check termination conditions
        if allCompleted {
            return nil
        }
        if !anyExecuting && !allCompleted {
            return fmt.Errorf("no progress possible - execution stalled")
        }

        time.Sleep(5 * time.Second)
    }
}

クロスプラットフォームのヘルスチェック

PnR は、Go の標準ライブラリを使用してプラットフォームに依存しないヘルスチェックを実装します。

{
    "name": "dev_stack",
    "cpuxs": {
        "stack_startup": {
            "design_chunks": [
                {
                    "name": "mongodb",
                    "gatekeeper": {
                        "system_ready": {
                            "prompt": "Is system ready?",
                            "response": ["yes"],
                            "tv": "Y"
                        }
                    },
                    "flowout": {
                        "mongodb_ready": {
                            "prompt": "Is MongoDB ready?",
                            "response": ["yes"],
                            "tv": "Y"
                        }
                    },
                    "health_check": {
                        "type": "tcp",
                        "port_key": "27017",
                        "timeout_seconds": 2,
                        "status_mapping": {
                            "success": {
                                "key": "mongodb_ready",
                                "response": ["yes"],
                                "tv": "Y"
                            },
                            "failure": {
                                "key": "mongodb_ready",
                                "response": ["no"],
                                "tv": "N"
                            }
                        }
                    },
                    "container": {
                        "name": "pnr_mongodb",
                        "image": "mongo:latest",
                        "ports": {
                            "27017": "27017"
                        }
                    }
                }
            ]
        }
    }
}

主な利点

1. 真のクロスプラットフォーム サポート: Windows、Linux、macOS 上で同様に動作します
2. 構成主導: すべてのオーケストレーション ロジックは、domain.json
内にあります
3. コンテナに依存しない: PnR 固有のコンテナの変更は必要ありません
4. 柔軟なヘルスチェック: TCP、HTTP、および他のプロトコルに拡張可能
5. 状態の可視性: ランタイム ファイルを通じてステータスの更新をクリアします
6. 同時実行: 効率的な並列コンテナ管理

はじめる

完全なコードはここから入手できます: Github

前提条件

1. Go (1.19 以降) をインストールします:

2. Docker をインストールします

プロジェクトの構造

func (il *ContainerIntentionLoop) Execute() error {
    // Create platform-specific network
    _, err := il.dockerClient.NetworkCreate(il.ctx, "pnr_network", types.NetworkCreate{})
    if err != nil {
        return fmt.Errorf("failed to create network: %v", err)
    }

    for {
        // Update runtime state
        if err := il.updateRTStateFromRuntime(); err != nil {
            return err
        }

        allCompleted := true
        anyExecuting := false

        // Process each container
        for i := range il.cpux.DesignChunks {
            chunk := &il.cpux.DesignChunks[i]

            // Container state machine
            switch chunk.Status {
            case "completed":
                continue
            case "executing":
                anyExecuting = true
                allCompleted = false
                if il.checkChunkCompletion(chunk) {
                    chunk.Status = "completed"
                }
            case "", "ready":
                allCompleted = false
                if il.checkGatekeeper(chunk) {
                    if err := il.startContainer(chunk); err != nil {
                        return err
                    }
                    chunk.Status = "executing"
                    anyExecuting = true
                }
            }
        }

        // Check termination conditions
        if allCompleted {
            return nil
        }
        if !anyExecuting && !allCompleted {
            return fmt.Errorf("no progress possible - execution stalled")
        }

        time.Sleep(5 * time.Second)
    }
}

インストール

func (il *ContainerIntentionLoop) checkChunkCompletion(chunk *DesignChunk) bool {
    // Platform-agnostic container status check
    isRunning, err := il.isContainerRunning(chunk.Container.Name)
    if !isRunning {
        il.updateChunkStatus(chunk, false)
        return false
    }

    // Health check based on configuration
    status := false
    switch chunk.HealthCheck.Type {
    case "tcp":
        addr := fmt.Sprintf("localhost:%s", chunk.Container.Ports[chunk.HealthCheck.PortKey])
        conn, err := net.DialTimeout("tcp", addr, timeout)
        if err == nil {
            conn.Close()
            status = true
        }

    case "http":
        url := fmt.Sprintf("http://localhost:%s%s", 
            chunk.Container.Ports[chunk.HealthCheck.PortKey],
            chunk.HealthCheck.Path)
        resp, err := client.Get(url)
        if err == nil {
            status = (resp.StatusCode == chunk.HealthCheck.ExpectedCode)
        }
    }

    il.updateChunkStatus(chunk, status)
    return status
}

構築と実行

pnr-orchestrator/
├── main.go
├── containers.go
├── config/
│   └── domain.json
└── runtime/          # Created automatically

単純な依存関係を超えて

従来の Docker Compose:

# Create project directory
mkdir pnr-orchestrator
cd pnr-orchestrator

# Initialize Go module
go mod init pnr-orchestrator

# Install dependencies
go get github.com/docker/docker/client
go get github.com/docker/docker/api/types
go get github.com/docker/go-connections/nat

PnR のインテリジェントなオーケストレーション:

# Option 1: Direct run
go run main.go containers.go

# Option 2: Build and run separately
go build
./pnr-orchestrator   # Unix/Linux/Mac
pnr-orchestrator.exe # Windows

主な違いは何ですか? PnR は、コンテナーの起動だけでなく、あらゆるプラットフォームにわたって実際のサービスの準備を整えます。

次のステップ

1. より複雑なオーケストレーション パターンを探索する
2. カスタムヘルスチェックタイプを追加します
3. 正常なシャットダウンとクリーンアップを実装する
4. プラットフォーム固有の最適化ヒントを作成する

PnR は、Go の強力なプラットフォーム抽象化機能により、シンプルさやパワーを犠牲にすることなく、堅牢なクロスプラットフォームのコンテナ オーケストレーション ツールをどのように作成できるかを示します。

さらに例を見たい場合、またはプラットフォーム固有の実装について質問がある場合は、コメントでお知らせください。

以上がPnR: Go&#s プラットフォーム抽象化による構成意図主導のコンテナ オーケストレーションの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。