OpenEBS容器存储教程

1. 核心概念

OpenEBS是一种开源的容器原生存储解决方案，专为Kubernetes设计，提供了一种在Kubernetes集群中部署、配置和管理存储的方法。它将每个节点上的本地存储聚合成一个分布式存储系统。

1.1 主要特点

• 容器原生：专为Kubernetes设计，与Kubernetes深度集成
• 分布式：将节点本地存储聚合成分布式存储
• 高可用性：自动复制数据，提供高可用性
• 快照和克隆：支持卷快照和克隆
• 备份和恢复：支持卷备份和恢复
• 多种存储引擎：支持多种存储引擎，如Jiva、cStor、LocalPV等
• CSI驱动：与Kubernetes CSI集成
• 监控：与Prometheus和Grafana集成
• 开源免费：使用Apache 2.0许可证
• 企业级：提供企业级存储功能

1.2 核心组件

• OpenEBS API Server：核心组件，管理存储卷的生命周期
• OpenEBS Provisioner：存储卷供应器，创建和管理存储卷
• OpenEBS Scheduler：调度器，调度存储卷的副本
• OpenEBS Jiva：基于Java的存储引擎
• OpenEBS cStor：基于CStor的存储引擎
• OpenEBS LocalPV：本地持久卷存储引擎
• OpenEBS NDM：节点磁盘管理器，管理节点上的磁盘
• OpenEBS UI：Web管理界面

1.3 架构

OpenEBS的架构：

• 微服务架构：由多个微服务组成
• 容器化：所有组件都运行在容器中
• 分层架构：使用分层架构管理存储
• 插件化：支持多种存储引擎插件
• 自动故障转移：当节点故障时自动故障转移

1.4 核心概念

• Volume：存储卷，Kubernetes Pod使用的存储单元
• Replica：卷的副本，存储在不同节点上
• Controller：卷的控制器，处理I/O操作
• Storage Engine：存储引擎，如Jiva、cStor、LocalPV等
• Pool：存储池，由多个磁盘组成
• Disk：物理磁盘，存储数据的物理介质
• Snapshot：卷的快照，用于备份和恢复
• Backup：卷的备份，存储在外部存储中

2. 安装配置

2.1 安装OpenEBS

前提条件

• Kubernetes集群（版本1.14+）
• kubectl命令行工具
• 每个节点至少有10GB可用存储空间
• 每个节点需要安装iscsi-initiator-utils（对于Jiva和cStor）

安装步骤

# 安装iscsi-initiator-utils（所有节点）
# Ubuntu/Debian
sudo apt update
sudo apt install open-iscsi

# CentOS/RHEL
sudo yum install iscsi-initiator-utils
sudo systemctl enable iscsid
sudo systemctl start iscsid

# 安装OpenEBS
kubectl apply -f https://openebs.github.io/charts/openebs-operator.yaml

# 验证安装
kubectl get pods -n openebs

# 等待所有Pod就绪
kubectl wait --for=condition=ready pod --all -n openebs --timeout=120s

# 查看OpenEBS服务
kubectl get svc -n openebs

# 查看默认存储类
kubectl get storageclass

2.2 配置OpenEBS

存储类配置

# 查看默认存储类
kubectl get storageclass

# 创建Jiva存储类
cat > openebs-jiva.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: openebs-jiva-default
  annotations:
    openebs.io/cas-type: jiva
    cas.openebs.io/config: |
      - name: ReplicaCount
        value: "3"
      - name: StoragePool
        value: default
      - name: ReplicaResourceRequest
        value: "2Gi"
      - name: ReplicaResourceLimit
        value: "4Gi"
provisioner: openebs.io/provisioner-iscsi
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
EOF

kubectl apply -f openebs-jiva.yaml

# 创建cStor存储类
cat > openebs-cstor.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: openebs-cstor-default
  annotations:
    openebs.io/cas-type: cstor
    cas.openebs.io/config: |
      - name: ReplicaCount
        value: "3"
      - name: StoragePool
        value: cstor-pool
      - name: ReplicaResourceRequest
        value: "2Gi"
      - name: ReplicaResourceLimit
        value: "4Gi"
provisioner: openebs.io/provisioner-iscsi
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
EOF

kubectl apply -f openebs-cstor.yaml

# 创建LocalPV存储类
cat > openebs-localpv.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: openebs-localpv-default
provisioner: openebs.io/local
volumeBindingMode: WaitForFirstConsumer
reclaimPolicy: Delete
EOF

kubectl apply -f openebs-localpv.yaml

# 设置默认存储类
kubectl patch storageclass openebs-jiva-default -p '{"metadata":{"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'

# 验证存储类
kubectl get storageclass

2.3 验证安装

# 测试存储
cat > test-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: test-pvc
spec:
  storageClassName: openebs-jiva-default
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
EOF

kubectl apply -f test-pvc.yaml

# 查看PVC状态
kubectl get pvc

# 创建测试Pod
cat > test-pod.yaml << EOF
apiVersion: v1
kind: Pod
metadata:
  name: test-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: ["/bin/sh", "-c", "echo 'Hello OpenEBS' > /mnt/test.txt && cat /mnt/test.txt && sleep infinity"]
    volumeMounts:
    - name: test-volume
      mountPath: /mnt
  volumes:
  - name: test-volume
    persistentVolumeClaim:
      claimName: test-pvc
EOF

kubectl apply -f test-pod.yaml

# 查看Pod状态
kubectl get pods

# 查看Pod日志
kubectl logs test-pod

# 清理测试资源
kubectl delete pod test-pod
kubectl delete pvc test-pvc

3. 基本使用

3.1 Jiva存储引擎

Jiva是OpenEBS的默认存储引擎，基于Java实现：

# 创建Jiva存储卷
cat > jiva-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jiva-pvc
spec:
  storageClassName: openebs-jiva-default
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
EOF

kubectl apply -f jiva-pvc.yaml

# 查看PVC状态
kubectl get pvc

# 创建应用Pod
cat > jiva-pod.yaml << EOF
apiVersion: v1
kind: Pod
metadata:
  name: jiva-pod
spec:
  containers:
  - name: jiva-container
    image: nginx
    ports:
    - containerPort: 80
    volumeMounts:
    - name: jiva-volume
      mountPath: /usr/share/nginx/html
  volumes:
  - name: jiva-volume
    persistentVolumeClaim:
      claimName: jiva-pvc
EOF

kubectl apply -f jiva-pod.yaml

# 查看Pod状态
kubectl get pods

# 测试应用
kubectl exec -it jiva-pod -- bash -c 'echo "Hello from Jiva" > /usr/share/nginx/html/index.html && curl localhost'

3.2 cStor存储引擎

cStor是OpenEBS的高性能存储引擎，基于CStor实现：

# 创建cStor存储池
cat > cstor-pool.yaml << EOF
apiVersion: openebs.io/v1alpha1
kind: StoragePoolClaim
metadata:
  name: cstor-pool
  namespace: openebs
spec:
  name: cstor-pool
  type: disk
  poolSpec:
    poolType: striped
  blockDevices:
    blockDeviceList:
    - blockDeviceName: blockdevice-<uuid>
EOF

kubectl apply -f cstor-pool.yaml

# 查看存储池状态
kubectl get spc -n openebs

# 创建cStor存储卷
cat > cstor-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: cstor-pvc
spec:
  storageClassName: openebs-cstor-default
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
EOF

kubectl apply -f cstor-pvc.yaml

# 查看PVC状态
kubectl get pvc

# 创建应用Pod
cat > cstor-pod.yaml << EOF
apiVersion: v1
kind: Pod
metadata:
  name: cstor-pod
spec:
  containers:
  - name: cstor-container
    image: nginx
    ports:
    - containerPort: 80
    volumeMounts:
    - name: cstor-volume
      mountPath: /usr/share/nginx/html
  volumes:
  - name: cstor-volume
    persistentVolumeClaim:
      claimName: cstor-pvc
EOF

kubectl apply -f cstor-pod.yaml

# 查看Pod状态
kubectl get pods

# 测试应用
kubectl exec -it cstor-pod -- bash -c 'echo "Hello from cStor" > /usr/share/nginx/html/index.html && curl localhost'

3.3 LocalPV存储引擎

LocalPV是OpenEBS的本地持久卷存储引擎：

# 创建LocalPV存储卷
cat > localpv-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: localpv-pvc
spec:
  storageClassName: openebs-localpv-default
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
EOF

kubectl apply -f localpv-pvc.yaml

# 查看PVC状态
kubectl get pvc

# 创建应用Pod
cat > localpv-pod.yaml << EOF
apiVersion: v1
kind: Pod
metadata:
  name: localpv-pod
spec:
  containers:
  - name: localpv-container
    image: nginx
    ports:
    - containerPort: 80
    volumeMounts:
    - name: localpv-volume
      mountPath: /usr/share/nginx/html
  volumes:
  - name: localpv-volume
    persistentVolumeClaim:
      claimName: localpv-pvc
EOF

kubectl apply -f localpv-pod.yaml

# 查看Pod状态
kubectl get pods

# 测试应用
kubectl exec -it localpv-pod -- bash -c 'echo "Hello from LocalPV" > /usr/share/nginx/html/index.html && curl localhost'

3.4 快照和克隆

OpenEBS支持卷快照和克隆：

# 创建快照
cat > volume-snapshot.yaml << EOF
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: jiva-pvc-snapshot
spec:
  volumeSnapshotClassName: openebs-snapshot-class
  source:
    persistentVolumeClaimName: jiva-pvc
EOF

kubectl apply -f volume-snapshot.yaml

# 查看快照状态
kubectl get volumesnapshot

# 从快照创建新卷
cat > snapshot-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jiva-pvc-from-snapshot
spec:
  storageClassName: openebs-jiva-default
  dataSource:
    name: jiva-pvc-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
EOF

kubectl apply -f snapshot-pvc.yaml

# 查看新PVC状态
kubectl get pvc

4. 高级功能

4.1 备份和恢复

OpenEBS支持卷备份和恢复：

# 创建备份配置
cat > backup-config.yaml << EOF
apiVersion: openebs.io/v1alpha1
kind: BackupConfig
metadata:
  name: jiva-pvc-backup
  namespace: openebs
spec:
  backupLocation:
    name: default-ns
    namespace: openebs
  schedule:
    cronExpression: "0 */4 * * *"
  volumeName: pvc-<uuid>
EOF

kubectl apply -f backup-config.yaml

# 查看备份配置
kubectl get backupconfig -n openebs

# 查看备份状态
kubectl get backup -n openebs

# 从备份创建卷
cat > restore-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jiva-pvc-from-backup
spec:
  storageClassName: openebs-jiva-default
  dataSource:
    name: backup-<uuid>
    kind: Backup
    apiGroup: openebs.io
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
EOF

kubectl apply -f restore-pvc.yaml

# 查看恢复卷状态
kubectl get pvc

4.2 监控

OpenEBS与Prometheus和Grafana集成，提供监控：

# 启用监控
# OpenEBS默认启用监控

# 查看Prometheus服务
kubectl get svc -n openebs | grep prometheus

# 查看Grafana仪表板
kubectl get svc -n openebs | grep grafana

# 访问Grafana
# 获取Grafana URL
GRAFANA_URL=$(kubectl get svc openebs-grafana -n openebs -o jsonpath='{.spec.clusterIP}'):3000
 echo "Grafana URL: http://$GRAFANA_URL"

# 或者使用NodePort访问
NODE_IP=$(kubectl get nodes -o jsonpath='{.items[0].status.addresses[0].address}')
echo "Grafana NodePort URL: http://$NODE_IP:30080"

4.3 性能调优

OpenEBS支持性能调优：

# 配置Jiva性能
cat > openebs-jiva-performance.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: openebs-jiva-performance
  annotations:
    openebs.io/cas-type: jiva
    cas.openebs.io/config: |
      - name: ReplicaCount
        value: "2"
      - name: StoragePool
        value: default
      - name: ReplicaResourceRequest
        value: "4Gi"
      - name: ReplicaResourceLimit
        value: "8Gi"
      - name: ControllerResourceRequest
        value: "2Gi"
      - name: ControllerResourceLimit
        value: "4Gi"
provisioner: openebs.io/provisioner-iscsi
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
EOF

kubectl apply -f openebs-jiva-performance.yaml

# 配置cStor性能
cat > openebs-cstor-performance.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: openebs-cstor-performance
  annotations:
    openebs.io/cas-type: cstor
    cas.openebs.io/config: |
      - name: ReplicaCount
        value: "2"
      - name: StoragePool
        value: cstor-pool
      - name: ReplicaResourceRequest
        value: "4Gi"
      - name: ReplicaResourceLimit
        value: "8Gi"
provisioner: openebs.io/provisioner-iscsi
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
EOF

kubectl apply -f openebs-cstor-performance.yaml

4.4 安全

OpenEBS支持安全配置：

# 配置网络策略
cat > openebs-network-policy.yaml << EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: openebs-network-policy
  namespace: openebs
spec:
  podSelector:
    matchLabels:
      app: openebs
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: openebs
    ports:
    - protocol: TCP
      port: 3260
    - protocol: TCP
      port: 9500
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: openebs
    ports:
    - protocol: TCP
      port: 3260
    - protocol: TCP
      port: 9500
EOF

kubectl apply -f openebs-network-policy.yaml

# 配置RBAC
cat > openebs-rbac.yaml << EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: openebs-view
rules:
- apiGroups: [""]
  resources: ["pods", "nodes"]
  verbs: ["get", "list"]
- apiGroups: ["openebs.io"]
  resources: ["volumes", "replicas", "controllers"]
  verbs: ["get", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: openebs-view-binding
subjects:
- kind: User
  name: user
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: openebs-view
  apiGroup: rbac.authorization.k8s.io
EOF

kubectl apply -f openebs-rbac.yaml

5. 最佳实践

5.1 部署最佳实践

• 节点准备：确保每个节点有足够的存储空间
• 存储设备：使用专用存储设备，避免使用系统盘
• 网络配置：确保节点之间网络连接稳定且带宽充足
• 资源分配：为OpenEBS组件分配足够的CPU和内存资源
• 备份策略：制定定期备份策略
• 监控：启用监控和告警
• 安全：配置适当的安全设置
• 升级策略：制定OpenEBS的升级策略
• 文档：记录部署和配置细节

5.2 性能优化

• 存储设备：使用SSD存储设备提高性能
• 存储引擎选择：根据工作负载选择合适的存储引擎
• 副本数量：根据可用性需求设置适当的副本数量
• 资源分配：为控制器和副本分配足够的资源
• I/O调度：调整I/O调度策略
• 缓存：启用适当的缓存策略

5.3 高可用性

• 多节点部署：部署OpenEBS到多个节点
• 副本分布：确保副本分布在不同节点上
• 节点亲和性：使用节点亲和性确保高可用性
• 自动故障转移：启用自动故障转移
• 定期备份：定期备份卷数据
• 灾难恢复：配置跨集群灾难恢复

5.4 故障排查

• 查看OpenEBS组件状态：kubectl get pods -n openebs
• 查看OpenEBS日志：kubectl logs -n openebs deploy/openebs-api-server
• 查看卷状态：kubectl get pv,pvc
• 查看事件：kubectl get events -n openebs
• 检查存储：检查节点存储使用情况
• 检查网络：检查节点之间网络连接
• 检查iSCSI：检查iSCSI服务状态

6. 实际应用

6.1 数据库存储

OpenEBS可以为数据库提供高性能、可靠的存储：

# 创建数据库存储类
cat > openebs-db.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: openebs-db
  annotations:
    openebs.io/cas-type: cstor
    cas.openebs.io/config: |
      - name: ReplicaCount
        value: "3"
      - name: StoragePool
        value: cstor-pool
      - name: ReplicaResourceRequest
        value: "4Gi"
      - name: ReplicaResourceLimit
        value: "8Gi"
provisioner: openebs.io/provisioner-iscsi
reclaimPolicy: Retain
volumeBindingMode: Immediate
allowVolumeExpansion: true
EOF

kubectl apply -f openebs-db.yaml

# 部署PostgreSQL
cat > postgresql.yaml << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgresql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgresql
  template:
    metadata:
      labels:
        app: postgresql
    spec:
      containers:
      - name: postgresql
        image: postgres:13
        env:
        - name: POSTGRES_PASSWORD
          value: mysecretpassword
        - name: POSTGRES_USER
          value: myuser
        - name: POSTGRES_DB
          value: mydb
        ports:
        - containerPort: 5432
        volumeMounts:
        - name: postgresql-data
          mountPath: /var/lib/postgresql/data
      volumes:
      - name: postgresql-data
        persistentVolumeClaim:
          claimName: postgresql-pvc
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgresql-pvc
spec:
  storageClassName: openebs-db
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
---
apiVersion: v1
kind: Service
metadata:
  name: postgresql
spec:
  selector:
    app: postgresql
  ports:
  - port: 5432
    targetPort: 5432
EOF

kubectl apply -f postgresql.yaml

# 查看PostgreSQL状态
kubectl get pods
kubectl get pvc

# 测试PostgreSQL
kubectl exec -it $(kubectl get pods -l app=postgresql -o jsonpath='{.items[0].metadata.name}') -- psql -U myuser -d mydb -c "CREATE TABLE test (id SERIAL PRIMARY KEY, name VARCHAR(50)); INSERT INTO test (name) VALUES ('test'); SELECT * FROM test;"

6.2 应用程序存储

OpenEBS可以为各种应用程序提供存储：

# 部署WordPress
cat > wordpress.yaml << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wordpress
  template:
    metadata:
      labels:
        app: wordpress
    spec:
      containers:
      - name: wordpress
        image: wordpress:5.8-apache
        env:
        - name: WORDPRESS_DB_HOST
          value: mysql
        - name: WORDPRESS_DB_USER
          value: wordpress
        - name: WORDPRESS_DB_PASSWORD
          value: wordpress
        - name: WORDPRESS_DB_NAME
          value: wordpress
        ports:
        - containerPort: 80
        volumeMounts:
        - name: wordpress-data
          mountPath: /var/www/html
      volumes:
      - name: wordpress-data
        persistentVolumeClaim:
          claimName: wordpress-pvc
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wordpress-pvc
spec:
  storageClassName: openebs-jiva-default
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi
---
apiVersion: v1
kind: Service
metadata:
  name: wordpress
spec:
  selector:
    app: wordpress
  ports:
  - port: 80
    targetPort: 80
  type: NodePort
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:8.0
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: root
        - name: MYSQL_USER
          value: wordpress
        - name: MYSQL_PASSWORD
          value: wordpress
        - name: MYSQL_DATABASE
          value: wordpress
        ports:
        - containerPort: 3306
        volumeMounts:
        - name: mysql-data
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-data
        persistentVolumeClaim:
          claimName: mysql-pvc
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pvc
spec:
  storageClassName: openebs-db
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
---
apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  selector:
    app: mysql
  ports:
  - port: 3306
    targetPort: 3306
EOF

kubectl apply -f wordpress.yaml

# 查看WordPress状态
kubectl get pods
kubectl get pvc

# 访问WordPress
NODE_IP=$(kubectl get nodes -o jsonpath='{.items[0].status.addresses[0].address}')
NODE_PORT=$(kubectl get svc wordpress -o jsonpath='{.spec.ports[0].nodePort}')
echo "WordPress URL: http://$NODE_IP:$NODE_PORT"

6.3 开发和测试环境

OpenEBS可以为开发和测试环境提供快速、灵活的存储：

# 创建开发存储类
cat > openebs-dev.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: openebs-dev
  annotations:
    openebs.io/cas-type: jiva
    cas.openebs.io/config: |
      - name: ReplicaCount
        value: "2"
      - name: StoragePool
        value: default
      - name: ReplicaResourceRequest
        value: "2Gi"
      - name: ReplicaResourceLimit
        value: "4Gi"
provisioner: openebs.io/provisioner-iscsi
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
EOF

kubectl apply -f openebs-dev.yaml

# 部署开发环境
cat > dev-environment.yaml << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: dev-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dev-app
  template:
    metadata:
      labels:
        app: dev-app
    spec:
      containers:
      - name: dev-app
        image: node:14
        command: ["/bin/sh", "-c", "mkdir -p /app && cd /app && npm init -y && npm install express && echo 'const express = require(\"express\"); const app = express(); app.get(\"/\", (req, res) => res.send(\"Hello from Dev App\"); app.listen(3000, () => console.log(\"App listening on port 3000\"));' > app.js && node app.js"]
        ports:
        - containerPort: 3000
        volumeMounts:
        - name: dev-data
          mountPath: /app
      volumes:
      - name: dev-data
        persistentVolumeClaim:
          claimName: dev-pvc
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: dev-pvc
spec:
  storageClassName: openebs-dev
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
---
apiVersion: v1
kind: Service
metadata:
  name: dev-app
spec:
  selector:
    app: dev-app
  ports:
  - port: 3000
    targetPort: 3000
  type: NodePort
EOF

kubectl apply -f dev-environment.yaml

# 查看开发环境状态
kubectl get pods
kubectl get pvc

# 访问开发应用
NODE_IP=$(kubectl get nodes -o jsonpath='{.items[0].status.addresses[0].address}')
NODE_PORT=$(kubectl get svc dev-app -o jsonpath='{.spec.ports[0].nodePort}')
echo "Dev App URL: http://$NODE_IP:$NODE_PORT"

6.4 持续集成/持续部署

OpenEBS可以为CI/CD环境提供可靠的存储：

# 创建CI/CD存储类
cat > openebs-cicd.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: openebs-cicd
  annotations:
    openebs.io/cas-type: localpv
provisioner: openebs.io/local
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
EOF

kubectl apply -f openebs-cicd.yaml

# 部署Jenkins
cat > jenkins.yaml << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jenkins
  template:
    metadata:
      labels:
        app: jenkins
    spec:
      containers:
      - name: jenkins
        image: jenkins/jenkins:lts
        ports:
        - containerPort: 8080
        - containerPort: 50000
        volumeMounts:
        - name: jenkins-home
          mountPath: /var/jenkins_home
      volumes:
      - name: jenkins-home
        persistentVolumeClaim:
          claimName: jenkins-pvc
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jenkins-pvc
spec:
  storageClassName: openebs-cicd
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 50Gi
---
apiVersion: v1
kind: Service
metadata:
  name: jenkins
spec:
  selector:
    app: jenkins
  ports:
  - port: 8080
    targetPort: 8080
  - port: 50000
    targetPort: 50000
  type: NodePort
EOF

kubectl apply -f jenkins.yaml

# 查看Jenkins状态
kubectl get pods
kubectl get pvc

# 访问Jenkins
NODE_IP=$(kubectl get nodes -o jsonpath='{.items[0].status.addresses[0].address}')
NODE_PORT=$(kubectl get svc jenkins -o jsonpath='{.spec.ports[0].nodePort}')
echo "Jenkins URL: http://$NODE_IP:$NODE_PORT"

# 获取Jenkins初始密码
kubectl exec -it $(kubectl get pods -l app=jenkins -o jsonpath='{.items[0].metadata.name}') -- cat /var/jenkins_home/secrets/initialAdminPassword

7. 总结

OpenEBS是一种强大的容器原生存储解决方案，专为Kubernetes设计，提供了一种在Kubernetes集群中部署、配置和管理存储的方法。它通过多种存储引擎提供了灵活的存储选项，满足不同工作负载的需求。

通过本教程的学习，读者应该能够：

1. 理解OpenEBS的核心概念和架构
2. 掌握OpenEBS的安装和配置方法
3. 熟练使用OpenEBS提供的各种存储服务
4. 了解OpenEBS的高级功能和应用场景
5. 掌握OpenEBS的性能优化和最佳实践
6. 能够在实际项目中应用OpenEBS解决存储问题

OpenEBS作为一种容器原生存储解决方案，为Kubernetes集群提供了企业级的存储功能。它的高可用性、快照和克隆、备份和恢复等特性，使得在Kubernetes集群中部署和管理存储变得更加简单和可靠。

随着容器技术的不断发展，OpenEBS的重要性将会继续增长，为容器化应用提供更加先进、可靠的存储服务。