PnR：具有 Go 平台抽象的配置意圖驅動的容器編排

您是否曾經希望容器編排能夠比靜態依賴鏈更靈活，但又比 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 透過三個關鍵組件來編排容器：

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 撰寫：

# 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 平台抽象的配置意圖驅動的容器編排的詳細內容。更多資訊請關注PHP中文網其他相關文章！