Using Terraform to deploy a docker image on Google Kubernetes Engine

Introduction to Terraform

Terraform is an Infrastructure as Code (IaC) tool developed by HashiCorp. It allows you to build, change, and version your infrastructure safely and efficiently.



Here are some key features of Terraform:
  • Human-Readable Configuration Files: Terraform lets you define both cloud and on-prem resources in human-readable configuration files that you can version, reuse, and share.
  • Multi-Cloud Support: Terraform can manage infrastructure on multiple cloud platforms. Providers enable Terraform to work with virtually any platform or service with an accessible API.
  • Lifecycle Management: The core Terraform workflow consists of three stages:
    • Write: Define resources across multiple cloud providers and services.
    • Plan: Terraform creates an execution plan describing what it will create, update, or destroy.
    • Apply: On approval, Terraform performs the proposed operations in the correct order, respecting any resource dependencies.
  • State Management: Terraform keeps track of your real infrastructure in a state file, which acts as a source of truth for your environment.
  • Provider Ecosystem: HashiCorp and the Terraform community have written thousands of providers to manage many different types of resources and services.

After successfully installing, use the following command to check the version of Terraform:

terraform version


Prerequisites

Before proceeding, you need to prepare the following:

  1. A Google Cloud account with billing enabled and necessary services such as Compute Engine, Kubernetes Engine enabled.
  2. Installed gcloud, kubectl.
  3. Understanding of Google Kubernetes Engine, clusters, and Docker. If you're unsure, you can refer to this article to gain some basic knowledge.


Deploying a Docker Image to GKE

1. Login to gcloud

In this step, you can use an existing project, or if you don't want to affect existing projects, it's better to create a new project. After completing the deployment, you can simply delete the project to release resources.

Once you've determined which project to work with, switch to that project, retrieve the project ID, and log in to use it with Terraform.

# get project id
gcloud config get-value project

# authen to working with terraform
gcloud auth application-default login --project {project id}


2. Terraform codebase

Create a Terraform project with the following file contents:

First, let's create a file named `provider.tf` to define the information of the Google Cloud Provider.

terraform {
required_providers {
google = {
source = "hashicorp/google"
version = "5.18.0"
}
}
}

provider "google" {
project = var.projectId
region = var.region
}


`variable.tf` file to define the variables we'll use in this project.

variable "projectId" {
type = string
description = "Project ID"
}

variable "location" {
type = string
description = "Location"
}

variable "region" {
type = string
description = "Region"
}

variable "clusterName" {
type = string
description = "Cluster name"
}

variable "machineType" {
type = string
description = "Node Instance machine type"
}

variable "nodeCount" {
type = number
description = "Number of nodes in the node pool"
}

variable "dockerImage" {
type = string
description = "Docker Image"
}


Create a file named `terraform.tfvars` to define the default variable values. You'll need to change these values to fit your needs.

projectId = "project-id"

location = "asia-southeast1-a"
region = "asia-southeast1"

clusterName = "k8s-cluster"
machineType = "e2-micro"
nodeCount = 1

dockerImage = "{host}/{project-id}/{image name}:{version}"

If you want to learn about building a Docker image and publishing it to the GCP Container Registry for use in this article, you can find it here.


The `cluster.tf` file is used to initialize the Kubernetes cluster.

resource "google_container_cluster" "default" {
name = var.clusterName
location = var.location
initial_node_count = var.nodeCount
deletion_protection = false

node_config {
preemptible = true
machine_type = var.machineType
}
}


The `k8s.tf` file is used to create Pod Deployment and LoadBalancer Service.

data "google_client_config" "default" {}

provider "kubernetes" {
host = "https://${google_container_cluster.default.endpoint}"
token = data.google_client_config.default.access_token
cluster_ca_certificate = base64decode(google_container_cluster.default.master_auth[0].cluster_ca_certificate)
}

resource "kubernetes_deployment_v1" "default" {
metadata {
name = "deployment-name"
}
spec {
replicas = 1
selector {
match_labels = {
app = "label-name"
}
}
template {
metadata {
labels = {
app = "label-name"
}
}
spec {
container {
name = "express-ts"
image = var.dockerImage
}
}
}
}
}

resource "kubernetes_service_v1" "default" {
metadata {
name = "service-name"
}
spec {
selector = {
app = kubernetes_deployment_v1.default.spec[0].selector[0].match_labels.app
}
port {
port = 80
target_port = 3000
}
type = "LoadBalancer"
}
depends_on = [time_sleep.wait_service_cleanup]
}

resource "time_sleep" "wait_service_cleanup" {
depends_on = [google_container_cluster.default]
destroy_duration = "180s"
}

Here, `kubernetes_deployment_v1` defines the Docker image to deploy, while the LoadBalancer Service is used to map ports between the Docker container for external access.


Next, create an additional file named `output.tf` to print out the necessary information after the execution process is successful.

output "cluster_endpoint" {
description = "Cluster endpoint"
value = google_container_cluster.default.endpoint
}

output "load_balancer_hostname" {
description = "LoadBalancer EXTERNAL-IP"
value = kubernetes_service_v1.default.status.0.load_balancer.0.ingress.0.ip
}


3. Execute Terraform commands

Please execute each of the following commands to proceed with the deployment on Google Cloud:

# initialize the terraform configuration
terraform init

# generate and show an execution plan
terraform plan

# apply the execution plan to provision resources
terraform apply


After successfully executing, you will see the following results:


You can check if the cluster has been initialized as follows:


Check Pods, Deployments, and Docker container running:


View information about the LoadBalancer Service that has been created:


Please access the EXTERNAL-IP field to check if the NodeJS Server has been deployed successfully. After executing the `terraform apply` command, you will also see similar results in the `load_balancer_hostname` field.



4. Clean up resources

To delete the resources created by Terraform, please execute the following command:

terraform destroy



Conclusion

Through this article, I have guided you on how to use Terraform as an Infrastructure as Code (IaC) tool to deploy a docker image on Google Kubernetes Engine. This means that our entire infrastructure has been deployed using code without the need for manual configuration. This is the greatest advantage of Terraform, as configuration information can be easily edited, shared, and applied to cloud providers in a simple and efficient manner.

If you have any suggestions or questions regarding the content of the article, please don't hesitate to leave a comment below!

Comments

Post a Comment

Popular posts from this blog

Kubernetes Practice Series

Image
Introduction Kubernetes (often abbreviated as K8s ) is an open-source system designed to automate the deployment, scaling, and management of containerized applications. This page serves as a collection of articles related to Kubernetes (K8s) , including theoretical concepts and practical guides on using Kubernetes to set up essential tools for the software development process. I will continue to update this series with new articles as ideas come to mind, to ensure the series becomes more comprehensive. The articles are arranged in increasing order of difficulty to make it easier for you to follow. If you have time, it's recommended that you start from the beginning of the series to acquire the necessary knowledge and information that will prepare you for the subsequent articles. Key Topics Covered in This Series Basic Knowledge : Fundamental concepts, common commands, etc. Resources : Pod, Deployment, Service, StatefulSet, Ingress, etc. Pod Autoscaler : Horizontal and Vertical sc
Read more

Docker Practice Series

Image
Introduction Docker is an open platform for developing, shipping, and running applications. This page is dedicated to compiling articles related to Docker , covering both the theoretical aspects and practical applications of Docker in setting up popular tools essential for software development. I will be updating this series with more articles in the future as new ideas for topics arise. The articles are arranged in increasing order of difficulty, making it easier for you to follow along. If you have the time, I recommend starting from the beginning of the series to ensure that you grasp the necessary knowledge and information needed for the more advanced articles later on. Here are some key topics in the series that you need to explore to effectively use Docker : Basic knowledge Docker commands Docker Compose Building Docker images Performance improvement Integration with CI/CD Once you have a solid understanding of the foundational knowledge, the extended topics (including advanced
Read more

NodeJS Practice Series

Image
Introduction NodeJS is an open-source and cross-platform JavaScript runtime environment . Here are some key points about NodeJS : V8 Engine : NodeJS runs on the V8 JavaScript engine , which is also the core of Google Chrome . This allows NodeJS to be highly performant. Asynchronous and Non-Blocking : NodeJS  uses an event-driven, non-blocking I/O model. It’s lightweight and efficient, making it ideal for data-intensive real-time applications. Single-Threaded : NodeJS  runs in a single process, handling multiple requests without creating new threads. It eliminates waiting and continues with the next request. Common Language : Frontend developers who write JavaScript for browsers can use the same language for server-side code in NodeJS . You can even use the latest ECMAScript standards without waiting for browser updates. This page is designed to compile articles related to NodeJS , including how to integrate it with various libraries and relevant tech stacks. I will continue to u
Read more

React Practice Series

Image
Introduction React is a JavaScript library created by Facebook , often referred to as the most popular frontend framework today. This page aims to gather articles related to ReactJS , covering topics such as theory, features, and commonly used packages in the process of building ReactJS applications. I will update this series with more articles in the future as new ideas for content come up. The articles are arranged in increasing order of difficulty, so if you have time, it's recommended to start from the beginning of the series. This will ensure you grasp the essential knowledge and information needed for the subsequent articles. Here are some key topics in the series that you need to explore to effectively use ReactJS : Fundamental : React Hook, React Context, Lazy load, etc. State management : redux, mobx, recoil, etc. Middleware libraries : redux-thunk, redux-saga, redux-observable, etc. Popular packages : react-query, immer, styled-components, etc. Rendering techniques : C
Read more

Sitemap

Image
A page aggregator designed for easy reference and search, compiling all blog posts for convenient access.
Read more

Setting up Kubernetes Dashboard with Kind

Image
Introduction In a previous article, I guided you through using Helm to deploy on Google Kubernetes Engine . However, if you want to cut down costs by using Kubernetes in your local environment instead of relying on a cloud provider during development, then Kind is your go-to. There are several tools to help set up Kubernetes locally, such as MiniKube , Kind , K3S , KubeAdm , and more. Each tool has its own pros and cons. In this article, I'll walk you through using Kind to quickly set up a Kubernetes cluster on Docker . Kind stands out for its compactness, making Kubernetes start up quickly, being user-friendly, and supporting the latest Kubernetes versions. Working with Kind Firstly, follow the instructions here to install Kind according to your operating system. If you're using Ubuntu , execute the command: [ $( uname -m ) = x86_64 ] && curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.23.0/kind-linux-amd64 chmod +x ./kind sudo mv ./kind /usr/local/bin/ki
Read more

Deploying a NodeJS Server on Google Kubernetes Engine

Image
Introduction to GKE Google Kubernetes Engine (GKE) is a managed Kubernetes service provided by Google Cloud Platform , facilitating simple and efficient deployment of Docker images. We only need to provide some configuration for the number of nodes, machine types, and replicas to use. Some Concepts Cluster A Cluster is a collection of Nodes where Kubernetes can deploy applications. A cluster includes at least one Master Node and multiple Worker Nodes . The Master Node is used to manage the Worker Nodes . Node A Node is a server in the Kubernetes Cluster. Nodes can be physical servers or virtual machines. Each Node runs  Kubernetes , which is responsible for communication between the Master Node and Worker Node , as well as managing Pods and containers running on it. Pod A Pod is the smallest deployable unit in Kubernetes . Each Pod contains one or more containers, typically Docker containers. Containers in the same Pod share a network namespace, meaning they have the same
Read more

Create API Gateway with fast-gateway

Image
Introduction In this article, I will guide you on how to use fast-gateway to deploy a simple API Gateway on NodeJS along with express . The advantage of an API Gateway is that it acts as an intermediary layer to hide the rest of the system, including services, commonly used in Microservices architecture. Example Usage This is the Microservices model after deployment: First, install the package yarn add fast-gateway Next, define the ports that will be used. import * as express from 'express' import * as gateway from 'fast-gateway' const portGateway = 5000 const portService1 = 5001 const portService2 = 5002 Define service 1 as follows: const startService1 = (): void => { const app = express () app . get ( '/list' , ( req , res ) => { const items = [ { id: 1 , name: 'service 1 value 1' , }, { id: 2 , name: 'service 1 value 2' , }, ] re
Read more

Explaining Async/Await in JavaScript in 10 Minutes

Image
Introduction For a long time, we've relied on callbacks to deal with asynchronous code in JavaScript. As a result, many of us have faced dreadful experiences dealing with deeply nested functions ( callback hell ). Callback hell Callbacks come with a lot of drawbacks. When we have multiple asynchronous operations, callbacks have to wait for each other to execute, prolonging the completion time. Additionally, writing nested callbacks makes our code messy and hard to maintain. In the ES6 (ECMAScript 2015) version, JavaScript introduced Promises. This was a fantastic replacement for callbacks and was quickly embraced by the community. Our new code looks similar to the old one, making it easier to follow and maintain. However, the issues with callbacks weren't completely resolved. Since the ES7 (ECMAScript 2016) version, Async/Await has been added to make asynchronous code in JavaScript look and feel easier to use. What is Async/Await? Async/Await is a feature of JavaScript that
Read more

A Handy Guide to Using Dynamic Import in JavaScript

Image
Introduction In JavaScript, when we import a file, the process usually happens synchronously, known as static import. However, as our applications grow, this synchronous loading can lead to slower initial page loads due to larger JavaScript bundles. Moreover, there are times when imports are necessary only under specific circumstances, leading to unnecessary loading times for users who might not even utilize those features. Details Instead of burdening all users with unnecessary imports, dynamic imports come to the rescue. They allow us to load modules or files only when they are needed, thus improving performance and user experience. Dynamic imports are invoked using the import() function and return a promise. When using default exports, the exported data can be accessed through the default field, while other data can be accessed through fields with matching names. Here's how you can use dynamic imports: import ( "ramda" ). then ( module => { const moduleDefaul
Read more