# Install Helm

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/)
- [Get started with Helm on Google Axion C4A (Arm-based)](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/background/)
- [Create a Google Axion C4A virtual machine on Google Cloud](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/instance/)
- [Install Helm](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/installation/)
- [Validate Helm workflows on a Google Axion C4A virtual machine](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/baseline/)
- [Prepare a GKE cluster for Helm deployments](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/gke-cluster-for-helm/)
- [PostgreSQL Deployment Using Custom Helm Chart](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/postgresql-helm/)
- [Deploy Redis on GKE](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/redis-helm/)
- [Deploy NGINX with public access](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/nginx-helm/)
- [Benchmark Helm concurrency on a Google Axion C4A virtual machine](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/benchmarking/)
- [Next Steps](https://learn.arm.com/learning-paths/servers-and-cloud-computing/helm-on-gcp/_next-steps/)

## Set up your environment
In this section you’ll prepare a SUSE Linux Arm64 VM to work with Helm by installing Docker, kubectl, Helm, and KinD. After installation, you create and verify a local Kubernetes cluster for validating Helm workflows.

## Prepare the system
Update the system packages and install dependencies:
```
sudo zypper refresh
sudo zypper update -y
sudo zypper install -y curl git tar gzip
```

## Enable the SUSE Containers module
Enable the SUSE Containers Module to ensure that Docker and container-related tools are fully supported.
```
sudo SUSEConnect -p sle-module-containers/15.5/arm64
sudo SUSEConnect --list-extensions | grep Containers
```
Verify that the output shows the Containers module as **Activated**.

## Install Docker
Docker is required to run KinD and the Kubernetes control plane components. Install Docker, start the service, and add your user to the docker group:
```
sudo zypper refresh
sudo zypper install -y docker
sudo systemctl enable --now docker
sudo usermod -aG docker $USER
exit
```
Exit the current shell and reconnect to the virtual machine so that the group membership change takes effect. Then verify that Docker is running:
```
docker ps
```
Output similar to the following indicates that Docker is installed and accessible:
```
__output__
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
```

## Install kubectl
Install the kubectl command-line tool for interacting with Kubernetes clusters:
```
curl -LO https://dl.k8s.io/release/v1.30.1/bin/linux/arm64/kubectl
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
```

## Verify kubectl
Confirm that kubectl is installed and accessible from the command line:
```
kubectl version --client
```
Output similar to the following indicates that kubectl is installed correctly:
```
__output__
Client Version: v1.30.1
__output__
Kustomize Version: v5.0.4-0.20230601165947-6ce0bf390ce3
```

## Install Helm
Install Helm using the official Helm installation script to get a verified and up-to-date release.
```
curl -sSfL https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 > get_helm.sh
chmod 755 ./get_helm.sh
./get_helm.sh
```

## Verify Helm
Confirm that Helm is installed correctly and ready to use.
```
helm version
```
You should see an output similar to:
```
__output__
version.BuildInfo{Version:"v3.19.4", GitCommit:"7cfb6e486dac026202556836bb910c37d847793e", GitTreeState:"clean", GoVersion:"go1.24.11"}
```

## Install KinD
Install KinD (Kubernetes-in-Docker) to run a lightweight Kubernetes cluster locally:
```
curl -Lo kind https://kind.sigs.k8s.io/dl/v0.30.0/kind-linux-arm64
chmod +x kind
sudo mv kind /usr/local/bin/
```

## Create a local Kubernetes cluster
Create a cluster named helm-lab:
```
kind create cluster --name helm-lab
```

## Verify cluster status
Verify that the Kubernetes cluster is running correctly:
```
kubectl get nodes
```
You should see an output similar to:
```
__output__
NAME                     STATUS   ROLES           AGE   VERSION
__output__
helm-lab-control-plane   Ready    control-plane   23h   v1.34.0
```
The node should be in **Ready** state. If not, wait 30 seconds for the cluster to initialize and retry the command.

Your local Kubernetes cluster is now running on your Arm64 VM.

## What you’ve accomplished and what’s next
You’ve successfully set up your development environment by:
- Installing Docker, kubectl, and Helm on your Arm64 SUSE VM
- Creating a local Kubernetes cluster using KinD
- Verifying that all components are working correctly

Next, you’ll validate Helm functionality by performing install, upgrade, and uninstall workflows on your Arm64 Kubernetes cluster.