Pinata Go CLI: Installation, Setup, and Core Commands

In IPFS, pinning files ensures they remain on your local node and are protected from garbage collection, which automatically removes unpinned content that no longer exists on any node; the 'ipfs pin add' command pins files to prevent removal, while 'ipfs pin rm' unpins them, making them eligible for garbage collection; content on IPFS is immutable and extremely difficult to remove once distributed across multiple nodes, as the network will continue serving content from any node that has cached it.

IPFS (Interplanetary File System) is a distributed content addressable file system that stores data through cryptographic hashing, producing unique Content Identifiers (CIDs) that enable tamper-proof data retrieval across the network; however, data added to IPFS is not automatically persistent and may be garbage-collected if not pinned to always-on nodes, which is why services like Pinata exist to provide reliable, 24/7 data pinning for developers deploying decentralized applications.

Without pinning, IPFS content gets garbage-collected from nodes. Pin with 'ipfs pin add <hash>' to lock content locally. For production, use services like Fleek that automate pinning, handle updates, manage IPNS names, and provide reliable gateways. These platforms abstract complexity, offering Git integration and automatic deployment—similar to Netlify/Vercel for traditional hosting—while still storing content on IPFS. This hybrid approach balances decentralization benefits with practical usability.

Garbage collection is a mechanism in IPFS that automatically removes files that haven't been accessed for a long time. The system scans through files and identifies those that are not being requested by any node in the network. These files are then deleted from the network to free up storage space. Pinning is a feature that prevents files from being deleted by garbage collection. When you pin a file, you tell the network to keep it stored even if no one is requesting it. This is useful for files that need to be permanently available.

This section covers the fundamental concepts of IPFS and the Pinata service. IPFS stands for Interplanetary File System and is a peer-to-peer decentralized storage protocol. Files are identified by their hash, making IPFS URIs immutable—once a file is uploaded, it cannot change because the hash would change if the file were modified. Pinata provides a user-friendly web interface and SDKs for uploading files to IPFS. It also offers a pinning service that guarantees files will not be forgotten by the network, which is important because IPFS nodes may forget files that are not frequently accessed.

A command line interface (CLI) is a text-based user interface for running programs, managing files, and interacting with operating systems. Users enter text commands (input) and receive text output. Common CLIs include Bash for Unix/Linux, Z shell for Mac, Windows Command Prompt, and PowerShell. CLI commands follow a standard syntax: command (directive), options/flags (modify behavior), and arguments (parameters). Core navigation commands include pwd (display absolute path), ls (list directory contents with -l for detailed metadata), and cd (change directory with .. to return to parent or cd alone to return home). File and directory management commands include mkdir (create directories with -v for confirmation), touch (create empty files), cp (copy files/folders with -r for recursion), mv (move/rename files/folders), and rm (remove files/folders with -r for recursion). These commands form the foundation for efficient system navigation and file management.

Command line interfaces (CLI) are text-based systems essential for web development, programming, and system administration. Three main types exist: CMD (traditional Windows), PowerShell (newer Windows), and Bash (Unix/Linux/Mac). Launch CMD via Win+R and type 'cmd'; PowerShell via Start menu. Core navigation commands include 'pwd' (display current directory), 'cd' (change directory with '..' for up, [directory] for into, [drive]: for switching), 'dir' or 'ls' (list contents), and 'clear' (clear screen). File management commands include 'mkdir' (create directories), 'rename' (change names), 'remove' (delete), 'new-item' (create files), 'copy' (duplicate), and 'move' (relocate). Process management uses 'ps' (list processes) and 'kill [PID]' (terminate processes). The 'help' command provides syntax information. PowerShell scripts (.ps1 files) enable automation of repetitive tasks. These commands work identically across platforms, making them essential cross-platform technical skills.

A command line interface (CLI) is a text-based method of interacting with a computer system, where users type commands and press enter to execute them. A terminal provides the interface through which users interact with a shell, while a shell is the program that processes commands. Common shells include PowerShell, Bash, Zsh, and Fish. Different shells use different commands for similar functions, such as clearing the screen using 'cls' in Windows Command Prompt, 'clear' in PowerShell and Bash. Users can customize shells through aliases (shortcut names pointing to commands) and create custom commands using batch files. Directory navigation uses 'cd' and 'pwd' commands, with different syntax across shells. Creating files differs: 'touch' in Bash, 'New-Item' in PowerShell, and 'type nul >' in Windows Command Prompt. Viewing file contents uses 'cat' in Bash, 'type' in Windows Command Prompt, and 'Get-Content' in PowerShell. The 'echo' command outputs text or redirects it to files, with '>' overwriting and '>>' appending. Different shells handle quotes differently. Searching for text within files uses 'grep' in Bash, 'findstr' in Windows Command Prompt, and 'Select-String' in PowerShell. Command history is navigable using up/down arrows, with Windows Command Prompt using F7 and Bash offering 'reverse search' (Ctrl+R). Running commands as an administrator requires different approaches: Ctrl+Shift in Windows, 'sudo' in Linux. Administrator privileges allow system-level changes that regular users cannot perform.

The terminal is a text-based interface that serves as the standard method for communicating with computers, operating without visual elements and returning raw data. It originated from early computing systems that lacked graphical interfaces and remains essential for servers where graphical interfaces are impractical. The shell interprets commands and converts them into executable instructions, with different systems using different shells like Bash, ZSH, or PowerShell. Core navigation commands include 'ls' for listing files, 'pwd' for displaying the current directory, 'cd' for changing directories, and 'clear' for emptying the screen. The 'tab' key provides command and path completion, streamlining navigation and command entry.

Command Line Interface (CLI) is a text-based user interface where users type commands to instruct computers. The shell acts as a translator between user commands and the operating system. Windows Command Prompt (cmd) and PowerShell are the primary interfaces. Basic navigation commands include 'dir' to list files, 'cd' to change directories, and 'cd ..' to move up one level. File management commands include 'mkdir' to create folders, 'rmdir' to remove folders, 'type nul > filename.txt' to create empty files, 'echo' to add content, 'ren' to rename, 'copy' to duplicate, 'move' to relocate, 'del' to delete files, and 'cls' to clear the screen. Users can run programs by typing the program name followed by the filename, and open editors like VS Code using 'code .'

API keys and JWT tokens serve fundamentally different authentication purposes. API keys identify applications and grant access to services, while JWT tokens identify specific users and control resource-level permissions. API keys are appropriate for automated system-to-system communication where application identity matters more than individual user tracking. JWT tokens are necessary when tracking which specific user performed actions within a system. For example, YouTube uses API keys for application access but JWT tokens for user authentication. The choice depends on whether you need to control which applications can access your service or which users can access specific resources.

Basic authentication sends credentials with each request, verified by the server. API key authentication uses shared keys for authentication. Token-based authentication uses access tokens with expiry dates, more secure than basic authentication. JWT (JSON Web Token) is a token format where the server creates a token with a secret and sends it to the client. The client includes the JWT in the Authorization header of subsequent requests. The server verifies the JWT signature to authenticate the client. JWT tokens consist of three parts: Header (token type and algorithm), Payload (claims like user information), and Signature (verifies issuer and prevents tampering).

API authentication is the process of verifying client identities to ensure only authorized users or systems can access API resources, preventing data leaks and unauthorized access. Four common methods exist: API Key Authentication uses unique keys generated for each client, included in request headers or query parameters, with the server validating against a database; HTTP Basic Authentication sends username and password encoded in base64 within the authorization header, though it's insecure as credentials are sent unencrypted with every request; JWT (JSON Web Token) Authentication involves the server generating signed tokens containing user data (ID, roles, expiration) that clients include in authorization headers, eliminating the need for server-side session storage; OAuth is a protocol enabling third-party applications to access user resources without exposing credentials, using an authorization code flow where users grant permissions and applications exchange codes for access tokens. These authentication methods provide essential security features including identity verification, controlled access through permissions and roles, usage monitoring, and rate limiting to prevent abuse.

API security involves two distinct concepts: authentication (verifying identity) and authorization (determining permissions). API keys are simple identifiers passed with requests but are static and less secure. OAuth enables delegated trust, allowing apps to access user data without passwords through temporary tokens. JWTs (JSON Web Tokens) are self-contained tokens with header, payload (user claims), and signature, enabling stateless verification ideal for scalable microservices. Each method serves different use cases: API keys for server-to-server communication, OAuth for user-delegated access, and JWTs for high-performance, stateless authentication.

JWT (JSON Web Token) is a protocol for securing API endpoints by ensuring entities have proper privileges. The backend must validate tokens using a secret key, as tokens can be manipulated and the frontend cannot be trusted for validation. JWT consists of three parts: Header (type and algorithm), Payload (user metadata and roles), and Signature (ensures validity using the secret key). The authentication flow involves login returning a JWT, frontend including it in Authorization headers, and backend validating permissions. Protected endpoints require authentication while login endpoints remain public.