# Step-by-Step Guide: Building Infrastructure on Google Cloud with Terraform

အားလုံးပဲ မဂ်လာပါ

ကျနော်ဒီနေ့ Sharing လုပ်ပေးမှာကတာ့ Google Cloud Platform (GCP) ပေါ်မှာ terraform နဲ့ Infrastructure တစ်ခုကို ဘယ်လို တည်ဆောက်မလဲ ဆိုတာ ပြော‌‌ပြ ပေးသွားမှာဖြစ်ပါတယ် ။

ပထမဆုံး အနေ နဲ့ Terraform ဆိုတာဘာလဲ၊ Terraform ကို ဘာလို့ သုံးသင့်တယ် ဆိုတာ အကျဉ်းချုပ်အနေ နဲ့ မိတ်ဆက်ပေးပါမယ်။ ဒီမှာတာ့ Terraform ကို deep မပြောတော့ပါဖူး ။ ဘာလို့ဆို ဒါကို ဖတ်ပြီဆိုတည်းက Terraform ကို ဘာကြောင့် သုံးလဲ ဆိုတာ သိမယ် ထင်လို့ပါ ။ အခု blog မှာလဲ Terraform ကို အသေးစိတ် ရှင်းပြတာမဟုတ်လို့ Terraform နဲ့ Infrastructure ဘယ်လို တည်ဆောက်မလဲ ဆိုတာ ပြောပြမှာ ဖြစ်လို့ပါ။

### **Terraform Overview**

Terraform ဆိုတာ HashiCorp ကထုတ် ပေးထားတဲ့ Infrastructure as Code (IaC) နည်းပညာတစ်ခုဖြစ်ပါတယ်။ ဒီ tool ကိုအသုံးပြုပြီး Infrastructure ကို building, changing, managing လုပ်နိုင်ပြီး safe ဖြစ်စွာ ထပ်ခါထပ်ခါ အသုံးပြုနိုင်ပါတယ် ကိုယ့်လူတို့ ဘယ်လောက်မိုက်လဲ ဒီ tool ကြီးက အမြဲတမ်း ထပ်ခါခါ ခေါင်း မကိုက်ချင်တဲ့ ကိုယ်တွေ အတွက် အဆင်ပြေတယ် ။Operator နဲ့ Infrastructure team တွေက ဒီ tool ကိုအသုံးပြုပြီး environment တွေကို automated deployment လုပ်ဖို့ (HCL )လို့ခေါ်တဲ့ သုံး HashiCorp Configuration Language ကိုသုံးထား တယ် ။ HCL က Human-readable ဖြစ်တဲ့ အတွက် ဖတ်ရတာ လွယ်ကူတယ် ကျက်ရတာ လွယ်ကူတာ မဟုတ်ဖူးနော် ။ IaC လို့ ပြောခဲ့တယ် နော် IaC ဆိုတာက User Interface မှာ သုံးရတာမဟုတ်ပဲ file ထဲ မှာ Configuration ထည့်ပြီး Infrastructure ကို management လုပ်ရတာကို ပြောချင်တာ ပါ။ Configuration ထဲမှာ Resources တွေထည့်ရမှာ Resource type/name တို့ Resources ဆိုတာ Infrastructure ရဲ့ အစိတ် အပိုင်းတွေ ဖြစ်တဲ့ VM, Security Group, Network Interface, etc...blah blah ပေါ့နော်။ အဲ့မှာ Resources ဆိုလို့ ပြောရဦးမယ် Terraform က ဘယ် Provider အတွက်လဲ ဆိုတာ အရင် အသိပေးရမှာပါ AWS လား Azure လား GCP လား Docker လား တစ်ခြား Provider တွေလဲ အများကြီးရှိပါသေးတယ် အဲ့တာမှ ဘယ် Provider ရဲ့ resources ဆိုတာ သိမှာ ဖြစ်ပါတယ်။

Terraform မှာပုံမှန် လုပ်ဆောင်ရမယ့် flow လေးတွေပြောပြပါမယ်

\-Scope : ပေးထားတဲ့ Project အတွက် ဘယ် resources တွေလဲ ဆိုတာ အရင် Confirm လုပ်ရပါမယ်

\-Author : Scoped parameter ပေါ်မူတည်ပြီး HCL နဲ့ Configuration file ရေးရပါမယ်

\-Initialize : Project Directory အတွင်းမှာ Terraform init command run လိုက်မှသာ Project အတွက် လိုအပ်တဲ့ Provider plug-in download လုပ်သွားမှာဖြစ်ပါတယ်။

\-Plan : Terraform plan ဆိုတဲ့ command run ရမှာပါ ဘာလို့ဆို ငါတို့ ဘာလုပ်ချင်တယ် ဆိုတာ ကြိုတင် ပြပေးတာပါ အကယ်၍ လိုအပ်တာ/မလိုအပ်တာ ရှိရင် ပြန်ပြင်လို့ ရအောင်ပါ။ အမှားအယွင်း နည်းအောင် ပေါ့။

\-Apply : Terraform apply command က Configuration ထဲ အတိုင်း အကုန် အကောင်အထည် ဖော်တော့မှာပါ ။ State file ပါ တစ်ခါတည်း ဖန်တီး ပေးသွားမှာပါ။

State file ဆိုတာက တော့ လုပ်သမျှ Configuration တွေကို အဲ့ထဲမှာ မှတ်ပြီး ပြန်သုံးလို့လဲ ရသလို modify လဲ ပြန်လုပ်လို့ရပါတယ် ။ အဲ့ State file ကြောင့် Project တစ်ခုလုံး တစ်ခါထဲလဲ destroy လုပ်လို့ရပါတယ် ၊အမှားအယွင်းဖြစ်မှာ စိုးရိမ်ရင် backup လုပ် ကိုလုပ်သင့်ပါတယ်။ ‌‌

State file ရဲ့ feature တွေက Meta Data တွေကို Map လုပ်ပေးတယ်၊ Performance ပိုကောင်းစေတယ် (cache function)၊ Syncing လုပ်ပေးတယ် ၊ State Locking လုပ်ပေးတယ် ၊ Workspaces ခွဲပေးထားတယ် ၊ ဘာတွေလဲ ဆိုတာကတော့ ရှာဖတ်လိုက်တာ့ ရှင်းပြရင် အရမ်းရှည်သွားမှာဆိုးလို့။

ကဲ အဲ့လောက် ဆိုရင် အခုလုပ်ပြမဲ့ Infrastructure တည်ဆောက်တာကို စလိုက်ကြရအောင်ပါ။ အဓိက Project တစ်ခုလုံး မဟုတ်ပါဖူး အခြေခံ နဲ့ Sample အနေနဲ့ ပြမှာ ဖြစ်ပါတယ် ။

### **Step 1 : Create the configuration files**

ပထမဆုံး ဒီ Lab အတွက်လိုအပ်တဲ့ Configuration file တွေအရင် တည်ဆောက်ပါမယ်။

Google Cloud Console ကို၀င်ပါ ။Activate Cloud Shell ကိုနှိပ်ပါ ။

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725641154199/328e0dc3-ebf8-4071-8b3d-f5780e2f4181.png align="center")

အရင်ဆုံး account name ကိုစစ်ပါ ။

```plaintext
gcloud auth list
```

ကိုယ် အသုံးပြုမဲ့ project id မှန်မမှန်စစ်ပါ။

```plaintext
gcloud config list project
```

```plaintext
mkdir -p modules/instances modules/storage
touch main.tf variables.tf
touch modules/instances/{instances.tf,outputs.tf,variables.tf}
touch modules/storage/{storage.tf,outputs.tf,variables.tf}
```

```plaintext
main.tf
variables.tf
modules/
└── instances
    ├── instances.tf
    ├── outputs.tf
    └── variables.tf
└── storage
    ├── storage.tf
    ├── outputs.tf
    └── variables.tf
```

အခုလက်ရှိမှာ main.tf နဲ့ variables.tf က Root အနေနဲ့ ရှိနေပါတယ် သူတို့က အဓိကလုပ်ဆာင်မှာပါ။ Modules အောက်မှာရှိနေတဲ့ instances နဲ့ Storage ကို module အနေနဲ့ ခေါ်သုံးမှာ ဖြစ်ပါတယ် local module ပေါ့ဗျာ။ Terraform Registry မှာ လဲ module တွေခေါ်သုံးလို့ရပါတယ် ။ဒီ lab မှာလဲ registry ကခေါ်သုံးတာပြ ပေးမှာပါ။အောက်က ပုံထဲက အတိုင်း Cloud Shell မှာ Open Editor လေးရှိပါတယ် နှိပ်လိုက်ပါ

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725641508334/7e381add-d25c-40ca-b3d0-4045d7accec7.png align="center")

### **Step 2 : Build infrastructure**

Cloud Shell မှာ ပေါ်နေတဲ့ Editor ဆိုတာလေးဖွင့်လိုက်ပါ ကျနော်တို့ခုနက ဆောက်ထားတဲ့ root variables.tf ဆိုတဲ့ file ထဲမှာ variables တွေကိုကြေညာပါမယ်။

```plaintext
variable "region" {
  default = "us-east4"
}

variable "zone" {
  default = "us-east4-a"
}

variable "project_id" {
  default = "your project id"
}
```

‌ဒါက instance နဲ့ storage modules ရဲ့ variables တွေဖြစ်ပါတယ်။ အဓိကကတော့ root ရဲ့ variables ကိုပဲ main.tf ကယူသုံးမှာဖြစ်ပါတယ်။ instance နဲ့ storage modules ရဲ့ variables.tf file မှာထည့်ပါမယ်။

```plaintext
variable "region" {
  type = string
}

variable "zone" {
  type = string
}

variable "project_id" {
  type = string
}
```

main.tf file မှာ ကိုယ်သုံးမည့် Provider ကို အရင်ကြေညာပေးရမှာပါ

```plaintext
terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 4.0"
    }
  }
}

provider "google" {
  project = var.project_id
  region  = var.region
  zone    = var.zone
}
```

VPC တည်ဆောက်ဖို့ အတွက် main.tf file ထဲသို့ ထပ်ထည့်ပါ။

```plaintext
resource "google_compute_network" "vpc_network" {
  name = "terraform-network"
  auto_create_subnetworks  = false
}
resource "google_compute_subnetwork" "subnet_1" {
  name          = "subnet-1"
  ip_cidr_range = "10.10.10.0/24"
  region        = var.region
  network       = google_compute_network.vpc_network.self_link
}
```

Provider အတွက် လိုအပ်တဲ့ plug-in download ယူရန်နှင့် အကောင်ထည် ဖော်ဖို့အတွက် အောက်ပါ commands တွေ ကို တစ်ခုချင်းဆီ Run ပါ။

```plaintext
terraform init
terraform plan
terraform apply
```

Google Cloud Console ကနေ စစ်ကြည့်ပါ terraform-network ဆိုတဲ့ VPC လေး create လုပ်ပြီးပါပြီ

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725642390592/c818b5fe-953b-45d3-ab5d-c0eea6ea7b64.png align="center")

### **Step 3 : Create Instances**

Instances Modules မှ instances များကို ခေါ်သုံးမှာ ဖြစ်တဲ့ အတွက် instances.tf file ထဲ instances အတွက် Configuration ကို အရင် ရေးရပါမယ်

```plaintext
resource "google_compute_instance" "instance-1" {
  name         = "instance-1"
  machine_type = "e2-standard-2"
  boot_disk {
    initialize_params {
      image = "debian-11-bullseye-v20240815"
    }
  }
  network_interface {
    network = var.network_name
    subnetwork = var.subnet_name
  }
}

resource "google_compute_instance" "instance-2" {
  name         = "instance-2"
  machine_type = "e2-standard-2"
  boot_disk {
    initialize_params {
      image = "debian-11-bullseye-v20240815"
    }
  }
  network_interface {
    network = var.network_name
    subnetwork = var.subnet_name
  }
}
```

instances.tf file ထဲမှာ network\_interface မှ ခေါ်သုံးဖို့ အတွက် instances module ရဲ့ variables.tf file ထဲ ထည့်ပါ

```plaintext
variable "network_name" {
  description = "The name of the Google Compute Network"
  type        = string
}
variable "subnet_name" {
  type = string
}
```

Instance module ကို main.tf file တွင် ညွှန်းပေးရပါမယ်။ အဲ့တာမှ instance.tf file ထဲ configuration ကိုယူသုံးမှာဖြစ်ပါတယ်။ Source မှန်အောင် ထည့်ဖို့ လိုအပ်ပါတယ်။

```plaintext
module "instances" {
  source    = "./modules/instances"
  region    = var.region
  zone      = var.zone
  project_id = var.project_id
  network_name = google_compute_network.vpc_network.self_link
  subnet_name = google_compute_subnetwork.subnet_1.self_link
}
```

အပြောင်းအလဲ လုပ်ပြီးတိုင်း လုပ်ဆောင်ပါ။

```plaintext
terraform init
terraform plan
terraform apply
```

instance-1 နှင့် instance-2 ဖန်တီးပြီး ဖြစ်ကြောင်း တွေ့ရပါလိမ့်မယ်

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725642606294/7a7bd4fe-854f-4a28-a52a-5cbc2992923c.png align="center")

cloud console တွင် instance-1 ကိုနှိပ်ပြီး ပေးထားတဲ့ machine type, boot\_disk, Network မှန်/မမှန်စစ်ဆေးကြည့်ပါ

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725642622635/95493fad-f8b8-4040-b6f1-dab3c480a2c6.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725642639243/2dfd9ece-5893-4979-be10-d7a645cb3d99.png align="center")

### **Step 4 : Import Infrastructure**

Import Infrastructure ဆိုတာကတော့ ကျနော်တို့က user interface ကနေ manual ဆောက်ထားတဲ့ objects တွေက Terraform နဲ့ ဆက်စပ်မူ မရှိပါဖူး ။ Manual ဆောက်ထားခဲ့ resources တွေကို Terraform နဲ့ manage လုပ်ချင်တယ် ဆိုရင် Terraform state file ထဲကို import လုပ်ပေးရမှာ ဖြစ်ပါတယ် ။ ဘယ်လို လုပ်ရမလဲ ပြောပြ ပေးပါမယ်။ အရင်ဆုံး ကိုယ် import လုပ်ချင်တဲ့ VM ရဲ့ machine type, boot-disk, network\_interface, တွေကို configuration file မှာ တူအောင် ရေးရပါမယ် ။ အဲ့မှာ အရေးကြီး တာက meta\_startup\_script နဲ့ allow\_stopping\_for\_update ကို ထည့်ပေးရမှာပါ ။ ကျနော် example တစ်ခု ပြပါမယ်

```plaintext
resource "google_compute_instance" "tf-instance-1" {
  name         = "tf-instance-1"
  machine_type = "e2-standard-2"
  boot_disk {
    initialize_params {
      image = "debian-11-bullseye-v20240815"
    }
  }
  network_interface {
    network = "default"
  }
  metadata_startup_script = <<-EOT
    #!/bin/bash
  EOT
  allow_stopping_for_update = true
}
```

ကျနော် အခု ပြထားတာ example configuration ပါ machine type တွေ name တွေ boot\_disk တွေ network\_interface တွေ ကိုယ် import လုပ်ချင်တဲ့ instance အသုံးပြုထားတဲ့ အတိုင်း ပြန် ပြင်ပါ ။ ပြောချင်တာ ရောက်လာပါပြီ metadata\_startup\_script ဆိုတာ VM up တဲ့အခါ အလိုအလျောက် လုပ်ဆောင်မည့် script ပါ bash script နဲ့လုပ်မယ်လို့လဲ ကြေညာထားပါတယ် အဲ့ VM ထဲမှာ run software တွေ setting တွေ configure ချထားတာ တွေ automated ပြန်လုပ်ပေးမယ် ပြောတာပါ ။ allow\_stopping\_for\_update ကို true လို့ သတ်မှတ်ထားတာက instance ကိုပြန်ဖျက်ပြီး အသစ် ပြန်ဖန်တီး စရာမလိုပဲ update လုပ်ဖို့ အတွက်ပါ ။ဒါက instance configuration ကို downtime မရှိပဲ ပြင်ဖို့ အထောက်အကူ ပေးတာပါ ။ ဒီလောက်ဆို နားလည်မယ် ထင်ပါတယ် ။ကျနော်တို့ ဆက်သွားပါမယ် ။

အဲ့တာ တွေ အကုန်ပြီးသွားရင် import စလုပ်ပါမယ် ။ instance တွေကို import လုပ်ပါမယ် ။ အခု အောက်မှာ ပြထားတဲ့ Terraform import command နဲ့ import လုပ်ပါမယ် ။ ဒီနေရာမှာ မင်းအခု module အောက်မှာ ရေးထားတဲ့ configuration နဲ့ import လုပ်ချင်တဲ့ instance ရဲ့ instance id နဲ့ map လုပ်ပေးပါ ။ VM ပဲ သုံးသုံး instance ပဲ သုံး သုံး အတူတူပဲ လို့ယူဆပေးပါ အခေါ်အဝေါ်ပဲ ကွဲတာမို့။import လုပ်ရင် သတိထားရမှာက import လုပ်ထားတဲ့ instance တိုင်းကို Terraform က life cycle management ဖြစ်တဲ့ အတွက် Terraform destroy run အကုန် ပျက်မှာဖြစ်ပါတယ်

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725642778123/d463eb93-372e-4388-b688-2a2e292a9d7b.png align="center")

စာဖတ်သူ import လုပ်ချင်တဲ့ instance ရဲ့ id ကိုယူပြီး အောက်ပါ command အတိုင်း run ပါ

```plaintext
terraform import module.instances.google_compute_instance.tf-instance-1 <tf-instance-1-id>
```

```plaintext
terraform init 
terraform apply
```

### **Step 5 : Configure a remote backend**

ဒါက ဘာကို ‌‌‌ပြောချင်တာလဲ ဆိုရင် Terraform state file ကို remote ကနေ ယူသုံးပြီး modify လုပ်မယ် create လုပ်မယ်ပေါ့ဗျာ ။ အရင်ဆုံး google bucket တစ်ခု ဆောက်လိုက်မယ် ဗျာ။ storage module မှာ storage.tf file မှာ configuration ရေးကြမယ် let's go ။ bucket name က unique ဖြစ်ရမယ် နော် ။

```plaintext
resource "google_storage_bucket" "bucket_01" {
  name                        = "qwiklabs-gcp-00-3712a4245aff"
  location                    = "US"
  force_destroy               = true
  uniform_bucket_level_access = true
}
```

နောက်တစ်ဆင့် module ကို main.tf file ထဲမှာ ပြန်ညွှန်းမယ် ။

```plaintext
module "storage" {
  source    = "./modules/storage"
  project_id = var.project_id
  region    = var.region
  zone = var.zone
}
```

```plaintext
terraform init
terraform plan
terraform apply
```

Bucket တစ်ခု ဖန်တီးထားကြောင်း တွေ့ရပါလိမ့်မယ် ။ bucket name က unique ဖြစ်လို့ ကျနော် က project id ထည့်သုံးထားတာပါ။

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725643270979/a4b7dfd8-7196-4aa2-9e1e-a5aff8610fda.png align="center")

နောက်တစ်ဆင့် cloud bucket ပေါ် remote backend ကိုတင်ဖို့ main.tf file ထဲ ထည့်ရမယ် ။ ပြောရမယ် ဆို ဒီ Terraform state file တစ်ခုထဲ မှာ store လုပ်ထားတဲ့ configuration တွေ Workspace လို့ခေါ်တယ် ပေါ့ဗျာ။

```plaintext
terraform {
  backend "gcs" {
    bucket = "qwiklabs-gcp-00-3712a4245aff"
    prefix = "terraform/state"
  }
}
```

```plaintext
terraform init
```

အခုဆို Terraform ဆိုတဲ့ state file ရဲ့ folder လေးရာက် နေပါပြီ

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725643329955/c8a85ef7-690d-40fd-9fd9-1d7eba1b4da8.png align="center")

Remote backend ကို local ကို revert ပြန်လုပ်ချင်ရင် main.tf file တွင် အောက်ပါ configuration ကို change ပါ

```plaintext
terraform {
  backend "local" {
    path = "terraform/state/terraform.tfstate"
  }
}
```

\-migrate-state argument ကို ထည့်ပေးရမယ် ။

```plaintext
terraform init -migrate-state
```

ls command နဲ့ စစ်ကြည့်ပါ local ထဲကို ပေးထားတဲ့ PATH အတိုင်း ရောက် နေပါပြီ

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725643441588/b4cd28f5-8f7e-41f9-b2d5-8a5e7661aea1.png align="center")

### **Step 6 : Modify and update infrastructure**

နမူနာ အနေ နဲ့ Infrastructure ကို Modify လုပ်ပြမယ် ။ အခု လုပ်ပြမှာက instance တစ်ခုကို ထပ် add ပြပါမယ် ။ Instance.tf file ထဲတွင် ထပ် ထည့်ပါ။

```plaintext
resource "google_compute_instance" "instance-3" {
  name         = "instance-3"
  machine_type = "e2-standard-2"
  boot_disk {
    initialize_params {
      image = "debian-11-bullseye-v20240815"
    }
  }
  network_interface {
    network = var.network_name
    subnetwork = var.subnet_name 
  }
}
```

```plaintext
terraform apply
```

အခုဆို instance-3 ဆိုတဲ့ instance လေးတစ်လုံးထပ်ရာက် နေပါပြီ

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725643544486/58a8d578-3a82-4465-8959-efc41c6cd627.png align="center")

နောက်တစ်ခုက အခု ထပ်ထည့်လိုက်တဲ့ instance ကိုပဲ ဖျက်ပြမှာပါ ။ Instance.tf file မှာ instance အသစ် အတွက် Configuration ကို ဖျက်ပစ် လိုက် ။ ဒါမှ မဟုတ် # sign ခံပြီး comment ပိတ် လိုက် ရပါတယ် ။ ပြီးသွားရင် Terraform apply command ပြန်run ပါ။

```plaintext
terraform apply
```

configuration ပြင်ပြီး apply ပြန်စစ် ကြည့်ပါ instance မရှိတော့ကြောင်း တွေ့ရပါလိမ့်မယ်

ဒါက ကျနော်တို့က Terraform ကနေ manage လုပ်တာ ဖြစ်ပါတယ် ။အကယ်၍ ကျနော်တို့ က user interface ကနေ change လိုက် တယ် tag တို့ label တို့ အစရှိ သဖြင့်ပေါ့ ဗျာ အဲ့တာဆို ရင် state file မှာပါ update ဖြစ်အောင် ‌‌‌‌refresh ဆိုတဲ့ command နဲ့ update လုပ်ရမှာဖြစ်ပါတယ်။ ဥပမာ အနေ နဲ့ ကျနော် အပေါ် ‌create လုပ်ထားခဲ့ တဲ့ bucket file ကို label ထည့်ပြပါမယ် ။ Bucket ကို အမှန်ခြစ် ပေးပြီး LABELS ကိုနှိပ်လိုက်ပါ

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725643616325/7d70a377-08db-446a-97b0-45c441c40a79.png align="center")

ဒီမှာဆို Add Label နှိပ်ပြီး key နဲ့ value ဆိုပြီးပေးခဲ့ပါတယ် ။Save ခဲ့ပါ

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725643633895/66a3d143-5f85-4cf1-b088-3ea01f14e898.png align="center")

ပြီးရင် Terraform state file မှာ update လုပ်ဖို့ refresh ဆိုတဲ့ command ကို runပါ

```plaintext
terraform refresh
```

ပြီးရင် Terraform state file မှာ update ဖြစ်လား ပြန်ကြည့်ဖို့ အောက်ပါ command ကို run ပါ

```plaintext
terraform show
```

အခုဆို label ပေးထားခဲ့တဲ့ key နဲ့ value ကိုမြင်နရပါပြီ

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725643721539/6527f66b-225e-45a7-bf2d-f17873db50c7.png align="center")

### **Step 7 : Configure a Firewall**

အခု တစ်ခါ မှာ တော့ အပေါ်မှာ ဆောက်ထား ခဲ့တဲ့ VPC network ကို All IP (0.0.0.0/0)ကို Port 80 ကနေ ingress connection ကို allow ပေးမှာ ဖြစ်ပါတယ် ။ ဒီတော့ main.tf file မှာ firewall resources တွေကို ကြေညာပါမယ် ။

```plaintext
resource "google_compute_firewall" "tf-firewall" {
  name    = "tf-firewall"
  network = google_compute_network.vpc_network.name

  allow {
    protocol = "tcp"
    ports    = ["80"]
  }

  source_ranges = ["0.0.0.0/0"]
}
```

```plaintext
terraform init
terraform apply
```

အခုဆို tf-firewall ဆိုတဲ့ firewall rule ကိုတွေ့ရပါလိမ့်မယ်

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725643810776/a2898ea3-78c1-425d-937d-b3d71447f68d.png align="center")

### **Step 8 : Use a module from the Registry**

အခု ပြောပြ ပေးမဲ့ အရာက တော့ Network module ကို Terraform Registry ကနေ ခေါ်သုံးမှာ ဖြစ်တယ် ။ အ‌‌ပေါ်မှာ ပြောပြခဲ့တာတွေက local မှာပဲ module ကို တည်ဆောက်ပြီး ပြောပြခဲ့တာတွေပါ ။ Version 6.0 ကို သုံးပြပါမယ် ။ Main.tf file ထဲမှာ ထည့်ပါ ။ Subnets 2 ခုနဲ့ ဆောက်ပြ ပေးထားပါတယ် ။

```plaintext
module "vpc" {
  source  = "terraform-google-modules/network/google"
  version = "6.0.0"

  project_id   = var.project_id
  network_name = "test-vpc"
  routing_mode = "GLOBAL"

  subnets = [
    {
      subnet_name   = "subnet-01"
      subnet_ip     = "10.10.20.0/24"
      subnet_region = var.region
    },
    {
      subnet_name   = "subnet-02"
      subnet_ip     = "10.10.30.0/24"
      subnet_region = var.region
    },
  ]
}
```

Terraform Registry ရဲ့ source ကိုမှန် အောင်ထည့်ပါ။ အောက်မှာ link ချပေးထားပါတယ် ။

[https://registry.terraform.io/modules/terraform-google-modules/network/google/6.0.0](https://registry.terraform.io/modules/terraform-google-modules/network/google/6.0.0)

```plaintext
terraform init
terraform apply
```

Terraform Registry မှ ယူသုံးထားတဲ့ Network Module နဲ့ create လုပ်ထားတဲ့ VPC လေး တွေ့ရပါလိမ့်မယ်

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1725643877604/65809abf-d44b-4ca2-9bbf-5cf90a3132bd.png align="center")

### **Step 9 : Destroy Infrastructure**

Terraform နဲ့ ဖန်တီးတဲ့ အရာတွေ အကုန်ဖျက်ချင်ရင် destroy ဆိုတဲ့ command နဲ့ ဖျက်လို့ပါတယ် ။ command run ပြီးတဲ့ အခါ စတင်ဖျက်မဲ့ resources list တွေ ပြပြီး အတည်ပြချက် တောင်းဆိုပါတယ် ။terraform state file ကနေ ကြည့်ပြီး အကုန် ဖျက်ပစ်မှာ ဖြစ်ပါတယ်

```plaintext
terraform destroy
```

ကျနော် ဆောက်ထားခဲ့တဲ့ resources တွေ အကုန်ဖျက်သွားမည် ဖြစ်တယ် ။Google Cloud Console တွင် ပြန်ကြည့်ကြည့်ပါ ဘာမှ မရှိတော့ ဖူး ကြည့်မ နေနဲ့ 😁

ဒီစာကို ဒီလောက်နဲ့ ပဲ နားပါမယ် စာဖတ်သူ တွေ တစ်ခုခု ရမယ်လို့ မျော် လင့်ပါတယ် ။

Author by Kyaw Thet Htun

My Linkedin Profile - [https://www.linkedin.com/in/kyaw-thet-htun/](https://www.linkedin.com/in/kyaw-thet-htun/)