With AWS Lambda/API Gateway (and arguably with Google App Engine before it) you take away the toil of having to:
* Manage/deploy servers
* Monitor/maintain/upgrade servers
* Figuring out tools to deploy your app to your server
* Scaling an app globally.
* Coping with outages in a data-centre/availability
* Worry about load-balancing & scaling infrastructure
So obviously there are still servers there, but they are largely invisible to the developer.I think this is more than just a marketing gimmick. It is part of a big change in application architectures.
At one end as a small developer of of web/mobile app this can considerably reduce the amount of code/maintenance you need.
At the opposite end of the spectrum the likes of Google (Borg) and Facebook (Tupperware) have developed their own in-house solutions where by servers are largely abstracted out as an entity that developers need to worry about.
Managed docker services (e.g. Google Container Platform, Docker Cloud) are another approach of achieving a largely 'serverless' goal.
(edits for formatting)
This would only be true if the abstraction were not leaky. Frankly, upon a very cursory inspection, my opinion is that AWS Lambda leaks like a sieve.
Docker vs Ansible is a deployment strategy.
Relying on others to make your code run on a server is VERY different than doing it yourself. It's practically the difference between a company with a DevOps team and one without it.
Write server-side code as part of my application, targetting some platform API. Once finished, invoke some deployment routine.
The service provider's job is:
Receive a request from me to deploy my server-side code and keep it running on some server cluster.
That's not a serverless applications architecture because the application contains server-side code.
If you don't want to call it a deployment strategy, fine, I won't insist on that name, even though in my view using a service provider for deployment deserves to be called a deployment strategy.
More generally, it's an approach to make my server-side code run once I'm finished writing it. Call it what you will.
There are some discussions of API's. Whether or not a service has an API is orthogonal to something being a hosted service.
Since the servers are completely abstracted away, they could have just as well not be - hence serverless.
An analogy escapes me but I sure there are some.
Or do you mean that the user don't have to care on how to configure the application? Then "Zero-configuration" is a better name.
Or do you mean that the application hides that it use services on the net? Then it is even worse.
The user here is the developer. Here's an explanation from the article:
> "some amount of server-side logic is still written by the application developer but unlike traditional architectures is run in stateless compute containers that are event-triggered, ephemeral (may only last for one invocation), and fully managed by a 3rd party ... One way to think of this is Functions as a Service."
FaaS is probably a better name.
Serverless really is an auto-scalable distributed infrastructure, perfect for small CPU-intensive tasks in an app which doesn't know how many CPUs it'll need at any one time.
That's a weird logical leap.
Let's make the servers not be by unplugging them. How's the abstraction working now?
The whole idea of a server is to abstract away the details of the upstream computer and its software stack, so the user can think of it only as a provider of an abstract service. The irrelevance of their implementation as a host, VM, box, rack of boxes, pool of quantum foam, string and sparkles, is already built into the concept.
We all know that there's no unique process that is http://amazon.com. It's a service, provided by a (vast distributed) server.
(And yes, 2 years ago I was a little more violent with my wording. Time has taught me things.)
Thus "serverless" means software and humans writing and deploying said software that do not need to know anything about /etc/<whatever> and installing packages and disk partitioning and swapping and whether Python 2 or Python 3 gets installed by default this week and ...
IMHO a good thing, mostly.
Perhaps we could adopt 'A1' instead of the confusing term 'serverless'...
I think to an end-user the definition is meaningless, but to its intended audience it fits.
This is marketing bullshit for microservice architecture. It just sounds better with some added philosophy.
Its an architecture that relies on multiple, supposedly distributed services, all of which are hosted on servers...
Why not just call it "Multiserver" instead.
If they mean "containerless servers" or "microservices", then why don't they say so?
If they mean "distributed servers" why not call it that.
If they mean that the client relies on multiple services (each hosted on different servers) why not just call it a thick/fat/stateful client?
Even a database is a remote service (if not embedded), that is run on some sort of server.
Calling anything serverless is just ridiculous as long as it depends on services on the network.
This smells really bad of just another attempt at marketing a pointless definition just to get more business.