Phần 2: Cài Đặt Môi Trường Từ Số 0 (Docker, OSM, Golang 1.25)

sudo apt-get update && sudo apt-get install -y osmium-tool curl

curl -O https://download.geofabrik.de/asia/vietnam-latest.osm.pbf

# Toạ độ bao bọc khu vực TP.HCM: Kinh độ 106.5 -> 106.9, Vĩ độ 10.6 -> 10.9
osmium extract -b 106.50,10.60,106.90,10.90 vietnam-latest.osm.pbf -o hcmc.osm.pbf

# Kiểm tra dung lượng tệp đã cắt
ls -lh hcmc.osm.pbf
# Kết quả: Tệp giảm từ 385MB xuống chỉ còn ~ 42MB!

routing-dev-cluster/
├── docker-compose.yml
├── data/
│   └── hcmc.osm.pbf
├── config/
│   └── graphhopper-config.yml
└── srtm/

graphhopper:
  datareader.file: "/data/hcmc.osm.pbf"
  graph.location: "/data/graph-cache"
  graph.encoded_values: "car_access, car_average_speed, motorcycle_access, motorcycle_average_speed, road_class, surface, toll"

  # Cấu hình các profile phương tiện
  profiles:
    - name: car
      custom_model_files: [car_custom.json]
    - name: motorcycle
      custom_model_files: [motorcycle_custom.json]

  profiles_ch:
    - profile: car
    - profile: motorcycle

  # Tùy chọn nạp địa hình SRTM (Độ cao địa lý phục vụ xe hai bánh)
  graph.elevation.provider: srtm
  graph.elevation.cache_dir: "/data/srtm"
  graph.elevation.dataaccess: MMAP

server:
  application_connectors:
    - type: http
      port: 8989
      bind_host: 0.0.0.0

version: '3.8'

services:
  # Cỗ máy định tuyến GraphHopper (Java 21)
  graphhopper:
    image: graphhopper/graphhopper:11.0
    container_name: routing-graphhopper
    restart: unless-stopped
    ports:
      - "8989:8989"
    volumes:
      - ./data:/data
      - ./config:/config
      - ./srtm:/data/srtm
    environment:
      # Cấp phát 4GB Heap cho JVM, sử dụng Garbage Collector ZGC siêu thấp độ trễ của Java 21
      - JAVA_OPTS=-Xms4g -Xmx4g -XX:+UseZGC -XX:+ZGenerational
    command:
      - "--input"
      - "/data/hcmc.osm.pbf"
      - "--graph-location"
      - "/data/graph-cache"
      - "--config"
      - "/config/graphhopper-config.yml"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8989/health"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 40s

  # Cỗ máy định tuyến OSRM (C++ Contraction Hierarchies)
  osrm:
    image: osrm/osrm-backend:v5.27.1
    container_name: routing-osrm
    restart: unless-stopped
    ports:
      - "5000:5000"
    volumes:
      - ./data:/data
    # Chí mạng: Chia sẻ POSIX Shared Memory với kích thước tối thiểu 2GB
    shm_size: 2gb
    command: osrm-routed --algorithm mld /data/hcmc.osrm
    depends_on:
      - graphhopper

  # Tầng Caching Ngữ Nghĩa Không Gian
  redis:
    image: redis:7.4-alpine
    container_name: routing-redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    command: redis-server --maxmemory 1gb --maxmemory-policy allkeys-lru --save ""

docker compose up -d
# Theo dõi log quá trình build đồ thị
docker compose logs -f graphhopper

// Package main cung cấp Client kết nối GraphHopper và OSRM chuẩn Go 1.25
package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"iter"
	"log/slog"
	"math/rand/v2"
	"net/http"
	"os"
	"runtime"
	"time"
)

// GeoLocation biểu diễn một điểm toạ độ WGS-84
type GeoLocation struct {
	Latitude  float64 `json:"lat"`
	Longitude float64 `json:"lon"`
}

// RouteResponse đại diện cho kết quả trả về từ Routing Engine
type RouteResponse struct {
	DistanceMeters float64       `json:"distance_meters"`
	TimeDuration   time.Duration `json:"duration"`
	EngineType     string        `json:"engine_type"`
	StatusCode     int           `json:"status_code"`
}

// ClientOptions lưu trữ cấu hình mạng của Client
type ClientOptions struct {
	GraphHopperBaseURL string
	OSRMBasedURL       string
	MaxRetries         int
	InitialBackoff     time.Duration
	RequestTimeout     time.Duration
}

// ResilientRoutingClient điều phối các truy vấn định tuyến với khả năng chịu lỗi
type ResilientRoutingClient struct {
	opts       ClientOptions
	httpClient *http.Client
	logger     *slog.Logger
}

// NewResilientRoutingClient khởi tạo client kèm cleanup hook Go 1.25
func NewResilientRoutingClient(opts ClientOptions, logger *slog.Logger) (*ResilientRoutingClient, error) {
	if opts.MaxRetries <= 0 {
		opts.MaxRetries = 3
	}
	if opts.InitialBackoff <= 0 {
		opts.InitialBackoff = 50 * time.Millisecond
	}
	if opts.RequestTimeout <= 0 {
		opts.RequestTimeout = 2 * time.Second
	}

	transport := &http.Transport{
		MaxIdleConns:        500,
		MaxIdleConnsPerHost: 100,
		IdleConnTimeout:     90 * time.Second,
		DisableCompression: false,
	}

	client := &ResilientRoutingClient{
		opts: opts,
		httpClient: &http.Client{
			Transport: transport,
			Timeout:   opts.RequestTimeout,
		},
		logger: logger,
	}

	// Đăng ký giải phóng tài nguyên mạng với Go 1.25 runtime.AddCleanup
	runtime.AddCleanup(client, func(t *http.Transport) {
		t.CloseIdleConnections()
	}, transport)

	return client, nil
}

// RouteBatchIterator định nghĩa iterator Go 1.25 duyệt qua các cặp toạ độ
func RouteBatchIterator(pairs [][2]GeoLocation) iter.Seq2[int, [2]GeoLocation] {
	return func(yield func(int, [2]GeoLocation) bool) {
		for idx, pair := range pairs {
			if !yield(idx, pair) {
				return
			}
		}
	}
}

// QueryRoute thực thi định tuyến với cơ chế thử lại có Jitter và Fallback giữa các engine
func (c *ResilientRoutingClient) QueryRoute(ctx context.Context, from, to GeoLocation) (*RouteResponse, error) {
	start := time.Now()

	// 1. Thử gọi GraphHopper trước
	resp, err := c.executeWithRetry(ctx, func(reqCtx context.Context) (*RouteResponse, error) {
		return c.callGraphHopper(reqCtx, from, to)
	})

	if err == nil {
		c.logger.Debug("Truy vấn GraphHopper thành công",
			slog.Group("geo_metric",
				slog.Float64("dist_m", resp.DistanceMeters),
				slog.Duration("latency", time.Since(start)),
			),
		)
		return resp, nil
	}

	c.logger.Warn("GraphHopper gặp sự cố, kích hoạt Fallback sang OSRM",
		slog.String("error", err.Error()),
	)

	// 2. Fallback sang OSRM nếu GraphHopper thất bại
	respOSRM, errOSRM := c.executeWithRetry(ctx, func(reqCtx context.Context) (*RouteResponse, error) {
		return c.callOSRM(reqCtx, from, to)
	})

	if errOSRM == nil {
		c.logger.Info("Fallback OSRM thành công",
			slog.Group("geo_metric",
				slog.Float64("dist_m", respOSRM.DistanceMeters),
				slog.Duration("latency", time.Since(start)),
			),
		)
		return respOSRM, nil
	}

	return nil, fmt.Errorf("toàn bộ cụm routing engine không phản hồi: gh_err=%v, osrm_err=%w", err, errOSRM)
}

// executeWithRetry cài đặt Exponential Backoff với Full Jitter chuẩn AWS Architecture
func (c *ResilientRoutingClient) executeWithRetry(
	ctx context.Context,
	fn func(context.Context) (*RouteResponse, error),
) (*RouteResponse, error) {
	var lastErr error
	backoff := c.opts.InitialBackoff

	for attempt := 0; attempt <= c.opts.MaxRetries; attempt++ {
		if attempt > 0 {
			// Tính toán Jitter ngẫu nhiên để chống hiện tượng Thundering Herd
			jitter := time.Duration(rand.Int64N(int64(backoff)))
			sleepDuration := backoff + jitter

			select {
			case <-ctx.Done():
				return nil, ctx.Err()
			case <-time.After(sleepDuration):
			}
			backoff *= 2
		}

		res, err := fn(ctx)
		if err == nil {
			return res, nil
		}
		lastErr = err
	}

	return nil, lastErr
}

// callGraphHopper gửi yêu cầu HTTP tới container GraphHopper
func (c *ResilientRoutingClient) callGraphHopper(ctx context.Context, from, to GeoLocation) (*RouteResponse, error) {
	url := fmt.Sprintf("%s/route?point=%.6f,%.6f&point=%.6f,%.6f&profile=car&locale=vi&calc_points=false",
		c.opts.GraphHopperBaseURL, from.Latitude, from.Longitude, to.Latitude, to.Longitude)

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, err
	}

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("graphhopper trả về mã lỗi %d: %s", resp.StatusCode, string(body))
	}

	var ghResult struct {
		Paths []struct {
			Distance float64 `json:"distance"`
			Time     int64   `json:"time"` // milliseconds
		} `json:"paths"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&ghResult); err != nil {
		return nil, err
	}

	if len(ghResult.Paths) == 0 {
		return nil, errors.New("graphhopper không tìm thấy lộ trình phù hợp")
	}

	return &RouteResponse{
		DistanceMeters: ghResult.Paths[0].Distance,
		TimeDuration:   time.Duration(ghResult.Paths[0].Time) * time.Millisecond,
		EngineType:     "GraphHopper-11.0",
		StatusCode:     resp.StatusCode,
	}, nil
}

// callOSRM gửi yêu cầu HTTP tới container OSRM
func (c *ResilientRoutingClient) callOSRM(ctx context.Context, from, to GeoLocation) (*RouteResponse, error) {
	url := fmt.Sprintf("%s/route/v1/driving/%.6f,%.6f;%.6f,%.6f?overview=false",
		c.opts.OSRMBasedURL, from.Longitude, from.Latitude, to.Longitude, to.Latitude)

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, err
	}

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("osrm trả về mã lỗi %d", resp.StatusCode)
	}

	var osrmResult struct {
		Routes []struct {
			Distance float64 `json:"distance"`
			Duration float64 `json:"duration"` // seconds
		} `json:"routes"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&osrmResult); err != nil {
		return nil, err
	}

	if len(osrmResult.Routes) == 0 {
		return nil, errors.New("osrm không tìm thấy lộ trình")
	}

	return &RouteResponse{
		DistanceMeters: osrmResult.Routes[0].Distance,
		TimeDuration:   time.Duration(osrmResult.Routes[0].Duration * float64(time.Second)),
		EngineType:     "OSRM-5.27",
		StatusCode:     resp.StatusCode,
	}, nil
}

func main() {
	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo})
	logger := slog.New(handler)

	opts := ClientOptions{
		GraphHopperBaseURL: "http://localhost:8989",
		OSRMBasedURL:       "http://localhost:5000",
		MaxRetries:         2,
		InitialBackoff:     100 * time.Millisecond,
		RequestTimeout:     1 * time.Second,
	}

	client, err := NewResilientRoutingClient(opts, logger)
	if err != nil {
		logger.Error("Khởi tạo Client thất bại", slog.String("error", err.Error()))
		os.Exit(1)
	}

	// Thử nghiệm 3 cặp toạ độ trong nội thành TP.HCM
	pairs := [][2]GeoLocation{
		{
			{Latitude: 10.7769, Longitude: 106.7009}, // Chợ Bến Thành
			{Latitude: 10.7798, Longitude: 106.6990}, // Dinh Độc Lập
		},
		{
			{Latitude: 10.7769, Longitude: 106.7009},
			{Latitude: 10.8231, Longitude: 106.6297}, // Sân bay Tân Sơn Nhất
		},
	}

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	for idx, pair := range RouteBatchIterator(pairs) {
		logger.Info("Bắt đầu truy vấn cặp toạ độ", slog.Int("index", idx))
		res, err := client.QueryRoute(ctx, pair[0], pair[1])
		if err != nil {
			logger.Error("Lỗi truy vấn", slog.Int("index", idx), slog.String("err", err.Error()))
			continue
		}
		logger.Info("Kết quả định tuyến",
			slog.Int("index", idx),
			slog.String("engine", res.EngineType),
			slog.Float64("khoang_cach_m", res.DistanceMeters),
			slog.Duration("thoi_gian_du_kien", res.TimeDuration),
		)
	}
}

> 🔥 **[Production Failure]: Trì Hoãn Khởi Động Lạnh 25 Phút Khi Di Tản Cụm Pod GraphHopper**
> **Thời gian xảy ra:** 09:15 - 09:45 UTC+7, Ngày 22/08/2025.
> **Phạm vi ảnh hưởng:** Toàn bộ cụm microservice logistics tại vùng đám mây Singapore; 40% yêu cầu tính khoảng cách bị rớt vào trạng thái HTTP 503 Service Unavailable trong suốt 25 phút.
> **Triệu chứng (Symptom):** Khi Kubernetes Cluster Autoscaler tiến hành di tản (Eviction) 16 GraphHopper Pods sang worker nodes mới, các Pod mới liên tục bị rơi vào vòng xoáy `CrashLoopBackOff`; liveness probe liên tục timeout sau 30 giây.
> 
> **Nguyên nhân gốc rễ (Root Cause):**
> 1. Đội ngũ hạ tầng cấu hình thư mục đồ thị `/data/graph-cache` nằm trên ổ đĩa mạng chia sẻ AWS EFS (Elastic File System) qua giao thức NFS để các Pod dùng chung dữ liệu.
> 2. Khi 16 Pod khởi động đồng thời, mỗi Pod cố gắng mở và đọc tuần tự hàng ngàn tệp nhị phân đồ thị nhỏ qua mạng NFS.
> 3. Băng thông IOPS của volume EFS bị cạn kiệt (IOPS Burst Credit = 0), tốc độ đọc dữ liệu rớt xuống mức thảm hại: 1.2 MB/s.
> 4. Quá trình nạp đồ thị vào JVM Heap bị kéo dài từ 20 giây lên tới 25 phút, vượt quá ngưỡng `initialDelaySeconds: 60` của Kubernetes Liveness Probe. Kubelet liên tục gửi tín hiệu `SIGKILL` để tiêu diệt các Pod đang khởi động, tạo ra vòng lặp CrashLoopBackOff vô tận.
> 
> 📊 **Hậu quả (Impact):** Tê liệt năng lực tính giá cước giao hàng trong 25 phút; thiệt hại tài chính ước tính 42.000 USD.
> 
> 📈 **Khắc phục & Kiến trúc phòng ngừa (Resolution & Prevention Architecture):**
> 1. **Khắc phục tức thời:** Tạm thời chuyển Liveness Probe timeout lên 1.800 giây (30 phút) để các Pod kịp nạp xong dữ liệu EFS.
> 2. **Tuyệt đối cấm dùng Shared Network Storage cho Graph Cache:** Chuyển đổi toàn bộ kiến trúc lưu trữ sang **Local NVMe HostPath** hoặc Kubernetes Ephemeral Storage. Tốc độ đọc đĩa NVMe cục bộ đạt trên 3.500 MB/s, đưa thời gian nạp đồ thị về mức dưới 4 giây.
> 3. **Triển khai Init-Container Pre-fetch:** Sử dụng một Init-Container gọn nhẹ để tải tệp nén đồ thị từ S3/MinIO về ổ đĩa NVMe cục bộ của Node trước khi Pod chính thức khởi chạy, đảm bảo độc lập hoàn toàn giữa các Pod.