Helm

https://helm.sh/docs
Admin
Helm is the package manager for Kubernetes that helps you manage Kubernetes applications.
Tokens:152,393
Snippets:1,767
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Action in Go

Source: https://helm.sh/docs/sdk/examples

This example demonstrates how to install a Helm chart using the action.NewInstall client. It includes logic for initializing the action configuration, locating the chart, checking dependencies, and running the installation.

```go
package main  

  

import (  

	"context"  

	"fmt"  

	"log"  

  

	"helm.sh/helm/v4/pkg/action"  

	"helm.sh/helm/v4/pkg/chart"  

	"helm.sh/helm/v4/pkg/chart/loader"  

	"helm.sh/helm/v4/pkg/cli"  

	"helm.sh/helm/v4/pkg/downloader"  

	"helm.sh/helm/v4/pkg/getter"  

)  

  

func runInstall(ctx context.Context, logger *log.Logger, settings *cli.EnvSettings, releaseName string, chartRef string, chartVersion string, releaseValues map[string]interface{}) error {  

  

	actionConfig, err := initActionConfig(settings, logger)  

	if err != nil {  

		return fmt.Errorf("failed to init action config: %w", err)  

	}  

  

	installClient := action.NewInstall(actionConfig)  

  

	installClient.DryRunStrategy = "none"  

	installClient.WaitStrategy = "watcher"  

	installClient.ReleaseName = releaseName  

	installClient.Namespace = settings.Namespace()  

	installClient.Version = chartVersion  

  

	registryClient, err := newRegistryClient(  

		settings,  

		installClient.CertFile,  

		installClient.KeyFile,  

		installClient.CaFile,  

		installClient.InsecureSkipTLSVerify,  

		installClient.PlainHTTP)  

	if err != nil {  

		return fmt.Errorf("failed to created registry client: %w", err)  

	}  

	installClient.SetRegistryClient(registryClient)  

  

	chartPath, err := installClient.ChartPathOptions.LocateChart(chartRef, settings)  

	if err != nil {  

		return err  

	}  

  

	providers := getter.All(settings)  

  

	charter, err := loader.Load(chartPath)  

	if err != nil {  

		return err  

	}  

  

	chartAccessor, err := chart.NewDefaultAccessor(charter)  

	if err != nil {  

		return fmt.Errorf("error creating chart accessor: %w", err)  

	}  

  

	// Check chart dependencies to make sure all are present in /charts  

	if chartDependencies := chartAccessor.MetaDependencies(); chartDependencies != nil {  

		if err := action.CheckDependencies(charter, chartDependencies); err != nil {  

			err = fmt.Errorf("failed to check chart dependencies: %w", err)  

			if !installClient.DependencyUpdate {  

				return err  

			}  

  

			manager := &downloader.Manager{  

				Out:              logger.Writer(),  

				ChartPath:        chartPath,  

				Keyring:          installClient.ChartPathOptions.Keyring,  

				SkipUpdate:       false,  

				Getters:          providers,  

				RepositoryConfig: settings.RepositoryConfig,  

				RepositoryCache:  settings.RepositoryCache,  

				Debug:            settings.Debug,  

				RegistryClient:   installClient.GetRegistryClient(),  

			}  

			if err := manager.Update(); err != nil {  

				return err  

			}  

			// Reload the chart with the updated Chart.lock file.  

			if charter, err = loader.Load(chartPath); err != nil {  

				return fmt.Errorf("failed to reload chart after repo update: %w", err)  

			}  

		}  

	}  

  

	_, err = installClient.RunWithContext(ctx, charter, releaseValues)  

	if err != nil {  

		return fmt.Errorf("failed to run install: %w", err)  

	}  

  

	logger.Printf("release created")  

  

	return nil  

}  
```

--------------------------------

### Example helm install output with NOTES.txt

Source: https://helm.sh/docs/chart_template_guide/notes_files

The terminal output displayed after running 'helm install' when a NOTES.txt file is present in the chart.

```text

RESOURCES:  

==> v1/Secret  

NAME                   TYPE      DATA      AGE  

rude-cardinal-secret   Opaque    1         0s  

  

==> v1/ConfigMap  

NAME                      DATA      AGE  

rude-cardinal-configmap   3         0s  

  

  

NOTES:  

Thank you for installing mychart.  

  

Your release is named rude-cardinal.  

  

To learn more about the release, try:  

  

  $ helm status rude-cardinal  

  $ helm get all rude-cardinal  


```

--------------------------------

### Install a Helm chart

Source: https://helm.sh/docs/intro/using_helm

Installs a packaged Helm chart from a .tgz file.

```bash
$ helm install deis-workflow ./deis-workflow-0.1.0.tgz  

...  
```

--------------------------------

### Install Plugin in Dev Mode

Source: https://helm.sh/docs/plugins/developer/tutorial-cli-plugin

Install the plugin from the local filesystem to enable development mode.

```bash
% helm plugin install $HOME/code/helm/plugins/system-info  

Installing plugin from local directory (development mode)  

Installed plugin: system-info  
```

--------------------------------

### Install a Helm chart with 'helm install'

Source: https://helm.sh/docs/intro/using_helm

Installs a new package by specifying a release name and the chart name. The command outputs deployment details and access instructions.

```bash
$ helm install happy-panda bitnami/wordpress  

NAME: happy-panda  

LAST DEPLOYED: Tue Jan 26 10:27:17 2021  

NAMESPACE: default  

STATUS: deployed  

REVISION: 1  

NOTES:  

** Please be patient while the chart is being deployed **  

  

Your WordPress site can be accessed through the following DNS name from within your cluster:  

  

    happy-panda-wordpress.default.svc.cluster.local (port 80)  

  

To access your WordPress site from outside the cluster follow the steps below:  

  

1. Get the WordPress URL by running these commands:  

  

  NOTE: It may take a few minutes for the LoadBalancer IP to be available.  

        Watch the status with: 'kubectl get svc --namespace default -w happy-panda-wordpress'  

  

   export SERVICE_IP=$(kubectl get svc --namespace default happy-panda-wordpress --template "{{ range (index .status.loadBalancer.ingress 0) }}{{.}}{{ end }}")  

   echo "WordPress URL: http://$SERVICE_IP/"  

   echo "WordPress Admin URL: http://$SERVICE_IP/admin"  

  

2. Open a browser and access WordPress using the obtained URL.  

  

3. Login with the following credentials below to see your blog:  

  

  echo Username: user  

  echo Password: $(kubectl get secret --namespace default happy-panda-wordpress -o jsonpath="{.data.wordpress-password}" | base64 --decode)
```

--------------------------------

### Install and verify a Helm chart

Source: https://helm.sh/docs/topics/provenance

Installs a chart while simultaneously verifying its provenance.

```bash
$ helm install --generate-name --verify mychart-0.1.0.tgz  
```

--------------------------------

### Install Helm via pkg

Source: https://helm.sh/docs/intro/install

Install Helm on FreeBSD using the Ports Collection.

```bash
pkg install helm  
```

--------------------------------

### Verify Plugin Installation

Source: https://helm.sh/docs/plugins/developer/tutorial-getter-plugin

Commands to list installed plugins and verify the symlink creation.

```bash
% ls -lah $(helm env HELM_PLUGINS)  

total 0  

drwxr-xr-x@ 4 r6by  staff   160B Nov 10 04:04 .  

drwxr-xr-x@ 3 r6by  staff    96B Jan 21  2025 ..  

lrwxr-xr-x  1 r6by  staff    41B Nov 10 04:04 demo-getter -> /Users/r6by/code/helm/plugins/demo-getter  

lrwxr-xr-x  1 r6by  staff    41B Nov 10 02:18 system-info -> /Users/r6by/code/helm/plugins/system-info  
```

```bash
% helm plugin list  

NAME          	VERSION	TYPE           	APIVERSION	PROVENANCE	SOURCE  

demo-getter   	0.1.0  	getter/v1      	v1        	local dev 	unknown  

system-info   	0.1.0  	cli/v1         	v1        	local dev 	unknown  
```

--------------------------------

### Install the chart

Source: https://helm.sh/docs/topics/library_charts

Deploy the chart to the cluster.

```bash
$ helm install mydemo mychart/  

NAME: mydemo  

LAST DEPLOYED: Tue Mar  3 17:52:40 2020  

NAMESPACE: default  

STATUS: deployed  

REVISION: 1  

TEST SUITE: None  
```

--------------------------------

### Install Helm via Snap

Source: https://helm.sh/docs/intro/install

Install the Snap version of Helm using the --classic flag.

```bash
sudo snap install helm --classic  
```

--------------------------------

### Install Helm via Winget

Source: https://helm.sh/docs/intro/install

Use the Winget package manager to install Helm on Windows.

```bash
winget install Helm.Helm  
```

--------------------------------

### Install Helm via Apt

Source: https://helm.sh/docs/intro/install

Install Helm on Debian or Ubuntu systems by adding the Buildkite repository.

```bash
HELM_BUILDKITE_APT_KEY_ID="DDF78C3E6EBB2D2CC223C95C62BA89D07698DBC6"  

  

sudo apt-get install curl gpg apt-transport-https --yes  

  

curl -fsSL https://packages.buildkite.com/helm-linux/helm-debian/gpgkey > "${TMPDIR:-/tmp}/helm.gpg"  

  

# Ensure that the key ID matches to prevent a repository compromise from establishing an attacker controlled key  

if [ "$(gpg --show-keys --with-colons "${TMPDIR:-/tmp}/helm.gpg" | awk -F: '$1 == "fpr" {print $10}' | head -n 1)" != "${HELM_BUILDKITE_APT_KEY_ID}" ]; then echo "ERROR: Unexpected Helm APT key ID: potential key compromise"; exit 1; fi  

  

cat "${TMPDIR:-/tmp}/helm.gpg" | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null  

echo "deb [signed-by=/usr/share/keyrings/helm.gpg] https://packages.buildkite.com/helm-linux/helm-debian/any/ any main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list  

  

sudo apt-get update  

sudo apt-get install helm  
```

--------------------------------

### Install and run Helm tests

Source: https://helm.sh/docs/topics/chart_tests

Commands to install the 'demo' chart and execute the defined test suite, followed by the expected output showing the test phase.

```bash
$ helm install demo demo --namespace default  

$ helm test demo  

NAME: demo  

LAST DEPLOYED: Mon Feb 14 20:03:16 2022  

NAMESPACE: default  

STATUS: deployed  

REVISION: 1  

TEST SUITE:     demo-test-connection  

Last Started:   Mon Feb 14 20:35:19 2022  

Last Completed: Mon Feb 14 20:35:23 2022  

Phase:          Succeeded  

[...]  
```

--------------------------------

### Install the Helm chart

Source: https://helm.sh/docs/chart_template_guide/getting_started

Command to install the chart from the local directory and the resulting deployment output.

```bash
$ helm install full-coral ./mychart  

NAME: full-coral  

LAST DEPLOYED: Tue Nov  1 17:36:01 2016  

NAMESPACE: default  

STATUS: DEPLOYED  

REVISION: 1  

TEST SUITE: None  
```

--------------------------------

### Install Helm via script

Source: https://helm.sh/docs/intro/install

Commands to download, set permissions for, and execute the official Helm installer script.

```bash
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-4

chmod 700 get_helm.sh

./get_helm.sh
```

--------------------------------

### helm get help options

Source: https://helm.sh/docs/helm/helm_get

Displays the help information for the helm get command.

```bash
  -h, --help   help for get  
```

--------------------------------

### Install chart with digest

Source: https://helm.sh/docs/topics/registries

Use a digest in the chart URI to ensure an immutable and secure installation.

```bash
$ helm install myrelease oci://localhost:5000/helm-charts/mychart@sha256:52ccaee6d4dd272e54bfccda77738b42e1edf0e4a20c27e23f0b6c15d01aef79  

NAME: myrelease  

LAST DEPLOYED: Wed Oct 27 15:11:40 2021  

NAMESPACE: default  

STATUS: deployed  

REVISION: 1  

NOTES:  

...  
```

--------------------------------

### helm plugin install

Source: https://helm.sh/docs/helm/helm_plugin_install

Installs a Helm plugin from a specified path or URL.

```APIDOC
## helm plugin install

### Description
Installs a Helm plugin from a URL to a VCS repo or a local path. By default, it verifies plugin signatures for tarballs unless --verify=false is used.

### Usage
`helm plugin install [options] <path|url> [flags]`

### Options
- **--ca-file** (string) - Verify certificates of HTTPS-enabled servers using this CA bundle
- **--cert-file** (string) - Identify registry client using this SSL certificate file
- **--insecure-skip-tls-verify** (bool) - Skip TLS certificate checks for the plugin download
- **--key-file** (string) - Identify registry client using this SSL key file
- **--keyring** (string) - Location of public keys used for verification (default "~/.gnupg/pubring.gpg")
- **--password** (string) - Registry password
- **--plain-http** (bool) - Use insecure HTTP connections for the plugin download
- **--username** (string) - Registry username
- **--verify** (bool) - Verify the plugin signature before installing (default true)
- **--version** (string) - Specify a version constraint
```

--------------------------------

### Install Helm via Scoop

Source: https://helm.sh/docs/intro/install

Use the Scoop package manager to install Helm on Windows.

```bash
scoop install helm  
```

--------------------------------

### helm plugin install command syntax

Source: https://helm.sh/docs/helm/helm_plugin_install

The basic command structure for installing a Helm plugin.

```bash
helm plugin install [options] <path|url> [flags]
```

--------------------------------

### Verify Plugin Installation

Source: https://helm.sh/docs/plugins/developer/tutorial-cli-plugin

Commands to verify the plugin symlink, list installed plugins, and check help documentation.

```bash
% ls -lah $(helm env HELM_PLUGINS)  

total 0  

drwxr-xr-x@ 3 r6by  staff    96B Nov 10 02:18 .  

drwxr-xr-x@ 3 r6by  staff    96B Jan 21  2025 ..  

lrwxr-xr-x  1 r6by  staff    41B Nov 10 02:18 system-info -> /Users/r6by/code/helm/plugins/system-info  
```

```bash
% helm plugin list  

NAME       	VERSION	TYPE  	APIVERSION	PROVENANCE	SOURCE  

system-info	0.1.0  	cli/v1	v1        	local dev 	unknown  
```

```bash
% helm help | grep system-info  

  system-info Display system and Helm information  

  

% helm help system-info  

Shows OS info, Helm version, and environment details  

  

Usage:  

  helm system-info [flags]  
```

--------------------------------

### Install a chart from an OCI registry

Source: https://helm.sh/docs/intro/quickstart

Install a chart directly from an OCI-compliant registry using the oci:// prefix.

```bash
$ helm install my-podinfo oci://ghcr.io/stefanprodan/charts/podinfo --version 6.11.2  

Pulled: ghcr.io/stefanprodan/charts/podinfo:6.11.2  

NAME: my-podinfo  

LAST DEPLOYED: Sat May  3 12:05:00 2026  

NAMESPACE: default  

STATUS: deployed  

REVISION: 1  

NOTES: ...  
```

--------------------------------

### Verify installation with port-forward and curl

Source: https://helm.sh/docs/intro/quickstart

Forward the service port to test the endpoint and verify the installation is working.

```bash
$ kubectl port-forward svc/my-podinfo 9898:9898 &  

$ curl http://localhost:9898  

{  

  "hostname": "podinfo-6f89b4c6b5-xvwtb",  

  "version": "6.7.1",  

  "message": "greetings from podinfo v6.7.1",  

  "goos": "linux",  

  "goarch": "amd64",  

  ...  

}  
```

--------------------------------

### Example Provenance File Format

Source: https://helm.sh/docs/topics/provenance

This example illustrates the structure of a provenance file, containing the Chart.yaml content, a checksum map, and a PGP signature block.

```text

Hash: SHA512  

  

apiVersion: v2  

appVersion: "1.16.0"  

description: Sample chart  

name: mychart  

type: application  

version: 0.1.0  

  

...  

files:  

  mychart-0.1.0.tgz: sha256:d31d2f08b885ec696c37c7f7ef106709aaf5e8575b6d3dc5d52112ed29a9cb92  

-----BEGIN PGP SIGNATURE-----  

  

wsBcBAEBCgAQBQJdy0ReCRCEO7+YH8GHYgAAfhUIADx3pHHLLINv0MFkiEYpX/Kd  

nvHFBNps7hXqSocsg0a9Fi1LRAc3OpVh3knjPfHNGOy8+xOdhbqpdnB+5ty8YopI  

mYMWp6cP/Mwpkt7/gP1ecWFMevicbaFH5AmJCBihBaKJE4R1IX49/wTIaLKiWkv2  

cR64bmZruQPSW83UTNULtdD7kuTZXeAdTMjAK0NECsCz9/eK5AFggP4CDf7r2zNi  

hZsNrzloIlBZlGGns6mUOTO42J/+JojnOLIhI3Psd0HBD2bTlsm/rSfty4yZUs7D  

qtgooNdohoyGSzR5oapd7fEvauRQswJxOA0m0V+u9/eyLR0+JcYB8Udi1prnWf8=  

=aHfz  

-----END PGP SIGNATURE-----  



```

--------------------------------

### Install and Uninstall App Commands

Source: https://helm.sh/docs/intro/CheatSheet

Commands for installing charts with various configurations and uninstalling releases.

```bash
helm install <name> <chart>                           # Install the chart with a name

helm install <name> <chart> --namespace <namespace>   # Install the chart in a specific namespace

helm install <name> <chart> --set key1=val1,key2=val2 # Set values on the command line (can specify multiple or separate values with commas)

helm install <name> <chart> --values <yaml-file/url>  # Install the chart with your specified values

helm install <name> <chart> --dry-run --debug         # Run a test installation to validate chart (p)

helm install <name> <chart> --verify                  # Verify the package before using it

helm install <name> <chart> --dependency-update       # update dependencies if they are missing before installing the chart

helm install <name> <chart> --force-replace           # force resource updates by replacement

helm uninstall <name>                                 # Uninstalls a release from the current (default) namespace

helm uninstall <release-name> --namespace <namespace> # Uninstalls a release from the specified namespace
```

--------------------------------

### Install Helm via Chocolatey

Source: https://helm.sh/docs/intro/install

Use the Chocolatey package manager to install Helm on Windows.

```bash
choco install kubernetes-helm  
```

--------------------------------

### Install a plugin from a remote URL

Source: https://helm.sh/docs/topics/plugins

Use the helm plugin install command to clone a plugin from a remote VCS repository.

```bash
$ helm plugin install https://github.com/adamreese/helm-env
```

--------------------------------

### helm plugin install options

Source: https://helm.sh/docs/helm/helm_plugin_install

Available flags for configuring the plugin installation process, including verification and authentication settings.

```bash
      --ca-file string             verify certificates of HTTPS-enabled servers using this CA bundle  

      --cert-file string           identify registry client using this SSL certificate file  

  -h, --help                       help for install  

      --insecure-skip-tls-verify   skip tls certificate checks for the plugin download  

      --key-file string            identify registry client using this SSL key file  

      --keyring string             location of public keys used for verification (default "~/.gnupg/pubring.gpg")  

      --password string            registry password  

      --plain-http                 use insecure HTTP connections for the plugin download  

      --username string            registry username  

      --verify                     verify the plugin signature before installing (default true)  

      --version string             specify a version constraint. If this is not specified, the latest version is installed
```

--------------------------------

### Install Helm via script one-liner

Source: https://helm.sh/docs/intro/install

A shorthand command to pipe the installer script directly into bash.

```bash
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-4 | bash
```

--------------------------------

### Example values.yaml

Source: https://helm.sh/docs/topics/charts

A sample values.yaml file that satisfies the defined schema requirements.

```yaml
name: frontend

protocol: https

port: 443
```

--------------------------------

### Install chart with custom values file

Source: https://helm.sh/docs/intro/using_helm

Create a YAML file with overrides and pass it to the helm install command using the -f flag.

```bash
$ echo '{mariadb.auth.database: user0db, mariadb.auth.username: user0}' > values.yaml  

$ helm install -f values.yaml bitnami/wordpress --generate-name
```

--------------------------------

### Create a chart using a starter pack

Source: https://helm.sh/docs/topics/charts

Use the helm create command with the --starter or -p option to initialize a new chart from a starter pack. You can specify the starter by name or by an absolute path.

```bash
helm create my-chart --starter starter-name  

helm create my-chart -p starter-name  

helm create my-chart -p /absolute/path/to/starter-name
```

--------------------------------

### Helm SDK Driver Implementation in Go

Source: https://helm.sh/docs/sdk/examples

This example provides the necessary auxiliary functions and a main workflow to interact with Helm SDK actions. It covers initializing the action configuration, setting up a registry client, and executing a full chart lifecycle.

```go
package main  
  
  

import (  

	"bufio"  

	"context"  

	"fmt"  

	"log"  

	"net/http"  

	"os"  

  

	"helm.sh/helm/v4/pkg/action"  

	"helm.sh/helm/v4/pkg/cli"  

	"helm.sh/helm/v4/pkg/registry"  

)  

  

var helmDriver string = os.Getenv("HELM_DRIVER")  

  

func initActionConfig(settings *cli.EnvSettings, logger *log.Logger) (*action.Configuration, error) {  

	return initActionConfigList(settings, logger, false)  

}  

  

func initActionConfigList(settings *cli.EnvSettings, logger *log.Logger, allNamespaces bool) (*action.Configuration, error) {  

  

actionConfig := new(action.Configuration)  

  

namespace := func() string {  

	// For list action, you can pass an empty string instead of settings.Namespace() to list  

	// all namespaces  

	if allNamespaces {  

		return ""  

	}  

	return settings.Namespace()  

}()  

  

if err := actionConfig.Init(  

	settings.RESTClientGetter(),  

	namespace,  

	helmDriver); err != nil {  

	return nil, err  

}  

  

return actionConfig, nil  

}  

  

func newRegistryClient(settings *cli.EnvSettings, certFile, keyFile, caFile string, insecureSkipTLSVerify, plainHTTP bool) (*registry.Client, error) {  

  

opts := []registry.ClientOption{  

	registry.ClientOptDebug(settings.Debug),  

	registry.ClientOptEnableCache(true),  

	registry.ClientOptWriter(os.Stderr),  

	registry.ClientOptCredentialsFile(settings.RegistryConfig),  

}  

  

if plainHTTP {  

	opts = append(opts, registry.ClientOptPlainHTTP())  

}  

  

if certFile != "" && keyFile != "" || caFile != "" || insecureSkipTLSVerify {  

	tlsConf, err := NewTLSConfig(  

		WithInsecureSkipVerify(insecureSkipTLSVerify),  

		WithCertKeyPairFiles(certFile, keyFile),  

		WithCAFile(caFile),  

	)  

	if err != nil {  

		return nil, fmt.Errorf("failed to load client TLS certs: %w", err)  

	}  

  

	opts = append(opts, registry.ClientOptHTTPClient(&http.Client{  

		Transport: &http.Transport{  

			TLSClientConfig: tlsConf,  

			Proxy:           http.ProxyFromEnvironment,  

		},  

	}))  

}  

  

// Create a new registry client  

registryClient, err := registry.NewClient(opts...)  

if err != nil {  

	return nil, fmt.Errorf("failed to initialize registry client: %w", err)  

}  

  

return registryClient, nil  

}  

  

func main() {  

  

logger := log.Default()  

  

// For convenience, initialize SDK setting via CLI mechanism  

settings := cli.New()  

  

// Release name, chart and values  

releaseName := "helm-sdk-example"  

chartRef := "oci://ghcr.io/stefanprodan/charts/podinfo"  

releaseValues := map[string]interface{}{  

	"replicaCount": "2",  

}  

  

// Pull the chart to the local filesystem  

if err := runPull(logger, settings, chartRef, "6.4.1"); err != nil {  

	fmt.Printf("failed to run pull: %+v", err)  

	os.Exit(1)  

}  

  

// Install the chart (from the pulled chart local archive)  

if err := runInstall(context.TODO(), logger, settings, releaseName, "./podinfo-6.4.1.tgz", "", releaseValues); err != nil {  

	fmt.Printf("failed to run install: %+v", err)  

	os.Exit(1)  

}  

  

// List installed charts  

if err := runList(logger, settings); err != nil {  

	fmt.Printf("failed to run list: %+v", err)  

	os.Exit(1)  

}  

  

//  

fmt.Print("Chart installed. Press 'Return' to continue...")  

bufio.NewReader(os.Stdin).ReadBytes('\n')  

  

// Upgrade to version 6.5.4, updating the replicaCount to three  

releaseValues["replicaCount"] = "3"  

if err := runUpgrade(context.TODO(), logger, settings, releaseName, chartRef, "6.5.4", releaseValues); err != nil {  

	fmt.Printf("failed to run upgrade: %+v", err)  

	os.Exit(1)  

}  

  

// List installed charts  

if err := runList(logger, settings); err != nil {  

	fmt.Printf("failed to run list: %+v", err)  

	os.Exit(1)  

}  

  

//  

fmt.Print("Chart upgraded. Press 'Return' to continue...")  

bufio.NewReader(os.Stdin).ReadBytes('\n')  

  

// Uninstall the chart  

if err := runUninstall(logger, settings, releaseName); err != nil {  

	fmt.Printf("failed to run uninstall: %+v", err)  

	os.Exit(1)  

}  

}
```

--------------------------------

### List Helm releases using Go SDK

Source: https://helm.sh/docs/sdk/gosdk

This example demonstrates how to perform a 'helm list' operation using the action package. It initializes the action configuration with standard Helm environment settings and iterates through deployed releases.

```go
package main  
  
  

import (  

    "log"  

    "os"  

  

    "helm.sh/helm/v4/pkg/action"  

    "helm.sh/helm/v4/pkg/cli"  

)  

  

func main() {  

    settings := cli.New()  

  

    actionConfig := new(action.Configuration)  

    // You can pass an empty string instead of settings.Namespace() to list  

    // all namespaces  

    if err := actionConfig.Init(settings.RESTClientGetter(), settings.Namespace(), os.Getenv("HELM_DRIVER"), log.Printf); err != nil {  

        log.Printf("%+v", err)  

        os.Exit(1)  

    }  

  

    client := action.NewList(actionConfig)  

    // Only list deployed  

    client.Deployed = true  

    results, err := client.Run()  

    if err != nil {  

        log.Printf("%+v", err)  

        os.Exit(1)  

    }  

  

    for _, rel := range results {  

        log.Printf("%+v", rel)  

    }  

}  

  
```

--------------------------------

### Install Helm via Homebrew

Source: https://helm.sh/docs/intro/install

Use Homebrew to install Helm on macOS.

```bash
brew install helm  
```

--------------------------------

### Upgrade a Helm Release

Source: https://helm.sh/docs/sdk/examples

This example demonstrates how to upgrade a release using the action.NewUpgrade client. It includes logic for locating the chart, checking dependencies, and handling registry authentication.

```go
package main  
  
  

import (  

	"context"  

	"fmt"  

	"log"  

  

	"helm.sh/helm/v4/pkg/action"  

	"helm.sh/helm/v4/pkg/chart"  

	"helm.sh/helm/v4/pkg/chart/loader"  

	"helm.sh/helm/v4/pkg/cli"  

	"helm.sh/helm/v4/pkg/downloader"  

	"helm.sh/helm/v4/pkg/getter"  

)  

  

func runUpgrade(ctx context.Context, logger *log.Logger, settings *cli.EnvSettings, releaseName string, chartRef string, chartVersion string, releaseValues map[string]interface{}) error {  

	actionConfig, err := initActionConfig(settings, logger)  

	if err != nil {  

		return fmt.Errorf("failed to init action config: %w", err)  

	}  

  

	upgradeClient := action.NewUpgrade(actionConfig)  

  

	upgradeClient.Namespace = settings.Namespace()  

	upgradeClient.DryRunStrategy = "none"  

	upgradeClient.Version = chartVersion  

	upgradeClient.WaitStrategy = "watcher"  

  

	registryClient, err := newRegistryClient(  

		settings,  

		upgradeClient.CertFile,  

		upgradeClient.KeyFile,  

		upgradeClient.CaFile,  

		upgradeClient.InsecureSkipTLSVerify,  

		upgradeClient.PlainHTTP)  

	if err != nil {  

		return fmt.Errorf("missing registry client: %w", err)  

	}  

	upgradeClient.SetRegistryClient(registryClient)  

  

	chartPath, err := upgradeClient.ChartPathOptions.LocateChart(chartRef, settings)  

	if err != nil {  

		return err  

	}  

  

	providers := getter.All(settings)  

  

	// Check chart dependencies to make sure all are present in /charts  

	charter, err := loader.Load(chartPath)  

	if err != nil {  

		return fmt.Errorf("failed to load chart: %w", err)  

	}  

  

	chartAccessor, err := chart.NewDefaultAccessor(charter)  

	if err != nil {  

		return fmt.Errorf("error creating chart accessor: %w", err)  

	}  

  

	if chartDependencies := chartAccessor.MetaDependencies(); chartDependencies != nil {  

		if err := action.CheckDependencies(charter, chartDependencies); err != nil {  

			err = fmt.Errorf("failed to check chart dependencies: %w", err)  

			if !upgradeClient.DependencyUpdate {  

				return err  

			}  

  

			man := &downloader.Manager{  

				Out:              logger.Writer(),  

				ChartPath:        chartPath,  

				Keyring:          upgradeClient.ChartPathOptions.Keyring,  

				SkipUpdate:       false,  

				Getters:          providers,  

				RepositoryConfig: settings.RepositoryConfig,  

				RepositoryCache:  settings.RepositoryCache,  

				Debug:            settings.Debug,  

			}  

			if err := man.Update(); err != nil {  

				return err  

			}  

			// Reload the chart with the updated Chart.lock file.  

			if charter, err = loader.Load(chartPath); err != nil {  

				return fmt.Errorf("failed to reload chart after repo update: %w", err)  

			}  

		}  

	}  

  

	release, err := upgradeClient.RunWithContext(ctx, releaseName, charter, releaseValues)  

	if err != nil {  

		return fmt.Errorf("failed to run upgrade action: %w", err)  

	}  

  

	logger.Printf("release: %+v", release)  

  

	return nil  

}
```

--------------------------------

### Verify Helm installation

Source: https://helm.sh/docs/intro/install

Command to verify the Helm client is installed and accessible.

```bash
helm help
```

--------------------------------

### Example .helmignore file configuration

Source: https://helm.sh/docs/chart_template_guide/helm_ignore_file

A sample .helmignore file demonstrating various glob patterns for excluding files and directories from a Helm chart.

```text

# comment  

  

# Match any file or path named .helmignore  

.helmignore  

  

# Match any file or path named .git  

.git  

  

# Match any text file  

*.txt  

  

# Match only directories named mydir  

mydir/  

  

# Match only text files in the top-level directory  

/*.txt  

  

# Match only the file foo.txt in the top-level directory  

/foo.txt  

  

# Match any file named ab.txt, ac.txt, or ad.txt  

a[b-d].txt  

  

# Match any file under subdir matching draft*  

*/draft*  

  

# Match draft files two levels deep (e.g., foo/bar/draft123)  

*/*/draft*  

draft?  



```

--------------------------------

### Build Helm from Source

Source: https://helm.sh/docs/intro/install

Clone the Helm repository and build the binary from source. Requires a working Go environment.

```bash
git clone https://github.com/helm/helm.git  

cd helm  

make  
```

--------------------------------

### Implementing plugin.complete as a wrapper

Source: https://helm.sh/docs/topics/plugins

This example shows how to implement plugin.complete by calling the main plugin script with a special flag to handle completion logic.

```bash
#!/usr/bin/env sh  
  
# "$@" is the entire command-line that requires completion.  
# It is important to double-quote the "$@" variable to preserve a possibly empty last parameter.  
$HELM_PLUGIN_DIR/status.sh --complete "$@"  
```

--------------------------------

### Helm install command output

Source: https://helm.sh/docs/chart_template_guide/getting_started

The output displayed after installing a chart with a release name.

```text
$ helm install clunky-serval ./mychart  

NAME: clunky-serval  

LAST DEPLOYED: Tue Nov  1 17:45:37 2016  

NAMESPACE: default  

STATUS: DEPLOYED  

REVISION: 1  

TEST SUITE: None  
```

--------------------------------

### Helm chart directory structure example

Source: https://helm.sh/docs/helm/helm_create

Visual representation of the directory structure created by running 'helm create foo'.

```text
foo/  

├── .helmignore   # Contains patterns to ignore when packaging Helm charts.  

├── Chart.yaml    # Information about your chart  

├── values.yaml   # The default values for your templates  

├── charts/       # Charts that this chart depends on  

└── templates/    # The template files  

    └── tests/    # The test files
```

--------------------------------

### helm get all command syntax

Source: https://helm.sh/docs/helm/helm_get_all

The basic syntax for executing the helm get all command.

```bash
helm get all RELEASE_NAME [flags]
```

--------------------------------

### Failing Scope Example

Source: https://helm.sh/docs/chart_template_guide/variables

An example demonstrating how accessing .Release.Name fails when restricted by a with block.

```yaml
  {{- with .Values.favorite }}  

  drink: {{ .drink | default "tea" | quote }}  

  food: {{ .food | upper | quote }}  

  release: {{ .Release.Name }}  

  {{- end }}  
```

--------------------------------

### Create a demo Helm chart

Source: https://helm.sh/docs/topics/chart_tests

Initializes a new Helm chart named 'demo' to explore the directory structure and test functionality.

```bash
$ helm create demo  
```

--------------------------------

### Example completion.yaml for fullstatus plugin

Source: https://helm.sh/docs/topics/plugins

A sample configuration for a plugin named fullstatus that accepts output and revision flags.

```yaml
name: fullstatus  

flags:  

- o  

- output  

- revision
```

--------------------------------

### Dry-run chart installation

Source: https://helm.sh/docs/topics/library_charts

Check the rendered template output without actually installing the chart.

```bash
$ helm install mydemo mychart/ --debug --dry-run  

install.go:159: [debug] Original chart version: ""  

install.go:176: [debug] CHART PATH: /root/test/helm-charts/mychart  

  

NAME: mydemo  

LAST DEPLOYED: Tue Mar  3 17:48:47 2020  

NAMESPACE: default  

STATUS: pending-install  

REVISION: 1  

TEST SUITE: None  

USER-SUPPLIED VALUES:  

{}  

  

COMPUTED VALUES:  

affinity: {}  

fullnameOverride: ""  

image:  

  pullPolicy: IfNotPresent  

  repository: nginx  

imagePullSecrets: []  

ingress:  

  annotations: {}  

  enabled: false  

  hosts:  

  - host: chart-example.local  

    paths: []  

  tls: []  

mylibchart:  

  global: {}  

nameOverride: ""  

nodeSelector: {}  

podSecurityContext: {}  

replicaCount: 1  

resources: {}  

securityContext: {}  

service:  

  port: 80  

  type: ClusterIP  

serviceAccount:  

  annotations: {}  

  create: true  

  name: null  

tolerations: []  

  

HOOKS:  

MANIFEST:  

---  

# Source: mychart/templates/configmap.yaml  

apiVersion: v1  

data:  

  myvalue: Hello World  

kind: ConfigMap  

metadata:  

  labels:  

    app: mychart  

    chart: mychart-0.1.0  

    release: mydemo  

  name: mychart-mydemo  
```

--------------------------------

### Example index.yaml File

Source: https://helm.sh/docs/topics/chart_repository

A sample index.yaml file containing metadata for multiple versions of the alpine chart and an nginx chart.

```yaml
apiVersion: v1  

entries:  

  alpine:  

    - created: 2016-10-06T16:23:20.499814565-06:00  

      description: Deploy a basic Alpine Linux pod  

      digest: 99c76e403d752c84ead610644d4b1c2f2b453a74b921f422b9dcb8a7c8b559cd  

      home: https://helm.sh/helm  

      name: alpine  

      sources:  

      - https://github.com/helm/helm  

      urls:  

      - https://technosophos.github.io/tscharts/alpine-0.2.0.tgz  

      version: 0.2.0  

    - created: 2016-10-06T16:23:20.499543808-06:00  

      description: Deploy a basic Alpine Linux pod  

      digest: 515c58e5f79d8b2913a10cb400ebb6fa9c77fe813287afbacf1a0b897cd78727  

      home: https://helm.sh/helm  

      name: alpine  

      sources:  

      - https://github.com/helm/helm  

      urls:  

      - https://technosophos.github.io/tscharts/alpine-0.1.0.tgz  

      version: 0.1.0  

  nginx:  

    - created: 2016-10-06T16:23:20.499543808-06:00  

      description: Create a basic nginx HTTP server  

      digest: aaff4545f79d8b2913a10cb400ebb6fa9c77fe813287afbacf1a0b897cdffffff  

      home: https://helm.sh/helm  

      name: nginx  

      sources:  

      - https://github.com/helm/charts  

      urls:  

      - https://technosophos.github.io/tscharts/nginx-1.1.0.tgz  

      version: 1.1.0  

generated: 2016-10-06T16:23:20.499029981-06:00
```

--------------------------------

### Example templates/NOTES.txt file

Source: https://helm.sh/docs/chart_template_guide/notes_files

A basic template file that uses Helm template objects to display the chart name and release name to the user.

```text

Thank you for installing {{ .Chart.Name }}.  

  

Your release is named {{ .Release.Name }}.  

  

To learn more about the release, try:  

  

  $ helm status {{ .Release.Name }}  

  $ helm get all {{ .Release.Name }}  

  


```

--------------------------------

### helm registry help options

Source: https://helm.sh/docs/helm/helm_registry

Displays the available help options for the helm registry command.

```bash

  -h, --help   help for registry  


```

--------------------------------

### Uninstall a Helm Release

Source: https://helm.sh/docs/sdk/examples

This example shows how to uninstall a release using the action.NewUninstall client, including configuration for deletion propagation and wait strategies.

```go
package main  
  
  

import (  

	"fmt"  

	"log"  

  

	"helm.sh/helm/v4/pkg/action"  

	"helm.sh/helm/v4/pkg/cli"  

)  

  

func runUninstall(logger *log.Logger, settings *cli.EnvSettings, releaseName string) error {  

  

	actionConfig, err := initActionConfig(settings, logger)  

	if err != nil {  

		return fmt.Errorf("failed to init action config: %w", err)  

	}  

  

	uninstallClient := action.NewUninstall(actionConfig)  

	uninstallClient.DeletionPropagation = "foreground" // "background" or "orphan"  

	uninstallClient.WaitStrategy = "watcher"  

  

	result, err := uninstallClient.Run(releaseName)  

	if err != nil {  

		return fmt.Errorf("failed to run uninstall action: %w", err)  

	}  

	if result != nil {  

		logger.Printf("result: %+v\n", result.Info)  

	}  

  

	logger.Printf("release \"%s\" uninstalled\n", releaseName)  

  

	return nil  

}
```

--------------------------------

### Verify a plugin during installation

Source: https://helm.sh/docs/plugins/migrate

Use the --verify flag when installing a plugin tarball to ensure provenance.

```bash
helm plugin install https://example.com/myplugin.tgz --verify
```

--------------------------------

### Install Helm via dnf/yum

Source: https://helm.sh/docs/intro/install

Install Helm on Fedora 35 or later using the official repository.

```bash
sudo dnf install helm  
```

--------------------------------

### Create a Charts v3 API Chart

Source: https://helm.sh/docs/overview

Initialize a new chart using the experimental v3 API version.

```bash
helm create --chart-api-version=v3 mychart
```

--------------------------------

### helm get metadata command syntax

Source: https://helm.sh/docs/helm/helm_get_metadata

The basic syntax for executing the helm get metadata command.

```bash
helm get metadata RELEASE_NAME [flags]
```

--------------------------------

### Display Helm version with template

Source: https://helm.sh/docs/helm/helm_version

Example of using the --template flag to output specific version properties.

```text
--template='Version: {{.Version}}'
```

--------------------------------

### helm get hooks command syntax

Source: https://helm.sh/docs/helm/helm_get_hooks

The basic syntax for executing the helm get hooks command.

```bash
helm get hooks RELEASE_NAME [flags]
```

--------------------------------

### Example values.yaml file

Source: https://helm.sh/docs/topics/charts

A standard YAML file used to define default configuration values for a Helm chart.

```yaml
imageRegistry: "quay.io/deis"

dockerTag: "latest"

pullPolicy: "Always"

storage: "s3"
```

--------------------------------

### Create Plugin Directory

Source: https://helm.sh/docs/plugins/developer/tutorial-postrenderer-plugin

Commands to create and navigate to the directory for the new plugin.

```bash
mkdir -p $HOME/code/helm/plugins/label-injector  

cd $HOME/code/helm/plugins/label-injector  

```

--------------------------------

### helm get inherited options

Source: https://helm.sh/docs/helm/helm_get

Lists the global options inherited from parent commands that can be used with helm get.

```bash
      --burst-limit int                 client-side default throttling limit (default 100)  

      --color string                    use colored output (never, auto, always) (default "auto")  

      --colour string                   use colored output (never, auto, always) (default "auto")  

      --content-cache string            path to the directory containing cached content (e.g. charts) (default "~/.cache/helm/content")  

      --debug                           enable verbose output  

      --kube-apiserver string           the address and the port for the Kubernetes API server  

      --kube-as-group stringArray       group to impersonate for the operation, this flag can be repeated to specify multiple groups.  

      --kube-as-user string             username to impersonate for the operation  

      --kube-ca-file string             the certificate authority file for the Kubernetes API server connection  

      --kube-context string             name of the kubeconfig context to use  

      --kube-insecure-skip-tls-verify   if true, the Kubernetes API server's certificate will not be checked for validity. This will make your HTTPS connections insecure  

      --kube-tls-server-name string     server name to use for Kubernetes API server certificate validation. If it is not provided, the hostname used to contact the server is used  

      --kube-token string               bearer token used for authentication  

      --kubeconfig string               path to the kubeconfig file  

  -n, --namespace string                namespace scope for this request  

      --qps float32                     queries per second used when communicating with the Kubernetes API, not including bursting  

      --registry-config string          path to the registry config file (default "~/.config/helm/registry/config.json")  

      --repository-cache string         path to the directory containing cached repository indexes (default "~/.cache/helm/repository")  

      --repository-config string        path to the file containing repository names and URLs (default "~/.config/helm/repositories.yaml")  
```

--------------------------------

### Verify library chart installation error

Source: https://helm.sh/docs/topics/library_charts

Attempt to install the library chart to confirm that Helm correctly identifies it as non-installable.

```bash
$ helm install mylibchart mylibchart/  

Error: library charts are not installable  

```

--------------------------------

### helm repo help options

Source: https://helm.sh/docs/helm/helm_repo

Displays the help options available for the helm repo command.

```bash
  -h, --help   help for repo  
```

--------------------------------

### helm get hooks options

Source: https://helm.sh/docs/helm/helm_get_hooks

Available flags for the helm get hooks command, including help and revision selection.

```bash
  -h, --help           help for hooks  

      --revision int   get the named release with revision
```

--------------------------------

### Sign a chart with helm package

Source: https://helm.sh/docs/helm/helm_package

Example command to package a chart and sign it using a PGP key.

```bash
$ helm package --sign ./mychart --key mykey --keyring ~/.gnupg/secring.gpg
```

--------------------------------

### Search for charts in repositories

Source: https://helm.sh/docs/helm/helm_search_repo

Examples of searching for charts using keywords, development versions, and semantic versioning constraints.

```bash
# Search for stable release versions matching the keyword "nginx"  

$ helm search repo nginx  

  

# Search for release versions matching the keyword "nginx", including pre-release versions  

$ helm search repo nginx --devel  

  

# Search for the latest stable release for nginx-ingress with a major version of 1  

$ helm search repo nginx-ingress --version ^1.0.0
```

--------------------------------

### helm get all command options

Source: https://helm.sh/docs/helm/helm_get_all

Available flags for the helm get all command, including revision selection and output templating.

```bash
  -h, --help              help for all  

      --revision int      get the named release with revision  

      --template string   go template for formatting the output, eg: {{.Release.Name}}
```
Tokens:
Raw