Terraform di Azure: Panduan Praktis Pemula untuk IaC

Jika Anda pernah berkali-kali mengklik portal Azure untuk merangkai sumber daya cloud secara manual, saya juga pernah mengalaminya—dan itu cepat melelahkan. Di sinilah Terraform membantu. Ini adalah alat infrastructure-as-code (IaC) yang memungkinkan Anda mendefinisikan dan mengelola konfigurasi cloud hanya dengan beberapa baris kode.

Dalam tutorial ini, kita akan berfokus pada penggunaan Terraform dengan Azure. Saya akan memandu Anda memahami apa itu Terraform, cara kerjanya dalam ekosistem Azure, dan cara memulai dengan contoh praktis. Kita juga akan membahas beberapa praktik terbaik agar sejak awal Anda dapat membangun deployment yang aman dan andal.

Jika Anda baru di ekosistem Azure, jalur dasar Azure ini menawarkan pengantar terstruktur untuk layanan inti dan prinsip-prinsipnya.

Mengapa Menggunakan Terraform di Azure?

Terraform, dikembangkan oleh HashiCorp, adalah alat IaC open-source yang memungkinkan Anda mendefinisikan dan mengelola infrastruktur cloud menggunakan sintaks deklaratif. Dipasangkan dengan Microsoft Azure, ini memungkinkan Anda menskrip sumber daya seperti virtual network, VM, dan database dalam berkas konfigurasi yang mudah dibaca manusia.

Mengapa menggunakan Terraform dengan Azure? Intinya adalah konsistensi, skalabilitas, dan kecepatan. Baik saat Anda membuat satu VM maupun mengorkestrasi aplikasi multi-tier yang kompleks, Terraform menyederhanakan proses sekaligus mengurangi kesalahan manusia.

Jika Anda benar-benar baru dengan Terraform, panduan ramah pemula Terraform ini menjelaskan dasar-dasar dan cara mulai menggunakannya untuk infrastructure as code.

Konsep Inti Terraform di Azure

Integrasi Terraform dengan Azure menawarkan serangkaian fitur yang membuat pengelolaan infrastruktur intuitif dan kuat. Mari kita telaah komponen utama dan jenis sumber daya Terraform yang tersedia.

Manajemen infrastruktur deklaratif

Pendekatan deklaratif Terraform memungkinkan Anda mendefinisikan seperti apa infrastruktur Azure Anda di berkas .tf menggunakan HashiCorp Configuration Language (HCL). 

Sebagai contoh, Anda dapat menentukan sebuah VM Azure beserta ukuran, lokasi, dan pengaturan jaringannya, dan Terraform akan menangani bagaimana cara membuatnya. Berikut sekilas contohnya:

resource "azurerm_virtual_machine" "example" {
  name                  = "my-vm"
  location              = "East US"
  resource_group_name   = "my-resource-group"
  vm_size               = "Standard_D2s_v3"
  network_interface_ids = [azurerm_network_interface.example.id]
  # ... other necessary configurations like OS disk, admin details
}Didukung oleh

Definisi di atas memastikan idempoten—menjalankan kode yang sama berkali-kali menghasilkan hasil yang sama tanpa duplikasi atau kesalahan. 

Sekarang, mari kita uraikan konsep inti Terraform yang membuat pendekatan deklaratif ini berjalan.

Terraform state (.tfstate)

Berkas terraform.tfstate adalah inti dari model deklaratif Terraform. Ini adalah berkas JSON yang mencatat keadaan saat ini dari sumber daya Azure Anda—apa yang dideploy, konfigurasinya, dan relasinya. 

Saat Anda menjalankan terraform apply, Terraform membandingkan berkas .tf Anda (keadaan yang diinginkan) dengan berkas .tfstate (keadaan aktual) untuk menentukan perubahan apa yang perlu dilakukan. Misalnya, jika Anda memperbarui ukuran VM di kode, Terraform memeriksa berkas .tfstate dan hanya memodifikasi atribut itu di Azure. 

Anda bisa menyimpan berkas ini secara lokal, namun untuk tim, gunakan Azure Blob Storage agar dapat berkolaborasi dan mengaktifkan penguncian state untuk mencegah konflik.

Variabel Terraform (.tfvars)

Variabel membuat konfigurasi Anda fleksibel dan dapat digunakan kembali. Didefinisikan di variables.tf dan terraform.tfvars, variabel memungkinkan Anda memparametrisasi nilai seperti nama sumber daya atau wilayah. 

Sebagai contoh:

# variables.tf
variable "location" {
  type        = string
  default     = "East US"
  description = "The Azure region where resources will be deployed."
}

# terraform.tfvars (for a specific environment, e.g., production)
location = "West US"

# main.tf
resource "azurerm_resource_group" "example" {
  name     = "my-rg"
  location = var.location
}Didukung oleh

Berkas terraform.tfvars menimpa nilai default, sehingga Anda dapat mendeploy kode yang sama di wilayah berbeda tanpa mengubah berkas .tf inti. Ini dapat digunakan untuk mengelola banyak environment (misalnya, dev, prod).

Berkas konfigurasi Terraform (.tf)

Berkas-berkas ini berisi kode infrastruktur Anda, yang ditulis dalam HCL. Mereka mendefinisikan resources, providers, modules, dan lainnya. Anda dapat mengaturnya sebagai satu main.tf atau membaginya ke beberapa berkas (misalnya, variables.tf, outputs.tf, network.tf, compute.tf) untuk kejelasan dan organisasi yang lebih baik.

Terraform plan

Sebelum menerapkan perubahan, perintah terraform plan menampilkan pratinjau tindakan Terraform—membuat, memperbarui, atau menghapus sumber daya—berdasarkan perbedaan antara berkas .tf dan .tfstate. Ini seperti dry run yang menangkap potensi masalah lebih awal, dengan menampilkan ringkasan tindakan yang diusulkan secara detail.

Terraform apply

Perintah terraform apply mengeksekusi perubahan yang diidentifikasi oleh terraform plan, memperbarui Azure agar sesuai dengan keadaan yang diinginkan dan menyegarkan berkas .tfstate. Anda akan diminta konfirmasi sebelum perubahan diterapkan, sehingga ada jaring pengaman.

Workspace

Workspace Terraform memungkinkan Anda mengelola banyak environment (misalnya, dev, staging, prod) dengan satu set berkas .tf. Setiap workspace memiliki berkas .tfstate sendiri, sehingga Anda dapat mendeploy infrastruktur serupa dengan konfigurasi berbeda (misalnya, ukuran VM berbeda untuk dev vs. prod). 

Untuk membuat workspace baru, Anda dapat menggunakan:

terraform workspace new productionDidukung oleh

Lalu, Anda dapat beralih ke workspace tersebut:

terraform workspace select productionDidukung oleh

Modul

Module adalah paket kode Terraform yang dapat digunakan kembali. Misalnya, Anda dapat membuat module untuk virtual network Azure dan menggunakannya ulang di berbagai proyek, mengurangi duplikasi dan mendorong standarisasi. Kita akan membahas module lebih lanjut di bagian praktik terbaik.

Konsep-konsep ini—.tfstate, .tfvars, dan alur kerja deklaratif—bekerja bersama untuk memastikan infrastruktur Azure Anda dapat diprediksi, direproduksi, dan mudah dikelola.

Manajemen state dan kolaborasi

Berkas terraform.tfstate melacak keadaan infrastruktur Anda. Untuk tim, menyimpannya di Azure Blob Storage adalah praktik terbaik yang krusial untuk memungkinkan akses bersama dan kontrol versi. Konfigurasi backend jarak jauh ini memungkinkan semua anggota tim bekerja dengan pandangan infrastruktur yang konsisten. 

Penguncian state, fitur yang otomatis disediakan oleh banyak backend jarak jauh seperti Azure Blob Storage, mencegah konflik saat beberapa anggota tim mencoba menjalankan perintah Terraform secara bersamaan, memastikan integritas data.

Berikut contoh konfigurasi backend Azure Blob Storage:

terraform {
  backend "azurerm" {
    resource_group_name  = "my-terraform-state-rg"
    storage_account_name = "mystorageterraformstate"
    container_name  = "tfstate"
    key  = "production/terraform.tfstate" # Path within the container
  }
}Didukung oleh

Sebelum menjalankan terraform init dengan konfigurasi ini, Anda perlu membuat akun penyimpanan Azure dan kontainernya secara manual atau melalui konfigurasi Terraform terpisah. Penyiapan ini memastikan pengelolaan sumber daya Azure yang aman dan kolaboratif.

Ekosistem provider dan AzureRM

Provider azurerm adalah jembatan Terraform ke Azure, menerjemahkan HCL menjadi panggilan API untuk mengelola layanan seperti VM, jaringan, dan database. 

Ini mendukung ratusan jenis resource, dari komputasi (azurerm_linux_virtual_machine, azurerm_windows_virtual_machine) hingga analitik (azurerm_synapse_workspace). Beberapa fiturnya meliputi:

• Cakupan luas: Kelola beragam layanan Azure, termasuk virtual machine, storage account, Azure Kubernetes Service (AKS), Azure SQL Database, Azure Cosmos DB dengan MongoDB API, Azure Functions, dan banyak lagi. Provider azurerm aktif dikembangkan untuk mendukung layanan dan fitur Azure baru saat tersedia.
• Fungsi dinamis: Gunakan fungsi yang didefinisikan provider untuk menghasilkan nama unik (misalnya, azurerm_resource_group.example.name) atau mengambil detail dari sumber daya yang sudah ada (misalnya, data.azurerm_virtual_network.existing.id). Ini memungkinkan konfigurasi yang lebih dinamis dan cerdas.
• Data source: Provider azurerm memanfaatkan data source untuk mengambil informasi tentang sumber daya Azure yang sudah ada. Ini sangat berguna saat Anda perlu mereferensikan resource yang tidak diprovisikan oleh konfigurasi Terraform saat ini. Misalnya, Anda dapat mengambil detail virtual network yang sudah ada untuk mendeploy subnet atau virtual machine baru tanpa membuat ulang VNet.

Sebelum mendalami Terraform, ada baiknya memahami cara mengonfigurasi Azure secara manual—panduan pemula ini membahas hal-hal pentingnya.

Menyiapkan Lingkungan Terraform-Azure

Mari praktik langsung! Bagian ini memandu Anda melalui penyiapan awal yang diperlukan untuk menggunakan Terraform dengan langganan Azure Anda.

Autentikasi dan alat CLI

Untuk berinteraksi dengan Azure, pertama-tama Anda perlu memasang dan mengonfigurasi Azure Command Line Interface (CLI). Azure CLI menyediakan alat yang diperlukan untuk autentikasi dan pengelolaan sumber daya Azure Anda. Setelah terpasang, masuk ke akun Azure Anda:

az loginDidukung oleh

Perintah di atas akan membuka jendela peramban untuk autentikasi interaktif. Untuk rujukan cepat, lembar contekan Azure CLI ini dapat mempercepat alur kerja baris perintah Anda.

Untuk deployment terotomatisasi dengan Terraform, terutama di pipeline CI/CD, sangat disarankan untuk membuat dan menggunakan service principal Azure Active Directory (AAD). Service principal menyediakan cara yang aman dan terprogram bagi Terraform untuk melakukan autentikasi dengan langganan Azure Anda tanpa memerlukan login interaktif.

Untuk membuat service principal dengan peran "Contributor" pada cakupan langganan, jalankan:

az ad sp create-for-rbac --name "http://myTerraformServicePrincipal" --role "Contributor" --scopes "/subscriptions/<your-subscription-id>"Didukung oleh

Output akan menyediakan appId, password, dan tenant (ID penyewa). Anda kemudian dapat menyetelnya sebagai variabel lingkungan untuk Terraform:

export ARM_CLIENT_ID="<appId>"
export ARM_CLIENT_SECRET="<password>"
export ARM_TENANT_ID="<tenant>"
export ARM_SUBSCRIPTION_ID="<your-subscription-id>"Didukung oleh

Menginisialisasi proyek

Proyek Terraform yang khas mengikuti tata letak direktori terstruktur, sering kali dengan berkas .tf terpisah untuk jenis resource atau module yang berbeda (misalnya, main.tf, variables.tf, outputs.tf, network.tf, compute.tf). 

Untuk memulai proyek Terraform apa pun, buka direktori proyek Anda dan jalankan perintah terraform init. Perintah ini menginisialisasi direktori kerja, mengunduh plugin provider yang diperlukan (seperti azurerm), dan menyiapkan backend untuk manajemen state sebagaimana didefinisikan dalam konfigurasi Anda.

mkdir my-azure-terraform-project
cd my-azure-terraform-project
# Create your .tf files here
terraform initDidukung oleh

Perintah ini menyiapkan direktori Anda untuk operasi Terraform, memastikan semua plugin yang dibutuhkan tersedia.

Menyediakan Sumber Daya Azure

Bagian ini menyajikan contoh praktis penyediaan sumber daya Azure umum menggunakan Terraform, menunjukkan cara mendefinisikan dan mendeploynya secara terprogram.

Virtual network dan subnet

Terraform unggul dalam mendefinisikan dan mendeploy infrastruktur jaringan di Azure. Anda dapat dengan mudah mendefinisikan virtual network (VNet) dan membaginya menjadi subnet, mengendalikan ruang alamat IP dan isolasi jaringan. 

Manajemen dependensi bawaan Terraform memastikan resource dibuat dengan urutan yang benar; misalnya, subnet hanya akan diprovisikan setelah VNet induknya berhasil dibuat. Berikut contohnya:

resource "azurerm_resource_group" "network_rg" {
  name     = "my-network-rg"
  location = "East US"
}

resource "azurerm_virtual_network" "main_vnet" {
  name                = "my-vnet"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.network_rg.location
  resource_group_name = azurerm_resource_group.network_rg.name
}

resource "azurerm_subnet" "web_subnet" {
  name                 = "web-subnet"
  resource_group_name  = azurerm_resource_group.network_rg.name
  virtual_network_name = azurerm_virtual_network.main_vnet.name
  address_prefixes     = ["10.0.1.0/24"]
}

resource "azurerm_subnet" "app_subnet" {
  name                 = "app-subnet"
  resource_group_name  = azurerm_resource_group.network_rg.name
  virtual_network_name = azurerm_virtual_network.main_vnet.name
  address_prefixes     = ["10.0.2.0/24"]
}Didukung oleh

Virtual machine dengan cloud-init

Menyediakan virtual machine (VM) dengan Terraform itu mudah. Untuk mengotomatiskan konfigurasi pascadeployment dan penyiapan awal, Anda dapat memanfaatkan skrip cloud-init. 

cloud-init memungkinkan Anda menyuntikkan skrip yang berjalan pada boot pertama VM, sehingga dapat melakukan tugas seperti memasang perangkat lunak, mengonfigurasi pengguna, atau menyiapkan layanan, langsung dari konfigurasi Terraform Anda.

Berikut contoh penyediaan Linux VM dengan skrip cloud-init sederhana untuk memasang Nginx:

resource "azurerm_resource_group" "vm_rg" {
  name     = "my-vm-rg"
  location = "East US"
}

resource "azurerm_network_interface" "vm_nic" {
  name                = "my-vm-nic"
  location            = azurerm_resource_group.vm_rg.location
  resource_group_name = azurerm_resource_group.vm_rg.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.web_subnet.id # Assuming web_subnet defined above
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.vm_public_ip.id
  }
}

resource "azurerm_public_ip" "vm_public_ip" {
  name                = "my-vm-public-ip"
  location            = azurerm_resource_group.vm_rg.location
  resource_group_name = azurerm_resource_group.vm_rg.name
  allocation_method   = "Static"
}

resource "azurerm_linux_virtual_machine" "my_vm" {
  name                  = "my-linux-vm"
  location              = azurerm_resource_group.vm_rg.location
  resource_group_name   = azurerm_resource_group.vm_rg.name
  size                  = "Standard_B2s"
  admin_username        = "azureuser"
  admin_password        = "P@ssw0rd1234!" # In a real scenario, use Azure Key Vault or variables
  network_interface_ids = [azurerm_network_interface.vm_nic.id]

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }

  # cloud-init script to install Nginx
  custom_data = base64encode(<<EOF
#cloud-config
packages:
  - nginx
runcmd:
  - systemctl start nginx
  - systemctl enable nginx
EOF
  )
}Didukung oleh

Memodularisasi infrastruktur

Seiring pertumbuhan infrastruktur Azure Anda, memodularisasi konfigurasi Terraform menjadi krusial untuk kegunaan ulang, keterkelolaan, dan skalabilitas. 

Module mengenkapsulasi serangkaian resource terkait beserta konfigurasinya menjadi unit yang dapat digunakan kembali. Bagian ini akan memberikan panduan strukturisasi kode Terraform Anda menjadi module dan menunjukkan cara memanggil module tersebut dalam konfigurasi utama, sehingga basis kode menjadi lebih bersih dan terorganisasi.

Contoh: Struktur module (modules/web-app/main.tf):

# modules/web-app/main.tf
resource "azurerm_app_service_plan" "app_plan" {
  name                = var.app_service_plan_name
  location            = var.location
  resource_group_name = var.resource_group_name
  kind                = "Linux"
  sku {
    tier = "Basic"
    size = "B1"
  }
}

resource "azurerm_app_service" "app_service" {
  name                = var.app_service_name
  location            = var.location
  resource_group_name = var.resource_group_name
  app_service_plan_id = azurerm_app_service_plan.app_plan.id
}

variable "app_service_plan_name" {
  type = string
}

variable "app_service_name" {
  type = string
}

variable "location" {
  type = string
}

variable "resource_group_name" {
  type = string
}

output "app_service_default_hostname" {
  value = azurerm_app_service.app_service.default_host_name
}Didukung oleh

Contoh: Memanggil module (main.tf di direktori root):

resource "azurerm_resource_group" "app_rg" {
  name     = "my-webapp-rg"
  location = "East US"
}

module "my_web_app" {
  source                = "./modules/web-app" # Path to your module
  app_service_plan_name = "my-webapp-plan"
  app_service_name      = "my-unique-webapp-2025"
  location              = azurerm_resource_group.app_rg.location
  resource_group_name   = azurerm_resource_group.app_rg.name
}

output "webapp_url" {
  value = module.my_web_app.app_service_default_hostname
}Didukung oleh

Struktur ini memudahkan penggunaan ulang logika deployment aplikasi web Anda di berbagai environment atau proyek.

Alur Kerja Terraform Lanjutan

Bagian ini mengeksplorasi fitur Terraform yang lebih canggih untuk meningkatkan fleksibilitas dan kekuatan deployment infrastruktur Anda, melampaui penyediaan resource dasar.

Data source dan konfigurasi dinamis

Data source di Terraform memungkinkan Anda mengambil informasi tentang resource yang sudah ada, baik yang dikelola Terraform maupun tidak. Ini sangat berguna untuk integrasi dengan infrastruktur yang sudah ada atau untuk pencarian dinamis. 

Dipadukan dengan konfigurasi dinamis (seperti for_each dan count), data source memungkinkan skrip Terraform yang sangat fleksibel dan adaptif yang dapat merespons berbagai kondisi dan ketersediaan resource.

Contoh: Menggunakan Data Source untuk menemukan VNet yang sudah ada dan menambahkan subnet baru:

# Data source to fetch an existing Virtual Network
data "azurerm_virtual_network" "existing_vnet" {
  name                = "production-vnet"
  resource_group_name = "production-network-rg"
}

# Create a new subnet within the existing VNet
resource "azurerm_subnet" "new_app_subnet" {
  name                 = "new-app-subnet"
  resource_group_name  = data.azurerm_virtual_network.existing_vnet.resource_group_name
  virtual_network_name = data.azurerm_virtual_network.existing_vnet.name
  address_prefixes     = ["10.0.3.0/24"]
}Didukung oleh

Contoh: Pembuatan dinamis banyak VM menggunakan for_each dan variabel map:

variable "vm_configs" {
  type = map(object({
    size = string
    ip   = string
  }))
  default = {
    "web-server-01" = { size = "Standard_B1s", ip = "10.0.1.10" },
    "web-server-02" = { size = "Standard_B1s", ip = "10.0.1.11" }
  }
}

resource "azurerm_linux_virtual_machine" "web_servers" {
  for_each              = var.vm_configs
  name                  = each.key
  location              = azurerm_resource_group.main_rg.location
  resource_group_name   = azurerm_resource_group.main_rg.name
  size                  = each.value.size
  admin_username        = "azureuser"
  admin_password        = "StrongPassword!123" # Use Key Vault in production
  network_interface_ids = [azurerm_network_interface.web_servers_nic[each.key].id]

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }
}

resource "azurerm_network_interface" "web_servers_nic" {
  for_each            = var.vm_configs
  name                = "${each.key}-nic"
  location            = azurerm_resource_group.main_rg.location
  resource_group_name = azurerm_resource_group.main_rg.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.web_subnet.id
    private_ip_address_allocation = "Static"
    private_ip_address            = each.value.ip
  }
}Didukung oleh

Policy as code dengan Sentinel

Untuk organisasi yang membutuhkan kepatuhan dan tata kelola ketat, HashiCorp Sentinel menyediakan kerangka policy-as-code yang terintegrasi dengan Terraform Enterprise (atau dapat diadaptasi untuk penggunaan kustom dengan Terraform Cloud). 

Sentinel memungkinkan Anda mendefinisikan kebijakan granular yang menegakkan praktik terbaik keamanan, biaya, dan operasional sebelum infrastruktur diprovisikan. 

Misalnya, kebijakan dapat mencegah pembuatan VM yang lebih besar dari ukuran tertentu atau memastikan semua resource memiliki tag tertentu. Kebijakan siap pakai dapat menegakkan standar kepatuhan, mencegah deployment yang tidak sesuai mencapai environment Azure Anda.

Strategi optimalisasi biaya

Terraform, bersama dengan Azure Policy, dapat menjadi alat yang kuat untuk menegakkan kontrol biaya dalam environment Azure Anda. 

Dengan mendefinisikan Azure Policy yang membatasi SKU resource, menegakkan tagging untuk alokasi biaya, atau mencegah deployment resource yang mahal, Anda dapat menerapkan langkah penghematan biaya yang efektif langsung di alur kerja IaC Anda. 

Terraform juga dapat mendeploy dan mengelola Azure Policy, memastikan aturan tata kelola Anda terkontrol versinya dan diterapkan secara konsisten.

Contoh: Mendeploy Definisi Azure Policy dengan Terraform:

resource "azurerm_resource_group" "policy_rg" {
  name     = "azure-policy-rg"
  location = "global" # Policies are global resources
}

resource "azurerm_policy_definition" "deny_large_vms" {
  name         = "deny-large-vm-skus"
  policy_type  = "Custom"
  mode         = "All"
  display_name = "Deny creation of large VM SKUs (E-series)"
  description  = "This policy denies the creation of Azure Virtual Machines with SKUs from the E-series for cost management."

  policy_rule = <<POLICY_RULE
{
  "if": {
    "allOf": [
      {
        "field": "type",
        "equals": "Microsoft.Compute/virtualMachines"
      },
      {
        "field": "Microsoft.Compute/virtualMachines/sku.name",
        "like": "Standard_E*"
      }
    ]
  },
  "then": {
    "effect": "deny"
  }
}
POLICY_RULE
}

resource "azurerm_policy_assignment" "deny_large_vms_assignment" {
  name                 = "deny-large-vm-skus-assignment"
  scope                = "/subscriptions/${data.azurerm_subscription.current.id}" # Assign to entire subscription
  policy_definition_id = azurerm_policy_definition.deny_large_vms.id
  display_name         = "Deny large VM SKUs"
}

data "azurerm_subscription" "current" {}Didukung oleh

Kombinasi ini memungkinkan Anda menegakkan kebijakan biaya organisasi secara otomatis, mencegah pemborosan dan mendorong efisiensi resource.

Integrasi CI/CD

Bagian ini berfokus pada mengintegrasikan Terraform ke pipeline Continuous Integration/Continuous Delivery (CI/CD) Anda untuk deployment yang terotomatisasi dan andal, menjadikan perubahan infrastruktur bagian mulus dari siklus pengembangan perangkat lunak Anda.

Pipeline Azure DevOps

Azure DevOps menyediakan platform tangguh untuk membangun pipeline CI/CD. Alur kerja umum mencakup:

1. Inisialisasi: terraform init untuk mengunduh provider dan menyiapkan backend.
2. Plan: terraform plan -out untuk menghasilkan rencana eksekusi dan menyimpannya.
3. Tinjau (persetujuan manual): Tahap di mana rencana yang dihasilkan ditinjau oleh manusia untuk disetujui sebelum diterapkan.
4. Apply: terraform apply tfplan untuk mengeksekusi perubahan.

Anda dapat mengeksplor bagaimana Azure DevOps mendukung alur kerja CI/CD ujung ke ujung untuk penyebaran aplikasi di tutorial praktis ini.

GitHub Actions

GitHub Actions menawarkan cara yang fleksibel dan kuat untuk mengotomatiskan alur kerja Terraform langsung di dalam repositori GitHub Anda. Ini menggunakan berkas YAML untuk mendefinisikan alur kerja yang merespons peristiwa seperti push atau pull request.

Berikut langkah-langkah untuk deployment Terraform dasar menggunakan GitHub Actions:

1. Tentukan pemicu workflow: Biasanya on: push ke cabang tertentu (misalnya, main).
2. Checkout kode: Gunakan actions/checkout@v3.
3. Konfigurasi kredensial Azure: Atur variabel lingkungan menggunakan GitHub Secrets (misalnya, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID, AZURE_SUBSCRIPTION_ID).
4. Instal Terraform: Gunakan hashicorp/setup-terraform@v2.
5. Terraform init: Inisialisasi direktori kerja.
6. Terraform plan: Buat dan keluarkan rencana eksekusi.
7. Terraform apply (kondisional): Terapkan perubahan, sering kali bersyarat pada langkah persetujuan manual atau cabang tertentu.

Contoh: YAML untuk workflow GitHub Actions (.github/workflows/terraform-azure.yml):

name: 'Terraform Azure CI/CD'

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

env:
  ARM_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
  ARM_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
  ARM_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
  ARM_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  TF_STATE_RG: 'my-terraform-state-rg'
  TF_STATE_SA: 'mystorageterraformstate'
  TF_STATE_CONTAINER: 'tfstate'
  TF_STATE_KEY: 'production/terraform.tfstate'

jobs:
  terraform:
    name: 'Terraform Actions'
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: './terraform' # Assuming Terraform files are in a 'terraform' folder

    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v2
      - name: Terraform Init
        id: init
        run: terraform init -backend-config="resource_group_name=${{ env.TF_STATE_RG }}" -backend-config="storage_account_name=${{ env.TF_STATE_SA }}" -backend-config="container_name=${{ env.TF_STATE_CONTAINER }}" -backend-config="key=${{ env.TF_STATE_KEY }}"
      - name: Terraform Plan
        id: plan
        run: terraform plan -no-color
      - name: Terraform Apply
        if: github.ref == 'refs/heads/main' && github.event_name == 'push'
        run: terraform apply -auto-approveDidukung oleh

Keamanan dan Kepatuhan

Bagian ini menyoroti pertimbangan keamanan dan kepatuhan saat bekerja dengan Terraform di Azure, menekankan praktik aman untuk data sensitif dan akses jaringan.

Integrasi Azure Key Vault

Mengelola data sensitif seperti kunci API, string koneksi, kredensial database, dan sertifikat dalam konfigurasi Terraform Anda bisa berisiko jika tidak ditangani dengan benar. Azure Key Vault menyediakan solusi terpusat yang aman untuk menyimpan dan mengelola secrets, keys, dan certificates. 

Contoh: Mengambil kata sandi database dari Key Vault:

# Data source to retrieve an existing Azure Key Vault
data "azurerm_key_vault" "my_key_vault" {
  name                = "my-secure-keyvault"
  resource_group_name = "my-secrets-rg"
}

# Data source to retrieve a specific secret from the Key Vault
data "azurerm_key_vault_secret" "db_password" {
  name         = "DbPassword"
  key_vault_id = data.azurerm_key_vault.my_key_vault.id
}

resource "azurerm_sql_server" "example" {
  administrator_login          = "sqladmin"
  administrator_login_password = data.azurerm_key_vault_secret.db_password.value # Securely retrieve password
}Didukung oleh

Metode ini memastikan bahwa data sensitif tidak pernah terekspos langsung dalam kode Terraform atau berkas state Anda, sesuai praktik keamanan terbaik.

Network Security Group (NSG)

Network Security Group (NSG) adalah dasar untuk menerapkan aturan lalu lintas dan mengamankan virtual network Azure Anda. NSG bertindak sebagai firewall virtual, mengizinkan atau menolak lalu lintas jaringan masuk dan keluar ke resource Azure Anda berdasarkan aturan yang Anda tetapkan.

Contoh: Mengonfigurasi NSG untuk aplikasi web:

resource "azurerm_network_security_group" "web_nsg" {
  name                = "web-nsg"
  location            = azurerm_resource_group.network_rg.location
  resource_group_name = azurerm_resource_group.network_rg.name

  security_rule {
    name                       = "AllowHTTPInbound"
    priority                   = 100
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "80"
    source_address_prefix      = "Internet"
    destination_address_prefix = "*"
  }
  security_rule {
    name                       = "AllowSSHInbound"
    priority                   = 120
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "22"
    source_address_prefix      = "YourTrustedIPRange" # IMPORTANT: Restrict to known IPs
    destination_address_prefix = "*"
  }
}

# Associate NSG with a subnet 
resource "azurerm_subnet_network_security_group_association" "web_subnet_nsg_association" {
  subnet_id                 = azurerm_subnet.web_subnet.id
  network_security_group_id = azurerm_network_security_group.web_nsg.id
}Didukung oleh

Praktik Terbaik untuk Deployment Perusahaan

Bagian ini menguraikan praktik terbaik penting untuk mendeploy dan mengelola Terraform dalam skala besar di lingkungan perusahaan, berfokus pada desain, pemeliharaan, dan pemantauan.

Arsitektur referensi

Untuk deployment Azure yang tangguh dan efisien, selaraskan konfigurasi Terraform Anda dengan Azure Well-Architected Framework. Kerangka ini menyediakan cetak biru untuk merancang solusi cloud yang berkualitas tinggi, aman, hemat biaya, serta membimbing desain Terraform Anda untuk keandalan, keamanan, optimalisasi biaya, keunggulan operasional, dan efisiensi kinerja.

Kebersihan berkas state

Berkas state Terraform adalah sumber kebenaran tunggal untuk infrastruktur Anda. Pastikan integritas dan keamanannya dengan:

• Penyimpanan jarak jauh: Selalu gunakan backend jarak jauh seperti Azure Blob Storage untuk manajemen state kolaboratif.
• Enkripsi dan kontrol akses: Pastikan state jarak jauh Anda terenkripsi saat disimpan dan terapkan Azure RBAC yang ketat untuk membatasi akses.
• Penguncian dan versi state: Manfaatkan penguncian state bawaan untuk mencegah konflik dan aktifkan versioning pada kontainer penyimpanan Anda untuk pelacakan historis dan pemulihan.

Pemantauan dan deteksi drift

Pertahankan konsistensi infrastruktur dengan aktif memantau "configuration drift"—penyimpangan yang tidak diotorisasi dari state Terraform yang Anda definisikan.

• Deteksi proaktif: Terapkan terraform plan berkala dalam pipeline CI/CD Anda (misalnya, setiap malam) untuk mengidentifikasi perubahan.
• Pemantauan Azure: Manfaatkan Azure Monitor dan Log Analytics untuk melacak kesehatan resource dan peristiwa.
• Remediasi otomatis: Kembangkan proses (manual atau otomatis) untuk menjalankan kembali terraform apply guna mengembalikan resource yang menyimpang agar sesuai dengan IaC Anda.

Untuk lebih lanjut memantau dan mengoptimalkan infrastruktur Anda, Azure Monitor menyediakan wawasan berharga—panduan ini menunjukkan cara memulainya.

Kesimpulan

Selesai! Sekarang Anda telah melihat bagaimana Terraform dapat membuat pengelolaan sumber daya Azure jauh lebih efisien dan dapat diprediksi. Kita melihat cara menghadirkan otomasi ke alur kerja Anda dengan alat CI/CD seperti Azure DevOps dan GitHub Actions, serta cara menjaga keamanan menggunakan fitur seperti Azure Key Vault dan Network Security Group.

Kita juga menyinggung beberapa praktik terbaik penting—seperti menggunakan arsitektur referensi, mengelola berkas state dengan cermat, dan memantau perubahan dengan monitoring dan deteksi drift.

Dengan alat dan kiat ini, Anda siap membangun infrastruktur yang lebih andal dan skalabel di Azure.

Ingin memvalidasi keterampilan Anda? Pertanyaan wawancara Terraform ini dapat membantu Anda bersiap untuk peluang kerja atau sertifikasi!