Edit Bab

Batal

# Bab 8: Dari Homelab ke Cloud

Ada satu titik dalam perjalanan homelab di mana anda mula terfikir, "Okay, macam mana kalau saya nak serve users sebenar?" Mungkin anda sudah buat app yang kawan-kawan guna, atau anda mahu host side project yang perlu uptime 24/7 tanpa bergantung pada power supply rumah anda.

Homelab adalah tempat terbaik untuk belajar. Tapi production workload ada requirements yang berbeza. Reliability, scalability, global accessibility. Ini bukan bermaksud homelab tidak berguna. Sebaliknya, skill yang anda belajar di homelab adalah foundation yang sangat solid untuk cloud.

Bab ini akan guide anda dari homelab ke cloud. Kita akan explore kenapa dan bila perlu cloud, bandingkan providers, dan deploy app sebenar ke cloud step by step.

## Apa yang anda akan belajar:

- Bila homelab tidak mencukupi dan kenapa cloud diperlukan
- Perbandingan cloud providers (AWS, GCP, Azure, DigitalOcean)
- Konsep cloud yang penting (VPC, IAM, load balancer, managed services)
- Cost management supaya bil cloud tidak mengejutkan anda
- Pendekatan hybrid: homelab dan cloud bersama
- Practical: deploy app ke DigitalOcean dan AWS
- Cloud certifications yang berbaloi untuk kerjaya

## Kenapa Cloud? Bila Homelab Tidak Cukup

Homelab ada limitasi yang cloud boleh selesaikan.

**Reliability.** Rumah anda ada power outage, internet down, atau hardware failure. Cloud providers ada multiple data centers dengan redundancy yang anda tidak mampu replicate di rumah.

**Scalability.** Anda boleh tambah RAM pada server homelab, tapi ada limit fizikal. Dalam cloud, anda boleh scale dari 1 server ke 100 server dalam masa beberapa minit.

**Global reach.** Kalau users anda di US dan Europe, serve dari server di rumah anda di Malaysia bermakna latency yang tinggi. Cloud providers ada data centers di seluruh dunia.

**Compliance.** Sesetengah industries require data disimpan di certified data centers. Homelab tidak memenuhi requirements ini.

**Bandwidth.** Home internet biasanya ada upload speed yang rendah dan ISP mungkin block certain ports.

Tapi ingat, cloud bukan jawapan untuk semua benda. Untuk development, testing, learning, dan personal projects, homelab masih sangat relevan dan jauh lebih murah.

> **Nota Beginner:** Jangan terus migrate semua ke cloud. Start dengan identify workloads yang benar-benar perlu cloud (public-facing apps, production APIs) dan keep yang lain di homelab (development, CI runners, media server, monitoring).

## Perbandingan Cloud Providers

### Amazon Web Services (AWS)

AWS adalah cloud provider paling besar dan paling mature. Ia mempunyai lebih daripada 200 services.

**Kelebihan:**
- Services paling lengkap. Apa sahaja yang anda perlukan, AWS mungkin ada.
- Community paling besar. Banyak tutorials, documentation, dan Stack Overflow answers.
- Free tier yang generous. 12 bulan free tier untuk banyak services.
- Paling banyak job opportunities.

**Kekurangan:**
- Learning curve yang steep. Terlalu banyak services boleh jadi overwhelming.
- Pricing yang complex. Bil boleh jadi mengejutkan kalau tidak monitor.
- Console UI yang kurang intuitive.

**Sesuai untuk:** Production workloads, enterprise, kalau anda target kerjaya cloud engineering.

### Google Cloud Platform (GCP)

GCP adalah cloud provider dari Google. Strong dalam data analytics, machine learning, dan Kubernetes.

**Kelebihan:**
- Google Kubernetes Engine (GKE) adalah managed Kubernetes terbaik.
- BigQuery untuk data analytics sangat powerful.
- Pricing lebih transparent dan predictable.
- UI yang lebih clean daripada AWS.

**Kekurangan:**
- Kurang services berbanding AWS.
- Community lebih kecil.
- Google ada track record shutdown products.

**Sesuai untuk:** Data-heavy applications, Kubernetes workloads, machine learning.

### Microsoft Azure

Azure adalah cloud provider dari Microsoft. Strong dalam enterprise dan integration dengan Microsoft ecosystem.

**Kelebihan:**
- Integration sempurna dengan Active Directory, Office 365, dan Windows ecosystem.
- Hybrid cloud capabilities yang baik.
- Enterprise compliance dan security features.

**Kekurangan:**
- Naming convention yang confusing (mereka rename services kerap).
- Documentation kadang-kadang tidak up to date.
- Pricing boleh jadi complex.

**Sesuai untuk:** Enterprise environments, organisations yang sudah guna Microsoft stack.

### DigitalOcean

DigitalOcean bukan "big three" tapi ia sangat popular di kalangan developers dan small teams.

**Kelebihan:**
- Paling simple dan straightforward.
- Pricing yang transparent dan predictable.
- Documentation yang sangat baik dan tutorials yang banyak.
- Perfect untuk small to medium projects.

**Kekurangan:**
- Kurang services advanced berbanding big three.
- Tidak suitable untuk enterprise-scale workloads.
- Kurang regions berbanding AWS atau GCP.

**Sesuai untuk:** Side projects, startups, small businesses, belajar cloud basics.

Recommendation saya untuk orang yang baru mula? DigitalOcean untuk hands-on learning dan side projects. AWS untuk kerjaya dan production workloads. Sebabnya simple. DigitalOcean tidak overwhelming, dan AWS adalah standard industri.

### Perbandingan Ringkas

| Feature | AWS | GCP | Azure | DigitalOcean |
|---------|-----|-----|-------|--------------|
| Jumlah services | 200+ | 100+ | 200+ | 20+ |
| Free tier | 12 bulan | 12 bulan + always free | 12 bulan | $200 credit 60 hari |
| Pricing complexity | Tinggi | Sederhana | Tinggi | Rendah |
| Learning curve | Steep | Moderate | Steep | Easy |
| Job market | Terbesar | Growing | Enterprise | Niche |
| Region terdekat | Singapore | Singapore, Jakarta | Singapore | Singapore |

Satu tip penting. Jangan terlalu worry tentang memilih provider yang "betul". Skill cloud anda transferable antara providers. Kalau anda faham konsep VPC di AWS, anda boleh setup VPC di GCP atau Azure juga. Yang berbeza cuma interface dan naming.

## Konsep Cloud Yang Penting

Sebelum deploy apa-apa ke cloud, anda perlu faham beberapa konsep asas.

### VPC (Virtual Private Cloud)

VPC adalah virtual network anda dalam cloud. Bayangkan ia macam network rumah anda, tapi di cloud. Anda control IP ranges, subnets, routing, dan firewall rules.

```
VPC: 10.0.0.0/16
  ├── Public Subnet: 10.0.1.0/24   (web servers, load balancers)
  ├── Private Subnet: 10.0.2.0/24  (app servers)
  └── Database Subnet: 10.0.3.0/24 (databases, caches)
```

Best practice: letak web servers dalam public subnet (boleh diakses dari internet), app servers dan databases dalam private subnet (hanya boleh diakses dari dalam VPC).

### IAM (Identity and Access Management)

IAM control siapa boleh buat apa dalam cloud account anda. Ini critical untuk security.

**Principles:**
- Principle of least privilege. Beri hanya permission yang diperlukan, jangan lebih.
- Jangan guna root account untuk daily tasks.
- Enable MFA (Multi-Factor Authentication) untuk semua users.
- Guna roles dan policies, bukan hardcode credentials.

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:PutObject"
      ],
      "Resource": "arn:aws:s3:::my-app-bucket/*"
    }
  ]
}
```

Policy di atas hanya allow read dan write ke specific S3 bucket. Tidak boleh delete, tidak boleh access bucket lain. Ini contoh least privilege.

### Load Balancer

Load balancer distribute traffic ke multiple servers. Kalau satu server down, traffic automatically pergi ke server yang lain.

Jenis load balancer:
- **Application Load Balancer (ALB).** Layer 7, faham HTTP. Boleh route berdasarkan URL path atau hostname.
- **Network Load Balancer (NLB).** Layer 4, handle millions of requests per second. Untuk TCP/UDP traffic.

### Managed Services

Managed services bermaksud cloud provider handle maintenance, patching, backups, dan scaling untuk anda.

Contoh:
- **Managed Database.** RDS (AWS), Cloud SQL (GCP). Anda tidak perlu worry tentang database backups, patching, atau replication.
- **Managed Kubernetes.** EKS (AWS), GKE (GCP). Control plane di-manage oleh provider.
- **Managed Cache.** ElastiCache (AWS). Redis atau Memcached yang di-manage.

Managed services kos lebih mahal daripada self-hosted, tapi ia save masa dan reduce operational burden. Untuk team kecil, managed services biasanya berbaloi.

> **Nota Beginner:** Mulakan dengan managed services dan hanya self-host kalau anda ada sebab yang kukuh (cost, compliance, specific requirements). Masa engineer lebih mahal daripada kos managed services.

## Cost Management

Bil cloud boleh jadi sangat mahal kalau anda tidak careful. Berikut beberapa tips.

**Set budget alerts.** Semua cloud providers ada billing alerts. Set alert pada 50%, 80%, dan 100% budget anda. Jangan tunggu sampai hujung bulan untuk check bil.

**Guna right-sizing.** Jangan guna instance besar kalau workload anda kecil. Monitor actual usage dan downsize kalau perlu.

**Shutdown apa yang tidak digunakan.** Development servers tidak perlu running 24/7. Automate start/stop schedule.

**Guna reserved instances atau savings plans.** Kalau anda tahu workload akan consistent selama setahun atau lebih, reserved pricing boleh save 30% hingga 60%.

**Monitor daily.** Install tools macam Infracost untuk Terraform. Ia tunjuk cost estimate sebelum anda provision resources.

```bash
# Install Infracost
brew install infracost

# Generate cost estimate dari Terraform code
infracost breakdown --path .
```

Output:

```
Name                                     Monthly Qty  Unit    Monthly Cost

aws_instance.web
├─ Instance usage (t3.small)                     730  hours         $18.98
└─ root_block_device
   └─ Storage (gp3, 20 GB)                       20  GB             $1.60

aws_db_instance.main
├─ Database instance (db.t3.micro)               730  hours         $14.98
└─ Storage (gp2, 20 GB)                          20  GB             $2.30

OVERALL TOTAL                                                      $37.86
```

> **Nota Beginner:** Rule of thumb saya: kalau anda belajar, gunakan free tier. Kalau anda test, gunakan smallest instance. Kalau anda production, size berdasarkan actual load testing, bukan guessing.

### Contoh Monthly Cost Estimation

Untuk memberi gambaran, ini anggaran kos bulanan untuk setup web app yang typical:

**Setup minimum (side project):**
- 1x DigitalOcean Droplet (s-1vcpu-1gb): $6/bulan
- Managed database (basic): $15/bulan
- Domain name: ~$1/bulan
- Total: sekitar $22/bulan

**Setup production (small business):**
- 2x AWS EC2 t3.small: ~$38/bulan
- 1x RDS db.t3.micro: ~$15/bulan
- Application Load Balancer: ~$18/bulan
- S3 storage (10GB): ~$0.25/bulan
- CloudFront CDN: ~$5/bulan
- Total: sekitar $76/bulan

Bandingkan dengan homelab di mana anda mungkin bayar RM50 hingga RM100 lebihan bil elektrik sahaja. Untuk learning dan development, homelab jauh lebih jimat. Tapi untuk serve real users dengan reliability, cloud berbaloi dengan kosnya.

### Tagging Resources

Satu practice yang ramai orang abaikan tapi sangat penting untuk cost management. Tag semua cloud resources anda.

```hcl
resource "aws_instance" "web" {
  # ... config ...

tags = {
    Name        = "web-production"
    Environment = "production"
    Project     = "mywebapp"
    Owner       = "syafi"
    CostCenter  = "engineering"
  }
}
```

Dengan tags, anda boleh filter bil mengikut project, environment, atau team. Ini sangat membantu bila anda ada multiple projects dan mahu tahu project mana yang paling mahal.

## Pendekatan Hybrid: Homelab + Cloud

Anda tidak perlu pilih satu sahaja. Ramai DevOps engineers guna pendekatan hybrid.

**Homelab untuk:**
- Development dan testing.
- CI/CD runners (save cloud compute cost).
- Internal tools (wiki, password manager, file sharing).
- Learning dan experimentation.
- Media server dan personal apps.

**Cloud untuk:**
- Production-facing applications.
- APIs yang perlu low latency globally.
- Services yang perlu high availability.
- Workloads yang perlu elastic scaling.

Architecture contoh hybrid:

```
                    Internet
                       |
                 [Cloud - DO/AWS]
                 ├── Load Balancer
                 ├── Web App (Production)
                 ├── Database (Managed)
                 └── CDN
                       |
              VPN Tunnel (WireGuard)
                       |
                 [Homelab]
                 ├── GitLab / Gitea
                 ├── CI/CD Runners
                 ├── Dev/Staging Environment
                 ├── Monitoring (Grafana)
                 └── Backup Storage
```

WireGuard VPN connect homelab dan cloud securely. CI/CD runners di homelab buat builds dan push ke cloud deployment. Monitoring di homelab observe kedua-dua environments.

## Practical: Deploy App ke DigitalOcean

Jom deploy web app ke DigitalOcean step by step.

### Step 1: Setup DigitalOcean Account

1. Daftar di digitalocean.com.
2. Buat API token di Settings > API > Generate New Token.
3. Install `doctl` CLI.

```bash
# macOS
brew install doctl

# Login
doctl auth init
# Paste your API token
```

### Step 2: Provision Dengan Terraform

Buat file `main.tf`:

```hcl
terraform {
  required_providers {
    digitalocean = {
      source  = "digitalocean/digitalocean"
      version = "~> 2.0"
    }
  }
}

provider "digitalocean" {
  token = var.do_token
}

variable "do_token" {
  type      = string
  sensitive = true
}

variable "ssh_key_fingerprint" {
  type = string
}

resource "digitalocean_droplet" "web" {
  image    = "ubuntu-24-04-x64"
  name     = "web-production"
  region   = "sgp1"
  size     = "s-1vcpu-1gb"
  ssh_keys = [var.ssh_key_fingerprint]

tags = ["web", "production"]

user_data = <<-EOF
    #!/bin/bash
    apt-get update
    apt-get install -y docker.io docker-compose-plugin
    systemctl enable docker
    systemctl start docker
    ufw allow 22/tcp
    ufw allow 80/tcp
    ufw allow 443/tcp
    ufw --force enable
  EOF
}

resource "digitalocean_firewall" "web" {
  name        = "web-firewall"
  droplet_ids = [digitalocean_droplet.web.id]

inbound_rule {
    protocol         = "tcp"
    port_range       = "22"
    source_addresses = ["0.0.0.0/0"]
  }

inbound_rule {
    protocol         = "tcp"
    port_range       = "80"
    source_addresses = ["0.0.0.0/0"]
  }

inbound_rule {
    protocol         = "tcp"
    port_range       = "443"
    source_addresses = ["0.0.0.0/0"]
  }

outbound_rule {
    protocol              = "tcp"
    port_range            = "1-65535"
    destination_addresses = ["0.0.0.0/0"]
  }

outbound_rule {
    protocol              = "udp"
    port_range            = "1-65535"
    destination_addresses = ["0.0.0.0/0"]
  }
}

resource "digitalocean_domain" "default" {
  name = "myapp.com"
}

resource "digitalocean_record" "web" {
  domain = digitalocean_domain.default.id
  type   = "A"
  name   = "@"
  value  = digitalocean_droplet.web.ipv4_address
}

output "web_ip" {
  value = digitalocean_droplet.web.ipv4_address
}
```

```bash
terraform init
terraform plan
terraform apply
```

### Step 3: Deploy App Dengan Ansible

Selepas Terraform provision server, guna Ansible untuk deploy app.

Buat `deploy-playbook.yml`:

```yaml
---
- name: Deploy Web App
  hosts: production
  become: yes

vars:
    app_name: "mywebapp"
    app_image: "ghcr.io/myuser/mywebapp:latest"
    app_port: 3000
    domain: "myapp.com"

tasks:
    - name: Create app directory
      file:
        path: "/opt/{{ app_name }}"
        state: directory
        mode: "0755"

- name: Copy docker-compose file
      template:
        src: templates/docker-compose.prod.yml.j2
        dest: "/opt/{{ app_name }}/docker-compose.yml"

- name: Copy Nginx config
      template:
        src: templates/nginx.prod.conf.j2
        dest: "/opt/{{ app_name }}/nginx.conf"

- name: Login to container registry
      docker_login:
        registry: ghcr.io
        username: "{{ registry_user }}"
        password: "{{ registry_token }}"

- name: Pull latest image
      docker_image:
        name: "{{ app_image }}"
        source: pull
        force_source: yes

- name: Start services
      community.docker.docker_compose_v2:
        project_src: "/opt/{{ app_name }}"
        state: present
        pull: "always"

- name: Install Certbot and get SSL certificate
      shell: |
        snap install --classic certbot
        certbot --nginx -d {{ domain }} --non-interactive --agree-tos -m admin@{{ domain }}
      args:
        creates: "/etc/letsencrypt/live/{{ domain }}"
```

Template `templates/docker-compose.prod.yml.j2`:

```yaml
services:
  app:
    image: {{ app_image }}
    container_name: {{ app_name }}
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - PORT={{ app_port }}
    ports:
      - "{{ app_port }}:{{ app_port }}"

nginx:
    image: nginx:alpine
    container_name: nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf
      - /etc/letsencrypt:/etc/letsencrypt:ro
    depends_on:
      - app
```

Deploy:

```bash
ansible-playbook -i "DROPLET_IP," deploy-playbook.yml
```

## Practical: Deploy ke AWS

Untuk AWS, prosesnya similar tapi dengan lebih services involved.

### Setup AWS CLI

```bash
# Install
brew install awscli

# Configure
aws configure
# Masukkan Access Key ID, Secret Access Key, region (ap-southeast-1)
```

### Terraform Untuk AWS

```hcl
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "ap-southeast-1"
}

# VPC
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true

tags = {
    Name = "production-vpc"
  }
}

resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  availability_zone       = "ap-southeast-1a"
  map_public_ip_on_launch = true

tags = {
    Name = "public-subnet"
  }
}

resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id
}

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.main.id
  }
}

resource "aws_route_table_association" "public" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}

# Security Group
resource "aws_security_group" "web" {
  name   = "web-sg"
  vpc_id = aws_vpc.main.id

ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# EC2 Instance
resource "aws_instance" "web" {
  ami                    = "ami-0f935a2ecd3a7bd5c"
  instance_type          = "t3.small"
  key_name               = "my-key-pair"
  subnet_id              = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web.id]

root_block_device {
    volume_size = 20
    volume_type = "gp3"
  }

tags = {
    Name        = "web-production"
    Environment = "production"
  }
}

output "public_ip" {
  value = aws_instance.web.public_ip
}
```

Ini adalah setup basic AWS. Dalam real production, anda biasanya akan tambah Application Load Balancer, Auto Scaling Group, RDS untuk database, dan S3 untuk static assets. Tapi untuk start, ini sudah mencukupi.

```bash
terraform init
terraform plan
terraform apply
```

Selepas instance running, guna Ansible untuk configure dan deploy app sama macam contoh DigitalOcean di atas.

## Cloud Certifications Yang Berbaloi

Certifications membantu validate knowledge anda dan membuka peluang kerjaya. Berikut certifications yang saya recommend.

### AWS Solutions Architect Associate (SAA-C03)

Ini adalah certification cloud paling popular. Ia cover architectural best practices, core AWS services, security, dan cost optimization. Sangat berbaloi untuk sesiapa yang mahu masuk cloud engineering.

**Tips preparation:**
- Belajar 2 hingga 3 bulan secara konsisten.
- Guna kursus dari Adrian Cantrill atau Stephane Maarek.
- Buat hands-on labs, bukan sekadar baca.
- Practice exams dari Tutorial Dojo sangat membantu.

### Certified Kubernetes Administrator (CKA)

Kalau anda target DevOps atau platform engineering role, CKA sangat valuable. Ia adalah hands-on exam di mana anda perlu solve real Kubernetes problems.

**Tips preparation:**
- Setup Kubernetes cluster di homelab anda untuk practice.
- Kursus dari Mumshad Mannambeth di KodeKloud sangat bagus.
- Practice dengan killer.sh (percuma bila register exam).
- Belajar `kubectl` shortcuts. Masa sangat terhad dalam exam.

### Certification Path Yang Saya Recommend

1. **AWS Cloud Practitioner** kalau anda benar-benar baru dengan cloud. Ia basic tapi foundation yang baik.
2. **AWS Solutions Architect Associate** sebagai certification utama.
3. **CKA** kalau anda banyak kerja dengan containers dan Kubernetes.
4. **Terraform Associate** kalau anda banyak guna Terraform (ini relatively easy).

> **Nota Beginner:** Certification bukan pengganti pengalaman. Ia melengkapi. Kalau anda ada homelab experience dan certifications, anda sudah ahead of banyak candidates. Employers value combination hands-on skills dan validated knowledge.

## Ringkasan

Perjalanan dari homelab ke cloud bukan lompatan yang besar kalau anda sudah ada foundation yang betul. Konsep networking, Linux administration, containers, dan IaC yang anda belajar di homelab semua applicable di cloud.

**Perkara penting yang anda belajar:**

- Cloud diperlukan untuk reliability, scalability, dan global reach yang homelab tidak boleh provide.
- DigitalOcean paling sesuai untuk belajar dan small projects. AWS paling sesuai untuk kerjaya dan production.
- Faham konsep VPC, IAM, load balancer, dan managed services sebelum deploy ke cloud.
- Cost management sangat penting. Set budget alerts, right-size instances, dan shutdown apa yang tidak digunakan.
- Pendekatan hybrid (homelab + cloud) adalah pragmatic. Guna homelab untuk development, cloud untuk production.
- Terraform dan Ansible yang anda belajar di Bab 6 boleh digunakan untuk provision dan configure cloud resources.
- Cloud certifications (AWS SAA, CKA) membantu validate knowledge dan buka peluang kerjaya. Combine dengan hands-on homelab experience untuk impact maximum.

Anda tidak perlu tinggalkan homelab anda. Jadikan ia lab R&D peribadi dan gunakan cloud untuk serve dunia.

Satu nasihat terakhir. Jangan tunggu sampai anda rasa "ready" untuk mula dengan cloud. Buat akaun free tier, deploy satu app kecil, dan belajar dari situ. Pengalaman hands-on lebih berharga daripada membaca 10 buku tentang cloud architecture. Homelab anda sudah beri anda foundation yang kukuh. Sekarang masanya untuk expand horizon anda ke cloud.

\newpage