WebAssembly on Kubernetes • Nicolas Frankel • YOW! 2025

[00:00:02][applause] >> Hi everybody. Thanks to be here for this talk about WebAssembly on Kubernetes.

[00:00:09]Well, I'm Nicolas Frankel, but who cares? I've been a developer before, then I went to developer advocacy, and now I'm back to software engineering.

[00:00:20]Um Just a disclaimer before we start.

[00:00:24]In general, I talk about something I'm very expert on, and here, this is completely different. This is more exploratory. It changes a lot with time.

[00:00:36]I don't have that much time to keep up.

[00:00:38]If you're interested, you need to do your own research. Don't come back to your boss saying, "Hey, this guy at this conference, he said to do that." And then in 6 months it doesn't work, and then I'm the guilty guy.

[00:00:51]So, who here knows about Kubernetes?

[00:00:55]Okay. Well, you are not an expert. You know about Kubernetes. I assume that everybody knows about Kubernetes. So, what probably you don't know about is WebAssembly.

[00:01:07]Who here knows about WebAssembly?

[00:01:09]Who here comes to discover about WebAssembly?

[00:01:13]Who is the rest?

[00:01:17]Um I like this illustration.

[00:01:20]Uh do you know the story about the blind men and the elephants?

[00:01:26]Like there is a story when you bring blind men into a room, and they need to touch the elephant, and depending on the part they touch, then they have a different mental model of what is an elephant. And I believe WebAssembly is the same. Depending on what part you are familiar with, you have a mental model of WebAssembly as something very specific. So, before I go to talk about WebAssembly on Kubernetes, I just want to talk about WebAssembly in general. Uh by the way, you see this is like generated uh picture because the guy is touching the back of the elephant and and he thinks it's a serpent and elephant at the same time.

[00:02:06]So, it's pretty stupid, but I It's so stupid I like it.

[00:02:10]I kept it because well, it's fun.

[00:02:14]Um So, in order for you to understand what is WebAssembly, I want us to go back in time to understand how WebAssembly presented itself >> [snorts] >> back in 2018.

[00:02:29]And then we will see how it evolved over the time because it's not set in stone.

[00:02:34]Actually, you might have the correct mental model of something that was there in the past.

[00:02:41]So, if you go on the Wayback Time Machine there and you check the WebAssembly WebAssembly website in 2018, they say, "Oh, it's compilation to the web."

[00:02:54]And the idea at the time was well, JavaScript is great, but for performance reason, it might be pretty slow. It's not made for fast computation. So, we will provide something that is much much more performant and then we can use it for computation for for example, 3D or multimedia.

[00:03:21]That's something I took from the time is I did a tutorial that was Conway's Game of Life.

[00:03:31]No, come on. I'm not a bot.

[00:03:35]No, I'm not a bot. Really?

[00:03:40]No, I'm not a bot.

[00:03:42]Is that okay?

[00:03:44]That's the first time it happens to me.

[00:03:46]What did I do?

[00:03:52]Okay.

[00:03:53]Um copy video URL do like this.

[00:04:03]Yeah, I'm pretty agile.

[00:04:08]When I need to.

[00:04:12]Okay.

[00:04:14]So, as I mentioned, this is Conway's Game of Life. This is not nothing new.

[00:04:18]Um but then all the computation like the refreshing of the grid, the computation on every new position is made in WebAssembly. And you can see I have like around 60 frames per second, which is quite good.

[00:04:33]All interaction is through regular JavaScript. So, every time I I click a button or I change something, then the JavaScript code is triggered and it calls the the WebAssembly code.

[00:04:48]Uh you can still find it it it's fun to do.

[00:05:00]Now, for what's 2 years, so not much, 2 years, now they mention a stack-based virtual machine, so we go into the details. They also mention not only deployment for the web, they mention explicitly client and server application. Like in the past, they mentioned for the web, but implicitly it was for clients.

[00:05:25]And now they know, no no, it's not only for clients, now we also want to include server side.

[00:05:33]So, the scope that was at the beginning like content to the browser, now is much much wider, much bigger.

[00:05:43]And the use cases are also very different. Of course, they still like encompass the one that we have seen so far, but it's also polyglots like you work in a company, you work in Java, Rust,.NET, whatever, and then you need to do something else, but there is another stack that is much more focused on the task at hand. Well, you have two choices. You can continue to use your regular stack and use not the right tool. You can try to hire people for the new stack, but you don't know what questions to ask them.

[00:06:19]You don't know whether they are good or not.

[00:06:21]So, the idea is here we should have polyglot approach and then everybody can do their own stuff in their own language and have web assembly at the end and work toward the same goal.

[00:06:36]You can have the same stuff if you are a vendor and a big problem of having a platform as a vendor is how do you allow uh your users to actually extend the platform? In general, it has been done by like custom scripting languages that are super super limited or very open languages such as Groovy or Lua that might be super dangerous because they allow a lot.

[00:07:03]By having web assembly, you can restrict the capabilities while still having a lot and being performant.

[00:07:12]Likewise, functions as a service, this is in the straight line of the performance and small devices because, well, it has a very small footprint.

[00:07:24]Reminds you of something?

[00:07:28]Let's see if that's the case.

[00:07:31]And if you check the web assembly site now, you see now it's for all programming languages. Like before, it was like for C, C++ and Rust, like very very specific.

[00:07:47]But now it's programming languages.

[00:07:51]Who is a Kotlin user?

[00:07:54]Nobody?

[00:07:56]Wow.

[00:07:57]I'm ashamed.

[00:07:59]I love Kotlin and there is not a single Kotlin, Kotlin. You love Kotlin. Oh, yeah. Yeah, you you develop in Kotlin. I love Kotlin.

[00:08:07]Yes, amazing. Now Kotlin compiles to WebAssembly. Even better.

[00:08:13]There was a company that actually works a lot on WebAssembly.

[00:08:18]And they say, "Now we have a Python API that compiles to WebAssembly."

[00:08:23]So, who who is here a Java developer?

[00:08:28].NET?

[00:08:30]Oh, lots. Python?

[00:08:34]JavaScript?

[00:08:36]Ah, it's pretty mixed, cool.

[00:08:38]So, either your current stack actually can compile to WebAssembly at the moment, or it should be in the future if it, of course, can structure.

[00:08:49]And then you can have multiple teams in your company um working on the same code base in different languages, which is super cool.

[00:08:59]And the use cases is the sky is the limit, right?

[00:09:03]You can do anything at this point.

[00:09:05]At least that's what they want you to convince you of.

[00:09:11]And so, the mental model of oh, WebAssembly is just the web is not true anymore. And there was a foundational blog post by another company that works on WebAssembly called Fermion. And in this article, they say, "Now WebAssembly has just like went over the boundaries of the web.

[00:09:34]You can use WebAssembly if you want strong security because it run in the sandbox >> [snorts] >> or if you like small binary sizes, we will see that just afterwards.

[00:09:48]Performance like support of many different OS and architectures and of course still it's still incomparable with the browser. So, with all those capabilities I guess that you want to try it, right?

[00:10:03]It's a dream.

[00:10:07]But actually, it's even more more than that. It's a very vivid, very living ecosystem.

[00:10:13]So, all those products, all those companies, they somehow use WebAssembly at the moment to add something very specific. For example, you have Spin Cube that has something on Kubernetes as well. Wasmer Cloud, they mentioned the Kubernetes and of course as the name imply, the clouds.

[00:10:33]Wasmer Edge is the one we will be using.

[00:10:35]Wasmer, whatever. I mentioned the plugin system. So, for example, Envoy allows you to write extension in WebAssembly.

[00:10:45]So, you don't need to know about C or C++. You can use whatever language you want that compiles to WebAssembly. You use a couple of APIs and then you can write your extensions.

[00:10:59]I've talked a lot already and I want demos because otherwise it's just slide ware and you can do the same at home.

[00:11:07]My demo will focus on three main points.

[00:11:10]First, the container size.

[00:11:12]Second, how you can do it from Rust. I'm sorry. I'm I'm not a Python developer.

[00:11:17]Who here is a Rust developer?

[00:11:19]Ah, much better.

[00:11:21]More than Kotlin at least.

[00:11:23]Um So, it's very hard for me. Hey, you can translate this experience from Rust to other stacks. That's for sure and as I mentioned, it depends lot on the stack, but at least from a Rust perspective, I can show you something. And finally, I want to show you how you can configure Kubernetes to do that.

[00:11:44]So, the project architecture, well, the project, the small demo, um is how I can run a container in Kubernetes, obviously.

[00:11:52]And it's an HTTP server.

[00:11:55]So, I want to create an HTTP server, a web app. Which normally WebAssembly can't do, right? That's the the the opposite of WebAssembly.

[00:12:05]Can't open ports. You you don't choose the network. Here, I want to do that.

[00:12:10]That's my point. And for that, I will use uh a Rust uh framework called Axum, which is to develop web app.

[00:12:20]I will have three different flavors of my containers. The first one is the one regular Rust developers do. Basically, you have a from and a very small image.

[00:12:32]Like, can be um scratch, it can be distro static, and many very very small image. So, you compile your Rust uh sources to native, and you use it.

[00:12:44]The second, I will compile to WebAssembly.

[00:12:48]And my base image will be an embedded a WebAssembly runtime.

[00:12:55]So, far so good.

[00:12:57]And finally, I will use WebAssembly and start from a scratch container, from nothing.

[00:13:05]And I will still run it inside of Kubernetes.

[00:13:09]Sounds good to you?

[00:13:10]That's good, because I have nothing else.

[00:13:15]I have a couple of requirements.

[00:13:20]And one of them is I want to use the exact same source code.

[00:13:26]That's the idea, right? Just like in Rust, you can write Rust code and have different artifacts. Here, I want to have the same source code to both create my native code and create my WebAssembly.

[00:13:44]If you know about HTTP bin, I will implement one single uh endpoint, which is the get request.

[00:13:52]I will have two tunnel. So, if you don't know Rust tunnel, the tunnel file, the cargo tunnel file, actually, is how you describe the project.

[00:14:01]It's for JVM developer, it's the palm.

[00:14:04]For uh Python developer, it's the pipe project.tunnel. For the.NET developers, I have no clue. For uh the JavaScript developers, uh it's the package.json.

[00:14:16]And I I will have three separate Docker files.

[00:14:20]So, let's start looking at the codes.

[00:14:24]I will remove my glasses.

[00:14:29]Close all tabs, and let's start.

[00:14:33]So, the source Big enough?

[00:14:40]Okay.

[00:14:41]Couple of imports, and here you can see that I lied a bit.

[00:14:46]Slightly.

[00:14:48]Because I said I want to have the exact same source code for all, right? To generate the same from the same source, different um bytecode, well, native or WebAssembly.

[00:15:02]Here, it's just I lied a bit because I want inside of the binary, whether it's the native binary of the WebAssembly code, to have the flavor in which it's supposed to be. Not that it be a runtime configuration, that it's really baked in.

[00:15:22]And for that I need to use the configuration of Rust to say, "Okay, if I pass this flag, then it will the flavor will be native. If I pass this flag at compile time, sorry, this flavor will be embedded and it will be runtime.

[00:15:37]So, I will have one single const that depends how I compile it will give different results."

[00:15:44]And then I can't actually cheat afterwards.

[00:15:50]Um this is the main function.

[00:15:54]So, there is one thing is WebAssembly doesn't support async stuff, so I will run everything to the same thread. And here is the magic. I will actually create a TCP listener and start it. So, normally I will do something that WebAssembly can't do. I will start a web app and listen to port 3000.

[00:16:19]The rest is regular stuff. I'm reading the request. I'm getting the URI, the query parameters, the headers, and I return it as a JSON.

[00:16:31]First thing, the TOML.

[00:16:34]The TOML are here, native cargo TOML.

[00:16:42]Rust developers, can you confirm that this is regular Rust, nothing mind-blowing?

[00:16:48]There are a couple of hands. Yes.

[00:16:51]Thanks.

[00:16:52]Okay, good.

[00:16:53]>> [snorts] >> Now, the not so regular part. Here is how I will compile with a toward WebAssembly.

[00:17:08]So, if you are not used to it, Rust doesn't work like other regular languages I'm I know of.

[00:17:18]In that case, in the case for example of Java, you say I depend on this jar and it will get the jar, the package manager will get the jar and it will use the jar at run time.

[00:17:30]But the jar is already compiled. With Rust, you actually download the source of the crate you want to use and you compile it.

[00:17:40]So what I'm doing here, I download the source, but I will patch the source.

[00:17:48]And so I will patch the source of some of the crates that I'm using, for example the one that normally create a web server for something that is adapted to web assembly that normally couldn't be done in a regular web assembly a context.

[00:18:07]So I'm patching two of them.

[00:18:12]And now comes the fun part, the Dockerfile.

[00:18:18]I'm using Rust.

[00:18:19]I do whatever is necessary. So basically I install the tool chain.

[00:18:25]I compile everything. And then afterwards, so this is a multi-stage Dockerfile, must multi-stage build Dockerfile. I start from, sorry, distro static and I run HTTP.

[00:18:40]Easy peasy.

[00:18:43]Web assembly embedded, meaning that I'm using for my base image, I will be using a wasm runtime.

[00:18:56]Okay? So I do the exact same stuff. The only difference is I install a different target.

[00:19:04]And of course, when I compile, I target web assembly.

[00:19:11]Okay?

[00:19:12]And now I'm running this binary, which is here to run the web assembly code.

[00:19:24]Finally, this one is the most mind-blowing in general.

[00:19:32]I do the exact same to start with. So, I install the tool chain to generate web assembly. I compile to web assembly.

[00:19:41]And the second stage is I copy the wasm file and I run the wasm file.

[00:19:50]And I start from nada, zero.

[00:19:56]Isn't it amazing?

[00:19:58]Let's start to check if it works.

[00:20:02]So, normally, because I am used to forgetting stuff, this is wasm Kubernetes native, so I will docker run uh IT or RM. Don't forget the port, 3,000.

[00:20:25]3,000.

[00:20:28]Should work, right?

[00:20:30]And now I curl.

[00:20:33]Uh I will keep it this here.

[00:20:36]I Oh.

[00:20:38]No, here. I will curl here. Curl localhost 3,000/get.

[00:20:47]If I jq it, jq.

[00:20:52]Amazing. So, you see flavor native. This is what anybody would expect, right?

[00:20:57]Nothing crazy.

[00:20:59]I kill it.

[00:21:02]I kill it.

[00:21:04]I kill it.

[00:21:09]Yeah, that's the problem when you start with a very, very small um distro base image. He's normally you should wire the sick term inside and I never do it because I'm super lazy.

[00:21:22]Uh so I will docker PS.

[00:21:27]And normally I will docker stop.

[00:21:31]>> [snorts] >> Where is it?

[00:21:33]This one.

[00:21:37]And normally it is done. Okay? I can do the same with the embedded one.

[00:21:56]Embedded one.

[00:21:59]So far so good?

[00:22:01]What I want to show you is also the images size.

[00:22:07]Docker images grep wasm.

[00:22:19]Wasm runtime 2 megs.

[00:22:24]A bit more.

[00:22:27]Who can beat that?

[00:22:30]I mean 2 megs is nothing, right?

[00:22:34]The native, which is very good, it's Rust, it's 12 megs.

[00:22:38]And the embedded one is 8 megs.

[00:22:41]So even if you don't use the native one, if you use the embedded one, so remember the native the embedded one means that you have a base image that is a runtime a wasm runtime container, you can still shave off space. I'm not talking about performance, just space.

[00:23:04]But if you only have 2 megs, so let's try to run it.

[00:23:17]It's called run time.

[00:23:20]Oops.

[00:23:23]Docker doesn't know how to run it.

[00:23:25]Fun fact, 6 months ago it knew how to run it.

[00:23:30]Doesn't anymore.

[00:23:32]And this is the problem of web assembly, it changes all the time. Did that change? Did something happen to my machine? I don't know.

[00:23:40]So we have very, very small container because we only have the web assembly file that can't run.

[00:23:47]Fortunately, our goal is not Docker, it's Kubernetes.

[00:23:54]So remember, 2 megs, unbeatable.

[00:23:58]But doesn't work.

[00:24:00]Hey, you can't have both, huh?

[00:24:02]>> [laughter] >> So now I want to show you how to run on Kubernetes. And for that, I need to get a bit, not that deep, but a bit into Kubernetes.

[00:24:15]You might know that Kubernetes itself or Docker don't run the containers themselves.

[00:24:22]They delegate to something.

[00:24:25]Uh the new Docker delegates to containerd before before it uses dockerd, and Kubernetes also by default delegates to containerd. But containerd doesn't run the container, either.

[00:24:39]It delegates to something called a shim.

[00:24:44]Guess what?

[00:24:46]The shim doesn't run the container, either.

[00:24:49]It delegates to something.

[00:24:52]And in general, if you did nothing by default, it we'd probably use something called runc.

[00:25:02]So, the idea here is that instead of having a containerd shim, we have a wasm edge shim that will call will delegate to the wasm edge binary.

[00:25:15]Just the same way that the containerd shim delegates to the runc binary.

[00:25:21]So, if you are super interested in that, you can check everyone's responsibility, but basically containerd is just the life cycle manager, the shim is the middle man, and runc or wasm edge is just a common line interface. So, you can basically call runc something.

[00:25:46]I decided among all the runtimes available to use wasm edge. Spoiler, mhm, was perhaps not the great choice, but at least I learned a lot.

[00:26:00]So, normally here, I would show you everything with the common line and the internet, and there is a chance it might not work.

[00:26:09]So, what I did is I recorded the stuff already.

[00:26:15]Yes, I'm like this.

[00:26:17]So, I will clear, and I will do something called askinema askinema play, and it's called wasm edge cast.

[00:26:28]Ready?

[00:26:31]So, imagine it happens in real time.

[00:26:39]So, what I will be doing, normally you would do that on the similar machine, but here I do it on my production machine, which is my laptop. First, I will SSH into uh the Kubernetes control Kubernetes.

[00:26:54]Then I will download Rust installer.

[00:26:58]Uh for whatever reason, I don't have the correct permission, so I need to copy the temporary file to another place where I have the permission. It's fine, too. And then I run the installer.

[00:27:07]Because I'm super lazy, I will be using the default installation. I don't need to customize anything. So, again, if you are Rust uh developer, that is probably regular stuff. I installed the different components, Cargo, which is the package manager, and everything. The Clippy, which uh like allows you to for everybody to use the same Rust style, Rustfmt for the formatting.

[00:27:32]Done.

[00:27:33]Then I need to uh configure the environment so that it's part of my path.

[00:27:39]Now I have Rust installed. Why do I need Rust? That's a good question.

[00:27:44]Because WasmEdge actually there is no don don loadable library or binary or anything. I need to compile it by myself.

[00:27:55]Which is what I'm doing here.

[00:27:57]So, for that, I added Rust.

[00:28:01]Uh now I have cloned the one Wasm-Edge, which contains all the different runtimes, including WasmEdge.

[00:28:08]And now I will be making the stuff.

[00:28:14]And so, for whatever reason, in that case, I think that at some point I will need to download a different Rust installation, and I have no clue why.

[00:28:24]So, here I'm updating the Linux packages, like always.

[00:28:29]Which I already did, but they choose this different registry.

[00:28:34]So, now I'm preparing to build, and I'm building. And here, as you can see, it uses a different Rust version.

[00:28:42]So, I'm downloading the components again.

[00:28:45]Real fun stuff.

[00:28:47]Uh but for for more serious thing, um, again, this should be done only once on a regular machine, and then you use the component itself directly.

[00:29:00]But here I used my laptop, so I do everything on the same one.

[00:29:08]And now it fetches the crates, it does all its magic.

[00:29:13]And sorry, at the end of the process, I should have my WasmEdge binary ready.

[00:29:24]I know it would be more impressive if if it was in real time, but it looks very good, right?

[00:29:31]Perhaps once I shouldn't tell anybody, I would just say, "Oh, look, this is I will install and blah blah blah."

[00:29:39]And now now I have the binary ready, and the last thing I need to do, and here it's where the Skenema doesn't work anymore, is I need to configure Kubernetes. So I need to go inside of Kubernetes in a very specific file to actually say, "Okay, now if I want to run web assembly stuff, you need to delegate to the WasmEdge shim."

[00:30:14]So we can wait a bit if I find this one because I'm super lazy.

[00:30:21]Up. Took.

[00:30:22]So I can SSH into uh, it's minicube.

[00:30:30]SSH profile Wasm.

[00:30:39]And here I can do this, and I can find the wasm pod.

[00:30:50]So, this is a regular configuration. So, normally here you have all the run times and the all the run times generally is just run C. It's big enough?

[00:31:03]Yep. It's just run C. What I added was those two lines.

[00:31:08]And basically it says, "Okay, if you find something that is there is a naming implicit convention, but basically it says if you find something that is wasm edge, you should run it with the wasm edge shim."

[00:31:25]Good?

[00:31:26]So, I can exit that.

[00:31:29]And now I have built the images. The only thing that I need is to deploy to schedule the pods to Kubernetes. So, I will do that.

[00:31:39]Uh no, I needs to have the native one.

[00:31:42]So, this one.

[00:31:45]Shall I do it again?

[00:31:47]I I It's free. I will do it again.

[00:31:51]Of course, everything is already applied. So, normally you shouldn't have any surprise like and change and change and change.

[00:32:03]And change and change and change and and change and change and change.

[00:32:09]Good. Now I can curl because they have been scheduled.

[00:32:15]Can remove that. Remove that.

[00:32:19]So, let's start with the native one, the one that already worked with Docker.

[00:32:28]Flavors native.

[00:32:30]I have additional headers because I'm going through Kubernetes, right?

[00:32:34]And I added a parameter.

[00:32:38]So, it gets me that.

[00:32:40]I can do the same with the embed.

[00:32:42]It still worked.

[00:32:45]Yeah, it works again. And now, the thing that didn't work in Docker, are you ready?

[00:32:51]Should I do it?

[00:32:56]2 megs container running in Kubernetes.

[00:33:00]And the exact same result. So, here you have an HTTP server that actually is made from WebAssembly running in Kubernetes in a 2 meg container.

[00:33:11]Unbeatable.

[00:33:16]And you know, at this point people applaud, but okay. THAT'S FINE. THAT'S FINE.

[00:33:20]>> [applause] >> I I HEARD IN THE LAST IN THE PREVIOUS session that Australian were very shy, so that's fine.

[00:33:32]So, now time to reflect.

[00:33:35]There are good things and there are not so good things. First, yes, as mentioned, it's an HTTP server in Wasm.

[00:33:43]It runs your code with 2 megs.

[00:33:45]It's crazy.

[00:33:49]The bad.

[00:33:50]I told you WasmEdge, it might not have been a super wise choice, and the reason is the code isn't actively maintained.

[00:34:02]So, the latest commit was in March 2024, which is not great, but for the runtime itself, it's even worse.

[00:34:16]It hurts a bit.

[00:34:18]But, the really the ugly is that I prepared this talk 6 monthses ago.

[00:34:23]6 monthses ago, it worked perfectly.

[00:34:27]Then, I went to go to Amsterdam, which is the sister parent, how can you do you call it? Go to conference compared to this one. Is it sister conference? Is it parent conference? Is it cousin conference? Is cousin?

[00:34:43]Um that's the reason why I wear this this t-shirt, by the way. It's not that I love myself so much but I love myself so much.

[00:34:50]But they gave it to me at the Go to conference and I thought every other speaker was at the Go to conference would come with their own t-shirt as well. But no, I'm the only idiot having my face and people now think that I I have a very high opinion of myself, which is true but not the reason why I'm wearing this t-shirt.

[00:35:08]>> [sighs] >> Anyway, we prepared that the the talk 6 months ago and for Go to conference which happened in October or November, I thought okay, I will run the code.

[00:35:19]The code didn't work anymore.

[00:35:21]I had to actually downgrade Tokio version.

[00:35:26]And though the the code like wasn't touched since 2024 March.

[00:35:34]I had absolutely no clue why now it it failed afterwards.

[00:35:39]And so it doesn't give you a good confidence, right?

[00:35:44]So my summary is this world of WebAssembly and especially WebAssembly on communities is evolving like really really fast. If you're a startup and this you want to leverage this to have competitive advantage, just embrace it. It can give It can give you amazing results.

[00:36:04]If you are a more traditional software shop, I wouldn't recommend it because it's super super risky and you might need to invest a lot of things into well, stuff that doesn't work out in the end or you need to get back in time.

[00:36:20]Thanks a lot for your attention. You can follow me on all the social media including the dead birds.

[00:36:26]Um if you are interested in the codes, uh everything is on GitHub, so you have a nice GitHub repo for that. And if you are interested in the blog post that I made 6 months ago, so with stuff that doesn't work anymore, but you still get the idea. Everything is on my blog. Thanks a lot.