<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Matt Ober on Medium]]></title>
        <description><![CDATA[Stories by Matt Ober on Medium]]></description>
        <link>https://medium.com/@matt_ober?source=rss-a446d4aefa91------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*BBA8GOSnZIpUr0tk-9oH7Q.png</url>
            <title>Stories by Matt Ober on Medium</title>
            <link>https://medium.com/@matt_ober?source=rss-a446d4aefa91------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 16:48:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@matt_ober/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Dedicated IPFS Networks]]></title>
            <link>https://medium.com/pinata/dedicated-ipfs-networks-c692d53f938d?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/c692d53f938d</guid>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[pinata]]></category>
            <category><![CDATA[immutability]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[ipfs]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Thu, 12 Sep 2019 15:36:25 GMT</pubDate>
            <atom:updated>2019-12-09T19:28:29.529Z</atom:updated>
            <content:encoded><![CDATA[<h4>Scaling Through Network Specialization</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rQ-cdKNeBl49nVVEU-8X2A.png" /></figure><p>Scalability. It’s something we’re constantly thinking about at <a href="https://pinata.cloud/">Pinata</a>. With IPFS’s massive growth and adoption, we need more and more ways to optimize content discoverability via <a href="https://medium.com/textileio/how-the-ipfs-dht-works-47af8bfd3c6a">IPFS’s DHT (Distributed Hash Table</a>). In this post, we will take a look at a couple of challenges faced by IPFS and a potential solution for projects facing performance issues right now.</p><h4>A Lot of Nodes</h4><p>The first scalability challenge with content discoverability has to do with the amount of nodes in the IPFS network. An individual IPFS node frequently announces content to other nodes in the network. This allows other nodes to point to the node hosting that content if anybody ever asks about it, as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/882/0*ZMAz1ww6xyd_ftRs.png" /><figcaption>From: “<a href="https://medium.com/pinata/speeding-up-ipfs-pinning-through-swarm-connections-b509b1471986">Speeding Up IPFS Through Swarm Connections</a>”</figcaption></figure><p>This works great when there’s a reasonable amount of nodes in the IPFS network. However, as the amount of nodes in the network increases, the network tends to slow down. This is because all of the IPFS nodes are using the same DHT to locate data. With the growth of IPFS nodes on the public network, content discovery has started to look more like the diagram below than the one above:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TMsK9AlkeyfV12rEhHfiNg.png" /></figure><p>This node congestion slows down the ability for the DHT to find the node that has the content. Additionally, not all nodes are equally stable. Many of these nodes that join the network can frequently go offline or become unresponsive. This creates additional delays when attempting to route information through the IPFS network. However, the amount of nodes in the network isn’t the only scalability challenge. The amount of content <em>on</em> those nodes is also a challenge.</p><h4>A Lot of Content</h4><p>The second reason IPFS can struggle with efficient content discoverability is the amount of content being announced by nodes in the network. The act of announcing content takes a little bit of time for IPFS nodes. Additionally, these nodes want to announce all of the content they have. However, as nodes start storing more and more content, the DHT records for that content start to expire before the node is able to re-announce that content. As shown below, this backs up the content announcement queue and can lead to a situation where a node can only keep the network aware of a fraction of its content at any given time. So, how does the network scale with an increasing amount of nodes and content?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/947/1*qtARkdvxSRgyeZNG0D50Tw.png" /></figure><h4>Private Networks</h4><p><a href="https://protocol.ai/">Protocol Labs</a> is already putting considerable efforts into scaling the public DHT. But, there is a way for applications to scale their IPFS usage right now. Consider <a href="https://github.com/ipfs/go-ipfs/blob/master/docs/experimental-features.md#private-networks">private IPFS networks</a>.</p><p>Private IPFS networks are fairly simple in nature. Instead of connecting to the main IPFS network, participants in a private IPFS network will only connect to the nodes in that network. Access to these networks is controlled by a private “swarm key” that each member in the network must possess in order to take part.</p><p>To learn more about setting up a private IPFS network, visit <a href="https://github.com/ipfs/go-ipfs/blob/master/docs/experimental-features.md#private-networks">these instructions on github</a>.</p><p>To this point, most private networks have been thought of as a way to add privacy to content. However, they become much more powerful when thought about in the context of network scalability.</p><h3>Dedicated Networks</h3><p>Most applications using the public IPFS network don’t actually care about content hosted by nodes other than their own. And, likewise, most other nodes don’t care about their content.</p><p>By using IPFS’s ability to set up private networks, we can set up “dedicated” networks that consist only of nodes for a specific application’s data. These networks can be private through safeguarding the private access key that allows other nodes to join the network. Or, they can be “public” dedicated networks.</p><p>A “public” dedicated network is a private IPFS network with a publicly known access key. These public, private IPFS networks allow anybody to join them. The difference being that these networks are separated from the main IPFS network to specialize themselves. Nodes who don’t care about the data on these networks have no reason to join them because doing so would be a waste of resources.</p><h4>Scaling Benefits</h4><p>By separating themselves from the main IPFS network, a dedicated IPFS network can realize significant performance gains. The main reason for these performance gains is that nodes in the network will be connected to most, if not all, the other nodes in the network at all times.</p><p>How does this help with performance?</p><p>In a previous post, <a href="https://medium.com/pinata/speeding-up-ipfs-pinning-through-swarm-connections-b509b1471986">Speeding Up IPFS Through Swarm Connections</a>, we talk about how being directly connected to a host node allows a requested node to instantly locate content. This essentially bypasses the DHT lookup process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/881/0*Cqbo1b1pz9hh_LEd.png" /><figcaption>From: “<a href="https://medium.com/pinata/speeding-up-ipfs-pinning-through-swarm-connections-b509b1471986">Speeding Up IPFS Through Swarm Connections</a>”</figcaption></figure><p>This same functionality applies with dedicated IPFS networks. Since most nodes are going to be connected to each other at all times, content discovery happens near instantaneously throughout the entire network. This means no more lengthy lookup times.</p><p>This also solves the issue of too much content being announced from a single node. When directly connected to a host node, it doesn’t matter whether or not that node has had the time to announce that content to the DHT. By being directly connected to the host node, any requesting nodes are still able to instantly discover the content. But, how do we serve the content to the end user if they don’t have an IPFS node?</p><h4>Gateways</h4><p>IPFS gateways can be run on dedicated IPFS networks just like they are on the public network. In fact, gateways work exactly the same with dedicated networks as they do with the main public IPFS network. The only difference is that instead of searching the public IPFS network for data, a gateway on a dedicated network will only search for content on nodes in the dedicated network.</p><p>This becomes a huge selling point for applications that rely heavily on gateways to retrieve content. Instead of a user waiting through a lengthy content discovery progress each time they want to consume data, they can find it near instantly from a dedicated network gateway.</p><h4>Real World Examples</h4><p>Let’s say that we have three decentralized networks, as detailed below:</p><ul><li>A <a href="https://en.wikipedia.org/wiki/Decentralized_autonomous_organization">Decentralized Autonomous Organization</a> that stores and shares all of its files through IPFS</li><li>A network for sharing scientific data over IPFS</li><li>A decentralized exchange that uses IPFS for its order books</li></ul><p>With dedicated IPFS networks, each of these examples can make sure that their data flows as efficiently as possible through their networks without dealing with the outside network noise that they don’t care about. But, what if you want to switch between dedicated networks?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*28UjQJ3FQBwibyZWoe5UAA.png" /></figure><h4>Switching Between Networks</h4><p>Another advantage of using a dedicated IPFS network is the ability to transition to the public network at any time. If, at any point, a node or network of nodes decides that its data wants to become part of the public IPFS network, all that’s required is a few small configuration changes and a node restart. When switching back to the public IPFS network, all of a node’s data will remain safe and unchanged. The only change is that the node will now be participating in the public IPFS DHT again.</p><p>This allows for a relatively easy transition path for applications that may choose the dedicated network approach for performance in the near future, but ultimately would like to participate in the public network as it becomes more performant.</p><p>The same concept works for switching to a different dedicated network. If a node wants to join a different dedicated network, it can simply change its node configuration to point to the new dedicated network.</p><h3>Important Considerations</h3><p>Dedicated IPFS networks provide a lot of power for scaling an application’s usage of IPFS. But, that doesn’t make them right for every project.</p><p>These are important things to keep in mind when considering a dedicated network.</p><h4>Node Configuration</h4><p>Every node that wants to participate in a dedicated network needs to be properly configured to do so. This can become a user experience problem if not properly accounted for.</p><h4>Bootstrapping</h4><p>By default, IPFS nodes are configured to bootstrap themselves to public IPFS bootstrapping nodes run by <a href="https://protocol.ai/">Protocol Labs</a>. To successfully run a dedicated IPFS network, dedicated bootstrapping nodes will need to be run and nodes will need to be configured to connect to them on startup.</p><h4>Public Data Access</h4><p>Nodes participating in a dedicated IPFS network won’t be able to access any data on the public IPFS network. If a network relies on data from the public network that won’t be hosted by users on their dedicated network, this could pose a problem.</p><p>Likewise, nodes on the public network such as public gateways, won’t be able to access data that’s hosted on a dedicated IPFS network.</p><h4>Network Size / Peer Counts</h4><p>One of the biggest performance boosts of a dedicated network comes from the ability of each peer to maintain a connection to every other peer. If a dedicated network becomes too large, or if nodes participating in the dedicated network don’t have powerful enough hardware to connect to a lot of nodes, the performance boost could be minimal.</p><h3>Conclusion</h3><p>Dedicated IPFS networks provide a powerful tool for scaling when an application doesn’t need to participate in the public IPFS network. Leveraging dedicated IPFS networks can provide faster content discovery times for dedicated network nodes. This leads to a better and more stable user experience.</p><p>While dedicated IPFS networks provide many advantages, they won’t be a good solution for every project. There are things that should be considered before transitioning a project to utilizing a dedicated IPFS network. If you have questions about setting up a dedicated IPFS network, be sure to ask in our <a href="https://join.slack.com/t/pinatahq/shared_invite/enQtODM0Mzg3MTk5OTg3LTE5NTBiMTBiOWY2ZTRlYzhjZjAwZjQ0YTkzZjFmZmE2ZWZmMGFhOGM2MTAwZTJlYzRlYzBjMzE0ZDEwM2ZhYzg">community slack</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c692d53f938d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/dedicated-ipfs-networks-c692d53f938d">Dedicated IPFS Networks</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The IPFS / LibP2P Help Desk is coming to ETHBerlin]]></title>
            <link>https://medium.com/pinata/the-ipfs-libp2p-help-desk-is-coming-to-ethberlin-9754fadaf095?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/9754fadaf095</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[pinata]]></category>
            <category><![CDATA[ethberlin]]></category>
            <category><![CDATA[ipfs]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Wed, 14 Aug 2019 17:37:53 GMT</pubDate>
            <atom:updated>2019-08-14T18:24:29.249Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Af5EKfeWbiIqtV3q" /><figcaption><strong>IPFS Help Desk v1</strong></figcaption></figure><p>Hackathons are one of the best parts of the decentralized community. They provide an environment where developers can come learn and share ideas while trying to build amazing things in the process.</p><p>However, hacking things together at the speed of light can be challenging. Nothing is more frustrating than working with new technology and being stuck on something for hours on end while your precious hackathon hours slip by.</p><p>We’ve all been there.</p><p>This year, ETHBerlin is offering hackers a little bit of help for a decentralized tech that many of you are starting to use in your applications: IPFS and libp2p. For those of you unfamiliar with IPFS, or the InterPlanetary File System, it’s a peer-to-peer storage protocol that allows developers to make sure their data is <strong>tamper-proof</strong> and <strong>decentralized</strong>. IPFS is a core tool for many dapps (including Textile Photos, OpenBazaar, DTube, and many others), as well as blockchains (including Civic, Arbore, Origin, etc) to address and organize their data within a fully distributed network.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1evtfdYDf6OvfIfq" /><figcaption><strong>The IPFS Ecosystem</strong></figcaption></figure><p>IPFS runs atop libp2p, a powerful, modular networking stack to build p2p networks that solves hard challenges such as encryption, transport selection, NAT traversal, multiplexing, peer discovery, routing, and more. In addition to IPFS, libp2p is used by Ethereum 2.0, Filecoin, Polkadot, 0x, and various other large-scale projects looking to assemble unstoppable networks.</p><p>To help developers quickly hop over hurdles and get back to building awesome hacks, ETHBerlin will have a dedicated IPFS/libp2p help desk that’s available for hackers to come visit during the hackathon.</p><p>Have a question about anything IPFS or libp2p related? Our volunteers would love to help! They’ll also be on hand to answer general questions about IPFS and libp2p and provide their own takes on how you can use this awesome technology.</p><p>Have a hackathon idea that you think could benefit from decentralized storage? They can help you scope it out! And if these folks don’t know the answer, they’ll figure out who does.</p><h3>Meet the IPFS/libp2p Help Desk Team</h3><p>The whole team is also part of the broader ETHBerlinZwei Mentors program, so they are available to provide on site, and ‘virtual’ mentoring. To give you an idea of who you can expect to see there, here’s the team:</p><h4><a href="https://github.com/obo20">Matt Ober</a></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/373/1*cY7X2Gs_-tOAmfvaU5Pz6w.png" /></figure><p><a href="https://twitter.com/MattOber1">Matt</a> is the CTO / CoFounder of <a href="https://pinata.cloud/">Pinata</a>, an IPFS pinning service that projects can use to host or mirror content on the IPFS network. Pinata was born out of the first ETHBerlin and Matt is excited for the opportunity to help hackers with all things IPFS at this year’s ETHBerlin. He loves hearing about crazy ideas and is excited to help bring yours to life!</p><h4><a href="https://github.com/carsonfarmer">Carson Farmer</a></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/436/1*XdBgM1cjr5rRjCl0VyQ9Pw.png" /></figure><p><a href="https://twitter.com/carsonfarmer">Carson</a> is a core developer and community wrangler for <a href="https://textile.io/">Textile</a>, which is a set of open source tools/technologies that provide a decentralized database, remote storage, user management, and more over the IPFS network (on desktop and mobile!). Carson has been working with IPFS-related technologies for a while now, and has written about the topic extensively on the Textile blog. He can help you with all things Textile, IPFS, Javascript, Go, and might even share some parenting hacks he’s learned along the way if you ask nicely 😜.</p><h4><a href="https://github.com/raulk">Raúl Kripalani</a></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/543/1*dRyNLZuExAimRBpsa3M7Jg.png" /></figure><p>Raúl is the tech lead for the libp2p project at Protocol Labs. He loves listening to novel, loopy ideas and helping steer them towards fruition. If you’re all set on your grand vision for the next big thing, but need to sketch out the p2p network aspects of it, he is your guy. Whether you’re knowledgeable and simply seek confirmation on your design, or if you’re totally clueless to begin with, he’ll be happy to help!</p><h4><a href="https://github.com/hsanjuan">Héctor Sanjuán</a></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/524/1*9dKd8cjy1EvTOr4hAMGAsg.png" /></figure><p>Héctor is the IPFS Cluster project lead at Protocol Labs. He is used to working with many parts of the go-ipfs and libp2p stack and combining them to produce new applications. If you are looking to understand which part does what, how to quickly plug some components together, or what pieces you can take advantage of for your application, you can talk to Hector.</p><h4><a href="https://github.com/vasco-santos">Vasco Santos</a></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/509/1*73wMbIRgTNNfjBrIsIESzA.png" /></figure><p>Vasco is a software engineer at MOXY and is part of the libp2p core engineering team, who has been contributing to the Javascript implementations of libp2p and IPFS. He is a technology enthusiast who aspires to build software to make the world a better place. Either if you are looking to understand how any subsystem of libp2p works, or you want to discuss more specific js-libp2p design or implementation, you can reach Vasco and he will be there to assist.</p><p>This blog post was community written and cross-posted on Textile’s blog <a href="http://blog.textile.io/ipfs-libp2p-help-desk-coming-to-ethberlin">here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9754fadaf095" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/the-ipfs-libp2p-help-desk-is-coming-to-ethberlin-9754fadaf095">The IPFS / LibP2P Help Desk is coming to ETHBerlin</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Easily Host a Website on IPFS]]></title>
            <link>https://medium.com/pinata/how-to-easily-host-a-website-on-ipfs-9d842b5d6a01?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d842b5d6a01</guid>
            <category><![CDATA[cloudflare]]></category>
            <category><![CDATA[web-hosting]]></category>
            <category><![CDATA[ipfs]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[pinata]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Fri, 14 Jun 2019 18:54:24 GMT</pubDate>
            <atom:updated>2019-06-18T20:17:27.963Z</atom:updated>
            <content:encoded><![CDATA[<h4>A step by step guide to easily host Angular, ReactJS, or VueJS apps on IPFS using Cloudflare and Pinata</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9x9oSZsRVBWzCcGhIDAolw.png" /></figure><p><a href="https://www.cloudflare.com/">Cloudflare</a> and <a href="http://pinata.cloud/">Pinata</a> are teaming up to bring you a blog post surrounding website hosting on the InterPlanetary File System (IPFS)!</p><p><a href="https://www.cloudflare.com/">Cloudflare</a> has been operating an<a href="https://blog.cloudflare.com/distributed-web-gateway/"> IPFS gateway</a> since last year and has seen amazing usage and feedback from the decentralized web community. In addition to the IPFS gateway, Cloudflare also has hassle-free SSL certificates for you while hosting websites on IPFS using the gateway.</p><p><a href="https://pinata.cloud/">Pinata</a> is the easiest way to use IPFS by providing fast and reliable infrastructure and tools to store content on the IPFS ecosystem.</p><p>This post will dive into how you can host a website on IPFS and how to keep it online using a combination of Cloudflare and Pinata.</p><p>But, before jumping straight to the tutorial, it’s important to understand what’s happening behind the scenes when people talk about hosting a website on IPFS.</p><h3>How Does Hosting a Website on IPFS Work?</h3><p>Hosting a website on IPFS requires two things:</p><ul><li>A source node that has the website <a href="https://docs.ipfs.io/guides/concepts/pinning/">pinned</a> on IPFS.</li><li>A retrieval node for you to retrieve the website from IPFS. For most people, this often takes the form of an <a href="https://github.com/ipfs/go-ipfs/blob/master/docs/gateway.md">IPFS gateway</a>.</li></ul><h4>Source Nodes</h4><p>A source node is where content is initially added to and made available to the rest of the IPFS network. As other nodes begin requesting the desired content, the source node is where they will initially retrieve it from.</p><h4>Gateway Nodes</h4><p>In order to retrieve desired content from the IPFS network, you need to have access to an IPFS node. This node will provide the IPFS network with the cryptographic hash of the content it wants and the IPFS network will find a node with a copy of the content to provide back to the retrieval node.</p><p>While this retrieval node could be one running locally on your computer, for many of you, a retrieval node will take the form of an IPFS gateway. Gateways are essentially IPFS nodes that allow you to retrieve content from IPFS without hosting an IPFS node yourself. IPFS gateways do this by allowing anyone to retrieve content from IPFS by using a link typically formatted like this:</p><p><a href="https://gateway.pinata.cloud/ipfs/QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ/">https://gateway.pinata.cloud/ipfs/QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ/</a></p><p>The “QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ” part of the link above is the Content-Identifier (CID) that’s being asked for. It’s important to realize that you could retrieve that same content by visiting any public gateway, not just one run by <a href="https://pinata.cloud/">Pinata</a>. For example, try retrieving that CID at the following public gateways:</p><ul><li><a href="https://cloudflare-ipfs.com/ipfs/QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ">https://cloudflare-ipfs.com/ipfs/QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ</a></li><li><a href="https://ipfs.io/ipfs/QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ">https://ipfs.io/ipfs/QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ</a></li></ul><p>Notice how you retrieve the same content from each gateway? That’s because the CID provided to each gateway was the same. When you visited each gateway, it searched the IPFS network until it found the content for the CID “QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ”. Once that content was found, the gateway provided it back to you in your web browser.</p><p>Make sense? Awesome! Now that you’ve learned a little bit about what’s going on behind the scenes, let’s get to the tutorial!</p><h3>How to Prepare Your Website for IPFS</h3><p>Hosting a website on IPFS is slightly different than hosting it on a web server out in the cloud. Your website may require a little bit of tweaking in order to properly be served on the IPFS network.</p><p>The important rules are:</p><ul><li>All of the content for your website must be contained in one build folder, with an index.html file.</li><li>All links within your files should be relative links.</li></ul><p>If you’re working with a javascript framework, things can be a little trickier. Here’s how you get three popular frameworks, <a href="https://angular.io/">Angular</a>, <a href="https://reactjs.org/">ReactJS</a>, and <a href="https://vuejs.org/">VueJS</a>, working with IPFS.</p><h4>Angular:</h4><p>For the purposes of this tutorial, it’s assumed that you have a working <a href="https://angular.io/">Angular</a> app. If you do not, check out the <a href="https://angular.io/guide/quickstart">Angular Quick Start Guide</a> for more info.</p><p>To prepare your Angular app, open up your application’s index.html in the src folder of your app. In the index.html, change the &lt;base href&gt; tag to:</p><pre>&lt;script&gt;<br>     document.write(&#39;&lt;base href=&quot;&#39;+window.location.pathname+&#39;&quot;/&gt;&#39;);<br>&lt;/script&gt;</pre><p>Once you’ve made this change, build your app by running the following in the root of your project directory:</p><pre>ng build --prod --aot</pre><p>You should now have an updated IPFS compatible build in the “dist” folder of your Angular app.</p><p>Here’s an example of an IPFS compatible Angular app:</p><ul><li><a href="https://github.com/PinataCloud/Angular-IPFS-Example">Github Example</a></li><li><a href="https://gateway.pinata.cloud/ipfs/Qmf6UXZ3EJET8VYM8dqeRe2J3c7AXebyfCQ41VDLt77aiy/">IPFS Gateway Link</a></li></ul><h4>ReactJS:</h4><p>For the purposes of this tutorial, it’s assumed that you already have a working <a href="https://reactjs.org/">React</a> app. If you don’t, you can easily create one with <a href="https://github.com/facebook/create-react-app">Create-React-App</a>.</p><p>In the root directory of your React application, open up the package.json file and add the following entry to the top of the file:</p><pre>&quot;homepage&quot;: &quot;./&quot;,</pre><p>Once you’ve made this change, build your app by running the following in the root of your project directory:</p><pre>npm run build</pre><p>You should now have an updated IPFS compatible build in the “build” folder of your React app.</p><p>Here’s an example of an IPFS compatible React App</p><ul><li><a href="https://github.com/PinataCloud/React-IPFS-Example">Github Example</a></li><li><a href="https://gateway.pinata.cloud/ipfs/QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ/">IPFS Gateway Link</a></li></ul><h4>VueJS:</h4><p>For the purposes of this tutorial, it’s assumed that you already have a working <a href="https://vuejs.org/">Vue</a> app. If you don’t, you can easily create one with <a href="https://cli.vuejs.org/">Vue CLI</a>.</p><p>In the root directory of your Vue application, create a file called “vue.config.js”. In this file put the following:</p><pre>module.exports = {<br>    publicPath: &#39;./&#39;<br>};</pre><p>Once you’ve made this change, build your app by running the following in the root of your project directory:</p><pre>npm run build</pre><p>You should now have an updated IPFS compatible build in the “dist” folder of your Vue app.</p><p>Here’s an example of an IPFS compatible Vue App</p><ul><li><a href="https://github.com/PinataCloud/Vue-IPFS-Example">Github Example</a></li><li><a href="https://gateway.pinata.cloud/ipfs/QmXHmZuhmLX6wjtnTuByH1w12k4UWPNEgyW2WUyxbYudAE/">IPFS Gateway Link</a></li></ul><h3>Adding the Website to IPFS</h3><p>Now that you have our website prepared, you can move to the fun part. Hosting the website on IPFS.</p><p>When hosting on IPFS, it’s important to keep in mind that IPFS isn’t a magical cloud that will store your data forever. In order for content to be reachable by other nodes on IPFS, a node with that content needs to be connected to other nodes on the network.</p><p>This means that when hosting your website on IPFS, you need to make sure whatever node you’re hosting your content on should be online at all times. For this, you have two options:</p><h4>The Easy Way</h4><p>For those of you who aren’t looking to maintain your own dedicated server to run an IPFS node, <a href="https://pinata.cloud/">Pinata</a> provides an easy alternative. If you haven’t signed up for an account, you can do so for free at: <a href="https://pinata.cloud/signup">https://pinata.cloud/signup</a>.</p><p>Once you have an account, visit the <a href="https://pinata.cloud/pinataupload">Pinata Upload page</a> and go to “Upload Directory”. From here, simply browse your local machine for the directory containing your website’s build and click “Upload”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/525/1*wfiP3jIT3obpeXYNKq7lsg.png" /></figure><p>Once the upload is finished, visit the <a href="https://pinata.cloud/pinexplorer">Pin Explorer</a>. You should see the record for your website at the top of the list.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HsP9DiU0eWXRMY-qq8uwOg.png" /></figure><p>Go ahead and take note of the “IPFS Hash” and move on to the next step!</p><h4>The Hard Way</h4><p>Self-hosting a node on a cloud provider is a good option if you are looking to do everything yourself. If you are looking to go down this path, you can read our guide for the full setup process: <a href="https://medium.com/pinata/how-to-deploy-an-ipfs-node-on-digital-ocean-c59b9e83098e">How to Deploy an IPFS Node on Digital Ocean</a>.</p><p>Once you have the node up and running, you’ll need to transfer your website’s build directory to the remote machine hosting your node. You can do this using <a href="https://kb.iu.edu/d/agye">SCP</a> by running the following command on your local machine in the directory that contains your websites build folder:</p><pre>scp -r yourBuildFolder username@remoteAddress:pathOnRemoteMachine</pre><p>From here, you can add the folder to IPFS by running the following command on the remote machine hosting your IPFS node:</p><pre>ipfs add -r /path/to/directory-with-your-website</pre><p>Look for the last hash that is output. This will be your website’s hash on IPFS.</p><p>If this worked, congratulations, you can now move on to the next step!</p><h3>Double-Check That Your Website Works on IPFS</h3><p>Before you do anything else, double-check that your website works correctly on IPFS. To do so, visit: https://gateway.pinata.cloud/ipfs/yourWebsiteHash to confirm the website loads correctly.</p><p>If you receive what looks like a file explorer by visiting your hash on a gateway, it’s likely that your application has some custom code that will need to be tweaked in order to work with IPFS.</p><h3>Improve Your Website with a Domain and Cloudflare</h3><p>At this point in the guide, you should be able to reach your website by visiting a gateway like so:</p><p>https://gateway.pinata.cloud/ipfs/yourWebsiteHash</p><p>But, IPFS hashes aren’t very human readable and chances are you don’t want to type out something like, <a href="https://gateway.pinata.cloud/ipfs/QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ/">https://gateway.pinata.cloud/ipfs/QmWcLKHWqrRB95zQnb4vX8RRgoGsVm5YAUHyZyiAw4mCMQ/</a>, every time you visit your website. So, what can you do to make this better?</p><p>You can put your website behind a domain name! Go ahead and buy one real quick. Got one? Great! Now that you have your very own domain name, let’s learn what’s needed to put your IPFS website behind it.</p><h4>Cloudflare as a Gateway Provider</h4><p>To put a website hosted on IPFS behind a domain name, you need an IPFS gateway. For this guide we’re going to use <a href="https://www.cloudflare.com/">Cloudflare</a> as a service provider to put our website behind a domain name.</p><p><a href="https://www.cloudflare.com/">Cloudflare</a> currently provides a dedicated IPFS gateway service as part of its platform. What makes Cloudflare’s gateway different, is its ability to leverage Cloudflare’s <a href="https://www.cloudflare.com/network/">global network of 150+ data centers</a> as a caching layer. This means that content cached on Cloudflare’s gateway will resolve quickly no matter where you are in the world.</p><p>Another benefit that Cloudflare’s provides is the ability to put your website behind HTTPS in a super easy way. If you are new to website hosting, this means that your user’s traffic will be encrypted between their computer and Cloudflare’s gateway. As a result, browsers will treat your website as more secure and you’ll even get a bump in search engine’s like google as your website is deemed safer for users to visit.</p><h4>Setting Up Your DNS Records to Point to Cloudflare</h4><p>To hook your domain name up to Cloudflare and point it to your IPFS website, the following steps need to be taken:</p><ol><li>Go to where you purchased your domain name. There should be an area to manage “DNS records” for your domain name.</li><li>Edit the records so that you have two entries:</li></ol><ul><li>A CNAME record for your your.domain with a value of <a href="http://www.cloudflare-ipfs.com/">www.cloudflare-ipfs.com</a></li><li>A TXT record for _dnslink.your.domain with a value of dnslink=/ipfs/yourWebsiteHash</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/633/1*88AaVDwvK_LSxACjOetITQ.png" /></figure><h4>Securing Your Website with Cloudflare</h4><p>Now that your DNS records are pointing to Cloudflare’s gateway, you should be able to view your website by going to your.domain . But there’s one more step you should take before finishing up and that’s applying a free SSL certificate to your website.</p><p>Cloudflare makes this super easy. All you have to do is go to <a href="https://www.cloudflare.com/distributed-web-gateway/">https://www.cloudflare.com/distributed-web-gateway/</a> and scroll to the bottom of the page to where you should see this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DgAEZHkcTasOrg4-4hj_rw.png" /></figure><p>Once you’re there, simply enter in the domain name for your website and hit “Submit”. If you see a message saying “Certificate is live”, congratulations, you’re finished!</p><p>As an example of a finished website, check out <a href="https://deploypinata.com/">https://deploypinata.com/</a></p><h3>Troubleshooting</h3><p>Here’s a few common issues you may run into and how to solve them</p><h4>Gateway Fails to Find Your Website on IPFS</h4><p>The IPFS network is getting bigger and bigger every day. Sometimes, it can take awhile to find content. If a particular gateway is unable to retrieve your website, there’s a good chance it’s being overloaded from too many people requesting content at once. Try waiting awhile before attempting to retrieve your content on that gateway again.</p><h4>You Received “Error: Failed to build request to hostname.” When Submitting Your Domain to Cloudflare for the SSL Cert.</h4><p>If you receive this message after you submit your domain name to Cloudflare, double check and make sure that you’re only submitting your.domain into the text field. Inputs such as http://your.domain or your.domain/ won’t work. For example our example website, <a href="https://deploypinata.com/">https://deploypinata.com/</a>, needed to be entered in as deploypinata.com .</p><h4>You Received “Certificate is live” but the HTTPS Version of Your Website Isn’t Working</h4><p>Sometimes these things can take a little bit of time to propagate. Give it about an hour before contacting Cloudflare.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d842b5d6a01" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/how-to-easily-host-a-website-on-ipfs-9d842b5d6a01">How to Easily Host a Website on IPFS</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[IPFS Privacy]]></title>
            <link>https://medium.com/pinata/ipfs-privacy-711f4b72b2ea?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/711f4b72b2ea</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[decentralization]]></category>
            <category><![CDATA[pinata]]></category>
            <category><![CDATA[ipfs]]></category>
            <category><![CDATA[privacy]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Fri, 05 Apr 2019 13:33:23 GMT</pubDate>
            <atom:updated>2019-04-05T13:33:23.566Z</atom:updated>
            <content:encoded><![CDATA[<h4>How Private is IPFS?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dsBg_-Ke7fqiP41M9oCZsw.png" /></figure><h3>A Misconception of Privacy</h3><p>While IPFS itself is a public network, a common misconception we see from <a href="https://pinata.cloud/">Pinata</a> users is that IPFS is private if they don’t explicitly share the hashes (also known as CIDs) for content they’ve stored.</p><blockquote>Unfortunately this isn’t the case.</blockquote><p>When adding content to the IPFS network, the node storing that content gives back a hash that can later be provided to any IPFS node to retrieve the content that was originally uploaded. Without understanding the internal workings of IPFS, it might seem like this hash behaves like a private link (If the hash isn’t shared with the public, then nobody would know it exists).</p><p>For now, this somewhat works. But, this isn’t because IPFS is inherently private. Rather, this is due to the fact that IPFS is still young and people haven’t implemented tools for monitoring the network.</p><h4>How IPFS Hashes Become Public</h4><p>IPFS, like many distributed data storage technologies, uses what’s called a <a href="https://en.wikipedia.org/wiki/Distributed_hash_table">Distributed Hash Table</a> (a DHT for short).</p><p>In practice, this means that when an IPFS node <a href="https://docs.ipfs.io/guides/concepts/pinning/">pins</a> new content, it announces that it has the content to all of the peers it’s connected to. It does this so that the IPFS network knows where to find the content it has. The more peers the original node sends content announcements to, the more discoverable that content is.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/552/1*_ssyAdgMpLb8-CaqaSUIMQ.png" /><figcaption>IPFS node announcing content</figcaption></figure><p>To most of the world, these content announcements happen behind the scenes and are just part of how the IPFS network works. However, depending on a company’s business model, these content announcements might be quite valuable, and as such, they would be incentivized to record as many of these announcements as possible.</p><h4>Logging Hashes</h4><p>For companies looking to keep track of this data, all that’s required to track the data is a slight modification to their IPFS nodes. This tweak would simply add code that logs each DHT announcement instead of letting DHT records expire like they normally do.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/769/1*UwbFma86REPwxKlhBq4ICg.png" /><figcaption>Modified nodes logging content announcements</figcaption></figure><p>Since this strategy requires logging nodes to be connected to announcing nodes, it is most effective when attempting to log announcements coming from specific nodes. In order to log the entire IPFS network as a whole, you’d need to maintain a connection to every IPFS node that’s storing content. Such a feat would require a huge network of extremely powerful nodes spread all around the world.</p><h4>Users Can Be Tracked Too</h4><p>It’s not just the host nodes that can be tracked. Users requesting content can be tracked, too! When a user running a node requests content from the network, each node they’re connected to receives a message asking for that content.</p><p>Similarly to how content announcements can be logged, content requests can be logged as well. In fact, if a node doesn’t have the content requested, that node will relay that request to other nodes in an attempt to find the content, which means an even greater number of nodes have the potential to log the information.</p><h3>How Can IPFS Be Private?</h3><p>Let’s talk about a few ways that you can utilize IPFS while still remaining private. Each method has its own pros and cons.</p><h4>Private IPFS Networks</h4><p>Private IPFS networks provide the greatest level of privacy from the outside world. A private IPFS network behaves the same as the public network except participants are only able to communicate with other nodes inside that same private IPFS network. This means that only those nodes in the private network will be able to see things like content announcements / content requests.</p><p>In order to connect to a private IPFS network, nodes will need private access keys for that private network. When running a private network, be careful who you give access keys to. If these keys fall into the wrong hands your network security and privacy will be compromised.</p><h4>Content Encryption</h4><p>Applications that wish to maintain usage of the public IPFS network may wish to consider adding encryption to content they upload to the IPFS network. Encrypted content can still be tracked, but the main difference is that without a decryption key, the content will be unreadable.</p><p>For applications using encryption, it’s important to keep in mind that as content is public, malicious nodes could potentially save encrypted content in hopes that they either somehow obtain the decryption keys, or the encryption mechanism is broken at some point in the future. For this reason, it’s important to make sure any decryption keys are highly guarded and to never upload content that could have disastrous consequences if the encryption is ever broken.</p><h4>Gateway Usage</h4><p>I’ve talked about public gateways a <a href="https://medium.com/pinata/the-ipfs-gateway-problem-64bbe7eb8170">bit in the past</a>. While they definitely <a href="https://medium.com/pinata/the-ipfs-gateway-problem-64bbe7eb8170">have their own issues</a> concerning scalability, that doesn’t mean gateways are all bad. In the context of privacy, they remain a useful tool for users looking to hide their identify while requesting content on the IPFS network.</p><p>Requesting content through a public gateway allows a user to retrieve content from the IPFS network without running their own node. While the rest of the network can still see the gateway requesting the content, the request will simply appear as one of many requests coming through that gateway.</p><p>Keep in mind public gateways could be tracking public IPs and the content those IPs request. If you’re concerned about public gateways tracking your information, you’ll have to look further to preserve privacy while using public gateways.</p><h3>Key Takeaways</h3><p>When using IPFS, it’s important to realize that you’re utilizing a public network. Anything that happens on the public IPFS network is technically trackable and people uploading content should do so with the understanding that their content can be viewed, monitored, or saved by anybody.</p><p>With that being said, there are methods to preserving privacy on IPFS. Each with their own pros and cons. Things like private IPFS networks, content encryption, and gateway utilization act as valuable tools for increasing privacy while using IPFS. As with most technologies, everybody’s individual needs will likely differ, so it’s important that applications weigh the pros and cons of various privacy approaches against their specific user needs.</p><p>If you are interested in more conversations around this subject, feel free to join the Pinata <a href="https://join.slack.com/t/pinatahq/shared_invite/enQtNDc2MzMxMjE0MzkwLTU0NTc4YjY1NTQ4ZjRjNjJhZTNkY2ZhNjNjNTk0MzhkYjllMDBjNWZmN2U0MDZmYmI5Mjc5ZTkxNTI0YWMwYjY">slack</a> or reach out to me on twitter <a href="https://twitter.com/MattOber1">@MattOber1</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=711f4b72b2ea" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/ipfs-privacy-711f4b72b2ea">IPFS Privacy</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Speeding Up IPFS Pinning Through Swarm Connections]]></title>
            <link>https://medium.com/pinata/speeding-up-ipfs-pinning-through-swarm-connections-b509b1471986?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/b509b1471986</guid>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[decentralization]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[ipfs]]></category>
            <category><![CDATA[pinata]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Mon, 04 Mar 2019 15:17:12 GMT</pubDate>
            <atom:updated>2019-03-04T15:18:44.623Z</atom:updated>
            <content:encoded><![CDATA[<h3>Speeding Up IPFS Through Swarm Connections</h3><h4>Building Direct Connections Through Swarm Connect</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ti1X7U25A0AMii0rjOX5Vg.png" /></figure><p>This week brings new functionality to a commonly used part of the <a href="https://pinata.cloud/">Pinata</a> platform: our <a href="https://pinata.cloud/documentation#PinHashToIPFS">pin by hash functionality</a>.</p><p>I wanted to take some time to explain this new functionality and dive into the IPFS mechanics surrounding this update.</p><p>Without further ado, let’s dive in.</p><h3>IPFS pinning — How it works</h3><p>There are two main ways to pin content on an IPFS node:</p><ol><li><strong>Adding a local file to an IPFS node:</strong> Adding a local file is how content first becomes part of the IPFS network and is what happens when you upload a file to pin using our <a href="https://pinata.cloud/documentation#PinFileToIPFS">pinFileToIPFS</a> endpoint. Essentially, we receive your file via our API and then send it directly to our nodes to be pinned.</li><li><strong>Retrieving content by its hash (Content-Identifier) and pinning it: </strong>IPFS also allows you to pin content that exists on the IPFS network but doesn’t reside locally on your machine. This is what happens when you utilize our <a href="https://pinata.cloud/documentation#AddHashToPinQueue">addHashToPinQueue</a> or <a href="https://pinata.cloud/documentation#PinHashToIPFS">pinHashToIPFS</a> endpoints and is the use case we’ll be focusing on in this article.</li></ol><h3>Pinning by Hash — A deeper look</h3><p>A quick reminder: When a file is added to an IPFS node, the node returns a Content-Identifier (CID) for the file. The CID that is returned from the IPFS node is the direct result of running the file through a <a href="https://github.com/multiformats/multihash">cryptographic hash function</a>. Because of this, the CID is commonly referred to as the content’s “hash” and is how we’ll be referring to the CID for the rest of this article.</p><h4>The DHT</h4><p>When a node is connected to the IPFS network, the content that node has is frequently broadcasted over the IPFS Distributed Hash Table (DHT). This means the node is telling all the other nodes that it has certain content. This makes it so that if anybody asks those nodes for that content, they’ll know which node to point the requesting node towards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/882/1*39d6L3tEO7v8EzvmgTYINA.png" /></figure><h4>MultiAddresses</h4><p>A key concept to understand here is that when a node “searches for content” by using the DHT, it’s really searching for who has that content. The requesting node uses the DHT to find out which nodes have the content it’s looking for and where those nodes are located at. If the requesting node is able to find a node with the content it’s looking for, the IPFS network will eventually provide back the “multiaddress” of that node hosting the desired content. The multiaddress looks something like this:</p><pre>/ip4/123.456.78.90/tcp/4001/ipfs/QmAbCdEfGhIjKlMnOpQrStUvWxYzAbCdEfGhIjKlMnOpQr</pre><p>Multiaddresses can vary in format, hence the “multi” part of “multiaddress”, but the important thing to note is that the multiaddress provides the requesting node with a few things:</p><ul><li>Which protocols to use to communicate with the node</li><li>The IP location of the node</li><li>Which port the node can be reached at</li><li>The unique Peer ID of the node</li></ul><p>We’ll talk more about how to find your node’s multiaddress in a bit. But, for now, let’s talk about why this address is important.</p><h4>Content Retrieval</h4><p>As mentioned above, requesting nodes use the DHT to find the multiaddress of peers that host content they’re looking for. Once they’ve found this multiaddress, the requesting node directly connects to the host node via IPFS’s <a href="https://docs.ipfs.io/reference/api/cli/#ipfs-swarm">“swarm”</a> functionality and starts retrieving the content.</p><p>Similarly to how requesting nodes use the DHT to locate content they want to consume, nodes who want to pin content that already exists on the network also use the DHT to locate content they’re looking to pin.</p><p>A common issue with this is that it can often take awhile to find which node is hosting the content.</p><p>There are a variety of reasons for this. Two common causes are:</p><ul><li>The hosting node has just recently connected to the IPFS network</li><li>The hosting node is connected to very few other nodes</li></ul><p>Both of these problems stem from the fact that there are often quite a few degrees of separation between the node requesting the content and the node hosting that content.</p><p>Wouldn’t it be great if we could speed up this process?</p><h3>Speeding up content discovery</h3><p>If the owner of a requesting node already knows that content is stored on a specific node, it doesn’t make much sense for that node to traverse the DHT to find out which node has that content.</p><p>Luckily, IPFS allows us to manually connect to nodes that we already know about. I talk about this mechanism in a previous <a href="https://medium.com/pinata/how-to-keep-your-ipfs-nodes-connected-and-ensure-fast-content-discovery-7d92fb23da46">post</a>. To give a quick recap: if we know the multiaddress of an IPFS node, we can manually connect to it using IPFS’s <a href="https://docs.ipfs.io/reference/api/cli/#ipfs-swarm-connect">“swarm connect”</a> functionality.</p><h4>So what does this gain us?</h4><p>With a direct connection, the requesting node has a “fast-lane” for content discovery on the host node. When the requesting node sends out a request for content, instead of having to wait for its peer nodes to find out who is hosting that content, one of those peers will actually be the node hosting the content. This allows for a near instant response time. Once the requesting node finds out that the host node has the content it desires, it will retrieve the content for pinning.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/881/1*bUqhjNl_OOVpm-SzvyoI7Q.png" /></figure><p>In this scenario we’ve cut out a significant amount of initial time that the requesting node would have otherwise spent searching for the location of the content it desired.</p><h3>How this was implemented in Pinata</h3><p>Our new functionality this week can be seen in our <a href="https://pinata.cloud/documentation#AddHashToPinQueue">addHashToPinQueue</a> or <a href="https://pinata.cloud/documentation#PinHashToIPFS">pinHashToIPFS</a> endpoints. Now, when providing a hash to pin, you can provide the multiaddress of up to five nodes that your content already resides on.</p><p>If our API notices that you provided host nodes as part of your request, we’ll directly connect to those nodes before attempting to pin your content! This allows us to take advantage of the speed benefits mentioned earlier in this article by cutting out the node discovery process of pinning content.</p><h4>Finding your multiaddress</h4><p>To find the multiaddress of a node you’re running simply run:</p><pre>ipfs id</pre><p>Your response should look something like this:</p><pre>{</pre><pre>&quot;ID&quot;: &quot;NodeID&quot;,</pre><pre>&quot;PublicKey&quot;: &quot;NodePublicKey&quot;,</pre><pre>&quot;Addresses&quot;: [</pre><pre>&quot;/ip4/127.0.0.1/tcp/4001/ipfs/NodeID&quot;,</pre><pre>&quot;/ip4/XXX.XXX.XXX.XXX/tcp/4001/ipfs/NodeID&quot;,</pre><pre>&quot;/ip6/::1/tcp/4001/ipfs/YourNodeID&quot;,</pre><pre>&quot;/ip6/YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY/tcp/4001/ipfs/NodeID&quot;,</pre><pre>&quot;/ip6/YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY/tcp/4001/ipfs/NodeID&quot;,</pre><pre>&quot;/ip6/YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY/tcp/4001/ipfs/NodeID&quot;,</pre><pre>&quot;/ip4/XXX.XXX.XXX.XXX/tcp/4001/ipfs/NodeID&quot;,</pre><pre>],</pre><pre>&quot;AgentVersion&quot;: &quot;go-ipfs/0.4.17/&quot;,</pre><pre>&quot;ProtocolVersion&quot;: &quot;ipfs/0.1.0&quot;</pre><pre>}</pre><p>In the response you should see an “Addresses” array that lists the different multiaddresses for your node. Depending on your network configurations you’ll likely have a few entries listed, but the one you’ll want to take note of is the entry that contains your machine’s “external” IP address. To double check your machines external address, check out <a href="https://www.whatismyip.com/">this handy tool</a> or run the following in your server’s command line:</p><pre>dig +short myip.opendns.com @resolver1.opendns.com</pre><h4>How to provide host nodes as part of your request</h4><p>To provide the multiaddresses of your host nodes as part of your <a href="https://pinata.cloud/documentation#AddHashToPinQueue">addHashToPinQueue</a> or <a href="https://pinata.cloud/documentation#PinHashToIPFS">pinHashToIPFS</a> request, simply add the “host_nodes” property to your request POST body like so:</p><pre>{<br>    hashToPin: (Your Content&#39;s Hash Goes Here),<br>    host_nodes: [<br>        /ip4/host_node_1_external_IP/tcp/4001/ipfs/node_1_peer_id,<br>        /ip4/host_node_2_external_IP/tcp/4001/ipfs/node_2_peer_id,<br>        .<br>        .<br>        .<br>    ]<br>}</pre><p>And that’s it! By providing the multiaddresses for your host nodes, you can enjoy noticeably faster pinning times for content you’re already hosting. This speed improvement will be especially noticeable for customers attempting to pin content on nodes that have just recently connected to the network or nodes with a low peer connection count.</p><h3>Conclusion</h3><p>In situations where it’s already known which nodes are hosting desired content, content retrieval / pinning time can be significantly lowered by having the receiving node make a manual IPFS swam connection to host nodes before pin attempts are made. This removes the need for the receiving node to search for host nodes through the IPFS DHT before retrieving content.</p><p>As always, feel free to comment or reach out to me at @<a href="https://twitter.com/MattOber1">MattOber1</a> on twitter if you have any questions on this post or IPFS in general!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b509b1471986" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/speeding-up-ipfs-pinning-through-swarm-connections-b509b1471986">Speeding Up IPFS Pinning Through Swarm Connections</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The IPFS Cloud]]></title>
            <link>https://medium.com/pinata/the-ipfs-cloud-352ecaa3ba76?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/352ecaa3ba76</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[ipfs]]></category>
            <category><![CDATA[decentralization]]></category>
            <category><![CDATA[ipfscloud]]></category>
            <category><![CDATA[web3]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Tue, 04 Dec 2018 13:27:52 GMT</pubDate>
            <atom:updated>2018-12-04T15:44:54.737Z</atom:updated>
            <content:encoded><![CDATA[<h4>Node by Node, We Get Better and Better</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sm-4Hri9j_5hEdDTGBxzuQ.png" /></figure><p>When people first hear about the InterPlanetary File System (<a href="https://ipfs.io/">IPFS</a>), it’s often described as a “decentralized cloud”. A decentralized cloud certainly sounds exciting, but what actually is a “decentralized cloud”? If you’re building a decentralized application, you’ll want to consider using IPFS in your stack. But, it might not be for the reasons you think.</p><h3>The Main IPFS Misconception</h3><p>While IPFS is an incredible technology, there’s a common misconception around the phrase “decentralized cloud”. With blockchains, we’ve been conditioned that once our data is put onto the blockchain, it will remain there forever (<a href="https://twitter.com/raulitojordan/status/977168280904347648">sort of</a>).</p><p>A trap that many people fall into is thinking that IPFS behaves similarly. There’s a common belief that IPFS is a magic cloud that we can freely upload our files to forever.</p><blockquote><strong>Unfortunately, this isn’t true.</strong></blockquote><p>While it would be incredible to have a giant network of servers all storing our data for free, the economics don’t make sense. After all, storage isn’t free. All of this data needs to be stored somewhere and that costs money or <a href="http://filecoin.io/">tokens</a>.</p><p>The current reality of how most data is stored on IPFS is actually pretty similar to modern cloud storage. When a user uploads a file, that file is sent to servers run by Example Company™ and those servers store that data on a company owned IPFS node.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/977/1*5LDbR9TFD-KeTTwSNIGBkw.png" /></figure><p>Pretty similar right? In each example, the file is being stored on a machine run by a specific company. Similar to modern cloud infrastructure, some companies may run their own IPFS infrastructure, while others may opt to use a different company to host their content on IPFS for them.</p><blockquote><strong>The key to take away from this is that in order for content to be available on the IPFS network, at least one node has to be purposefully hosting the content.</strong></blockquote><p>In the majority of cases today, the company will be in charge of hosting that content. This will either be done through running their own node or paying somebody else to host one for them.</p><h3>How’s it Different?</h3><p>If IPFS is so similar to the modern cloud, why should we use it? To understand this, we need to understand the fundamental problems IPFS is attempting to solve. Juan Benet gave a great talk on this which you can watch <a href="https://youtu.be/HUVmypx9HGI">here</a>. To summarize, IPFS allows us to retrieve content based on <strong><em>what</em></strong> the content is, not <strong><em>where</em></strong> the content is.</p><blockquote>This is a paradigm shift.</blockquote><p>Imagine that you share a viral video with everybody in the office. The way the video would be retrieved today starts with everyone clicking on the link to the video. This then takes them to the website that the video is hosted on and every single one of your coworkers’ computers has to individually reach out to the website’s server to download the video. This situation puts enormous strain on our internet infrastructure and is why phrases like the “<a href="https://en.wikipedia.org/wiki/Slashdot_effect">Reddit hug of death</a>” exist today.</p><p>With IPFS, we can do things differently. Instead of a website’s server needing to send the video to every single person that’s trying to view it, IPFS can simply look for the video’s IPFS hash. Think of the IPFS hash as the id for the content. Again, this hash is based on what the content is, not where the content is. Instead of fetching that content from the website’s server, the browser will ask the IPFS network for the content that corresponds to the IPFS hash it was just given, regardless of where it is stored.</p><p>Keeping with the example above, if everybody is downloading the exact same video, they can now retrieve it from a peer within the office. Instead of each person retrieving that video from a server across the internet backbone, the first person to download the video could just share it with everybody else in the office. Because your peers in the same building are likely able to deliver the video faster than the website’s server, you’ll fetch it from them without touching the internet backbone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/827/1*1gPcQ605lySypxbC-nEY2A.png" /></figure><h3>What’s the Catch?</h3><p>There is a catch to all of this. The good news is that this catch isn’t a technical one but simply one of industry adoption.</p><p>As IPFS is still a young technology, your fellow officemates likely won’t be running their own IPFS node on their computer. Browser extensions such as <a href="https://github.com/ipfs-shipyard/ipfs-companion">IPFS Companion</a> allow users to connect their browser directly to IPFS, but this setup still requires some technical expertise.</p><p>User adoption will most likely take place behind the scenes as more applications start to integrate IPFS into their technical stacks and major browsers integrate the IPFS protocol into the browsers themselves.</p><p>You’re starting to see some behind the scenes work through the <a href="https://github.com/ipfs/js-ipfs">JS-IPFS</a> project which allows developers to run an IPFS node as part of their javascript based web application. Such integrations will be critical to developer adoption of IPFS.</p><p>This is fairly similar to how the internet protocol HTTP gained adoption. Not through end users themselves, but by products figuring out how to utilize HTTP to deliver a product to those users. Similarly to HTTP, most users who use IPFS in the future won’t know or care that they’re using IPFS. They’ll just enjoy the benefits of a better / more stable web experience.</p><h3>How Do We Get There?</h3><h4>More Applications Need to be Built</h4><p>Great technical advancements have little impact unless they actually get incorporated into projects.</p><p>A few examples of projects that IPFS pairs well with are:</p><ul><li><a href="https://medium.com/pinata/ethereum-and-ipfs-e816e12a3c59">Blockchain based projects with storage requirements</a></li><li><a href="https://www.textile.photos/">Photo / File storage</a></li><li><a href="https://d.tube/">Video Streaming</a></li></ul><h4>Infrastructure Needs to be Built</h4><p>You’re starting to see this built out through a variety of projects like <a href="https://pinata.cloud/">Pinata</a> and a few bigger players like <a href="https://blog.cloudflare.com/distributed-web-gateway/">CloudFlare</a>. As more IPFS nodes and supporting infrastructure comes online, the network will continue to grow stronger. <a href="https://medium.com/u/ff64f4a69e5a">Andrew Hill</a> from <a href="https://www.textile.io/">Textile</a> wrote a great piece on this topic: <a href="https://medium.com/textileio/adding-the-next-million-peers-to-ipfs-76d356352d14">Adding the next million peers to IPFS</a></p><h4>We Need Major Browser Support</h4><p>Like I mentioned above, we need native browser support for IPFS. With major browser support comes a better developer experience. It will be easier for developers to develop applications with IPFS because they’ll have less hurdles to jump over. Node packages such as <a href="https://github.com/ipfs/js-ipfs">JS-IPFS</a> are a great start but with browser support typically comes Web Standards that make the development ecosystem much more stable.</p><p>And, with a better developer experience comes a better user experience. We didn’t get to where we are overnight. It took years of developer tools that continually iterated on what had been learned from the previous generation of tools. The advanced developer frameworks we have today allow developers to build performant, user-friendly applications thanks to much of the heavy lifting being done by these tools.</p><h3>Conclusion</h3><p>IPFS is becoming more prevalent in decentralized applications for good reason. However, IPFS isn’t a magic cloud that we can freely upload all of our data to. In reality, data on IPFS is currently being managed by many applications in a way that’s quite similar to centralized server / database paradigms.</p><p>So, why should we use IPFS? In addition to the benefits provided to decentralized applications, IPFS helps solve some very real issues with our modern web infrastructure. These are issues that will need to be addressed as our society continues to consume data at a <a href="https://www.seagate.com/files/www-content/our-story/trends/files/Seagate-WP-DataAge2025-March-2017.pdf">rapidly increasing rate</a>.</p><p>However, for IPFS to truly be successful, we’ll need a few more things. Applications using IPFS need to be built, better supporting infrastructure needs to be built, and we need major browser adoption. These advancements won’t happen overnight, but <em>they are happening</em> and I’m excited for what the future will bring.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=352ecaa3ba76" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/the-ipfs-cloud-352ecaa3ba76">The IPFS Cloud</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ethereum and IPFS]]></title>
            <link>https://medium.com/pinata/ethereum-and-ipfs-e816e12a3c59?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/e816e12a3c59</guid>
            <category><![CDATA[ipfs]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[decentralization]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Fri, 02 Nov 2018 16:14:35 GMT</pubDate>
            <atom:updated>2018-11-02T16:14:35.455Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Decentralized Power of Ethereum and IPFS</h3><h4>How to Create Immutable Files</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BEkefAmS0Nf2cf742kXhpA.png" /><figcaption>The <a href="http://pinata.cloud/">Pinata</a> team spent a week enjoying Prague for Devcon 4</figcaption></figure><p><a href="https://devcon4.ethereum.org/">Devcon 4</a> has me wanting to write about Ethereum. More specifically, how combining Ethereum with the <a href="https://ipfs.io/">Interplanetary File System</a> (IPFS) creates a simple, yet powerful, system of immutable content.</p><p>This post will be a high level overview geared towards those who are just learning about Ethereum or IPFS. A more technical guide on how to utilize both of these technologies will be coming out in the near future.</p><h3>The Limitation of Blockchains</h3><p>Blockchains are terrible at storing large amounts of data. Seriously, they’re really bad at it. For example, depending on the cost of Ether, you’re looking at a cost of hundreds (if you’re lucky) to <a href="https://ethereum.stackexchange.com/questions/872/what-is-the-cost-to-store-1kb-10kb-100kb-worth-of-data-into-the-ethereum-block">thousands of dollars per megabyte</a> (MB) of data you put on Ethereum.</p><p>To put this in perspective, the average size of a photo taken on my iPhone 6 is 2–3MB. Buying a car could cost less than adding the data for one photo onto the Ethereum blockchain!</p><h4><strong>Why are blockchains so bad at storing lots of data?</strong></h4><p>It takes a lot to duplicate data across thousands of machines. When a piece of data gets added to Ethereum, the new data becomes part of a block. This means that thousands of computers around the world are working together to verify that data by coming to a “consensus”. In the context of a blockchain, consensus means that these computers agree that the data for a given block is valid, and it’s okay to move onto the next block.</p><p>Because new blocks of data have to be verified by so many different computers all at once, there’s a limit to how much new data can be processed in a given block. At Ethereum’s current rate of 15 seconds per block, the average amount of data that gets put into a new block is around 20 KB. If we refer back to our photo size of around 2MB, it would take roughly 100 blocks for me to add that data to Ethereum. Additionally, that’s assuming I somehow managed to reserve 100 blocks of data all to myself (which realistically isn’t going to happen).</p><p>The above explanation is an extreme simplification of how Ethereum works. For more in-depth explanation, check out <a href="https://medium.com/@preethikasireddy/how-does-ethereum-work-anyway-22d1df506369">this post</a> by <a href="https://medium.com/u/d446dafbe292">Preethi Kasireddy</a>. It’s a great read.</p><h3>What Blockchains Excel At</h3><p>The consensus process is what makes Ethereum so powerful. While we can’t add a lot of data to Ethereum at once, the consensus process assures us that all data added to the chain is immutable. Once data gets put onto Ethereum, it’s there forever. You can change the “state” of a blockchain by sending tokens or executing a smart contract, but the records of all previous states still exist in previous blocks.</p><blockquote><strong><em>Ethereum allows us to timestamp data in a way that prevents data tampering.</em></strong></blockquote><p>A few examples of where tamper proof, timestamped data time can be useful:</p><ul><li>Real world instrument measurements (<a href="http://blog.klaehn.org/2018/06/10/efficient-telemetry-storage-on-ipfs/">telemetry data</a>)</li><li>Signed documents</li><li>Security photos / video footage</li></ul><p>But wait…if we think back to what we talked about earlier, these types of data would be incredibly expensive to store on a blockchain!</p><h3>IPFS to the Rescue</h3><p><a href="https://ipfs.io/">IPFS</a> helps solve a lot of problems on the modern web. It also solves a lot of problems for the new decentralized web! It turns out that by combining a blockchain with IPFS, we can timestamp much larger amounts of data than we’re able to using just the blockchain.</p><p>When data is added to IPFS, the protocol returns a hash of the data that was just added. <strong>This hash is cryptographically guaranteed to be unique to the content.</strong> If the same content is added to IPFS again, the same unique hash will be returned.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_dzsD5VCQJ4JpPS4EOtXoQ.png" /></figure><p>Content retrieval using IPFS works in the reverse. To retrieve content that has been stored on IPFS, the same cryptographic hash returned from the storage process is provided back to the IPFS network. Through this retrieval process, the requester of the content is cryptographically guaranteed to receive the same content that was initially uploaded to the IPFS network.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*08WsJlt22_LNGRzPGfIA9A.png" /></figure><p>In other words, IPFS allows us to store data and then later retrieve it, with the knowledge that our data wasn’t tampered with. That’s pretty powerful.</p><p><strong><em>What’s even more powerful is when we combine this with Ethereum.</em></strong></p><p>Remember how blockchains allow us to timestamp data in a way that prevents data tampering? Also, remember how blockchains are really bad at doing this with large amounts of data? Well, now we can get around that limitation using IPFS.</p><p>Hashes provided back from IPFS are currently 46 bytes in size, which is 1/43478 the size of our 2MB photo from earlier. This means that an IPFS hash is magnitudes cheaper to store on Ethereum than the data itself.</p><p>So, if we wanted to timestamp a large piece of data, all we would have to do is upload that data to IPFS and then put the corresponding hash onto Ethereum.</p><h4>A Real World Example</h4><p>Let’s say that a company signed a rather large legal agreement. The signed PDF of that agreement was stored on IPFS and the corresponding hash was printed onto the Ethereum blockchain.</p><p>Now, let’s say there was a dispute where one party claimed the agreement had never been signed. This could easily be disproven by referencing the block where the hash of the agreement was added to the blockchain.</p><p>If all we had was the IPFS hash of the agreement, it could easily be claimed that the document was forged. After all, the document could have been added to the IPFS network at any time, not necessarily when the truthful party claimed it was. But, since the hash was added to the Ethereum blockchain at the time of upload to the IPFS network, the signed document was timestamped in a tamperproof way. And, because IPFS provides tamper-proof content retrieval, it can be proven that the content the hash points to hasn’t been altered in any way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QJ5e21hWKozOp7RXelZdZA.png" /></figure><h3>Conclusion</h3><p>Blockchains like Ethereum and IPFS are both incredibly powerful tools. But, they both have their weaknesses.</p><p>Ethereum is really good at timestamping data but can only handle very small amounts of data at a given time.</p><p>IPFS is really good at storing data in a tamper proof way but there’s no way of proving when the data was added to the IPFS network.</p><p>When we combine Ethereum and IPFS, we gain the ability to timestamp any data we want, no matter how big the size.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e816e12a3c59" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/ethereum-and-ipfs-e816e12a3c59">Ethereum and IPFS</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to deploy an IPFS node on Digital Ocean]]></title>
            <link>https://medium.com/pinata/how-to-deploy-an-ipfs-node-on-digital-ocean-c59b9e83098e?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/c59b9e83098e</guid>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[digitalocean]]></category>
            <category><![CDATA[ipfs]]></category>
            <category><![CDATA[decentralization]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Mon, 22 Oct 2018 08:10:55 GMT</pubDate>
            <atom:updated>2021-12-23T20:55:51.517Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to Deploy an IPFS Node on Digital Ocean</h3><h4>An IPFS Tutorial</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/615/1*r6MLgnwolGsNow3prRuJgA.png" /></figure><p>There are plenty of easy <a href="https://www.pinata.cloud/">options</a> out there for accessing an <a href="https://ipfs.io/">IPFS</a> node in the cloud. However, some of you working on your dapps may want to host your own node in the cloud but don’t know where to start. I wrote this guide on how to deploy an IPFS node on Digital Ocean so you don’t have to go through the undocumented struggles I did. This guide will cover the following:</p><ol><li>Setting up a Digital Ocean account</li><li>Creating a droplet</li><li>Securing your droplet</li><li>Installing GoLang / IPFS / IPFS-Update</li><li>Setting up a service to keep the IPFS daemon online at all times</li></ol><h3>Step One — Sign Up</h3><p>If you don’t have an account, feel free to use our <a href="https://m.do.co/t/17e7762d5ab0">referral link</a> for some free sign-up credits!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5V3jkKEncIaRHTQMbjk1KQ.png" /><figcaption>First Project Page</figcaption></figure><h3>Step Two — Creating a droplet</h3><p>Droplets are the name Digital Ocean uses for its virtual machines. You’ll be creating one for the purposes of this tutorial. Go ahead and click “Get Started with a Droplet” to be taken to the droplet creation page.</p><p>This guide will use the following options for your droplet:</p><h4>Distribution and specs</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/601/1*1jymxYcXWhwyvZ-ElYgJAA.png" /></figure><p>I’m using the least expensive specifications here. Feel free to choose a faster option if you’d like.</p><h4>Backups</h4><p>Backups are optional. If you want to backup your node, feel free to do so.</p><h4><strong>Block Storage</strong></h4><p>To keep this tutorial simple, you won’t be enabling block storage. If you’re building a larger application you may eventually outgrow the 25GB SSD that’s provided with the base droplet. You can always upgrade your droplet to other options as your node starts to receive more traffic. However, eventually you’ll likely reach a point where you don’t need a faster machine, you just need more storage.</p><p>This is where block storage shines. Utilizing block storage as your main storage option for IPFS in your droplet allows you to periodically increase your data storage capabilities without needing to increase your general machine specs. I’ll be writing a guide on how to utilize block storage for your IPFS node in the near future. For now, you can read about block storage <a href="https://www.digitalocean.com/docs/volumes/">here</a>.</p><h4>Datacenter Region</h4><p>Choose whichever datacenter you’d like. For quick access during this tutorial, choose the one that’s closest to you.</p><h4>Additional Options</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/561/1*NLZ0cfRjskcPp6XCF52gIg.png" /></figure><p>The two options I select here are “IPv6” and “Monitoring”. I chose “IPv6” because IPFS performs better with IPv6 enabled. I chose “Monitoring” because it’s free and I like to see how my Droplet is doing from time to time.</p><h4>Adding an SSH Key</h4><p>While this is technically optional, I would <em>highly</em> recommend utilizing an SSH key. I will be utilizing one for this tutorial. If you have an SSH key already, add it here. If not, I would recommend reading through <a href="https://www.digitalocean.com/docs/droplets/how-to/add-ssh-keys/">this documentation</a> on how to create one. It’s something you won’t regret learning.</p><h4>Finalization</h4><p>Once you have all your settings in place, name your droplet (or use the one provided), and click “Create”. Your droplet should start the creation process. Once finished, you should see something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zTFfFD4vudvUD2rW3SWjXQ.png" /></figure><p><em>(FYI, I may sometimes include things such as IP addresses in this guide to make it easier to follow, but the node will have been deleted upon guide publication)</em></p><h3><strong>Step Three — Updating the new droplet</strong></h3><p>First, you’ll need to connect your droplet to start setting things up. You can do this by entering the following in your local machine’s console.</p><pre>ssh root@your_droplet_ip</pre><p>You should be greeted with some fun messages saying that you have a few packages you can update. Let’s do that right now.</p><pre>apt-get update<br>apt-get upgrade<br>apt-get dist-upgrade<br>apt autoremove</pre><p>A reboot may or may not be necessary after updating your droplet:</p><pre>shutdown -r 0</pre><p>(You’ll be disconnected from the SSH connection to your droplet when your droplet restarts)</p><h3>Step Four — Setting up your non-root user (Optional)</h3><p><em>This step is optional but highly recommended. Setting up and utilizing a non-root user for interacting with a linux instance is much safer than utilizing the root user. I’ve included this in my guide because I want you to have the knowledge to set up a more secure node if desired.</em></p><h4>SSH back into your Droplet as root:</h4><pre>ssh root@your_droplet_ip</pre><h4>Create a new user:</h4><p>For this example, let’s use my name as the new non-root user.</p><pre>adduser matt</pre><p>Enter in a new password for your user. You can leave the rest of the information blank by hitting enter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/314/1*FvHAGYKuvzreDyB2N8VMjw.png" /></figure><h4>Give your user root privileges</h4><p>Running the following command allows you to execute root commands on your new user by adding “sudo” before your commands.</p><pre>usermod -aG sudo matt</pre><h4>Enable your SSH key for your new non-root user</h4><p>Still have your public SSH key from before? Great. Temporarily switch over to your new user.</p><pre>su - matt</pre><h4>Create a new directory called .ssh and restrict permissions for it</h4><pre>mkdir ~/.ssh<br>chmod 700 ~/.ssh</pre><h4>Open a file in your new directory called “authorized_keys”</h4><pre>nano ~/.ssh/authorized_keys</pre><p>Copy and paste your public ssh key from earlier into this file and then hit CTRL+x to exit the file. Hit y to save the changes and then ENTER to confirm.</p><h4>Restrict the permissions of your new file</h4><pre>chmod 600 ~/.ssh/authorized_keys</pre><h4>Exit your SSH instance</h4><p>Exit the instance for both SSH users by typing this command <strong>TWICE</strong></p><pre>exit</pre><h4>Try logging into your new user via SSH</h4><pre>ssh matt@your_droplet_ip</pre><p>You should now be connected to your droplet as your new non-root user.</p><h3>Step Five — Secure your machine</h3><p>You’ll want to set up some security on your machine. This will help keep the bad guys away.</p><p>Go to the “networking menu” of your node</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/890/1*ePgnvIw2L75W-u7xllw2Xg.png" /></figure><p>Click on “Manage Firewalls”</p><p>Click on “Create Firewall”</p><p>My firewall looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mgeOI6AUJEDDSNubRtKgzg.png" /></figure><p><strong>A brief description of the inbound ports you’ve opened:</strong></p><p><strong>TCP 22 </strong>— This is so you can SSH into your Droplet</p><p><strong>TCP 4001 </strong>— This is the primary port that your IPFS node will use to communicate to other IPFS nodes</p><p><strong>Optional ports you can enable depending on your needs:</strong></p><p><strong>TCP 5001 </strong>— This port can be opened up if you want to access your IPFS node API remotely. Disclaimer! If you do this, the entire world can access your IPFS node unless you add further safety features such as restricting which external IP addresses can access port 5001.</p><p><strong>TCP 8080</strong> — This is needed if you want to run your node as a gateway node. IPFS gateways are essentially web interfaces where users who aren’t running their own IPFS node can go and retrieve content from. So, people could retrieve content without running a node by visiting:</p><p>“your_droplet_ip_address:8080/ipfs/hashOfTheContent”</p><p>For example, you can retrieve an image of my dog without running a node through your public gateway: <a href="https://gateway.pinata.cloud/ipfs/Qmbz4WpZ4Btx6YrcQeZDAg43d6ABmrLLHxyuBkyb1ZBP59">Photo of Winston</a></p><p>If you want to learn more about how to set up public gateways using your own custom domain, <a href="https://medium.com/u/adda52ceb6bc">Carson Farmer</a> from <a href="https://www.textile.io/">Textile</a> has a <a href="https://medium.com/textileio/tutorial-setting-up-an-ipfs-peer-part-ii-67a99cd2c5">great guide on setting up your own gateway node with NGINX</a> that I would highly recommend.</p><p><strong>TCP 8081</strong> — This is needed if you want to run pubsub capabilities on your node. You can read more about pubsub functionality <a href="https://blog.ipfs.io/25-pubsub/">here</a>.</p><p><strong>Outbound rules:</strong></p><p>You shouldn’t really care about what’s leaving your node so feel free to keep this open as shown.</p><h3>Step Six— Installing GoLang</h3><p><a href="https://golang.org/">GoLang</a> is needed for running IPFS.</p><h4>Install GoLang</h4><pre>curl -O <a href="https://dl.google.com/go/go1.11.linux-amd64.tar.gz">https://dl.google.com/go/go1.12.5.linux-amd64.tar.gz</a></pre><p>(At the time of this guide, the current version of GoLang is 1.12.5. You may want to replace the version of GoLang if a newer version becomes available)</p><h4>Extract GoLang to /usr/local</h4><pre>sudo tar -C /usr/local -xzf go1.12.5.linux-amd64.tar.gz</pre><h4>Open up your .profile</h4><pre>nano ~/.profile</pre><h4>Add these lines to the bottom of the file</h4><pre>export PATH=$PATH:/usr/local/go/bin<br>export GOPATH=&quot;$HOME/go&quot;<br>PATH=&quot;$GOPATH/bin:$PATH&quot;</pre><p>OPTIONAL</p><p>If you’d like to define a specific path for IPFS instead of the default ~/.ipfs path, please include the following line at the end of the file:</p><pre>export IPFS_PATH=/your/custom/path</pre><p>Exit with CTRL+x, save with y, and hit ENTER to confirm.</p><h4>Reload your profile</h4><pre>source ~/.profile</pre><h4>Check that your installation was successful</h4><pre>go version</pre><p>You should be greeted with something like: “go version go1.12.1 linux/amd64”. If you received this message, congrats! GoLang was successfully installed.</p><h3>Step Seven — Installing IPFS</h3><h4>Install ipfs-update</h4><p>First, you’ll want to install <a href="https://github.com/ipfs/ipfs-update">ipfs-update</a>. This handy package allows you to easily update your ipfs client whenever there are new updates without having to go through a bunch of manual upgrade headaches.</p><pre>go get -u github.com/ipfs/ipfs-update</pre><p>Once this is complete, go ahead and run this command:</p><pre>ipfs-update versions</pre><p>Take note of whatever version is the latest and run something like this:</p><pre>ipfs-update install v0.4.19</pre><p>You should receive a message that says “Installation complete!”</p><p>Now run:</p><pre>ipfs init --profile server</pre><p>You should receive a message that looks something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/467/1*_eNZQgIzzNn0AAk8I-OkOw.png" /></figure><p>If you’re seeing this, congrats! You’ve successfully installed IPFS on your droplet!</p><p>Last thing for this section. Since your droplet has 25GB in storage, you might as well use it. Let’s increase your IPFS repo size from the default 10GB to 20GB.</p><pre>ipfs config Datastore.StorageMax 20GB</pre><h3>Step Eight — Making sure IPFS is running all the time.</h3><h4>At this point you can run:</h4><pre>ipfs daemon</pre><p>Your IPFS node will now be officially running.</p><p>However, if you exit your SSH session with the droplet, IPFS will shut down.</p><p>You can fix this by creating an ubuntu systemd service to keep things running.</p><pre>sudo nano /etc/systemd/system/ipfs.service</pre><h4>Enter the following code into your editor.</h4><p>*Note* — If you chose a custom path for IPFS in Step Six, you’ll want to use that in the environment instead of the default IPFS path.</p><pre>[Unit]</pre><pre>Description=IPFS Daemon</pre><pre>[Service]</pre><pre>Type=simple</pre><pre>ExecStart=/home/matt/go/bin/ipfs daemon --enable-gc</pre><pre>Group=matt</pre><pre>Restart=always</pre><pre>Environment=&quot;IPFS_PATH=/home/matt/.ipfs&quot;</pre><pre>[Install]</pre><pre>WantedBy=multi-user.target</pre><p>Save your new file by hitting CTRL+x, y, and then confirming by hitting ENTER.</p><h4><strong>Run these lines in the terminal to enable your new service:</strong></h4><pre>sudo systemctl daemon-reload<br>sudo systemctl enable ipfs<br>sudo systemctl start ipfs</pre><h4>Check and see if this worked by running:</h4><pre>sudo systemctl status ipfs</pre><p>You should see something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/756/1*jWnX3NLBE7qc7CmxOql5CA.png" /></figure><h4><strong>Reboot your machine as one final test that everything worked:</strong></h4><pre>sudo shutdown -r 0</pre><p>Once the reboot is complete, SSH back into your droplet and run the following to see if you have an IPFS node up and running:</p><pre>ipfs swarm peers</pre><p>You should see a few peers your node is connected to. This list will grow the longer your node is online!</p><h3>Conclusion</h3><p>You now have an IPFS node up and running on Digital Ocean! Hopefully this guide was helpful. If you have any questions about this tutorial or IPFS in general, please reach out!</p><p>Twitter: <a href="https://twitter.com/MattOber1">https://twitter.com/MattOber1</a></p><p>Email: <a href="/service/mailto:matt@pinata.cloud">matt@pinata.cloud</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c59b9e83098e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/how-to-deploy-an-ipfs-node-on-digital-ocean-c59b9e83098e">How to deploy an IPFS node on Digital Ocean</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Keep Your IPFS Nodes Connected and Ensure Fast Content Discovery]]></title>
            <link>https://medium.com/pinata/how-to-keep-your-ipfs-nodes-connected-and-ensure-fast-content-discovery-7d92fb23da46?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d92fb23da46</guid>
            <category><![CDATA[decentralization]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[ipfs]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Fri, 19 Oct 2018 14:16:34 GMT</pubDate>
            <atom:updated>2018-10-24T10:06:00.431Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to Keep Your IPFS Nodes Connected to Ensure Fast Content Discovery</h3><h4>An IPFS Tutorial</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0ost4Tck0vBNAt_fswT1uQ.png" /></figure><h3>Assumptions</h3><ul><li>This guide assumes the reader already has multiple <a href="http://ipfs.io/">IPFS</a> nodes running on Ubuntu 16 systems.</li></ul><h3>This guide is written for any of the following people:</h3><ul><li>People who want to make their IPFS nodes discover content faster from their other nodes</li><li>People who run IPFS gateways alongside their IPFS nodes.</li><li>People who have IPFS nodes that are repeatedly disconnecting from or “forgetting” about each other.</li></ul><h3>The Problem</h3><p>IPFS currently doesn’t provide mechanisms that allow hosts to keep all nodes they control perpetually connected to each other. This creates scenarios where even if we bootstrap the nodes together on startup, they can eventually “forget” about each other and become disconnected. This can lead to slower content discovery and prevent content from being discovered entirely.</p><p>This can be a problem when a product hosts its own gateway and points users to it for retrieving content hosted on the product’s own nodes. If the gateway isn’t directly connected to the product’s nodes, then users may find themselves waiting quite a while for their content to load. Not a great user experience.</p><p>So how can we fix this?</p><h3>Step 1 — Acquire your node multiAddresses</h3><p>Open up the command line on each machine hosting an IPFS node and run:</p><pre>ipfs id</pre><p>Your response should look something like this:</p><pre>{</pre><pre>&quot;ID&quot;: &quot;YourNodeID&quot;,</pre><pre>&quot;PublicKey&quot;: &quot;YourPublicKey&quot;,</pre><pre>&quot;Addresses&quot;: [</pre><pre>&quot;/ip4/127.0.0.1/tcp/4001/ipfs/YourNodeID&quot;,</pre><pre>&quot;/ip4/XXX.XXX.XXX.XXX/tcp/4001/ipfs/YourNodeID&quot;,</pre><pre>&quot;/ip6/::1/tcp/4001/ipfs/YourNodeID&quot;,</pre><pre>&quot;/ip6/YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY/tcp/4001/ipfs/YourNodeID&quot;,</pre><pre>&quot;/ip6/YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY/tcp/4001/ipfs/YourNodeID&quot;,</pre><pre>&quot;/ip6/YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY:YYYY/tcp/4001/ipfs/YourNodeID&quot;,</pre><pre>&quot;/ip4/XXX.XXX.XXX.XXX/tcp/4001/ipfs/YourNodeID&quot;,</pre><pre>],</pre><pre>&quot;AgentVersion&quot;: &quot;go-ipfs/0.4.17/&quot;,</pre><pre>&quot;ProtocolVersion&quot;: &quot;ipfs/0.1.0&quot;</pre><pre>}</pre><p>We primarily care about the “Addresses” array. These contain the “multiAddress” values that outside IPFS nodes can use to connect to. You might have some duplicate results, that’s okay. The key thing here is to take note of the entries containing your external IP addresses, and NOT the entries with your local IP address in them. If you have IPv6 enabled on ALL of your nodes, copy that multiAddress, if you don’t, copy the IPv4 multiAddress.</p><h3>Step 2 — Connect your IPFS nodes</h3><p>Now that we have our multiAddresses, let’s connect our nodes together.</p><p>For this example, we’ll pretend we have Node A, and Node B. In reality, this works for as multiple nodes.</p><p><strong>From the command line in Node A, run:</strong></p><pre>ipfs swarm connect /ip4/BBB.BBB.BBB.BBB/tcp/4001/ipfs/NodeBID</pre><p>(replacing the above example multiAddress with Node B’s IPv4 multiAddress)</p><p><strong>or if you’re connecting via IPv6, run:</strong></p><pre>ipfs swarm connect /ip6/BBBB:BBBB:BBBB:BBBB:BBBB:BBBB:BBBB:BBBB/tcp/4001/ipfs/NodeBID</pre><p>(replacing the above example multiAddress with Node B’s IPv6 multiAddress)</p><p><strong>Results</strong></p><p>We should receive the following results in the terminal:</p><pre>connect NodeBID success</pre><p>You can verify this worked by running the following on each node:</p><pre>ipfs swarm peers</pre><p>On Node A, you should see Node B’s multiAddress in the returned list, and on Node B, you should see Node A’s multiAddress in the returned list.</p><p>Now that our two nodes are connected together. Content discovery should be near instant. Instead of having to go through multiple layers of nodes before Node A discovers that Node B has the content it’s looking for, Node B will be one of the first nodes asked for the content and can instantly start providing it (the same works in reverse).</p><h3>Step 3 — Let’s automate things</h3><p>Connecting our nodes manually via the command line is cool, but how do we automate this process so our nodes can stay connected on their own?</p><p>Using linux services / timers, we can do just that!</p><p>(For these examples, let’s pretend we have a gateway node, and that we want our content hosting nodes automatically connected to the gateway node)</p><h4>For every node that you want to connect to the gateway, add the following two files:</h4><p><strong>/etc/systemd/system/gateway-connector.service</strong></p><pre>[Unit]</pre><pre>Description=Job that periodically connects this IPFS node to the gateway node</pre><pre>[Service]</pre><pre>ExecStart=/home/yourUserName/go/bin/ipfs swarm connect /ip4/GGG.GGG.GGG.GGG/tcp/4001/ipfs/gatewayID</pre><pre>Environment=&quot;IPFS_PATH=/ipfs&quot;</pre><p>*Note* — In the above file, you’ll need to input custom values for:</p><ul><li>Under ExecStart, your ipfs executable path will depend on where you installed Go / the ipfs executable.</li><li>Under ExecStart, the multiAddress will be one of the values retrieved form running “ipfs id” on your gateway node. You can also use an IPv6 multiAddress here as well.</li><li>Under Environment, you’ll need to replace this with the location you have your IPFS repo installed. If you can get this value by running “ipfs repo stat” in the command line and copying the “RepoPath” value.</li></ul><p><strong>/etc/systemd/system/gateway-connector.timer</strong></p><pre>[Unit]</pre><pre>Description=Timer that periodically triggers gateway-connector.service<br></pre><pre>[Timer]</pre><pre>OnBootSec=3min</pre><pre>OnUnitActiveSec=1min<br></pre><pre>[Install]</pre><pre>WantedBy=timers.target</pre><p>In the above file, “OnBootSec” is the amount of time your machine waits to start the timer after it boots up. The OnUnitActiveSec is the amount of time between each execution of gateway-connector.service.</p><h3>Step 4 — Let’s run our automation</h3><p>Now that we’ve created our automation files, let’s enable / run them.</p><p>From the command line on each of the nodes we added our automation files to, run:</p><pre>sudo systemctl enable gateway-connector.timer<br>sudo systemctl start gateway-connector.timer</pre><p>To double checked this worked, run:</p><pre>systemctl list-timers</pre><p>You should see an entry for your gateway connector service. You can also check the status of its last execution attempt by running:</p><pre>systemctl status gateway-connector</pre><h3>Conclusion</h3><p>Now, you should have everything up and running. From this point on, when requesting content from nodes in your network (from one of your other nodes), everything should go much faster. That’s the magic of keeping your nodes connected via swarm!</p><p>As always, feel free to reach out to me at <a href="/service/mailto:matt@pinata.cloud">matt@pinata.cloud</a> if you have any questions on this post or IPFS in general!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d92fb23da46" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/how-to-keep-your-ipfs-nodes-connected-and-ensure-fast-content-discovery-7d92fb23da46">How to Keep Your IPFS Nodes Connected and Ensure Fast Content Discovery</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Beta and Some Metadata]]></title>
            <link>https://medium.com/pinata/a-beta-and-some-metadata-cc4655504c0c?source=rss-a446d4aefa91------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc4655504c0c</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[ipfs]]></category>
            <category><![CDATA[decentralization]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[pinata]]></category>
            <dc:creator><![CDATA[Matt Ober]]></dc:creator>
            <pubDate>Fri, 05 Oct 2018 11:20:03 GMT</pubDate>
            <atom:updated>2018-10-05T14:09:21.142Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uHs3-ThhltnwKLNQy84GBg.png" /></figure><p>It’s been a busy couple of weeks here at Pinata. Since winning at <a href="https://medium.com/@kyletut/the-centralized-secret-c7de795ddd9f">ETHBerlin</a>, we’ve been receiving a ton of great feedback from teams around the world. From that feedback, we are thrilled to announce some exciting updates to our Pinata <a href="https://pinata.cloud/">IPFS hosting service</a> i.e Pinata Cloud.</p><h3>Metadata Support</h3><p>When uploading to <a href="https://ipfs.io/">IPFS</a>, it can be hard to keep track of all of your content. Wouldn’t it be nice if you could give your uploads a name? Or, maybe, associate some vital data to each upload that allows you to find it easier? With Pinata’s new metadata functionality you can!</p><p>From this point onward, when adding content to IPFS through Pinata’s API, you can include optional metadata along with your API request. This includes giving your upload a custom name and the option to add custom key / value pairs. After uploading, you can use that metadata to find your content hashes using a new search functionality we’ve added to our <a href="https://pinata.cloud/documentation#UserPinList">userPinList</a> API endpoint.</p><p>There’s a lot to talk about with this new feature. You can find more about how to use it here: <a href="https://medium.com/pinata/how-to-include-metadata-with-your-ipfs-uploads-19813513320f"><strong><em>How to Include Metadata with Your IPFS Uploads</em></strong></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AshMXyG7UAZMqoyo8QOUiQ.png" /></figure><h3>Pinata Upload</h3><p>Another feature people have been asking for is the ability to upload files via our web interface. Pinata users can go to the <a href="https://pinata.cloud/pinataupload">Pinata Upload</a> page to upload content with the click of a button. No code. No hassle. Just click “Upload” and you’re good to go.</p><h3>Pinata Mobile</h3><p>To complement our new web-based file uploader, we’ve made much of our website mobile friendly. So, feel free to upload pictures of your dog from your phone. <a href="https://gateway.pinata.cloud/ipfs/Qmbz4WpZ4Btx6YrcQeZDAg43d6ABmrLLHxyuBkyb1ZBP59">We do it all the time</a>.</p><h3>Pinata moves into Beta</h3><p>With this new set of features, we’ve officially moved Pinata Cloud into Beta. With this move, our priority is keeping things stable. That means that any future changes we make should be backwards compatible and anything you pin to Pinata during our Beta period will still exist when we officially launch.</p><p>Think of this time as an extended free trial while the Pinata team continues to improve our product offerings. Speaking of product offerings…</p><h3>Pinata Overlay</h3><p>Since ETHBerlin, we’ve had a crazy amount of people reach out to us and ask about <a href="https://medium.com/@kyletut/the-centralized-secret-c7de795ddd9f">Pinata Overlay</a>. With Pinata Cloud stable, we want to make sure we’re focusing on the right things. So, from this point on, we’ll be focusing much of our resources on building out Pinata Overlay.</p><p>Pinata Overlay offers an exciting opportunity for us to help projects around the world replicate their content on IPFS in a decentralized fashion. Keep an eye out for future posts detailing our progress as we build out the Pinata Overlay platform.</p><p>Finally, we’re going to need both hosting providers and smart contract owner beta testers. <strong>We need your help to make this thing happen!</strong> If you’re interested in getting involved, please send us an email at <a href="/service/mailto:team@pinata.cloud">team@pinata.cloud</a>. We’d love to hear from you!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc4655504c0c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pinata/a-beta-and-some-metadata-cc4655504c0c">A Beta and Some Metadata</a> was originally published in <a href="https://medium.com/pinata">Pinata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>