
Jets: Ruby Serverless Framework - alfonsodev
http://rubyonjets.com
======
ryanmarsh
I’ve been using Serverless for a while. Having almost 10 years of familiarity
with Ruby on Rails I knew the Ruby community would do something great in this
space. AWS Lambda took, what feels like, forever to get official Ruby support.

I really love this and I feel the JS and Go Serverless communities could pick
up a few tips on developer friendliness from the Ruby community.

------
burlesona
This is interesting. It's obviously designed to look and feel just like Rails,
and with "afterburner" can deploy Rails apps to lambda.

It would be interesting to see a direct comparison with what's actually
different from Rails. I saw some a few notes in the docs but not a high-level
rundown.

Also interesting, was this forked from Rails or written from scratch to mimic
the API? It doesn't look like a fork from just reading the source, as the code
is organized a bit differently, but the API is such an exact match I can't
help but wonder :)

~~~
nateberkopec
Rails is a dependency:
[https://github.com/tongueroo/jets/blob/master/jets.gemspec#L...](https://github.com/tongueroo/jets/blob/master/jets.gemspec#L30)

~~~
burlesona
Splitting hairs, but from the gemfile it looks more like bits of rails are
dependencies.

------
DanielKehoe
I just built a tiny application in Ruby for AWS Lambda using the Serverless
Framework. It's a fallback application that only needs to catch SMS messages
from Twilio when our main application falls down. So a perfect fit for always
available but seldom running and cold starts shouldn't matter. I implemented
services such as a cron job and sending email (for a daily administrative
report) in just a line of two of code. Compared to Rails, there's hardly any
code. But compared to Rails, there's a lot of configuration of infrastructure
(in one serverless.yml file) and it wasn't easy to find blog posts or
examples. Implementing logging? Shouldn't be difficult but it was because of
the AWS permissions structure. Ruby gems? Complicated especially for any that
have native extensions. And yes, Amazon and Serverless have documentation but
the wonderful Rails community has created much richer resources for solving
every little problem.

I'm eager to try implementing our application in Jets to compare it to the
Serverless Framework implementation. It'd be nice to stand up an application
on AWS as easily as we build a Rails application and deploy to Heroku. That
said, maybe after figuring out how to use the Serverless Framework, there's
not much reason to use Jets. I'm curious.

------
logandk
For things like simple Sinatra APIs, a light-weight alternative is
[https://github.com/logandk/serverless-
rack](https://github.com/logandk/serverless-rack) (a plugin for
[https://serverless.com](https://serverless.com), I'm the maintainer.)

To get a large Rails app operational on Lambda, Jets is the way to go.

~~~
bigtunacan
What is the advantage of serverless-rack over using AWS SAM? A quick glance at
your project seems like it has a similar general intent, but without the
official backing/support of Amazon.

~~~
logandk
Indeed, SAM and serverless framework serve the same overall purpose. It's
mostly a matter of whether you prefer CloudFormation (SAM) or serverless'
configuration format. I have mostly used serverless, but there are some posts
out there comparing the two in detail, such as:
[https://sanderknape.com/2018/02/comparing-aws-sam-with-
serve...](https://sanderknape.com/2018/02/comparing-aws-sam-with-serverless-
framework/)

------
arthurcolle
Anyone using serverless frameworks: is it actually any cheaper, practically
speaking?

~~~
djsumdog
I still don't understand the difference between serverless vs just a Docker
container. You still have to define your dependencies and entrypoints. Most
serverless stuff runs in some type of abstraction behind the scenes (a
container or some other chroot/namespace).

It just feels like silly buzzword garbage that locks you in further to AWS.

~~~
jonthepirate
We used serverless/lambda to run our flask app for flaptastic.com. Since the
site doesn't see a lot of web traffic, our web costs are roughly $0 per month
whereas running any kind of long running web server platform (docker or
otherwise) has fixed costs.

------
faizshah
I wish GCP would bring ruby support for cloud functions. Their ruby client
libs are the best out of the languages I have tried for GCP (JS, python, PHP).

~~~
akvadrako
They should just support Docker and be done with it. I mean you can already
hack any runtime you want to run on cloud functions by just including the
required binaries in your package – why should it be so difficult to support
it officially?

~~~
gizzlon
Maybe Cloud Run can fill the gap?
[https://news.ycombinator.com/item?id=19616265](https://news.ycombinator.com/item?id=19616265)
?

------
bigtunacan
What's the advantage of this over just using the existing AWS SAM with Ruby
and your current favorite framework like Rails or Sinatra?

~~~
pjmlp
Pimping up the CV.

------
drewcoo
Is this a slant reference to the Frank Zappa album?
[https://en.wikipedia.org/wiki/Cruising_with_Ruben_%26_the_Je...](https://en.wikipedia.org/wiki/Cruising_with_Ruben_%26_the_Jets)

~~~
22c
If it is, I like the other Zappa tie in:
[https://www.zappa.io](https://www.zappa.io)

------
stretchwithme
Been thinking about such possibilities. With the advent of serverless, what
executes a controller action does not need to be a server executing every
other controller action in an application.

We don't need to keep two machines alive, one each in two different
availability zones to provide the bare minimum uptime. Not if any controller
action can quickly be given part of a machine on which to execute. There is no
uptime or downtime, other than that of the service administering this fleet of
machines.

------
rohindaswani
I lol'd so much after reading the name. I was just building a test server less
app in Ruby with Aws to figure out how it works.

This seems potentially useful though run through server less without Jet to
under stand the knitty gritties of the server less architecture

------
xrd
I'm not sure of this tagline but:

"Ruby and Lambda splat out a baby and that child's name is Jets."

