Longhorn容器存储教程

1. 核心概念

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

1.1 主要特点

• 云原生：专为Kubernetes设计，与Kubernetes深度集成
• 分布式：将节点本地存储聚合成分布式存储
• 高可用性：自动复制数据，提供高可用性
• 快照和备份：支持卷快照和备份
• 备份存储：支持将备份存储到NFS、S3等外部存储
• 灾难恢复：支持跨集群灾难恢复
• 卷克隆：支持快速克隆卷
• 卷扩展：支持在线卷扩展
• 监控：与Prometheus和Grafana集成
• 开源免费：使用Apache 2.0许可证

1.2 核心组件

• Longhorn Manager：核心组件，管理存储卷的生命周期
• Longhorn Engine：存储引擎，运行在每个卷的Pod中
• Longhorn Instance Manager：管理Longhorn Engine实例
• Longhorn Replica：存储卷的副本
• Longhorn Backing Image Manager：管理后端镜像
• Longhorn UI：Web管理界面
• Longhorn CSI Driver：CSI驱动，与Kubernetes CSI集成

1.3 架构

Longhorn的架构：

• 分层架构：使用分层架构管理存储
• 微服务：由多个微服务组成
• 容器化：所有组件都运行在容器中
• 分布式：数据分布在多个节点上
• 自动故障转移：当节点故障时自动故障转移

1.4 核心概念

• Volume：存储卷，Kubernetes Pod使用的存储单元
• Replica：卷的副本，存储在不同节点上
• Engine：卷的存储引擎，处理I/O操作
• Snapshot：卷的快照，用于备份和恢复
• Backup：卷的备份，存储在外部存储中
• Backing Image：卷的后端镜像，用于快速创建卷
• Node：Kubernetes节点，提供本地存储
• StorageClass：Kubernetes存储类，用于动态存储配置

2. 安装配置

2.1 安装Longhorn

前提条件

• Kubernetes集群（版本1.18+）
• kubectl命令行工具
• 每个节点至少有10GB可用存储空间
• 每个节点需要安装open-iscsi

安装步骤

# 安装open-iscsi（所有节点）
# 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

# 安装Longhorn
kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/v1.4.0/deploy/longhorn.yaml

# 验证安装
kubectl get pods -n longhorn-system

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

# 查看Longhorn服务
kubectl get svc -n longhorn-system

# 获取Longhorn UI URL
LONGHORN_UI=$(kubectl get svc longhorn-frontend -n longhorn-system -o jsonpath='{.spec.clusterIP}')
echo "Longhorn UI URL: http://$LONGHORN_UI"

# 或者使用NodePort访问
kubectl patch svc longhorn-frontend -n longhorn-system --type='json' -p '[{"op":"replace","path":"/spec/type","value":"NodePort"},{"op":"replace","path":"/spec/ports/0/nodePort","value":30080}]'
NODE_IP=$(kubectl get nodes -o jsonpath='{.items[0].status.addresses[0].address}')
echo "Longhorn UI NodePort URL: http://$NODE_IP:30080"

2.2 配置Longhorn

存储类配置

# 查看默认存储类
kubectl get storageclass

# 创建自定义存储类
cat > longhorn-storageclass.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: longhorn
provisioner: driver.longhorn.io
parameters:
  numberOfReplicas: "3"
  staleReplicaTimeout: "30"
  fromBackup: ""
  baseImage: ""
  backupTarget: ""
  backupTargetCredentialSecret: ""
  recurringJobs: '{"recurringJobs":[{"name":"snap", "task":"snapshot", "cron":"0 */4 * * *", "retain":3},{"name":"backup", "task":"backup", "cron":"0 0 * * *", "retain":3}]}'
  fsType: "ext4"
volumeBindingMode: Immediate
allowVolumeExpansion: true
reclaimPolicy: Delete
EOF

kubectl apply -f longhorn-storageclass.yaml

# 设置为默认存储类
kubectl patch storageclass longhorn -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: longhorn
  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 Longhorn' > /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 创建和使用存储卷

Longhorn提供存储卷，通过Kubernetes PVC使用：

# 创建PVC
cat > app-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: app-pvc
spec:
  storageClassName: longhorn
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
EOF

kubectl apply -f app-pvc.yaml

# 查看PVC状态
kubectl get pvc

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

kubectl apply -f app-pod.yaml

# 查看Pod状态
kubectl get pods

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

3.2 快照和备份

Longhorn支持卷快照和备份：

# 创建手动快照
# 通过Longhorn UI创建快照

# 或者使用kubectl创建快照
cat > volume-snapshot.yaml << EOF
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: app-pvc-snapshot
spec:
  volumeSnapshotClassName: longhorn-snapshot-vsc
  source:
    persistentVolumeClaimName: app-pvc
EOF

kubectl apply -f volume-snapshot.yaml

# 查看快照状态
kubectl get volumesnapshot

# 从快照创建新卷
cat > snapshot-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: app-pvc-from-snapshot
spec:
  storageClassName: longhorn
  dataSource:
    name: app-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

3.3 卷克隆

Longhorn支持快速克隆卷：

# 克隆卷
cat > cloned-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: app-pvc-clone
spec:
  storageClassName: longhorn
  dataSource:
    name: app-pvc
    kind: PersistentVolumeClaim
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
EOF

kubectl apply -f cloned-pvc.yaml

# 查看克隆PVC状态
kubectl get pvc

3.4 卷扩展

Longhorn支持在线卷扩展：

# 扩展卷
kubectl patch pvc app-pvc -p '{"spec":{"resources":{"requests":{"storage":"10Gi"}}}}'

# 查看卷状态
kubectl get pvc

# 验证卷扩展
kubectl exec -it app-pod -- df -h

4. 高级功能

4.1 备份存储

Longhorn支持将备份存储到外部存储：

# 配置备份存储
# 通过Longhorn UI配置备份存储

# 或者使用kubectl配置
cat > backup-target.yaml << EOF
apiVersion: v1
kind: ConfigMap
metadata:
  name: longhorn-backup-target
  namespace: longhorn-system
data:
  backup-target: "s3://my-bucket@us-east-1/longhorn-backups"
  backup-target-credential-secret: "longhorn-s3-secret"
EOF

kubectl apply -f backup-target.yaml

# 创建S3凭证Secret
cat > s3-secret.yaml << EOF
apiVersion: v1
kind: Secret
metadata:
  name: longhorn-s3-secret
  namespace: longhorn-system
type: Opaque
data:
  AWS_ACCESS_KEY_ID: "YOUR_ACCESS_KEY"
  AWS_SECRET_ACCESS_KEY: "YOUR_SECRET_KEY"
EOF

kubectl apply -f s3-secret.yaml

# 重启Longhorn Manager
kubectl rollout restart deployment longhorn-manager -n longhorn-system

# 验证备份存储
kubectl get configmap longhorn-backup-target -n longhorn-system -o yaml

4.2 灾难恢复

Longhorn支持跨集群灾难恢复：

# 配置灾难恢复
# 在源集群创建备份

# 在目标集群配置备份存储
kubectl apply -f backup-target.yaml
kubectl apply -f s3-secret.yaml

# 在目标集群创建恢复卷
# 通过Longhorn UI创建恢复卷

# 或者使用kubectl创建
cat > dr-pvc.yaml << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: dr-pvc
spec:
  storageClassName: longhorn
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
  dataSource:
    name: "backup-name"
    kind: LonghornBackup
    apiGroup: longhorn.io
EOF

kubectl apply -f dr-pvc.yaml

# 查看恢复卷状态
kubectl get pvc

4.3 监控

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

# 启用监控
# Longhorn默认启用监控

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

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

# 访问Grafana
# 获取Grafana URL
GRAFANA_URL=$(kubectl get svc longhorn-frontend -n longhorn-system -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.4 性能调优

Longhorn支持性能调优：

# 配置卷性能
# 通过Longhorn UI配置卷性能

# 或者使用StorageClass配置
cat > longhorn-performance.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: longhorn-performance
provisioner: driver.longhorn.io
parameters:
  numberOfReplicas: "2"
  staleReplicaTimeout: "30"
  fsType: "ext4"
  diskSelector: "performance"
  nodeSelector: "performance"
  replicaSoftAntiAffinity: "true"
  replicaAutoBalance: "best-effort"
volumeBindingMode: Immediate
allowVolumeExpansion: true
reclaimPolicy: Delete
EOF

kubectl apply -f longhorn-performance.yaml

# 配置节点标签
kubectl label nodes node1 longhorn.io/hostpath-enabled=true
kubectl label nodes node1 longhorn.io/disk-performance=ssd

4.5 安全

Longhorn支持安全配置：

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

kubectl apply -f longhorn-network-policy.yaml

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

kubectl apply -f longhorn-rbac.yaml

5. 最佳实践

5.1 部署最佳实践

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

5.2 性能优化

• 存储设备：使用SSD存储设备提高性能
• 副本数量：根据可用性需求设置适当的副本数量
• 节点选择：使用节点选择器将卷部署在高性能节点上
• 磁盘选择：使用磁盘选择器将卷部署在高性能磁盘上
• 文件系统：选择合适的文件系统，如ext4或xfs
• I/O调度：调整I/O调度策略
• 缓存：启用适当的缓存策略

5.3 高可用性

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

5.4 故障排查

• 查看Longhorn组件状态：kubectl get pods -n longhorn-system
• 查看Longhorn日志：kubectl logs -n longhorn-system deploy/longhorn-manager
• 查看卷状态：通过Longhorn UI查看卷状态
• 查看事件：kubectl get events -n longhorn-system
• 检查存储：检查节点存储使用情况
• 检查网络：检查节点之间网络连接
• 检查iSCSI：检查iSCSI服务状态

6. 实际应用

6.1 数据库存储

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

# 创建数据库存储类
cat > longhorn-db.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: longhorn-db
provisioner: driver.longhorn.io
parameters:
  numberOfReplicas: "3"
  staleReplicaTimeout: "30"
  fsType: "ext4"
  recurringJobs: '{"recurringJobs":[{"name":"snap", "task":"snapshot", "cron":"0 */2 * * *", "retain":5},{"name":"backup", "task":"backup", "cron":"0 0 * * *", "retain":3}]}'
volumeBindingMode: Immediate
allowVolumeExpansion: true
reclaimPolicy: Retain
EOF

kubectl apply -f longhorn-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: longhorn-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 应用程序存储

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

# 部署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: longhorn
  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: longhorn-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 开发和测试环境

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

# 创建开发存储类
cat > longhorn-dev.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: longhorn-dev
provisioner: driver.longhorn.io
parameters:
  numberOfReplicas: "2"
  staleReplicaTimeout: "30"
  fsType: "ext4"
volumeBindingMode: Immediate
allowVolumeExpansion: true
reclaimPolicy: Delete
EOF

kubectl apply -f longhorn-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: longhorn-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 持续集成/持续部署

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

# 创建CI/CD存储类
cat > longhorn-cicd.yaml << EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: longhorn-cicd
provisioner: driver.longhorn.io
parameters:
  numberOfReplicas: "2"
  staleReplicaTimeout: "30"
  fsType: "ext4"
volumeBindingMode: Immediate
allowVolumeExpansion: true
reclaimPolicy: Delete
EOF

kubectl apply -f longhorn-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: longhorn-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. 总结

Longhorn是一种强大的云原生容器存储解决方案，专为Kubernetes设计，提供了一种在Kubernetes集群中部署、配置和管理分布式块存储的方法。它通过自动复制数据提供高可用性，支持快照、备份、克隆等高级功能。

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

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

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

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