Alternatives to Dapr logo

Alternatives to Dapr

Istio, Akka, Orleans, Knative, and Envoy are the most popular alternatives and competitors to Dapr.
66
248
+ 1
8

What is Dapr and what are its top alternatives?

It is a portable, event-driven runtime that makes it easy for developers to build resilient, stateless and stateful microservices that run on the cloud and edge and embraces the diversity of languages and developer frameworks.
Dapr is a tool in the Microservices Tools category of a tech stack.
Dapr is an open source tool with 17.9K GitHub stars and 1.4K GitHub forks. Here’s a link to Dapr's open source repository on GitHub

Top Alternatives to Dapr

  • Istio
    Istio

    Istio is an open platform for providing a uniform way to integrate microservices, manage traffic flow across microservices, enforce policies and aggregate telemetry data. Istio's control plane provides an abstraction layer over the underlying cluster management platform, such as Kubernetes, Mesos, etc. ...

  • Akka
    Akka

    Akka is a toolkit and runtime for building highly concurrent, distributed, and resilient message-driven applications on the JVM. ...

  • Orleans
    Orleans

    Orleans is a framework that provides a straightforward approach to building distributed high-scale computing applications, without the need to learn and apply complex concurrency or other scaling patterns. It was created by Microsoft Research and designed for use in the cloud. ...

  • Knative
    Knative

    Knative provides a set of middleware components that are essential to build modern, source-centric, and container-based applications that can run anywhere: on premises, in the cloud, or even in a third-party data center ...

  • Envoy
    Envoy

    Originally built at Lyft, Envoy is a high performance C++ distributed proxy designed for single services and applications, as well as a communication bus and “universal data plane” designed for large microservice “service mesh” architectures. ...

  • Kubernetes
    Kubernetes

    Kubernetes is an open source orchestration system for Docker containers. It handles scheduling onto nodes in a compute cluster and actively manages workloads to ensure that their state matches the users declared intentions. ...

  • Docker
    Docker

    The Docker Platform is the industry-leading container platform for continuous, high-velocity innovation, enabling organizations to seamlessly build and share any application — from legacy to what comes next — and securely run them anywhere ...

  • Kafka
    Kafka

    Kafka is a distributed, partitioned, replicated commit log service. It provides the functionality of a messaging system, but with a unique design. ...

Dapr alternatives & related posts

Istio logo

Istio

697
1.2K
44
Open platform to connect, manage, and secure microservices, by Google, IBM, and Lyft
697
1.2K
+ 1
44
PROS OF ISTIO
  • 13
    Zero code for logging and monitoring
  • 8
    Service Mesh
  • 7
    Great flexibility
  • 4
    Ingress controller
  • 3
    Resiliency
  • 3
    Easy integration with Kubernetes and Docker
  • 3
    Full Security
  • 3
    Powerful authorization mechanisms
CONS OF ISTIO
  • 13
    Performance

related Istio posts

Anas MOKDAD
Shared insights
on
KongKongIstioIstio

As for the new support of service mesh pattern by Kong, I wonder how does it compare to Istio?

See more
Akka logo

Akka

893
885
86
Build powerful concurrent & distributed applications more easily
893
885
+ 1
86
PROS OF AKKA
  • 32
    Great concurrency model
  • 16
    Fast
  • 11
    Actor Library
  • 10
    Open source
  • 7
    Resilient
  • 5
    Scalable
  • 5
    Message driven
CONS OF AKKA
  • 3
    Mixing futures with Akka tell is difficult
  • 2
    Closing of futures
  • 2
    No type safety
  • 1
    Very difficult to refactor
  • 1
    Typed actors still not stable

related Akka posts

To solve the problem of scheduling and executing arbitrary tasks in its distributed infrastructure, PagerDuty created an open-source tool called Scheduler. Scheduler is written in Scala and uses Cassandra for task persistence. It also adds Apache Kafka to handle task queuing and partitioning, with Akka to structure the library’s concurrency.

The service’s logic schedules a task by passing it to the Scheduler’s Scala API, which serializes the task metadata and enqueues it into Kafka. Scheduler then consumes the tasks, and posts them to Cassandra to prevent data loss.

See more
Shared insights
on
AkkaAkkaKafkaKafka

I decided to use Akka instead of Kafka streams because I have personal relationships at @Lightbend.

See more
Orleans logo

Orleans

44
100
26
An approach to building distributed applications in .NET
44
100
+ 1
26
PROS OF ORLEANS
  • 4
    Akka.net alternative
  • 3
    Open source
  • 3
    Distributed high-scale computing applications
  • 2
    Virtual Actor Model
  • 2
    Async/Await
  • 2
    Cross Platform
  • 2
    Scalable
  • 2
    Distributed Locking
  • 2
    Objects
  • 2
    Distributed ACID Transactions
  • 2
    Fast
CONS OF ORLEANS
    Be the first to leave a con

    related Orleans posts

    Knative logo

    Knative

    73
    273
    16
    Kubernetes-based platform for serverless workloads
    73
    273
    + 1
    16
    PROS OF KNATIVE
    • 4
      Portability
    • 3
      On top of Kubernetes
    • 3
      Autoscaling
    • 2
      Secure Eventing
    • 2
      Eventing
    • 2
      Open source
    CONS OF KNATIVE
      Be the first to leave a con

      related Knative posts

      Envoy logo

      Envoy

      256
      464
      8
      C++ front/service proxy
      256
      464
      + 1
      8
      PROS OF ENVOY
      • 8
        GRPC-Web
      CONS OF ENVOY
        Be the first to leave a con

        related Envoy posts

        Joseph Irving
        DevOps Engineer at uSwitch · | 7 upvotes · 161.9K views
        Shared insights
        on
        KubernetesKubernetesEnvoyEnvoyGolangGolang
        at

        At uSwitch we wanted a way to load balance between our multiple Kubernetes clusters in AWS to give us added redundancy. We already had ingresses defined for all our applications so we wanted to build on top of that, instead of creating a new system that would require our various teams to change code/config etc.

        Envoy seemed to tick a lot of boxes:

        • Loadbalancing capabilities right out of the box: health checks, circuit breaking, retries etc.
        • Tracing and prometheus metrics support
        • Lightweight
        • Good community support

        This was all good but what really sold us was the api that supported dynamic configuration. This would allow us to dynamically configure envoy to route to ingresses and clusters as they were created or destroyed.

        To do this we built a tool called Yggdrasil using their Go sdk. Yggdrasil effectively just creates envoy configuration from Kubernetes ingress objects, so you point Yggdrasil at your kube clusters, it generates config from the ingresses and then envoy can loadbalance between your clusters for you. This is all done dynamically so as soon as new ingress is created the envoy nodes get updated with the new config. Importantly this all worked with what we already had, no need to create new config for every application, we just put this on top of it.

        See more
        Shared insights
        on
        EnvoyEnvoyHAProxyHAProxyTraefikTraefikNGINXNGINX

        We are looking to configure a load balancer with some admin UI. We are currently struggling to decide between NGINX, Traefik, HAProxy, and Envoy. We will use a load balancer in a containerized environment and the load balancer should flexible and easy to reload without changes in case containers are scaled up.

        See more
        Kubernetes logo

        Kubernetes

        44.5K
        38.3K
        634
        Manage a cluster of Linux containers as a single system to accelerate Dev and simplify Ops
        44.5K
        38.3K
        + 1
        634
        PROS OF KUBERNETES
        • 161
          Leading docker container management solution
        • 126
          Simple and powerful
        • 102
          Open source
        • 75
          Backed by google
        • 56
          The right abstractions
        • 24
          Scale services
        • 19
          Replication controller
        • 9
          Permission managment
        • 7
          Simple
        • 7
          Supports autoscaling
        • 6
          Cheap
        • 4
          Self-healing
        • 4
          No cloud platform lock-in
        • 4
          Reliable
        • 3
          Open, powerful, stable
        • 3
          Scalable
        • 3
          Quick cloud setup
        • 3
          Promotes modern/good infrascture practice
        • 2
          Backed by Red Hat
        • 2
          Cloud Agnostic
        • 2
          Runs on azure
        • 2
          Custom and extensibility
        • 2
          Captain of Container Ship
        • 2
          A self healing environment with rich metadata
        • 1
          Golang
        • 1
          Easy setup
        • 1
          Everything of CaaS
        • 1
          Sfg
        • 1
          Expandable
        • 1
          Gke
        CONS OF KUBERNETES
        • 15
          Poor workflow for development
        • 13
          Steep learning curve
        • 7
          Orchestrates only infrastructure
        • 4
          High resource requirements for on-prem clusters
        • 1
          Additional vendor lock-in (Docker)
        • 1
          Additional Technology Overhead
        • 1
          More moving parts to secure
        • 1
          Too heavy for simple systems

        related Kubernetes posts

        Conor Myhrvold
        Tech Brand Mgr, Office of CTO at Uber · | 40 upvotes · 4.9M views

        How Uber developed the open source, end-to-end distributed tracing Jaeger , now a CNCF project:

        Distributed tracing is quickly becoming a must-have component in the tools that organizations use to monitor their complex, microservice-based architectures. At Uber, our open source distributed tracing system Jaeger saw large-scale internal adoption throughout 2016, integrated into hundreds of microservices and now recording thousands of traces every second.

        Here is the story of how we got here, from investigating off-the-shelf solutions like Zipkin, to why we switched from pull to push architecture, and how distributed tracing will continue to evolve:

        https://eng.uber.com/distributed-tracing/

        (GitHub Pages : https://www.jaegertracing.io/, GitHub: https://github.com/jaegertracing/jaeger)

        Bindings/Operator: Python Java Node.js Go C++ Kubernetes JavaScript OpenShift C# Apache Spark

        See more
        Yshay Yaacobi

        Our first experience with .NET core was when we developed our OSS feature management platform - Tweek (https://github.com/soluto/tweek). We wanted to create a solution that is able to run anywhere (super important for OSS), has excellent performance characteristics and can fit in a multi-container architecture. We decided to implement our rule engine processor in F# , our main service was implemented in C# and other components were built using JavaScript / TypeScript and Go.

        Visual Studio Code worked really well for us as well, it worked well with all our polyglot services and the .Net core integration had great cross-platform developer experience (to be fair, F# was a bit trickier) - actually, each of our team members used a different OS (Ubuntu, macos, windows). Our production deployment ran for a time on Docker Swarm until we've decided to adopt Kubernetes with almost seamless migration process.

        After our positive experience of running .Net core workloads in containers and developing Tweek's .Net services on non-windows machines, C# had gained back some of its popularity (originally lost to Node.js), and other teams have been using it for developing microservices, k8s sidecars (like https://github.com/Soluto/airbag), cli tools, serverless functions and other projects...

        See more
        Docker logo

        Docker

        131.6K
        104.8K
        3.8K
        Enterprise Container Platform for High-Velocity Innovation.
        131.6K
        104.8K
        + 1
        3.8K
        PROS OF DOCKER
        • 823
          Rapid integration and build up
        • 688
          Isolation
        • 518
          Open source
        • 505
          Testa­bil­i­ty and re­pro­ducibil­i­ty
        • 459
          Lightweight
        • 217
          Standardization
        • 184
          Scalable
        • 105
          Upgrading / down­grad­ing / ap­pli­ca­tion versions
        • 87
          Security
        • 84
          Private paas environments
        • 33
          Portability
        • 25
          Limit resource usage
        • 16
          Game changer
        • 15
          I love the way docker has changed virtualization
        • 13
          Fast
        • 11
          Concurrency
        • 7
          Docker's Compose tools
        • 5
          Easy setup
        • 5
          Fast and Portable
        • 4
          Because its fun
        • 3
          Makes shipping to production very simple
        • 2
          It's dope
        • 2
          Highly useful
        • 1
          Very easy to setup integrate and build
        • 1
          Package the environment with the application
        • 1
          Does a nice job hogging memory
        • 1
          Open source and highly configurable
        • 1
          Simplicity, isolation, resource effective
        • 1
          MacOS support FAKE
        • 1
          Its cool
        • 1
          Docker hub for the FTW
        • 1
          HIgh Throughput
        CONS OF DOCKER
        • 8
          New versions == broken features
        • 6
          Unreliable networking
        • 6
          Documentation not always in sync
        • 4
          Moves quickly
        • 3
          Not Secure

        related Docker posts

        Simon Reymann
        Senior Fullstack Developer at QUANTUSflow Software GmbH · | 29 upvotes · 4.2M views

        Our whole DevOps stack consists of the following tools:

        • GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
        • Respectively Git as revision control system
        • SourceTree as Git GUI
        • Visual Studio Code as IDE
        • CircleCI for continuous integration (automatize development process)
        • Prettier / TSLint / ESLint as code linter
        • SonarQube as quality gate
        • Docker as container management (incl. Docker Compose for multi-container application management)
        • VirtualBox for operating system simulation tests
        • Kubernetes as cluster management for docker containers
        • Heroku for deploying in test environments
        • nginx as web server (preferably used as facade server in production environment)
        • SSLMate (using OpenSSL) for certificate management
        • Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
        • PostgreSQL as preferred database system
        • Redis as preferred in-memory database/store (great for caching)

        The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:

        • Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
        • Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
        • Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
        • Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
        • Scalability: All-in-one framework for distributed systems.
        • Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.
        See more
        Tymoteusz Paul
        Devops guy at X20X Development LTD · | 23 upvotes · 5.1M views

        Often enough I have to explain my way of going about setting up a CI/CD pipeline with multiple deployment platforms. Since I am a bit tired of yapping the same every single time, I've decided to write it up and share with the world this way, and send people to read it instead ;). I will explain it on "live-example" of how the Rome got built, basing that current methodology exists only of readme.md and wishes of good luck (as it usually is ;)).

        It always starts with an app, whatever it may be and reading the readmes available while Vagrant and VirtualBox is installing and updating. Following that is the first hurdle to go over - convert all the instruction/scripts into Ansible playbook(s), and only stopping when doing a clear vagrant up or vagrant reload we will have a fully working environment. As our Vagrant environment is now functional, it's time to break it! This is the moment to look for how things can be done better (too rigid/too lose versioning? Sloppy environment setup?) and replace them with the right way to do stuff, one that won't bite us in the backside. This is the point, and the best opportunity, to upcycle the existing way of doing dev environment to produce a proper, production-grade product.

        I should probably digress here for a moment and explain why. I firmly believe that the way you deploy production is the same way you should deploy develop, shy of few debugging-friendly setting. This way you avoid the discrepancy between how production work vs how development works, which almost always causes major pains in the back of the neck, and with use of proper tools should mean no more work for the developers. That's why we start with Vagrant as developer boxes should be as easy as vagrant up, but the meat of our product lies in Ansible which will do meat of the work and can be applied to almost anything: AWS, bare metal, docker, LXC, in open net, behind vpn - you name it.

        We must also give proper consideration to monitoring and logging hoovering at this point. My generic answer here is to grab Elasticsearch, Kibana, and Logstash. While for different use cases there may be better solutions, this one is well battle-tested, performs reasonably and is very easy to scale both vertically (within some limits) and horizontally. Logstash rules are easy to write and are well supported in maintenance through Ansible, which as I've mentioned earlier, are at the very core of things, and creating triggers/reports and alerts based on Elastic and Kibana is generally a breeze, including some quite complex aggregations.

        If we are happy with the state of the Ansible it's time to move on and put all those roles and playbooks to work. Namely, we need something to manage our CI/CD pipelines. For me, the choice is obvious: TeamCity. It's modern, robust and unlike most of the light-weight alternatives, it's transparent. What I mean by that is that it doesn't tell you how to do things, doesn't limit your ways to deploy, or test, or package for that matter. Instead, it provides a developer-friendly and rich playground for your pipelines. You can do most the same with Jenkins, but it has a quite dated look and feel to it, while also missing some key functionality that must be brought in via plugins (like quality REST API which comes built-in with TeamCity). It also comes with all the common-handy plugins like Slack or Apache Maven integration.

        The exact flow between CI and CD varies too greatly from one application to another to describe, so I will outline a few rules that guide me in it: 1. Make build steps as small as possible. This way when something breaks, we know exactly where, without needing to dig and root around. 2. All security credentials besides development environment must be sources from individual Vault instances. Keys to those containers should exist only on the CI/CD box and accessible by a few people (the less the better). This is pretty self-explanatory, as anything besides dev may contain sensitive data and, at times, be public-facing. Because of that appropriate security must be present. TeamCity shines in this department with excellent secrets-management. 3. Every part of the build chain shall consume and produce artifacts. If it creates nothing, it likely shouldn't be its own build. This way if any issue shows up with any environment or version, all developer has to do it is grab appropriate artifacts to reproduce the issue locally. 4. Deployment builds should be directly tied to specific Git branches/tags. This enables much easier tracking of what caused an issue, including automated identifying and tagging the author (nothing like automated regression testing!).

        Speaking of deployments, I generally try to keep it simple but also with a close eye on the wallet. Because of that, I am more than happy with AWS or another cloud provider, but also constantly peeking at the loads and do we get the value of what we are paying for. Often enough the pattern of use is not constantly erratic, but rather has a firm baseline which could be migrated away from the cloud and into bare metal boxes. That is another part where this approach strongly triumphs over the common Docker and CircleCI setup, where you are very much tied in to use cloud providers and getting out is expensive. Here to embrace bare-metal hosting all you need is a help of some container-based self-hosting software, my personal preference is with Proxmox and LXC. Following that all you must write are ansible scripts to manage hardware of Proxmox, similar way as you do for Amazon EC2 (ansible supports both greatly) and you are good to go. One does not exclude another, quite the opposite, as they can live in great synergy and cut your costs dramatically (the heavier your base load, the bigger the savings) while providing production-grade resiliency.

        See more
        Kafka logo

        Kafka

        17.8K
        16.9K
        587
        Distributed, fault tolerant, high throughput pub-sub messaging system
        17.8K
        16.9K
        + 1
        587
        PROS OF KAFKA
        • 125
          High-throughput
        • 118
          Distributed
        • 88
          Scalable
        • 82
          High-Performance
        • 65
          Durable
        • 37
          Publish-Subscribe
        • 19
          Simple-to-use
        • 16
          Open source
        • 11
          Written in Scala and java. Runs on JVM
        • 7
          Message broker + Streaming system
        • 4
          Avro schema integration
        • 4
          KSQL
        • 3
          Robust
        • 2
          Suport Multiple clients
        • 2
          Partioned, replayable log
        • 1
          Flexible
        • 1
          Extremely good parallelism constructs
        • 1
          Simple publisher / multi-subscriber model
        • 1
          Fun
        CONS OF KAFKA
        • 29
          Non-Java clients are second-class citizens
        • 27
          Needs Zookeeper
        • 7
          Operational difficulties
        • 2
          Terrible Packaging

        related Kafka posts

        Eric Colson
        Chief Algorithms Officer at Stitch Fix · | 21 upvotes · 2.3M views

        The algorithms and data infrastructure at Stitch Fix is housed in #AWS. Data acquisition is split between events flowing through Kafka, and periodic snapshots of PostgreSQL DBs. We store data in an Amazon S3 based data warehouse. Apache Spark on Yarn is our tool of choice for data movement and #ETL. Because our storage layer (s3) is decoupled from our processing layer, we are able to scale our compute environment very elastically. We have several semi-permanent, autoscaling Yarn clusters running to serve our data processing needs. While the bulk of our compute infrastructure is dedicated to algorithmic processing, we also implemented Presto for adhoc queries and dashboards.

        Beyond data movement and ETL, most #ML centric jobs (e.g. model training and execution) run in a similarly elastic environment as containers running Python and R code on Amazon EC2 Container Service clusters. The execution of batch jobs on top of ECS is managed by Flotilla, a service we built in house and open sourced (see https://github.com/stitchfix/flotilla-os).

        At Stitch Fix, algorithmic integrations are pervasive across the business. We have dozens of data products actively integrated systems. That requires serving layer that is robust, agile, flexible, and allows for self-service. Models produced on Flotilla are packaged for deployment in production using Khan, another framework we've developed internally. Khan provides our data scientists the ability to quickly productionize those models they've developed with open source frameworks in Python 3 (e.g. PyTorch, sklearn), by automatically packaging them as Docker containers and deploying to Amazon ECS. This provides our data scientist a one-click method of getting from their algorithms to production. We then integrate those deployments into a service mesh, which allows us to A/B test various implementations in our product.

        For more info:

        #DataScience #DataStack #Data

        See more
        John Kodumal

        As we've evolved or added additional infrastructure to our stack, we've biased towards managed services. Most new backing stores are Amazon RDS instances now. We do use self-managed PostgreSQL with TimescaleDB for time-series data—this is made HA with the use of Patroni and Consul.

        We also use managed Amazon ElastiCache instances instead of spinning up Amazon EC2 instances to run Redis workloads, as well as shifting to Amazon Kinesis instead of Kafka.

        See more