Dapr pluggable components Go SDK

Pluggable components are Dapr components that resides outside Dapr binary and are dynamically registered in runtime.

The SDK provides a better interface to create pluggable components without worrying about underlying communication protocols and connection resiliency.

Building blocks Interfaces

All building blocks interfaces for this sdk follows the same interfaces provided by the built-in components.

See concrete examples of them:

Implementing your own State Store pluggable component

Implement the State Store interface.

Implementing your own Input/Output Binding pluggable component

Implement the Input or/and Output interface.

Implementing your own Pub/Sub pluggable component

Implement the Pub/Sub interface.

Registering a pluggable component

Once you have your component implemented, now in order to get your component discovered and registered by Dapr runtime you must register it using the sdk.

Let's say you want to name your state store component as my-component, so you have to do the following:

package main

import (
	dapr "github.com/dapr-sandbox/components-go-sdk"
	"github.com/dapr-sandbox/components-go-sdk/state/v1"
)


func main() {
	dapr.Register("my-component", dapr.WithStateStore(func() state.Store {
		return &MyStateStoreComponent{}
	}))
	dapr.MustRun()
}

That's all!

Starting the component daemon

Component daemon (or server) is a term used for pluggable components processes that runs alongside the Dapr runtime.

You can start your component daemon without any Dapr runtime connecting to it for testing purposes. When running in this mode, you have to make gRPC calls to see your component working.

Run your component using go run as you do normally.

Running examples

Start by running ./run.sh inside /examples folder. It will start the daprd runtime with pluggable components version + default in memory state store implementation from components-contrib, use ./run.sh state.redis to run redis instead.

Run ARGS=--no-cache ./run.sh if you want to rebuild the docker image.

See it working:

curl -X POST -H "Content-Type: application/json" -d '[{ "key": "name", "value": "Bruce Wayne", "metadata": { "ttlInSeconds": "60"}}]' http://localhost:3500/v1.0/state/default

curl http://localhost:3500/v1.0/state/default/name

Implementing a Pluggable State Store component

To create your own implementation:

Create a new folder under /examples
Implement a stateStore using the sdk
create a component.yml (copying from other sources and changing the component-specific metadata)
Run ./run.sh your_folder_goes_here

Optionally you can also add a docker-compose.dependencies.yml file and specify container dependencies that will be used when starting your app.

arturotrenard/components-go-sdk