celeriac alternatives and similar packages
Based on the "Distributed Systems" category.
Alternatively, view celeriac alternatives based on common mentions on social networks and blogs.
-
Nomad
Nomad is an easy-to-use, flexible, and performant workload orchestrator that can deploy a mix of microservice, batch, containerized, and non-containerized applications. Nomad is easy to operate and scale and has native Consul and Vault integrations. -
go-zero
DISCONTINUED. go-zero is a web and rpc framework written in Go. It's born to ensure the stability of the busy sites with resilient design. Builtin goctl greatly improves the development productivity. [Moved to: https://github.com/zeromicro/go-zero] -
rpcx
Best microservices framework in Go, like alibaba Dubbo, but with more features, Scale easily. Try it. Test it. If you feel it's better, use it! ๐๐๐ฏ๐ๆ๐๐ฎ๐๐๐จ, ๐๐จ๐ฅ๐๐ง๐ ๆ๐ซ๐ฉ๐๐ฑ! build for cloud! -
Encore
Open Source Development Platform for building robust type-safe distributed systems with declarative infrastructure -
gleam
Fast, efficient, and scalable distributed map/reduce system, DAG execution, in memory or on disk, written in pure Go, runs standalone or distributedly. -
glow
Glow is an easy-to-use distributed computation system written in Go, similar to Hadoop Map Reduce, Spark, Flink, Storm, etc. I am also working on another similar pure Go system, https://github.com/chrislusf/gleam , which is more flexible and more performant. -
Olric
Distributed, in-memory key/value store and cache. It can be used as an embedded Go library and a language-independent service. -
Dragonfly
Dragonfly is an open source P2P-based file distribution and image acceleration system. It is hosted by the Cloud Native Computing Foundation (CNCF) as an Incubating Level Project. -
go-doudou
go-doudou๏ผdoudou pronounce /dษudษu/๏ผis OpenAPI 3.0 (for REST) spec and Protobuf v3 (for grpc) based lightweight microservice framework. It supports monolith service application as well. -
resgate
A Realtime API Gateway used with NATS to build REST, real time, and RPC APIs, where all your clients are synchronized seamlessly. -
go-sundheit
A library built to provide support for defining service health for golang services. It allows you to register async health checks for your dependencies and the service itself, provides a health endpoint that exposes their status, and health metrics. -
Maestro
Take control of your data, connect with anything, and expose it anywhere through protocols such as HTTP, GraphQL, and gRPC. -
drmaa
Compute cluster (HPC) job submission library for Go (#golang) based on the open DRMAA standard.
CodeRabbit: AI Code Reviews for Developers
Do you think we are missing an alternative of celeriac or a related project?
Popular Comparisons
README
Celeriac
Golang client library for adding support for interacting and monitoring Celery workers and tasks.
It provides functionality to place tasks on the task queue, as well as monitor both task and worker events.
Dependencies
This library depends upon the following packages:
- github.com/streadway/amqp
- github.com/sirupsen/logrus
- github.com/nu7hatch/gouuid
- github.com/mailru/easyjson
Install easyjson
$ go get -u github.com/mailru/easyjson/...
Usage
Installation: go get github.com/svcavallar/celeriac.v1
This imports a new namespace called celeriac
package main
import (
"log"
"os"
"github.com/svcavallar/celeriac.v1"
)
func main() {
taskBrokerURI := "amqp://user:pass@localhost:5672/vhost"
// Connect to RabbitMQ task queue
TaskQueueMgr, err := celeriac.NewTaskQueueMgr(taskBrokerURI)
if err != nil {
log.Printf("Failed to connect to task queue: %v", err)
os.Exit(-1)
}
log.Printf("Service connected to task queue - (URL: %s)", taskBrokerURI)
// Go routine to monitor the Celery events emitted on the celeriac events channel
go func() {
for {
select {
default:
ev := <-TaskQueueMgr.Monitor.EventsChannel
if ev != nil {
if x, ok := ev.(*celeriac.WorkerEvent); ok {
log.Printf("Celery Event Channel: Worker event - %s [Hostname]: %s", x.Type, x.Hostname)
} else if x, ok := ev.(*celeriac.TaskEvent); ok {
log.Printf("Celery Event Channel: Task event - %s [ID]: %s", x.Type, x.UUID)
} else if x, ok := ev.(*celeriac.Event); ok {
log.Printf("Celery Event Channel: General event - %s [Hostname]: %s - [Data]: %v", x.Type, x.Hostname, x.Data)
} else {
log.Printf("Celery Event Channel: Unhandled event: %v", ev)
}
}
}
}
}()
}
Dispatching Tasks
By Name
This will create and dispatch a task incorporating the supplied data. The task will automatically be allocated and identified by a UUID returned in the task object. The UUID is represented in the form of "6ba7b810-9dad-11d1-80b4-00c04fd430c8".
// Dispatch a new task
taskName := "root.test.task"
taskData := map[string]interface{}{
"foo": "bar"
}
routingKey := "root.test"
task, err := TaskQueueMgr.DispatchTask(taskName, taskData, routingKey)
if err != nil {
log.Errorf("Failed to dispatch task to queue: %v", err)
}
By ID & Name
This will create and dispatch a task incorporating the supplied data, and identified by the user-supplied task identifier.
// Dispatch a new task
taskID := "my_task_id_123456789"
taskName := "root.test.task"
taskData := map[string]interface{}{
"foo": "bar"
}
routingKey := "root.test"
task, err := TaskQueueMgr.DispatchTaskWithID(taskID, taskName, taskData, routingKey)
if err != nil {
log.Errorf("Failed to dispatch task to queue: %v", err)
}
Modifying task_event.go
If you modify the properties of any the structs in task_event.go
you will need to re-generate the easyjson
version of this file. This is easily achieved by issuing the following command:
$ easyjson -all task_eventtest.go
Processing Redis Backend Result Automatically
If you are using a Redis backend for storing results you can easily process new/updated entries by subscribing to Redis keyspace events.
This will save polling for results, and is made convenient to integrate by using my golang helper package go-redis-event-sink
, available at the repo https://github.com/svcavallar/go-redis-event-sink
An example on how to use this is provided within the repository. Essentially, just provide it with the Celery task naming mask patten to watch: celery-task-meta-*