Alternatives to UnQLite logo

Alternatives to UnQLite

SQLite, RocksDB, LevelDB, LiteDB, and MongoDB are the most popular alternatives and competitors to UnQLite.
6
51
+ 1
0

What is UnQLite and what are its top alternatives?

UnQLite is a lightweight, in-process database that allows storage and retrieval of data with ease. It provides a self-contained transactional database engine that requires zero configuration. Key features include ACID properties, support for multiple programming languages, high-performance, and simplicity. However, UnQLite has limitations such as lack of advanced querying capabilities and limited scalability for large datasets.

  1. SQLite: SQLite is a popular embedded database engine that is ACID-compliant and supports SQL queries. It is widely used and offers excellent performance and reliability. A major pro of SQLite is its compatibility with almost all programming languages, but a con is its lack of concurrent write support.

  2. LevelDB: LevelDB is a fast, key-value storage library developed by Google that provides ordered mapping from string keys to string values. It is optimized for performance and is efficient in storing large volumes of data. However, LevelDB lacks native SQL support and may require more set up compared to UnQLite.

  3. RocksDB: RocksDB is an embeddable persistent key-value store developed by Facebook based on LevelDB. It is optimized for fast storage and retrieval of data with low latency. Pros of RocksDB include high performance and scalability, but it may have a steeper learning curve compared to UnQLite.

  4. LMDB: Lightning Memory-Mapped Database (LMDB) is a high-performance, highly efficient key-value store library developed by Symas. LMDB offers ACID transactions and is known for its speed and low memory footprint. However, integrating LMDB may require additional effort compared to UnQLite.

  5. Berkeley DB: Oracle Berkeley DB is an embeddable database engine that provides key-value storage with ACID properties. It is a mature and reliable database solution, but may have licensing considerations and can be more complex to work with compared to UnQLite.

  6. Couchbase Lite: Couchbase Lite is a lightweight, NoSQL document database designed for mobile devices. It offers offline support, synchronization, and real-time updates. Pros of Couchbase Lite include its mobile-friendly design, but it may require more resources compared to UnQLite.

  7. BoltDB: BoltDB is an embedded key-value store written in Go that is easy to use and offers excellent performance. It is suitable for small to medium-sized datasets and is ACID-compliant. However, BoltDB may not be as feature-rich as UnQLite in terms of advanced querying capabilities.

  8. TiKV: TiKV is a distributed, transactional key-value store developed by PingCAP that is designed for cloud-native applications. It offers horizontal scalability, high availability, and strong consistency. Pros of TiKV include its distributed nature, but it may have a higher learning curve and complexity compared to UnQLite.

  9. CockroachDB: CockroachDB is a distributed SQL database that offers scalability, resilience, and consistency across multiple nodes. It is compatible with the PostgreSQL protocol and supports ACID transactions. However, setting up and managing CockroachDB may require more resources and expertise compared to UnQLite.

  10. DynamoDB: Amazon DynamoDB is a fully managed NoSQL database service that offers seamless scalability, high performance, and low latency. It is a serverless solution that can handle large workloads efficiently. Pros of DynamoDB include its managed nature, but pricing considerations and vendor lock-in are potential cons compared to self-hosted solutions like UnQLite.

Top Alternatives to UnQLite

  • SQLite
    SQLite

    SQLite is an embedded SQL database engine. Unlike most other SQL databases, SQLite does not have a separate server process. SQLite reads and writes directly to ordinary disk files. A complete SQL database with multiple tables, indices, triggers, and views, is contained in a single disk file. ...

  • RocksDB
    RocksDB

    RocksDB is an embeddable persistent key-value store for fast storage. RocksDB can also be the foundation for a client-server database but our current focus is on embedded workloads. RocksDB builds on LevelDB to be scalable to run on servers with many CPU cores, to efficiently use fast storage, to support IO-bound, in-memory and write-once workloads, and to be flexible to allow for innovation. ...

  • LevelDB
    LevelDB

    It is a fast key-value storage library written at Google that provides an ordered mapping from string keys to string values. It has been ported to a variety of Unix-based systems, macOS, Windows, and Android. ...

  • LiteDB
    LiteDB

    Embedded NoSQL database for .NET. An open source MongoDB-like database with zero configuration - mobile ready ...

  • MongoDB
    MongoDB

    MongoDB stores data in JSON-like documents that can vary in structure, offering a dynamic, flexible schema. MongoDB was also designed for high availability and scalability, with built-in replication and auto-sharding. ...

  • MySQL
    MySQL

    The MySQL software delivers a very fast, multi-threaded, multi-user, and robust SQL (Structured Query Language) database server. MySQL Server is intended for mission-critical, heavy-load production systems as well as for embedding into mass-deployed software. ...

  • PostgreSQL
    PostgreSQL

    PostgreSQL is an advanced object-relational database management system that supports an extended subset of the SQL standard, including transactions, foreign keys, subqueries, triggers, user-defined types and functions. ...

  • Redis
    Redis

    Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker. Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams. ...

UnQLite alternatives & related posts

SQLite logo

SQLite

19.2K
535
A software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine
19.2K
535
PROS OF SQLITE
  • 163
    Lightweight
  • 135
    Portable
  • 122
    Simple
  • 81
    Sql
  • 29
    Preinstalled on iOS and Android
  • 2
    Free
  • 2
    Tcl integration
  • 1
    Portable A database on my USB 'love it'
CONS OF SQLITE
  • 2
    Not for multi-process of multithreaded apps
  • 1
    Needs different binaries for each platform

related SQLite posts

Dimelo Waterson
Shared insights
on
PostgreSQLPostgreSQLMySQLMySQLSQLiteSQLite

I need to add a DBMS to my stack, but I don't know which. I'm tempted to learn SQLite since it would be useful to me with its focus on local access without concurrency. However, doing so feels like I would be defeating the purpose of trying to expand my skill set since it seems like most enterprise applications have the opposite requirements.

To be able to apply what I learn to more projects, what should I try to learn? MySQL? PostgreSQL? Something else? Is there a comfortable middle ground between high applicability and ease of use?

See more
Pran B.
Fullstack Developer at Growbox · | 6 upvotes · 287K views

Goal/Problem: A small mobile app (using Flutter ) for saving data offline ( some data offline) and rest data need to be synced with Cloud Firestore Tools: Cloud Firestore , SQLite Decision/Considering/Need suggestions: There is no state management in the app yet. There is a requirement to store some data offline and it should be available easily (when the phone is offline) and some data needs to stored in the cloud. I am considering using sqlflite for phone storage and firestore to sync and manage the online database. I am using flutter to build the app, I couldn't find a reliable way to use firestore cache for reading the data when phonphone is offline. So I came up with the above solution. Please suggest is this good?

See more
RocksDB logo

RocksDB

140
11
Embeddable persistent key-value store for fast storage, developed and maintained by Facebook Database Engineering Team
140
11
PROS OF ROCKSDB
  • 5
    Very fast
  • 3
    Made by Facebook
  • 2
    Consistent performance
  • 1
    Ability to add logic to the database layer where needed
CONS OF ROCKSDB
    Be the first to leave a con

    related RocksDB posts

    Thierry Schellenbach
    Shared insights
    on
    RedisRedisCassandraCassandraRocksDBRocksDB
    at

    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’s data engineering team. RocksDB started as a fork of Google’s 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’s fast. Have a look at how this benchmark handles 7 million QPS. In terms of technology it’s much more simple than Cassandra.

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

    #InMemoryDatabases #DataStores #Databases

    See more

    I am researching different querying solutions to handle ~1 trillion records of data (in the realm of a petabyte). The data is mostly textual. I have identified a few options: Milvus, HBase, RocksDB, and Elasticsearch. I was wondering if there is a good way to compare the performance of these options (or if anyone has already done something like this). I want to be able to compare the speed of ingesting and querying textual data from these tools. Does anyone have information on this or know where I can find some? Thanks in advance!

    See more
    LevelDB logo

    LevelDB

    103
    0
    An open-source on-disk key-value store
    103
    0
    PROS OF LEVELDB
      Be the first to leave a pro
      CONS OF LEVELDB
        Be the first to leave a con

        related LevelDB posts

        LiteDB logo

        LiteDB

        40
        24
        A .Net NoSQL Document Store in a single data file
        40
        24
        PROS OF LITEDB
        • 6
          No Sql
        • 5
          Portable
        • 4
          Easy to use
        • 3
          Document oriented storage
        • 2
          Bring up or extend a database very quickly
        • 2
          Open Source
        • 2
          Capable of storing images or documents
        CONS OF LITEDB
        • 2
          Online documentation needs improvement
        • 2
          Needs more real world examples

        related LiteDB posts

        MongoDB logo

        MongoDB

        94.1K
        4.1K
        The database for giant ideas
        94.1K
        4.1K
        PROS OF MONGODB
        • 828
          Document-oriented storage
        • 593
          No sql
        • 553
          Ease of use
        • 464
          Fast
        • 410
          High performance
        • 255
          Free
        • 218
          Open source
        • 180
          Flexible
        • 145
          Replication & high availability
        • 112
          Easy to maintain
        • 42
          Querying
        • 39
          Easy scalability
        • 38
          Auto-sharding
        • 37
          High availability
        • 31
          Map/reduce
        • 27
          Document database
        • 25
          Easy setup
        • 25
          Full index support
        • 16
          Reliable
        • 15
          Fast in-place updates
        • 14
          Agile programming, flexible, fast
        • 12
          No database migrations
        • 8
          Easy integration with Node.Js
        • 8
          Enterprise
        • 6
          Enterprise Support
        • 5
          Great NoSQL DB
        • 4
          Support for many languages through different drivers
        • 3
          Schemaless
        • 3
          Aggregation Framework
        • 3
          Drivers support is good
        • 2
          Fast
        • 2
          Managed service
        • 2
          Easy to Scale
        • 2
          Awesome
        • 2
          Consistent
        • 1
          Good GUI
        • 1
          Acid Compliant
        CONS OF MONGODB
        • 6
          Very slowly for connected models that require joins
        • 3
          Not acid compliant
        • 2
          Proprietary query language

        related MongoDB posts

        Jeyabalaji Subramanian

        Recently we were looking at a few robust and cost-effective ways of replicating the data that resides in our production MongoDB to a PostgreSQL database for data warehousing and business intelligence.

        We set ourselves the following criteria for the optimal tool that would do this job: - The data replication must be near real-time, yet it should NOT impact the production database - The data replication must be horizontally scalable (based on the load), asynchronous & crash-resilient

        Based on the above criteria, we selected the following tools to perform the end to end data replication:

        We chose MongoDB Stitch for picking up the changes in the source database. It is the serverless platform from MongoDB. One of the services offered by MongoDB Stitch is Stitch Triggers. Using stitch triggers, you can execute a serverless function (in Node.js) in real time in response to changes in the database. When there are a lot of database changes, Stitch automatically "feeds forward" these changes through an asynchronous queue.

        We chose Amazon SQS as the pipe / message backbone for communicating the changes from MongoDB to our own replication service. Interestingly enough, MongoDB stitch offers integration with AWS services.

        In the Node.js function, we wrote minimal functionality to communicate the database changes (insert / update / delete / replace) to Amazon SQS.

        Next we wrote a minimal micro-service in Python to listen to the message events on SQS, pickup the data payload & mirror the DB changes on to the target Data warehouse. We implemented source data to target data translation by modelling target table structures through SQLAlchemy . We deployed this micro-service as AWS Lambda with Zappa. With Zappa, deploying your services as event-driven & horizontally scalable Lambda service is dumb-easy.

        In the end, we got to implement a highly scalable near realtime Change Data Replication service that "works" and deployed to production in a matter of few days!

        See more
        Robert Zuber

        We use MongoDB as our primary #datastore. Mongo's approach to replica sets enables some fantastic patterns for operations like maintenance, backups, and #ETL.

        As we pull #microservices from our #monolith, we are taking the opportunity to build them with their own datastores using PostgreSQL. We also use Redis to cache data we’d never store permanently, and to rate-limit our requests to partners’ APIs (like GitHub).

        When we’re dealing with large blobs of immutable data (logs, artifacts, and test results), we store them in Amazon S3. We handle any side-effects of S3’s eventual consistency model within our own code. This ensures that we deal with user requests correctly while writes are in process.

        See more
        MySQL logo

        MySQL

        126.2K
        3.8K
        The world's most popular open source database
        126.2K
        3.8K
        PROS OF MYSQL
        • 800
          Sql
        • 679
          Free
        • 562
          Easy
        • 528
          Widely used
        • 490
          Open source
        • 180
          High availability
        • 160
          Cross-platform support
        • 104
          Great community
        • 79
          Secure
        • 75
          Full-text indexing and searching
        • 26
          Fast, open, available
        • 16
          Reliable
        • 16
          SSL support
        • 15
          Robust
        • 9
          Enterprise Version
        • 7
          Easy to set up on all platforms
        • 3
          NoSQL access to JSON data type
        • 1
          Relational database
        • 1
          Easy, light, scalable
        • 1
          Sequel Pro (best SQL GUI)
        • 1
          Replica Support
        CONS OF MYSQL
        • 16
          Owned by a company with their own agenda
        • 3
          Can't roll back schema changes

        related MySQL posts

        Nick Rockwell
        SVP, Engineering at Fastly · | 46 upvotes · 4.3M views

        When I joined NYT there was already broad dissatisfaction with the LAMP (Linux Apache HTTP Server MySQL PHP) Stack and the front end framework, in particular. So, I wasn't passing judgment on it. I mean, LAMP's fine, you can do good work in LAMP. It's a little dated at this point, but it's not ... I didn't want to rip it out for its own sake, but everyone else was like, "We don't like this, it's really inflexible." And I remember from being outside the company when that was called MIT FIVE when it had launched. And been observing it from the outside, and I was like, you guys took so long to do that and you did it so carefully, and yet you're not happy with your decisions. Why is that? That was more the impetus. If we're going to do this again, how are we going to do it in a way that we're gonna get a better result?

        So we're moving quickly away from LAMP, I would say. So, right now, the new front end is React based and using Apollo. And we've been in a long, protracted, gradual rollout of the core experiences.

        React is now talking to GraphQL as a primary API. There's a Node.js back end, to the front end, which is mainly for server-side rendering, as well.

        Behind there, the main repository for the GraphQL server is a big table repository, that we call Bodega because it's a convenience store. And that reads off of a Kafka pipeline.

        See more
        Tim Abbott

        We've been using PostgreSQL since the very early days of Zulip, but we actually didn't use it from the beginning. Zulip started out as a MySQL project back in 2012, because we'd heard it was a good choice for a startup with a wide community. However, we found that even though we were using the Django ORM for most of our database access, we spent a lot of time fighting with MySQL. Issues ranged from bad collation defaults, to bad query plans which required a lot of manual query tweaks.

        We ended up getting so frustrated that we tried out PostgresQL, and the results were fantastic. We didn't have to do any real customization (just some tuning settings for how big a server we had), and all of our most important queries were faster out of the box. As a result, we were able to delete a bunch of custom queries escaping the ORM that we'd written to make the MySQL query planner happy (because postgres just did the right thing automatically).

        And then after that, we've just gotten a ton of value out of postgres. We use its excellent built-in full-text search, which has helped us avoid needing to bring in a tool like Elasticsearch, and we've really enjoyed features like its partial indexes, which saved us a lot of work adding unnecessary extra tables to get good performance for things like our "unread messages" and "starred messages" indexes.

        I can't recommend it highly enough.

        See more
        PostgreSQL logo

        PostgreSQL

        98.9K
        3.5K
        A powerful, open source object-relational database system
        98.9K
        3.5K
        PROS OF POSTGRESQL
        • 764
          Relational database
        • 510
          High availability
        • 439
          Enterprise class database
        • 383
          Sql
        • 304
          Sql + nosql
        • 173
          Great community
        • 147
          Easy to setup
        • 131
          Heroku
        • 130
          Secure by default
        • 113
          Postgis
        • 50
          Supports Key-Value
        • 48
          Great JSON support
        • 34
          Cross platform
        • 33
          Extensible
        • 28
          Replication
        • 26
          Triggers
        • 23
          Multiversion concurrency control
        • 23
          Rollback
        • 21
          Open source
        • 18
          Heroku Add-on
        • 17
          Stable, Simple and Good Performance
        • 15
          Powerful
        • 13
          Lets be serious, what other SQL DB would you go for?
        • 11
          Good documentation
        • 9
          Scalable
        • 8
          Free
        • 8
          Reliable
        • 8
          Intelligent optimizer
        • 7
          Transactional DDL
        • 7
          Modern
        • 6
          One stop solution for all things sql no matter the os
        • 5
          Relational database with MVCC
        • 5
          Faster Development
        • 4
          Full-Text Search
        • 4
          Developer friendly
        • 3
          Excellent source code
        • 3
          Free version
        • 3
          Great DB for Transactional system or Application
        • 3
          Relational datanbase
        • 3
          search
        • 3
          Open-source
        • 2
          Text
        • 2
          Full-text
        • 1
          Can handle up to petabytes worth of size
        • 1
          Composability
        • 1
          Multiple procedural languages supported
        • 0
          Native
        CONS OF POSTGRESQL
        • 10
          Table/index bloatings

        related PostgreSQL posts

        Simon Reymann
        Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 11.9M 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
        Jeyabalaji Subramanian

        Recently we were looking at a few robust and cost-effective ways of replicating the data that resides in our production MongoDB to a PostgreSQL database for data warehousing and business intelligence.

        We set ourselves the following criteria for the optimal tool that would do this job: - The data replication must be near real-time, yet it should NOT impact the production database - The data replication must be horizontally scalable (based on the load), asynchronous & crash-resilient

        Based on the above criteria, we selected the following tools to perform the end to end data replication:

        We chose MongoDB Stitch for picking up the changes in the source database. It is the serverless platform from MongoDB. One of the services offered by MongoDB Stitch is Stitch Triggers. Using stitch triggers, you can execute a serverless function (in Node.js) in real time in response to changes in the database. When there are a lot of database changes, Stitch automatically "feeds forward" these changes through an asynchronous queue.

        We chose Amazon SQS as the pipe / message backbone for communicating the changes from MongoDB to our own replication service. Interestingly enough, MongoDB stitch offers integration with AWS services.

        In the Node.js function, we wrote minimal functionality to communicate the database changes (insert / update / delete / replace) to Amazon SQS.

        Next we wrote a minimal micro-service in Python to listen to the message events on SQS, pickup the data payload & mirror the DB changes on to the target Data warehouse. We implemented source data to target data translation by modelling target table structures through SQLAlchemy . We deployed this micro-service as AWS Lambda with Zappa. With Zappa, deploying your services as event-driven & horizontally scalable Lambda service is dumb-easy.

        In the end, we got to implement a highly scalable near realtime Change Data Replication service that "works" and deployed to production in a matter of few days!

        See more
        Redis logo

        Redis

        59.8K
        3.9K
        Open source (BSD licensed), in-memory data structure store
        59.8K
        3.9K
        PROS OF REDIS
        • 887
          Performance
        • 542
          Super fast
        • 514
          Ease of use
        • 444
          In-memory cache
        • 324
          Advanced key-value cache
        • 194
          Open source
        • 182
          Easy to deploy
        • 165
          Stable
        • 156
          Free
        • 121
          Fast
        • 42
          High-Performance
        • 40
          High Availability
        • 35
          Data Structures
        • 32
          Very Scalable
        • 24
          Replication
        • 23
          Pub/Sub
        • 22
          Great community
        • 19
          "NoSQL" key-value data store
        • 16
          Hashes
        • 13
          Sets
        • 11
          Sorted Sets
        • 10
          Lists
        • 10
          NoSQL
        • 9
          Async replication
        • 9
          BSD licensed
        • 8
          Integrates super easy with Sidekiq for Rails background
        • 8
          Bitmaps
        • 7
          Open Source
        • 7
          Keys with a limited time-to-live
        • 6
          Lua scripting
        • 6
          Strings
        • 5
          Awesomeness for Free
        • 5
          Hyperloglogs
        • 4
          Runs server side LUA
        • 4
          Transactions
        • 4
          Networked
        • 4
          Outstanding performance
        • 4
          Feature Rich
        • 4
          Written in ANSI C
        • 4
          LRU eviction of keys
        • 3
          Data structure server
        • 3
          Performance & ease of use
        • 2
          Temporarily kept on disk
        • 2
          Dont save data if no subscribers are found
        • 2
          Automatic failover
        • 2
          Easy to use
        • 2
          Scalable
        • 2
          Channels concept
        • 2
          Object [key/value] size each 500 MB
        • 2
          Existing Laravel Integration
        • 2
          Simple
        CONS OF REDIS
        • 15
          Cannot query objects directly
        • 3
          No secondary indexes for non-numeric data types
        • 1
          No WAL

        related Redis posts

        Russel Werner
        Lead Engineer at StackShare · | 32 upvotes · 2.9M views

        StackShare Feed is built entirely with React, Glamorous, and Apollo. One of our objectives with the public launch of the Feed was to enable a Server-side rendered (SSR) experience for our organic search traffic. When you visit the StackShare Feed, and you aren't logged in, you are delivered the Trending feed experience. We use an in-house Node.js rendering microservice to generate this HTML. This microservice needs to run and serve requests independent of our Rails web app. Up until recently, we had a mono-repo with our Rails and React code living happily together and all served from the same web process. In order to deploy our SSR app into a Heroku environment, we needed to split out our front-end application into a separate repo in GitHub. The driving factor in this decision was mostly due to limitations imposed by Heroku specifically with how processes can't communicate with each other. A new SSR app was created in Heroku and linked directly to the frontend repo so it stays in-sync with changes.

        Related to this, we need a way to "deploy" our frontend changes to various server environments without building & releasing the entire Ruby application. We built a hybrid Amazon S3 Amazon CloudFront solution to host our Webpack bundles. A new CircleCI script builds the bundles and uploads them to S3. The final step in our rollout is to update some keys in Redis so our Rails app knows which bundles to serve. The result of these efforts were significant. Our frontend team now moves independently of our backend team, our build & release process takes only a few minutes, we are now using an edge CDN to serve JS assets, and we have pre-rendered React pages!

        #StackDecisionsLaunch #SSR #Microservices #FrontEndRepoSplit

        See more
        Simon Reymann
        Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 11.9M 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