Terraform Cloud基础工具入门指南（Golang版）

我来帮你解决这两个核心问题。以下是针对 Terraform Cloud SDK 使用的具体示例：

1. 上下文传递的正确方式

对于 Terraform Cloud SDK，你应该在函数间传递上下文，而不是在每个函数内部创建。这样可以实现请求取消、超时控制等：

package main

import (
    "context"
    "fmt"
    "time"
    
    tfe "github.com/hashicorp/go-tfe"
)

func getOrganization(ctx context.Context, client *tfe.Client, orgName string) (*tfe.Organization, error) {
    // 使用传入的上下文
    org, err := client.Organizations.Read(ctx, orgName)
    if err != nil {
        return nil, fmt.Errorf("failed to read organization: %w", err)
    }
    return org, nil
}

func listWorkspaces(ctx context.Context, client *tfe.Client, orgName string) ([]*tfe.Workspace, error) {
    // 可以设置特定操作的超时
    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()
    
    workspaces, err := client.Workspaces.List(ctx, orgName, &tfe.WorkspaceListOptions{})
    if err != nil {
        return nil, fmt.Errorf("failed to list workspaces: %w", err)
    }
    return workspaces.Items, nil
}

func main() {
    ctx := context.Background()
    
    config := &tfe.Config{
        Token: "your-token-here",
    }
    
    client, err := tfe.NewClient(config)
    if err != nil {
        panic(err)
    }
    
    // 传递上下文到函数
    org, err := getOrganization(ctx, client, "my-org")
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Organization: %s\n", org.Name)
    
    workspaces, err := listWorkspaces(ctx, client, "my-org")
    if err != nil {
        panic(err)
    }
    
    for _, ws := range workspaces {
        fmt.Printf("Workspace: %s\n", ws.Name)
    }
}

2. Client 对象的传递方式

对于 tfe.Client，你应该传递指针，因为 SDK 的方法都是指针接收者：

package main

import (
    "context"
    "fmt"
    
    tfe "github.com/hashicorp/go-tfe"
)

// 正确：传递指针
func getWorkspaceDetails(ctx context.Context, client *tfe.Client, orgName, workspaceName string) (*tfe.Workspace, error) {
    // 传递指针允许修改接收者的状态
    ws, err := client.Workspaces.Read(ctx, orgName, workspaceName)
    if err != nil {
        return nil, fmt.Errorf("failed to read workspace: %w", err)
    }
    return ws, nil
}

// 错误：传递值（这会导致编译错误或运行时错误）
func badGetWorkspaceDetails(ctx context.Context, client tfe.Client, orgName, workspaceName string) (*tfe.Workspace, error) {
    // 这不会工作，因为 Workspaces 字段等方法需要指针接收者
    ws, err := client.Workspaces.Read(ctx, orgName, workspaceName)
    return ws, err
}

// 初始化 client 的正确方式
func initializeClient(token string) (*tfe.Client, error) {
    config := &tfe.Config{
        Token: token,
        // 可以添加其他配置
        Address: "https://app.terraform.io", // 或你的企业版地址
    }
    
    // NewClient 返回的是指针
    client, err := tfe.NewClient(config)
    if err != nil {
        return nil, fmt.Errorf("failed to create client: %w", err)
    }
    
    return client, nil
}

func main() {
    ctx := context.Background()
    
    // 获取 client 指针
    client, err := initializeClient("your-tfe-token")
    if err != nil {
        panic(err)
    }
    
    // 传递指针到函数
    ws, err := getWorkspaceDetails(ctx, client, "my-org", "production")
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Workspace ID: %s\n", ws.ID)
    fmt.Printf("Terraform Version: %s\n", ws.TerraformVersion)
}

完整示例：初始化 Terraform Cloud 运行

package main

import (
    "context"
    "fmt"
    "log"
    "time"
    
    tfe "github.com/hashicorp/go-tfe"
)

type TFCloudManager struct {
    client *tfe.Client
    ctx    context.Context
}

func NewTFCloudManager(token, address string) (*TFCloudManager, error) {
    config := &tfe.Config{
        Token:   token,
        Address: address,
    }
    
    client, err := tfe.NewClient(config)
    if err != nil {
        return nil, err
    }
    
    return &TFCloudManager{
        client: client,
        ctx:    context.Background(),
    }, nil
}

func (m *TFCloudManager) CreateRun(orgName, workspaceName, message string) (*tfe.Run, error) {
    // 获取工作区
    ws, err := m.client.Workspaces.Read(m.ctx, orgName, workspaceName)
    if err != nil {
        return nil, fmt.Errorf("failed to read workspace: %w", err)
    }
    
    // 创建运行
    run, err := m.client.Runs.Create(m.ctx, tfe.RunCreateOptions{
        Workspace: ws,
        Message:   &message,
    })
    if err != nil {
        return nil, fmt.Errorf("failed to create run: %w", err)
    }
    
    return run, nil
}

func (m *TFCloudManager) WaitForRunCompletion(runID string, timeout time.Duration) (*tfe.Run, error) {
    ctx, cancel := context.WithTimeout(m.ctx, timeout)
    defer cancel()
    
    ticker := time.NewTicker(5 * time.Second)
    defer ticker.Stop()
    
    for {
        select {
        case <-ctx.Done():
            return nil, ctx.Err()
        case <-ticker.C:
            run, err := m.client.Runs.Read(ctx, runID)
            if err != nil {
                return nil, err
            }
            
            switch run.Status {
            case tfe.RunApplied, tfe.RunPlannedAndFinished:
                return run, nil
            case tfe.RunErrored, tfe.RunCanceled, tfe.RunDiscarded:
                return run, fmt.Errorf("run ended with status: %s", run.Status)
            }
        }
    }
}

func main() {
    manager, err := NewTFCloudManager(
        "your-token",
        "https://app.terraform.io", // 企业版使用你的私有地址
    )
    if err != nil {
        log.Fatal(err)
    }
    
    // 创建运行
    run, err := manager.CreateRun("my-org", "my-workspace", "Triggered via Go SDK")
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Created run: %s\n", run.ID)
    
    // 等待完成
    completedRun, err := manager.WaitForRunCompletion(run.ID, 10*time.Minute)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Run completed with status: %s\n", completedRun.Status)
}

关于代码分享：在帖子中保留关键代码片段，同时提供 Playground 链接是个好方法。对于 Terraform Cloud SDK 这种需要外部依赖的情况，Playground 可能无法运行，但代码示例仍然有价值。