Cara Pony.ai menggunakan Terraform untuk mencapai otomatisasi infrastruktur cloud 100% - Terraform

Tim DevOps Pony.ai berbagi bagaimana mereka mengadopsi Terraform untuk sepenuhnya mengotomatiskan infrastruktur cloud mereka—mulai dari pemilihan teknologi, keputusan arsitektur, hingga solusi yang dibangun guna menangani penggunaan ulang kode dan penerapan di berbagai lingkungan.

Latar Belakang

Didirikan pada tahun 2016, Pony.ai adalah perusahaan teknologi kendaraan otonom global dengan pusat R&D di Silicon Valley, Guangzhou, Beijing, Shanghai, dan Shenzhen. Perusahaan ini memiliki izin uji coba dan operasional kendaraan otonom di berbagai lokasi di AS dan Tiongkok, serta bekerja sama dengan produsen mobil seperti Toyota, Hyundai, FAW Group, dan GAC Group.

Operasi Pony.ai di Tiongkok berjalan di Alibaba Cloud, yang menyediakan layanan kritis seperti pelabelan data, platform Robotaxi, dan Robotruck. Layanan-layanan tersebut bergantung pada Elastic Compute Service (ECS), ApsaraDB RDS (RDS), Server Load Balancer (SLB), Bastionhost, dan Security Center—sehingga manajemen infrastruktur menjadi semakin kompleks bagi tim DevOps.

Untuk mengatasi hal ini, tim menetapkan tiga tujuan utama:

Penerapan yang dapat ditinjau: Setiap tahap aktivitas operasional—mulai dari pengumpulan kebutuhan, desain arsitektur, pengkodean, hingga penerapan—harus akurat dan dapat dilacak.
Penerapan terkontrol versi: Riwayat lengkap dan dapat diaudit atas semua perubahan infrastruktur, dengan kemampuan melakukan rollback ke versi tertentu.
Penerapan multi-lingkungan yang konsisten: Tidak ada perbedaan antara lingkungan development, staging, dan production yang dapat menyebabkan kegagalan spesifik lingkungan.

Pemilihan teknologi

Tim mengevaluasi tiga pendekatan utama untuk mengelola sumber daya cloud publik:

Konsol penyedia cloud: Manajemen langsung melalui GUI.
Sistem manajemen kustom: Membangun atau membeli sistem yang memanggil API penyedia cloud.
Kerangka Infrastructure as Code (IaC): Menggunakan kode untuk mendefinisikan dan mengelola infrastruktur.

3steps

IaC merupakan standar mapan untuk otomatisasi infrastruktur dan kerangka kerja paling luas digunakan dalam manajemen multi-cloud. Dipadukan dengan Git, IaC secara langsung menjawab tujuan pelacakan dan pengendalian versi—setiap penerapan dan perubahan dikelola sebagai kode, dan rollback semudah mengembalikan ke branch Git sebelumnya.

Dalam ekosistem IaC, Terraform adalah tool open-source terkemuka dengan rekam jejak kuat di lingkungan produksi enterprise. Dengan mengadopsi Terraform, tim DevOps dapat fokus menulis logika bisnis untuk infrastruktur mereka daripada membangun sistem orkestrasi kustom dari nol.

Mengingat strategi multi-cloud dan arsitektur cloud hibrida Pony.ai, standardisasi, kemudahan penggunaan, serta komunitas aktif Terraform menjadikannya pilihan yang jelas.

Arsitektur dan implementasi

Tim menerapkan solusi IaC berbasis Terraform dengan alur kerja berpusat pada Git, seperti yang ditunjukkan di bawah ini:

arch

Untuk file konfigurasi, tim memilih JSON daripada HashiCorp Configuration Language (HCL) agar konsisten dengan aplikasi berbasis JSON yang sudah ada dan menyederhanakan tinjauan kode.

Kode diorganisir berdasarkan layanan bisnis. Jika suatu layanan memerlukan SLB, sertifikat, dan instance ECS, semua sumber daya tersebut didefinisikan dalam satu file Terraform untuk layanan tersebut. Berikut contoh sederhananya:

{
    "output": {
        "ecs_instance_1-private-ip": {
            "value": "${alicloud_instance.ecs_instance_1.private_ip}"
        }, 
        "ecs_instance_2-private-ip": {
            "value": "${alicloud_instance.ecs_instance_2.private_ip}"
        }, 
        "ponyai_business_1-slb-address": {
            "value": "${alicloud_slb.ponyai_business_1-slb.address}"
        }
    }, 
    "provider": {
        "alicloud": {
            "region": "alicloud_region"
        }
    }, 
    "resource": {
        "alicloud_instance": {
            "ecs_instance_1": {
                "availability_zone": "availability_zone_1", 
                "data_disks": [
                    {
                        "category": "cloud_essd", 
                        "name": "data_volume", 
                        "size": "xx"
                    }
                ], 
                "host_name": "ecs_instance_1", 
                "image_id": "image_id_1", 
                "instance_name": "ecs_instance_1", 
                "instance_type": "ecs_instance_type", 
                "internet_charge_type": "PayByTraffic", 
                "internet_max_bandwidth_out": 10, 
                "key_name": "key_name_1", 
                "security_groups": [
                    "security_groups_1"
                ], 
                "system_disk_category": "cloud_essd", 
                "system_disk_size": "xx", 
                "tags": {
                    "host_name": "ecs_instance_1"
                }, 
                "vswitch_id": "vswitch_id_1"
            }, 
            "ecs_instance_2": {
                "availability_zone": "availability_zone_2", 
                "data_disks": [
                    {
                        "category": "cloud_essd", 
                        "name": "data_volume", 
                        "size": "xx"
                    }
                ], 
                "host_name": "availability_zone_2", 
                "image_id": "image_id_1", 
                "instance_name": "availability_zone_2", 
                "instance_type": "ecs_instance_type", 
                "internet_charge_type": "PayByTraffic", 
                "internet_max_bandwidth_out": 10, 
                "key_name": "key_name_1", 
                "security_groups": [
                    "security_groups_1"
                ], 
                "system_disk_category": "cloud_essd", 
                "system_disk_size": "xx", 
                "tags": {
                    "host_name": "availability_zone_2"
                }, 
                "vswitch_id": "vswitch_id_2"
            }
        }, 
        "alicloud_slb": {
            "slb-1": {
                "address_type": "internet", 
                "internet_charge_type": "PayByTraffic", 
                "name": "slb_name", 
                "specification": "slb_specification"
            }
        }, 
        "alicloud_slb_listener": {
            "slb-listener-1": {
                "backend_port": "xx", 
                "bandwidth": -1, 
                "frontend_port": "xx", 
                "health_check": "on", 
                "health_check_connect_port": "xx", 
                "health_check_domain": "domain_name", 
                "health_check_type": "check_type", 
                "health_check_uri": "uri_1", 
                "load_balancer_id": "${alicloud_slb.slb-1.id}", 
                "protocol": "protocol_1", 
                "scheduler": "scheduler_1", 
                "server_certificate_id": "${alicloud_slb_server_certificate.slb-certificate-1.id}", 
                "server_group_id": "${alicloud_slb_server_group.slb-server-group-1.id}"
            }
        }, 
        "alicloud_slb_server_certificate": {
            "slb-certificate-1": {
                "alicloud_certificate_id": "xx", 
                "alicloud_certificate_name": "xx", 
                "name": "certificate_1"
            }
        }, 
        "alicloud_slb_server_group": {
            "slb-server-group-1": {
                "load_balancer_id": "${alicloud_slb.slb-1.id}", 
                "name": "slb-server-group", 
                "servers": {
                    "port": "xx", 
                    "server_ids": [
                        "${alicloud_instance.ecs_instance_1.id}", 
                        "${alicloud_instance.ecs_instance_2.id}"
                    ]
                }
            }
        }
    }, 
    "terraform": {
        "backend": {
            "s3": {
                "bucket": "bucket_name", 
                "dynamodb_table": "table", 
                "key": "key_1", 
                "profile": "profile_1", 
                "region": "region_1"
            }
        }, 
        "required_providers": {
            "alicloud": {
                "source": "aliyun/alicloud", 
                "version": "xx"
            }
        }
    }
}

Tantangan bisnis

Saat basis kode Terraform berkembang, dua masalah muncul:

Untuk sumber daya seperti instance ECS, engineer hanya peduli pada sejumlah kecil parameter—instance_type, instance_name, availability_zone—tetapi harus mendefinisikan konfigurasi lengkap setiap kali.
Penerapan layanan yang sama di berbagai lingkungan (development, staging, production) berarti konfigurasi hampir identik dengan hanya sedikit perbedaan, seperti menggunakan SLB slb.s2.medium di production versus slb.s1.small di lingkungan uji. Menyalin dan menulis ulang kode untuk setiap lingkungan mengurangi keterbacaan dan kemudahan pemeliharaan.

Solusi

Untuk mengatasi masalah ini, tim memperkenalkan Jsonnet—bahasa templating data open-source—untuk menghasilkan file JSON Terraform. Jsonnet memungkinkan mereka mengabstraksi boilerplate berulang ke dalam pustaka fungsi utilitas yang dapat digunakan kembali. Sebagai contoh, mereka membangun fungsi generateEcs yang membungkus semua parameter default ECS:

generateEcs(instance_name,
            availability_zone,
            vswitch_id,
            security_groups,
            instance_type,
            host_name,
            data_volume_size=null,
            system_disk_size=null,
            internet_charge_type="PayByTraffic",
            image_id="ubuntu_18_04_x64_20G_alibase_20200914.vhd",
            key_name="bootstrap-bot",
            system_disk_category="cloud_essd",
            internet_max_bandwidth_out=10,
            data_disk_category="cloud_essd"): {
  instance_name: instance_name,
  availability_zone: availability_zone,
  vswitch_id: vswitch_id,
  security_groups: security_groups,
  instance_type: instance_type,
  internet_charge_type: internet_charge_type,
  image_id: image_id,
  system_disk_category: system_disk_category,
  [if system_disk_size != null then "system_disk_size"]:
    system_disk_size,
    key_name: key_name,
    internet_max_bandwidth_out: internet_max_bandwidth_out,
    host_name: host_name,
    data_disks: if data_volume_size != null then [
      {
        name: "data_volume",
        size: data_volume_size,
        category: data_disk_category,
      },
    ] else [],
      tags: {
        host_name: host_name,
      },
}

Engineer memanggil fungsi ini untuk menghasilkan konfigurasi lengkap, sehingga kode yang dibutuhkan untuk menyediakan beberapa instance direduksi menjadi loop ringkas:

alicloud_instance: {
  [host_config.host_name]:
    ecsUtils.generateEcs(
      instance_name=host_config.host_name,
      availability_zone=host_config.az,
      security_groups=$.ecs_security_groups,
      host_name=host_config.host_name,
      instance_type=$.ecs_instance_type,
      vswitch_id=vpc_output["vswitch-public-" + host_config.az].value,
      data_volume_size=$.ecs_data_volume_size,
      system_disk_size=$.ecs_system_disk_size
    )
  for host_config in host_configs
},

Setiap perubahan parameter dilakukan di fungsi utilitas bersama, bukan di setiap definisi sumber daya individual.

Konfigurasi multi-lingkungan

Untuk layanan yang berjalan di berbagai lingkungan dengan hanya sedikit perbedaan parameter, tim mendefinisikan templat dasar. Konfigurasi setiap lingkungan mengimpor templat dasar tersebut dan hanya mengganti bidang yang berubah.

Hal ini menghasilkan struktur direktori berikut untuk setiap layanan:

Catatan

generated/main.tf.json adalah file JSON yang dieksekusi oleh Terraform. File ini dihasilkan oleh Jsonnet dari main.tf.json.jsonnet. File main.tf.json.jsonnet.output berisi output yang dihasilkan setelah Terraform menerapkan konfigurasi.

├── alicloud-region
│   ├── dev
│   │   ├── generated
│   │   │   └── main.tf.json
│   │   ├── main.tf.json.jsonnet
│   │   └── main.tf.json.jsonnet.output
│   ├── prod
│   │   ├── generated
│   │   │   └── main.tf.json
│   │   ├── main.tf.json.jsonnet
│   │   └── main.tf.json.jsonnet.output
│   └── staging
│       ├── generated
│       │   └── main.tf.json
│       ├── main.tf.json.jsonnet
│       └── main.tf.json.jsonnet.output
└── ponyai_business_1_base.libsonnet

Lingkungan production mengimpor templat dasar dan menetapkan spesifikasi SLB-nya sendiri:

local base = import "../../ponyai_business_1_base.libsonnet";
base {
  name: "ponyai_business_1_prod",
  environment: "prod",
  region: "alicloud_region",
  slb_specification: "slb.s2.medium"
}

Lingkungan development mengimpor templat dasar yang sama dan hanya mengganti nama serta spesifikasinya:

local base = import "../../ponyai_business_1_base.libsonnet";
base {
  name: "ponyai_business_1_dev",
  environment: "dev",
  region: "alicloud_region",
  slb_specification: "slb.s1.small"
}

Referensi lintas-stack

Jsonnet juga menyelesaikan masalah dependensi antar komponen infrastruktur. Membuat instance ECS memerlukan ID Virtual Private Cloud (VPC), tetapi VPC biasanya dikelola dalam file Terraform terpisah. Alih-alih hardcoding ID VPC yang dihasilkan, alur kerja Pony.ai membacanya dari file output stack VPC.

File main.tf.json membuat VPC dan menulis ID-nya ke main.tf.json.jsonnet.output di direktorinya sendiri:

├── ali-cloud-region
│   ├── dev
│   │   ├── generated
│   │   │   └── main.tf.json
│   │   ├── main.tf.json.jsonnet
│   │   └── main.tf.json.jsonnet.output
│   └── prod
│       ├── generated
│       │   └── main.tf.json
│       ├── main.tf.json.jsonnet
│       └── main.tf.json.jsonnet.output

File main.tf.json.jsonnet.output yang dihasilkan tampak seperti ini:

{
  "vpc_id": {
    "sensitive": false,
    "type": "string",
    "value": "vpc_id_for_ponyai"
  },
"vswitch-id": {
    "sensitive": false,
    "type": "string",
    "value": "vswitch_public_id_for_ponyai"
  }
}

Layanan apa pun yang memerlukan nilai-nilai ini mengimpor file output tersebut secara langsung:

{
"ali-cloud-region": {
  prod: import "./ali-cloud-region/prod/main.tf.json.jsonnet.output",
  }
}

Abstraksi berlapis ini memungkinkan tim DevOps Pony.ai memanfaatkan sepenuhnya ekosistem Terraform sekaligus menjaga dependensi antar layanan tetap bersih dan eksplisit.

Hasil bisnis

Penerapan IaC dengan Terraform dan Git telah memberikan peningkatan nyata di seluruh siklus hidup infrastruktur. Semua parameter infrastruktur didefinisikan secara eksplisit dalam kode—ketika suatu layanan memerlukan dua instance ECS dengan ukuran dan konfigurasi disk tertentu, setiap detailnya tersimpan dalam satu file.

Sebelum setiap penerapan, tim meninjau pull request (PR) lengkap di Git dan mendiskusikan perubahannya. Langkah tinjauan ini juga menciptakan catatan historis atas setiap perubahan infrastruktur, memberikan pelacakan lengkap.

Karena perubahan dapat ditinjau di tingkat parameter, tim dapat memastikan bahwa penerapan akhir sesuai dengan desain awal. Ketidaksesuaian yang terdeteksi selama fase pengkodean Terraform dapat diperbaiki sebelum mencapai production. Developer juga diwajibkan menjalankan pengujian mandiri sebelum membuka PR, sehingga menghindari beberapa siklus tinjauan untuk kode yang rusak.

Transformasi ini menghasilkan empat outcome utama:

Lebih cepat: Penyediaan infrastruktur tidak lagi merupakan rangkaian operasi manual berulang di Konsol. Siklus produksi yang lebih singkat memungkinkan perusahaan merespons keputusan bisnis dan peluang pasar lebih cepat.
Lebih terkendali: Setiap perubahan dikontrol versi dan dapat diaudit, meningkatkan organisasi dari operasi manual di Konsol ke sistem manajemen yang dapat dilacak dan tepercaya.
Lebih efisien: Kolaborasi lintas tim—termasuk tim yang tersebar secara internasional—telah meningkat signifikan, mengurangi keterlambatan akibat perbedaan zona waktu dan gaya kerja.
Lebih aman: Kemungkinan kesalahan manusia di production jauh lebih kecil. Menggabungkan proses otomatis berbasis kode dengan alur kerja persetujuan spesifik lingkungan memberikan perlindungan kuat bagi operasi bisnis Pony.ai.

Kesimpulan

Peningkatan model manajemen

Filosofi IaC kini menjadi fondasi seluruh pengembangan infrastruktur di Pony.ai. Tim telah mengabstraksi berbagai komponen Alibaba Cloud—termasuk ECS, VPC, Object Storage Service (OSS), Public DNS, Resource Access Management (RAM), Simple Log Service, dan manajemen pengguna—ke dalam fungsi internal yang dapat digunakan kembali.

Peningkatan model bisnis

Ketika suatu tim memerlukan sumber daya cloud, mereka memanggil salah satu fungsi pra-bangun yang telah diverifikasi. Tim DevOps fokus memelihara dan meningkatkan pustaka internal, yang mendorong peningkatan efisiensi operasional berkelanjutan di seluruh organisasi.

Peningkatan model operasional

Saat ini, lebih dari 20 unit bisnis di Pony.ai diterapkan dan dikelola 100% melalui alur kerja IaC ini. Setiap komponen memiliki riwayat versi yang jelas; perubahan melalui tinjauan ketat; dan tim dapat menolak penerapan yang tidak sesuai sebelum mencapai production. Hasilnya adalah lingkungan online yang bersih, andal, dan skalabel.

Tentang penulis

Tim DevOps Pony.ai

Artikel ini disumbangkan oleh penulis eksternal, dan seluruh hak cipta dimiliki oleh mereka. Alibaba Cloud tidak bertanggung jawab atas isi konten.