Introduction
We are going to explore how to play with Kubernetes infrastructure using Terraform. Kubernetes automates operational tasks of container management and includes built-in commands for deploying applications, rolling out changes to your applications, scaling your applications up and down to fit changing needs, monitoring your applications, and more
Prerequisites
Before we start, ensure that you have the following prerequisites:
A minikube, kubectl, is installed on your local machine
Terraform installed on your local machine
A basic understanding of Kubernetes concepts
Step 1: Set up your local Kubernetes environment
To test the deployment of your application on your local machine we need to install and start the services of minikube and kubectl.
Start your minikube:
minikube start --driver=docker
Step 2: Create a Terraform configuration file
Create a new directory for your Terraform files and create a file named kube.tf. In this file, write the Terraform configuration code to set up your Kubernetes cluster.
Create a directory and main.tf file in it:
mkdir kube-terraform
cd kube-terraform
touch main.tf
terraform {
required_providers {
kubernetes = {
source = "hashicorp/kubernetes"
version = ">= 2.23.0"
}
}
}
provider "kubernetes" {
config_path = "~/.kube/config"
}
resource "kubernetes_namespace" "nginx" {
metadata {
name = "nginx"
}
}
resource "kubernetes_deployment" "nginx" {
metadata {
name = "my-nginx-ns"
namespace = kubernetes_namespace.nginx.metadata.0.name
}
spec {
replicas = 2
selector {
match_labels = {
app = "my-nginx-app"
}
}
template {
metadata {
labels = {
app = "my-nginx-app"
}
}
spec {
container {
image = "nginx"
name = "nginx-container"
port {
container_port = 80
}
}
}
}
}
}
resource "kubernetes_service" "nginx" {
metadata {
name = "nginx"
namespace = kubernetes_namespace.nginx.metadata.0.name
}
spec {
selector = {
app = kubernetes_deployment.nginx.spec.0.template.0.metadata.0.labels.app
}
type = "NodePort"
port {
node_port = 31010
port = 80
target_port = 80
}
}
}
Step 3: Initialize and apply the Terraform configuration
Now, navigate to the directory where your kube.tf file is located. Run the following command to initialize the Terraform provider and download the necessary plugins:
terraform init
Once the initialization is complete, you can apply the Terraform configuration by running the following command:
terraform apply
Terraform will now inspect your configuration and provision the defined Kubernetes resources in your cluster.
Step 4: Verify the deployment
After Terraform finishes provisioning your Kubernetes resources, you need to verify the deployment by using the Kubernetes tool kubectl . Check if the pods and services are up and running as expected.
Run the following commands:
kubectl get ns
kubectl get all -n nginx
kubectl port-forward -n nginx svc/nginx 31010
Check Nginx deployment by opening its IP address in a web browser.
Step 5: Clean up
Once you are done with your Kubernetes infrastructure, remember to clean up the resources to avoid unnecessary costs. Run the following command to destroy the resources provisioned by Terraform:
terraform destroy
Terraform will remove all the resources that were provisioned by the configuration file.
Conclusion
In this blog post, we explored how to create a simple Kubernetes infrastructure with an Nginx container using Terraform. By leveraging Terraform's power to provision and manage resources, you can simplify the deployment process and focus more on building and scaling your applications.