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 ကိုနှိပ်ပါ ။

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

gcloud auth list

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

gcloud config list project

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}

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 လေးရှိပါတယ် နှိပ်လိုက်ပါ

Step 2 : Build infrastructure

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

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 မှာထည့်ပါမယ်။

variable "region" {
  type = string
}

variable "zone" {
  type = string
}

variable "project_id" {
  type = string
}

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

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 ထဲသို့ ထပ်ထည့်ပါ။

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 ပါ။

terraform init
terraform plan
terraform apply

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

Step 3 : Create Instances

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

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 ထဲ ထည့်ပါ

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 မှန်အောင် ထည့်ဖို့ လိုအပ်ပါတယ်။

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
}

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

terraform init
terraform plan
terraform apply

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

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

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 တစ်ခု ပြပါမယ်

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 အကုန် ပျက်မှာဖြစ်ပါတယ်

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

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

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 ဖြစ်ရမယ် နော် ။

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 ထဲမှာ ပြန်ညွှန်းမယ် ။

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

terraform init
terraform plan
terraform apply

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

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

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

terraform init

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

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

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

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

terraform init -migrate-state

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

Step 6 : Modify and update infrastructure

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

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 
  }
}

terraform apply

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

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

terraform apply

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

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

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

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

terraform refresh

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

terraform show

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

Step 7 : Configure a Firewall

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

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"]
}

terraform init
terraform apply

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

Step 8 : Use a module from the Registry

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

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

terraform init
terraform apply

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

Step 9 : Destroy Infrastructure

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

terraform destroy

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

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

Author by Kyaw Thet Htun

My Linkedin Profile - https://www.linkedin.com/in/kyaw-thet-htun/

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

Comments

Cloud & DevOps

Lessons from Building a Native Kubernetes HA Cluster

More from this blog

Lessons from Building a Native Kubernetes HA Cluster

Terraform + Crossplane: Modern GitOps Platform

Headlamp: A New Alternative to the Kubernetes Dashboard

Vagrant For Beginner

Why need to associate IAM OIDC Provider for Amazon EKS Cluster?

Terraform Overview

Step 1 : Create the configuration files

Step 2 : Build infrastructure

Step 3 : Create Instances

Step 4 : Import Infrastructure

Step 5 : Configure a remote backend

Step 6 : Modify and update infrastructure

Step 7 : Configure a Firewall

Step 8 : Use a module from the Registry

Step 9 : Destroy Infrastructure

Command Palette

Comments

Cloud & DevOps

Lessons from Building a Native Kubernetes HA Cluster

More from this blog

Terraform Overview

Step 1 : Create the configuration files

Step 2 : Build infrastructure

Step 3 : Create Instances

Step 4 : Import Infrastructure

Step 5 : Configure a remote backend

Step 6 : Modify and update infrastructure

Step 7 : Configure a Firewall

Step 8 : Use a module from the Registry

Step 9 : Destroy Infrastructure