Minikube is a lightweight Kubernetes implementation that runs a single-node cluster on your local machine. It’s an excellent environment for testing and developing Kubernetes applications before deploying them to a larger, production-level Kubernetes cluster. Helm is a package manager for Kubernetes, and Terraform is an Infrastructure as Code (IaC) tool that can automate the deployment and management of your infrastructure. In this article, we’ll walk you through how to deploy a Helm chart in Minikube using Terraform.

Prerequisites

Before you begin, ensure that you have the following:

1. Minikube Installed: Minikube should be installed and running on your local machine. You can follow the official Minikube installation guide to get started.
2. Helm Installed: Helm should be installed on your machine. Download it from the Helm website.
3. Terraform Installed: Terraform should be installed. You can download it from the Terraform website.
4. kubectl Configured: Ensure kubectl is installed and configured to interact with your Minikube cluster.

Step 1: Start Minikube

First, start Minikube to ensure that your Kubernetes cluster is running:

minikube start

This command starts a single-node Kubernetes cluster locally.

Step 2: Initialize a Terraform Directory

Create a new directory for your Terraform configuration files:

mkdir terraform-minikube-helm
cd terraform-minikube-helm

Step 3: Create the Terraform Configuration File

In this directory, create a main.tf file. This file will define the Terraform configuration needed to deploy a Helm chart on Minikube.

touch main.tf

Open main.tf in your preferred text editor and add the following configuration:

# main.tf

provider "kubernetes" {
  config_path = "~/.kube/config"
}

provider "helm" {
  kubernetes {
    config_path = "~/.kube/config"
  }
}

resource "helm_release" "nginx" {
  name       = "my-nginx"
  repository = "https://charts.helm.sh/stable"
  chart      = "nginx-ingress"
  namespace  = "default"

  values = [
    <<EOF
controller:
  replicaCount: 1
EOF
  ]
}

Explanation of the Configuration

• provider “kubernetes”: This block configures Terraform to use the Kubernetes provider, which allows Terraform to interact with your Kubernetes cluster. The config_path points to your Kubernetes configuration file, typically located at ~/.kube/config.
• provider “helm”: This block configures Terraform to use the Helm provider. Like the Kubernetes provider, it uses your Kubernetes configuration file to interact with the cluster.
• resource “helm_release” “nginx”: This block defines a Helm release for the nginx-ingress chart. It includes the following details:
• name: The name of the Helm release.
• repository: The URL of the Helm chart repository.
• chart: The name of the chart to deploy (nginx-ingress in this case).
• namespace: The Kubernetes namespace where the chart will be deployed.
• values: Custom values for the Helm chart, provided as YAML.

Step 4: Initialize Terraform

Before applying your configuration, initialize Terraform in your project directory. This command downloads the necessary provider plugins:

terraform init

Step 5: Plan the Deployment

Next, run terraform plan to preview the changes that Terraform will apply. This step allows you to validate your configuration before making any changes to your environment:

terraform plan

Terraform will display a plan of the resources it will create, including the Helm release.

Step 6: Deploy the Helm Chart

After verifying the plan, apply the configuration to deploy the Helm chart to your Minikube cluster:

terraform apply

Terraform will prompt you to confirm the action. Type yes to proceed.

Terraform will then create the resources defined in your configuration, including the deployment of the nginx-ingress Helm chart.

Step 7: Verify the Deployment

Once Terraform has completed the deployment, you can verify that the Helm chart was successfully deployed using kubectl:

kubectl get all -l app.kubernetes.io/name=nginx-ingress

This command lists all resources associated with the nginx-ingress deployment, such as pods, services, and deployments.

You can also verify the Helm release using the Helm CLI:

helm list

This command should show your my-nginx release listed.

Step 8: Clean Up Resources

When you’re done and want to remove the deployed resources, you can use Terraform to clean up everything it created:

terraform destroy

This command will remove the Helm release and all associated Kubernetes resources from your Minikube cluster.

Conclusion

Deploying Helm charts using Terraform in a Minikube environment is a powerful way to manage your Kubernetes applications with Infrastructure as Code. This approach ensures consistency, version control, and automation in your development workflows. By integrating Helm with Terraform, you can easily manage and scale complex Kubernetes deployments in a controlled and repeatable manner.