DEV Community

Cover image for 🔌 Programmable backups are here: Introducing Plakar integrations
Julien Mangeard
Julien Mangeard

Posted on

🔌 Programmable backups are here: Introducing Plakar integrations

#backup #devops #cicd

Hey Dev.to 👋

I’m Julien, co-founder of Plakar, a simple and reliable open-source backup solution. Today we’re excited to introduce our new Go SDK, which makes backups truly programmable—and we think you’re going to love what that unlocks.

What is Plakar?

Plakar is an open-source, CLI-first backup and restore tool built on our immutable storage engine, Kloset. It delivers:

  • Military-grade end-to-end encryption
  • Content-addressed deduplication
  • Compression, immutability and verifiable restores
  • Tiny storage and bandwidth overhead

Engineers love its Unix-style commands and defaults that just work. Check out the repo on GitHub:
👉 https://github.com/PlakarKorp/plakar

💡 Backups aren’t just insurance anymore

In modern environments, backups need to be part of your stack:

  • Hook into your CI/CD: run application-consistent backups on every deploy
  • Automate restores: test rollbacks in staging or spin up a disaster-recovery drill
  • Embed scanners: plug in compliance checks or secret detectors right in the backup pipeline
  • Ship your own connectors: whether it’s a proprietary database or a custom SaaS API

With programmability, your backups become first-class citizens of your infrastructure.

🚀 Discover the programmable stack

We shipped a new integration framework in Kloset: any source or destination can now be a connectors bundle in an "integration package". You can consider this framework to backup and restore: databases, SaaS apps, IMAP inboxes, local folders, object/blob storages, APIs data.

If you can read it, Plakar can protect it.

🛠️ Build your custom backup integration with go-kloset-sdk

Most backup systems don’t even let you write your own connectors or plugins, forcing you to rely on limited built-in options.

With go-kloset-sdk, you can design, build, and package custom backup components in minutes—no low-level plumbing or protocol handling required.

1. Implement the Connector Interface

Example: A simple FTP source connector:

func NewFTPImporter(...) (importer.Importer, error)
func (p *FTPImporter) Close() error

// produce the full list of resources to backup
func (p *FTPImporter) Scan() (<-chan *importer.ScanResult, error)

// provide a ReadCloser to a specific ressource 
func (p *FTPImporter) NewReader(string) (io.ReadCloser, error)
Enter fullscreen mode Exit fullscreen mode

That’s really it. Connect to the resource, expose the data.

2. Implement the Connector Interface

Second step is to write a main.go that registers the implementation to the SDK:

package main

import (
    "fmt"
    "os"

    "github.com/PlakarKorp/go-kloset-sdk/sdk"
    "github.com/PlakarKorp/integration-ftp/importer"
)

func main() {
    if len(os.Args) != 1 {
        fmt.Printf("Usage: %s\n", os.Args[0])
        os.Exit(1)
    }

    err := sdk.RunImporter(importer.NewFTPImporter);
    if err != nil {
        panic(err)
    }
}
Enter fullscreen mode Exit fullscreen mode

3. Describe it in a Manifest 

name: ftp
description: ftp importer
version: 0.1.0
connectors:
- type: importer
  executable: ftpImporter
  homepage: https://github.com/PlakarKorp/integration-ftp
  license: ISC
  protocols: [ftp]
Enter fullscreen mode Exit fullscreen mode

4. Build the Package 

$ go build -o ftpImporter ./plugin/importer
$ plakar pkg create manifest.yaml
Enter fullscreen mode Exit fullscreen mode

You’ll get a ftp-v0.1.0.ptar you can install:

$ plakar pkg add ftp-v0.1.0.ptar
Enter fullscreen mode Exit fullscreen mode

And voilà — ftp:// becomes a fully-supported import source in your setup.

Explore the SDK and examples:
👉 https://github.com/PlakarKorp/go-kloset-sdk

👷‍♀️ For SREs: integrate missing stack elements

Is there a piece of your infrastructure that lacks a backup story? Maybe:

  • A legacy CRM with only ad-hoc exports
  • A proprietary message queue without snapshot support
  • A home-grown secrets vault

With a few lines of Go you can bridge it into Plakar’s snapshot engine.

Then your SRE runbooks can include native plakar backup plakar restore steps—no glue scripts, no brittle ad-hoc tooling.

🔐 Your data inherits Kloset’s guarantees

Once your plugin feeds data into Plakar, you instantly get:

  • Immutable, content-addressed storage
  • Built-in encryption and compression
  • Verifiable restore process (tamper-evident digests)
  • Portability across clouds, data centers and air-gapped vaults

Whether you’re snapshotting database dumps, pulling API payloads, or archiving complex object graphs, it all benefits from one battle-tested storage layer.

🧪 Try it now (early access)

Grab our latest development build and dive in:

go install github.com/PlakarKorp/plakar@v1.0.3-devel.455ca52
Enter fullscreen mode Exit fullscreen mode

Check out the code, browse our docs and sample integrations on GitHub:

We’ll be publishing more examples this week—think API-based importers, advanced snapshot transformers and beyond.

💬 Your turn: what will you back up?

We’re building this for engineers and SREs who want more from backups:

  • Which app in your stack still needs a proper backup solution?
  • What service forces you to write fragile glue code just to capture state?
  • What would you love to snapshot and restore as easily as a folder?

Drop a comment below, open an issue on GitHub or join our Discord to share ideas, contribute your own integrations, or help shape the future of programmable backups.

Happy coding!

— The Plakar team

Top comments (0)