golang框架在DevOps实践中的应用方案

import (
    "fmt"
    "io"

    "github.com/go-git/go-git/v5"
    "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
)

func main() {
    // 创建 Kubernetes 客户端
    clientset, err := kubernetes.NewForConfig(restConfig)
    if err != nil {
        panic(err)
    }

    // 创建 Git 客户端
    gitClient, err := git.PlainOpen("my-repo")
    if err != nil {
        panic(err)
    }

    // 定义 Tekton 管道任务
    taskSpec := &v1alpha1.TaskSpec{
        Steps: []v1alpha1.Step{
            {
                Name: "clone-repo",
                Image: "gcr.io/tekton-hub/git-init",
                Script: `cd $(WORKSPACE)/src
                    git clone https://github.com/my-org/my-repo.git`,
            },
            {
                Name: "build-image",
                Image: "gcr.io/my-org/my-image",
                Command: []string{"make", "build"},
            },
            {
                Name: "deploy-image",
                Image: "gcr.io/tekton-hub/gcloud",
                Args: []string{"compute", "instance-groups", "managed", "update",
                    "my-instance-group", "--zone", "us-central1-a"},
                Script: `#!/bin/bash
                    gcloud docker -- project=${GOOGLE_CLOUD_PROJECT} \
                    -- execute --target-project=${GOOGLE_CLOUD_PROJECT} \
                    -- my-zone=us-central1-a \
                    --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/my-image
                    --container=my-container \
                    'bash -c "make run"'`,
            },
        },
    }

    // 创建 Tekton 任务
    task, err := clientset.TektonV1alpha1().Tasks(appNamespace).Create(ctx,
        &v1alpha1.Task{
            ObjectMeta: metav1.ObjectMeta{
                Name: "my-task",
            },
            Spec: *taskSpec,
        })
    if err != nil {
        panic(err)
    }

    // 创建 Tekton 流水线资源
    pipelineSpec := &v1alpha1.PipelineSpec{
        Tasks: map[string]*v1alpha1.TaskRef{
            "clone-repo": {Name: "my-task"},
            "build-image": {Name: "my-task"},
            "deploy-image": {Name: "my-task"},
        },
        Finally: []v1alpha1.PipelineFinally{
            {
                Name: "cleanup-workspace",
                TaskRefName: "clone-repo",
                WhenExpressions: []string{"status.failed"},
                Resources: &v1alpha1.PipelineResources{
                    Requests: map[v1alpha1.PipelineResourceType]string{
                        v1alpha1.PipelineResourceMemory: "128Mi",
                        v1alpha1.PipelineResourceStorage: "1Gi",
                    },
                },
            },
        },
    }

    // 创建 Tekton 流水线资源
    pipeline, err := clientset.TektonV1alpha1().Pipelines(appNamespace).Create(ctx,
        &v1alpha1.Pipeline{
            ObjectMeta: metav1.ObjectMeta{
                Name: "my-pipeline",
            },
            Spec: *pipelineSpec,
        })
    if err != nil {
        panic(err)
    }

    // 监视流水线执行
    ctx, cancel := context.WithCancel(ctx)
    go func() {
        stream, err := clientset.TektonV1alpha1().PipelineRuns(appNamespace).Watch(ctx,
            metav1.ListOptions{FieldSelector: fmt.Sprintf("metadata.name=%s", pipeline.Name)})
        if err != nil {
            panic(err)
        }
        for {
            select {
            case <-ctx.Done():
                return
            case pre, ok := <-stream.ResultChan():
                if !ok {
                    return
                }
                pr := pre.Object.(*v1alpha1.PipelineRun)
                if pr.Status != nil {
                    fmt.Printf("PipelineRun %s status: %s\n", pr.Name, pr.Status.Phase)
                }
            }
        }
    }()

    // 手动触发流水线执行
    _, err = clientset.TektonV1alpha1().PipelineRuns(appNamespace).Create(ctx,
        &v1alpha1.PipelineRun{
            ObjectMeta: metav1.ObjectMeta{
                GenerateName: "my-pipeline-run-",
                Labels: map[string]string{
                    "my-label": "my-value",
                },
            },
            Spec: v1alpha1.PipelineRunSpec{
                PipelineRef: &v1alpha1.PipelineRef{Name: pipeline.Name},
            },
        })
    if err != nil {
        panic(err)
    }

    // 取消上下文停止监听