Alternatives to Amazon DocumentDB logo

Alternatives to Amazon DocumentDB

MongoDB, MongoDB Atlas, Elasticsearch, Atlas, and Amazon DynamoDB are the most popular alternatives and competitors to Amazon DocumentDB.
75
62
+ 1
0

What is Amazon DocumentDB and what are its top alternatives?

Amazon DocumentDB is a fully managed database service that is compatible with MongoDB workloads. It offers scalability, durability, and security features while providing high performance. However, DocumentDB has limitations such as lack of support for certain MongoDB features like full text search and triggers.

  1. MongoDB: MongoDB is a popular open-source NoSQL database that offers high performance, scalability, and flexibility. It supports a wide range of features including sharding, indexing, and geo-spatial queries. Pros: rich feature set, active community support. Cons: self-managed, limited querying capabilities.
  2. Google Cloud Firestore: Google Cloud Firestore is a flexible, scalable NoSQL database that automatically handles sharding and replication. It offers real-time data synchronization, offline support, and serverless integration. Pros: serverless, real-time updates. Cons: limited querying capabilities.
  3. Microsoft Azure Cosmos DB: Azure Cosmos DB is a globally distributed, multi-model database service that supports multiple APIs including MongoDB, SQL, and Gremlin. It offers automatic scaling, multiple consistency levels, and low latency. Pros: multi-model support, global distribution. Cons: high cost.
  4. Couchbase: Couchbase is an open-source, distributed NoSQL database that offers high-performance querying, indexing, and data access. It supports flexible data models, clustering, and security features. Pros: JSON support, high performance. Cons: limited scalability options.
  5. Redis: Redis is an open-source, in-memory data structure store that can be used as a database, cache, and message broker. It offers fast data access, high availability, and support for various data structures. Pros: in-memory storage, high performance. Cons: limited data persistence.
  6. RethinkDB: RethinkDB is an open-source, distributed database designed for real-time applications. It offers automatic sharding, real-time data feeds, and flexible data modeling. Pros: real-time updates, flexible schema. Cons: limited scalability options.
  7. Firebase Realtime Database: Firebase Realtime Database is a NoSQL cloud database that provides real-time data synchronization and offline capabilities for mobile and web applications. It supports data syncing across devices and platforms. Pros: real-time updates, offline support. Cons: limited querying capabilities.
  8. DynamoDB: Amazon DynamoDB is a fully managed NoSQL database service provided by AWS. It offers seamless scalability, high availability, and low latency. Pros: fully managed, seamless scalability. Cons: limited querying flexibility.
  9. ScyllaDB: ScyllaDB is a high-performance NoSQL database compatible with Apache Cassandra. It offers low latency, high throughput, and linear scalability. Pros: Apache Cassandra compatibility, high performance. Cons: limited query language support.
  10. MariaDB: MariaDB is an open-source relational database management system that offers high performance, scalability, and security features. It supports SQL queries, multi-master replication, and storage engines. Pros: SQL support, open-source. Cons: relational database limitations.

Top Alternatives to Amazon DocumentDB

  • 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. ...

  • MongoDB Atlas
    MongoDB Atlas

    MongoDB Atlas is a global cloud database service built and run by the team behind MongoDB. Enjoy the flexibility and scalability of a document database, with the ease and automation of a fully managed service on your preferred cloud. ...

  • Elasticsearch
    Elasticsearch

    Elasticsearch is a distributed, RESTful search and analytics engine capable of storing data and searching it in near real time. Elasticsearch, Kibana, Beats and Logstash are the Elastic Stack (sometimes called the ELK Stack). ...

  • Atlas
    Atlas

    Atlas is one foundation to manage and provide visibility to your servers, containers, VMs, configuration management, service discovery, and additional operations services. ...

  • Amazon DynamoDB
    Amazon DynamoDB

    With it , you can offload the administrative burden of operating and scaling a highly available distributed database cluster, while paying a low price for only what you use. ...

  • 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. ...

Amazon DocumentDB alternatives & related posts

MongoDB logo

MongoDB

93.9K
4.1K
The database for giant ideas
93.9K
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
MongoDB Atlas logo

MongoDB Atlas

845
34
Deploy and scale a MongoDB cluster in the cloud with just a few clicks
845
34
PROS OF MONGODB ATLAS
  • 10
    MongoDB SaaS for and by Mongo, makes it so easy
  • 6
    Amazon VPC peering
  • 4
    Granular role-based access controls
  • 4
    MongoDB atlas is GUItool through you can manage all DB
  • 3
    Use it anywhere
  • 3
    Cloud instance to be worked with
  • 3
    Built-in data browser
  • 1
    Simple and easy to integrate
CONS OF MONGODB ATLAS
    Be the first to leave a con

    related MongoDB Atlas posts

    Praveen Mooli
    Engineering Manager at Taylor and Francis · | 19 upvotes · 4M views

    We are in the process of building a modern content platform to deliver our content through various channels. We decided to go with Microservices architecture as we wanted scale. Microservice architecture style is an approach to developing an application as a suite of small independently deployable services built around specific business capabilities. You can gain modularity, extensive parallelism and cost-effective scaling by deploying services across many distributed servers. Microservices modularity facilitates independent updates/deployments, and helps to avoid single point of failure, which can help prevent large-scale outages. We also decided to use Event Driven Architecture pattern which is a popular distributed asynchronous architecture pattern used to produce highly scalable applications. The event-driven architecture is made up of highly decoupled, single-purpose event processing components that asynchronously receive and process events.

    To build our #Backend capabilities we decided to use the following: 1. #Microservices - Java with Spring Boot , Node.js with ExpressJS and Python with Flask 2. #Eventsourcingframework - Amazon Kinesis , Amazon Kinesis Firehose , Amazon SNS , Amazon SQS, AWS Lambda 3. #Data - Amazon RDS , Amazon DynamoDB , Amazon S3 , MongoDB Atlas

    To build #Webapps we decided to use Angular 2 with RxJS

    #Devops - GitHub , Travis CI , Terraform , Docker , Serverless

    See more

    Repost

    Overview: To put it simply, we plan to use the MERN stack to build our web application. MongoDB will be used as our primary database. We will use ExpressJS alongside Node.js to set up our API endpoints. Additionally, we plan to use React to build our SPA on the client side and use Redis on the server side as our primary caching solution. Initially, while working on the project, we plan to deploy our server and client both on Heroku . However, Heroku is very limited and we will need the benefits of an Infrastructure as a Service so we will use Amazon EC2 to later deploy our final version of the application.

    Serverside: nodemon will allow us to automatically restart a running instance of our node app when files changes take place. We decided to use MongoDB because it is a non relational database which uses the Document Object Model. This allows a lot of flexibility as compared to a RDMS like SQL which requires a very structural model of data that does not change too much. Another strength of MongoDB is its ease in scalability. We will use Mongoose along side MongoDB to model our application data. Additionally, we will host our MongoDB cluster remotely on MongoDB Atlas. Bcrypt will be used to encrypt user passwords that will be stored in the DB. This is to avoid the risks of storing plain text passwords. Moreover, we will use Cloudinary to store images uploaded by the user. We will also use the Twilio SendGrid API to enable automated emails sent by our application. To protect private API endpoints, we will use JSON Web Token and Passport. Also, PayPal will be used as a payment gateway to accept payments from users.

    Client Side: As mentioned earlier, we will use React to build our SPA. React uses a virtual DOM which is very efficient in rendering a page. Also React will allow us to reuse components. Furthermore, it is very popular and there is a large community that uses React so it can be helpful if we run into issues. We also plan to make a cross platform mobile application later and using React will allow us to reuse a lot of our code with React Native. Redux will be used to manage state. Redux works great with React and will help us manage a global state in the app and avoid the complications of each component having its own state. Additionally, we will use Bootstrap components and custom CSS to style our app.

    Other: Git will be used for version control. During the later stages of our project, we will use Google Analytics to collect useful data regarding user interactions. Moreover, Slack will be our primary communication tool. Also, we will use Visual Studio Code as our primary code editor because it is very light weight and has a wide variety of extensions that will boost productivity. Postman will be used to interact with and debug our API endpoints.

    See more
    Elasticsearch logo

    Elasticsearch

    34.7K
    1.6K
    Open Source, Distributed, RESTful Search Engine
    34.7K
    1.6K
    PROS OF ELASTICSEARCH
    • 328
      Powerful api
    • 315
      Great search engine
    • 231
      Open source
    • 214
      Restful
    • 200
      Near real-time search
    • 98
      Free
    • 85
      Search everything
    • 54
      Easy to get started
    • 45
      Analytics
    • 26
      Distributed
    • 6
      Fast search
    • 5
      More than a search engine
    • 4
      Great docs
    • 4
      Awesome, great tool
    • 3
      Highly Available
    • 3
      Easy to scale
    • 2
      Potato
    • 2
      Document Store
    • 2
      Great customer support
    • 2
      Intuitive API
    • 2
      Nosql DB
    • 2
      Great piece of software
    • 2
      Reliable
    • 2
      Fast
    • 2
      Easy setup
    • 1
      Open
    • 1
      Easy to get hot data
    • 1
      Github
    • 1
      Elaticsearch
    • 1
      Actively developing
    • 1
      Responsive maintainers on GitHub
    • 1
      Ecosystem
    • 1
      Not stable
    • 1
      Scalability
    • 0
      Community
    CONS OF ELASTICSEARCH
    • 7
      Resource hungry
    • 6
      Diffecult to get started
    • 5
      Expensive
    • 4
      Hard to keep stable at large scale

    related Elasticsearch posts

    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
    Tymoteusz Paul
    Devops guy at X20X Development LTD · | 23 upvotes · 10.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
    Atlas logo

    Atlas

    33
    0
    Develop, deploy, and maintain your application anywhere. Use one console and one workflow from development to production
    33
    0
    PROS OF ATLAS
      Be the first to leave a pro
      CONS OF ATLAS
        Be the first to leave a con

        related Atlas posts

        Amazon DynamoDB logo

        Amazon DynamoDB

        3.7K
        195
        Fully managed NoSQL database service
        3.7K
        195
        PROS OF AMAZON DYNAMODB
        • 62
          Predictable performance and cost
        • 56
          Scalable
        • 35
          Native JSON Support
        • 21
          AWS Free Tier
        • 7
          Fast
        • 3
          No sql
        • 3
          To store data
        • 2
          Serverless
        • 2
          No Stored procedures is GOOD
        • 1
          ORM with DynamoDBMapper
        • 1
          Elastic Scalability using on-demand mode
        • 1
          Elastic Scalability using autoscaling
        • 1
          DynamoDB Stream
        CONS OF AMAZON DYNAMODB
        • 4
          Only sequential access for paginate data
        • 1
          Scaling
        • 1
          Document Limit Size

        related Amazon DynamoDB posts

        Praveen Mooli
        Engineering Manager at Taylor and Francis · | 19 upvotes · 4M views

        We are in the process of building a modern content platform to deliver our content through various channels. We decided to go with Microservices architecture as we wanted scale. Microservice architecture style is an approach to developing an application as a suite of small independently deployable services built around specific business capabilities. You can gain modularity, extensive parallelism and cost-effective scaling by deploying services across many distributed servers. Microservices modularity facilitates independent updates/deployments, and helps to avoid single point of failure, which can help prevent large-scale outages. We also decided to use Event Driven Architecture pattern which is a popular distributed asynchronous architecture pattern used to produce highly scalable applications. The event-driven architecture is made up of highly decoupled, single-purpose event processing components that asynchronously receive and process events.

        To build our #Backend capabilities we decided to use the following: 1. #Microservices - Java with Spring Boot , Node.js with ExpressJS and Python with Flask 2. #Eventsourcingframework - Amazon Kinesis , Amazon Kinesis Firehose , Amazon SNS , Amazon SQS, AWS Lambda 3. #Data - Amazon RDS , Amazon DynamoDB , Amazon S3 , MongoDB Atlas

        To build #Webapps we decided to use Angular 2 with RxJS

        #Devops - GitHub , Travis CI , Terraform , Docker , Serverless

        See more
        Julien DeFrance
        Principal Software Engineer at Tophatter · | 16 upvotes · 3.2M views

        Back in 2014, I was given an opportunity to re-architect SmartZip Analytics platform, and flagship product: SmartTargeting. This is a SaaS software helping real estate professionals keeping up with their prospects and leads in a given neighborhood/territory, finding out (thanks to predictive analytics) who's the most likely to list/sell their home, and running cross-channel marketing automation against them: direct mail, online ads, email... The company also does provide Data APIs to Enterprise customers.

        I had inherited years and years of technical debt and I knew things had to change radically. The first enabler to this was to make use of the cloud and go with AWS, so we would stop re-inventing the wheel, and build around managed/scalable services.

        For the SaaS product, we kept on working with Rails as this was what my team had the most knowledge in. We've however broken up the monolith and decoupled the front-end application from the backend thanks to the use of Rails API so we'd get independently scalable micro-services from now on.

        Our various applications could now be deployed using AWS Elastic Beanstalk so we wouldn't waste any more efforts writing time-consuming Capistrano deployment scripts for instance. Combined with Docker so our application would run within its own container, independently from the underlying host configuration.

        Storage-wise, we went with Amazon S3 and ditched any pre-existing local or network storage people used to deal with in our legacy systems. On the database side: Amazon RDS / MySQL initially. Ultimately migrated to Amazon RDS for Aurora / MySQL when it got released. Once again, here you need a managed service your cloud provider handles for you.

        Future improvements / technology decisions included:

        Caching: Amazon ElastiCache / Memcached CDN: Amazon CloudFront Systems Integration: Segment / Zapier Data-warehousing: Amazon Redshift BI: Amazon Quicksight / Superset Search: Elasticsearch / Amazon Elasticsearch Service / Algolia Monitoring: New Relic

        As our usage grows, patterns changed, and/or our business needs evolved, my role as Engineering Manager then Director of Engineering was also to ensure my team kept on learning and innovating, while delivering on business value.

        One of these innovations was to get ourselves into Serverless : Adopting AWS Lambda was a big step forward. At the time, only available for Node.js (Not Ruby ) but a great way to handle cost efficiency, unpredictable traffic, sudden bursts of traffic... Ultimately you want the whole chain of services involved in a call to be serverless, and that's when we've started leveraging Amazon DynamoDB on these projects so they'd be fully scalable.

        See more
        MySQL logo

        MySQL

        125.9K
        3.8K
        The world's most popular open source database
        125.9K
        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.2M 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.6K
        3.5K
        A powerful, open source object-relational database system
        98.6K
        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.8M 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.7K
        3.9K
        Open source (BSD licensed), in-memory data structure store
        59.7K
        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.8M 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