阿里云国际版弹性伸缩、镜像管理与抢占式实例深度实战指南（2026版）

前言

在上一篇文章中，我们全面解析了阿里云国际版ECS的实例规格、ACK容器服务基础架构以及全球多Region部署方案。然而，真正让云基础设施从"能用"走向"好用"的关键，在于三个容易被忽视却至关重要的能力：弹性伸缩（Auto Scaling）、镜像管理（Image Management）和抢占式实例（Spot Instance）的成本优化策略。

这三者构成了云原生架构的"动态三角"——弹性伸缩确保资源供给始终匹配业务需求，镜像管理保障应用交付的一致性和安全性，抢占式实例则让成本控制不再以牺牲性能为代价。本文将深入这三个主题，提供可直接落地的实战方案。

阿里云弹性伸缩（Auto Scaling）全解析

伸缩组核心概念

弹性伸缩（ESS，Elastic Scaling Service）是阿里云提供的自动化资源管理服务。其核心抽象是伸缩组（Scaling Group），包含以下关键要素：

创建伸缩组完整流程

首先通过阿里云CLI创建伸缩组及其关联资源：

# 步骤1：创建伸缩组
aliyun ess CreateScalingGroup \
  --RegionId ap-southeast-1 \
  --ScalingGroupName "web-app-asg" \
  --MinSize 2 \
  --MaxSize 100 \
  --DefaultCooldown 300 \
  --VSwitchIds '["vsw-singapore-a", "vsw-singapore-b"]' \
  --MultiAZPolicy BALANCE \
  --HealthCheckType ECS \
  --GroupDeletionProtection true

# 步骤2：创建伸缩配置（启动模板）
aliyun ess CreateScalingConfiguration \
  --ScalingGroupId asg-xxx \
  --ScalingConfigurationName "web-app-v2" \
  --ImageId "aliyun_3_x64_20G_alibase_20250615.vhd" \
  --InstanceType "ecs.g8i.large" \
  --SecurityGroupId "sg-webapp" \
  --KeyPairName "singapore-prod-key" \
  --SystemDisk.Category "cloud_essd" \
  --SystemDisk.Size 40 \
  --InternetChargeType "PayByTraffic" \
  --InternetMaxBandwidthOut 100 \
  --UserData "IyEvYmluL2Jhc2gKZG9ja2VyLWNvbXBvc2UgdXAgLWQ="

# 步骤3：启用伸缩配置
aliyun ess EnableScalingConfiguration \
  --ScalingConfigurationId asc-xxx \
  --ScalingGroupId asg-xxx

伸缩规则深度对比

阿里云弹性伸缩支持四种伸缩规则类型，各有适用场景：

创建不同类型伸缩规则的示例：

# 简单规则：CPU使用率超过75%时扩容2台
aliyun ess CreateScalingRule \
  --ScalingGroupId asg-xxx \
  --ScalingRuleName "cpu-high-add" \
  --ScalingRuleType SimpleScalingRule \
  --AdjustmentType QuantityChangeInCapacity \
  --AdjustmentValue 2

# 步进规则：根据CPU使用率分级扩容
aliyun ess CreateScalingRule \
  --ScalingGroupId asg-xxx \
  --ScalingRuleName "cpu-step-scale" \
  --ScalingRuleType StepScalingRule \
  --StepAdjustments '[
    {"MetricIntervalLowerBound": 0, "MetricIntervalUpperBound": 60, "AdjustmentValue": 0},
    {"MetricIntervalLowerBound": 60, "MetricIntervalUpperBound": 80, "AdjustmentValue": 2},
    {"MetricIntervalLowerBound": 80, "MetricIntervalUpperBound": 90, "AdjustmentValue": 5},
    {"MetricIntervalLowerBound": 90, "AdjustmentValue": 10}
  ]'

# 目标追踪规则：维持CPU使用率在60%
aliyun ess CreateScalingRule \
  --ScalingGroupId asg-xxx \
  --ScalingRuleName "cpu-target-60" \
  --ScalingRuleType TargetTrackingScalingRule \
  --TargetValue 60.0 \
  --MetricName CpuUtilization \
  --DisableScaleIn false

配置告警任务触发伸缩

伸缩规则本身不会自动执行，需要绑定告警任务（Alarm Task）来驱动：

# 创建CPU告警任务并关联伸缩规则
aliyun ess CreateAlarm \
  --RegionId ap-southeast-1 \
  --ScalingGroupId asg-xxx \
  --Name "cpu-high-alarm" \
  --MetricName CpuUtilization \
  --MetricType system \
  --Period 300 \
  --Statistics Average \
  --ComparisonOperator '>=' \
  --Threshold 75.0 \
  --EvaluationCount 2 \
  --AlarmActions '["ari:acs:ess:ap-southeast-1:123456789:scalingrule/scalingrule-xxx"]'

生命周期挂钩：实例就绪前的自定义编排

当新实例加入伸缩组时，你可能需要执行初始化操作（安装监控Agent、拉取配置、预热缓存等），生命周期挂钩（Lifecycle Hook）正是为此设计：

# 创建扩容生命周期挂钩
aliyun ess CreateLifecycleHook \
  --ScalingGroupId asg-xxx \
  --LifecycleHookName "init-check-hook" \
  --LifecycleTransition SCALE_OUT \
  --HeartbeatTimeout 600 \
  --DefaultResult CONTINUE

# 通过MNS队列监听生命周期事件
# 当实例创建后，ESS会向MNS发送消息
# 你的自动化脚本消费该消息，执行初始化操作
# 完成后调用CompleteLifecycleAction通知ESS继续

aliyun ess CompleteLifecycleAction \
  --LifecycleHookId hook-xxx \
  --LifecycleActionToken "token-from-mns-message" \
  --LifecycleActionResult CONTINUE

镜像管理：构建不可变基础设施的基石

阿里云镜像体系总览

镜像是云服务器实例的只读模板，阿里云国际版提供四类镜像资源：

构建自定义镜像的最佳实践

方案一：从已有实例创建镜像

这是最直接的方式——先创建一台裸实例，手动或通过脚本完成所有配置，然后创建镜像：

# 创建实例
INSTANCE_ID=$(aliyun ecs CreateInstance \
  --RegionId ap-southeast-1 \
  --InstanceType ecs.g8i.large \
  --ImageId aliyun_3_x64_20G_alibase_20250615.vhd \
  --SecurityGroupId sg-xxx \
  --VSwitchId vsw-xxx \
  --InstanceName "image-builder" \
  | jq -r '.InstanceId')

# 等待实例运行
aliyun ecs WaitInstanceReady --InstanceId $INSTANCE_ID

# 执行自定义初始化脚本
# （通过RunCommand或SSH远程执行）
aliyun ecs RunCommand \
  --InstanceId.1 $INSTANCE_ID \
  --Type RunShellScript \
  --CommandContent 'IyEvYmluL2Jhc2gKeXVtIGluc3RhbGwgLXkgZG9ja2VyIG5naW54C...'

# 清理实例（删除SSH密钥、bash history等敏感信息）
# 创建镜像前必须确保实例处于Stopped状态
aliyun ecs StopInstance --InstanceId $INSTANCE_ID

# 创建自定义镜像
aliyun ecs CreateImage \
  --InstanceId $INSTANCE_ID \
  --ImageName "webapp-golden-v3.2-$(date +%Y%m%d)" \
  --ImageVersion "3.2.0" \
  --Description "WebApp Golden Image: Nginx 1.26 + Docker 26 + Node.js 22 LTS" \
  --Tag.1.Key "env" --Tag.1.Value "production" \
  --Tag.2.Key "version" --Tag.2.Value "3.2.0"

方案二：使用Packer自动化构建（推荐生产环境）

手动构建镜像缺乏可重复性和审计能力，引入HashiCorp Packer可以实现镜像即代码（Image as Code）：

# alicloud-webapp.pkr.hcl
packer {
  required_plugins {
    alicloud = {
      version = ">= 1.1.0"
      source  = "github.com/hashicorp/alicloud"
    }
  }
}

variable "region" {
  type    = string
  default = "ap-southeast-1"
}

source "alicloud-ecs" "webapp" {
  access_key      = var.access_key
  secret_key      = var.secret_key
  region          = var.region
  instance_type   = "ecs.g8i.large"
  image_name      = "webapp-golden-{{isotime \"20060102-150405\"}}"
  source_image    = "aliyun_3_x64_20G_alibase_20250615.vhd"
  ssh_username    = "root"
  internet_charge_type = "PayByTraffic"
  internet_max_bandwidth_out = 50
  system_disk_category = "cloud_essd"
  system_disk_size = 40
  image_description = "Automated golden image for web application fleet"
}

build {
  sources = ["source.alicloud-ecs.webapp"]

  provisioner "shell" {
    inline = [
      "dnf update -y",
      "dnf install -y docker nginx nodejs npm",
      "systemctl enable docker nginx",
      # 安全加固
      "sed -i 's/#PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config",
      "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config",
      # 清理构建痕迹
      "rm -rf /var/cache/dnf/*",
      "rm -f /root/.bash_history",
      "cloud-init clean --logs",
    ]
  }

  provisioner "file" {
    source      = "./files/nginx-default.conf"
    destination = "/etc/nginx/conf.d/default.conf"
  }

  provisioner "file" {
    source      = "./files/docker-compose.prod.yml"
    destination = "/opt/app/docker-compose.yml"
  }
}

# 执行Packer构建
packer init alicloud-webapp.pkr.hcl
packer build \
  -var "access_key=${ALICLOUD_ACCESS_KEY}" \
  -var "secret_key=${ALICLOUD_SECRET_KEY}" \
  alicloud-webapp.pkr.hcl

镜像复制与跨Region分发

当你的应用需要在多个Region部署时，利用镜像复制功能可以确保所有节点使用完全一致的运行环境：

# 将新加坡Region的镜像复制到法兰克福
aliyun ecs CopyImage \
  --RegionId ap-southeast-1 \
  --ImageId "m-singapore-golden-v3" \
  --DestinationRegionId eu-central-1 \
  --DestinationImageName "webapp-golden-v3-frankfurt" \
  --DestinationDescription "Replicated from ap-southeast-1"

# 查询跨Region复制进度
aliyun ecs DescribeImages \
  --RegionId eu-central-1 \
  --ImageName "webapp-golden-v3-frankfurt" \
  | jq '.Images.Image[0].Status'

# 批量复制到所有业务Region
for region in ap-northeast-1 me-central-1 us-west-1; do
  aliyun ecs CopyImage \
    --RegionId ap-southeast-1 \
    --ImageId "m-singapore-golden-v3" \
    --DestinationRegionId $region \
    --DestinationImageName "webapp-golden-v3-$region"
done

镜像生命周期管理

随着持续交付流水线的运转，镜像数量会迅速膨胀。建立镜像生命周期策略至关重要：

# 列出超过90天未使用的自定义镜像
aliyun ecs DescribeImages \
  --RegionId ap-southeast-1 \
  --ImageOwnerAlias self \
  --Status Available \
  | jq '.Images.Image[] | select(.CreationTime < "'$(date -d '90 days ago' +%Y-%m-%d)'T00:00Z") | {ImageId, ImageName, CreationTime, Size}'

# 自动清理过期镜像（通过标签管理）
# 给所有非生产镜像打上expire标签
aliyun ecs TagResources \
  --ResourceType image \
  --ResourceId.1 m-old-build-20250401 \
  --Tag.1.Key "retention" --Tag.1.Value "30d"

# 定期执行清理脚本
aliyun ecs DescribeImages --RegionId ap-southeast-1 --Tag.1.Key "retention" \
  | jq -r '.Images.Image[] | select(.CreationTime < "'$(date -d '30 days ago' +%Y-%m-%dT%H:%MZ)'") | .ImageId' \
  | while read img; do
      aliyun ecs DeleteImage --ImageId $img --Force
    done

抢占式实例深度实践：极致成本优化

抢占式实例的核心特性

抢占式实例（Spot Instance）是阿里云将闲置计算资源以极低价格出售的实例类型，折扣低至按量付费的10%~30%。但其核心代价是：当资源紧张时，实例可能被系统回收。

创建抢占式实例

# 方法1：通过RunInstances创建
aliyun ecs RunInstances \
  --RegionId ap-southeast-1 \
  --ImageId aliyun_3_x64_20G_alibase_20250615.vhd \
  --InstanceType ecs.g8i.large \
  --SecurityGroupId sg-xxx \
  --VSwitchId vsw-xxx \
  --Amount 10 \
  --SpotStrategy SpotWithPriceLimit \
  --SpotPriceLimit 0.05 \
  --InstanceChargeType PostPaid

# 方法2：在伸缩配置中使用抢占式实例
aliyun ess CreateScalingConfiguration \
  --ScalingGroupId asg-xxx \
  --ScalingConfigurationName "spot-mixed-config" \
  --ImageId aliyun_3_x64_20G_alibase_20250615.vhd \
  --InstanceType "ecs.g8i.large" \
  --SpotStrategy SpotWithPriceLimit \
  --SpotPriceLimit 0.05 \
  --SecurityGroupId sg-xxx

抢占式实例中断处理最佳实践

抢占式实例被回收前，阿里云会通过实例元数据（Instance Metadata）提供5分钟预警。应用需要主动轮询这个端点：

#!/usr/bin/env python3
"""
spot-interruption-handler.py
抢占式实例中断处理守护进程
"""
import requests
import time
import subprocess
import json
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("spot-handler")

METADATA_URL = "http://100.100.100.200/latest/meta-data/"
INSTANCE_ID_URL = METADATA_URL + "instance-id"
INTERRUPTION_URL = METADATA_URL + "instance/spot/termination-time"


def is_spot_instance():
    """检查当前实例是否为抢占式实例"""
    try:
        resp = requests.get(METADATA_URL + "instance/spot/instance-action", timeout=3)
        return resp.status_code == 200
    except requests.RequestException:
        return False


def graceful_shutdown():
    """
    优雅停机流程：
    1. 从负载均衡摘除
    2. 排空已有请求（连接排空等待30秒）
    3. 保存关键状态到OSS
    4. 通知编排系统（MNS/Kafka）
    """
    instance_id = requests.get(INSTANCE_ID_URL, timeout=2).text
    logger.warning(f"Spot instance {instance_id} received termination notice!")

    # 1. 从SLB/ALB后端摘除
    subprocess.run([
        "aliyun", "slb", "RemoveBackendServers",
        "--LoadBalancerId", "lb-xxx",
        "--BackendServers", json.dumps([{"ServerId": instance_id, "Weight": 0}])
    ])

    # 2. 连接排空（graceful drain）
    time.sleep(30)

    # 3. 优雅停止应用
    subprocess.run(["systemctl", "stop", "webapp"])

    # 4. 保存检查点到OSS
    subprocess.run([
        "aliyun", "oss", "cp",
        "/var/lib/webapp/state.db",
        f"oss://checkpoint-bucket/spot-exit/{instance_id}-state.db"
    ])

    logger.info(f"Instance {instance_id} graceful shutdown complete")


def main():
    if not is_spot_instance():
        logger.info("Not a spot instance, handler exiting.")
        return

    logger.info("Spot instance handler started, polling for termination notices...")

    while True:
        try:
            resp = requests.get(INTERRUPTION_URL, timeout=2)
            if resp.status_code == 200:
                # 终止时间已设置，说明即将被回收
                termination_time = resp.text
                logger.warning(f"Termination scheduled at: {termination_time}")
                graceful_shutdown()
                break
        except requests.RequestException:
            logger.debug("Metadata service unreachable, retrying...")

        time.sleep(5)


if __name__ == "__main__":
    main()

混合实例策略：抢占式+按量付费的最佳组合

在生产环境中，推荐采用混合实例策略——抢占式实例承担可中断的弹性负载，按量付费实例或包年包月实例保障基线容量：

┌─────────────────────────────────────────────┐
│              ALB / SLB 负载均衡               │
├─────────────────────────────────────────────┤
│  ┌─────────────────┐  ┌─────────────────┐   │
│  │  按量付费实例    │  │  抢占式实例集群  │   │
│  │  (基线容量 40%)  │  │  (弹性容量 60%)  │   │
│  │  2台 g8i.xlarge │  │  6~20台 g8i.large│   │
│  └─────────────────┘  └─────────────────┘   │
├─────────────────────────────────────────────┤
│           弹性伸缩组 (Multi-AZ)               │
└─────────────────────────────────────────────┘

对应的伸缩配置：

# 基线伸缩配置（按量付费，不伸缩）
aliyun ess CreateScalingConfiguration \
  --ScalingGroupId asg-xxx \
  --ScalingConfigurationName "baseline-ondemand" \
  --InstanceType "ecs.g8i.xlarge" \
  --SpotStrategy NoSpot \
  --ImageId "webapp-golden-v3"

# 弹性伸缩配置（抢占式实例）
aliyun ess CreateScalingConfiguration \
  --ScalingGroupId asg-xxx \
  --ScalingConfigurationName "elastic-spot" \
  --InstanceTypes.1 "ecs.g8i.large" \
  --InstanceTypes.2 "ecs.g7.large" \
  --InstanceTypes.3 "ecs.c8i.large" \
  --SpotStrategy SpotWithPriceLimit \
  --SpotPriceLimit 0.06 \
  --ImageId "webapp-golden-v3"

多实例族备选是关键策略：当某个实例族的抢占式资源紧张时，ESS会自动尝试备选实例族，极大提高获取成功率。

ACK自动伸缩：Kubernetes集群的弹性之道

三层弹性伸缩架构

阿里云ACK容器服务支持三层弹性伸缩，形成完整的自动化扩容体系：

第一层: Cluster Autoscaler (CA) / Karpenter
       ↓  Node级别伸缩——节点池动态增减ECS
第二层: Horizontal Pod Autoscaler (HPA)  
       ↓  Pod级别伸缩——根据CPU/Memory/自定义指标
第三层: Vertical Pod Autoscaler (VPA)    
       ↓  Container级别伸缩——调整Pod的Resource Request/Limit

配置ACK节点池自动伸缩

# 创建启用自动伸缩的节点池
aliyun cs POST /clusters/<cluster-id>/nodepools \
  --header "Content-Type=application/json" \
  --body '{
    "nodepool_info": {
      "name": "auto-scaling-pool",
      "resource_group_id": ""
    },
    "scaling_group": {
      "vswitch_ids": ["vsw-singapore-a", "vsw-singapore-b"],
      "instance_types": ["ecs.g8i.large", "ecs.c8i.large", "ecs.r8i.large"],
      "instance_charge_type": "PostPaid",
      "system_disk_category": "cloud_essd",
      "system_disk_size": 60,
      "platform": "AliyunLinux",
      "image_type": "AliyunLinux",
      "spot_strategy": "SpotWithPriceLimit",
      "spot_price_limit": [
        {"instance_type": "ecs.g8i.large", "price_limit": "0.068"},
        {"instance_type": "ecs.c8i.large", "price_limit": "0.052"},
        {"instance_type": "ecs.r8i.large", "price_limit": "0.091"}
      ]
    },
    "auto_scaling": {
      "enable": true,
      "type": "autoscale",
      "max_instances": 30,
      "min_instances": 2,
      "eip_internet_charge_type": "PayByTraffic",
      "eip_bandwidth": 100
    },
    "kubernetes_config": {
      "labels": [
        {"key": "workload-type", "value": "elastic"},
        {"key": "lifecycle", "value": "spot"}
      ],
      "taints": [
        {"key": "spot-instance", "value": "true", "effect": "NoSchedule"}
      ]
    },
    "management": {
      "enable": true,
      "auto_repair": true,
      "auto_upgrade": false
    }
  }'

虚拟节点（Virtual Node）+ ECI：Serverless弹性

当ACK的物理节点池达到上限，或者需要秒级启动Pod时，虚拟节点（基于ECI弹性容器实例）是绝佳选择：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: burst-worker
spec:
  replicas: 50
  selector:
    matchLabels:
      app: burst-worker
  template:
    metadata:
      labels:
        app: burst-worker
    spec:
      # 通过nodeSelector将Pod调度到虚拟节点
      nodeSelector:
        type: virtual-kubelet
      # 或使用Toleration容忍虚拟节点Taint
      tolerations:
      - key: virtual-kubelet.io/provider
        operator: Exists
      containers:
      - name: worker
        image: registry.ap-southeast-1.aliyuncs.com/myapp/worker:v3.2
        resources:
          requests:
            cpu: "2"
            memory: "4Gi"
          limits:
            cpu: "4"
            memory: "8Gi"

# 在ACK集群中创建虚拟节点
aliyun cs POST /clusters/<cluster-id>/virtual-nodes \
  --body '{
    "vswitch_id": "vsw-singapore-c",
    "security_group_id": "sg-xxx",
    "enable_public_eip": true
  }'

基于KEDA的事件驱动伸缩

对于事件驱动的负载（消息队列积压、定时任务等），阿里云ACK支持KEDA（Kubernetes Event-Driven Autoscaling）：

# 安装KEDA
helm repo add kedacore https://kedacore.github.io/charts
helm install keda kedacore/keda \
  --namespace keda --create-namespace

# 基于阿里云RocketMQ消息积压量伸缩
kubectl apply -f - << 'EOF'
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: rocketmq-scaler
  namespace: production
spec:
  scaleTargetRef:
    name: order-processor
  minReplicaCount: 1
  maxReplicaCount: 100
  triggers:
  - type: alicloud-rocketmq
    metadata:
      InstanceID: "rmq-instance-xxx"
      GroupID: "GID-order-processor"
      Topic: "order-events"
      Threshold: "1000"
      ActivationThreshold: "100"
EOF

综合最佳实践：构建弹性、经济、可重复的云原生架构

成本优化全景对比

端到端架构示例

下面是一个融合了弹性伸缩、镜像管理和抢占式实例的完整架构声明：

# 阿里云ACK + ESS完整弹性架构 (Terraform)
resource "alicloud_cs_managed_kubernetes" "production" {
  name         = "prod-cluster"
  cluster_spec = "ack.pro.small"
  version      = "1.30.1-aliyun.1"

  # 常规节点池：包年包月 + 预留实例券
  worker_nodes {
    name              = "baseline-pool"
    instance_type     = "ecs.g8i.xlarge"
    count             = 3
    instance_charge_type = "PrePaid"
    period            = 12
    system_disk_size  = 60
  }

  # 弹性节点池：抢占式实例
  addons {
    name = "cluster-autoscaler"
  }
}

resource "alicloud_cs_kubernetes_node_pool" "spot_pool" {
  node_pool_name = "spot-elastic-pool"
  cluster_id     = alicloud_cs_managed_kubernetes.production.id
  vswitch_ids    = [alicloud_vswitch.node.id]

  instance_types = [
    "ecs.g8i.large",
    "ecs.g7.large",
    "ecs.c8i.large"
  ]

  system_disk_category  = "cloud_essd"
  system_disk_size      = 40
  image_type            = "AliyunLinux"

  # 使用自定义金镜像
  image_id = alicloud_image.golden.id

  # 抢占式实例配置
  spot_strategy   = "SpotWithPriceLimit"
  spot_price_limit {
    instance_type = "ecs.g8i.large"
    price_limit   = "0.068"
  }
  spot_price_limit {
    instance_type = "ecs.g7.large"
    price_limit   = "0.062"
  }
  spot_price_limit {
    instance_type = "ecs.c8i.large"
    price_limit   = "0.052"
  }

  # 自动伸缩配置
  scaling_config {
    min_size = 0
    max_size = 50
    type     = "autoscale"
  }

  # 节点标签和污点
  labels {
    key   = "workload-type"
    value = "spot"
  }
  taints {
    key    = "spot-instance"
    value  = "true"
    effect = "NoSchedule"
  }

  # 节点自动修复
  management {
    enable       = true
    auto_repair  = true
    auto_upgrade = false
  }
}

对应的工作负载Pod需要配置容忍（Toleration）才能调度到抢占式节点池：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: batch-processor
spec:
  replicas: 20
  selector:
    matchLabels:
      app: batch-processor
  template:
    metadata:
      labels:
        app: batch-processor
    spec:
      # 容忍抢占式节点污点
      tolerations:
      - key: "spot-instance"
        operator: "Equal"
        value: "true"
        effect: "NoSchedule"
      # 优先调度到抢占式节点，调度失败则使用常规节点
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            preference:
              matchExpressions:
              - key: workload-type
                operator: In
                values:
                - spot
      containers:
      - name: processor
        image: registry.ap-southeast-1.aliyuncs.com/myapp/batch-processor:latest
        resources:
          requests:
            cpu: "2"
            memory: "4Gi"
          limits:
            cpu: "2"
            memory: "4Gi"
        lifecycle:
          preStop:
            exec:
              command: ["/bin/sh", "-c", "sleep 30 && /opt/app/checkpoint.sh"]

总结

阿里云国际版的弹性伸缩、镜像管理和抢占式实例构成了云原生基础设施的核心三角。弹性伸缩让资源供给精准匹配业务需求，避免资源浪费的同时保障服务可用性；镜像管理通过不可变基础设施的理念，确保应用交付的标准化和可重复性；抢占式实例则让成本优化从可选题变为必选题——在正确的架构设计下，70%~90%的算力成本节省并非遥不可及。

对于正在阿里云国际版上构建生产系统的团队，建议按照以下优先级落地：

1. 第一天：为所有业务创建自定义金镜像，用Packer自动化构建流水线
2. 第一周：为无状态服务配置弹性伸缩组，开启目标追踪规则
3. 第二周：将批处理和CI/CD负载迁移到抢占式实例，配置中断处理
4. 第一个月：在ACK集群中引入混合节点池（按量+抢占+虚拟节点），实现三层弹性伸缩

云原生的核心理念不是追求完美的架构，而是构建一个持续演进、自我优化的系统。弹性伸缩、镜像管理和抢占式实例的深度结合，正是这一理念在阿里云国际版上的最佳实践。

---

本文由 chengzicloud.cloud 提供，点击访问首页了解更多