# StatefulSet规划
– 目标：
– 实现有状态应用的部署和管理
– 确保应用的高可用性
– 确保数据的持久性和一致性
– 简化应用的运维管理
– 范围：
– 应用架构设计
– StatefulSet配置
– 存储配置
– 网络配置
– 扩缩容策略
– 更新策略
– 工具选择：
– kubectl：用于创建和管理StatefulSet
– Helm：用于部署有状态应用
– 存储插件：根据存储后端选择合适的插件
– 监控工具：如Prometheus、Grafana
– 流程设计：
– 应用需求分析：分析应用的存储、网络和可用性需求
– StatefulSet设计：设计StatefulSet的配置和参数
– 存储配置：配置PersistentVolume和StorageClass
– 网络配置：配置Headless Service和网络策略
– 部署测试：部署应用并测试功能和性能
– 监控管理：配置监控和告警
– 资源分配：
– 人力资源：应用开发人员、运维人员
– 时间资源：设计时间、部署时间、测试时间
– 基础设施：计算资源、存储资源、网络资源

# 有状态应用规划
– 目标：
– 确保应用的高可用性
– 确保数据的持久性和一致性
– 优化应用性能
– 简化应用管理
– 范围：
– 应用架构设计
– 数据持久化策略
– 高可用性设计
– 灾难恢复策略
– 监控和告警
– 工具选择：
– 应用特定工具：如数据库管理工具
– 存储管理工具：如Ceph、GlusterFS
– 监控工具：如Prometheus、Grafana
– 备份工具：如Velero
– 流程设计：
– 应用架构设计：设计应用的架构和组件
– 数据持久化设计：设计数据的存储和备份策略
– 高可用性设计：设计应用的高可用架构
– 灾难恢复设计：设计应用的灾难恢复策略
– 部署测试：部署应用并测试功能和性能
– 监控管理：配置监控和告警
– 资源分配：
– 人力资源：应用开发人员、数据库管理员、运维人员
– 时间资源：设计时间、部署时间、测试时间
– 基础设施：计算资源、存储资源、网络资源

# 最佳实践规划
– StatefulSet最佳实践：
– 使用Headless Service：为StatefulSet创建Headless Service，提供稳定的网络标识
– 配置PersistentVolume：为每个Pod配置独立的PersistentVolume
– 合理设置更新策略：根据应用需求设置合适的更新策略
– 配置资源限制：为StatefulSet中的Pod配置合理的资源限制
– 使用PodDisruptionBudget：配置PodDisruptionBudget，确保应用的可用性
– 有状态应用最佳实践：
– 数据备份：定期备份应用数据，确保数据安全
– 数据一致性：确保多实例之间的数据一致性
– 高可用性：设计应用的高可用架构，避免单点故障
– 性能优化：根据应用特点优化性能，如数据库索引、缓存策略等
– 监控和告警：配置详细的监控和告警，及时发现问题
– 存储最佳实践：
– 使用StorageClass：使用StorageClass动态创建PersistentVolume
– 选择合适的存储后端：根据应用需求选择合适的存储后端
– 配置存储QoS：为不同的应用配置不同的存储QoS
– 监控存储使用情况：定期监控存储的使用情况，及时发现问题
– 网络最佳实践：
– 使用Headless Service：为StatefulSet创建Headless Service
– 配置网络策略：使用网络策略限制Pod间的通信
– 监控网络性能：监控网络性能，及时发现网络问题
– 优化网络配置：根据应用需求优化网络配置

# StatefulSet实现
1. 创建Headless Service：
# 创建Headless Service
$ cat > headless-service.yaml << 'EOF' apiVersion: v1 kind: Service metadata: name: nginx-headless spec: clusterIP: None selector: app: nginx ports: - port: 80 targetPort: 80 EOF $ kubectl apply -f headless-service.yaml 2. 创建StatefulSet： # 创建StatefulSet $ cat > statefulset.yaml << 'EOF' apiVersion: apps/v1 kind: StatefulSet metadata: name: nginx-statefulset spec: serviceName: "nginx-headless" replicas: 3 selector: matchLabels: app: nginx template: metadata: labels: app: nginx spec: containers: - name: nginx image: nginx:latest ports: - containerPort: 80 volumeMounts: - name: data mountPath: /usr/share/nginx/html volumeClaimTemplates: - metadata: name: data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 1Gi EOF $ kubectl apply -f statefulset.yaml 3. 查看StatefulSet： # 查看StatefulSet $ kubectl get statefulsets # 输出 NAME READY AGE nginx-statefulset 3/3 1m # 查看Pod $ kubectl get pods -l app=nginx # 输出 NAME READY STATUS RESTARTS AGE nginx-statefulset-0 1/1 Running 0 1m nginx-statefulset-1 1/1 Running 0 50s nginx-statefulset-2 1/1 Running 0 40s # 查看PersistentVolumeClaim $ kubectl get pvc # 输出 NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE data-nginx-statefulset-0 Bound pvc-12345678-1234-1234-1234-1234567890ab 1Gi RWO standard 1m data-nginx-statefulset-1 Bound pvc-23456789-2345-2345-2345-234567890abc 1Gi RWO standard 50s data-nginx-statefulset-2 Bound pvc-34567890-3456-3456-3456-34567890abcd 1Gi RWO standard 40s 4. 测试StatefulSet： # 测试Pod的网络标识 $ for i in 0 1 2; do kubectl exec nginx-statefulset-$i -- hostname; done # 输出 nginx-statefulset-0 nginx-statefulset-1 nginx-statefulset-2 # 测试Pod的存储 $ for i in 0 1 2; do kubectl exec nginx-statefulset-$i -- sh -c "echo 'Hello from pod $i' > /usr/share/nginx/html/index.html”; done
# 测试访问
$ for i in 0 1 2; do kubectl exec nginx-statefulset-0 — curl http://nginx-statefulset-$i; done
# 输出
Hello from pod 0
Hello from pod 1
Hello from pod 2，风哥提示：。
5. 扩缩容StatefulSet：
# 扩缩容StatefulSet
$ kubectl scale statefulset nginx-statefulset –replicas=5
# 查看Pod
$ kubectl get pods -l app=nginx
# 输出
NAME READY STATUS RESTARTS AGE
nginx-statefulset-0 1/1 Running 0 2m
nginx-statefulset-1 1/1 Running 0 1m
nginx-statefulset-2 1/1 Running 0 1m
nginx-statefulset-3 1/1 Running 0 10s
nginx-statefulset-4 1/1 Running 0 5s
# 缩容StatefulSet
$ kubectl scale statefulset nginx-statefulset –replicas=2
# 查看Pod
$ kubectl get pods -l app=nginx
# 输出
NAME READY STATUS RESTARTS AGE
nginx-statefulset-0 1/1 Running 0 2m
nginx-statefulset-1 1/1 Running 0 1m

# 有状态应用实现
1. 部署MySQL数据库：
# 创建Headless Service
$ cat > mysql-headless.yaml << 'EOF' apiVersion: v1 kind: Service metadata: name: mysql-headless spec: clusterIP: None selector: app: mysql ports: - port: 3306 targetPort: 3306 EOF $ kubectl apply -f mysql-headless.yaml # 创建StatefulSet $ cat > mysql-statefulset.yaml << 'EOF' apiVersion: apps/v1 kind: StatefulSet metadata: name: mysql spec: serviceName: "mysql-headless" replicas: 1 selector: matchLabels: app: mysql template: metadata: labels: app: mysql spec: containers: - name: mysql image: mysql:8.0 ports: - containerPort: 3306 env: - name: MYSQL_ROOT_PASSWORD value: password - name: MYSQL_DATABASE value: fgedudb - name: MYSQL_USER value: fgedu - name: MYSQL_PASSWORD value: password volumeMounts: - name: mysql-data mountPath: /var/lib/mysql volumeClaimTemplates: - metadata: name: mysql-data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 10Gi EOF $ kubectl apply -f mysql-statefulset.yaml # 查看StatefulSet $ kubectl get statefulsets # 输出 NAME READY AGE mysql 1/1 1m # 查看Pod $ kubectl get pods -l app=mysql # 输出 NAME READY STATUS RESTARTS AGE mysql-0 1/1 Running 0 1m 2. 部署Redis集群： # 创建Headless Service $ cat > redis-headless.yaml << 'EOF' apiVersion: v1 kind: Service metadata: name: redis-headless spec: clusterIP: None selector: app: redis ports: - port: 6379 targetPort: 6379 EOF $ kubectl apply -f redis-headless.yaml # 创建StatefulSet $ cat > redis-statefulset.yaml << 'EOF' apiVersion: apps/v1 kind: StatefulSet metadata: name: redis spec: serviceName: "redis-headless" replicas: 3 selector: matchLabels: app: redis template: metadata: labels: app: redis spec: containers: - name: redis image: redis:6.0 ports: - containerPort: 6379 command: - redis-server - --cluster-enabled yes - --cluster-config-file /data/nodes.conf - --cluster-node-timeout 5000 - --appendonly yes volumeMounts: - name: redis-data mountPath: /data volumeClaimTemplates: - metadata:，学习交流加群风哥微信: itpux-com。 name: redis-data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 5Gi EOF $ kubectl apply -f redis-statefulset.yaml # 查看StatefulSet $ kubectl get statefulsets # 输出 NAME READY AGE redis 3/3 1m # 查看Pod $ kubectl get pods -l app=redis # 输出 NAME READY STATUS RESTARTS AGE redis-0 1/1 Running 0 1m redis-1 1/1 Running 0 50s redis-2 1/1 Running 0 40s

# 管理实现
1. 更新StatefulSet：
# 更新StatefulSet
$ kubectl patch statefulset nginx-statefulset -p ‘{“spec”:{“template”:{“spec”:{“containers”:[{“name”:”nginx”,”image”:”nginx:1.21.0″}]}}}’
# 查看更新状态
$ kubectl rollout status statefulset nginx-statefulset
# 输出
statefulset rolling update complete 3 pods at revision nginx-statefulset-78901234
2. 备份有状态应用数据：
# 使用Velero备份数据
$ velero backup create mysql-backup –include-resources=persistentvolumeclaims,persistentvolumes –selector app=mysql
# 查看备份
$ velero get backups
# 输出
NAME STATUS CREATED EXPIRES STORAGE LOCATION SELECTOR
mysql-backup Completed 2024-01-01 00:00:00 +0000 UTC 29d default app=mysql
3. 恢复有状态应用数据：
# 使用Velero恢复数据
$ velero restore create –from-backup mysql-backup
# 查看恢复
$ velero get restores
# 输出
NAME STATUS CREATED STORAGE LOCATION BACKUP RESOURCE LIST
mysql-backup-20240101000000 Completed 2024-01-01 00:00:00 +0000 UTC default mysql-backup persistentvolumeclaims,persistentvolumes
4. 监控StatefulSet：
# 安装Prometheus和Grafana
$ helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
$ helm repo update
$ helm install prometheus prometheus-community/kube-prometheus-stack
# 查看监控面板
$ kubectl port-forward deployment/prometheus-grafana 3000:3000
# 打开浏览器访问 http://localhost:3000
5. 配置PodDisruptionBudget：
# 创建PodDisruptionBudget
$ cat > pdb.yaml << 'EOF' apiVersion: policy/v1 kind: PodDisruptionBudget metadata: name: mysql-pdb spec: minAvailable: 1 selector: matchLabels: app: mysql EOF $ kubectl apply -f pdb.yaml # 查看PodDisruptionBudget $ kubectl get pdb # 输出 NAME MIN AVAILABLE MAX UNAVAILABLE ALLOWED DISRUPTIONS AGE mysql-pdb 1 N/A 0 1m

# 案例：使用StatefulSet部署高可用MySQL
# 场景：部署一个高可用MySQL集群，使用StatefulSet管理
# 问题：
– MySQL需要持久化存储
– MySQL需要稳定的网络标识
– MySQL需要有序的部署和更新
– MySQL需要高可用性
# 解决方案：
1. 创建Headless Service：
# 创建Headless Service
$ cat > mysql-headless.yaml << 'EOF' apiVersion: v1 kind: Service metadata: name: mysql-headless spec: clusterIP: None selector: app: mysql ports: - port: 3306 targetPort: 3306 EOF $ kubectl apply -f mysql-headless.yaml 2. 创建StatefulSet： # 创建StatefulSet $ cat > mysql-statefulset.yaml << 'EOF' apiVersion: apps/v1 kind: StatefulSet metadata: name: mysql spec: serviceName: "mysql-headless" replicas: 3 selector: matchLabels: app: mysql template: metadata: labels: app: mysql spec: containers: - name: mysql image: mysql:8.0 ports: - containerPort: 3306 env: - name: MYSQL_ROOT_PASSWORD value: password - name: MYSQL_DATABASE value: fgedudb - name: MYSQL_USER value: fgedu - name: MYSQL_PASSWORD value: password volumeMounts: - name: mysql-data mountPath: /var/lib/mysql volumeClaimTemplates:，学习交流加群风哥QQ113257174。 - metadata: name: mysql-data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 20Gi EOF $ kubectl apply -f mysql-statefulset.yaml 3. 配置MySQL主从复制： # 进入主节点 $ kubectl exec -it mysql-0 -- /bin/bash # 配置主节点 $ mysql -u root -ppassword mysql> CREATE USER ‘repl’@’%’ IDENTIFIED BY ‘replpassword’;
mysql> GRANT REPLICATION SLAVE ON *.* TO ‘repl’@’%’;
mysql> FLUSH PRIVILEGES;
mysql> SHOW MASTER STATUS;
# 输出
+——————+———-+————–+——————+——————-+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+——————+———-+————–+——————+——————-+
| binlog.000001 | 12345 | | | |
+——————+———-+————–+——————+——————-+
# 进入从节点1
$ kubectl exec -it mysql-1 — /bin/bash
# 配置从节点1
$ mysql -u root -ppassword
mysql> CHANGE MASTER TO MASTER_HOST=’mysql-0.mysql-headless.default.svc.cluster.local’, MASTER_USER=’repl’, MASTER_PASSWORD=’replpassword’, MASTER_LOG_FILE=’binlog.000001′, MASTER_LOG_POS=12345;
mysql> START SLAVE;
mysql> SHOW SLAVE STATUS\G
# 进入从节点2
$ kubectl exec -it mysql-2 — /bin/bash
# 配置从节点2
$ mysql -u root -ppassword
mysql> CHANGE MASTER TO MASTER_HOST=’mysql-0.mysql-headless.default.svc.cluster.local’, MASTER_USER=’repl’, MASTER_PASSWORD=’replpassword’, MASTER_LOG_FILE=’binlog.000001′, MASTER_LOG_POS=12345;
mysql> START SLAVE;
mysql> SHOW SLAVE STATUS\G
4. 测试MySQL集群：
# 在主节点创建数据
$ kubectl exec -it mysql-0 — /bin/bash
$ mysql -u root -ppassword fgedudb
mysql> CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(255));
mysql> INSERT INTO users VALUES (1, ‘Alice’), (2, ‘Bob’), (3, ‘Charlie’);
mysql> SELECT * FROM users;
# 输出
+—-+———+
| id | name |
+—-+———+
| 1 | Alice |
| 2 | Bob |
| 3 | Charlie |
+—-+———+
# 在从节点验证数据
$ kubectl exec -it mysql-1 — /bin/bash
$ mysql -u root -ppassword fgedudb
mysql> SELECT * FROM users;
# 输出
+—-+———+
| id | name |
+—-+———+
| 1 | Alice |
| 2 | Bob |
| 3 | Charlie |
+—-+———+
5. 验证高可用性：
# 模拟主节点故障
$ kubectl delete pod mysql-0
# 查看Pod状态
$ kubectl get pods -l app=mysql
# 输出
NAME READY STATUS RESTARTS AGE
mysql-0 1/1 Running 0 1m
mysql-1 1/1 Running 0 5m
mysql-2 1/1 Running 0 5m
# 验证数据一致性
$ kubectl exec -it mysql-0 — /bin/bash
$ mysql -u root -ppassword fgedudb
mysql> SELECT * FROM users;
# 输出
+—-+———+
| id | name |
+—-+———+
| 1 | Alice |
| 2 | Bob |
| 3 | Charlie |
+—-+———+
# 输出结果：
# MySQL集群部署成功
# 主从复制配置成功
# 数据一致性保持
# 高可用性验证成功

# 案例：使用StatefulSet部署Kafka集群
# 场景：部署一个Kafka集群，使用StatefulSet管理
# 问题：
– Kafka需要持久化存储
– Kafka需要稳定的网络标识
– Kafka需要有序的部署和更新
– Kafka需要高可用性
# 解决方案：
1. 部署ZooKeeper集群：
# 创建Headless Service
$ cat > zookeeper-headless.yaml << 'EOF' apiVersion: v1 kind: Service metadata: name: zookeeper-headless spec: clusterIP: None selector: app: zookeeper ports: - port: 2181 targetPort: 2181 EOF $ kubectl apply -f zookeeper-headless.yaml # 创建StatefulSet $ cat > zookeeper-statefulset.yaml << 'EOF' apiVersion: apps/v1 kind: StatefulSet metadata: name: zookeeper spec: serviceName: "zookeeper-headless" replicas: 3 selector: matchLabels: app: zookeeper template: metadata: labels: app: zookeeper spec: containers: - name: zookeeper image: bitnami/zookeeper:3.7 ports: - containerPort: 2181 env:，更多视频教程www.fgedu.net.cn。 - name: ZOO_SERVERS value: server.1=zookeeper-0.zookeeper-headless.default.svc.cluster.local:2888:3888 server.2=zookeeper-1.zookeeper-headless.default.svc.cluster.local:2888:3888 server.3=zookeeper-2.zookeeper-headless.default.svc.cluster.local:2888:3888 - name: ZOO_ENSEMBLE_SIZE value: "3" - name: ZOO_SERVER_ID valueFrom: fieldRef: fieldPath: metadata.name volumeMounts: - name: zookeeper-data mountPath: /bitnami/zookeeper volumeClaimTemplates: - metadata: name: zookeeper-data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 5Gi EOF $ kubectl apply -f zookeeper-statefulset.yaml 2. 部署Kafka集群： # 创建Headless Service $ cat > kafka-headless.yaml << 'EOF' apiVersion: v1 kind: Service metadata: name: kafka-headless spec: clusterIP: None selector: app: kafka ports: - port: 9092 targetPort: 9092 EOF $ kubectl apply -f kafka-headless.yaml # 创建StatefulSet $ cat > kafka-statefulset.yaml << 'EOF' apiVersion: apps/v1 kind: StatefulSet metadata: name: kafka spec: serviceName: "kafka-headless" replicas: 3 selector: matchLabels: app: kafka template: metadata: labels: app: kafka spec: containers: - name: kafka image: bitnami/kafka:2.8 ports: - containerPort: 9092 env: - name: KAFKA_ZOOKEEPER_CONNECT value: zookeeper-0.zookeeper-headless.default.svc.cluster.local:2181,zookeeper-1.zookeeper-headless.default.svc.cluster.local:2181,zookeeper-2.zookeeper-headless.default.svc.cluster.local:2181 - name: KAFKA_ADVERTISED_LISTENERS value: PLAINTEXT://kafka-0.kafka-headless.default.svc.cluster.local:9092 - name: KAFKA_BROKER_ID valueFrom: fieldRef: fieldPath: metadata.name volumeMounts: - name: kafka-data mountPath: /bitnami/kafka volumeClaimTemplates: - metadata: name: kafka-data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 10Gi EOF $ kubectl apply -f kafka-statefulset.yaml 3. 测试Kafka集群： # 查看Pod状态 $ kubectl get pods -l app=kafka # 输出 NAME READY STATUS RESTARTS AGE kafka-0 1/1 Running 0 1m kafka-1 1/1 Running 0 50s kafka-2 1/1 Running 0 40s # 创建主题 $ kubectl exec -it kafka-0 -- kafka-topics.sh --create --topic test-topic --bootstrap-server kafka-0.kafka-headless.default.svc.cluster.local:9092 --partitions 3 --replication-factor 3 # 查看主题 $ kubectl exec -it kafka-0 -- kafka-topics.sh --list --bootstrap-server kafka-0.kafka-headless.default.svc.cluster.local:9092 # 输出 test-topic # 生产消息 $ kubectl exec -it kafka-0 -- kafka-console-producer.sh --topic test-topic --bootstrap-server kafka-0.kafka-headless.default.svc.cluster.local:9092 >Hello, Kafka!
>Welcome to Kubernetes!
# 消费消息
$ kubectl exec -it kafka-1 — kafka-console-consumer.sh –topic test-topic –bootstrap-server kafka-1.kafka-headless.default.svc.cluster.local:9092 –from-beginning
# 输出
Hello, Kafka!
Welcome to Kubernetes!
4. 验证高可用性：
# 模拟节点故障
$ kubectl delete pod kafka-0
# 查看Pod状态
$ kubectl get pods -l app=kafka
# 输出
NAME READY STATUS RESTARTS AGE
kafka-0 1/1 Running 0 1m
kafka-1 1/1 Running 0 5m
kafka-2 1/1 Running 0 5m
# 测试消息生产和消费
$ kubectl exec -it kafka-0 — kafka-console-producer.sh –topic test-topic –bootstrap-server kafka-0.kafka-headless.default.svc.cluster.local:9092
>Test message after failure
$ kubectl exec -it kafka-1 — kafka-console-consumer.sh –topic test-topic –bootstrap-server kafka-1.kafka-headless.default.svc.cluster.local:9092 –from-beginning
# 输出
Hello, Kafka!
Welcome to Kubernetes!
Test message after failure
# 输出结果：
# Kafka集群部署成功
# 消息生产和消费正常
# 高可用性验证成功

# 案例：使用StatefulSet部署完整的有状态应用栈
# 场景：部署一个包含MySQL、Redis和Web应用的完整应用栈
# 问题：
– 多个有状态应用需要协同工作
– 需要稳定的网络标识和持久化存储
– 需要高可用性和数据一致性
# 解决方案：
1. 部署MySQL：
# 创建Headless Service
$ cat > mysql-headless.yaml << 'EOF' apiVersion: v1 kind: Service metadata: name: mysql-headless，更多学习教程公众号风哥教程itpux_com。 spec: clusterIP: None selector: app: mysql ports: - port: 3306 targetPort: 3306 EOF $ kubectl apply -f mysql-headless.yaml # 创建StatefulSet $ cat > mysql-statefulset.yaml << 'EOF' apiVersion: apps/v1 kind: StatefulSet metadata: name: mysql spec: serviceName: "mysql-headless" replicas: 1 selector: matchLabels: app: mysql template: metadata: labels: app: mysql spec: containers: - name: mysql image: mysql:8.0 ports: - containerPort: 3306 env: - name: MYSQL_ROOT_PASSWORD value: password - name: MYSQL_DATABASE value: fgedudb - name: MYSQL_USER value: fgedu - name: MYSQL_PASSWORD value: password volumeMounts: - name: mysql-data mountPath: /var/lib/mysql volumeClaimTemplates: - metadata: name: mysql-data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 20Gi EOF $ kubectl apply -f mysql-statefulset.yaml 2. 部署Redis： # 创建Headless Service $ cat > redis-headless.yaml << 'EOF' apiVersion: v1 kind: Service metadata: name: redis-headless spec: clusterIP: None selector: app: redis ports: - port: 6379 targetPort: 6379 EOF $ kubectl apply -f redis-headless.yaml # 创建StatefulSet $ cat > redis-statefulset.yaml << 'EOF' apiVersion: apps/v1 kind: StatefulSet metadata: name: redis spec: serviceName: "redis-headless" replicas: 1 selector: matchLabels: app: redis template: metadata: labels: app: redis spec: containers: - name: redis image: redis:6.0 ports: - containerPort: 6379 command: - redis-server - --requirepass - password volumeMounts: - name: redis-data mountPath: /data volumeClaimTemplates: - metadata: name: redis-data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 5Gi EOF $ kubectl apply -f redis-statefulset.yaml 3. 部署Web应用： # 创建Deployment $ cat > web-deployment.yaml << 'EOF' apiVersion: apps/v1 kind: Deployment metadata: name: web-app spec: replicas: 3 selector: matchLabels: app: web-app template: metadata: labels: app: web-app spec: containers: - name: web-app image: web-app:latest ports: - containerPort: 8080 env: - name: DB_HOST value: mysql-0.mysql-headless.default.svc.cluster.local - name: DB_PORT value: "3306" - name: DB_NAME value: fgedudb - name: DB_USER value: fgedu - name: DB_PASSWORD value: password - name: REDIS_HOST value: redis-0.redis-headless.default.svc.cluster.local - name: REDIS_PORT value: "6379"，from K8S+DB视频:www.itpux.com。 - name: REDIS_PASSWORD value: password EOF $ kubectl apply -f web-deployment.yaml # 创建Service $ cat > web-service.yaml << 'EOF' apiVersion: v1 kind: Service metadata: name: web-service spec: selector: app: web-app。 ports: - port: 80 targetPort: 8080 type: LoadBalancer EOF $ kubectl apply -f web-service.yaml 4. 测试应用栈： # 查看所有Pod $ kubectl get pods # 输出 NAME READY STATUS RESTARTS AGE mysql-0 1/1 Running 0 5m redis-0 1/1 Running 0 4m web-app-12345-abcde 1/1 Running 0 3m web-app-12345-fghij 1/1 Running 0 3m web-app-12345-klmno 1/1 Running 0 3m # 查看Service $ kubectl get services # 输出 NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE web-service LoadBalancer 10.96.123.45 192.168.1.100 80:30080/TCP 3m # 测试应用访问 $ curl http://192.168.1.100 # 输出

Hello, World!

Database connected: true

Redis connected: true

5. 验证集成：
# 测试数据库操作
$ kubectl exec -it mysql-0 — /bin/bash
$ mysql -u fgedu -ppassword fgedudb
mysql> CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(255));
mysql> INSERT INTO users VALUES (1, ‘Alice’), (2, ‘Bob’), (3, ‘Charlie’);
mysql> SELECT * FROM users;
# 输出
+—-+———+
| id | name |
+—-+———+
| 1 | Alice |
| 2 | Bob |
| 3 | Charlie |
+—-+———+
# 测试Web应用访问数据库
$ curl http://192.168.1.100/users
# 输出
[
{“id”: 1, “name”: “Alice”},
{“id”: 2, “name”: “Bob”},
{“id”: 3, “name”: “Charlie”}
]
# 输出结果：
# 应用栈部署成功
# 组件间集成正常
# 数据库和Redis连接正常
# Web应用访问正常