Fluence Labs Start with Fluence. Tutorials, 10 Sep 2021

Previous Meeting

⏯

youtube image

►

From YouTube: How to add compute layer to IPFS with Aqua

Description

00:00 Intro by Protocol Labs
02:06 Aqua Language
03:33 Browser-to-browser communication tutorial
09:50 Terminology and structure of the network
11:58 Fluence and IPFS integration
16:15 How Fluence and IPFS integration organized
18:18 How to run computations on the data stored in IPFS. Demo
24:22 Trying Aqua with VSCode Devcontainer

Speaker: Dmitry Kurinskiy, Fluence Labs CTO

Original video: https://youtu.be/8FpZOjTVYiA (Browsers3000)

Useful Links:
Open bounties for GitCoin hackathon, until 28.9.2021 https://gitcoin.co/hackathon/gr11?org=fluencelabs
Fluence documentation https://doc.fluence.dev/docs/
Aqua book https://doc.fluence.dev/aqua-book/
Fluence Devcontainer https://github.com/fluencelabs/devcontainer
Fluence IPFS Adapter https://github.com/fluencelabs/aqua-ipfs
Discord Support https://fluence.chat/
Book A Meeting With The Team https://calendly.com/fluencehack/

A

Hi everyone um welcome. Thank you so much for joining us here today. We are just letting some people in from the waiting room, so we'll give it a couple of seconds to let everyone come in and get settled thanks again for being here.

A

If you want, you can drop us a note in the chat box there and let us know where you are tuning in from.

A

We'll just give it one more minute or so.

A

A

Okay, I think this sounds good, we'll go ahead and get started so once again welcome and thank you all for joining us for another browser's 3000 learning session today. We are very excited to have dimitri karinsky here. To tell us about. Fluence fluence is a peer-to-peer peer-to-peer application platform that allows the creation of applications free of proprietary cloud providers or centralized apis.

A

Fluence's pdp platform provides a complementary compute layer to ipfs, enabling a wide variety of decentralized use cases. So dimitri, thank you again for being here today and we look forward to hearing all about fluence.

B

B

So this is a the learning session and I want to get right to the point of adding value to the ipfs ecosystem from fluence and the entry point. uh Interfluence uh is aqua language, so I'm going to show you what is aqua language, uh what it enables and how it helps to compute to add a compute layer and computations to ipfs uh with aqua.

B

So, first of all, what is aqua aqua is a programming language that programs network routing in open, permissionless peer-to-peer networks.

B

So instead of recompiling files, thinking about security, every time and so on, you can write down the aqua script, uh throw it to the network and it will flow uh from peer to peer uh calling functions on the way uh getting data, providing data um and so on. So it's very easy to make peer-to-peer programs using aqua and it's real. It's simply it's powerful and it's ready. It's ready to use.

B

You can just take it and use, and I want to show you how easy it is uh with a tutorial example of browser-to-browser communication without ipfs, yet uh just the flow of perturbed computation and how it could be expressed with aqua.

B

So, um let's think about delivering the message from one web browser to another web browser. What we want is to call some function that will trigger this. This sequence as a web browser cannot be accessed from the outside and it's limited in connectivity.

B

It needs to connect to some node, uh which is called relay to provide the services, the routing services for the browser. Then, if you want to get to another browser, we need to get to another relay and here's the flow. I want to call the function that goes to my relay to the node that I'm connected to then to another one, then, to another browser, call some function there and then get back. Get back to me with the response.

B

That's how it could be expressed in aqua uh here's we have uh the snippet of aqua code, so we have the notion of service which has some functions which are executed outside of aqua in this case inside the web browser.

B

So we have the input type, the output type, pretty simple, and we have an aqua function where we have arguments- and we say that on target peer id on the target browser id via target relay, we want to call this function, catch the result and provide this result back.

B

So this via means that to get to the target browser and back, we need to get to go through through this bureau. So pretty simple: uh let's take a look on on the code and uh what it looks like in the code. So we have the examples repository and uh in the intro folder. That's one hello world.

B

Here we have aqua just the same. The same code uh and this aqua gets compiled to.

B

To typescript, because we want to run it from the web browser, so this is a the result of compilation of aqua. We see the low level code here doesn't matter. What matters is that, finally, what we have after compiling the aqua function to typescript is just an async function in typescript very convenient that returns a promise of the result type.

B

So, let's see how it integrated. Here we have a very simple react application and all we need to do to integrate our front end with this distributed. uh Workflow is just to import the the compiled aqua and import the function from it that we have just seen.

B

Then we need to register the callback for the service.

B

That is called from from the aquascript here we just return hello from like we are setting the state to have it displayed for the users, and uh we have a the on click action listener with a weight, say hello that actually triggers uh all this flow around the nose so again to have this distributed. Workflow. All you need is to write around uh 10 lines or seven lines of aqua code, compile it and import from the front end. So all you really need to do is to develop the front end, and I think it's awesome.

B

Let's take a look on uh on this example.

B

uh So I have this intro running. I have two browsers side by side and I have a list of relays over the fluence nodes that I know.

B

Let's pick one relay to one web browser another relay to a second browser. Here we have the peer id of this web browser and the node that is connected to let's copy and paste it. I'm copy pasting, because it's the most simple way to to go, uh but actually in the real world applications. You can discover these peers these ids and uh do algorithmic routing, so it just works. We have two nodes, we have two peers and we just delivered the message and it takes like minutes.

B

So, let's get to the presentation.

B

uh Aqua is running in the fluency network, and flint's network is a very open, very open. One, so browsers can be peers, interference, network. They are treated just as peers. You can call functions on on the browsers if they uh allow it you to do it.

B

They are just the parts of of aqua scripts nodes are also peers, they are running there. They are built to be the rust and running on some hardware somewhere uh and they are capable to run webassembly computations, bundled within services with the marine runtime.

B

So we have different peers like clients, it could be browsers or mobiles or anything. We have different nodes in the network and we can have web assembly services on these nodes. What's interesting is that these services even can execute external effects, uh for example, they can work with ipfs files.

B

You can instruct the webassembly service uh to download or to the file over ipfs, and that's what I'm going to show you or you can instruct it to fetch urls like get prices from an ethereum node or I don't know the weather from somewhere or fetch an image or a web hook trigger a web hook. Something like that, so you can make quite complex workflows uh using web assembly and aqua, but let's focus just on on aqua and just a bit of web assembly. The next part is about fluence and ipfs integration.

B

So, first of all, I want to show how fluence makes possible to deploy webassembly to deliver webassembly code from ipfs to fluence node. So this finally means that you can point on the web assembly on the computations to link computations by cid.

B

What's going to happen uh from the browser, I want to ask the fluence node using an aquascript to deploy a webassembly package that is fetched from the ipfs node fluence node will go to ipfs, node and fetch this file by cid ipfsnote will download it and provide it to the file system.

B

Then node will take this webassembly and move it to webassembly storage and then it will compile it and run and it will return the id which is callable, which you can just use for function calls the service id is different from this cid currently, because it shows that uh this uh code is already deployed and it's ready to be called.

B

So, let's, uh let's do it!

B

I want to stop the first example and go to ipfs code execution example.

B

And start it, uh this is the fourth fourth part of a tutorial. You can take a look on all the tutorials and readmes. They are more or less documented, and the structure is a bit more complex here, because we have a service in rust.

B

And aquascripts and front-end, but finally the logic is the same, so we're waiting for the front-end to run it's just typescript compiling and while it's running, let's take a look on on this. uh That's the api of the file that we are going to deploy and- and here we have all the flow of.

B

Deploying this service to to the node using the cid of the services web assembly. So here we have the node where we want to deploy the service, the service cid, the address of the node that holds this service. Actually we can get it from from the node, but uh you can point on the node, where you know it's cached or where you know that it's ready to serve you and we have a callback to provide errors back to the client in case there are some.

B

So it's running, let's connect to some relay, and here it is so. uh I have already uh uploaded uh this file process files uh web assembly. I did it with the iphone desktop actually and here's the cid and it's deployed so it's deployed. I can remove it and I have this service id.

B

So that's that's nice! Let's get back to the presentation, uh one step back about the fluency plus ipfs integration. uh Is it tight or not? What's about nodes? So, first of all, this integration comes by default, so the default deployment of the fluence node contains ipfs daemon.

B

So there is the fluence node and the ipfs node as a sidecar by default by the way, it's question: what is a sidecar for what, because you can think about the flint's node sidecar to fbfs?

B

But uh finally, you can just use ipfs for storage, and if you you're more about storage, then you can use fluence for computations.

B

Then there is a web assembly package that faces the ipfs node and the ipfs client for aqua and for other services. This is required to ensure security like to avoid the rmrf or something like that.

B

So all the ipfs related code resides here and you can take a look in it, edit it and then reuse it, and then all the services on the fluence node can access files from the file system.

B

uh You can fetch. The file from ipfs is on the file system. Then, and after that, you can use aqua aquascript to move the file from ipfs to the file system of the service to the sandbox and back so um that's the next demo.

B

uh I want to show how you can run computations on the data which is stored on ipfs, so it means that I want to apply the function coded on webassembly to the file which is addressed by ipfscid.

B

The flow is the following. I want to ask the fluence node to apply a function to a cid. Fluence node will ask ipfs node to fetch this file.

B

When this file is provided, it will be used as an input file to be used. um First, it will be moved to the web assembly sandbox as a services influence. I don't have access to the whole file system. uh This access is sandboxed, it's restricted, but you can move to the sandbox.

B

B

The node will run computations on the file, and these computations will finally write another file with the results. Then the node will move this file with the results to ipfs node and ask it to upload it to ipfs. It will return cid and after that the node will return cid to the browser.

B

So let's take a look on how it works here we have the cid of some file or is is the same file that we just deployed and uh we have a very simple function to get the size of the given file. Let's try it so this file was downloaded then moved to the service. uh Then its size was calculated uh and uh this number uh is uh uploaded as a file uh to the ipfs node.

B

uh If you have time in the end, we'll try to apply the different files and ensure that this hash corresponds to to this content.

B

Oh, uh I want to show the code perhaps, but actually it's pretty straightforward. We have this, put the file and get put the file size function and what it does it goes to. The relay gets the file from ipfs. If it succeeds, then it processes the file size with the service. It's if it's okay, then it logs the file size with a cording, writes it to to disk and then uploads the file over ipfs and the result and finally returns results back to the client.

B

So it's just the declarative description of what we want to achieve. Actually.

B

Looks looks quite straightforward to me.

B

Actually functions on the fluence network are addressed by three parts: it's the peer id service id and function name, and you can have a service, a stateful service uh that, for example, backups itself into ipfs, or it could be a stateless service uh that provides several functions uh with uh like holding some invariant uh around the data that it modifies or uh holding some uh access control uh credentials or something like this.

B

But um you can predefine this function, name and say it's always, for example, apply uh and you can predefine the peer id or discover it over the network with some algorithm like any beer that is registered as ready to serve me. Something like that uh and you can have the service id by deploying uh the webassembly package by cid.

B

So, finally, you can have the function type of cid to cid and the function itself can be expressed as a as the cid of the web assembly of the proper interface.

B

So it's very flexible but works awesome with ipfs and it means that you can add computations to cids to ipfs stored files really easily with web assembly influence and you can do, for example, ipld mutations or backups to to ipfs or you can provide indexing or ipfs data and queries or ipfs data on the fluence and so on.

B

So if you want to try aqua, the best way is to do it with a vs code. Dev container, we have one on fluent slab, slash dev container, it provides syntax highlighting we have the aqua language plugin for vs code.

B

All the tooling is already installed, including the aqua compiler and the web assembly compiler for marine, and it contains many tutorials and examples, including those that I've just shown and the fluence network is up and running.

B

It already has a ipfs demons and you can run the node itself if you want to, or you can use the nodes provided by the fluence labs.

B

Speaking about hackathon, we have some prizes.

B

We have usd 1000 prize for the best overall fluent submission from unsubmitted solution as drives file panel, and we have a usd 100 for using aqua in the browser and integrating ipfs to create just any any kind of decentralized application. And it's uh going to be unlimited in numbers and for the details. uh Specific to brother, 3000 hackathon.

B

Take a look on the on the dedicated wrapper flying slabs, slash browser, 3000, hackathon,.

B

And that's all uh here's the link to the aqua compiler wrapper. We have the contextual influence.dev and we have twitter and we have telegram- and probably we have also a room in discord.

B

Hopefully where we are open for the questions and we can provide the support.

B

B

If there are any questions, I'm ready to discuss them and if, if not, I want to try to upload something else to the ipfs node.

B

So this is the cd of the result.

B

Oh, we can calculate the the file size of the result as well is just six bytes.

B

That's calculated just one byte has calculated.

B

It's just the same.

B

B

That's that's the uploaded file. You can get it using ipfs desktop.

B

So, thank you for your attention. uh If any questions I'm here, if not, please ping me on any chat or any channel. Thank you.

B

uh There is question about hackathon participation with a huge application.

B

And it's possible to use it during the hackathon.

A

Okay, great well, thank you again, so much dimitri. um There are links in the chat to find more information about the hackathon and also to get to the discord channel. um For any other questions, you can follow up with dimitri there. Thank you again for joining us today and uh we'll see you at the next one thanks. Everyone.

B

A