企业级SpringCloud服务部署到阿里云K8S完整实战

一、架构全景：阿里云全链路技术栈

1.1 完整架构视图

本文以电商微服务架构为例，展示在阿里云ACK（容器服务Kubernetes）上的完整部署路径。与腾讯云TKE相比，阿里云的优势在于托管中间件（RDS/Redis/RocketMQ）和MSE微服务引擎的深度集成。

┌──────────────────────────────────────────────────────────────────┐
│                         阿里云 VPC                               │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                     ACK K8S Cluster                      │  │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐           │  │
│  │  │ Gateway  │  │  Auth    │  │  User    │           │  │
│  │  │Service   │  │Service   │  │Service   │           │  │
│  │  └────┬─────┘  └────┬─────┘  └────┬─────┘           │  │
│  │       │              │              │                   │  │
│  │  ┌────▼──────────────▼──────────────▼────┐           │  │
│  │  │           Service Discovery           │           │  │
│  │  │   (K8S DNS / MSE Nacos可选)        │           │  │
│  │  └─────────────────────────────────────┘           │  │
│  └───────────────────────────────────────────────────────┘  │
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐       │
│  │   SLB/ALB   │  │   ACR        │  │   MSE        │       │
│  │ (负载均衡)   │  │ (镜像仓库)  │  │ (Nacos托管) │       │
│  └─────────────┘  └─────────────┘  └─────────────┘       │
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐       │
│  │  RDS MySQL  │  │  云Redis    │  │  RocketMQ   │       │
│  │ (托管服务)   │  │  (托管服务) │  │  (托管服务)  │       │
│  └─────────────┘  └─────────────┘  └─────────────┘       │
└──────────────────────────────────────────────────────────────────┘
        

1.2 与腾讯云TKE的技术栈映射

对于需要在多云部署的团队，了解阿里云与腾讯云的产品对应关系，可以大幅降低迁移成本：

1.3 服务清单与技术栈（同腾讯云篇一致）

# 核心技术版本（与腾讯云篇保持一致，方便跨云迁移）
Spring Boot:           3.2.5
Spring Cloud:          2023.0.1
Spring Cloud Alibaba:   2023.0.1.0  # 阿里云生态集成包
Kubernetes:            1.28+ (ACK托管版)
Docker:                24.0+
Helm:                  3.14+
Aliyun ACR:            企业版
Aliyun ACK:            Pro版（托管Master）

# 阿里云专属SDK（可选，用于集成MSE/RDS等）

    com.alibaba.cloud
    spring-cloud-starter-alibaba-nacos-discovery

二、阿里云环境准备

2.1 ECS基础环境配置

购买跳板机（操作机），推荐使用阿里云ECS，规格：2核4G，系统盘40GB，Ubuntu 22.04。与腾讯云CVM操作基本一致。

# 1. SSH登录阿里云ECS
ssh root@your-ecs-public-ip

# 2. 安装Docker（同腾讯云）
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER
newgrp docker

# 3. 安装kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/

# 4. 安装Helm（同腾讯云）
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# 5. 配置阿里云CLI（区别于腾讯云tccli）
wget https://aliyun-cli-release.oss-cn-hangzhou.aliyuncs.com/aliyun-cli-linux-latest-amd64.tgz
tar -xzf aliyun-cli-linux-latest-amd64.tgz
sudo mv aliyun /usr/local/bin/
aliyun configure  # 输入AccessKeyId和AccessKeySecret

2.2 创建ACR（Aliyun Container Registry）

ACR是阿里云的镜像仓库，分为个人版（免费）和企业版（支持镜像安全扫描、跨域同步）。推荐使用企业版。

# 方式一：控制台创建（推荐）
# 1. 登录 https://cr.console.aliyun.com
# 2. 选择"企业版" → 创建实例
# 3. 配置：
#    - 实例名称: springcloud-acr
#    - 地域: 华东2（上海）或华南1（深圳）
#    - 实例规格: 基础版（个人测试）或 标准版（生产）

# 方式二：CLI创建
aliyun cr CreateInstance \
  --InstanceName springcloud-acr \
  --InstanceType Basic  # Basic=个人版, Standard=标准版

# 创建命名空间（对应项目）
aliyun cr CreateNamespace \
  --InstanceId cri-xxxxxxxx \
  --NamespaceName springcloud-demo

# 设置访问凭证（kubectl拉取镜像用）
# 控制台 → ACR实例 → 访问凭证 → 设置固定密码
# 然后在K8S中创建docker-registry secret：

kubectl create namespace springcloud
kubectl create secret docker-registry aliyun-acr-secret \
  --docker-server=registry.cn-shanghai.aliyuncs.com \
  --docker-username=your-acr-username \
  --docker-password=your-acr-password \
  --namespace=springcloud

# 验证
kubectl get secrets -n springcloud | grep aliyun-acr-secret

2.3 创建ACK Kubernetes集群

阿里云ACK提供三种集群模式：专有版（独立Master）、托管版（推荐）、Serverless版（无需管理节点）。大多数企业推荐托管版。

# 方式一：控制台创建（推荐）
# 容器服务 → Kubernetes → 集群 → 创建集群
# 配置建议：
#   - 集群类型: ACK托管版（Pro版，Master全托管）
#   - Kubernetes版本: 1.28（当前稳定版）
#   - 节点规格: 至少2台 4核8G（生产建议8核16G）
#   - 网络插件: Flannel（简单）或 Terway（阿里云自研，性能更好）
#   - 容器运行时: containerd（推荐）
#   - VPC: 与RDS/Redis在同一VPC，避免跨VPC访问延迟

# 方式二：CLI创建（自动化场景）
aliyun cs POST /clusters \
  --header "Content-Type=application/json" \
  --body '{
    "cluster_type": "ManagedKubernetes",
    "name": "springcloud-prod",
    "region_id": "cn-shanghai",
    "zoneid": "cn-shanghai-a",
    "vpcid": "vpc-xxxxxxxx",
    "container_cidr": "172.20.0.0/16",
    "service_cidr": "172.21.0.0/20"
  }'

# 获取kubeconfig
# 控制台 → 集群 → 连接信息 → 复制kubeconfig内容
mkdir -p ~/.kube
vim ~/.kube/config  # 粘贴kubeconfig

# 验证集群
kubectl cluster-info
kubectl get nodes

三、SpringCloud服务容器化

容器化部分与腾讯云篇基本相同，这里重点说明与阿里云ACR的集成差异。

3.1 Dockerfile（复用腾讯云篇规范）

使用与腾讯云篇完全相同的多阶段构建Dockerfile，保证跨云一致性。路径：gateway-service/Dockerfile

# 与腾讯云篇完全相同
FROM maven:3.9-eclipse-temurin-17 AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

FROM eclipse-temurin:17-jre-jammy
WORKDIR /app
COPY --from=builder /app/target/gateway-service-0.0.1-SNAPSHOT.jar app.jar

RUN addgroup --system spring && adduser --system spring --ingroup spring
RUN chown -R spring:spring /app
USER spring:spring

ENV JAVA_OPTS="-Xms256m -Xmx512m -XX:+UseContainerSupport -XX:+MaxRAMPercentage=75.0"

HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
  CMD curl -f http://localhost:8080/actuator/health || exit 1

EXPOSE 8080
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

3.2 构建并推送镜像到ACR

与腾讯云TCR的关键区别：ACR的登录命令使用docker login registry.cn-{region}.aliyuncs.com，且支持云效自动构建（无需本地build）。

# 构建脚本：build-and-push-aliyun.sh
#!/bin/bash
set -e

ACR_REGISTRY="registry.cn-shanghai.aliyuncs.com/springcloud-demo"
SERVICES=("gateway-service" "auth-service" "user-service" "order-service" "product-service")

# 登录ACR（与腾讯云TCR不同，使用aliyun cli获取临时密码）
echo "====== 登录ACR ======"
docker login ${ACR_REGISTRY} \
  -u your-acr-username \
  -p your-acr-password

for SERVICE in "${SERVICES[@]}"; do
  echo "====== 构建 $SERVICE ======"
  docker build -t ${ACR_REGISTRY}/${SERVICE}:latest ./${SERVICE}
  docker tag ${ACR_REGISTRY}/${SERVICE}:latest ${ACR_REGISTRY}/${SERVICE}:$(date +%Y%m%d-%H%M%S)

  echo "====== 推送 $SERVICE ======"
  docker push ${ACR_REGISTRY}/${SERVICE}:latest
  docker push ${ACR_REGISTRY}/${SERVICE}:$(date +%Y%m%d-%H%M%S)
done

echo "====== 所有镜像推送完成 ======"

# 可选：使用云效自动构建（无需本地docker build）
# 云效 → 流水线 → 镜像构建 → 选择ACR实例 → 自动构建并推送

四、K8S基础资源定义

与腾讯云篇相同，使用Namespace、ResourceQuota、LimitRange进行资源隔离和限制。这里只展示关键差异点。

4.1 Namespace与资源配置（同腾讯云篇）

# 文件：namespace.yaml（与腾讯云篇完全相同）
apiVersion: v1
kind: Namespace
metadata:
  name: springcloud
---
apiVersion: v1
kind: ResourceQuota
metadata:
  name: springcloud-quota
  namespace: springcloud
spec:
  hard:
    requests.cpu: "4"
    requests.memory: 8Gi
    limits.cpu: "8"
    limits.memory: 16Gi
---
apiVersion: v1
kind: LimitRange
metadata:
  name: springcloud-limitrange
  namespace: springcloud
spec:
  limits:
  - default:
      cpu: "500m"
      memory: "512Mi"
    defaultRequest:
      cpu: "200m"
      memory: "256Mi"
    type: Container

kubectl apply -f namespace.yaml

4.2 Secret：使用阿里云KMS加密（进阶）

阿里云KMS（密钥管理服务）可以在K8S中加密存储Secret，比腾讯云更完善。如果不使用KMS，则与腾讯云篇相同。

# 基础方式（与腾讯云相同）
kubectl create secret generic springcloud-secret \
  --from-literal=mysql-password='MySql@Pass123' \
  --from-literal=jwt-secret='YourJWTSecretKeyxxxxxxxx' \
  --namespace=springcloud

# 进阶：使用阿里云KMS加密Secret（需要ack-kms-plugin）
# 控制台 → 密钥管理服务KMS → 创建密钥
# ACK集群安装ack-kms-plugin组件
# 然后Secret会自动加密存储

五、中间件：RDS/Redis/RocketMQ托管方案

5.1 RDS for MySQL（托管服务，区别于腾讯云自建）

阿里云RDS是全托管数据库服务，无需在K8S中部署MySQL StatefulSet！这是与腾讯云篇最大的差异之一。

# 方式一：控制台创建RDS（推荐生产）
# 1. 登录 https://rds.console.aliyun.com
# 2. 创建实例 → 选择MySQL 8.0
# 3. 配置：
#    - 实例规格: mysql.x4.large.2c（4核8G，生产建议8核16G）
#    - 存储: 100GB（ESSD云盘）
#    - VPC: 与ACK集群同一VPC（关键！否则无法内网访问）
#    - 白名单: 添加ACK的Pod网段（172.20.0.0/16）

# 4. 创建数据库和用户
# RDS控制台 → 数据库管理 → 创建数据库 springcloud
# RDS控制台 → 账号管理 → 创建账号 springcloud_user

# 5. 获取内网地址
# RDS实例详情页 → 内网地址: rm-xxxxxxxx.mysql.rds.aliyuncs.com

# 方式二：CLI创建
aliyun rds CreateDBInstance \
  --Engine MySQL \
  --EngineVersion 8.0 \
  --DBInstanceClass mysql.x4.large.2c \
  --DBInstanceStorage 100 \
  --VPCId vpc-xxxxxxxx \
  --VSwitchId vsw-xxxxxxxx

# Spring配置中使用RDS地址（区别于K8S内部Service地址）
# application.yml
spring:
  datasource:
    url: jdbc:mysql://rm-xxxxxxxx.mysql.rds.aliyuncs.com:3306/springcloud
    username: springcloud_user
    password: ${MYSQL_PASSWORD}

5.2 云数据库Redis（托管服务）

同样使用托管服务，无需在K8S中部署Redis Deployment。

# 控制台创建Redis（推荐）
# 云数据库Redis版 → 创建实例
# 配置：
#   - 版本: Redis 7.0
#   - 规格: 2G（标准版，生产建议8G以上）
#   - 网络: 与ACK同一VPC
#   - 白名单: 添加ACK的Pod网段

# 获取内网地址
# Redis实例详情 → 内网地址: r-xxxxxxxx.redis.rds.aliyuncs.com:6379

# Spring配置
spring:
  redis:
    host: r-xxxxxxxx.redis.rds.aliyuncs.com
    port: 6379
    password: ${REDIS_PASSWORD}

5.3 RocketMQ托管服务（阿里云独有优势）

阿里云消息队列RocketMQ是Apache RocketMQ的托管版，比腾讯云CMQ更成熟，且与原生RocketMQ 100%兼容。

# 控制台创建RocketMQ实例
# 云消息队列 RocketMQ → 创建实例
# 配置：
#   - 版本: 5.0（推荐）或 4.0
#   - 规格: 标准版（生产建议企业铂金版）
#   - VPC: 与ACK同一VPC

# 创建Topic和Consumer Group
# 实例详情 → Topic管理 → 创建Topic: springcloud-orders
# 实例详情 → Group管理 → 创建Group: GID_springcloud

# 获取接入点
# 实例详情 → TCP接入点: http://mq-xxxxxxxx.rmq.aliyuncs.com:8080

# Spring Boot集成RocketMQ

    org.apache.rocketmq
    rocketmq-spring-boot-starter
    2.2.3


# application.yml
rocketmq:
  name-server: mq-xxxxxxxx.rmq.aliyuncs.com:8080
  producer:
    group: springcloud-producer-group
    send-message-timeout: 3000

六、SpringCloud服务部署到ACK

6.1 Deployment配置（与腾讯云篇相同规范）

Deployment YAML与腾讯云篇完全相同，唯一区别是镜像地址改为ACR地址。

# 文件：auth-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: auth-service
  namespace: springcloud
spec:
  selector:
    app: auth-service
  ports:
    - port: 8081
      targetPort: 8081
      name: http
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: auth-service
  namespace: springcloud
spec:
  replicas: 2
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels:
      app: auth-service
  template:
    metadata:
      labels:
        app: auth-service
    spec:
      containers:
      - name: auth-service
        image: registry.cn-shanghai.aliyuncs.com/springcloud-demo/auth-service:latest
        imagePullPolicy: Always
        ports:
        - containerPort: 8081
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "ack"
        - name: SPRING_DATASOURCE_URL
          value: "jdbc:mysql://rm-xxxxxxxx.mysql.rds.aliyuncs.com:3306/springcloud"
        - name: SPRING_DATASOURCE_USERNAME
          valueFrom:
            secretKeyRef:
              name: springcloud-secret
              key: mysql-username
        - name: SPRING_DATASOURCE_PASSWORD
          valueFrom:
            secretKeyRef:
              name: springcloud-secret
              key: mysql-password
        resources:
          requests:
            cpu: "200m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "1Gi"
        livenessProbe:
          httpGet:
            path: /actuator/health/liveness
            port: 8081
          initialDelaySeconds: 60
          periodSeconds: 10
      imagePullSecrets:
      - name: aliyun-acr-secret

6.2 Gateway与SLB/ALB暴露

阿里云提供两种负载均衡器：SLB（传统负载均衡）和ALB（应用型负载均衡，推荐）。ALB支持基于路径/域名的复杂路由，更适合微服务场景。

# 文件：gateway-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: springcloud-ingress
  namespace: springcloud
  annotations:
    # 使用ALB Ingress Controller（推荐）
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTP": 80}, {"HTTPS": 443}]'
    # 如果已有SSL证书，配置HTTPS
    # alb.ingress.kubernetes.io/certificate-ids: "cert-xxxxxxxx"
spec:
  ingressClassName: alb
  rules:
  - host: api.yourdomain.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: gateway-service
            port:
              number: 8080

# 或者使用传统SLB（简单场景）
# annotations:
#   service.beta.kubernetes.io/alicloud-loadbalancer-id: "lb-xxxxxxxx"

kubectl apply -f gateway-ingress.yaml

# 查看ALB分配的外部地址
kubectl get ingress -n springcloud

七、服务注册与发现：ACK+MSE方案

7.1 双轨方案：K8S DNS vs MSE Nacos

阿里云的优势在于MSE（微服务引擎），可以全托管Nacos/ ZooKeeper /Consul，适合多ACK集群或混合云场景。

7.2 方式一：K8S Service DNS（推荐，与腾讯云篇相同）

# 与腾讯云篇完全相同
# application-ack.yml
spring:
  cloud:
    kubernetes:
      discovery:
        enabled: true

# Gateway路由
spring:
  cloud:
    gateway:
      routes:
        - id: auth-service
          uri: lb://auth-service
          predicates:
            - Path=/api/auth/**
          filters:
            - StripPrefix=1

7.3 方式二：MSE Nacos托管（阿里云独有）

如果企业原本使用Dubbo/HSF，或者需要跨多个ACK集群的服务发现，MSE Nacos是最佳选择。

# 1. 创建MSE实例（控制台）
# 微服务引擎MSE → 创建实例 → Nacos版本 2.x
# 配置：专业版（支持主从切换）

# 2. 获取MSE接入点
# MSE实例详情 → 内网地址: mse-xxxxxxxx.nacos-ans.mse.aliyuncs.com:8848

# 3. Spring Cloud集成MSE Nacos

    com.alibaba.cloud
    spring-cloud-starter-alibaba-nacos-discovery


# application-ack.yml
spring:
  cloud:
    nacos:
      discovery:
        server-addr: mse-xxxxxxxx.nacos-ans.mse.aliyuncs.com:8848
        namespace: springcloud-prod
        username: nacos
        password: ${NACOS_PASSWORD}

# Gateway路由（使用服务名）
spring:
  cloud:
    gateway:
      routes:
        - id: auth-service
          uri: lb://auth-service  # Nacos会自动注册为Service
          predicates:
            - Path=/api/auth/**

八、配置中心：ACM vs K8S ConfigMap

8.1 ACM（应用配置管理，阿里云独有）

ACM是阿里云的托管配置中心，比K8S ConfigMap更强大——支持配置历史版本、秒级动态推送、灰度发布。

# 1. 控制台创建配置（可选，也可以只用K8S ConfigMap）
# 应用配置管理ACM → 命名空间 → 创建配置
# Data ID: auth-service.yml
# Group: SPRINGCLOUD_GROUP
# 内容: （YAML格式的配置）

# 2. Spring Boot集成ACM

    com.alibaba.cloud
    spring-cloud-starter-alibaba-nacos-config


# bootstrap.yml（注意是bootstrap，不是application）
spring:
  application:  name: auth-service
  cloud:
    nacos:
      config:
        server-addr: mse-xxxxxxxx.nacos-ans.mse.aliyuncs.com:8848
        namespace: springcloud-prod
        file-extension: yaml
        data-id: auth-service.yml
        group: SPRINGCLOUD_GROUP
      # 开启自动刷新
      refresh-enabled: true

# 3. 使用@RefreshScope实现配置热更新
@RefreshScope
@RestController
@RequestMapping("/config")
public class DynamicConfigController {
    @Value("${jwt.expiration:86400}")
    private int jwtExpiration;

    @GetMapping("/jwt-expiration")
    public int getJwtExpiration() {
        return jwtExpiration;
    }
}

# 4. 验证动态更新
# 在ACM控制台修改jwt.expiration值
# 访问 /config/jwt-expiration 查看更新后的值（无需重启Pod）

8.2 K8S ConfigMap vs ACM 取舍决策

两者并不互斥，可以同时使用。工程建议：基础配置用ConfigMap，业务配置用ACM。

九、监控与日志：ARMS + SLS

9.1 ARMS（应用实时监控，免自建Prometheus）

阿里云ARMS是全托管应用监控服务，可以直接集成Spring Boot Actuator，无需自建Prometheus+Grafana。相比腾讯云篇需要手动部署Prometheus，ARMS只需一键接入。

# 1. 控制台接入ARMS（免代码改动）
# 应用实时监控ARMS → 接入应用 → 选择ACK集群
# 选择命名空间springcloud
# 自动注入Agent，无需修改代码

# 2. 手动接入（推荐，更可控）
# 在Deployment中添加ARMS Agent sidecar
      containers:
      - name: auth-service
        image: registry.cn-shanghai.aliyuncs.com/springcloud-demo/auth-service:latest
        # ... 原有配置
      - name: arms-agent
        image: registry.cn-hangzhou.aliyuncs.com/arms-docker/arms-agent:latest
        env:
        - name: ARMS_APP_NAME
          value: "auth-service"
        - name: ARMS_REGION_ID
          value: "cn-shanghai"
        - name: ARMS_LICENSE_KEY
          valueFrom:
            secretKeyRef:
              name: arms-secret
              key: license-key

# 3. 验证接入（ARMS控制台就能看到）
# ARMS → 应用监控 → 选择auth-service
# 自动采集：调用链、JVM指标、接口QPS/RT、异常统计

# 4. Spring Boot Actuator配置（辅助指标，与腾讯云相同）

    org.springframework.boot
    spring-boot-starter-actuator


    io.micrometer
    micrometer-registry-prometheus


management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus

9.2 SLS（日志服务，自动采集容器日志）

SLS（Log Service）是阿里云的日志托管服务，通过Logtail Agent自动采集日志，无需Filebeat Sidecar。

# 1. 创建Logstore（日志存储）
# 控制台 → 日志服务SLS → 创建Project

# 2. 配置ACK日志采集（支持CRD方式）
# 安装logtail-ds组件（ACK控制台 → 组件管理）
# 然后创建AliyunLogConfig CRD：

apiVersion: log.alibabacloud.com/v1
kind: AliyunLogConfig
metadata:
  name: springcloud-log
  namespace: springcloud
spec:
  # 日志库名称
  logstore: springcloud-logstore
  # 日志采集配置
  logtailConfig:
    inputType: container-stdout  # 采集容器标准输出日志
    configName: springcloud-log-config
    inputDetail:
      IncludeContainerLabel:
        app: "auth-service"
    advanced:
      k8s:
        IncludeLabel:
          app: "auth-service"

kubectl apply -f aliyunlogconfig.yaml

# 3. Spring Boot配置JSON日志格式（与腾讯云篇相同）
logging:
  pattern:
    console: '{"timestamp":"%d","level":"%p","service":"${spring.application.name}","traceId":"%X{traceId}","message":"%m"}%n'

# 4. SLS自动解析JSON日志
# 在SLS控制台，可以按service、level、traceId等字段直接检索
# 支持SQL聚合分析：
# SELECT service, COUNT(*) as count FROM log GROUP BY service ORDER BY count DESC

十、CI/CD流水线：云效CodePipeline

10.1 云效流水线配置

云效（Aliyun DevOps）是阿里云的一站式DevOps平台，功能与腾讯云CODING类似，但在镜像自动构建和ACK部署集成上更紧密。

# 云效流水线核心阶段（可视化编排为主）
# 登录 https://devops.aliyun.com

# 流水线配置（YAML格式，云效也支持可视化编排）
# 文件：.aliyun/pipeline.yml

stages:
  checkout:
    - step: git-clone
      inputs:
        url: https://codeup.aliyun.com/springcloud-demo.git
        branch: master

  build-and-test:
    - step: maven-build
      inputs:
        goals: "clean package -DskipTests"
        jdk: 17
        settings: settings.xml  # 阿里云Maven镜像配置

  build-image:
    - step: docker-build-push
      inputs:
        imageName: "registry.cn-shanghai.aliyuncs.com/springcloud-demo/auth-service"
        tags: ["latest", "v${BUILD_NUMBER}"]
        dockerfile: Dockerfile
        cache: true  # 开启缓存加速

  deploy:
    - step: ack-deploy
      inputs:
        clusterId: "cxxxxxxxx"
        namespace: springcloud
        deployment: "auth-service"
        imageName: "registry.cn-shanghai.aliyuncs.com/springcloud-demo/auth-service"
        imageTag: "v${BUILD_NUMBER}"
        canary: true  # 金丝雀发布
        canaryWeight: 10  # 10%流量验证
        timeout: 300

10.2 云效 vs CODING 核心差异

两家CI/CD平台虽然功能相似，但在部署集成和成本上存在显著差异：

10.3 蓝绿部署与金丝雀发布（与腾讯云篇相同）

阿里云ACK同样支持Ingress金丝雀发布，原理与腾讯云篇相同，这里不再赘述。

# 金丝雀发布（与腾讯云TKE基本原理相同，但使用ALB注解）
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: auth-service-canary
  annotations:
    kubernetes.io/ingress.class: alb
    alb.ingress.kubernetes.io/canary: "true"
    alb.ingress.kubernetes.io/canary-weight: "10"
spec:
  rules:
  - host: api.yourdomain.com
    http:
      paths:
      - path: /api/auth
        pathType: Prefix
        backend:
          service:
            name: auth-service-canary
            port:
              number: 8081

10.4 深挖点：阿里云EDAS vs ACK原生部署

对于传统企业（尤其使用HSF/Dubbo的场景），阿里云EDAS（企业级分布式应用服务）是ACK之外的另一个选择。这里做深度对比。

总结：阿里云 vs 腾讯云选择建议

本文与《腾讯云SpringCloud部署》构成了完整的双云实战参考体系。以下是最终的选择建议：

关键要点回顾：

• 托管服务优先：RDS/Redis/RocketMQ用托管版，K8S只跑无状态服务
• 服务发现：单集群用K8S DNS，多集群用MSE Nacos
• 配置管理：基础配置用ConfigMap，业务配置用ACM
• 可观测性：ARMS + SLS一键接入，极大降低运维压力
• CI/CD：云效原生集成ACR+ACK，比CODING集成更紧密
• 多云可控：Dockerfile/YAML规范保持统一，跨云迁移成本极低

遵循这套流程，你可以在阿里云ACK上快速构建企业级SpringCloud微服务架构，也可以根据业务需要灵活地在阿里云和腾讯云之间切换。