If you’re wanting to code in Java (back end) SpringBoot project for this new CMS let me know because we can collaborate. I have a lot done toward this goal.
I’m always a little confused when people refer to a possible “IPFS pinning service”. What functionality are people referring to? Being able to pin the content pointed to by an IPNS record or republishing IPNS records?
I think people are looking for an app or service similar to cloud backup services, image sharing apps, file sharing apps, etc.
They don’t necessarily want to install their own gateway and may not even be a developer. For an end user to “use IPFS” and be assured their stuff is stored on IPFS with IPNS etc, they need some service to do it for them… Sadly there are VERY few such services. Quanta (my little hobby-horse), having it’s own imperfections (haha) is the only “open source” attempt at such a system, which would make it easy for people to run their own instance OR build commercial cloud infrastructure on.
The Quanta demo instance (quanta dot wiki) isn’t usable as a commercial site right now either, but my “idea” is definitely “correct”. I’m doing what needs to be done. I’m just not commercializing it, because I want it open source instead of proprietary.
First of all my no-backend CMS apparently isn’t possible yet, because:
IPFS in browsers have very limited (essentially no) access to the IPFS network.
Yeah, that is an issue that brings an immediate halt to this project. Bummer 
You’re right. There is.
In my future CMS, there will be a Submit button somewhere. In its onClick event handler call-back, I’ll need to do the equivalent of:
ipfs add -r website/ipfs name publish /ipfs/$hash
Whether the phrase “IPNS pinning” includes item 1 or not doesn’t really matter to me, since I already know how to accomplish item 1. For what its worth I thought of it as only meaning item 2.
But I’d also want it to be a remote service so that the js-ipfs node can terminate shortly after 2 has been completed, so that the user can close the web browser.
But it all doesn’t matter if I have to have a backend anyway. I was hoping that js-ipfs was all the backend I was going to need.
In case that wasn’t clear, you can, you just need to relay with a local IPFS node or a pinning service.
Thanks, yes I get that. As I pointed out in the OP the idea was to create a CMS editor that doesn’t need any backend other than js-ipfs. So no local IPFS node. No cron/bash script. Nothing.
I can use a pinning service for the IPFS part when the user (me) changes the website, e.g. via the pinata API. But as we’ve covered, there is no existing “pinning” service for IPNS that will do the required periodic republishing.
So now a “backend” IPFS node is needed to IPNS publish that new cid so that https://www.mysite.tld shows the new content. I can’t even as an alternative let the CMS hold an API key for my DNS provider so it can change the _dnslink TXT record because of same origin policy. (I’m guessing no DNS provider in their right mind would allowing modifying DNS using CORS.) And then I’d (again) need a backend. → Abandon project.
The whole idea was to try to make a CMS (or other dynamic website) that was entirely without a backend. If I have to have a backend process running, there is almost no point in me using IPFS. Then I might as well use a traditional rails, express, SpringBoot, or whatever backend.
Now that I think a little more about it, a pinning service, such as pinata, is also a “backend”. So however one looks at it, there needs to be a backend even if/when js-ipfs fully supports interaction with the IPFS network. To pin IPFS and to periodically republish IPNS. It sure would help if there was a service that could do the periodic IPNS republishing though.
Thanks for your contributions. I understand the problem domain much better now.
2 Likes
Be sure you’ve seen OrbitDB, and also, unrelated to IPFS there’s WebTorrent which I’ve used successfully and is pretty cool too.
I don’t belive so, the issue is that this is implementation details, any documentation about this will get wrong quickly if anyone just make a PR fixing thoses issues.
Im trying to work on this problem. I am implementing it in Go. And I need lots of eyes on it to review if it is how people want it and is the right way to implement it. It is an Open Source project and my plan is to make it both republishing and IPNS following. Here it is: IPNSGoServer
Im actually currently reworking the README to cover more information on why it is important to have. AND the limitations and problems with IPNS. So this post really helped!
I found this to be a very informative discussion on IPNS Understanding guarantees of the improved IPNS over pubsub
1 Like
Hey, Adrian from https://kubelt.com. We’re building the CMS on top of IPFS. We’re live with a couple customers in private beta and are almost ready to launch with some open source tools as services.
Jump on our Matrix channel if you want early access 
1 Like
Looks interesting. Is the entire Kubelt tech-stack open-source, or are there some proprietary or closed-source components in it?
We’re open sourcing all the functional code (SDK, plugins into other CMS like Sanity.io, our own UI and more) in a clojurescript mono repo.
How it works in a nutshell is, we take a CQRS-like pattern to content management and content delivery (reads over IPFS, writes locally and over a gateway for non-functional services) with a user-centric/wallet model.
We’re also hiring!
1 Like
We are running a free IPNS pinning service, its mainly used in the .eth websites ecosystem
see here: https://dwebservices.xyz
If one were willing to host such a service yourself, how to do it?
We have a use case where from an immutable container we need to find a single update to an object in IPFS which will be immutable, and never be modified or updated. And we need a way to find that update in a reasonable time.
So originally we thought we could:
- Create directory in IPFS
- Store data in IPFS
- Create IPNS keypair
- Store IPFS CID and IPNS public key into immutable container
- Do container magic and blockchain anchoring
- Store blockchain address & update based on container magic into directory created in step 1
- Update IPNS record to point to new CID of directory
- Forget IPNS key as it will never be needed again…
We’re ensuring persistence of the IPFS records over a few nodes.
All we would need is to also be able to ensure IPNS those addresses over these same nodes. But we could find no documentation on this, and no commands that seem related…
So can IPNS even deliver long term persistent addressing? How?
It is being discussed for web pages and the like, but given its apparently limited/short life time it does not seem it is actually suitable for that?
I’m kind of curious how one would define an IPNS pinning service? What service is it envisioned to provide?
Permanence for IPNS names / mapping.
Right now, if there is an IPNS name/mapping defined and provided, it is lost in seconds to hours, apparently defined by its time to live. The originating IPFS node may refresh the mapping, but that makes IPNS fully dependent on that single node/cluster. Effectively, in the current approach, IPNS is somewhat more centralised and less redundant than DNS.
What confused me at first is that the use cases mentioned in the IPNS documentation include things like web pages. These usually have longer time horizons than seconds, minutes or hours. So it does not seem like IPNS is really useful for that. It’s therefore not quite clear to me what the actual use case of IPNS could be with that short a mapping period. Perhaps that is one of the reasons it does not seem to be considered a mainstream feature, and its use is apparently largely discouraged.
In essence:
For IPFS objects itself I can make sure any number of nodes keep a copy permanently or for a long period of time. For IPNS there is no such thing to preserve the mapping of /ipns/ to /ipfs/.
Since the concept of providing long-term availability for IPFS data is called “pinning”, it seems intuitive that the equivalent would be “IPNS pinning.”
There seems to be some confusion in general about IPN. You might find this recent thread helpful How do I make my IPNS records live longer? - #10 by danieln
I find the use of the term pinning for IPNS confusing since there already is a term pinning that does something different.
I believe IPNS over the DHT is discouraged but pubsub works quite well.
It seems like there are a lot of separate things being proposed all under the same heading of “better IPNS”
1 Like
Does it, though?
I’m not talking about the underlying technical details. Those are (and should be) largely irrelevant to the people using a solution. In the “IPFS space”, the concept of “pinning” is basically to make data permanent either via a third party service and/or your own node, at a level of redundancy that you get to decide by choosing the right pinning service and/or node / network of nodes.
The underlying problem people are struggling with when talking about IPNS pinning is just that: Make mapping permanent, independent of the local node that you used to upload/generate the mapping.
So one is permanence for IPFS, the other is permanence for IPNS.
I get that those would be achieved in very different ways.
But conceptually, they don’t seem so different to me.
So how does one “switch” to pubsub? And if one does so, does DHT IPNS no longer work? I’ve struggled in the past to find documentation that would explain what it would mean to have “IPNS over pubsub” vs “IPNS over DHT”, to which extent they are perhaps mutually exclusive, and how to configure them.
Thanks for that - it is indeed helpful.
But participants there also seem to struggle with understanding configuration and persistence.
While I definitely have not understood everything perfectly yet, to me DHT vs pubvsub just seems like different distribution / dissemination mechanisms - and therefore orthogonal to the question of permanence (also referred to as “pinning” by many other posters in this forum).
And as for the time frames involved: People talk about hours or days. But for IPNS to truly be useful we’d probably have to be in the range of years, perhaps decades, as mapping gets more important the longer lived information really is. And there is no guarantee that original node will be around for that long.