Welcome.

MYLES BORINS: Hi, everyone.

Thanks for coming.

[APPLAUSE]

MYLES BORINS: It's been a long day.

It's been a long three days.

And I know Steren and myself really

appreciate all of you sticking around and coming

to our session.

So just one more time, thank you everyone.

STEREN GIANNINI: It's good to have you with us.

This is Myles, Myles Borins.

Myles is a developer advocate on Google Cloud

and we've been working together for the last year.

He also happens to be the director of the Node.js

Technical Steering Committee.

[APPLAUSE]

And of course he's a long time Node.js lover.

I think the first time you used Node.js

was for an Earth installation?

Something like that.

Nice.

MYLES BORINS: So this is Steren.

Steren is a product manager for Google Cloud Platform

on the serverless team.

And we've been working really closely on new Node.js

technologies.

Previously was involved in the Stackdriver Error Reporting

product.

And you used Node in production in 2011?

Was that like 04 or 06?

STEREN GIANNINI: 06 I think.

MYLES BORINS: 06.

Did anyone start with Node 06 in the audience?

Right on.

That was buggy.

I think that's like right when they introduced [? Util. ?]

But fun fact about Steren.

His wedding invitation was actually written in JavaScript

and it's still online.

And that means your wedding invitation will never break.

STEREN GIANNINI: Never.

The web.

All right.

So who can name these French pastry?

So it's called a millefeuille, literally

translating to thousand layers.

So it's basically a cake made of many, many, many layers.

So one of my teachers used to say

in French [SPEAKING FRENCH] Sort of translating, every problem

is millefeuille of simple things.

So you should understand every problem can be broken down

into many simple things.

And I think this is also true for software, for code,

but also for software architectures.

If you break down your big app into simple things,

it will be simpler.

Until you break them down into Microservices.

So that brings us to Microservices.

Why Microservices?

Well, maybe your app has grown too big.

Maybe it's actually hard to understand, deadlocked,

maintain, manage.

This is why Microservices can be a solution.

You break up the monolith.

You decouple those Microservices.

You make them simpler to understand and maintain.

And potentially each service will

be written in a different language,

owned by a different team, and deployed independently.

As a consequence, they will scale independently

if you've decoupled them.

The scaling is independent, too.

And by making them more fine-grained,

that will result in a better utilization of your resources.

That will result in a lower bill for you.

And lastly, Microservices pair great with Node.js

due to the asychronous nature of Node.js.

So Microservices break up the monolith,

scale independently, and pair great with Node.js.

But what is Node.js?

MYLES BORINS: So I was given this slide.

Node.js.

JavaScript, how many people like JavaScript?

Sweet.

So I don't if any of you have ever

seen this little emoji thing before, the rocket turtle.

That was the Node.js logo.

It was kind of like a joke.

Substack drew this turtle on a rocket ship

because JavaScript was not supposed to be a fast language.

It was pretty amazing how fast, both as a

runtime, but also for iteration.

Node is one of those things that just you have an idea

and you can get it done in like 10 or 15

minutes because someone's already written the module.

You just need to find it.

At its base, Node is a JavaScript runtime.

We take the V8 virtual machine that

comes in the Chrome browser, we wrap it

with libuv, which is an underlying architecture

wrapping all the system calls.

And that kind of abstracts all the different platforms

and allows developers to just write JavaScript and be

able to do compute, write servers,

and all those different things.

It allows you to leverage your front end skills.

It's event driven.

What that means is that compute is driven by events.

Something computes when something happens.

That can be an HTTP request.

That can be some sort of message coming over a socket.

It can be user input with a keyboard.

It can be some sensor if you're working with IoT.

Any form of I/O. So anytime there's

input, some sort of compute runs.

The [? adventure ?] of an architecture

plays really great with async non-blocking I/O. Multiple

things can run in parallel without blocking each other.

When I make some sort of request over a socket,

I'm able to suspend, let other things execute,

and resume when I'm done without requiring the developer

to program any of this.

It just happens.

Many events execute without blocking each other.

And this ends up being really great for web servers

because it means multiple people can

connect to the same process at the same time

and it just works.

You don't have to worry about mutex.

You don't have to worry about timing.

You just worry about handling the events.

So to sum that up, Node.js is JavaScript runtime

that's event driven with async non-blocking I/O.

STEREN GIANNINI: And the last term

that we need to define from the title of this talk

is serverless.

So who here is using a serverless product?

So we should agree that there are a lot of definitions

for serverless.

I'm going to highlight here the key characteristics

that we use along this talk.

The first one that, to me, is the main characteristic

is that you pay for what you use.

So it's a billing model.

If you don't use it, you don't pay,

and then the bill is proportional to your usage.

Of course you don't need to provision in advance

and your resource, all of this, is done on demand.

So why are we able to achieve that billing model?

Because of an operational model.

So a serverless product will scale with usage

without having to worry about it.

It grows with you from a single developer to a company

with thousands of developers.

It follows your usage.

And why can it scale?

Because of a programming model.

The cloud providers takes care of the rest.

You focus on your code.

That means that no infrastructure management,

no VM management.

Everything is abstracted from you.

So you focus on your code.

That also means that you focus on delivering business value

and value to your users.

So to recap, serverless, pay for what you use,

it scales and allows you to focus on code.

These are the principles we have to use along that talk

and you will see it's not actually not only for compute.

MYLES BORINS: So Google Cloud has

a number of different serverless offerings.

We have Cloud Functions.

How many people here have been using Node in Cloud Functions

so far?

Cool.

We've got App Engine Standard, we've

got Data Store, Cloud storage, BigQuery Pub/Sub, Dataflow,

ML Engine, the Firebase suite, as well as AppScripts.

And all of these different products,

what defines them as serverless and makes them all serverless

is the fact that you don't have to manage them.

We will scale them for you.

We will manage them for you.

You can utilize them as much as you need it.

STEREN GIANNINI: And today, we are

very proud to share with you the preview of Node.js on the App

Engine standard environment.

[APPLAUSE]

STEREN GIANNINI: Thank you.

So yes, we are adding a new language to App Engine's

standard, Node.js.

We will release it in a few weeks.

So let's see a small demo of Node.js on App Engine standard.

Myles is going to tell you more about it.

MYLES BORINS: So this package json file

is outlining a hello world application.

We have a single start script that calls node on server.js.

Which fun little fact, if you don't define the start script

and you just run npm start, that's actually

the default command it will just do,

which can be really confusing if you're not

expecting it to do that.

And it has a single dependency, which is Express.

Here's our Express app.

We're making an app using Express.

We have a single route.

And we celebrate Node.js on App Engine standard.

We listen on an environment variable for the port

or fall back to 80-84 local development.

And there's one more thing that we'll

need to get this onto App Engine standard.

It's just a tiny bit of YAML.

This one line of YAML runtime Node.js 8

is the only extra thing that you need

to add to the majority of Node.js apps.

And it will work as soon as you run a single command.

And that command is gcloud app deploy.

So Steren has something loaded up on his computer.

So we're going to switch over to it right now.

And your going to see Steren's in the Cloud Shell.

He's got that app that we were just showing you.

And he's going to type in that command

that I just mentioned, gcloud app deploy.

So this is how you know it's a real demo.

But we haven't actually deployed yet, we're ready to deploy now.

STEREN GIANNINI: Ready to go?

MYLES BORINS: You're ready?

STEREN GIANNINI: Let's do it.

MYLES BORINS: So we're starting to deploy.

And in the time it takes to deploy,

I'm going to try to list all the things I like about it.

So it's an idiomatic node runtime environment.

So that means we're using the exact version of Node that

gets published by Node.js.

There's no special runtimes, there are no special APIs,

it's the same app you can run in other places.

It scales to zero.

So when you're not using it, you're not paying for it.

It's a managed runtime.

So that means everything but your code

and the node modules that you're using will get updated by us.

If there is a security fix that needs to land into Node

or open SSL-- and trust me, there

are-- we're going to patch that for you

without you or your users really ever noticing.

Oh, wow.

I couldn't even get to it.

It's already deployed.

You also get npm install in the Cloud.

So that also did npm install.

You get hybrid monitoring for free and free and free HTTPS.

Wow, that was fast.