Alternatives to Objection.js logo

Alternatives to Objection.js

Sequelize, TypeORM, MySQL, PostgreSQL, and MongoDB are the most popular alternatives and competitors to Objection.js.
39
67
+ 1
0

What is Objection.js and what are its top alternatives?

Objection.js is a Node.js ORM that is built on top of the Knex SQL query builder. It provides a way to interact with relational databases through a simple and powerful API. Key features of Objection.js include eager loading, dynamic queries, transactions, validation, and automatic schema creation. However, some limitations of Objection.js include a steep learning curve for beginners and the lack of support for NoSQL databases.

  1. Sequelize: Sequelize is a promise-based Node.js ORM for Postgres, MySQL, MariaDB, SQLite, and Microsoft SQL Server. Key features include transaction support, migrations, associations, and read replication. Pros compared to Objection.js include comprehensive documentation and active community support, but it may have a steeper learning curve for some users.
  2. Bookshelf.js: Bookshelf.js is a JavaScript ORM for Node.js, built on top of the Knex query builder. It is designed to work well with PostgreSQL, MySQL, and SQLite. Key features include relations, transactions, and plug-ins. Pros compared to Objection.js include a more straightforward API and better performance in some cases.
  3. TypeORM: TypeORM is an ORM that can run in Node.js or in the browser. It supports TypeScript and JavaScript (ES5, ES6, ES7). Key features include entity manager, migrations, relations, and transactions. Pros compared to Objection.js include support for both SQL and NoSQL databases and a more intuitive way to define entities.
  4. Waterline: Waterline is a data persistence layer that provides a uniform API for accessing waterline adapters. It supports multiple databases like MySQL, PostgreSQL, MongoDB, and Redis. Key features include schema management, associations, and data validation. Pros compared to Objection.js include built-in support for NoSQL databases and a more flexible data model.
  5. Prisma: Prisma is a modern database toolkit that helps developers access databases in web development. It can be used as a replacement for traditional ORMs. Key features include type-safe database access, schema migrations, and a powerful query language (Prisma Client). Pros compared to Objection.js include a more intuitive query syntax and better performance optimization.
  6. Mikro-ORM: Mikro-ORM is a TypeScript ORM that supports SQL/NoSQL databases. It provides a simple and efficient way to work with data in Node.js applications. Key features include entities, migrations, transactions, and caching. Pros compared to Objection.js include easy setup and configuration with TypeScript decorators and support for NoSQL databases like MongoDB.
  7. Django ORM: Django ORM is an object-relational mapping (ORM) tool that comes with the Django web framework. It abstracts the database layer and provides a high-level API for querying and manipulating data. Key features include model definition, querysets, and migrations. Pros compared to Objection.js include seamless integration with the Django framework and built-in admin UI for managing data.
  8. Hibernate: Hibernate is a Java-based ORM framework that simplifies the interaction between Java applications and relational databases. It provides a way to map Java classes to database tables and perform CRUD operations. Key features include entity mapping, lazy loading, caching, and criteria queries. Pros compared to Objection.js include robust support for Java ecosystem and enterprise-level features like data validation and auditing.
  9. Active Record: Active Record is the ORM pattern used in Ruby on Rails framework. It integrates database access and object-oriented programming. Key features include model classes, associations, and validations. Pros compared to Objection.js include seamless integration with Ruby on Rails and convention over configuration approach for setting up database tables.
  10. Spring Data JPA: Spring Data JPA is a part of the larger Spring Data framework and provides easy ways to interact with JPA repositories in Spring applications. Key features include repository interfaces, query methods, and auditing support. Pros compared to Objection.js include seamless integration with Spring ecosystem and declarative repository definition with reduced boilerplate code.

Top Alternatives to Objection.js

  • Sequelize
    Sequelize

    Sequelize is a promise-based ORM for Node.js and io.js. It supports the dialects PostgreSQL, MySQL, MariaDB, SQLite and MSSQL and features solid transaction support, relations, read replication and more. ...

  • TypeORM
    TypeORM

    It supports both Active Record and Data Mapper patterns, unlike all other JavaScript ORMs currently in existence, which means you can write high quality, loosely coupled, scalable, maintainable applications the most productive way. ...

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

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

  • 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 S3
    Amazon S3

    Amazon Simple Storage Service provides a fully redundant data storage infrastructure for storing and retrieving any amount of data, at any time, from anywhere on the web ...

  • GitHub Actions
    GitHub Actions

    It makes it easy to automate all your software workflows, now with world-class CI/CD. Build, test, and deploy your code right from GitHub. Make code reviews, branch management, and issue triaging work the way you want. ...

Objection.js alternatives & related posts

Sequelize logo

Sequelize

886
143
Easy-to-use multi SQL dialect ORM for Node.js
886
143
PROS OF SEQUELIZE
  • 42
    Good ORM for node.js
  • 31
    Easy setup
  • 21
    Support MySQL & MariaDB, PostgreSQL, MSSQL, Sqlite
  • 14
    Open source
  • 13
    Free
  • 12
    Promise Based
  • 4
    Recommend for mongoose users
  • 3
    Typescript
  • 3
    Atrocious documentation, buggy, issues closed by bots
CONS OF SEQUELIZE
  • 30
    Docs are awful
  • 10
    Relations can be confusing

related Sequelize posts

Dieudonné ALLOGNON
Junior Fullstack Developer · | 5 upvotes · 339.5K views

Hey! I am actually in internship and have an app to create for my structure. It will be an intern app which will allow crud dashboard actions with some data provided by the use of an API of one of the structure partner and make a correspondence to data contained in a private database. Since it's an intern app, I thought about Electron for a desktop app because I did a lot of web with Laravel and the structure goes more for the desktop app. But it will be my first occasion working with this tech.

Is Electron a good choice? Wich ORM should be more complete and adapted to this between Sequelize and TypeORM? (Database will be MySQL) Some charts will be displayed in the app. Is there a library (preferably without jQuery) that suits this stack?

Thank you !

See more
Max Musing
Founder & CEO at BaseDash · | 5 upvotes · 103.8K views

Node.js is a great option for real-time applications, especially in conjunction with Socket.IO.

In terms of databases, I'd go with PostgreSQL. MongoDB has its benefits (schema-less, sharding, map-reduce), but for most CRUD-based apps, it makes sense to store the bulk of your data in a relational database (of which PostgreSQL is the best IMO). You can throw in MongoDB if you have a specific need for it. There's certainly no need to use both MySQL and PostgreSQL.

As for GraphQL, it can be nice to work with since you don't need to predefine specific data endpoints on your backend, instead shifting the power to your frontend in requesting the data it needs. It's also useful for public APIs, when you don't know what data users want (see Github's API). It can be useful at the early stage when you're prototyping and want to be able to fetch data quickly, but certainly isn't necessary.

At BaseDash we use Node.js, ExpressJS, Socket.IO, PostgreSQL, and Sequelize to fit our use case of database management and real-time operations.

See more
TypeORM logo

TypeORM

602
81
An ORM that can run in NodeJS and others
602
81
PROS OF TYPEORM
  • 30
    Typescript
  • 12
    Supports MySQL, PostgreSQL, MariaDB, SQLite, MS SQL Ser
  • 9
    Easy setup
  • 9
    Cons of TypeORM
  • 7
    Promise Based
  • 7
    Works in NodeJS, Browser, Ionic, Cordova and Electron p
  • 6
    Support MySQL & MariaDB, PostgreSQL, MSSQL, Sqlite
  • 1
    Support MongoDB
CONS OF TYPEORM
  • 5
    Completely abandoned by its creator
  • 3
    Too complex for what it does
  • 2
    Doesn't really support native javascript
  • 1
    Not proper/real type safety
  • 1
    Cannot use query on any relation

related TypeORM posts

Simon Reymann
Senior Fullstack Developer at QUANTUSflow Software GmbH · | 27 upvotes · 5.4M views

Our whole Node.js backend stack consists of the following tools:

  • Lerna as a tool for multi package and multi repository management
  • npm as package manager
  • NestJS as Node.js framework
  • TypeScript as programming language
  • ExpressJS as web server
  • Swagger UI for visualizing and interacting with the API’s resources
  • Postman as a tool for API development
  • TypeORM as object relational mapping layer
  • JSON Web Token for access token management

The main reason we have chosen Node.js over PHP is related to the following artifacts:

  • Made for the web and widely in use: Node.js is a software platform for developing server-side network services. Well-known projects that rely on Node.js include the blogging software Ghost, the project management tool Trello and the operating system WebOS. Node.js requires the JavaScript runtime environment V8, which was specially developed by Google for the popular Chrome browser. This guarantees a very resource-saving architecture, which qualifies Node.js especially for the operation of a web server. Ryan Dahl, the developer of Node.js, released the first stable version on May 27, 2009. He developed Node.js out of dissatisfaction with the possibilities that JavaScript offered at the time. The basic functionality of Node.js has been mapped with JavaScript since the first version, which can be expanded with a large number of different modules. The current package managers (npm or Yarn) for Node.js know more than 1,000,000 of these modules.
  • Fast server-side solutions: Node.js adopts the JavaScript "event-loop" to create non-blocking I/O applications that conveniently serve simultaneous events. With the standard available asynchronous processing within JavaScript/TypeScript, highly scalable, server-side solutions can be realized. The efficient use of the CPU and the RAM is maximized and more simultaneous requests can be processed than with conventional multi-thread servers.
  • A language along the entire stack: Widely used frameworks such as React or AngularJS or Vue.js, which we prefer, are written in JavaScript/TypeScript. If Node.js is now used on the server side, you can use all the advantages of a uniform script language throughout the entire application development. The same language in the back- and frontend simplifies the maintenance of the application and also the coordination within the development team.
  • Flexibility: Node.js sets very few strict dependencies, rules and guidelines and thus grants a high degree of flexibility in application development. There are no strict conventions so that the appropriate architecture, design structures, modules and features can be freely selected for the development.
See more
Martin Johannesson
Senior Software Developer at IT Minds · | 14 upvotes · 2.9M views

At IT Minds we create customized internal or #B2B web and mobile apps. I have a go to stack that I pitch to our customers consisting of 3 core areas. 1) A data core #backend . 2) A micro #serverless #backend. 3) A user client #frontend.

For the Data Core I create a backend using TypeScript Node.js and with TypeORM connecting to a PostgreSQL Exposing an action based api with Apollo GraphQL

For the micro serverless backend, which purpose is verification for authentication, autorization, logins and the likes. It is created with Next.js api pages. Using MongoDB to store essential information, caching etc.

Finally the frontend is built with React using Next.js , TypeScript and @Apollo. We create the frontend as a PWA and have a AMP landing page by default.

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
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
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
Amazon S3 logo

Amazon S3

53.5K
2K
Store and retrieve any amount of data, at any time, from anywhere on the web
53.5K
2K
PROS OF AMAZON S3
  • 590
    Reliable
  • 492
    Scalable
  • 456
    Cheap
  • 329
    Simple & easy
  • 83
    Many sdks
  • 30
    Logical
  • 13
    Easy Setup
  • 11
    REST API
  • 11
    1000+ POPs
  • 6
    Secure
  • 4
    Easy
  • 4
    Plug and play
  • 3
    Web UI for uploading files
  • 2
    Faster on response
  • 2
    Flexible
  • 2
    GDPR ready
  • 1
    Easy to use
  • 1
    Plug-gable
  • 1
    Easy integration with CloudFront
CONS OF AMAZON S3
  • 7
    Permissions take some time to get right
  • 6
    Requires a credit card
  • 6
    Takes time/work to organize buckets & folders properly
  • 3
    Complex to set up

related Amazon S3 posts

Ashish Singh
Tech Lead, Big Data Platform at Pinterest · | 38 upvotes · 3.4M views

To provide employees with the critical need of interactive querying, we’ve worked with Presto, an open-source distributed SQL query engine, over the years. Operating Presto at Pinterest’s scale has involved resolving quite a few challenges like, supporting deeply nested and huge thrift schemas, slow/ bad worker detection and remediation, auto-scaling cluster, graceful cluster shutdown and impersonation support for ldap authenticator.

Our infrastructure is built on top of Amazon EC2 and we leverage Amazon S3 for storing our data. This separates compute and storage layers, and allows multiple compute clusters to share the S3 data.

We have hundreds of petabytes of data and tens of thousands of Apache Hive tables. Our Presto clusters are comprised of a fleet of 450 r4.8xl EC2 instances. Presto clusters together have over 100 TBs of memory and 14K vcpu cores. Within Pinterest, we have close to more than 1,000 monthly active users (out of total 1,600+ Pinterest employees) using Presto, who run about 400K queries on these clusters per month.

Each query submitted to Presto cluster is logged to a Kafka topic via Singer. Singer is a logging agent built at Pinterest and we talked about it in a previous post. Each query is logged when it is submitted and when it finishes. When a Presto cluster crashes, we will have query submitted events without corresponding query finished events. These events enable us to capture the effect of cluster crashes over time.

Each Presto cluster at Pinterest has workers on a mix of dedicated AWS EC2 instances and Kubernetes pods. Kubernetes platform provides us with the capability to add and remove workers from a Presto cluster very quickly. The best-case latency on bringing up a new worker on Kubernetes is less than a minute. However, when the Kubernetes cluster itself is out of resources and needs to scale up, it can take up to ten minutes. Some other advantages of deploying on Kubernetes platform is that our Presto deployment becomes agnostic of cloud vendor, instance types, OS, etc.

#BigData #AWS #DataScience #DataEngineering

See more
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
GitHub Actions logo

GitHub Actions

23.8K
27
Automate your workflow from idea to production
23.8K
27
PROS OF GITHUB ACTIONS
  • 8
    Integration with GitHub
  • 5
    Free
  • 3
    Easy to duplicate a workflow
  • 3
    Ready actions in Marketplace
  • 2
    Configs stored in .github
  • 2
    Docker Support
  • 2
    Read actions in Marketplace
  • 1
    Active Development Roadmap
  • 1
    Fast
CONS OF GITHUB ACTIONS
  • 5
    Lacking [skip ci]
  • 4
    Lacking allow failure
  • 3
    Lacking job specific badges
  • 2
    No ssh login to servers
  • 1
    No Deployment Projects
  • 1
    No manual launch

related GitHub Actions posts

Somnath Mahale
Engineering Leader at Altimetrik Corp. · | 8 upvotes · 1.8M views

I am in the process of evaluating CircleCI, Drone.io, and Github Actions to cover my #CI/ CD needs. I would appreciate your advice on comparative study w.r.t. attributes like language-Inclusive support, code-base integration, performance, cost, maintenance, support, ease of use, ability to deal with big projects, etc. based on actual industry experience.

Thanks in advance!

See more
Shubham Chadokar
Software Engineer Specialist at Kaleyra · | 6 upvotes · 138.9K views

I have created a SaaS application. 1 backend service and 2 frontend services, all 3 run on different ports. I am using Amazon ECR images to deploy them on the EC2 server. My code is on GitHub. I want to automate this deployment process. How can I do this, and What tech stack should I use? It should be in sync with what I am currently using. On merge to master, it should build push the image to ECR and then later deploy again in the EC2 with the latest image. Maybe GitHub Actions or AWS CodePipeline would be ideal. Thanks, Shubham

See more