 Okay. So this is the IPFS operator. The IPFS operator is a Kubernetes operator that allows you to quickly and easily start up IPFS cluster. We made, I don't know, there's probably times, there's probably a lot of Kubernetes operator, Kubernetes people out there who would like to use more of a three stack and we up to this point, don't support it very well. So hopefully this is a step toward increasing that support. I want to start off by just showing you how it's used. There we go. I just want to show you how to create a cluster. I'm going to go back to this, but I'll show I want to have a really good, you know, I'll circle back to this and you'll see what happened. This is the cluster creation process, kubectl, apply-f, and we just apply, give it a file. And boom, has creating an IPFS cluster ever been easier than this? It's basically you're done. Actually, the operator is still working in the background, but I want to show you what's going on inside here. This is it. Basically, we took out all the critical components, the critical decisions that you might want to make, namely the storage and how many replicas you want to have. In this case, we're just, you know, each node is only going to have 50 gigs, pretty small. And we're going to set up 100 replicas. So we'll check back on this later. And I just want to get that started for now. Yeah. This is the page that basically shows that. And looking at the collab cluster is indeed a breeze. So what this is doing, we are going to, we're going to create a whole bunch of pods. They're going to, oh, yeah, collab clusters. Are you guys, if you guys are familiar with, there's a IPFS cluster has a feature called collabs, collab.cluster, ipfscluster.io. These are, this is a feature of IPFS cluster allows you to follow the pins that are going on in another cluster. Setting up collab clusters is also very easy. We can create an IPFS cluster simply by specifying who you want to follow. This will, it's the same process as creating a regular cluster, just as you saw. But in addition to allowing you to use it for your own purposes, it will also pin, you know, important content from around the world. In this example, we'd be pinning the Filecoin proof params, we'd be pinning the IPFS websites, the Gutenberg content, Pacman packages. Quick, easy. Yeah, let's see. Yeah, scaling a cluster. Yeah, IPFS. These are, I have two clusters now, one that I created earlier and one that I created just a couple minutes ago. Let's see how do we scale a cluster. So all Kubernetes objects are typically displayed in YAML. In this case, you know, this looks kind of similar to the one to the setup that we just saw. I want to change my, let's say replicas. I don't want four nodes. That's too small. Let's, let's go, let's go six and just save that. Done. No provisioning hardware, no messing around with cloud providers, no cabling, no configuration, just edit the config file, finished. Just to prove that this works. Get pods. There we go. We've got our cluster with 100 nodes still being built. And now we have our six nodes. Looks like the last one's just finishing up right now, but the, you know, we're up to six nodes for that cloud cluster already. Nice. Quick. Yeah. Okay, so now let's back up a little bit. What is an IPFS operator? I wanted to start off with that so that we can give a little bit of time for the 100 node cluster to build while we go on with the rest. What is an IPFS operator? Excuse me, a Kubernetes operator. Kubernetes allows you to extend the API by adding custom resources. And basically, whenever you do this, you have an operator. In this case, we have this object called an IPFS cluster. We have this object. This is kind IPFS. That's called a CRD, custom resource definition. You pass it parameters and you can have some custom code running that will act on those parameters and create things. I put some examples here. These are some great Kubernetes operators that exist. The Postgres operator, if you change the size of it, it knows how to handle, you know, wall backups. You don't need to be a DBA to run Postgres if you use the operator. Prometheus, same way. If you deal with Prometheus monitoring, you can edit Prometheus targets on the fly without going in and adding any of the config files. And of course, this one. This one that we're discussing right now. All the minutiae to deal with setting up an IPFS cluster, you probably noticed that I didn't do any of it, right? A little bit more deeper into the weeds. How this actually works is basically it's an IPFS node with IPFS cluster installed next to it. This is the standard IPFS cluster that you know and love. Additionally, the way the followership works, there's one additional pod for every cluster that you're following. So if you're following, you know, 10 different clusters, you know, good work. There'll be 10 additional pods that are all here. Basically they're connecting to this IPFS node and making requests to the IPFS to store content. The way this looks at a whole cluster, and this is actually the reason why an operator is necessary, is that to set up the entire cluster, it is, whoa, it's very complicated. But you can see here we have a number of IPFS nodes, you know, they're sitting here behind a load balancer that enables you to interact with the nodes. Internally, these IPFS clusters are doing a lot of complicated stuff. They all have peer IDs. They have a consensus protocol which might be RAFT or CRDT. They're talking to each other, doing membership joins and all this. Your application is this yellow box sitting over here. This is the experience that you want. You want to be able to just say, I want you to add this file. Something happens. And then over here on the left, that's you. I can just say I want to read this file over IPFS and it should just work like magic. Yeah, so I want to show an example of this. Let's do that. Okay, I have my handy dandy notes right here. So let me just copy that. Hello from Kate. Let's go ahead and use IPFS cluster add to add that to the cluster. Not with a capital letter, but lowercase. There we go. So this adds it to the cluster. This is indeed adding it to the cluster that is running in Kubernetes. I set up a port forward. What you can see is that we get an ID back and we can fetch this over IPFS or even through the gateway. Yeah, there we go. It's visible over IPFS. And indeed you can do this with any of them echo random. Let's put this IPFS cluster add more files. We get a different CID. Let's see what we got IPFS, DHT, find probes. Let's find this file that we just created. This is going to be demo hell. Let me use the other one just in case of your problem. Okay. So the file that we added a little bit earlier, we've got to give it some time to propagate, but the file that we added a little bit earlier, these are IPFS nodes that are running in our cluster. And indeed if we were to exec into one of these, there we go. IPFS ID, what's my ID? It's F3. It looks like that's this one right here. So we are indeed storing these files on the cluster that we created and fetching them anyway. This is the observation that I want to really hit home here is that you can add files and retrieve it off of IPFS. This is easy. All the complicated parts generating the peer IDs, generating the cluster secret. I bet you didn't even know that you had to do that just from looking at this. Yeah, wow, complicated. And yes, this is the overall point for putting this out here. We want to use things like this use operators to lower the barrier to entry. There are people out here who use Kubernetes in their day to day life for their business, and they maybe read about Web3 stack and they want to try it. And then they're like, oh, this isn't for me. But if there is an operator out there that is easy to pick up, maybe that puts them in a position where they're actually able to try it. This is the ability layer level. This is a sort of a matrix to show where different types of operators are. I would honestly say we're still in the very developing phase of this. So we're probably somewhere between level one and level two. We can do the basic install and we can handle some light changes like you can see that I can increase the scale of it and I can do some on the fly changes. Some of these deep insights and stuff like that are to come later, I guess. Still working on it, still work in progress. I'd put us right around level one, level two, something like that. And to top this off, where can you find it? This is being developed in conjunction with Red Hat Emerging Technologies. So its current home is right there, Red Hat ET IPFS operator. Once we get this into more of a production state, it will be on operator hub. This is planning on making sure that this is available on OpenShift and of course we will include it and make it as widely available as possible as it grows in maturity. And I think that is it for me. Hopefully, oh, one sec. I nearly forgot. How many nodes that we could create? I'm going for 100. Looks like 41 is the highest one. I did do a little bit of time, you know, some timing on this before. It takes right around, I wouldn't say like 20, 25 minutes to create a full 100 node IPFS cluster. But dare I say that is much faster than creating it manually. So there we go. I think that's it for me. Thank you.