Minikube + HPA 弹性伸缩部署实践：openEuler 24.03 LTS SP3

本手册基于 Minikube 单节点集群，所有命令均在 openEuler 24.03 LTS SP3 上验证。

前置提醒：openEuler 24.03 LTS SP3 基于 Linux 6.6 内核开发，主要面向服务器、云和 AI 场景，提供 4 年社区支持。openEuler 以 dnf 为主流包管理工具，比 yum 更现代高效。

一、基础环境配置#

1.1 关闭防火墙和 SELinux（避免网络问题）#

1
systemctl stop firewalld
2
systemctl disable firewalld
3
setenforce 0
4
sed -i 's/SELINUX=enforcing/SELINUX=disabled/' /etc/selinux/config

1.2 关闭 swap（K8s 要求）#

1
swapoff -a
2
# 永久关闭，注释 /etc/fstab 中的 swap 行
3
sed -i '/swap/d' /etc/fstab

1.3 配置内核参数#

1
# 1. 加载 br_netfilter 内核模块
2
modprobe br_netfilter
3
# 2. 验证模块是否加载成功
4
lsmod | grep br_netfilter
5

6
cat > /etc/sysctl.d/k8s.conf <<EOF
7
net.bridge.bridge-nf-call-ip6tables = 1
8
net.bridge.bridge-nf-call-iptables = 1
9
net.ipv4.ip_forward = 1
10
EOF
11

12
# 使内核参数生效
13
sysctl -p /etc/sysctl.d/k8s.conf

1.4 安装必要工具#

1
# [openEuler] 使用 dnf 替代 yum
2
dnf install -y yum-utils device-mapper-persistent-data lvm2 wget curl git

1.5 代理相关配置（如有）#

1
# 1. 创建或编辑 bashrc 配置文件
2
cat >> ~/.bashrc <<'EOF'
3

4
# Proxy settings for minikube
5
export HTTP_PROXY="http://192.168.0.1:7897"
6
export HTTPS_PROXY="http://192.168.0.1:7897"
7
export NO_PROXY="localhost,127.0.0.1,0.0.0.0,10.0.0.0/8,192.168.0.0/16,172.16.0.0/12,10.126.126.0/24,.svc,.cluster.local"
8
EOF
9

10
# 2. 立即应用配置
11
source ~/.bashrc
12

13
# 3. 验证环境变量
14
echo "HTTP_PROXY=$HTTP_PROXY"
15
echo "HTTPS_PROXY=$HTTPS_PROXY"
16
echo "NO_PROXY=$NO_PROXY"

二、安装 Docker#

2.1 安装 Docker CE#

1
# [openEuler] openEuler 优先使用 dnf 包管理器，但 Docker 官方源基于 CentOS，因此仍使用 yum-config-manager
2
dnf install -y dnf-utils device-mapper-persistent-data lvm2 dnf-plugins-core
3

4
# 添加 Docker 官方源
5
dnf config-manager --add-repo=https://repo.huaweicloud.com/docker-ce/linux/centos/docker-ce.repo
6

7
# 备份原始仓库配置文件
8
cp /etc/yum.repos.d/docker-ce.repo  /etc/yum.repos.d/docker-ce.repo.bak
9

10
# 替换仓库配置中的下载地址为华为云镜像站
11
sed -i 's+download.docker.com+repo.huaweicloud.com/docker-ce+'  /etc/yum.repos.d/docker-ce.repo
12

13
#强制指定系统版本为 CentOS 8
14
sed -i 's+$releasever+8+' /etc/yum.repos.d/docker-ce.repo
15

16
dnf makecache
17

18
# 安装 Docker CE
19
dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

2.2 配置 Docker#

1
mkdir -p /etc/docker
2
cat > /etc/docker/daemon.json <<EOF
3
{
4
  "exec-opts": ["native.cgroupdriver=systemd"],
5
  "log-driver": "json-file",
6
  "log-opts": {
7
    "max-size": "100m"
8
  },
9
  "storage-driver": "overlay2",
10
  "proxies": {
11
    "http-proxy": "http://192.168.0.1:7897",
12
    "https-proxy": "http://192.168.0.1:7897"
13
  }
14
}
15
EOF
16

17
# 启动 Docker
18
systemctl enable docker
19
systemctl start docker

2.3 为 Docker 服务配置代理（如需）#

1
mkdir -p /etc/systemd/system/docker.service.d
2
cat > /etc/systemd/system/docker.service.d/http-proxy.conf <<EOF
3
[Service]
4
Environment="HTTP_PROXY=http://192.168.0.1:7897"
5
Environment="HTTPS_PROXY=http://192.168.0.1:7897"
6
Environment="NO_PROXY=localhost,127.0.0.1,0.0.0.0,10.0.0.0/8,192.168.0.0/16,172.16.0.0/12,10.126.126.0/24,.svc,.cluster.local"
7
EOF
8

9
systemctl daemon-reload
10
systemctl restart docker

2.4 创建普通用户#

1
# 创建用户 k8s
2
useradd -m -s /bin/bash k8s
3

4
# 将 k8s 用户添加到 docker 组
5
usermod -aG docker k8s
6

7
# 验证
8
id k8s
9

10
passwd k8s

三、安装 Minikube 和 kubectl#

3.1 下载 Minikube 二进制#

1
curl -LO https://github.com/kubernetes/minikube/releases/latest/download/minikube-linux-amd64
2
sudo install minikube-linux-amd64 /usr/local/bin/minikube

3.2 下载 kubectl#

1
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
2
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

3.3 切换用户并启动 Minikube#

1
su - k8s
2

3
# [openEuler] 启动 Minikube
4
minikube start \
5
  --driver=docker \
6
  --extra-config=apiserver.bind-address=0.0.0.0 \
7
  --docker-env HTTP_PROXY=$HTTP_PROXY \
8
  --docker-env HTTPS_PROXY=$HTTPS_PROXY \
9
  --docker-env NO_PROXY=$NO_PROXY

3.4 验证#

1
kubectl cluster-info
2
kubectl get nodes

四、准备微服务应用镜像（CPU 密集型）#

4.1 创建应用代码#

1
mkdir -p ~/k8s-hpa-demo/app
2
cd ~/k8s-hpa-demo/app

app.py：

1
from flask import Flask
2
import time
3

4
app = Flask(__name__)
5

6
@app.route('/')
7
def hello():
8
    return "Hello from K8s HPA Demo"
9

10
@app.route('/cpu')
11
def cpu_load():
12
    start = time.time()
13
    x = 0
14
    while time.time() - start < 0.5:
15
        x += 1
16
        for i in range(1000):
17
            _ = i * i
18
    return f"CPU load done, result={x}"
19

20
if __name__ == '__main__':
21
    app.run(host='0.0.0.0', port=8080)

Dockerfile：

1
FROM python:3.9-slim
2
WORKDIR /app
3
RUN pip install flask
4
COPY app.py .
5
EXPOSE 8080
6
CMD ["python", "app.py"]

4.2 构建镜像（切换到 Minikube 内部 Docker 环境）#

1
# 重要
2
eval $(minikube docker-env)
3
docker build -t hpa-demo:latest .

五、部署应用到 K8s 并配置 HPA#

5.1 创建 Deployment YAML#

1
mkdir -p ~/k8s-hpa-demo/k8s
2
cd ~/k8s-hpa-demo/k8s

deployment.yaml：

1
apiVersion: apps/v1
2
kind: Deployment
3
metadata:
4
  name: hpa-demo
5
spec:
6
  replicas: 2
7
  selector:
8
    matchLabels:
9
      app: hpa-demo
10
  template:
11
    metadata:
12
      labels:
13
        app: hpa-demo
14
    spec:
15
      containers:
16
      - name: app
17
        image: hpa-demo:latest
18
        imagePullPolicy: IfNotPresent
19
        ports:
20
        - containerPort: 8080
21
        resources:
22
          requests:
23
            cpu: "100m"
24
            memory: "128Mi"
25
          limits:
26
            cpu: "500m"
27
            memory: "256Mi"

service.yaml：

1
apiVersion: v1
2
kind: Service
3
metadata:
4
  name: hpa-demo-svc
5
spec:
6
  selector:
7
    app: hpa-demo
8
  ports:
9
  - port: 80
10
    targetPort: 8080
11
  type: NodePort

hpa.yaml：

1
apiVersion: autoscaling/v2
2
kind: HorizontalPodAutoscaler
3
metadata:
4
  name: hpa-demo-hpa
5
spec:
6
  scaleTargetRef:
7
    apiVersion: apps/v1
8
    kind: Deployment
9
    name: hpa-demo
10
  minReplicas: 2
11
  maxReplicas: 10
12
  metrics:
13
  - type: Resource
14
    resource:
15
      name: cpu
16
      target:
17
        type: Utilization
18
        averageUtilization: 50

5.2 部署#

1
kubectl apply -f deployment.yaml
2
kubectl apply -f service.yaml
3
kubectl apply -f hpa.yaml
4
# minikube addons enable metrics-server

5.3 验证#

1
kubectl get pods
2
kubectl get svc
3
kubectl get hpa

5.4 获取服务访问地址#

1
minikube service hpa-demo-svc --url
2
# 记录输出的 URL，例如 http://192.168.49.2:31876

六、部署 Prometheus+Grafana 监控系统#

6.1 安装 Helm#

1
wget https://get.helm.sh/helm-v3.14.0-linux-amd64.tar.gz
2
tar -zxvf helm-v3.14.0-linux-amd64.tar.gz
3
sudo mv linux-amd64/helm /usr/bin/helm
4
chmod +x /usr/bin/helm
5
helm version

6.2 添加 Prometheus 社区 Helm 仓库#

1
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
2
helm repo update

6.3 安装 kube-prometheus-stack#

1
# 创建监控命名空间
2
kubectl create namespace monitoring
3

4
# 安装
5
helm install prometheus prometheus-community/kube-prometheus-stack \
6
  --namespace monitoring \
7
  --set grafana.service.type=NodePort \
8
  --set prometheus.service.type=NodePort

6.4 等待所有 Pod 就绪#

1
kubectl get pods -n monitoring -w
2
# 等待所有 Pod 状态为 Running

6.5 获取 Grafana 访问端口#

1
kubectl get svc -n monitoring | grep grafana
2
# 假设 NodePort 为 30495

获取 Grafana 管理员密码：

1
kubectl get secret -n monitoring prometheus-grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo

七、安装压测工具 hey#

1
wget https://hey-release.s3.us-east-2.amazonaws.com/hey_linux_amd64
2
chmod +x hey_linux_amd64
3
sudo mv hey_linux_amd64 /usr/local/bin/hey

八、功能验证：压测触发弹性伸缩#

8.1 打开三个终端窗口#

终端1：实时监控 Pod 数量

1
kubectl get pods -w

终端2：实时监控 HPA 状态

1
kubectl get hpa -w

终端3：执行压测（替换 URL 为你的服务地址）

1
hey -z 60s -c 20 -q 100 http://<服务IP>/cpu

8.2 观察现象#

压测开始后约 30 秒，kubectl top pods 显示 CPU 使用率超过 50%。
HPA 的 TARGETS 变为 65%/50%，REPLICAS 从 2 开始增加（2→3→4…）。
新 Pod 陆续启动，最终稳定在 6~8 个。
Grafana 仪表盘上 CPU 使用率曲线上升，Pod 数量曲线同步上升。

8.3 停止压测后观察缩容#

压测结束后约 5 分钟，Pod 数量自动降回 2。

九、清理环境（可选）#

1
# 删除所有部署资源
2
kubectl delete -f ~/k8s-hpa-demo/k8s/
3

4
# 卸载 Prometheus
5
helm uninstall prometheus -n monitoring
6

7
# 停止 Minikube
8
minikube stop
9

10
# 如需彻底删除
11
minikube delete