# Linuxtastic

> Everything Linux


## Posts

- [What a Shell Actually Is, and Which One to Use](https://linuxtastic.com/learn/the-shell/): The shell is a program, not the terminal it runs in. Which startup file runs when, why your alias vanishes over SSH, and an honest comparison of bash, zsh and fish.
- [SSH Keys: What Is Actually Happening](https://linuxtastic.com/learn/ssh-keys-explained/): Key pairs, host keys, the agent and forwarding — what each part does, why the warning about a changed host key matters, and how to hold keys safely.
- [Filesystems: Inodes, Journalling and Which One to Choose](https://linuxtastic.com/learn/filesystems/): What an inode is and why you can run out of them, what journalling protects you from, and an honest comparison of ext4, XFS, Btrfs and ZFS.
- [Linux Networking from First Principles](https://linuxtastic.com/learn/networking-explained/): Addresses, subnets, gateways, ports, DNS and NAT — what each one is for, and a diagnostic order that finds the broken layer in about a minute.
- [Ansible: When to Stop Writing Setup Scripts](https://linuxtastic.com/tools/ansible/): Ansible describes what a server should look like instead of the steps to get there. What idempotence buys you, a first playbook that works, and when it is overkill.
- [fzf: Fuzzy Finding, and What It Does to Your Shell](https://linuxtastic.com/tools/fzf/): fzf turns any list into something you pick from interactively — command history, files, git branches, running processes. The setup that matters and how to build your own pickers.
- [jq: Working with JSON on the Command Line](https://linuxtastic.com/tools/jq/): Every API returns JSON and none of the classic Unix tools can read it. jq is the missing piece — the handful of filters worth learning, and where it stops being the right tool.
- [eza vs ls: A Better Listing (and Why Not exa)](https://linuxtastic.com/tools/eza-vs-ls/): eza gives you colour, a tree view and git status in your file listings. Why exa is no longer the one to install, and why ls -l should stay in your scripts.
- [tldr vs man: Examples When You Just Need the Command](https://linuxtastic.com/tools/tldr-vs-man/): man pages are complete and unreadable in a hurry. tldr gives you the five commands people actually use. Why you need both, and the man features nobody knows about.
- [bat vs cat and less: Reading Files Without Squinting](https://linuxtastic.com/tools/bat-vs-cat/): bat adds syntax highlighting, line numbers and paging to cat. The batcat naming trap, using it as a man pager, and why plain cat still belongs in your pipes.
- [tmux vs screen: Never Lose Work to a Dropped Connection](https://linuxtastic.com/tools/tmux-vs-screen/): A terminal multiplexer keeps your work running when SSH drops. What tmux and screen each do, the keys that matter, and why the older one is still worth knowing.
- [Tailscale: Reaching Your Servers Without Opening Ports](https://linuxtastic.com/tools/tailscale/): A mesh VPN that puts your machines on one private network wherever they are — no port forwarding, no exposed SSH. What it does, and what depending on it means.
- [ncdu and dust vs du: Finding What Filled the Disk](https://linuxtastic.com/tools/ncdu-vs-du/): du tells you the truth in a format nobody enjoys reading. ncdu makes it navigable and lets you delete from the results. When to use each, including on a server with no spare space.
- [htop and btop vs top: Watching a Machine Work](https://linuxtastic.com/tools/htop-vs-top/): htop makes top's information legible and lets you act on it. btop goes further. Here is what each one shows, the keys worth learning, and why top is still the one to know.
- [fd vs find: A Friendlier Way to Locate Files](https://linuxtastic.com/tools/fd-vs-find/): fd finds files with a fraction of find's typing, but find can do things fd cannot. The syntax translation, the fdfind naming trap, and where the classic still wins.
- [ripgrep vs grep: Which Should You Actually Use?](https://linuxtastic.com/tools/ripgrep-vs-grep/): ripgrep is faster than grep and skips the files you did not want anyway. Here is what it changes, a syntax translation table, and the cases where grep is still the right answer.
- [Processes and Memory: What the Numbers Actually Mean](https://linuxtastic.com/learn/processes-and-memory/): What a process really is, why load average is not CPU percentage, why free -h always looks alarming, and how the OOM killer decides what to kill.
- [How Linux Boots, and Where It Goes Wrong](https://linuxtastic.com/learn/how-linux-boots/): Firmware to bootloader to kernel to systemd, in order — what each stage does, how to tell which one failed, and how to recover from each.
- [The Linux Filesystem: What Every Directory Is For](https://linuxtastic.com/learn/filesystem-hierarchy/): A tour of the top-level directories on a Linux system — what belongs in each, why /usr and /var are split, and where to look for the file you are actually after.
- [Users, Groups and Root: How Linux Decides Who Can Do What](https://linuxtastic.com/learn/users-and-groups/): UIDs and GIDs, why most accounts on your system are not people, what root actually is, and the group memberships that quietly hand out administrative power.
- [Ubuntu: The Default Choice, and When It Should Not Be](https://linuxtastic.com/distros/ubuntu/): How Ubuntu's release cycle and support windows actually work, what snaps are and why people argue about them, and an honest account of who Ubuntu suits.
- [Arch Linux: What Rolling Release Actually Costs](https://linuxtastic.com/distros/arch-linux/): How pacman and the AUR work, why partial upgrades break systems, what maintaining a rolling release actually involves, and an honest answer on whether you should run it.
- [Fedora: Where Red Hat Linux Gets Built](https://linuxtastic.com/distros/fedora/): Fedora's six-month cadence, how it feeds CentOS Stream and RHEL, living with dnf and SELinux, and why it is the desktop to run if your servers are Red Hat.
- [Debian: Stable Means Unchanging, Not Bug-Free](https://linuxtastic.com/distros/debian/): How Debian's stable, testing and unstable branches work, what backports are for, why it runs so many servers, and where it differs from Ubuntu in practice.
- [Migrating a Server Without Downtime](https://linuxtastic.com/guides/server-migration/): Moving a site to a new server: syncing files with rsync, dumping and restoring databases, testing the new box before anyone points at it, and cutting DNS over safely.
- [Reading Linux Logs: journalctl and the Files It Did Not Replace](https://linuxtastic.com/guides/reading-logs/): Finding the failure in journalctl and in traditional log files: filtering by time, unit and priority, and a repeatable method for diagnosing something that just broke.
- [Linux Firewalls: ufw, firewalld and What They Miss](https://linuxtastic.com/guides/linux-firewalls/): How to configure a host firewall properly with ufw or firewalld, why Docker quietly punches holes through it, and where cloud security groups fit in.
- [Getting Started with Docker](https://linuxtastic.com/guides/docker-basics/): A container is a process on your machine, isolated from the rest of it and shipped with everything it needs to run.
- [Securing a New Linux Server](https://linuxtastic.com/guides/securing-a-new-server/): A server exposed to the internet starts receiving automated login attempts within minutes of booting.
- [Set Up a Web Server with Nginx](https://linuxtastic.com/guides/nginx-web-server/): From a bare server to a site served over HTTPS with a certificate that renews itself.
- [Automated Backups with rsync and systemd Timers](https://linuxtastic.com/guides/automated-backups/): By the end of this you will have nightly snapshots that each look like a complete copy while costing almost nothing in disk space, running on a schedule, logged where you can see them, and — the part most guides skip — actually tested by restoring something.
- [Linux Command Line Basics](https://linuxtastic.com/guides/command-line-basics/): The terminal looks unwelcoming because it tells you nothing about what it can do.
- [sudo — Running Commands as Another User](https://linuxtastic.com/commands/sudo/): sudo runs one command as another user, normally root, after checking that you are allowed to.
- [rsync — Sync Files and Directories](https://linuxtastic.com/commands/rsync/): rsync copies files, but only the parts that changed.
- [vim and nano — Editing Files in a Terminal](https://linuxtastic.com/commands/vim-and-nano/): Sooner or later you will SSH into a server, type vim or find yourself dropped into it by git commit, and discover that nothing you try makes it stop.
- [Disks and Mounting — lsblk, mount and fstab](https://linuxtastic.com/commands/disks-and-mounting/): Linux does not have drive letters. Every filesystem is grafted onto a single tree at a mount point — a directory that becomes the doorway to that storage.
- [Package Management — apt, dnf and pacman](https://linuxtastic.com/commands/package-management/): Every distribution installs software from repositories, and every distribution family uses a different command to do it.
- [curl and wget — Fetch Things Over HTTP](https://linuxtastic.com/commands/curl-and-wget/): Both fetch things over HTTP. The difference in practice: curl is for talking to things — APIs, headers, authentication, sending data.
- [ln — Hard Links and Symbolic Links](https://linuxtastic.com/commands/ln/): Linux has two kinds of link and they are not variations on the same idea — they work at different levels of the filesystem.
- [Networking Basics — ip, ss, ping and dig](https://linuxtastic.com/commands/networking-basics/): "The network is broken" is four or five different problems wearing the same coat.
- [awk — Process Text by Fields](https://linuxtastic.com/commands/awk/): Where grep finds lines and sed edits them, awk understands that a line has columns.
- [Disk Space — df, du and ncdu](https://linuxtastic.com/commands/disk-space/): Sooner or later a Linux machine tells you No space left on device and something stops working.
- [cron — Schedule Recurring Jobs](https://linuxtastic.com/commands/cron/): cron runs commands on a schedule.
- [Processes — ps, top and htop](https://linuxtastic.com/commands/processes/): When a machine is slow, unresponsive, or something is running that should not be, these are the tools that tell you what is actually happening.
- [tar — Create and Extract Archives](https://linuxtastic.com/commands/tar/): tar bundles many files into one.
- [systemctl — Manage Services with systemd](https://linuxtastic.com/commands/systemctl/): systemctl is how you start, stop, inspect and configure services on any modern Linux distribution.
- [ssh — Remote Access, Keys and Tunnels](https://linuxtastic.com/commands/ssh/): ssh gives you an encrypted shell on another machine.
- [sed — Find and Replace in Streams and Files](https://linuxtastic.com/commands/sed/): sed is a stream editor: it reads text line by line, applies the edits you specify, and writes the result out.
- [find — Locate Files by Name, Size and Time](https://linuxtastic.com/commands/find/): Where grep searches inside files, find searches for the files themselves — by name, size, age, ownership, permissions, or any combination.
- [File Permissions — chmod, chown and umask](https://linuxtastic.com/commands/file-permissions/): Linux file permissions look cryptic for about a week and then become second nature.
- [grep — Search Text and Files](https://linuxtastic.com/commands/grep/): grep searches text for lines matching a pattern and prints them.
- [The Life of a Network Interface: Eight Stages, and the Address Your Network Manager Did Not Give You](https://linuxtastic.com/learn/life-of-a-network-interface/): How a Linux network interface gets its name, its owner, its address, its routes and its "online" — eight stages, no two done by the same program, and the three-line command that shows which one decided.
- [The Life of an SSH Connection: Seven Stages, and the Message That Names the Wrong One](https://linuxtastic.com/learn/life-of-an-ssh-connection/): A deploy job that has connected to the same server for two years starts failing, a few times an hour, with kex_exchange_identification: read: Connection reset by peer.
- [The Life of a Reload: Seven Steps Between Saving a File and a Process Using It](https://linuxtastic.com/learn/life-of-a-reload/): systemctl reload reports the exit status of a command the package maintainer chose. Whether the program adopted your file is a separate event, and nothing on the machine records it. Seven steps, measured on Ubuntu 24.04 against nginx, sshd, haproxy and Apache.
- [The Life of a Block Device: Seven Names for One Disk, and Not One of Them Is Both Stable and Unique](https://linuxtastic.com/learn/life-of-a-block-device/): Every name a Linux disk has is either a value stored inside it, and so copied by anything that copies the disk, or a description of the slot it is plugged into, and so changed by moving it. Eight stages between the kernel noticing a disk and a person asking which physical device they are actually looking at.
- [The Life of a Scheduled Job: Eight Stages, and the Failure You Should Fear Exits Zero](https://linuxtastic.com/learn/life-of-a-scheduled-job/): A scheduled job is the only routine thing on a Linux machine that destroys the evidence it ran by succeeding. Eight stages between the line you wrote and the person who needed last night's output, and why every alarm you have set is keyed on the wrong event.
- [The Life of an Outbound Email: Four Addresses, and the One You Set Is the One Nobody Checks](https://linuxtastic.com/guides/life-of-an-outbound-email/): The nine stages between an application calling sendmail and a person deciding they wanted it — and why every mechanism that judges the message authenticates an address somebody else chose.
- [The Life of a Log Line: Every Field Has an Author, and the Record Does Not Say Who](https://linuxtastic.com/learn/life-of-a-log-line/): The standard way to answer "who logged in as root" is one of three commands: journalctl -t sshd, journalctl _COMM=sshd, or journalctl -u ssh.
- [Restoring a Linux Server: What the Backup Kept and the Restore Threw Away](https://linuxtastic.com/guides/restoring-a-server/): The seven stages between a backup and a working machine, and the six decisions the restore makes that the backup did not. Why diff exits 0 on a tree that lost its ACLs, its capabilities and 256 MB of sparseness — and why a restore is a duplication rather than a return.
- [How Time Works on a Linux Machine: When the Clock Moves, Nothing Writes It Down](https://linuxtastic.com/learn/how-time-works/): A small VM comes back from a reboot during a maintenance window, and some hours later one scheduled job starts failing with certificate is not yet valid.
- [Building a Container Image: What a Green Build Log Does Not Prove](https://linuxtastic.com/guides/building-a-container-image/): A build goes green, the image is pushed, the deploy succeeds, and every route returns 404.
- [What Ships in Your Container Image, and What Happens to It After You Push](https://linuxtastic.com/learn/what-ships-in-your-container-image/): A node is replaced, the pod that lands on it goes to ImagePullBackOff, and nothing has changed: the deployment pins the image by digest, the registry still answers for that manifest with a 200, crane manifest, skopeo inspect and docker buildx imagetools inspect all report a healthy image, and the pods on the older nodes are still running it.
- [The Life of a DNS Zone: What Your Parent Publishes About You](https://linuxtastic.com/guides/life-of-a-dns-zone/): A company changes DNS providers on a Friday.
- [The Half of Patching That Happens After the Patch is Installed](https://linuxtastic.com/guides/keeping-a-server-patched/): A machine has just taken a real OpenSSL security upgrade.
- [The Life of a System Call: Who Actually Answered](https://linuxtastic.com/learn/life-of-a-system-call/): Here is a small program. It opens a file, forks, waits for the child, asks its own PID and exits: five library calls, every one written by name.
- [etcd, Honestly](https://linuxtastic.com/guides/etcd-honestly/): Six stages, from the member that answered to the restore that hands your data back on a clock that has been wound backwards. Why a successful etcd restore can break every controller in the cluster, why the fsync metric everyone recommends is not a disk metric, and why deleting keys under a quota alarm makes it worse.
- [The Life of a Unix Socket](https://linuxtastic.com/learn/life-of-a-unix-socket/): Seven stages, from an object with no name to a name with no object. Why every diagnostic tool on the machine prints a path it never checked, why only the write bit gates a connection, and why the kernel will tell you who is on the other end but never admits when it does not know.
- [The Life of a Certificate](https://linuxtastic.com/guides/life-of-a-certificate/): The six stages between an ACME account and a certificate your server is actually serving, and the two private keys that never meet. Why a renewal that succeeds proves nothing about your challenge setup, why the dry run skips the step that breaks, and who decides when your certificate should be replaced.
- [How a Path Becomes a File](https://linuxtastic.com/learn/how-a-path-becomes-a-file/): Path resolution is not a function from strings to strings. The six stages between a pathname and an open file: the trailing slash that defeats O_NOFOLLOW, why .. is a live pointer rather than a text edit, and the single descriptor that returns two different files.
- [The Life of a File Descriptor: Seven Stages from open() to close()](https://linuxtastic.com/learn/life-of-a-file-descriptor/): A daemon starts in under a second on one host and takes forty minutes on another — same image, same version, same configuration.
- [Kubernetes, Honestly: Seven Stages Between kubectl apply and a Running Container](https://linuxtastic.com/guides/kubernetes-honestly/): A self-managed cluster is upgraded from v1.33 to v1.36, and containerd from 1.7 to 2.3 in the same window. Pods start.
- [The Life of a Package: Eight Stages Between apt install and Working Software](https://linuxtastic.com/learn/life-of-a-package/): A server has been running fine for years.
- [The Life of a Login: Seven Stages Between a Password and a Shell](https://linuxtastic.com/learn/life-of-a-login/): A deployment pipeline that has restarted an application over SSH for two years, as the service account that owns it, starts failing the week the hosts are rebuilt onto a newer release: systemctl --user restart myapp now returns Failed to connect to bus: No medium found.
- [What Happens When You Type a URL: The Six Stages Before Anything Is Rendered](https://linuxtastic.com/learn/what-happens-when-you-type-a-url/): An internal service is served with a certificate from the company's own CA.
- [DNS, All the Way Down: From getaddrinfo to an Answer](https://linuxtastic.com/learn/dns-all-the-way-down/): An application on a VPN-connected laptop cannot reach db.internal.corp.example.
- [Memory, All the Way Down: From malloc to the OOM Killer](https://linuxtastic.com/learn/memory-all-the-way-down/): Eight stages between a program asking for memory and something being killed for it. Killing is the last one, and almost everything interesting happens before it. This follows a single page the whole way down, with the command that inspects each stage and the one question that tells you whether your machine is actually short of memory at all.
- [Running PostgreSQL Properly: A Transaction's Path to Durability](https://linuxtastic.com/guides/running-postgresql-properly/): Eight stages between a client sending COMMIT and data you could still restore a year later. The client waits on exactly one of them. This follows the whole path on a self-hosted server, with the setting that matters at each stage, the command that inspects it, and the widely repeated advice that has quietly expired.
- [Containers, All the Way Down: What docker run Actually Does](https://linuxtastic.com/learn/containers-all-the-way-down/): A container is not a kernel object. It is an ordinary process with nine things done to it first. This follows docker run all the way down: the registry request, the manifest, the layers, the overlay mount, the OCI bundle, the namespaces, the cgroup, the sandbox and the execve, with the command that inspects each stage.
- [The Shell, in Depth: From Enter to Exit Status](https://linuxtastic.com/learn/the-shell-in-depth/): Between pressing Enter and getting your prompt back, the shell rewrites your command line in six stages before anything runs, finds the program four different ways, and puts it in a process group that decides who owns the terminal. Every quoting bug and every "works by hand, fails in cron" lives in one of those steps.
- [The Life of a Write: From write() to the Disk](https://linuxtastic.com/learn/life-of-a-write/): Your write() call returned successfully and nothing is on the disk. Seven layers sit between that return and durable storage — page cache, filesystem, device mapper, block layer, device cache — each with its own idea of when a write is finished, and each with one command that tells you what it is doing.
- [From Power-On to a Login Prompt](https://linuxtastic.com/learn/power-on-to-login/): Eight handoffs stand between the power button and a shell, each one to a program that knows almost nothing about the last. Firmware, shim, bootloader, kernel, initramfs, the switch to the real root, systemd and getty — with the command that tells you which of them failed.
- [Permissions and Privilege, Properly](https://linuxtastic.com/learn/permissions-and-privilege/): Six independent layers stand between a process and a file, and every one of them can say no on its own. Mode bits, ACLs, capabilities, LSMs and user namespaces — in the order the kernel actually checks them, with the command that inspects each.
- [The Life of a Packet: What Really Happens When Your Application Sends Data](https://linuxtastic.com/learn/life-of-a-packet/): From write() to the wire and back again — sockets, the routing decision, netfilter, conntrack, ARP, queueing disciplines, offloads and the container detour. The long version, because almost every hard network problem lives in one of these layers.
- [A Second Machine: Redundancy, and Whether You Actually Need It](https://linuxtastic.com/guides/a-second-machine/): Two servers is not twice as reliable. It is twice as much to maintain, plus a class of failure that only exists when there are two. Here is how to decide, and how to do it if the answer is yes.
- [Hardening a Public-Facing Service Beyond the Basics](https://linuxtastic.com/guides/hardening-a-service/): You have closed the ports and set up key-only SSH. This is the next layer: making the service itself unable to do damage if it is compromised, using directives you already have and are probably not using.
- [Getting a Domain and Its DNS Right](https://linuxtastic.com/guides/domains-and-dns/): Buying the domain is the easy part. Where the nameservers point, which records exist, and what your TTL is on the day you move — those are what decide whether a migration is invisible or a bad afternoon.
- [Centralising Logs When One Server Is No Longer Enough](https://linuxtastic.com/guides/log-shipping/): Three machines means three journals and no way to follow a request across them. Here is a small, honest setup using Loki and Alloy — and a note about Promtail, which is not deprecated any more, it is gone.
- [Manjaro, EndeavourOS and CachyOS: The Arch Derivatives Compared](https://linuxtastic.com/distros/arch-derivatives/): They all give you Arch without the manual install, and then they differ on the one thing that matters most — whether you are getting packages from Arch's repositories or from someone else's copy of them.
- [The BSDs: FreeBSD, OpenBSD and NetBSD, for Linux People](https://linuxtastic.com/distros/the-bsds/): Not distributions of a kernel but complete operating systems, developed as a single thing, under a licence that lets anyone ship them without giving anything back. What that actually changes, from someone coming from Linux.
- [Slackware: The Oldest One Still Standing](https://linuxtastic.com/distros/slackware/): The last stable release was in February 2022, which sounds like abandonment and is not — the development branch was updated yesterday. Here is what Slackware actually is, and the one design decision everything else follows from.
- [Container Host Distributions: Fedora CoreOS, Flatcar and Talos](https://linuxtastic.com/distros/container-host-distros/): Server operating systems that exist only to run containers. No package manager to speak of, no SSH in one case, and updates that arrive as a whole new image — which is either exactly what you want or completely wrong for you.
- [Syncthing: Your Own Files, on All Your Machines, With No Cloud](https://linuxtastic.com/tools/syncthing/): Continuous file sync between your own devices, encrypted in transit, with nobody's server holding a copy. Plus the Android situation, which changed in 2024 and trips up everyone arriving from an old tutorial.
- [Docker Compose: One File That Describes the Whole Thing](https://linuxtastic.com/tools/docker-compose/): A compose file turns a long docker run command nobody can remember into something you can read, version and hand to someone else. Plus the version numbering that will confuse you, and the key you should delete.
- [Caddy vs nginx: Certificates You Never Think About Again](https://linuxtastic.com/tools/caddy-vs-nginx/): Caddy gets you HTTPS in a two-line config file with no certbot, no cron job and no renewal to forget. That is a real saving, and there are still good reasons to keep nginx.
- [Atuin: Shell History That Actually Remembers](https://linuxtastic.com/tools/atuin/): Your shell history is a text file that truncates, loses concurrent sessions and cannot tell you where or when a command ran. Atuin replaces it with a database, and optionally syncs it between machines.
- [What a Filesystem Journal Does During a Crash](https://linuxtastic.com/learn/journaling-and-crashes/): A journal means you no longer wait an hour for fsck after a power cut. It does not mean the file you were writing survived — and understanding that gap is what stops you losing data you thought was safe.
- [Signals: How Processes Are Asked to Stop](https://linuxtastic.com/learn/signals/): Ctrl+C, kill, systemctl stop and a container shutting down are all the same mechanism. Knowing which signal is being sent, and who is allowed to ignore it, explains why some things stop cleanly and others do not.
- [Memory, Swap and the OOM Killer](https://linuxtastic.com/learn/memory-and-oom/): free says almost no memory is available and the machine is fine. Then one day a process disappears with no error in its own logs. Both of those make sense once you know what the numbers mean.
- [What Actually Happens When You Run a Program](https://linuxtastic.com/learn/how-a-program-runs/): You type a name and press enter. Between that and the first line of output sit fork, exec, an ELF header and a dynamic linker — and knowing the sequence explains most of the errors you will ever see at startup.
- [xargs: Turning a List Into Commands (and When to Reach for parallel)](https://linuxtastic.com/commands/xargs/): Argument list too long, and filenames with spaces in them. xargs solves the first and creates the second unless you know the one flag that matters.
- [openssl: The Six Commands You Actually Need](https://linuxtastic.com/commands/openssl/): openssl has hundreds of subcommands and a manual page that assumes you already know cryptography. In practice there are six things people need, and each is one line.
- [timedatectl: Time, Time Zones and Why Your Logs Are an Hour Out](https://linuxtastic.com/commands/timedatectl/): Setting the clock is easy. The parts that bite are the two clocks in every machine, the difference between the system time zone and a user's, and what happens to a cron job at 1am on the last Sunday in October.
- [lsof and fuser: Finding Out What Is Holding a File, a Port or a Mount](https://linuxtastic.com/commands/lsof/): Address already in use. Device or resource busy. Disk full but nothing is using the space. All three are the same question, and lsof answers it in one line.
- [Sending Email From Your Server (And Why You Probably Should Not Run a Mail Server)](https://linuxtastic.com/guides/sending-email/): Your application needs to send password resets. That is a solved problem and takes an afternoon. Receiving mail on your own box is a different job entirely, and this is an honest account of both.
- [Moving an Existing Service Into a Container](https://linuxtastic.com/guides/containerising-a-service/): Taking something installed with apt and running it in a container instead, without discovering three weeks later that it was writing somewhere you forgot. The inventory, the parallel run, and the cutover.
- [A Home File and Media Server](https://linuxtastic.com/guides/home-file-server/): Storage that other machines can reach, permissions that survive more than one user, Samba and NFS side by side, and media streaming — plus the sentence about RAID that people learn the hard way.
- [A WireGuard VPN, Set Up Properly](https://linuxtastic.com/guides/wireguard-vpn/): Reaching your own machines from anywhere, in about forty minutes. Key generation, the one setting everybody misunderstands, split versus full tunnel, and how to diagnose a handshake that never happens.
- [NixOS: A Machine You Describe Rather Than Configure](https://linuxtastic.com/distros/nixos/): One file defines the whole system, every change is a new generation you can boot back into, and nothing is installed the usual way. The genuine advantages, the flakes question, and the binaries that will not run.
- [Void Linux: Rolling, Independent, and Not systemd](https://linuxtastic.com/distros/void-linux/): Its own package manager, runit instead of systemd, and a choice of glibc or musl. What Void does well, the install images that are eighteen months old, and who it is genuinely for.
- [Zorin OS and elementary OS: The Two Opinionated Desktops](https://linuxtastic.com/distros/zorin-and-elementary/): Both are Ubuntu LTS underneath and both are aimed at people arriving from Windows or macOS — with opposite philosophies. What each actually gives you, what the paid editions add, and how they differ from Mint.
- [Gentoo: Compiling Everything, and Why You Might Not Have To](https://linuxtastic.com/distros/gentoo/): USE flags are the real reason to run Gentoo, not speed. What Portage actually does, the official binary packages that changed the trade-off, and an honest account of the time it costs.
- [lazygit: The Git Operations Nobody Memorises](https://linuxtastic.com/tools/lazygit/): A terminal interface over git that makes staging individual lines, interactive rebasing and stash juggling take seconds. What it is good at, and why you should not learn git through it.
- [procs vs ps: Finding a Process Without a Pipeline](https://linuxtastic.com/tools/procs-vs-ps/): procs searches by name, shows which ports a process is listening on, and prints a readable tree. Where it helps, and why ps is still what every script and every server needs.
- [HTTPie vs curl: Talking to APIs Without the Flags](https://linuxtastic.com/tools/httpie-vs-curl/): HTTPie sends JSON by default and prints readable, coloured responses. The syntax translated, where curl remains the only sensible choice, and the faster reimplementation worth knowing about.
- [rclone: rsync for Cloud Storage](https://linuxtastic.com/tools/rclone/): One tool that speaks S3, Google Drive, Dropbox, SFTP and dozens more. Copy versus sync, the client-side encryption layer, and the command that deletes files at the other end.
- [Text Encodings and Locales: Why the Same Command Gives Different Answers](https://linuxtastic.com/learn/locales-and-encoding/): Linux stores text as bytes and records nothing about what they mean. What UTF-8 actually is, what the LC_ variables change, and why a script that works on your laptop sorts differently on the server.
- [What a TLS Certificate Actually Proves](https://linuxtastic.com/learn/tls-certificates/): A certificate binds a name to a key and nothing more. The chain of trust, where your machine keeps its root store, and why a site can work in a browser and fail from curl.
- [How a Name Is Actually Resolved on a Linux Box](https://linuxtastic.com/learn/dns-resolution/): Between your program and a DNS server sit nsswitch, the resolver library, and usually a local stub listener. Why dig can succeed while your application fails, and how to tell which layer is lying.
- [What a Terminal Actually Is: TTYs, PTYs and Job Control](https://linuxtastic.com/learn/terminals-and-ttys/): The window is not the terminal, and the terminal is not the shell. What sits between your keystrokes and a program, why Ctrl+C stops one thing and not another, and why a dropped SSH connection kills your job.
- [sort, uniq, cut and the Rest of the Text Toolkit](https://linuxtastic.com/commands/text-toolkit/): The small commands that turn a log file into an answer. The count-and-rank pipeline, why uniq needs sorted input, when cut is the wrong tool, and the ones you forget exist.
- [Compression — gzip, zstd, xz and bzip2](https://linuxtastic.com/commands/compression/): Four tools for one job, and the choice matters. Which to use when, the flag that stops them deleting your original, using every CPU core, and how they hook into tar.
- [ip — Addresses, Links and Routes in Depth](https://linuxtastic.com/commands/ip/): The full ip command: the object model, the two flags that make its output readable, ip route get, and the thing nobody tells you — none of your changes survive a reboot.
- [journalctl — Reading the systemd Journal](https://linuxtastic.com/commands/journalctl/): Filtering by unit, priority, boot and time; following logs live; the setting that decides whether yesterday's logs still exist; and how to stop the journal eating your disk.
- [A Staging Environment on One Server](https://linuxtastic.com/guides/staging-environment/): A second copy of your application on the same machine, with its own database and no way to email your customers. What must be separated, how to refresh it safely, and how to stop it appearing in search results.
- [Disk Encryption on a Linux Laptop, Done Properly](https://linuxtastic.com/guides/disk-encryption/): LUKS protects a laptop that is switched off and stolen — and nothing else. Setting it up, backing up the header that everything depends on, and the honest trade in unlocking it automatically.
- [Self-Hosting Your First Application, End to End](https://linuxtastic.com/guides/self-hosting-first-app/): Taking one application from a compose file to a working service on your own server: bound to localhost, behind TLS, backed up, and alerting you when it stops. About two hours.
- [Putting a Database Somewhere Sensible](https://linuxtastic.com/guides/running-a-database/): Installing PostgreSQL on your own server without leaving it open to the internet: scoped roles, socket versus TCP, dumps you have restored from, and the settings that actually matter.
- [Alpine Linux: Small, Fast, and Not Quite Like the Others](https://linuxtastic.com/distros/alpine/): The distribution most of your containers are already built on. What musl and busybox change, the support window people misread, and the DNS behaviour that breaks things in Kubernetes.
- [Immutable and Atomic Distributions: What You Give Up, and Get Back](https://linuxtastic.com/distros/immutable-distros/): Read-only system files, updates that apply completely or not at all, and a previous version you can always boot back into. How Fedora Atomic, openSUSE Aeon and NixOS differ, and the costs nobody mentions.
- [Pop!_OS and COSMIC: Ubuntu With a Desktop Written From Scratch](https://linuxtastic.com/distros/pop-os/): Ubuntu LTS underneath, an installer that puts the NVIDIA driver on for you, and COSMIC — a desktop built in Rust that finally shipped. What it does well, and why you no longer have to switch distribution to try it.
- [Kali, Parrot and BlackArch: The Security Distributions](https://linuxtastic.com/distros/security-distros/): What these distributions actually are, why Kali's own documentation tells you not to use it as a daily desktop, and how Parrot and BlackArch differ. Plus the legal line that matters more than any of it.
- [sd vs sed: Find and Replace Without the Escaping](https://linuxtastic.com/tools/sd-vs-sed/): sd does one job — substitution — with modern regex syntax, no delimiter to choose and no BSD-vs-GNU differences. Where it helps, and the large part of sed it deliberately cannot do.
- [delta vs diff: Making Changes Readable](https://linuxtastic.com/tools/delta-vs-diff/): delta does not compute diffs — it renders them, with syntax highlighting, line numbers and a side-by-side view. What to put in your gitconfig, and why diff is still what scripts and patches need.
- [zoxide vs cd: Jumping Instead of Navigating](https://linuxtastic.com/tools/zoxide-vs-cd/): zoxide remembers the directories you actually use, so one fragment gets you there from anywhere. What it changes, why cd is still what scripts must use, and the setting that stops it surprising you.
- [restic: Backups That Deduplicate, Encrypt and Verify](https://linuxtastic.com/tools/restic/): One binary, an encrypted repository on almost any storage, and snapshots that only store what changed. What restic is good at, the retention policy that actually frees space, and when rsync is the better answer.
- [systemd Beyond Services: Units, Targets and Dependencies](https://linuxtastic.com/learn/systemd-explained/): systemd manages units, and services are only one kind. Sockets, mounts, targets and slices explained — plus the difference between requiring something and waiting for it, which is behind most startup failures.
- [How Packages and Dependencies Actually Work](https://linuxtastic.com/learn/how-packages-work/): What a package contains, how a repository is indexed and trusted, why shared library versions are the real reason dependencies exist, and what mixing sources does to a system.
- [Containers: What Is Actually Happening](https://linuxtastic.com/learn/containers-explained/): A container is an ordinary Linux process with a restricted view of the system. Namespaces, cgroups and overlay filesystems explained — and the problems that stop being mysterious once you know which one you are hitting.
- [What the Kernel Actually Does](https://linuxtastic.com/learn/the-kernel/): Linux is the kernel — not the distribution around it. What lives on each side of the userspace boundary, how to watch a program ask for something, and why an "old" kernel version usually is not old.
- [Shell History — Stop Retyping Commands](https://linuxtastic.com/commands/shell-history/): Ctrl+R, history expansion, the readline editing keys worth learning, and the configuration that stops your history vanishing every time you close a terminal.
- [User Management — useradd, usermod, passwd and chage](https://linuxtastic.com/commands/user-management/): Creating accounts, adding someone to a group without wiping the groups they already had, password ageing with chage, and why locking an account beats deleting it.
- [systemd Timers: Scheduled Jobs That Tell You What Happened](https://linuxtastic.com/commands/systemd-timers/): Timer units do what cron does, with proper logging, dependency handling and catch-up after downtime. The syntax, a working example, and when cron is still fine.
- [dd: Writing Images and Cloning Disks](https://linuxtastic.com/commands/dd/): Write a bootable USB, clone a disk, or destroy the wrong one — dd does exactly what you tell it, without asking. How to use it, and how to check the target first.
- [Monitoring a Server Without a Full Observability Stack](https://linuxtastic.com/guides/simple-monitoring/): Find out a service died before your users do — systemd OnFailure alerts, a disk-space check, and external uptime monitoring. No Prometheus, no Grafana, about an hour.
- [A Reverse Proxy with Automatic TLS](https://linuxtastic.com/guides/reverse-proxy/): Putting several self-hosted applications behind one domain, each on its own subdomain with a certificate that renews itself — with Caddy, and the Nginx equivalent.
- [SSH Access for a Small Team](https://linuxtastic.com/guides/team-ssh-access/): Giving several people access to a server without a shared account: individual logins, scoped sudo, an audit trail, and offboarding that actually removes access.
- [Set Up a LEMP Stack: Nginx, MariaDB and PHP](https://linuxtastic.com/guides/lemp-stack/): A working PHP application server, with the socket paths, permissions and database privileges that most walkthroughs get slightly wrong.
- [openSUSE: Leap, Tumbleweed and Rollback That Works](https://linuxtastic.com/distros/opensuse/): Two very different distributions under one name, plus the one feature nobody else does as well — a rolling release you can undo from the boot menu.
- [Raspberry Pi OS: Debian on a Very Small Computer](https://linuxtastic.com/distros/raspberry-pi-os/): It is Debian, tuned for the hardware. Headless setup done properly, the SD card problem nobody warns you about, and when to run something else on a Pi.
- [Linux Mint: The Easiest Landing from Windows](https://linuxtastic.com/distros/linux-mint/): Ubuntu LTS underneath, no snaps, and a desktop that works the way you expect. What Mint changes, why the release cadence is deliberately slow, and where it falls short.
- [Rocky Linux and AlmaLinux: Free RHEL for Servers](https://linuxtastic.com/distros/rocky-and-alma/): Two projects took over what CentOS used to be. What they are, how they differ from each other, and why ten years of support without a subscription still matters.

## Pages

- [Do Not Sell My Personal Information](https://linuxtastic.com/do-not-track/): Please fill out the form below if you wish to remove yourself from our records.
- [Start Here](https://linuxtastic.com/start-here/): What this site is, how it is organised, and where to begin depending on whether you are new to Linux, running a server, or trying to stop guessing at a class of problem for good.
- [Blog](https://linuxtastic.com/blog/): Kernel releases, distro announcements, and occasional opinion.
- [Tools](https://linuxtastic.com/tools/): A generation of command-line tools has been rewritten.
- [Learn](https://linuxtastic.com/learn/): The Commands section tells you how.
- [Distros](https://linuxtastic.com/distros/): Every distribution is the same Linux kernel with different decisions made around it: how often things change, who packages the software, and what is set up for you before you arrive.
- [Guides](https://linuxtastic.com/guides/): Thirty-three walkthroughs that finish the job.
- [Commands](https://linuxtastic.com/commands/): Thirty-one references to the commands you actually use on a Linux machine — what each one is for, the flags worth remembering, and the ways each of them catches people out.
- [Acceptable Use Policy](https://linuxtastic.com/acceptable-use-policy/)
- [Disclaimer](https://linuxtastic.com/disclaimer/)
- [Terms and Conditions](https://linuxtastic.com/terms-and-conditions/)
- [Cookie Policy](https://linuxtastic.com/cookie-policy/)
- [Contact Us](https://linuxtastic.com/contact-us/): Please enable JavaScript in your browser to complete this form.
- [Privacy Policy](https://linuxtastic.com/privacy-policy/)

## Optional

- [Agent (MCP protocol)](websites-agents.hostinger.com/linuxtastic.com/mcp)

[comment]: # (Generated by Hostinger Tools Plugin)