.Net Foundation On .NET, 12 Sep 2019

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Walking Down the Memory Lane with Bing – Part 1

Description

Get started with .net
https://dotnet.microsoft.com?WT.mc_id=ondotnet-c9-cxa

Memory Management and garbage collection in .NET
https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/memory-management-and-gc?WT.mc_id=ondotnet-c9-cxa

In this episode, Maoni (CLR) and Mukul (Bing) talk about large page support in .NET Core 3.0 and the performance improvement in the Bing scenario.

Follow Maoni and Mukul on Twitter:
https://twitter.com/maoni0
https://twitter.com/mjsabby

#dotnet #dotnetdeveloper #dotnetcore

A

We're here today in on.net talking about state at.

A

Scale in serverless workflows using something new and magical called durable, entities.

A

You won't want to miss this. check it out on on.net.

A

Hello and welcome to another episode of on.net.

A

I'm your host, jeremy likness and I'm here today with the durable function's team.. I've got sebastian and chris with me, and they're, going to talk about some of the latest features that are coming out with durable functions.

A

So before we get started, sebastian, why don't we start with you.? Tell us a little bit about who you are, what you do with microsoft. right,. So I've been working at microsoft, research for about 10 years.

B

I recently got interested into severless programming, models,.

B

And I found that it was a great opportunity to work with the durable functions team on this., so I think we're at the cusp of something big in the severless world, and bringing state back into severless,.

B

I think, is where I'm at. so yeah,. That's what I'm here for.! That's why I'm excited.

B

Awesome. yeah, it's very exciting.

A

So this is coming straight out of microsoft: research, then., yeah,, so, well,, it's a coordination of efforts,. I would say.

A

okay., so we both brought the piece to it,, yeah., nice, and chris. yeah,. So I'm an engineering manager on the azure functions team..

A

My team owns various parts of the platform.

A

But one of my favorites is to work,.

B

They're all kind of favorites, right, is durable, functions..

B

So that's a project. I started back in 2017.

B

Now,, I think it was actually a hackathon project,, but since then it's grown, again,.

B

With the idea of creating a new way to do a stateful, serverless patterns., so it's very exciting framework..

B

I know when it came out. There was a lot of excitement on our side, and I've been working with some of the latest bits having a lot of fun with what's happening.

B

but more importantly,, seeing how these would apply to.

B

The enterprise and to actual workflows that people need.

B

So tell us a little bit about durable entities and what's new with the framework.

B

Sure, yeah. so recently,.

B

We announced that we're doing a durable functions, 2.0,.

B

And one of the flagship features.

B

Of durable functions, 2.0 is a thing that we call durable, entities.

B

The way to think about durable entities is these.

B

Are effectively serverless virtual actors.

A

B

So I've got a couple slides here, which I can give a little.

B

Bit more of a deep introduction, if that's all right.,.

B

But anyways, with durable functions, at least in 1.0,.

B

There are a whole bunch of stateful patterns that we allowed developers to implement in a serverless environment.

B

Now, some people, think of serverless and they're like wait, a minute, "state,. Aren't they supposed to be stateless." well,. We think that you could actually do stateful as well,.

B

And so we started out with orchestrations., so these workflow patterns,.

A

And we supported a whole bunch of them, function, chaining,, fan-out/fan-in, etc.

A

But there was something that was missing, and we think one of the patterns that a lot of customers wanted to implement in the serverless was,.

A

You can summarize it as like event: aggregation, all right?.

A

So I've got some function which manages states and it might be receiving a whole bunch of messages either concurrently from different places.

A

The orchestration support that we built was just really.

A

Not well-designed to handle that.

A

So that's when we got in contact with sebastian and microsoft, research, and said, "hey,. We think we can maybe.

A

Model this pattern using something like actors.

A

Let's collaborate,: let's talk about and see how we can do something: cool, here.", awesome., so, yeah.. We just want to add more patterns to.

A

Durable functions to help customers solve their stateful problems.

A

So traditionally, we had three different function: types.

A

You've got your client function, which is just a stateless function.. It's like http trigger,, key trigger, any of those..

A

These are the traditional functions that we're used to that.

A

Can basically kick off the durable workflows.

A

That's right., that's exactly right.! Then we had this orchestrator function, which this one is definitely a stateful function.

A

Long-Running, durable,.

B

Survives vm crashes and those sorts of things.

A

Then the orchestrator functions could call activity functions.

A

Like, in sequence and parallel you're able to orchestrate these.

A

So, with the new durable functions 2.0, we have.

A

A new function type that we're introducing.

A

Which is the entity function and it's blue.

B

This is another stateful function, type that we're introducing.

A

One of the things that was important to us is we didn't want to just build some new actor framework.

A

We wanted something that was very much tightly integrated into the durable functions, family and not just off by itself.

A

All right., so we had a bunch of bindings already for durable,.

A

And so effectively what we did was we said, "okay,?

A

Let's add these entity functions, if you will,.

B

And, let's add support for your client functions to be able to invoke these.".

B

Let's add support that orchestrators can call these things and get responses back from them,.

A

And then the entity functions themselves, they have a bunch of operations that they can perform.

A

So one of the things that really struck me,- and I think this may have been in the documentation,.

A

But it was the idea that orchestrations, as is, are.

A

Implicit state, and so by the pattern that you use for the orchestration,, whereas the entity functions are durable. Entities, are explicit, state.

A

I'm very tangibly saying, "here's, a piece of information I want to persist. Then mutate in a certain way." yeah,. Let's say you can totally do that,.

A

And maybe sebastian if you want to talk a little bit, about,.

A

Even like the name., so we talk about this as being like the actual pattern, but we're calling them entities,.

A

But maybe sebastian you can tell us your thoughts..

A

The name entity is interchangeable to some degree,, but I thought it's not bad. If you have a name where people don't immediately think they already know what it is., so they can think a bit like. How does this work,.

A

And there are some differences here., so at the surface of acs, they may look like actor,, but perhaps the biggest difference is that you can use them together with the orchestrators..

A

That's not something you get in an active framework,, the orchestrations.

A

having both of these things together actually unlocks.

B

New possibilities that you don't.

A

Easily get in a pure, active, framework.

A

well,. I like that. You approach the name in that way too, because I think sometimes people get confused when you name a technology after a pattern,.

A

And it's like, oh,. Is this just the pure implementation of the pattern.

A

so to your point,? This is something that interacts.

B

With the level of functions as is.

B

Yeah., so it's this interaction.

B

Which will, in the end, really make it productive.

B

Then productivity really is the keyword in all of the serverless space.

B

It's the point that programmers want to be able to write those services very conveniently,, and I think that's also something that's a little different here from classical actor frameworks.

B

All of our communication goes through durable, cues.

B

So we are persisting all the messages reliably, and that in a traditional setting, people would have thought,.

B

"Oh, this is too expensive.". You shouldn't force everything to be so persisted,.

A

But when it comes to productivity,.

B

That really unlocks something. like,. If you don't have to worry about the difference between something being in memory or on disk,.

B

If you can just write your application logic,, I think that's really. What brings state.

B

Back into serverless is for us what that means, all right?.

A

That's the durable part of durable, functions.

A

well,, the nice thing about it too, is you touched on several elements.

B

One is productivity for the developer, and I can focus on my code and my logic without worrying.

B

About the underpinnings of how that scaled, out,.

B

How that's replicated,, how that's duplicated., that's the other part of serverless, is that scale out,.

B

And I love that there's a way to deal with state.

B

That I do some very atomic operations and say I want to change this or do this, and all of the distribution and scale out is handled for me.

B

In fact, it can even,, I guess, scale out now on different back-ends as well., so that's pretty cool. yeah, for sure.. Why don't we jump into some code?.

B

That sounds good.. Let's see what this actually looks, like.

A

So I'm going to switch over to my visual studio project that I have here.

A

So when we first announced support for durable entities,.

A

The first experience we had was a very.

A

Much consistent with the azure functions, programming, model.

B

We had just a straight entity, function, very much untyped.

B

So if you're familiar with more typed actor, frameworks,.

A

It felt maybe a little foreign to you. if you've done aka,. Maybe this is familiar.

B

But the basic idea was that I've got some function,.

B

It's got an entity trigger, and has some contexts object, which you always get as part of the function..

B

You can fetch the states using.

B

A getstate method and formatted into whatever shape you need it to be..

B

Each operation that you invoke has an operation name potentially,,.

B

And, depending on what that name is,, you can read the inputs of that operation, modify some states.

A

In the context of an orchestration,, you can send that state back to an orchestrator,.

A

And then we have an operation to where you can explicitly save your state..

A

So this was our first iteration for doing this.

B

Again, very much untyped but consistent with the existing functions. Programming, model.

A

Okay. again,, you can do things like write.

B

An http trigger function and you can send messages to these entities.

B

They have an entity id which is basically,.

B

Effectively the function name,.

B

And then you get to give it some unique identity.

B

Then you can send messages to it,.

B

And you can also do similar things from orchestration.

B

So it's very similar to the orchestration model that we had,.

B

Except now, instead of writing, orchestrator functions,.

B

I'm writing an entity. Function. right. makes sense. so that works, but you notice this switch statements.

A

Some people got a little bit nervous when they saw the switch statement because they're imagining, well,.

A

What happens when I have more than two or three cases that I need to handle.

B

So what we did in our more recent release is.

B

We created a typed model, which I show here,.

B

Where, basically, you model your entity as a class.

B

So in this case, I have a new class,, I'm calling it counter..

B

All it does is just store a value, and you can increment that value.

B

my model, the state, just as a property,.

B

And you can declare exactly how you want to serialize that thing.

B

Then all the operations are just methods.

A

So add method to add some value to your state,.

A

Reset or get, this exactly the.

A

Same code that I had in the other side.

A

But this time it modeled as a class with methods.

A

Then we have a little boilerplates, a function,, you have to add here,, but that's basically it,.

A

Nice clean model that a lot of .net developers, we think, will like.

A

Yeah, so far, I've taken an existing project that was using storage as a backend,.

A

That was really just to maintain stayed the same way that you're doing and the conversion process of adding durable entities, and it just made sense and it just works.

A

So I was very happy with that. good, thanks., so why don't we fire this up.

B

And I want to show a little bit some of these in action.

A

So I'm just going to go ahead and f5. This project.

A

We shipped the sample..

A

If you go check out our github repo,, it's there.

A

So I'm just firing up the functions hosts right, now,.

A

And it looks like that's ready to go.

B

I'm going to switch over to another command line window that I have, and in my command history. Here I've got some commands.

B

So one of the things that's cool about durable entities to.

B

Is because we're running in the azure functions, host,.

B

And the azure functions host. Has these built-in http endpoints,.

B

We actually made it possible for you to invoke these double entities directly from http.

B

You don't necessarily have to write a function to go and then send a message to it,.

B

You can just send an http request directly., so I thought that might be cool to show off here..

B

So what I'm going to do is I've got this tool that I like.

B

The command line here is just http..

B

The tool is it's a python utility, http api which allows you to send http requests to any endpoint, and it's really good with json, formatting and stuff like that..

B

But what I'll do is I'm going to go ahead and try to query some counter? Entity.

B

Now, we'll call it my counter three..

B

Now this entity doesn't exist right, now.

B

But we're going to query it. Anyways just prove that okay, this thing doesn't exist., so I do an http get and I get back 404, not found..

B

Now,, so I understand for this url,.

B

This is because you declared it as a durable entity,.

B

It's automatically created a url for us to access all of those into the operations?, that's right., so the functions host has built-in web hooks.

B

We were able to register some new ones when you installed the durable functions extension..

B

So under this durable task,, url prefix,, we have something called entities..

B

Then after that, you can specify what is the type of entity that you want to query or want to invoke, and then what is the the unique id,.

B

That entity, if you'll add the key., I think, is the terminology we tend to use..

B

So it's just built in, and then you can immediately just start using it.

B

So we queried it,, we saw that there was nothing there.

B

So what I'm going to do next is actually try to send a value to it.

B

So with this tool, I can just say, I want to send the value five.

B

Instead of a get, we're going to do a post to my counter, three.

B

What I expect to get back is an http 202 accepted.

B

So we sent, actually wait, sorry.

B

One thing I forgot is we have specify what operation that we want.

B

So I think at this point we'd probably created it, but what happens.

B

Normally is that when you send a message to your entity,.

B

If it doesn't exist, we'll create it on the spot.

B

now, because I didn't specify an operation,.

B

It probably created it., it saw a message and it's like I don't know what to do with this,. It just ignored it., but what we allow you to do is specify an operation on the query string here, in this case add,. So if you remember, we have an add method that we defined in our entity. Class.

B

It takes in some integer amounts of data.

B

So in our command line, we're going to send a five to this,.

B

And that's just going to update this current value state that we have.

B

So let's go back and let's do that.

B

We should get back another 202 accepted.

B

So at this point,, what we should be able to do is we can go and query this again,, and we should be able to see that now we have our states,.

B

The entity exists and we have some state..

B

So if I wanted to, I could also send,, let's send another number. how about we send a three this time and that's going to basically go through the same process.

B

It's going to accept that message, and then, when we query it again,, we should see that the value is,.

B

Maybe the timing was wrong..

B

You did my counter two,, I think.

B

my goodness.. So now we have a my counter. Two,.

B

With some value, sorry about that.

B

So let's go back to this one and change it to my counter. Three.

B

It's all very dynamic here., so we do the add there, and now, if I query,, let's make sure I'm querying the right guy two..

B

So my counter three,, you do http get.. There you go. Again. durable entities can add.

B

Yes,, durable entities can add., so you can imagine that. Obviously this is a very trivial example, but in some cases,.

B

It's still very powerful., just like actors,. We support things like managing concurrency for you.

B

So if I had sent a whole bunch of these commands concurrently, behind the scenes,, we have a dispatcher which is going to serially, execute those so that you don't have to write, locks and things inside of your code to manage that concurrency.

B

So it's super convenient.

B

yeah,! That's another thing! We think that it's missing currently from stateless functions is the ability to synchronize things.

B

So if you have conflicts between requests, you need some way of making that happen.

B

we have seen over and over, have people struggle with that like trying to make things exclusive or having singletons or.

B

Locks and checking etags and all the that.

B

etags exactly. etags are complicated,. It's not-.

B

Concurrency is never fun, and I love this.

B

So you just dispatch an operation and it's guaranteed.

B

That no two operations will happen simultaneously on the same entity..

B

So then it just flows through and it gives me,.

B

I love the example by the way in the preview docs.

B

they talk about. If I have an iot endpoint and I'm picking up different metrics,, I can key off the metric type and aggregate the counters as it's going..

B

Even if I have millions of devices,, I don't have to worry about,. Oh there might be 10 devices concurrently accessing it,.

B

Those messages will come in order which is really nice.

B

yeah, and this also.

B

Scales up to potentially millions of entities as well.

B

This is the virtual actor pattern that we're following here,.

B

And so when these things aren't executing we're able to safely unload them from memory,, and then only when some operation arrives for them,.

B

We can load them back up and get their state,.

B

Do the computation and then take it back out of memory again, which allows you to scale to large numbers of these.

B

So this is available right now in durable functions. V2 preview.

B

Is there anything specific on roadmap, any timelines?.

B

I know I always put people on the spot when I ask that,, but any big things you can share as far.

B

As what's going into it before the final release?.

B

So I guess what I can say is that, as far as the programming model goes,, we feel pretty good with where we're at now..

B

There are a few nice things that we want to do to better integrated with functions.

B

for example,, make it easier to access your bindings from these types as.

B

Well, as better integrate with dependency injection, which was something added to azure functions, v2.

B

So we're going to tie up some of those loose ends, and we're also investing in some alternate backends that you can use to power. This.

B

So right now, everything's stored in azure storage, which is great,.

B

But azure storage has a certain scalability and throughput limitation,.

B

And so we think people that really want to do some very serious workloads like serious iot type, workloads or gaming whatever,.

B

Might want something: that's a little bit more performance..

B

So that's an area where sebastian and I are working together.

B

I think long-term. This is actually part of the story. Is.

B

Just like you saw with garbage collection, when it first came out, people said this is too expensive,. I don't want to use it.

B

again,. Now everybody uses it and you're ready to pay that cost, because it makes it so much easier.

B

So I think, with stateful serverless we have a similar story.

B

Initially, it will look like it's too expensive,, but in the long-term you just see what it buys. You.

B

And as we make those implementations better and better,.

B

The cost is actually becomes very acceptable.

B

Which is one of the appeals of the serverless architecture is that. to begin with,, right., low cost scale and in the fact, that,.

B

That's why I love about durable tasks in general.

B

The durable functions is being able to take something.

B

That is long running on the calendar, but compute time is actually really short..

B

You just asynchronously waiting for all these things., so it works out really well that way. yeah, it's actually got an extra. awesome.. Did you have any more code or anything else you wanted to highlight??

B

I think that's probably good for now.

B

We have more samples in our github repo., so if you're interested in seeing more end to end type samples,.

B

Little more complicated than just this counter, sebastian put together a few of them.

B

they're samples actually.

B

at the time of right, now, you have to switch over to our v2 branch,.

B

That's one thing to be aware of it's not in our master, branch.

B

We have a branch called v2.. You can find some samples using double entities.

B

All right,, well, I will check those out and just to make it easier on you. We put together an easy link so that you can get started right. Away.. You can read about the preview,.

B

You can link in to the various features.

B

you're going to go to aka.ms/vv2.

B

That's all one word,, no spaces, vv2, that'll. Take you right to the documentation.

B

Thank you both for coming out and sharing the hump.

B

super-excited about. What's coming out., we are too, thanks for having us. all right, appreciate, you.