🔌 Programmable backups are here: Introducing Plakar integrations

Julien Mangeard — Sun, 20 Jul 2025 16:20:13 +0000

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)

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)
    }
}

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]

4. Build the Package

$ go build -o ftpImporter ./plugin/importer
$ plakar pkg create manifest.yaml

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

$ plakar pkg add ftp-v0.1.0.ptar

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

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

Plakar core: https://github.com/PlakarKorp/plakar
go-kloset-sdk: https://github.com/PlakarKorp/go-kloset-sdk

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

DEV Community: Julien Mangeard