Build a CI/CD Runner in Go (Step-by-Step Guide)

mkdir ci-runner
cd ci-runner
go mod init ci-runner
go get github.com/docker/docker/client

// poller.go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

type Job struct {
    ID      string   `json:"id"`
    Image   string   `json:"image"`
    Steps   []string `json:"steps"`
    RepoURL string   `json:"repo_url"`
}

type Poller struct {
    APIURL  string
    Token   string
    Client  *http.Client
}

func NewPoller(apiURL, token string) *Poller {
    return &Poller{
        APIURL:  apiURL,
        Token:   token,
        Client:  &http.Client{Timeout: 10 * time.Second},
    }
}

func (p *Poller) FetchJob() (*Job, error) {
    req, _ := http.NewRequest("GET", p.APIURL+"/jobs/pending", nil)
    req.Header.Set("Authorization", "Bearer "+p.Token)

    resp, err := p.Client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("request failed: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusNotFound {
        return nil, nil
    }

    var job Job
    if err := json.NewDecoder(resp.Body).Decode(&job); err != nil {
        return nil, fmt.Errorf("decode failed: %w", err)
    }
    return &job, nil
}

// executor.go
package main

import (
    "bytes"
    "context"
    "io"
    "log"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/api/types/container"
    "github.com/docker/docker/client"
    "github.com/docker/docker/pkg/stdcopy"
)

type Executor struct {
    client *client.Client
}

func NewExecutor() (*Executor, error) {
    cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
    if err != nil {
        return nil, err
    }
    return &Executor{client: cli}, nil
}

func (e *Executor) RunStep(ctx context.Context, image, command string, logStream io.Writer) error {
    reader, err := e.client.ImagePull(ctx, image, types.ImagePullOptions{})
    if err != nil {
        return err
    }
    io.Copy(io.Discard, reader)
    reader.Close()

    resp, err := e.client.ContainerCreate(ctx, &container.Config{
        Image: image,
        Cmd:   []string{"sh", "-c", command},
        Tty:   false,
    }, nil, nil, nil, "")
    if err != nil {
        return err
    }
    defer e.client.ContainerRemove(ctx, resp.ID, types.ContainerRemoveOptions{})

    if err := e.client.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        return err
    }

    out, err := e.client.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{
        ShowStdout: true,
        ShowStderr: true,
        Follow:     true,
    })
    if err != nil {
        return err
    }
    stdcopy.StdCopy(logStream, logStream, out)
    out.Close()

    insp, _ := e.client.ContainerInspect(ctx, resp.ID)
    if insp.State.ExitCode != 0 {
        return fmt.Errorf("step failed with exit code %d", insp.State.ExitCode)
    }
    return nil
}

// main.go
package main

import (
    "bytes"
    "context"
    "encoding/json"
    "log"
    "net/http"
    "os"
    "time"
)

func reportStatus(apiURL, token string, job Job, success bool, logData string) {
    body, _ := json.Marshal(map[string]interface{}{
        "job_id":  job.ID,
        "success": success,
        "log":     logData,
    })
    req, _ := http.NewRequest("POST", apiURL+"/jobs/result", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+token)
    req.Header.Set("Content-Type", "application/json")
    http.DefaultClient.Do(req)
}

func main() {
    apiURL := os.Getenv("CI_API_URL")
    token := os.Getenv("CI_TOKEN")
    if apiURL == "" || token == "" {
        log.Fatal("CI_API_URL and CI_TOKEN must be set")
    }

    poller := NewPoller(apiURL, token)
    executor, err := NewExecutor()
    if err != nil {
        log.Fatalf("executor: %v", err)
    }

    for {
        job, err := poller.FetchJob()
        if err != nil {
            log.Printf("poll error: %v", err)
            time.Sleep(5 * time.Second)
            continue
        }
        if job == nil {
            time.Sleep(5 * time.Second)
            continue
        }

        log.Printf("executing job %s: %d steps", job.ID, len(job.Steps))
        var buf bytes.Buffer
        success := true

        for i, step := range job.Steps {
            log.Printf("  step %d: %s", i+1, step)
            if err := executor.RunStep(context.Background(), job.Image, step, &buf); err != nil {
                log.Printf("  step %d failed: %v", i+1, err)
                success = false
                break
            }
        }

        reportStatus(apiURL, token, *job, success, buf.String())
        log.Printf("job %s complete (success=%v)", job.ID, success)
    }
}