Alternatives to Apache Spark logo

Alternatives to Apache Spark

Hadoop, Splunk, Cassandra, Apache Beam, and Apache Flume are the most popular alternatives and competitors to Apache Spark.
1.4K
1.4K
+ 1
101

What is Apache Spark and what are its top alternatives?

Spark is a fast and general processing engine compatible with Hadoop data. It can run in Hadoop clusters through YARN or Spark's standalone mode, and it can process data in HDFS, HBase, Cassandra, Hive, and any Hadoop InputFormat. It is designed to perform both batch processing (similar to MapReduce) and new workloads like streaming, interactive queries, and machine learning.
Apache Spark is a tool in the Big Data Tools category of a tech stack.
Apache Spark is an open source tool with 25.6K GitHub stars and 21.4K GitHub forks. Here鈥檚 a link to Apache Spark's open source repository on GitHub

Apache Spark alternatives & related posts

Hadoop logo

Hadoop

1.5K
1.4K
53
1.5K
1.4K
+ 1
53
Open-source software for reliable, scalable, distributed computing
Hadoop logo
Hadoop
VS
Apache Spark logo
Apache Spark

related Hadoop posts

StackShare Editors
StackShare Editors
Kafka
Kafka
Kibana
Kibana
Elasticsearch
Elasticsearch
Logstash
Logstash
Hadoop
Hadoop

With interactions across each other and mobile devices, logging is important as it is information for internal cases like debugging and business cases like dynamic pricing.

With multiple Kafka clusters, data is archived into Hadoop before expiration. Data is ingested in realtime and indexed into an ELK stack. The ELK stack comprises of Elasticsearch, Logstash, and Kibana for searching and visualization.

See more
StackShare Editors
StackShare Editors
Prometheus
Prometheus
Chef
Chef
Consul
Consul
Memcached
Memcached
Hack
Hack
Swift
Swift
Hadoop
Hadoop
Terraform
Terraform
Airflow
Airflow
Apache Spark
Apache Spark
Kubernetes
Kubernetes
gRPC
gRPC
HHVM (HipHop Virtual Machine)
HHVM (HipHop Virtual Machine)
Presto
Presto
Kotlin
Kotlin
Apache Thrift
Apache Thrift

Since the beginning, Cal Henderson has been the CTO of Slack. Earlier this year, he commented on a Quora question summarizing their current stack.

Apps
  • Web: a mix of JavaScript/ES6 and React.
  • Desktop: And Electron to ship it as a desktop application.
  • Android: a mix of Java and Kotlin.
  • iOS: written in a mix of Objective C and Swift.
Backend
  • The core application and the API written in PHP/Hack that runs on HHVM.
  • The data is stored in MySQL using Vitess.
  • Caching is done using Memcached and MCRouter.
  • The search service takes help from SolrCloud, with various Java services.
  • The messaging system uses WebSockets with many services in Java and Go.
  • Load balancing is done using HAproxy with Consul for configuration.
  • Most services talk to each other over gRPC,
  • Some Thrift and JSON-over-HTTP
  • Voice and video calling service was built in Elixir.
Data warehouse
  • Built using open source tools including Presto, Spark, Airflow, Hadoop and Kafka.
Etc
See more
Splunk logo

Splunk

226
232
0
226
232
+ 1
0
Search, monitor, analyze and visualize machine data
    Be the first to leave a pro
    Splunk logo
    Splunk
    VS
    Apache Spark logo
    Apache Spark

    related Splunk posts

    Kibana
    Kibana
    Splunk
    Splunk
    Grafana
    Grafana

    I use Kibana because it ships with the ELK stack. I don't find it as powerful as Splunk however it is light years above grepping through log files. We previously used Grafana but found it to be annoying to maintain a separate tool outside of the ELK stack. We were able to get everything we needed from Kibana.

    See more
    Cassandra logo

    Cassandra

    2.7K
    2.3K
    454
    2.7K
    2.3K
    + 1
    454
    A partitioned row store. Rows are organized into tables with a required primary key.
    Cassandra logo
    Cassandra
    VS
    Apache Spark logo
    Apache Spark

    related Cassandra posts

    Thierry Schellenbach
    Thierry Schellenbach
    CEO at Stream | 17 upvotes 298.4K views
    atStreamStream
    Redis
    Redis
    Cassandra
    Cassandra
    RocksDB
    RocksDB
    #InMemoryDatabases
    #DataStores
    #Databases

    1.0 of Stream leveraged Cassandra for storing the feed. Cassandra is a common choice for building feeds. Instagram, for instance started, out with Redis but eventually switched to Cassandra to handle their rapid usage growth. Cassandra can handle write heavy workloads very efficiently.

    Cassandra is a great tool that allows you to scale write capacity simply by adding more nodes, though it is also very complex. This complexity made it hard to diagnose performance fluctuations. Even though we had years of experience with running Cassandra, it still felt like a bit of a black box. When building Stream 2.0 we decided to go for a different approach and build Keevo. Keevo is our in-house key-value store built upon RocksDB, gRPC and Raft.

    RocksDB is a highly performant embeddable database library developed and maintained by Facebook鈥檚 data engineering team. RocksDB started as a fork of Google鈥檚 LevelDB that introduced several performance improvements for SSD. Nowadays RocksDB is a project on its own and is under active development. It is written in C++ and it鈥檚 fast. Have a look at how this benchmark handles 7 million QPS. In terms of technology it鈥檚 much more simple than Cassandra.

    This translates into reduced maintenance overhead, improved performance and, most importantly, more consistent performance. It鈥檚 interesting to note that LinkedIn also uses RocksDB for their feed.

    #InMemoryDatabases #DataStores #Databases

    See more
    Laravel
    Laravel
    Zend Framework
    Zend Framework
    MySQL
    MySQL
    MongoDB
    MongoDB
    Cassandra
    Cassandra
    React
    React
    AngularJS
    AngularJS
    jQuery
    jQuery
    Docker
    Docker
    Linux
    Linux

    React AngularJS jQuery

    Laravel Zend Framework

    MySQL MongoDB Cassandra

    Docker

    Linux

    See more
    Apache Beam logo

    Apache Beam

    53
    85
    3
    53
    85
    + 1
    3
    A unified programming model
    Apache Beam logo
    Apache Beam
    VS
    Apache Spark logo
    Apache Spark
    Apache Flume logo

    Apache Flume

    23
    32
    0
    23
    32
    + 1
    0
    A service for collecting, aggregating, and moving large amounts of log data
      Be the first to leave a pro
      Apache Flume logo
      Apache Flume
      VS
      Apache Spark logo
      Apache Spark
      Apache Storm logo

      Apache Storm

      145
      152
      21
      145
      152
      + 1
      21
      Distributed and fault-tolerant realtime computation
      Apache Storm logo
      Apache Storm
      VS
      Apache Spark logo
      Apache Spark

      related Apache Storm posts

      Marc Bollinger
      Marc Bollinger
      Infra & Data Eng Manager at Thumbtack | 4 upvotes 235.2K views
      atLumosityLumosity
      Node.js
      Node.js
      Ruby
      Ruby
      Kafka
      Kafka
      Scala
      Scala
      Apache Storm
      Apache Storm
      Heron
      Heron
      Redis
      Redis
      Pulsar
      Pulsar

      Lumosity is home to the world's largest cognitive training database, a responsibility we take seriously. For most of the company's history, our analysis of user behavior and training data has been powered by an event stream--first a simple Node.js pub/sub app, then a heavyweight Ruby app with stronger durability. Both supported decent throughput and latency, but they lacked some major features supported by existing open-source alternatives: replaying existing messages (also lacking in most message queue-based solutions), scaling out many different readers for the same stream, the ability to leverage existing solutions for reading and writing, and possibly most importantly: the ability to hire someone externally who already had expertise.

      We ultimately migrated to Kafka in early- to mid-2016, citing both industry trends in companies we'd talked to with similar durability and throughput needs, the extremely strong documentation and community. We pored over Kyle Kingsbury's Jepsen post (https://aphyr.com/posts/293-jepsen-Kafka), as well as Jay Kreps' follow-up (http://blog.empathybox.com/post/62279088548/a-few-notes-on-kafka-and-jepsen), talked at length with Confluent folks and community members, and still wound up running parallel systems for quite a long time, but ultimately, we've been very, very happy. Understanding the internals and proper levers takes some commitment, but it's taken very little maintenance once configured. Since then, the Confluent Platform community has grown and grown; we've gone from doing most development using custom Scala consumers and producers to being 60/40 Kafka Streams/Connects.

      We originally looked into Storm / Heron , and we'd moved on from Redis pub/sub. Heron looks great, but we already had a programming model across services that was more akin to consuming a message consumers than required a topology of bolts, etc. Heron also had just come out while we were starting to migrate things, and the community momentum and direction of Kafka felt more substantial than the older Storm. If we were to start the process over again today, we might check out Pulsar , although the ecosystem is much younger.

      To find out more, read our 2017 engineering blog post about the migration!

      See more

      related Kafka posts

      Eric Colson
      Eric Colson
      Chief Algorithms Officer at Stitch Fix | 19 upvotes 906.7K views
      atStitch FixStitch Fix
      Kafka
      Kafka
      PostgreSQL
      PostgreSQL
      Amazon S3
      Amazon S3
      Apache Spark
      Apache Spark
      Presto
      Presto
      Python
      Python
      R Language
      R Language
      PyTorch
      PyTorch
      Docker
      Docker
      Amazon EC2 Container Service
      Amazon EC2 Container Service
      #AWS
      #Etl
      #ML
      #DataScience
      #DataStack
      #Data

      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
      John Kodumal
      CTO at LaunchDarkly | 16 upvotes 558K views
      atLaunchDarklyLaunchDarkly
      Amazon RDS
      Amazon RDS
      PostgreSQL
      PostgreSQL
      TimescaleDB
      TimescaleDB
      Patroni
      Patroni
      Consul
      Consul
      Amazon ElastiCache
      Amazon ElastiCache
      Amazon EC2
      Amazon EC2
      Redis
      Redis
      Amazon Kinesis
      Amazon Kinesis
      Kafka
      Kafka

      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鈥攖his 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
      PySpark logo

      PySpark

      51
      45
      0
      51
      45
      + 1
      0
      The Python API for Spark
        Be the first to leave a pro
        PySpark logo
        PySpark
        VS
        Apache Spark logo
        Apache Spark