如何使用Helm Go SDK从Git仓库或Artifactory等外部位置安装Chart

Great question! Since you’re already familiar with using helm.sh/helm/v3/pkg/chart/loader for embedded charts, let’s walk through how to adapt this to load charts from external sources like Artifactory or Git repositories—Helm does provide built-in tools to make this efficient, so you don’t have to roll your own HTTP requests from scratch.

1. Loading from Artifactory (Helm Chart Repository) #

Artifactory is typically set up as a standard Helm chart repository, which means you can leverage Helm’s built-in repository client to fetch charts directly. Here’s how to do it:

Key Concepts #

• Helm’s repo package handles repository discovery, authentication, and chart downloads.
• Once you download the chart archive (.tgz), you can load it using loader.LoadArchive (instead of loader.Load which works for local directories).

Example Code #

import (
    "os"
    "path/filepath"

    "helm.sh/helm/v3/pkg/chart"
    "helm.sh/helm/v3/pkg/chart/loader"
    "helm.sh/helm/v3/pkg/getter"
    "helm.sh/helm/v3/pkg/repo"
    "helm.sh/helm/v3/pkg/cli"
)

func loadChartFromArtifactory(repoURL, chartName, chartVersion, username, password string) (*chart.Chart, error) {
    // Set up repository configuration with authentication
    repoEntry := &repo.Entry{
        URL:      repoURL,
        Username: username,
        Password: password,
    }

    // Create a chart repository client
    settings := cli.New()
    getterConstructor := getter.All(settings)
    repoClient, err := repo.NewChartRepository(repoEntry, getterConstructor)
    if err != nil {
        return nil, err
    }

    // Download the chart to a temporary directory
    tempDir, err := os.MkdirTemp("", "helm-chart-")
    if err != nil {
        return nil, err
    }
    defer os.RemoveAll(tempDir) // Clean up after loading

    chartPath, err := repoClient.DownloadChart(chartName, chartVersion, tempDir)
    if err != nil {
        return nil, err
    }

    // Load the downloaded chart archive
    chartFile, err := os.Open(chartPath)
    if err != nil {
        return nil, err
    }
    defer chartFile.Close()

    return loader.LoadArchive(chartFile)
}

Efficiency Tips #

• Cache Charts: Store downloaded .tgz files in a persistent cache directory instead of a temporary one, and check if the chart version already exists before re-downloading.
• Leverage HTTP Caching: Artifactory supports HTTP cache headers (like ETag or Last-Modified)—Helm’s repo client will automatically use these to avoid unnecessary downloads.
• Secure Credentials: Use environment variables or secure vaults to store Artifactory credentials instead of hardcoding them.

2. Loading from a Git Repository #

For Git-hosted charts, you have two primary efficient options depending on your needs:

Option A: Use Helm’s Getter for Git URLs #

Helm’s getter package natively supports fetching chart content from Git repositories (including specifying branches, tags, or commit hashes). This avoids full repository clones if you only need a specific chart directory.

Example Code

import (
    "os"
    "path/filepath"

    "helm.sh/helm/v3/pkg/chart"
    "helm.sh/helm/v3/pkg/chart/loader"
    "helm.sh/helm/v3/pkg/getter"
    "helm.sh/helm/v3/pkg/cli"
)

func loadChartFromGit(gitURL, chartPathInRepo, ref string) (*chart.Chart, error) {
    // Format the Git URL with reference (branch/tag/commit)
    // Example: "git+https://github.com/example/charts.git//path/to/chart1?ref=main"
    fullURL := gitURL + "//" + chartPathInRepo + "?ref=" + ref

    // Set up getter options
    settings := cli.New()
    getterImpl, err := getter.Get(fullURL, settings)
    if err != nil {
        return nil, err
    }

    // Fetch the chart content into a temporary directory
    tempDir, err := os.MkdirTemp("", "helm-git-chart-")
    if err != nil {
        return nil, err
    }
    defer os.RemoveAll(tempDir)

    if err := getterImpl.Get(tempDir, fullURL); err != nil {
        return nil, err
    }

    // Load the chart from the temporary directory
    return loader.Load(filepath.Join(tempDir, chartPathInRepo))
}

Option B: Shallow Clone with Go-Git #

If you need more control over Git operations (like partial clones or custom authentication), use the go-git library to perform a shallow clone of the repository, then load the chart from the local clone.

Example Code Snippet

import (
    "os"
    "path/filepath"

    "helm.sh/helm/v3/pkg/chart"
    "helm.sh/helm/v3/pkg/chart/loader"
    "github.com/go-git/go-git/v5"
    "github.com/go-git/go-git/v5/plumbing"
    "github.com/go-git/go-git/v5/plumbing/transport/http"
)

func loadChartFromGitWithGoGit(repoURL, chartPath, branch string, username, token string) (*chart.Chart, error) {
    tempDir, err := os.MkdirTemp("", "helm-git-clone-")
    if err != nil {
        return nil, err
    }
    defer os.RemoveAll(tempDir)

    // Perform a shallow clone (only the latest commit of the target branch)
    _, err = git.PlainClone(tempDir, false, &git.CloneOptions{
        URL:           repoURL,
        SingleBranch:  true,
        Depth:         1,
        ReferenceName: plumbing.NewBranchReferenceName(branch),
        Auth: &http.BasicAuth{
            Username: username,
            Password: token, // Use personal access token for HTTPS
        },
    })
    if err != nil {
        return nil, err
    }

    // Load the chart from the cloned directory
    return loader.Load(filepath.Join(tempDir, chartPath))
}

Efficiency Tips for Git #

• Shallow Clones: Use Depth: 1 to only pull the latest commit, reducing download size and time.
• Targeted Paths: If using Helm’s getter, specify the exact chart path in the repository URL to avoid fetching unnecessary files.
• Cache Clones: Keep a local clone of the Git repo and pull updates only when needed, instead of cloning from scratch every time.

General Best Practices #

• Retry Logic: Add retries for network operations (use libraries like github.com/cenkalti/backoff/v4) to handle transient issues.
• Memory Loading: If you want to avoid disk I/O, modify the getter logic to download chart content into memory and use loader.LoadFiles instead of writing to disk.
• Chart Validation: Always validate the loaded chart using chart.Validate() to ensure it meets Helm’s schema requirements.

内容的提问来源于stack exchange，提问作者Jenny M