diff --git a/.github/styles/pln-ignore.txt b/.github/styles/pln-ignore.txt index f1055a5f3..1dd6a63f2 100644 --- a/.github/styles/pln-ignore.txt +++ b/.github/styles/pln-ignore.txt @@ -15,6 +15,7 @@ atcute auditable audius auspinner +Bacalhau bitswap bit[ss]wap blockchain @@ -82,6 +83,7 @@ explainers fabien failovers filebase +Filebase's filecoin filecorgi filesizes @@ -230,6 +232,7 @@ runtime's sandboxed satoshi satoshi nakamoto +SDKs serverless sharding snapshotted @@ -240,6 +243,7 @@ someguy stackparse stdout storacha +Storacha's storj subcommand substring diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index 243907c32..70cfa08e3 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -105,7 +105,9 @@ module.exports = { sidebarDepth: 1, collapsable: false, children: [ - ['/quickstart/retrieve','Retrieve with IPFS'], + ['/quickstart/retrieve','Retrieve from IPFS'], + ['/quickstart/pin','Pin with Browser'], + ['/quickstart/pin-cli','Pin with Command Line'], ['/how-to/websites-on-ipfs/deploy-github-action', 'Deploy to IPFS with GitHub Actions' ], ] }, @@ -123,7 +125,9 @@ module.exports = { sidebarDepth: 1, collapsable: false, children: [ - ['/quickstart/retrieve','Retrieve with IPFS'], + ['/quickstart/retrieve','Retrieve from IPFS'], + ['/quickstart/pin','Pin with Browser'], + ['/quickstart/pin-cli','Pin with Command Line'], ['/how-to/websites-on-ipfs/deploy-github-action', 'Deploy to IPFS with GitHub Actions' ], ] diff --git a/docs/.vuepress/redirects b/docs/.vuepress/redirects index 96bb819cb..fdf26e8a4 100644 --- a/docs/.vuepress/redirects +++ b/docs/.vuepress/redirects @@ -77,3 +77,5 @@ /reference/api/http/ /reference/http/api /reference/go/overview/ /reference/go/api /reference/js/overview/ /reference/js/api +/quickstart/publish /quickstart/pin +/quickstart/publish_cli /quickstart/pin-cli diff --git a/docs/concepts/cod.md b/docs/concepts/cod.md index 003e15b43..e0f2649bc 100644 --- a/docs/concepts/cod.md +++ b/docs/concepts/cod.md @@ -29,8 +29,7 @@ Bacalhau can: ### More Bacalhau resources -- [Getting started tutorial](https://docs.bacalhau.org/getting-started/installation/) -- [Bacalhau platform architecture](https://docs.bacalhau.org/getting-started/architecture/) +- [Bacalhau documentation](https://docs.bacalhau.org/) - [GitHub](https://github.com/bacalhau-project/bacalhau) ## IPVM @@ -39,7 +38,7 @@ The InterPlanetary Virtual Machine (IPVM) specification defines the easiest, fas IPVM uses [WebAssembly (Wasm)](https://webassembly.org/), content addressing, [simple public key infrastructure (SPKI)](https://en.wikipedia.org/wiki/Simple_public-key_infrastructure), and object capabilities to liberate computation from specific, prenegotiated services, such as large cloud computing providers. By default, execution scales flexibly on-device, all the way up to edge points-of-presence (PoPs) and data centers. -The core, Rust-based implementation and runtime of IPVM is the [Homestar project](https://github.com/ipvm-wg/homestar/). IPVM supports interoperability with [Bacalhau](https://bacalhau.org) and [Web3Storage](https://web3.storage/) +The core, Rust-based implementation and runtime of IPVM is the [Homestar project](https://github.com/ipvm-wg/homestar/). IPVM supports interoperability with [Bacalhau](https://bacalhau.org) and [Storacha (formerly web3.storage)](https://storacha.network/) ### More IPVM resources diff --git a/docs/concepts/glossary.md b/docs/concepts/glossary.md index 7bf6e5034..09ee7cc14 100644 --- a/docs/concepts/glossary.md +++ b/docs/concepts/glossary.md @@ -398,6 +398,10 @@ A Peer ID is how each unique IPFS node is identified on the network. The Peer ID Pinning is the method of telling an IPFS node that particular data is important and so it will never be removed from that node's cache. To learn more, start by understanding [persistence, permanence, and pinning](persistence.md); then, see how to [add local pin](../how-to/pin-files.md) and read [what remote pins are](#remote-pinning). +### Pinning service + +Third-party services that run IPFS nodes and [pin](#pinning) content on behalf of users, ensuring data remains available on the IPFS network even when the user's local node is offline. See [working with pinning services](../how-to/work-with-pinning-services.md). + ### Pinning Service API A vendor-agnostic [API specification](https://ipfs.github.io/pinning-services-api-spec/) that anyone can implement to provide a service for [remote pinning](#remote-pinning). @@ -422,6 +426,10 @@ QUIC (`/quic-v1`) is one of [libp2p](#libp2p) [transport](#transport) protocols. ## R +### Redundancy + +In IPFS context, the practice of [pinning](#pinning) the same content to multiple nodes or [pinning services](#pinning-service) to ensure availability even if one source goes offline. This increases the resilience and availability of data on the [network](#mainnet). + ### Relay node A means to establish connectivity between libp2p nodes (e.g., IPFS nodes) that wouldn't otherwise be able to establish a direct connection to each other. This may be due to nodes that are behind NAT (Network Address Translation), reverse proxies, firewalls, etc. See [Nodes > Relay](../concepts/nodes.md#relay) and [libp2p docs about Circuit Relay](https://docs.libp2p.io/concepts/nat/circuit-relay/). @@ -458,6 +466,10 @@ In IPFS, IPLD Schemas are a system for describing data with structural types. [M IPLD selectors are a form of graph query over IPLD data. They can also be thought of as a way to specify a [traversal](#traversal). [More about IPLD Selectors](https://ipld.io/glossary/#selectors) +### Self-hosting + +Running your own IPFS node (using [Kubo](#kubo), [IPFS Desktop](#ipfs-desktop), or other implementations) to [pin](#pinning) and serve content, as opposed to relying solely on third-party [pinning services](#pinning-service). Self-hosting gives you full control over your data while participating in the IPFS network. + ### SFS A Self-certifying File System (SFS) is a distributed file system that doesn't require special permissions for data exchange. It is self-certifying because data served to a client is authenticated by the file name (which is signed by the server). [More about SFS](https://en.wikipedia.org/wiki/Self-certifying_File_System) diff --git a/docs/concepts/persistence.md b/docs/concepts/persistence.md index 59535321d..acc895f5f 100644 --- a/docs/concepts/persistence.md +++ b/docs/concepts/persistence.md @@ -51,7 +51,7 @@ Some of the pinning services listed below are operated by third party companies. - [NFT.Storage](https://nft.storage/) - [Pinata](https://pinata.cloud/) - [Scaleway](https://labs.scaleway.com/en/ipfs-pinning/) -- [Web3.Storage](https://web3.storage/) +- [Storacha (formerly web3.storage)](https://storacha.network/) See how to [work with remote pinning services](../how-to/work-with-pinning-services.md). diff --git a/docs/how-to/gateway-best-practices.md b/docs/how-to/gateway-best-practices.md index 712a34ccb..a1dd324bf 100644 --- a/docs/how-to/gateway-best-practices.md +++ b/docs/how-to/gateway-best-practices.md @@ -5,7 +5,7 @@ description: Learn best practices for working with IPFS HTTP Gateways # Best practices for HTTP Gateways -Various best practices for the use of IPFS gateways are listed below. To learn more about the concepts behind IPFS gateways, including how they work, available providers, types and FAQs, see [IPFS Gateway](../concepts/ipfs-gateway.md). For troubleshooting information, see [Troubleshooting](./gateway-troubleshooting.md). +Various best practices for the use of IPFS gateways are listed below. To learn more about the concepts behind IPFS gateways, including how they work, available providers, types and FAQs, see [IPFS Gateway](../concepts/ipfs-gateway.md). For troubleshooting information, see [Troubleshooting](./troubleshooting.md). ## Selecting a gateway type to use @@ -33,7 +33,7 @@ If you are running an IPFS node that is also configured as an IPFS gateway, each - If your node is not reachable because you are behind NAT, see the [NAT configuration](https://docs.ipfs.tech/how-to/nat-configuration/#ipv6) docs. - Ensure that you are correctly returning HTTP cache headers to the client if the IPFS gateway node is behind a reverse proxy. Pay extra attention to `Etag`, `Cache-Control`, and `Last-Modified headers`. Consider leveraging the list of CIDs in `X-Ipfs-Roots` for smarter HTTP caching strategies. - Put a CDN like Cloudflare in front of the IPFS gateway. -- Consider enabling the [Accelerated DHT Client](https://github.com/ipfs/go-ipfs/blob/master/docs/experimental-features.md#accelerated-dht-client). +- Consider enabling the [Accelerated DHT Client](https://github.com/ipfs/kubo/blob/master/docs/config.md#routingaccelerateddhtclient). - Test and monitor your internet connection speed, with a tool like [Speedtest CLI](https://www.speedtest.net/apps/cli). - Monitor disk I/O and make sure that no other processes are causing disk I/O bottlenecks with a tool like [iotop](https://github.com/Tomas-M/iotop) or [iostat](https://github.com/sysstat/sysstat). @@ -73,7 +73,7 @@ These pages do not share the same origin. Similarly, the use of DNSLink gateway ## Cross-origin resource sharing (CORS) -[CORS](https://web.archive.org/web/20200418003728/https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#The_HTTP_response_headers) allows a webpage to permit access to specified data by pages with a different origin. The [IPFS public gateway checker](https://ipfs.github.io/public-gateway-checker/) identifies those public gateways that support CORS. +[CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) allows a webpage to permit access to specified data by pages with a different origin. The [IPFS public gateway checker](https://ipfs.github.io/public-gateway-checker/) identifies those public gateways that support CORS. ## Gateway man-in-the-middle vulnerability diff --git a/docs/how-to/troubleshooting.md b/docs/how-to/troubleshooting.md index e334db482..dc999cc3a 100644 --- a/docs/how-to/troubleshooting.md +++ b/docs/how-to/troubleshooting.md @@ -257,7 +257,7 @@ With this in mind, if no providers are returned, do the following: 2. Note the value for `LastReprovideDuration`. If it is close to 48 hours, or if you notice a "reprovide taking too long" warning in your `ipfs daemon` output log, select one of the following options, keeping in mind that each has tradeoffs: - - **Enable the [Accelerated DHT Client](https://github.com/ipfs/go-ipfs/blob/master/docs/experimental-features.md#accelerated-dht-client) in Kubo**. This configuration improves content providing times significantly by maintaining more connections to peers and a larger routing table and batching advertising of provider records. However, this performance boost comes at the cost of increased resource consumption, most notably network connections to other peers, and can lead to degraded network performance in home networks. + - **Enable the [Accelerated DHT Client](https://github.com/ipfs/kubo/blob/master/docs/config.md#routingaccelerateddhtclient) in Kubo**. This configuration improves content providing times significantly by maintaining more connections to peers and a larger routing table and batching advertising of provider records. However, this performance boost comes at the cost of increased resource consumption, most notably network connections to other peers, and can lead to degraded network performance in home networks. - **Change the [Reprovider Strategy](https://github.com/ipfs/kubo/blob/master/docs/config.md#reproviderstrategy) from `all` to either `pinned+mfs` or `roots`.** In both cases, only provider records for explicitly pinned content are advertised. Differences and tradeoffs are noted below: - The `pinned+mfs` strategy will advertise both the root CIDs and child block CIDs (the entire DAG) of explicitly pinned content and the locally available part of MFS. diff --git a/docs/install/README.md b/docs/install/README.md index 989defe93..4b5839446 100644 --- a/docs/install/README.md +++ b/docs/install/README.md @@ -19,6 +19,10 @@ Anyone can use IPFS to store files in a _decentralized_ way. The easiest way to If your browser doesn't support IPFS yet, you can install an IPFS companion extension that will let you view decentralized web content! [Learn more →](./ipfs-companion.md) +### Pin files with a pinning service + +Do you want to quickly and easily publish content with IPFS without complex tools? See the [Pin with IPFS quickstart](../quickstart/pin.md), where you'll learn how to use third-party pinning services to pin and provide files to the IPFS network. + ### Deploy static sites to the IPFS network with a GitHub Action Do you want to quickly and easily automate the deployment of static websites to the IPFS network? See the [Deploy static sites to the IPFS network with GitHub Actions](../how-to/websites-on-ipfs/deploy-github-action.md), where you'll learn how to use [GitHub Actions](https://github.com/ipshipyard/ipfs-deploy-action) to automatically deploy static websites to the IPFS network. @@ -53,7 +57,7 @@ To get started with a hands-on example, see [Helia 101](https://github.com/ipfs- If you are looking for simple [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)-like API for use on the web, see [@helia/verified-fetch](https://www.npmjs.com/package/@helia/verified-fetch). ::: -### Boxo SDK for GO +### Boxo SDK for Go [Boxo](https://github.com/ipfs/boxo#readme) is a set of reference libraries for building IPFS applications and implementations in Go. diff --git a/docs/install/command-line.md b/docs/install/command-line.md index 346bd77c3..13ce913ce 100644 --- a/docs/install/command-line.md +++ b/docs/install/command-line.md @@ -55,7 +55,7 @@ This reduces daemon overhead on the system but may degrade content discovery and This section describes how to download and install the Kubo binary from `dist.ipfs.tech` on Windows, MacOS, Linux, FreeBSD and OpenBSD operating systems. The IPFS team publishes the latest, official prebuilt Kubo binaries on the [dist.ipfs.tech website](https://dist.ipfs.tech#kubo). New IPFS Kubo binary releases are automatically shown on the Kubo page on `dist.ipfs.tech`. :::callout -If you are unable to access [dist.ipfs.tech](https://dist.ipfs.tech#kubo), you can also download Kubo (go-ipfs) from the project's GitHub [releases](https://github.com/ipfs/kubo/releases/latest) page or `/ipns/dist.ipfs.tech` at the [dweb.link](https://dweb.link/ipns/dist.ipfs.tech#kubo) gateway. +If you are unable to access [dist.ipfs.tech](https://dist.ipfs.tech#kubo), you can also download Kubo from the project's GitHub [releases](https://github.com/ipfs/kubo/releases/latest) page or `/ipns/dist.ipfs.tech` at the [dweb.link](https://dweb.link/ipns/dist.ipfs.tech#kubo) gateway. ::: For installation instructions for your operating system, select the appropriate tab. diff --git a/docs/install/server-infrastructure.md b/docs/install/server-infrastructure.md index 0946f48e0..2f069f5ac 100644 --- a/docs/install/server-infrastructure.md +++ b/docs/install/server-infrastructure.md @@ -8,15 +8,15 @@ current-ipfs-cluster-version: v1.1.4 If you want to install IPFS in a server environment and offer IPFS as a service, you should look at [IPFS Cluster](https://ipfscluster.io/) as a way to scale your IPFS deployment beyond a single IPFS daemon. IPFS Cluster provides data orchestration across a swarm of IPFS daemons by allocating, replicating, and tracking a global pin-set distributed among multiple peers. This makes it significantly easier to manage multiple IPFS nodes and ensure that data is available across an internal network. -IPFS Cluster is a distributed application that works as a sidecar to IPFS peers, maintaining a global cluster pinset and intelligently allocating its items to the IPFS peers. This makes it significantly easier to manage multiple IPFS nodes and ensure that data is available across an internal network. IPFS Cluster powers large IPFS storage services like [nft.storage](https://nft.storage/) and [web3.storage](https://web3.storage/). +IPFS Cluster is a distributed application that works as a sidecar to IPFS peers, maintaining a global cluster pinset and intelligently allocating its items to the IPFS peers. This makes it significantly easier to manage multiple IPFS nodes and ensure that data is available across an internal network. :::tip As a Kubernetes user, you can use a Kubernetes operator for IPFS called [IPFS operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) to easily create and manage clusters consisting of hundreds of peers. -The IPFS operator is in active development and not yet recommended for production use cases. If the operator is something you would like to include in your infrastructure, +The IPFS operator is in active development and not yet recommended for production use cases. If the operator is something you would like to include in your infrastructure, check out the [official documentation](https://ipfs-operator.readthedocs.io/) and [operator source code](https://github.com/redhat-et/ipfs-operator) for instructions and the latest progress. ::: -## Features +## Features IPFS Cluster has the following features: @@ -109,7 +109,7 @@ If you're having issues installing or using Docker or Docker-Compose, see the [o > Recreating cluster2 ... done > ... ``` - + :::warning Errors such as the following may display: @@ -131,7 +131,7 @@ If you're having issues installing or using Docker or Docker-Compose, see the [o 1. Open a new terminal window. 1. You can now interact with your cluster. In a new terminal window, navigate to the `ipfs-cluster-ctl` directory. - + 1. List the peers within the cluster: ```shell diff --git a/docs/quickstart/images/account-console.png b/docs/quickstart/images/account-console.png deleted file mode 100644 index 0327a9eb2..000000000 Binary files a/docs/quickstart/images/account-console.png and /dev/null differ diff --git a/docs/quickstart/images/login-web3-storage.png b/docs/quickstart/images/login-web3-storage.png deleted file mode 100644 index b09441a99..000000000 Binary files a/docs/quickstart/images/login-web3-storage.png and /dev/null differ diff --git a/docs/quickstart/images/web3-file-after-upload.png b/docs/quickstart/images/web3-file-after-upload.png deleted file mode 100644 index d60560e83..000000000 Binary files a/docs/quickstart/images/web3-file-after-upload.png and /dev/null differ diff --git a/docs/quickstart/images/web3-file-uploaded.png b/docs/quickstart/images/web3-file-uploaded.png deleted file mode 100644 index 753fe8419..000000000 Binary files a/docs/quickstart/images/web3-file-uploaded.png and /dev/null differ diff --git a/docs/quickstart/images/web3-upload-button.png b/docs/quickstart/images/web3-upload-button.png deleted file mode 100644 index 3016ac400..000000000 Binary files a/docs/quickstart/images/web3-upload-button.png and /dev/null differ diff --git a/docs/quickstart/images/web3-upload-tab.png b/docs/quickstart/images/web3-upload-tab.png deleted file mode 100644 index f8876b395..000000000 Binary files a/docs/quickstart/images/web3-upload-tab.png and /dev/null differ diff --git a/docs/quickstart/pin-cli.md b/docs/quickstart/pin-cli.md new file mode 100644 index 000000000..b42992a65 --- /dev/null +++ b/docs/quickstart/pin-cli.md @@ -0,0 +1,195 @@ +--- +title: 'Pin using the command line' +description: 'Learn how to publish content with IPFS by pinning a file to a pinning service using the command line.' +--- + +# Pin a file with IPFS using the command line + +Similar to the [Pin a file with IPFS](./pin.md) quickstart, this guide will teach you about [pinning services](../concepts/persistence.md#pinning-in-context) and how to use them to publish content-addressed data with IPFS. However, instead of using a web UI, you will upload files using **command-line tools and APIs** provided by various pinning services. By the end of this guide, you should have a better understanding of how content addressing and CIDs work from a high level, as well as how to use CLI tools to publish data to IPFS. + +:::callout +If you prefer a graphical interface, see [Pin with browser interfaces](./pin.md). +::: + +## Contents + +- [Overview](#overview) +- [Pinning services](#pinning-services) +- [Prerequisites](#prerequisites) +- [Upload and pin a file](#upload-and-pin-a-file) +- [CIDs explained](#cids-explained) +- [Retrieving with a gateway](#retrieving-with-a-gateway) +- [Summary and next steps](#summary-and-next-steps) + +## Overview + +_Pinning_ refers to the process of ensuring that a particular piece of content is retrievable with IPFS. In other words, pinning is equivalent to storing a file on a computer or server that is connected to the internet, thereby making it available to the rest of the IPFS network. + +Pinning can be done at various levels, from individual files to entire directories that are addressed by a CID. You can also pin CIDs to multiple IPFS nodes to increase the redundancy and resilience of the file on the network. + +## Pinning services + +[Pinning services](../concepts/glossary.md#pinning-service) are similar to hosting services, in that they run an IPFS node for you and ensure that your files are available to the IPFS network. + +:::callout +Data pinned to the IPFS network is public by default and retrievable by anyone. Avoid publishing private data or adequately encrypt it before publishing. +::: + +## Self-hosting option + +You can run your own IPFS node using [Kubo](../install/command-line.md) to pin files locally: + +- **Full control**: Run `ipfs daemon` to start your node and use `ipfs pin` commands to manage pinned content +- **Combine with pinning services**: Use both local pinning, and remote services for [redundancy](../concepts/glossary.md#redundancy) - your data stays available even if your node goes offline +- **Learn more**: See the [Kubo quickstart](../how-to/command-line-quick-start.md) and [pinning files guide](../how-to/pin-files.md) for detailed instructions + +Running your own node gives you complete control over your data while participating in the IPFS network. + +## Prerequisites + +- A unix-like terminal or command prompt +- **Option A**: Your own IPFS node + - Install [Kubo](../install/command-line.md) for command-line access + - Run `ipfs init` followed by `ipfs daemon` to start your node + +- **Option B**: An account with at least one pinning service (free tier is sufficient): + - [Storacha](https://storacha.network) - Requires Node.js for their CLI + - [Pinata](https://pinata.cloud/) - Uses REST API with curl + - [Filebase](https://filebase.com) - S3-compatible, works with AWS CLI + +- A sample file to upload, such as the [following image](../quickstart/images/welcome-to-IPFS.jpg): + +![image](../quickstart/images/welcome-to-IPFS.jpg) + +## Upload and pin a file + +Choose one of the following methods based on your setup: + +### Using Kubo (self-hosted) + +If you're running your own Kubo node, use the `ipfs add` and `ipfs pin` commands. See the [pinning files guide](../how-to/pin-files.md) for detailed instructions and the [working with remote pinning services](../how-to/work-with-pinning-services.md) guide to configure remote pinning. + +### Option 1: Storacha CLI + +Storacha provides a command-line interface through their storacha tool. For detailed installation and usage instructions, see their [CLI documentation](https://docs.storacha.network/cli/). + +Basic usage: +```shell +# Install the CLI (requires Node.js) +npm install -g @storacha/cli + +# Authenticate +storacha login your@email.com + +# Create a space for your files +storacha space create MySpace + +# Upload a file +storacha up welcome-to-IPFS.jpg +``` + +### Option 2: Pinata API + +Pinata provides a REST API that you can use with curl or any HTTP client. See their [API reference](https://docs.pinata.cloud/api-reference) for authentication setup. + +Basic usage with curl: +```shell +# Set your API credentials +export PINATA_API_KEY="your_api_key" +export PINATA_SECRET_API_KEY="your_secret_key" + +# Upload a file +curl -X POST https://api.pinata.cloud/pinning/pinFileToIPFS \ + -H "pinata_api_key: $PINATA_API_KEY" \ + -H "pinata_secret_api_key: $PINATA_SECRET_API_KEY" \ + -F "file=@welcome-to-IPFS.jpg" +``` + +### Option 3: Filebase S3-Compatible API and Kubo RPC + +Filebase offers an S3-compatible API, making it easy to use with AWS CLI or any S3 SDK. See their [S3-compatible API documentation](https://docs.filebase.com/api-documentation/s3-compatible-api) and [developer quick start guide](https://docs.filebase.com/getting-started/getting-started-guides/developer-quick-start-guide). They also offer a subset of Kubo RPC API - see their [IPFS RPC API documentation](https://docs.filebase.com/api-documentation/ipfs-rpc-api). + +Basic usage with AWS CLI: +```shell +# Configure AWS CLI with Filebase credentials +aws configure --profile filebase + +# Upload a file to your IPFS bucket +aws --profile filebase s3 cp welcome-to-IPFS.jpg s3://your-bucket-name/ +``` + +Each method will return a **CID** (Content Identifier) for your uploaded file. Save this CID as you'll use it to retrieve your file. + +## CIDs explained + +In IPFS, every file and directory is identified with a Content Identifier ([CID](../concepts/content-addressing.md)). The CID serves as the **permanent address** of the file and can be used by anyone to find it on the IPFS network. + +When a file is first added to an IPFS node (like the image used in this guide), it's first transformed into a content-addressable representation in which the file is split into smaller chunks (if above ~1MB) which are linked together and hashed to produce the CID. + +For example, a CID might look like: + +```plaintext +bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4 +``` + +You can now share the CID with anyone and they can fetch the file using IPFS. + +To dive deeper into the anatomy of the CID, check out the [CID inspector](https://cid.ipfs.tech/#bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4). + +:::callout +The transformation into a content-addressable representation is a local operation that doesn't require any network connectivity. Many CLI tools perform this transformation locally before uploading. +::: + +## Retrieving with a gateway + +Now that your file is pinned to a pinning service, you can fetch it using an IPFS gateway. An [**IPFS Gateway**](../concepts/ipfs-gateway.md) is an HTTP interface that serves as a bridge to the IPFS network. + +You can retrieve your content using curl or a web browser: + +### Using service-specific gateways + +**Storacha Gateway:** +```shell +curl https://[CID].ipfs.w3s.link/ +# or +curl https://w3s.link/ipfs/[CID] +``` + +**Pinata Gateway:** +```shell +curl https://gateway.pinata.cloud/ipfs/[CID] +``` + +**Filebase Gateway:** +```shell +curl https://[BUCKET_NAME].ipfs.filebase.io/ipfs/[CID] +``` + +### Using public gateways + +```shell +curl https://ipfs.io/ipfs/[CID] +# or +curl https://dweb.link/ipfs/[CID] +``` + +:::callout +When pinning a file to IPFS, the filename is not stored by default. To ensure the filename is retained, it's common to wrap the file in a directory. In such instances, both the file and the directory will have unique CIDs. +::: + +## Summary and next steps + +In this quickstart guide, you learned about [pinning services](../concepts/persistence.md#pinning-in-context), and how to use them to publish content-addressed data with IPFS using command-line tools. You explored different CLI options for Storacha, Pinata, and Filebase. + +Pinning services provide a convenient alternative to running IPFS nodes and infrastructure. However, the two are not mutually exclusive; you can combine a pinning service with an IPFS node on your computer to increase the resilience of your CIDs. + +Possible next steps include: + +- Check out [the lifecycle of data in IPFS](../concepts/lifecycle.md) to learn more about how publishing by pinning fits into the full lifecycle of data in IPFS +- Try fetching the pinned file by following the [retrieval quickstart](./retrieve.md) +- Explore the web-based upload experience in the [browser-based pin guide](./pin.md) +- Learn more about each service's API and software development kits: + - [Storacha CLI documentation](https://docs.storacha.network/cli/) + - [Pinata API reference](https://docs.pinata.cloud/api-reference) + - [Filebase S3 API guide](https://docs.filebase.com/api-documentation/s3-compatible-api) + - [Filebase IPFS RPC API](https://docs.filebase.com/api-documentation/ipfs-rpc-api) \ No newline at end of file diff --git a/docs/quickstart/pin.md b/docs/quickstart/pin.md new file mode 100644 index 000000000..e27224f2d --- /dev/null +++ b/docs/quickstart/pin.md @@ -0,0 +1,154 @@ +--- +title: 'Pin a file with IPFS using a pinning service' +description: 'Learn how to publish content with IPFS by pinning a file to a pinning service.' +--- + +# Pin a file with IPFS + +In this quickstart guide, you will learn about [pinning services](../concepts/persistence.md#pinning-in-context) and how to use their **web interfaces** to publish content with IPFS. By the end of this guide, you should have a better understanding of how content addressing and CIDs work from a high level. + +:::callout +If you prefer command-line tools, see [Pin using the command line](./pin-cli.md). +::: + +## Contents + +- [Overview](#overview) +- [Pinning services](#pinning-services) +- [Prerequisites](#prerequisites) +- [Upload and pin a file](#upload-and-pin-a-file) +- [CIDs explained](#cids-explained) +- [Retrieving with a gateway](#retrieving-with-a-gateway) +- [Summary and next steps](#summary-and-next-steps) + +## Overview + +_Pinning_ refers to the process of ensuring that a particular piece of content is retrievable with IPFS. In other words, pinning is equivalent to storing a file on a computer or server that is connected to the internet, thereby making it available to the rest of the IPFS network. + +Pinning can be done at various levels, from individual files to entire directories that are addressed by a CID. You can also pin CIDs to multiple IPFS nodes to increase the redundancy and resilience of the file on the network. + +## Pinning services + +[Pinning services](../concepts/glossary.md#pinning-service) are similar to hosting services, in that they run an IPFS node for you and ensure that your files are available to the IPFS network. + +:::callout +Data pinned to the IPFS network is public by default and retrievable by anyone. Avoid publishing private data or adequately encrypt it before publishing. +::: + +## Self-hosting option + +You can also run your own IPFS node to pin files locally! [IPFS Desktop](../install/ipfs-desktop.md) provides an easy-to-use graphical interface for managing your own IPFS node: + +- **Pin files locally**: Use the Files screen in IPFS Desktop to import and pin files. Right-click any file to access the Pin option in the context menu +- **Combine with pinning services**: For better [redundancy](../concepts/glossary.md#redundancy), you can pin files to both your local node, and remote pinning services +- **Learn more**: Follow the [IPFS Desktop tutorial](../how-to/desktop-app.md) to get started with [self-hosting](../concepts/glossary.md#self-hosting) + +Running your own node gives you full control over your data while still participating in the global IPFS network. + +## Prerequisites + +To follow along with this guide, you'll need: + +- **Option A**: Your own IPFS node + - Install [IPFS Desktop](../install/ipfs-desktop.md) for a graphical interface + +- **Option B**: An account with at least one pinning service (free tier is sufficient): + - [Pinata](https://pinata.cloud/) - Popular IPFS pinning service with simple web interface + - [Filebase](https://filebase.com) - S3-compatible pinning service with web dashboard + - [Storacha](https://storacha.network) - Decentralized storage network + +- A sample file to upload, such as the [following image](../quickstart/images/welcome-to-IPFS.jpg): + +![image](../quickstart/images/welcome-to-IPFS.jpg) + +## Upload and pin a file + +Choose one of the following options to upload and pin your first file: + +### Using IPFS Desktop (self-hosted) + +If you're running IPFS Desktop, follow the [add local files](../how-to/desktop-app.md#add-local-files) tutorial to import your file. Once imported, right-click the file and select **Pin** to ensure it stays on your node. To get the CID, see [sharing files](../how-to/desktop-app.md#share-files). + +You can also configure remote pinning services in IPFS Desktop. See [working with remote pinning services](../how-to/work-with-pinning-services.md) for details. + +### Using a pinning service + +Choose one of the following pinning services and use their web interface: + +- **Pinata**: Use the [Pinata App](https://app.pinata.cloud) for a simple drag-and-drop upload experience - see their [quickstart tutorial](https://docs.pinata.cloud/quickstart) +- **Filebase**: Access their web dashboard and follow their [pin your first file guide](https://docs.filebase.com/getting-started/getting-started-guides/pin-your-first-file-to-ipfs) +- **Storacha**: Requires some technical skills, but their [browser upload guide](https://docs.storacha.network/how-to/upload/) may be a useful option if you are developing a web application. You can also visit [console.storacha.network](https://console.storacha.network) for web-based uploads + +Each option will provide you with a **CID** (Content Identifier) after uploading your file. Save this CID as you'll use it to retrieve your file in the next sections. + +## CIDs explained + +In IPFS, every file and directory is identified with a Content Identifier ([CID](../concepts/content-addressing.md)). The CID serves as the **permanent address** of the file and can be used by anyone to find it on the IPFS network. + +When a file is first added to an IPFS node (like the image used in this guide), it's first transformed into a content-addressable representation in which the file is split into smaller chunks (if above ~1MB) which are linked together and hashed to produce the CID. + +For example, a CID might look like: + +```plaintext +bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4 +``` + +You can now share the CID with anyone and they can fetch the file using IPFS. + +To dive deeper into the anatomy of the CID, check out the [CID inspector](https://cid.ipfs.tech/#bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4) + +:::callout +The transformation into a content-addressable representation is a local operation that doesn't require any network connectivity. With many pinning services, this transformation happens client-side (in the browser). +::: + +## Retrieving with a gateway + +Now that your file is pinned to a pinning service, you can fetch it using an IPFS gateway. An [**IPFS Gateway**](../concepts/ipfs-gateway.md) is an HTTP interface that serves as a bridge to the IPFS network. In other words, it allows you to fetch CIDs from IPFS using HTTP in your web browser. + +Pinning services typically offer their own IPFS gateways: + +### Pinata Gateway +Pinata offers both public and dedicated gateway options. Their dedicated gateways provide better performance and reliability for production use. Access your content via: +- `https://gateway.pinata.cloud/ipfs/[CID]` + +Learn more about the differences between public and dedicated gateways in [Pinata's gateway guide](https://knowledge.pinata.cloud/en/articles/6297294-public-gateways-vs-dedicated-gateways). + +### Filebase Gateway +Filebase provides gateway access with the format: +- `https://[BUCKET_NAME].ipfs.filebase.io/ipfs/[CID]` + +Note that the Filebase gateway may refuse HTML hosting and primarily works with assets like images or videos. For details, see [Filebase IPFS gateway documentation](https://docs.filebase.com/ipfs-concepts/what-is-an-ipfs-gateway). + +### Storacha Gateway +Storacha provides gateway access through w3s.link. You can retrieve content using formats like: +- `https://[CID].ipfs.w3s.link` +- `https://w3s.link/ipfs/[CID]` + +For more details about their gateway options, see [Storacha IPFS gateway documentation](https://docs.storacha.network/concepts/ipfs-gateways/). + +### Public Gateways +You can also use public IPFS gateways to retrieve any CID: +- `https://ipfs.io/ipfs/[CID]` +- `https://dweb.link/ipfs/[CID]` + +Simply replace `[CID]` with your actual CID in your browser's address bar to retrieve your file. + +:::callout +When pinning a file to IPFS, the filename is not stored by default. To ensure the filename is retained, it's common to wrap the file in a directory. In such instances, both the file and the directory will have unique CIDs. Many pinning services wrap files in a directory by default. +::: + +## Summary and next steps + +In this quickstart guide, you learned about [pinning services](../concepts/persistence.md#pinning-in-context), and how to use them to publish content-addressed data with IPFS through web interfaces. You explored different pinning service options and learned how to retrieve your content through IPFS gateways. + +Pinning services provide a convenient alternative to running IPFS nodes and infrastructure. However, the two are not mutually exclusive; you can combine a pinning service with an IPFS node on your computer to increase the resilience of your CIDs. + +Possible next steps include: + +- Check out [the lifecycle of data in IPFS](../concepts/lifecycle.md) to learn more about how publishing by pinning fits into the full lifecycle of data in IPFS +- Try fetching the pinned file by following the [retrieval quickstart](./retrieve.md) +- Learn how to [pin files using the command line](./pin-cli.md) +- Explore service-specific documentation: + - [Pinata documentation](https://docs.pinata.cloud/) + - [Filebase documentation](https://docs.filebase.com/) + - [Storacha documentation](https://docs.storacha.network) \ No newline at end of file diff --git a/docs/quickstart/publish.md b/docs/quickstart/publish.md deleted file mode 100644 index ee3a22f72..000000000 --- a/docs/quickstart/publish.md +++ /dev/null @@ -1,119 +0,0 @@ ---- -title: 'Publish a file with IPFS using a pinning service' -description: 'Learn how to publish content with IPFS by pinning a file to a pinning service.' ---- - -# Publish a file with IPFS - -:::warning -Some steps of this guide are currently outdated due to [changes with web3.storage](https://blog.web3.storage/posts/the-data-layer-is-here-with-the-new-web3-storage). -::: - -In this quickstart guide, you will learn about [pinning services](../concepts/persistence.md#pinning-in-context) and how to use them to publish content-addressed data with IPFS. To learn the process, you will upload the file to a pinning service called [web3.storage](https://web3.storage/). By the end of this guide, you should have a better understanding of how content addressing and CIDs work from a high level. - -:::callout -The web3.storage pinning service was chosen purely for demonstration purposes, and is one of many [pinning services](../concepts/persistence.md#pinning-in-context) you can choose from. While each pinning services has different SDKs and APIs, their fundamental role is the same - to store files and make them available to the IPFS network. In fact, one of the main benefits of IPFS is that files can be pinned to multiple pinning services, thereby reducing vendor lock-in. -::: - -## Contents - -- [Overview](#overview) -- [Pinning services](#pinning-services) -- [Prerequisites](#prerequisites) -- [Uploading and pinning a file](#uploading-and-pinning-a-file) -- [CIDs explained](#cids-explained) -- [Retrieving with a gateway](#retrieving-with-a-gateway) -- [Summary and next steps](#summary-and-next-steps) - -## Overview - -_Pinning_ refers to the process of ensuring that a particular piece of content is retrievable with IPFS. In other words, pinning is equivalent to storing a file on a computer or server that is connected to the internet, thereby making it available to the rest of the IPFS network. - -Pinning can be done at various levels, from individual files to entire directories that are addressed by a CID. You can also pin CIDs to multiple IPFS nodes to increase the redundancy and resilience of the file on the network. - -## Pinning services - -[Pinning services](../concepts/persistence.md#pinning-services) are similar to hosting services, in that they run an IPFS node for you and ensure that your files are available to the IPFS network. - -:::callout -Data pinned to the IPFS network is public by default and retrievable by anyone. Avoid publishing private data or adequately encrypt it before publishing. -::: - -## Prerequisites - -- A free [web3.storage](https://web3.storage/) account. -- The [following image](../quickstart/images/welcome-to-IPFS.jpg), downloaded and saved on your computer: - -![image](../quickstart/images/welcome-to-IPFS.jpg) - -## Upload and pin a file - -1. Sign into your account on web3.storage. - - ![web3.storage login window](./images/login-web3-storage.png) - -1. After logging in, click on **Upload files** to open the upload tab. - - ![web3.storage upload button](./images/web3-upload-button.png) - -1. Upload and pin the file by doing either dragging the [image file](../quickstart/images/welcome-to-IPFS.jpg) to the dashed rectangle labeled **Drag and drop your files here**, or clicking on the dashed rectangle to select the [image](../quickstart/images/welcome-to-IPFS.jpg) file. - - ![web3.storage upload tab](./images/web3-upload-tab.png) - - Once the file has been successfully uploaded, the following displays: - - ![web3.storage file uploaded](./images/web3-file-uploaded.png) - - If you close the upload tab, you should also be able to see a shortened **Content Identifier (CID)** of the uploaded image, **`bafyb...d32wm3q4`**, similar to the image below: - - ![file after upload](./images/web3-file-after-upload.png) - -Congratulations, you have successfully **pinned** a file to IPFS! 🎉 - -Let's unpack what just happened, by looking at CIDs. - -## CIDs explained - -In IPFS, every file and directory is identified with a Content Identifier ([CID](../concepts/content-addressing.md)). The CID serves as the **permanent address** of the file and can be used by anyone to find it on the IPFS network. - -When a file is first added to an IPFS node (like the image used in this guide), it's first transformed into a content-addressable representation in which the file is split into smaller chunks (if above ~1MB) which are linked together and hashed to produce the CID. - -In this guide, the CID for the uploaded image is: - -```plaintext -bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4 -``` - -You can now share the CID with anyone and they can fetch the file using IPFS. - -To dive deeper into the anatomy of the CID, check out the [CID inspector](https://cid.ipfs.tech/#bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4) - -:::callout -The transformation into a content-addressable representation is a local operation that doesn't require any network connectivity. With web3.storage, this transformation happens client-side (in the browser). -::: - -## Retrieving with a gateway - -Now that your file is pinned to a pinning service, you will fetch it using an IPFS gateway. An [**IPFS Gateway**](../concepts/ipfs-gateway.md) is an HTTP interface that serves as a bridge to the IPFS network. In other words, it allows you to fetch CIDs from IPFS using HTTP. - -Pinning services typically offer an IPFS gateway as a way to easily retrieve your CIDs. For example, Web3.storage operates the [w3s.link](https://w3s.link) gateway, from which you can retrieve the uploaded CID. - -To retrieve the CID, open the following URL: -[bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4.ipfs.w3s.link](https://bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4.ipfs.w3s.link/) - -:::callout -When pinning a file to IPFS, the filename is not stored by default. To ensure the filename is retained, it's common to wrap the file in a directory. In such instances, both the file and the directory will have unique CIDs. Web3.storage wraps files in a directory by default, which is why you see a directory listing with the file `welcome-to-IPFS.jpg` followed by a shorthand CID: `bafk…beom` of the file. -::: - -## Summary and next steps - -In this quickstart guide, you learned about [pinning services](../concepts/persistence.md#pinning-in-context), and how to use them to publish content-addressed data with IPFS. You also learned how CIDs address files and directories in IPFS by uploading a file to a pinning service called [web3.storage](https://web3.storage/). - -Pinning services provide a convenient alternative to running IPFS nodes and infrastructure. However, the two are not mutually exclusive; you can combine a pinning service with an IPFS node on your computer to increase the resilience of your CIDs. - -Possible next steps include: - -- Check out [the lifecycle of data in IPFS](../concepts/lifecycle.md) to learn more about how publishing by pinning fits into the full lifecycle of data in IPFS. -- Try fetching the pinned file by following the [retrieval quickstart](./retrieve.md). -- If you prefer to upload a file programmatically with JavaScript or Go, check out the [Web3.storage docs](https://web3.storage/docs/how-tos/store/). -- Alternatively, try out [Filebase](https://filebase.com/), a pinning service that offers an [AWS S3-compatible API for pinning](https://docs.filebase.com/getting-started/s3-api-getting-started-guide), so you can use any S3-compatible SDK, e.g. [aws-sdk](https://www.npmjs.com/package/aws-sdk), and [many](https://github.com/s3tools/s3cmd) more. diff --git a/docs/quickstart/publish_cli.md b/docs/quickstart/publish_cli.md deleted file mode 100644 index ae0f4ed66..000000000 --- a/docs/quickstart/publish_cli.md +++ /dev/null @@ -1,123 +0,0 @@ ---- -title: 'Publish using the command line' -description: 'Learn how to publish content with IPFS by pinning a file to a pinning service using the command line.' ---- - -# Publish a file with IPFS using the command line - -:::warning -Some steps of this guide are currently outdated due to [changes with web3.storage](https://blog.web3.storage/posts/the-data-layer-is-here-with-the-new-web3-storage). -::: - -Similar to the [Publish a file with IPFS](./publish.md) quickstart, this guide will teach you about [pinning services](../concepts/persistence.md#pinning-in-context) and how to use them to publish content-addressed data with IPFS. However, instead of using the [Web3 UI used in the related guide](./publish.md#upload-and-pin-a-file) , you will upload the file to [web3.storage](https://web3.storage/) using the [w3 command line interface](https://github.com/web3-storage/w3cli). By the end of this guide, you should have a better understanding of how content addressing and CIDs work from a high level, as well as how to use the w3 command line interface to publish data to IPFS. - -:::callout -The web3.storage pinning service was chosen purely for demonstration purposes, and is one of many [pinning services](../concepts/persistence.md#pinning-in-context) you can choose from. While each pinning services has different SDKs and APIs, their fundamental role is the same - to store files and make them available to the IPFS network. In fact, one of the main benefits of IPFS is that files can be pinned to multiple pinning services, thereby reducing vendor lock-in. -::: - -## Contents - -- [Overview](#overview) -- [Pinning services](#pinning-services) -- [Prerequisites](#prerequisites) -- [Uploading and pinning a file](#uploading-and-pinning-a-file) -- [CIDs explained](#cids-explained) -- [Retrieving with a gateway](#retrieving-with-a-gateway) -- [Summary and next steps](#summary-and-next-steps) - -## Overview - -_Pinning_ refers to the process of ensuring that a particular piece of content is retrievable with IPFS. In other words, pinning is equivalent to storing a file on a computer or server that is connected to the internet, thereby making it available to the rest of the IPFS network. - -Pinning can be done at various levels, from individual files to entire directories that are addressed by a CID. You can also pin CIDs to multiple IPFS nodes to increase the redundancy and resilience of the file on the network. - -## Pinning services - -[Pinning services](../concepts/persistence.md#pinning-services) are similar to hosting services, in that they run an IPFS node for you and ensure that your files are available to the IPFS network. - -:::callout -Data pinned to the IPFS network is public by default and retrievable by anyone. Avoid publishing private data or adequately encrypt it before publishing. -::: - -## Prerequisites - -- A unix-like terminal. -- Node.js installed in the terminal environment. -- The [following image](../quickstart/images/welcome-to-IPFS.jpg), downloaded and saved on your computer: - -![image](../quickstart/images/welcome-to-IPFS.jpg) - -## Install and register to w3 - -1. Install the [w3 command line interface](https://github.com/web3-storage/w3cli). - - ```shell - npm install -g @web3-storage/w3cli - -1. Authorize the w3 tool to act on behalf of the account associated with your email address ``: - - ```shell - w3 login - -## Upload and pin a file - -1. Create a space for your files. - - ```shell - w3 space create Pictures - -1. Upload your file. - - ```shell - w3 up welcome-to-IPFS.jpg - ``` - -Congratulations, you have successfully **pinned** a file to IPFS using the w3 cli! 🎉 - -Let's unpack what just happened, by looking at CIDs. - -## CIDs explained - -In IPFS, every file and directory is identified with a Content Identifier ([CID](../concepts/content-addressing.md)). The CID serves as the **permanent address** of the file and can be used by anyone to find it on the IPFS network. - -When a file is first added to an IPFS node (like the image used in this guide), it's first transformed into a content-addressable representation in which the file is split into smaller chunks (if above ~1MB) which are linked together and hashed to produce the CID. - -In this guide, the CID for the uploaded image is: - -```plaintext -bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4 -``` - -You can now share the CID with anyone and they can fetch the file using IPFS. - -To dive deeper into the anatomy of the CID, check out the [CID inspector](https://cid.ipfs.tech/#bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4). - -:::callout -The transformation into a content-addressable representation is a local operation that doesn't require any network connectivity. With web3.storage, this transformation happens client-side (in the browser). -::: - -## Retrieving with a gateway - -Now that your file is pinned to a pinning service, you will fetch it using an IPFS gateway. An [**IPFS Gateway**](../concepts/ipfs-gateway.md) is an HTTP interface that serves as a bridge to the IPFS network. In other words, it allows you to fetch CIDs from IPFS using HTTP. - -Pinning services typically offer an IPFS gateway as a way to easily retrieve your CIDs. For example, Web3.storage operates the [w3s.link](https://w3s.link) gateway, from which you can retrieve the uploaded CID. - -To retrieve the CID, open the following URL: -[bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4.ipfs.w3s.link](https://bafybeicn7i3soqdgr7dwnrwytgq4zxy7a5jpkizrvhm5mv6bgjd32wm3q4.ipfs.w3s.link/) - -:::callout -When pinning a file to IPFS, the filename is not stored by default. To ensure the filename is retained, it's common to wrap the file in a directory. In such instances, both the file and the directory will have unique CIDs. Web3.storage wraps files in a directory by default, which is why you see a directory listing with the file `welcome-to-IPFS.jpg` followed by a shorthand CID: `bafk…beom` of the file. -::: - -## Summary and next steps - -In this quickstart guide, you learned about [pinning services](../concepts/persistence.md#pinning-in-context), and how to use them to publish content-addressed data with IPFS. You also learned how CIDs address files and directories in IPFS by uploading a file to a pinning service called [web3.storage](https://web3.storage/). - -Pinning services provide a convenient alternative to running IPFS nodes and infrastructure. However, the two are not mutually exclusive; you can combine a pinning service with an IPFS node on your computer to increase the resilience of your CIDs. - -Possible next steps include: - -- Check out [the lifecycle of data in IPFS](../concepts/lifecycle.md) to learn more about how publishing by pinning fits into the full lifecycle of data in IPFS. -- Try fetching the pinned file by following the [retrieval quickstart](./retrieve.md). -- If you prefer to upload a file programmatically with JavaScript or Go, check out the [Web3.storage docs](https://web3.storage/docs/how-tos/store/). -- Alternatively, try out [Filebase](https://filebase.com/), a pinning service that offers an [AWS S3-compatible API for pinning](https://docs.filebase.com/getting-started/s3-api-getting-started-guide), so you can use any S3-compatible SDK, e.g. [aws-sdk](https://www.npmjs.com/package/aws-sdk), and [many](https://github.com/s3tools/s3cmd) more.