精华内容
下载资源
问答
  • 目录 k8s存储卷-volumes 为什么要用volumes? volumes类型 emptyDir gitrepo hostPath nfs k8s--PV, PVC PV PVC带来了哪...

    k8s存储卷-volumes

    为什么要用volumes?

    容器中的磁盘的生命周期是短暂的, 这就带来了一些列的问题:

    1. 当一个容器损坏之后, kubelet会重启这个容器, 但是文件会丢失, 这个容器将是一个全新的状态
    2. 当很多容器运行在同一个pod中时, 很多时候需要数据文件的共享
    3. k8s中,由于pod分布在各个不同的节点之上,并不能实现不同节点之间持久性数据的共享,并且,在节点故障时,可能会导致数据的永久性丢失。

    volumes就是用来解决以上问题的

    Volume 的生命周期独立于容器,Pod 中的容器可能被销毁和重建,但 Volume 会被保留。

    volumes类型

    emptyDir

    一个emptyDir第一次被创建是在一个pod被指定到具体node的时候, 并且会一直存在在pod的生命周期中, 它初始化是一个空的目录,pod中的容器都可以读写这个目录,这个目录可以被挂在到各个容器相同或者不相同的的路径下。当一个pod因为任何原因被移除的时候,这些数据会被永久删除。注意:一个容器崩溃了不会导致数据的丢失,因为容器的崩溃并不移除pod.
    apiVersion: v1
    kind: Pod
    metadata:
      name: pod-demo   #name必须小写
      namespace: default
      labels:
        app: myapp
        tier: frontend
      annotations:
        create-by: tianpei.wang
    spec:
      containers:
      - name: myapp
        image: ikubernetes/myapp:v1
        ports:
        - name: http
          containerPort: 80
        volumeMounts:
        - name: html
          mountPath: /data/web/html/
    
      - name: busybox
        image: busybox:latest
        imagePullPolicy: IfNotPresent
        volumeMounts:
        - name: html
          mountPath: /data/
        command: ["/bin/sh", "-c", "sleep 7200"]
      volumes:
      - name: html
        emptyDir: {}

    gitrepo

    本质上还是一个emptyDir,创建的那一刻从git上clone下来文件,不会在更新,所以会借助sidecar容器来更新或者推送目录中的文件代码

    hostPath

    一个hostPath类型的磁盘就是挂在了主机的一个文件或者目录,这个功能可能不是那么常用,但是这个功能提供了一个很强大的突破口对于某些应用来说 例如,如下情况我们旧可能需要用到hostPath!!!!!! 一. 某些应用需要用到docker的内部文件,这个时候只需要挂在本机的/var/lib/docker作为hostPath!!!!!! 二. 在容器中运行cAdvisor,这个时候挂在/dev/cgroups!!!!!!
    apiVersion: v1
    kind: Pod
    metadata:
        name: pod-volume-hostpath
        namespace: default
    spec:
        containers:
        - name: myapp
          image: ikubernetes/myapp:v1
          volumeMounts:
          - name: html
            mountPath: /usr/share/nginx/html
        volumes:
        - name: html
          hostPath:
            path: /data/pod/volume1
            type: DirectoryOrCreate

    nfs

    安装部署nfs

    yum install -y nfs-utils rpcbind
    systemctl start rpcbind
    systemctl start nfs
    [root@test share]# cat /etc/exports
    /data/share 10.0.0.0/24(rw,no_root_squash)
    apiVersion: v1
    kind: Pod
    metadata:
        name: pod-volume-hostpath
        namespace: default
    spec:
        containers:
        - name: myapp
          image: ikubernetes/myapp:v1
          volumeMounts:
          - name: html
            mountPath: /usr/share/nginx/html
        volumes:
        - name: html
          nfs:
            path: /data/share
            server: 10.0.0.53

    k8s--PV, PVC

    PV PVC带来了哪些好处

    Volume 提供了非常好的数据持久化方案,不过在可管理性上还有不足。

    如前面nfs-volume举例, 当我们创建一个挂载到nfs服务器上的pod时, 我们需要知道:

    1. nfs服务的ip
    2. nfs服务的共享目录

    Pod 通常是由应用的开发人员维护,而 Volume 则通常是由存储系统的管理员维护。开发人员要获得上面的信息:

    1. 要么询问管理员。
    2. 要么自己就是管理员。

    这样就带来一个管理上的问题:应用开发人员和系统管理员的职责耦合在一起了。如果系统规模较小或者对于开发环境这样的情况还可以接受。但当集群规模变大,特别是对于生成环境,考虑到效率和安全性,这就成了必须要解决的问题。

    Kubernetes 给出的解决方案是 PersistentVolume 和 PersistentVolumeClaim。

    PersistentVolume (PV) 是外部存储系统中的一块存储空间,由管理员创建和维护。与 Volume 一样,PV 具有持久性,生命周期独立于 Pod。

    PersistentVolumeClaim (PVC) 是对 PV 的申请 (Claim)。PVC 通常由普通用户创建和维护。需要为 Pod 分配存储资源时,用户可以创建一个 PVC,指明存储资源的容量大小和访问模式(比如只读)等信息,Kubernetes 会查找并提供满足条件的 PV。

    有了 PersistentVolumeClaim,用户只需要告诉 Kubernetes 需要什么样的存储资源,而不必关心真正的空间从哪里分配,如何访问等底层细节信息。这些 Storage Provider 的底层信息交给管理员来处理,只有管理员才应该关心创建 PersistentVolume 的细节信息。

    • 一个pv只能对应一个pvc,但是一个pvc可以对应多个pod
    • pv属于集群级别的资源,整个集群都可以用;pvc属于namespace级别的资源,只属于所属namespace
    • pvc资源存储在etcd中,只要etcd服务正常就不会丢失,和节点没有关系

    1120683-20190910163548359-1520185793.png

    1120683-20190910163621092-1256290588.png

    基于nfs配置pv和pvc

    nfs的配置参考前文

    定义pv

    apiVersion: v1
    kind: PersistentVolume
    metadata:
        name: pv001
        labels:
            name: pv001
    spec:
        nfs:
            path: /data/volumes/test1
            server: 10.0.0.53
        accessModes: ["ReadWriteMany","ReadWriteOnce"]
        capacity:
            storage: 2Gi
    ---
    apiVersion: v1
    kind: PersistentVolume
    metadata:
        name: pv002
        labels:
            name: pv002
    spec:
        nfs:
            path: /data/volumes/test2
            server: 10.0.0.53
        accessModes: ["ReadWriteMany","ReadWriteOnce"]
        capacity:
            storage: 2Gi
    ---
    apiVersion: v1
    kind: PersistentVolume
    metadata:
        name: pv003
        labels:
            name: pv003
    spec:
        nfs:
            path: /data/volumes/test3
            server: 10.0.0.53
        accessModes: ["ReadWriteMany","ReadWriteOnce"]
        capacity:
            storage: 7Gi
    [root@master volumes]# kubectl get pv
    NAME    CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM           STORAGECLASS   REASON   AGE
    pv001   2Gi        RWO,RWX        Retain           Available                                           14m
    pv002   2Gi        RWO,RWX        Retain           Available                                           14m
    pv003   7Gi        RWO,RWX        Retain           Available                                           14m

    accessModes:

    • ReadWriteOnce (RWO) – the volume can be mounted as read-write by a single node
    • ReadOnlyMany (ROX) – the volume can be mounted read-only by many nodes
    • ReadWriteMany (RWX) – the volume can be mounted as read-write by many nodes

    定义pvc

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
        name: mypvc
        namespace: default
    spec:
        accessModes: ["ReadWriteMany"]
        resources:
            requests:
                storage: 6Gi
    ---
    apiVersion: v1
    kind: Pod
    metadata:
        name: myapp-pvc
        namespace: default
    spec:
        containers:
        - name: myapp
          image: ikubernetes/myapp:v1
          volumeMounts:
          - name: html
            mountPath: /usr/share/nginx/html
        volumes:
        - name: html
          persistentVolumeClaim:
            claimName: mypvc

    此时发现有符合要求的pv被绑定到了pod上

    [root@master volumes]# kubectl get pv
    NAME    CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM           STORAGECLASS   REASON   AGE
    pv001   2Gi        RWO,RWX        Retain           Available                                           15m
    pv002   2Gi        RWO,RWX        Retain           Available                                           15m
    pv003   7Gi        RWO,RWX        Retain           Bound       default/mypvc                           15m

    以mysql:5.6镜像为例

    1. 直接使用上例创建的pv

    2. 创建mysql的pvc和deployment

      apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
          name: mypvc
          namespace: default
      spec:
          accessModes: ["ReadWriteMany"]
          resources:
              requests:
                  storage: 6Gi
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
          name: mysql-deployment
          namespace: default
      spec:
          replicas: 1
          selector:
              matchLabels:
                  app: mysql
          template:
              metadata:
                labels:
                  app: mysql
              spec:
                  containers:
                  - name: mysql
                    image: mysql:5.6
                    imagePullPolicy: IfNotPresent
                    args:
                    - "--ignore-db-dir=lost+found"
                    ports:
                    - containerPort: 3306
                    env:
                    - name: MYSQL_ROOT_PASSWORD
                      value: "mysql"
                    volumeMounts:
                    - name: mysql
                      mountPath: /var/lib/mysql
                  volumes:
                  - name: mysql
                    persistentVolumeClaim:
                        claimName: mypvc
    3. 然后在创建的pod中创建数据

      kubectl exec -it pod mysql-deployment-5b9cf7df5c-mh94v -- /bin/sh
      
      #在pod中可以看到挂载好的nfs磁盘
      # df -h
      Filesystem                     Size  Used Avail Use% Mounted on
      overlay                         20G  3.7G   16G  19% /
      tmpfs                           64M     0   64M   0% /dev
      tmpfs                          912M     0  912M   0% /sys/fs/cgroup
      /dev/sda2                       20G  3.7G   16G  19% /etc/hosts
      shm                             64M     0   64M   0% /dev/shm
      10.0.0.53:/data/volumes/test3   20G  4.3G   16G  22% /var/lib/mysql
      
      #进入mysql
      # mysql -uroot -pmysql
      
      #创建新的数据库
      mysql> create database wtp;
      
      #进入新库
      mysql> use wtp;
      
      #创建新的表
      mysql> CREATE TABLE `tbl_dept`(
          -> `id` INT(11) NOT NULL AUTO_INCREMENT,
          -> `deptName` VARCHAR(30) DEFAULT NULL,
          -> `locAdd`  VARCHAR(40) DEFAULT NULL,
          -> PRIMARY KEY (`id`)
          -> )ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
      Query OK, 0 rows affected (0.12 sec)
      
      #删除mysql的deployment
      kubectl delete deployments mysql-deployment
      
      #重新创建mysql的deployment
      kubectl apply -f pvc.yaml
      
      #进入新的mysql pod
      kubectl exec -it mysql-deployment-5b9cf7df5c-ztfwx -- /bin/sh
      
      #可以看到依旧挂载的之前的目录
      # df -h
      Filesystem                     Size  Used Avail Use% Mounted on
      overlay                         20G  3.7G   16G  19% /
      tmpfs                           64M     0   64M   0% /dev
      tmpfs                          912M     0  912M   0% /sys/fs/cgroup
      /dev/sda2                       20G  3.7G   16G  19% /etc/hosts
      shm                             64M     0   64M   0% /dev/shm
      10.0.0.53:/data/volumes/test3   20G  4.3G   16G  22% /var/lib/mysql
      
      #进入mysql查看之前的数据都还在
      mysql> show databases;
      +--------------------+
      | Database           |
      +--------------------+
      | information_schema |
      | mysql              |
      | performance_schema |
      | wtp                |
      +--------------------+
      4 rows in set (0.08 sec)
      
      mysql> use wtp
      Reading table information for completion of table and column names
      You can turn off this feature to get a quicker startup with -A
      
      Database changed
      mysql> show tables
          -> ;
      +---------------+
      | Tables_in_wtp |
      +---------------+
      | tbl_dept      |
      +---------------+
      1 row in set (0.00 sec)

    转载于:https://www.cnblogs.com/peitianwang/p/11498279.html

    展开全文
  • k8s 一图看懂StorageClass pv pvc关系

    千次阅读 2021-04-09 11:19:31
    集群管理员预先创建存储类(Storage...系统基于存储类的信息,在后台自动创建PVC需要的PV; 用户创建一个使用PVC的Pod; Pod中的应用通过PVC进行数据的持久化; 而PVC使用PV进行数据的最终持久化处理。 ...

    在这里插入图片描述

    1. 集群管理员预先创建存储类(StorageClass);

    2. 用户创建使用存储类的持久化存储声明(PVC:PersistentVolumeClaim);

    3. 存储持久化声明通知系统,它需要一个持久化存储(PV: PersistentVolume);

    4. 系统读取存储类的信息;

    5. 系统基于存储类的信息,在后台自动创建PVC需要的PV;

    6. 用户创建一个使用PVC的Pod;

    7. Pod中的应用通过PVC进行数据的持久化;

    8. 而PVC使用PV进行数据的最终持久化处理。

    展开全文
  • Kubernetes存储(Volumes PV PVC) 1.1 Volume Volume:https://kubernetes.io/docs/concepts/storage/volumes/ On-disk files in a Container are ephemeral, which presents some problems for non-trivial ...

    Kubernetes存储(Volumes PV PVC)

    1.1 Volume

    Volumehttps://kubernetes.io/docs/concepts/storage/volumes/

    On-disk files in a Container are ephemeral, which presents some problems for non-trivial applications when running in Containers. First, when a Container crashes, kubelet will restart it, but the files will be lost - the Container starts with a clean state. Second, when running Containers together in a Pod it is often necessary to share files between those Containers. The Kubernetes Volume abstraction solves both of these problems.
    

    1.2 Host类型volume实战

    背景:定义一个Pod,其中包含两个Container,都使用Pod的Volume

    (1)创建资源

    volume-pod.yaml

    apiVersion: v1
    kind: Pod
    metadata:
      name: volume-pod
    spec:
      containers:
      - name: nginx-container
        image: nginx
        ports:
        - containerPort: 80
        volumeMounts:
        - name: volume-pod
          mountPath: /nginx-volume
      - name: busybox-container
        image: busybox
        command: ['sh', '-c', 'echo The app is running! && sleep 3600']
        volumeMounts:
        - name: volume-pod
          mountPath: /busybox-volume
      volumes:
      - name: volume-pod
        hostPath:
          path: /tmp/volume-pod 
    kubectl apply -f volume-pod.yaml
    

    (2)查看pod的运行情况

    kubectl get pods -o wide
    

    (3)来到运行的worker节点

    docker ps | grep volume
    ls /tmp/volume-pod
    docker exec -it containerid sh
    ls /nginx-volume
    ls /busybox-volume
    # 折腾一下是否同步

    image-20191223150958346

    image-20191223151146077

    image-20191223151258436

    在宿主机的/tmp/volume-pod新建文件。

    image-20191223151446923

    在去容器内查看

    image-20191223151640472

    image-20191223151834402

    (4)查看pod中的容器里面的hosts文件,是否一样。

    发现是一样的,并且都是由pod管理的

    docker exec -it containerid cat /etc/hosts
    

    image-20191223152044350

    (5)所以一般container中的存储或者网络的内容,不要在container层面修改,而是在pod中修改

    比如下面修改一下网络

    spec:
    hostNetwork: true
    hostPID: true
    hostAliases: 
      - ip: "192.168.1.61"
     hostnames: 
        - "test.wenbin.com" 
    containers:
      - name: nginx-container
     image: nginx

    1.3 PersistentVolume

    官网https://kubernetes.io/docs/concepts/storage/persistent-volumes/

    apiVersion: v1
    kind: PersistentVolume
    metadata:
      name: my-pv
    spec:
      capacity:
        storage: 5Gi    # 存储空间大小
      volumeMode: Filesystem
      accessModes:
        - ReadWriteOnce     # 只允许一个Pod进行独占式读写操作
      persistentVolumeReclaimPolicy: Recycle
      storageClassName: slow
      mountOptions:
        - hard
        - nfsvers=4.1
      nfs:
        path: /tmp            # 远端服务器的目录
        server: 172.17.0.2    # 远端的服务器

    说白了,PV是K8s中的资源,volume的plugin实现,生命周期独立于Pod,封装了底层存储卷实现的细节。

    注意:PV的维护通常是由运维人员、集群管理员进行维护的。

    1.4 PersistentVolumeClaim

    官网https://kubernetes.io/docs/concepts/storage/persistent-volumes/#persistentvolumeclaims

    有了PV,那Pod如何使用呢?为了方便使用,我们可以设计出一个PVC来绑定PV,然后把PVC交给Pod来使用即可,且听下面的分析。

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: myclaim
    spec:
      accessModes:
        - ReadWriteOnce
      volumeMode: Filesystem
      resources:
        requests:
          storage: 8Gi
      storageClassName: slow
      selector:
        matchLabels:
          release: "stable"
        matchExpressions:
          - {key: environment, operator: In, values: [dev]}

    说白了,PVC会匹配满足要求的PV[是根据size和访问模式进行匹配的],进行一一绑定,然后它们的状态都会变成Bound。

    也就是PVC负责请求PV的大小和访问方式,然后Pod中就可以直接使用PVC咯。

    注意:PVC通常由开发小伙伴维护,开发小伙伴无需关注与存储细节。

    1.5 Pod中如何使用PVC

    官网https://kubernetes.io/docs/concepts/storage/persistent-volumes/#claims-as-volumes

    apiVersion: v1
    kind: Pod
    metadata:
      name: mypod
    spec:
      containers:
        - name: myfrontend
          image: nginx
          volumeMounts:
          - mountPath: "/var/www/html"
            name: mypd
      volumes:
        - name: mypd
          persistentVolumeClaim:
            claimName: myclaim

    1.6 Pod中使用PVC实战

    背景:使用nginx持久化存储演示

    (1)共享存储使用nfs,比如选择在m节点
    (2)创建pv和pvc
    (3)nginx pod中使用pvc
    

    1.6.1 master节点搭建nfs

    在master节点上搭建一个NFS服务器,目录为/nfs/data

    nfs(network file system)网络文件系统,是FreeBSD支持的文件系统中的一种,允许网络中的计算机之间通过TCP/IP网络共享资源
    
    01 选择master节点作为nfs的server,所以在master节点上
    # 安装nfs
    	yum install -y nfs-utils
    	# 创建nfs目录
    	mkdir -p /nfs/data/
    	mkdir -p /nfs/data/mysql
    	# 授予权限
    	chmod -R 777 /nfs/data
    	# 编辑export文件
    	vi /etc/exports
    	  /nfs/data *(rw,no_root_squash,sync)
    	# 使得配置生效
    	exportfs -r
    	# 查看生效
    	exportfs
    	# 启动rpcbind、nfs服务
    	systemctl restart rpcbind && systemctl enable rpcbind
    	systemctl restart nfs && systemctl enable nfs
    	# 查看rpc服务的注册情况
    	rpcinfo -p localhost
    	# showmount测试
    	showmount -e master-ip
    	
    02 所有node上安装客户端
    	yum -y install nfs-utils
    	systemctl start nfs && systemctl enable nfs

    1.6.2 创建PV&PVC&Nginx

    (1)在nfs服务器创建所需要的目录

    mkdir -p /nfs/data/nginx

    (2)定义PV,PVC和Nginx的yaml文件

    nginx-pv-demo.yaml

    # 定义PV
    apiVersion: v1
    kind: PersistentVolume
    metadata:
      name: nginx-pv
    spec:
      accessModes:
        - ReadWriteMany
      capacity:
        storage: 2Gi    
      nfs:
        path: /nfs/data/nginx     
        server: 192.168.1.51vim
        
    ---
    # 定义PVC,用于消费PV
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: nginx-pvc
    spec:
      accessModes:
        - ReadWriteMany
      resources:
        requests:
          storage: 2Gi
      
    ---
    # 定义Pod,指定需要使用的PVC
    apiVersion: apps/v1beta1
    kind: Deployment
    metadata:
      name: nginx
    spec:
      selector:
        matchLabels: 
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - image: nginx
            name: mysql
            ports:
            - containerPort: 80
            volumeMounts:
            - name: nginx-persistent-storage
              mountPath: /usr/share/nginx/html
          volumes:
          - name: nginx-persistent-storage
            persistentVolumeClaim:
              claimName: nginx-pvc

    (3)根据yaml文件创建资源并查看资源

    kubectl apply -f nginx-pv-demo.yaml
    kubectl get pv,pvc
    kubectl get pods -o wide

    image-20191223162844800

    (4)测试持久化存储

    01 在/nfs/data/nginx新建文件1.html,写上内容
    02 kubectl get pods -o wide   得到nginx-pod的ip地址
    03 curl nginx-pod-ip/1.html
    04 kubectl exec -it nginx-pod bash    进入/usr/share/nginx/html目录查看
    05 kubectl delete pod nginx-pod
    06 查看新nginx-pod的ip并且访问nginx-pod-ip/1.html

    image-20191223163109184

    1.6.3 图解理解一下

    image-20191223143710828

    1.7 StorageClass

    上面手动管理PV的方式还是有点low,能不能更加灵活一点呢?

    官网https://kubernetes.io/docs/concepts/storage/storage-classes/

    nfs githubgithubhttps://github.com/kubernetes-incubator/external-storage/tree/master/nfs

    A StorageClass provides a way for administrators to describe the “classes” of storage they offer. Different classes might map to quality-of-service levels, or to backup policies, or to arbitrary policies determined by the cluster administrators. Kubernetes itself is unopinionated about what classes represent. This concept is sometimes called “profiles” in other storage systems.
    
    Each StorageClass contains the fields provisioner, parameters, and reclaimPolicy, which are used when a PersistentVolume belonging to the class needs to be dynamically provisioned.
    
    The name of a StorageClass object is significant, and is how users can request a particular class. Administrators set the name and other parameters of a class when first creating StorageClass objects, and the objects cannot be updated once they are created.
    

    StorageClass声明存储插件,用于自动创建PV。

    说白了就是创建PV的模板,其中有两个重要部分:PV属性和创建此PV所需要的插件。

    这样PVC就可以按“Class”来匹配PV。

    可以为PV指定storageClassName属性,标识PV归属于哪一个Class。

    apiVersion: storage.k8s.io/v1
    kind: StorageClass
    metadata:
      name: standard
    provisioner: kubernetes.io/aws-ebs
    parameters:
      type: gp2
    reclaimPolicy: Retain
    allowVolumeExpansion: true
    mountOptions:
      - debug
    volumeBindingMode: Immediate
    01 对于PV或者StorageClass只能对应一种后端存储
    02 对于手动的情况,一般我们会创建很多的PV,等有PVC需要使用的时候就可以直接使用了
    03 对于自动的情况,那么就由StorageClass来自动管理创建
    04 如果Pod想要使用共享存储,一般会在创建PVC,PVC中描述了想要什么类型的后端存储、空间等,K8s从而会匹配对应的PV,如果没有匹配成功,Pod就会处于Pending状态。Pod中使用只需要像使用volumes一样,指定名字就可以使用了
    05 一个Pod可以使用多个PVC,一个PVC也可以给多个Pod使用
    06 一个PVC只能绑定一个PV,一个PV只能对应一种后端存储
    

    image-20191223143931394

    有了StorageClass之后的PVC可以变成这样

    kind: PersistentVolumeClaim
    apiVersion: v1
    metadata:
    name: test-claim1
    spec:
    accessModes:
        - ReadWriteMany
    resources:
     requests:
        storage: 1Mi
      storageClassName: nfs

    StorageClass之所以能够动态供给PV,是因为Provisioner,也就是Dynamic Provisioning

    但是NFS这种类型,K8s中默认是没有Provisioner插件的,需要自己创建

    image-20191223144015723

    1.8 StorageClass实战

    githubhttps://github.com/kubernetes-incubator/external-storage/tree/master/nfs

    (1)准备好NFS服务器[并且确保nfs可以正常工作],创建持久化需要的目录

    path: /nfs/data/Wenbin

    server: 121.41.10.13

    比如mkdir -p /nfs/data/wenbin

    (2)根据rbac.yaml文件创建资源

    kind: ClusterRole
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: nfs-provisioner-runner
    rules:
      - apiGroups: [""]
        resources: ["persistentvolumes"]
        verbs: ["get", "list", "watch", "create", "delete"]
      - apiGroups: [""]
        resources: ["persistentvolumeclaims"]
        verbs: ["get", "list", "watch", "update"]
      - apiGroups: ["storage.k8s.io"]
        resources: ["storageclasses"]
        verbs: ["get", "list", "watch"]
      - apiGroups: [""]
        resources: ["events"]
        verbs: ["create", "update", "patch"]
      - apiGroups: [""]
        resources: ["services", "endpoints"]
        verbs: ["get"]
      - apiGroups: ["extensions"]
        resources: ["podsecuritypolicies"]
        resourceNames: ["nfs-provisioner"]
        verbs: ["use"]
    ---
    kind: ClusterRoleBinding
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: run-nfs-provisioner
    subjects:
      - kind: ServiceAccount
        name: nfs-provisioner
         # replace with namespace where provisioner is deployed
        namespace: default
    roleRef:
      kind: ClusterRole
      name: nfs-provisioner-runner
      apiGroup: rbac.authorization.k8s.io
    ---
    kind: Role
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: leader-locking-nfs-provisioner
    rules:
      - apiGroups: [""]
        resources: ["endpoints"]
        verbs: ["get", "list", "watch", "create", "update", "patch"]
    ---
    kind: RoleBinding
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: leader-locking-nfs-provisioner
    subjects:
      - kind: ServiceAccount
        name: nfs-provisioner
        # replace with namespace where provisioner is deployed
        namespace: default
    roleRef:
      kind: Role
      name: leader-locking-nfs-provisioner
      apiGroup: rbac.authorization.k8s.io
    kubectl apply -f rbac.yaml

    image-20191224080021867

    (3)根据deployment.yaml文件创建资源

    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: nfs-provisioner
    ---
    kind: Deployment
    apiVersion: extensions/v1beta1
    metadata:
      name: nfs-provisioner
    spec:
      replicas: 1
      strategy:
        type: Recreate
      template:
        metadata:
          labels:
            app: nfs-provisioner
        spec:
          serviceAccount: nfs-provisioner
          containers:
            - name: nfs-provisioner
              image: registry.cn-hangzhou.aliyuncs.com/open-ali/nfs-client-provisioner
              volumeMounts:
                - name: nfs-client-root
                  mountPath: /persistentvolumes
              env:
                - name: PROVISIONER_NAME
                  value: example.com/nfs
                - name: NFS_SERVER
                  value: 192.168.1.51
                - name: NFS_PATH
                  value: /nfs/data/wenbin
          volumes:
            - name: nfs-client-root
              nfs:
                server: 192.168.1.51
                path: /nfs/data/wenbin
    kubectl apply -f deployment.yaml

    image-20191224080355030

    (4)根据class.yaml创建资源

    kind: StorageClass
    apiVersion: storage.k8s.io/v1
    metadata:
      name: example-nfs
    provisioner: example.com/nfs
    kubectl apply -f class.yaml

    image-20191224080521826

    (5)根据pvc.yaml创建资源

    kind: PersistentVolumeClaim
    apiVersion: v1
    metadata:
      name: my-pvc
    spec:
      accessModes:
        - ReadWriteMany
      resources:
        requests:
          storage: 1Mi
      # 这个名字要和上面创建的storageclass名称一致
      storageClassName: example-nfs
    kubectl apply -f my-pvc.yaml
    kubectl get pvc

    image-20191224080727158

    (6)根据nginx-pod创建资源

    kind: Pod
    apiVersion: v1
    metadata:
      name: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        volumeMounts:
          - name: my-pvc
            mountPath: "/usr/wenbin"
      restartPolicy: "Never"
      volumes:
        - name: my-pvc
          persistentVolumeClaim:
            claimName: my-pvc
    kubectl apply -f nginx-pod.yaml
    kubectl exec -it nginx bash
    cd /usr/wenbin
    # 进行同步数据测试

    image-20191224080958700

    1.9 PV的状态和回收策略

    • PV的状态

    Available:表示当前的pv没有被绑定

    Bound:表示已经被pvc挂载

    Released:pvc没有在使用pv, 需要管理员手工释放pv

    Failed:资源回收失败

    • PV回收策略

    Retain:表示删除PVC的时候,PV不会一起删除,而是变成Released状态等待管理员手动清理

    Recycle:在Kubernetes新版本就不用了,采用动态PV供给来替代

    Delete:表示删除PVC的时候,PV也会一起删除,同时也删除PV所指向的实际存储空间

    注意:目前只有NFS和HostPath支持Recycle策略。AWS EBS、GCE PD、Azure Disk和Cinder支持Delete策略

    image-20191223144104156

    展开全文
  • k8s PV PVC简单实践

    2020-07-18 15:44:01
    pv1.yaml apiVersion: v1 kind: PersistentVolume metadata: name: nfs-pv1 labels: pv: nfs-pv1 spec: capacity: storage: 10Mi accessModes: - ReadWriteOnce persistentVolumeReclaimPolicy: Retain ...

     

    pv1.yaml

    apiVersion: v1
    kind: PersistentVolume
    metadata:
      name: nfs-pv1
      labels:
        pv: nfs-pv1
    spec:
      capacity:
        storage: 10Mi
      accessModes:
        - ReadWriteOnce
      persistentVolumeReclaimPolicy: Retain
      mountOptions:
        - soft
        - nolock
        - nfsvers=3
      storageClassName: nfs
      nfs:
        server: *.*.*.*
        path: /mnt/nfs
    

    pvc1.yaml

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: nfs-pvc1
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 10Mi
      storageClassName: nfs
      selector:
        matchLabels:
          pv: nfs-pv1
    

    pod yaml中的配置:

    ...
        spec:
          volumes:
            - name: nfs-pvtest
              persistentVolumeClaim:
                claimName: nfs-pvc1
    ...
          containers:
          - name: iag
            volumeMounts:
              - name: nfs-pvtest
                mountPath: /home/nfs
    ...

     

     

    展开全文
  • K8s 持久化存储 PV PVC

    2020-10-30 11:22:41
    PV 所有节点都要装nfs yum install -y nfs-utils-* mkdir /wp/data /wp/code -p vim /etc/exports /wp/data 192.168.2.0/24(rw,async,no_root_squash,no_all_squash) /wp/code 192.168.2.0/24(rw,async,no_root_...
  • Persistent Volume(持久化卷)简称PV, 是一个K8S资源对象,我们可以单独创建一个PV, 它不和Pod直接发生关系, 而是通过 Persistent Volume Claim, 简称PVC来实现动态...持久化卷下PVPVC概念: Persistent Volume(P...
  • K8s nfs挂载 PV PVC

    2020-04-11 11:35:32
    - name: httpd-data persistentVolumeClaim: claimName: nfs-pvc apiVersion: v1 kind: PersistentVolume metadata: name: nfs-pv01 labels: name: nfs-pv01 spec: capacity: storage: 1Gi accessModes: - ...
  • PV 的使用 有状态的应用和对数据有持久化的应用,我们...但是显然存储资源和 CPU 资源以及内存资源有很大不同,为了屏蔽底层的技术实现细节,让用户更加方便的使用,Kubernetes 便引入了 PVPVC 两个重要的资源对...
  • k8s pv pvc 模版

    千次阅读 2019-04-01 15:41:23
    apiVersion: v1 kind: PersistentVolume metadata: name: jzyqprod-data namespace: jzyq labels: type: pe spec: capacity: storage: 1024Gi volumeMode: Filesystem accessModes: - ReadW...
  • PersistentVolumeClaim(PVC)是用户存储的请求。 它类似于pod。Pod消耗节点资源,PVC消耗存储资源 StorageClass 提供了一种描述他们提供的存储的“类”的方法。...pv.kubernetes.io/bind-completed::yes ...
  • 问题的引入:Pod 通常是由应用的开发人员维护,而 Volume 则通常是由存储系统的管理员维护。这样就带来一个管理上的问题:应用开发人员和系统管理员的职责... PersistentVolume (PV) 是外部存储系统中的一块存储空...
  • kubernetes存储管理按照发展的历程,涉及到有Volume,PV(Persistent Volume)和PVC(PersistentVolumeClaims),和StorageClass,Volume是最早提出的存储卷,主要解决容器和数据存储的依赖关系,抽象底层驱动以支持不同...
  • k8s nfs pv pvc

    2020-02-04 00:16:12
    [root@k8s-master k8s]# cat pv.yaml apiVersion: v1 kind: PersistentVolume metadata: name: pv1 spec: capacity: storage: 5Gi accessModes: - ReadWriteMany persistentVolumeReclaimPolicy: Recycle ...
  • k8s基于nfs创建pvpvc

    2021-11-27 22:57:36
    查看创建结果 kubectl get pv,pvc -n jumpserve [root@k8s01-master-1 pvc]# kubectl get pv,pvc -n jumpserver NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS REASON AGE ...
  • Kubernetes K8S之存储PV-PVC详解

    千次阅读 2020-10-23 00:02:10
    K8S之存储PV-PVC概述与说明,并详解常用PV-PVC示例
  • 使用nfs对pod的数据持久化,进行网络存储时,需要在资源编排文件中暴露nfs主机的ip和存储路径,这样有一定弊端,为了解决这一问题引入了pv pvcpv:存储的资源,提供了资源访问的方式; pvc: ...
  • K8S 创建PV PVC

    2020-08-03 21:30:02
    K8S 创建PV PVC创建PV脚本创建PVC脚本执行命令 创建PV脚本 PV不用指定命令空间,k8s集群使用(标准yml格式) apiVersion: v1 kind: PersistentVolume metadata: labels: app: gateway-pv name: gateway-pv spec:...
  • k8s创建pv&pvc

    千次阅读 2020-12-28 17:56:23
    pvc简介 k8s提供了emptyDir,hostPath,rbd,cephfs等存储方式供容器使用,不过这些存储方式都有一个缺点:开发人员必须得知指定存储的相关配置信息,才能使用存储.例如要使用cephfs,Pod的配置信息就必须指明cephfs的...
  • Kubernets PV PVC详解

    千次阅读 2019-09-29 14:19:25
    Kubernets PV PVC 1. Volume https://kubernetes.io/docs/concepts/storage/volumes/ Kubernetes中的Volume提供了在容器中挂载外部存储的能力 Pod需要设置卷来源(spec.volume)和挂载点(spec.containers....
  • K8s PVPVC(动态)

    2021-01-27 19:19:13
    当用户需要使用存储时,需要通过PVC进行绑定PV,有几种情况会出现问题 PVC需求匹配不到需要的PV PVC需求量很大的时候 用户需求无法确定的常见,会随着环境而改变 存储类就是为了实现PV动态供给,对于PV进行分组...
  • 前言K8S的环境部署主机清单创建NFS持久化目录安装NFS创建PV&PVCK8S中的部署Redis配置文件:configmapDeployment:redisServicek8s验证数据迁移数据备份数据还原关于appendonly.aof和dump.rdb K8S的环境部署 我...
  • PV PVC PV是让kubernetes知道宿主机可以访问NFS等资源 PVC是从PV里取得一块资源让容器使用,同一个目录其实可以定义多个PV,生成多个PV后,再新建PVC,类似是随机绑定一个,实验是绑定最后生成那一个 使用PVC如果...
  • pvpvc

    2019-10-02 15:56:05
    目的: 为了屏蔽底层存储实现的细节, 让用户方便使用同时让管理员方便管理, 引入了pvpvc两种资源对象实现对存储的管理子系统 pv: 对底层网络共享存储的抽象, 将共享存储定义为一种资源 pvc: 用户对存储资源的一个...
  • Kubernetes PVPVC和StorageClass介绍 PVPVC Kubernetes Volume提供了非常好的数据持久化方案,不过对于大型Kubernetes集群来说管理上还有不方便之处。Volume方案需要创建Pod或者Deployment的管理员对共享存储的...
  • 文章目录一、高级存储(一)PV(二)PVC二、PVPVC生命周期 一、高级存储 使用NFS提供存储,此时就要求用户会搭建NFS系统,并且会在yaml配置nfs。由于kubernetes支持的存储系统有很多,要求客户全都掌握,显然不...
  • Kubernetes PVPVC 常见问题

    千次阅读 2021-01-11 12:34:32
    文章目录Kubernetes PVPVC 常见问题PVPVC的关系删除Kubernetes的PVPVC时状态一直为TerminatingPVC创建后一直处在Pending状态 Kubernetes PVPVC 常见问题 PVPVC的关系 PV (PersistentVolume): 由集群管理...
  • k8s资源之pv&pvc&sc

    千次阅读 2019-12-29 10:18:29
    •4.pv/pvc的创建顺序是:pv -> pvc -> pod •5.pv/pvc的销毁顺序是:pod -> pvc -> pv,顺序一定不要错 storageClass: Kubernetes集群管理员通过提供不同的存储类,可以满足用户不同的服务质量级别、备份策略和任意...
  • PVPVC的简介 k8s提供了emptyDir,hostPath,rbd,cephfs等存储方式供容器使用,(关于常用的emptyDir与hostPath的简介与区别,可以参考这篇文章【K8S】Volume类型-EmptyDir与HostPath的区别)。 不过这些存储方式都...
  • PVPVC是kubernetes集群中两个新的API资源,PVPVC是一对一的映射关系,PVC会根据storageClassName(存储类的名称)、accessModes (访问的模式),存储容量大小判断的时候,首要条件就是PV声明容量大于等于PVC...
  • pvpvc的绑定

    2021-03-08 09:53:11
    创建pv apiVersion: v1 kind: PersistentVolume metadata: name: pv003 labels: app: vnc003 namespace: vnc-space spec: capacity: storage: 5Gi accessModes: - ReadWriteMany ...path: "/home/pv" ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,594
精华内容 3,437
关键字:

pvpvc