mirror of
https://github.com/TECHNOFAB11/zfs-localpv.git
synced 2025-12-12 22:40:12 +01:00
287606b78a
This commits support snapshot and clone commands via CSI driver. User can create snap and clone using the following steps.
Note:
- Snapshot is created via reconciliation CR
- Cloned volume will be on the same zpool where the snapshot is taken
- Cloned volume will have same properties as source volume.
-----------------------------------
Create a Snapshotclass
```
kind: VolumeSnapshotClass
apiVersion: snapshot.storage.k8s.io/v1beta1
metadata:
name: zfspv-snapclass
annotations:
snapshot.storage.kubernetes.io/is-default-class: "true"
driver: zfs.csi.openebs.io
deletionPolicy: Delete
```
Once snapshotclass is created, we can use this class to create a Snapshot
```
apiVersion: snapshot.storage.k8s.io/v1beta1
kind: VolumeSnapshot
metadata:
name: zfspv-snap
spec:
volumeSnapshotClassName: zfspv-snapclass
source:
persistentVolumeClaimName: csi-zfspv
```
```
$ kubectl get volumesnapshot
NAME AGE
zfspv-snap 7m52s
```
```
$ kubectl get volumesnapshot -o yaml
apiVersion: v1
items:
- apiVersion: snapshot.storage.k8s.io/v1beta1
kind: VolumeSnapshot
metadata:
annotations:
kubectl.kubernetes.io/last-applied-configuration: |
{"apiVersion":"snapshot.storage.k8s.io/v1beta1","kind":"VolumeSnapshot","metadata":{"annotations":{},"name":"zfspv-snap","namespace":"default"},"spec":{"source":{"persistentVolumeClaimName":"csi-zfspv"},"volumeSnapshotClassName":"zfspv-snapclass"}}
creationTimestamp: "2020-01-30T10:31:24Z"
finalizers:
- snapshot.storage.kubernetes.io/volumesnapshot-as-source-protection
- snapshot.storage.kubernetes.io/volumesnapshot-bound-protection
generation: 1
name: zfspv-snap
namespace: default
resourceVersion: "30040"
selfLink: /apis/snapshot.storage.k8s.io/v1beta1/namespaces/default/volumesnapshots/zfspv-snap
uid: 1a5cf166-c599-4f58-9f3c-f1148be47fca
spec:
source:
persistentVolumeClaimName: csi-zfspv
volumeSnapshotClassName: zfspv-snapclass
status:
boundVolumeSnapshotContentName: snapcontent-1a5cf166-c599-4f58-9f3c-f1148be47fca
creationTime: "2020-01-30T10:31:24Z"
readyToUse: true
restoreSize: "0"
kind: List
metadata:
resourceVersion: ""
selfLink: ""
```
Openebs resource for the created snapshot
```
$ kubectl get snap -n openebs -o yaml
apiVersion: v1
items:
- apiVersion: openebs.io/v1alpha1
kind: ZFSSnapshot
metadata:
creationTimestamp: "2020-01-30T10:31:24Z"
finalizers:
- zfs.openebs.io/finalizer
generation: 2
labels:
kubernetes.io/nodename: pawan-2
openebs.io/persistent-volume: pvc-18cab7c3-ec5e-4264-8507-e6f7df4c789a
name: snapshot-1a5cf166-c599-4f58-9f3c-f1148be47fca
namespace: openebs
resourceVersion: "30035"
selfLink: /apis/openebs.io/v1alpha1/namespaces/openebs/zfssnapshots/snapshot-1a5cf166-c599-4f58-9f3c-f1148be47fca
uid: e29d571c-42b5-4fb7-9110-e1cfc9b96641
spec:
capacity: "4294967296"
fsType: zfs
ownerNodeID: pawan-2
poolName: zfspv-pool
status: Ready
volumeType: DATASET
kind: List
metadata:
resourceVersion: ""
selfLink: ""
```
Create a clone volume
We can provide a datasource as snapshot name to create a clone volume
```yaml
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
name: zfspv-clone
spec:
storageClassName: openebs-zfspv
dataSource:
name: zfspv-snap
kind: VolumeSnapshot
apiGroup: snapshot.storage.k8s.io
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 4Gi
```
It will create a ZFS clone volume from the mentioned snapshot and create the PV on the same node where original volume is there.
Here, As resize is not supported yet, the clone PVC size should match the size of the snapshot.
Also, all the properties from the storageclass will not be considered for the clone case, it will take the properties from the snapshot and create the clone volume. One thing to note here is that, the storageclass in clone PVC should have the same poolname as that of the original volume as across the pool, clone is not supported.
Signed-off-by: Pawan <pawan@mayadata.io>
106 lines
3.2 KiB
Go
106 lines
3.2 KiB
Go
/*
|
|
Copyright 2019 The OpenEBS Authors
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package volume
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
"github.com/pkg/errors"
|
|
|
|
"time"
|
|
|
|
clientset "github.com/openebs/zfs-localpv/pkg/generated/clientset/internalclientset"
|
|
informers "github.com/openebs/zfs-localpv/pkg/generated/informer/externalversions"
|
|
kubeinformers "k8s.io/client-go/informers"
|
|
"k8s.io/client-go/kubernetes"
|
|
"k8s.io/client-go/rest"
|
|
"k8s.io/client-go/tools/clientcmd"
|
|
)
|
|
|
|
var (
|
|
masterURL string
|
|
kubeconfig string
|
|
)
|
|
|
|
// Start starts the zfsvolume controller.
|
|
func Start(controllerMtx *sync.RWMutex, stopCh <-chan struct{}) error {
|
|
// Get in cluster config
|
|
cfg, err := getClusterConfig(kubeconfig)
|
|
if err != nil {
|
|
return errors.Wrap(err, "error building kubeconfig")
|
|
}
|
|
|
|
// Building Kubernetes Clientset
|
|
kubeClient, err := kubernetes.NewForConfig(cfg)
|
|
if err != nil {
|
|
return errors.Wrap(err, "error building kubernetes clientset")
|
|
}
|
|
|
|
// Building OpenEBS Clientset
|
|
openebsClient, err := clientset.NewForConfig(cfg)
|
|
if err != nil {
|
|
return errors.Wrap(err, "error building openebs clientset")
|
|
}
|
|
|
|
kubeInformerFactory := kubeinformers.NewSharedInformerFactory(kubeClient, time.Second*30)
|
|
zvInformerFactory := informers.NewSharedInformerFactory(openebsClient, time.Second*30)
|
|
// Build() fn of all controllers calls AddToScheme to adds all types of this
|
|
// clientset into the given scheme.
|
|
// If multiple controllers happen to call this AddToScheme same time,
|
|
// it causes panic with error saying concurrent map access.
|
|
// This lock is used to serialize the AddToScheme call of all controllers.
|
|
controllerMtx.Lock()
|
|
|
|
controller, err := NewZVControllerBuilder().
|
|
withKubeClient(kubeClient).
|
|
withOpenEBSClient(openebsClient).
|
|
withZVSynced(zvInformerFactory).
|
|
withZVLister(zvInformerFactory).
|
|
withRecorder(kubeClient).
|
|
withEventHandler(zvInformerFactory).
|
|
withWorkqueueRateLimiting().Build()
|
|
|
|
// blocking call, can't use defer to release the lock
|
|
controllerMtx.Unlock()
|
|
|
|
if err != nil {
|
|
return errors.Wrapf(err, "error building controller instance")
|
|
}
|
|
|
|
go kubeInformerFactory.Start(stopCh)
|
|
go zvInformerFactory.Start(stopCh)
|
|
|
|
// Threadiness defines the number of workers to be launched in Run function
|
|
return controller.Run(2, stopCh)
|
|
}
|
|
|
|
// GetClusterConfig return the config for k8s.
|
|
func getClusterConfig(kubeconfig string) (*rest.Config, error) {
|
|
cfg, err := rest.InClusterConfig()
|
|
if err != nil {
|
|
logrus.Errorf("Failed to get k8s Incluster config. %+v", err)
|
|
if kubeconfig == "" {
|
|
return nil, errors.Wrap(err, "kubeconfig is empty")
|
|
}
|
|
cfg, err = clientcmd.BuildConfigFromFlags(masterURL, kubeconfig)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "error building kubeconfig")
|
|
}
|
|
}
|
|
return cfg, err
|
|
}
|