
Lessons Operating a Serverless-Like Platform at Netflix, Part 2 - diab0lic
https://medium.com/@NetflixTechBlog/developer-experience-lessons-operating-a-serverless-like-platform-at-netflix-part-ii-63a376c28228
======
sparrish
"These fine grained units also meant that the composition of the final
application was much more distributed. ... As long as business and client
metrics remained unaffected, per unit health was ignored."

This was my big takeaway. I think this is the trajectory for monitoring in
general as services become increasingly more distributed.

~~~
eikenberry
This isn't so much a unique feature of serverless though, any self-healing
cluster based system is better monitored this way.

------
mirko22
I have hard time understanding "Serverless" part... It sounds cool, but there
are bunch of servers there they are using.

As far as I can manage to understand that name only has to do with pricing
rather then actual servers, but then why is it not called something like
"cheap" or "pay as you use"?

Maybe I am missing the point here, but this is just a buzzword? (nano-services
being the other one, much like micro-services, do we have pico-ones?)

~~~
BinaryIdiot
The best way to look at "serverless" is that it's a deployment strategy.
Instead of deploying a service you are deploying functions or files of code
versus a fully functioning service.

~~~
mirko22
But you spawning a bunch of worker nodes on demand to execute that code?

~~~
jcrites
The concept of serverless, as I understand it, is that the application
developer doesn't need to manage or think about the servers their applications
run on. It's not that no one is managing the servers -- it's that the
application developer doesn't need to. The developer is building on top of an
interface that encapsulates those details.

With typical cloud hosting, I need to think about and manage a fleet of hosts
from the kernel and operating system on up. I need to think about the hardware
and choose a machine type, with a configuration of CPUs, RAM, and disk. I need
to choose an OS, and the machine is my responsibility from the init system on
upwards, including all of its daemons for SSH, NTP, etc. I need to think about
how I'll distribute and install my software onto the machines, and how many
machines I need. I need to think about how I'll handle machine failures and
replacement.

With serverless, the interface to the developer is: specify what application
to run, and it runs. I don't have to manage the execution environment that
runs the application.

~~~
KGIII
I'm trying to understand. This sounds kind of opposite to a description given
to me for dev-ops. Is that accurate enough for a layman?

~~~
jcrites
I wouldn't consider serverless to be the opposite of DevOps. I'd actually
consider those concepts to be largely orthogonal.

Serverless and classic server environments are different kinds of system to
manage. Classic operations vs. DevOps is about how you manage your systems,
and who has responsibility for them.

In classic operations, software development and operations are separate teams
with different responsibilities. DevOps combines these two functions into a
single team (hence DevOps).

Serverless applications are still a system that needs to be managed; it's just
less responsibility and effort than the traditional model. Consider: if newly
released code contains a defect that's impacting the larger system, who has
responsibility for detecting the problem and rolling it back? This concern
exists with both server and serverless platforms, and DevOps vs. classic
operations would have different answers.

~~~
KGIII
Excellent, thanks. That sums it up wonderfully.

I'm retired and we had separate teams with a liaison between the two, pretty
much since our inception. A part of me thinks it's a good idea, but I'd worry
about depth of knowledge in both disciplines, but I digress.

------
cromwellian
Seems like the extreme version of this would be a simple annotation in client
code to run it on the server, like the old <script runat...> in ASP, e.g. Java
pseudo code

@RunAt(Platform.SERVER) public Observable<List<Customer>>
findCustomersByName(String name) { return // code to query DB and return a
list of customers over the wire }

// on client public void searchByCustomer(String name) { //
findCustomersByName() and bind stream to UI }

The idea being that the RPC is automatic here. The client code makes an async
call, constructs an observable around deserialized result. The server code is
pulled out by and spun up as a cloud function on demand. Of course this only
makes sense if the code needs to run on the server (e.g. the results are big
and need to run a lot of code, or need to run code that can't be trusted on
the client).

~~~
dualogy
> _like the old <script runat...> in ASP_

Good memories! I remember how neat I found that as a script-kid back in the
pre-.NET, VBScript-based ASP 3.0 days some 17 years ago. (MS Personal Web
Server for the Win! The QBasic of the early web age.) But there wasn't any
code-sharing and it was always clearly server-code, not client-code. Let alone
the fact that only IE could run VBScript on the client..

------
cagenut
I would be curious to see more detail about their warmup handler practices.
Did they tune the JVM for it or is there some way to deterministically invoke
the right JIT'ing.

~~~
techwizrd
I'm not sure what Netflix is doing, but Alibaba has a neat JWarmup feature[0]
in their AJDK that warms up the JVM and JITs based on recorded profiling data.

0: [https://jcp.org/aboutJava/communityprocess/ec-
public/materia...](https://jcp.org/aboutJava/communityprocess/ec-
public/materials/2017-02-14/Java_at_Alibaba.pdf)

~~~
ibejoeb
Very neat, thanks. I didn't know they ran a custom jvm. About to go down a
rabbit hole.

------
kolanos
If anyone is interested in learning more about serverless, AWS lambda, etc.
There's a webinar this Thursday: [https://read.iopipe.com/announcing-the-
things-to-know-about-...](https://read.iopipe.com/announcing-the-things-to-
know-about-lambda-webinar-eb8a42266301)

