Introducing KubeStash v2026.11.15

We are pleased to announce the release of KubeStash v2026.11.15 . This release rolls up the changes from v2026.11.10 and brings a resident KubeVirt CBT archiver with point-in-time restore, PVC support for kubectl kubestash download, DocumentDB continuous archiving with PITR, and a fix that stops a repository’s lastBackupTime from moving backwards. You can check out the full changelogs for v2026.11.15 and v2026.11.10 . In this post, we’ll highlight the key changes.


Quick highlights

  • Added the KubeVirtArchiver and KubeVirtArchiverRestore APIs: continuous, incremental VM backup using KubeVirt changed block tracking (CBT) with Restic, and restore to the latest or to a point in time.
  • Added PVC as storage support to kubectl kubestash download, so snapshots in a local PVC backend can be downloaded.
  • Added DocumentDB continuous archiving with a DocumentDBArchiver (full, WAL and manifest backups) and point-in-time recovery.
  • Fixed Repository lastBackupTime moving backwards when snapshots are resynced.

What’s New

KubeVirt: Continuous CBT Backup and Point-in-Time Restore

KubeStash already backs up KubeVirt VMs on a schedule. The new KubeVirtArchiver makes this continuous. A resident job per VM uses KubeVirt’s native CBT pull-mode export and streams each disk’s map-and-extent artifact straight into Restic. That gives you:

  • One full backup, then native incrementals. After the first full, every run carries only the dirty extents (plus map operations such as zero/hole), not a full raw disk.
  • No VM-sized staging PVC. The only temporary volume is KubeVirt’s per-export scratch PVC, which the archiver deletes after each iteration.
  • An ordered checkpoint lineage per disk, recorded on the Snapshot (status.components.<disk>.resticCBTStats): each entry has a kind (full or incremental), its checkpoint, and the parentCheckpoint it extends.
  • Safe failure handling. A partial checkpoint is never published. If a run fails, the next one re-anchors with a full backup instead of extending a broken chain.

Prepare the VM first. Label it so it matches a changedBlockTrackingLabelSelectors entry in your KubeVirt CR (here cbt: enabled), plus a label the archiver selects on, and use masquerade networking so the pull-mode export can reach the VM:

apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
  name: restic-cbt-vm
  namespace: demo
  labels:
    cbt: enabled                         # matches KubeVirt's CBT label selector
    kubestash.com/cbt-archive: enabled   # selected by the KubeVirtArchiver
spec:
  runStrategy: Always
  template:
    spec:
      domain:
        devices:
          interfaces:
            - name: default
              masquerade: {}             # pull-mode export traffic returns via the pod network
      networks:
        - name: default
          pod: {}
  # disks, DataVolumes and volumes omitted for brevity

Then create the archiver:

apiVersion: core.kubestash.com/v1alpha1
kind: KubeVirtArchiver
metadata:
  name: restic-cbt-archiver
  namespace: demo
spec:
  virtualMachines:
    namespaces:
      from: Same
    selector:
      matchLabels:
        kubestash.com/cbt-archive: enabled
  backupStorage:
    ref:
      name: s3-storage
      namespace: demo
    subDir: /cbt-archiver
  encryptionSecret:
    name: encrypt-secret
    namespace: demo
  fullBackup:
    driver: Restic
    scheduler:
      schedule: "0 1 * * *"       # a fresh full every night
      jobTemplate: {}             # required by the API, even when empty
  cbtBackup:
    interval: 10m                 # incremental cadence, and so your RPO
    scratchStorageClass: local-path
    # skipQuiesce: true           # only for guests without a QEMU guest agent
    retentionPeriod: 7d
    retentionSchedule: "0 0 * * *"
    successfulHistoryLimit: 5
    failedHistoryLimit: 5

To recover, create a KubeVirtArchiverRestore. It restores the newest complete multi-disk checkpoint, or, with recoveryPoint.targetTime, the newest complete checkpoint at or before that UTC time. Each checkpoint holds every disk plus an immutable copy of the VM manifest, so the restored VM is consistent. The target VM must not already exist: the restore refuses to overwrite one, and your source VM is never touched.

apiVersion: core.kubestash.com/v1alpha1
kind: KubeVirtArchiverRestore
metadata:
  name: restic-cbt-vm-restore
  namespace: demo
spec:
  archiverRef:
    name: restic-cbt-archiver
  source:
    name: restic-cbt-vm
  target:
    name: restic-cbt-vm-restored
  recoveryPoint:
    targetTime: "2026-11-10T07:47:39Z"   # optional; omit to restore the latest checkpoint

A point-in-time target resolves to the newest complete checkpoint at or before the requested time, so your recovery granularity equals the cbtBackup.interval. The restore can also be run from a different namespace than the source.


CLI: Download Snapshots from a PVC Backend

Local backends that are backed by a PersistentVolumeClaim are common in air-gapped and on-prem clusters, but kubectl kubestash download used to fail on them with unsupported type of local backend provided. It now supports a PVC as the storage backend. For example, with this BackupStorage:

apiVersion: storage.kubestash.com/v1alpha1
kind: BackupStorage
metadata:
  name: local-storage-with-pvc
  namespace: demo
spec:
  default: true
  deletionPolicy: WipeOut
  runtimeSettings:
    pod:
      securityContext:
        fsGroup: 65534
  storage:
    provider: local
    local:
      mountPath: /safe/data
      persistentVolumeClaim:
        claimName: backup-pvc
  usagePolicy:
    allowedNamespaces:
      from: Same

you can pull any snapshot to your workstation:

$ kubectl kubestash download <snapshot-name> -n demo --destination=/tmp/snapshot-data

DocumentDB: Manifest Backup and Continuous Archiving (PITR)

KubeStash can now archive a KubeDB-managed DocumentDB continuously. The new DocumentDBArchiver combines three things:

  • Full backups with Restic, taken on a schedule.
  • WAL log backups, shipped continuously so you can recover to any second inside the archived window.
  • Manifest backups of the Kubernetes objects around the database (the new manifest backup support in apimachinery), kept in their own repository.

Create the archiver. A DocumentDB joins it through a label selector:

apiVersion: archiver.kubedb.com/v1alpha1
kind: DocumentDBArchiver
metadata:
  name: documentdb-archiver
  namespace: demo
spec:
  databases:
    namespaces:
      from: Selector
      selector:
        matchLabels:
          kubernetes.io/metadata.name: demo
    selector:
      matchLabels:
        archiver: enabled
  fullBackup:
    driver: Restic
    scheduler:
      schedule: "0 1 * * *"           # nightly full backup
      successfulJobsHistoryLimit: 1
      failedJobsHistoryLimit: 1
  manifestBackup:
    scheduler:
      schedule: "*/30 * * * *"        # manifests every 30 minutes
      successfulJobsHistoryLimit: 1
      failedJobsHistoryLimit: 1
  logBackup:
    runtimeSettings: {}
  backupStorage:
    ref:
      name: s3-storage
      namespace: demo
  encryptionSecret:
    name: encrypt-secret
    namespace: demo
  retentionPolicy:
    name: demo-retention
    namespace: demo

Then label the DocumentDB and point spec.archiver.ref at the archiver. WAL is only shipped when a segment fills (16 MB) or when archive_timeout fires, so set archive_timeout to bound how much data you can lose. Here it is 60 seconds:

apiVersion: kubedb.com/v1alpha2
kind: DocumentDB
metadata:
  name: dcdb-pitr
  namespace: demo
  labels:
    archiver: enabled
spec:
  version: pg17-0.109.0
  replicas: 1
  storageType: Durable
  storage:
    accessModes: ["ReadWriteOnce"]
    resources:
      requests:
        storage: 1Gi
  configuration:
    inline:
      user.conf: |
        archive_timeout = 60        
  archiver:
    ref:
      name: documentdb-archiver
      namespace: demo
  deletionPolicy: WipeOut

To recover, create a new DocumentDB with spec.init.archiver. Recovery is never done in place. recoveryTimestamp is an RFC3339 UTC time with second precision. manifestRepository is optional; when set, the restore waits for a manifest snapshot before it starts.

apiVersion: kubedb.com/v1alpha2
kind: DocumentDB
metadata:
  name: dcdb-pitr-restored
  namespace: demo
spec:
  version: pg17-0.109.0
  replicas: 1
  storageType: Durable
  storage:
    accessModes: ["ReadWriteOnce"]
    resources:
      requests:
        storage: 1Gi
  init:
    archiver:
      recoveryTimestamp: "2026-11-15T11:10:22Z"   # a UTC time inside the archived window
      encryptionSecret:
        name: encrypt-secret
        namespace: demo
      fullDBRepository:
        name: dcdb-pitr-full
        namespace: demo
      manifestRepository:
        name: dcdb-pitr-manifest
        namespace: demo
  deletionPolicy: WipeOut

In our test we inserted a batch of rows, noted the time, inserted a second batch, and restored to a timestamp between the two. The restored database contained only the first batch.


Bug Fixes and Improvements

  • lastBackupTime no longer goes backwards. When snapshots were resynced, the Repository’s lastBackupTime could be set to an older snapshot’s time. That made a healthy repository look stale and could trigger false RPO alerts. It now only moves forward.

Component Versions

The following components have been released as part of KubeStash v2026.11.15:

ComponentVersion
kubestash/apimachineryv0.32.0
kubestash/kubestashv0.32.0
kubestash/cliv0.31.0
kubestash/kubedumpv0.31.0
kubestash/pvcv0.31.0
kubestash/workloadv0.31.0
kubestash/manifestv0.24.0
kubestash/volume-snapshotterv0.31.0
kubestash/vaultv0.6.0
kubestash/kubevirtv0.4.0
kubestash/ui-serverv0.4.0
kubestash/installerv2026.11.15
kubestash/docsv2026.11.15

What Next?

Please try the latest release and give us your valuable feedback.

  • If you want to install KubeStash in a clean cluster, please follow the installation instruction from HERE .
  • If you want to upgrade KubeStash from a previous version, please follow the upgrade instruction from HERE .

Support

To speak with us, please leave a message on our website .


TAGS

Ready to Transform Your
Cloud Native Journey?

Join hundreds of companies using AppsCode products and services to build, deploy, and manage production-grade Kubernetes applications.

Enterprise Support

24/7 Monitoring

Expert Consultation

Trusted by Fortune 500 companies and innovative startups worldwide