Switching to Tailscale completely changed the vibe. Suddenly everything could talk to everything else, securely, easily and without the hub getting overwhelmed with switching.

Hub-and-Spoke Network (left) vs Full Mesh Network (right) | Joey Manani

The Old Setup: Hub-and-Spoke WireGuard

Hub-and-spoke basically means:

• Every network node establishes a WireGuard tunnel only to the central hub
• If two spokes want to talk, traffic must route through the hub
• The hub must handle all encryption + forwarding
• No peer-to-peer discovery; everything is statically configured
• Peers basically don't know of each other's existence

In practice, this meant:

• Devices on the same AP-Isolating LAN had to talk via the hub rather than directly on the LAN. AP-Isolation prevents LAN devices talking entirely (hello apartment Wi-Fi)
• Latency was… BAD

It works, but it’s very “manual oldschool energy.”

The Upgrade: Tailscale Full Mesh

Tailscale flips the entire model on its head. Instead of a rigid hub, you now get a full mesh overlay network:

• Every device is a WireGuard peer
  
• Peers discover each other automatically using DERP + magic DNS
  
• Connections become direct, peer-to-peer, and encrypted
  
• If NAT says “no :)“, Tailscale falls back to DERP relay without breaking anything
  
• No manual key management!

The coolest part?
It's still WireGuard under the hood – Tailscale just simplifies all of the annoying parts.

Why Full Mesh Is Better

1. Direct Peer-to-Peer Traffic

With Tailscale, remote servers are able to talk to the home server directly and not zigzag through a hub.

Result:

• Lower latency
• Lower CPU usage
• Faster file transfers
• Hub doesn't have to process the same thing twice

2. Automatic Key Management

WireGuard’s biggest pain point basically disappears.

Tailscale handles:

• Key distribution
  
• Key rotation
• Device onboarding
• Device removal
  
• Secure device signing
• Revocation

3. MagicDNS and Stable IPs

Every node gets a stable 100.x address plus a nice readable DNS name:

storage.tsxxxx.net
raspberrypi.tsxxxx.net
syncthing.tsxxxx.net

Even if I'm switching networks five times a day, nothing breaks and everything remains accessible.

4. DERP & NAT Traversal

If two nodes can't reach each other directly (i.e., via CGNAT or an aggressive firewall), Tailscale relays traffic via DERP.

Full mesh + fallback relay means the connection always exist and is very reliable.

5. No More Central Point of Failure

In hub-and-spoke, if the hub died, the entire VPN network died.

This happened once and the TFR network came to a standstill.

With Tailscale, one node disappearing affects only that node.

Huge stability upgrade.

How I Migrated

1. Removed my WireGuard hub config from all nodes

2. Installed Tailscale everywhere:

   • Home server
     
   • Remote servers
   • NAS
     
   • Laptop
     
   • Phone
     
   • Whatever else I needed

3. Enabled subnet routing for certain networks so local LANs are reachable

4. Turned on MagicDNS using my own internal DNS server including Ad and Tracker blocking

5. Sat back and enjoyed a network that Just Works™

Tailscale DNS | Joey Manani

Final Thoughts

Switching from a DIY hub-and-spoke WireGuard setup to Tailscale full mesh is gamechanging. Same fundamentals, wildly improved experience.

If you've got servers scattered across a few networks, this is the easiest quality-of-life network upgrade you can make.

Everything just works how I like it, and every device knows about each other.

#sysadmin #tailscale #networking #wireguard

What is Unix?

Unix is an operating system developed in the 1970s at Bell Labs. It was designed to be simple, stable, and highly portable, which made it a great choice for servers and professional environments. The original Unix code isn’t widely used anymore, but the Unix principles and standards heavily influenced the development of modern OSs. Unix's main characteristics include:

• File System Structure: Unix organises data in a hierarchical file system, starting at a root directory (/). Key directories like /bin, /usr, and /var have specific roles within the Unix system. Everything (including files, executables, devices, etc.) are organised in a tree structure.

• Command-Line Interface (CLI): Unix’s CLI allows users to interact directly with the system using commands like ls (list files) or grep (search text). Shells like Bash or Zsh make scripting and automation in Unix easy.

• Multi-User & Multi-Tasking: Unix supports multiple users and processes at once, making it ideal for server environments. Users can control processes and manage system resources directly.

• Permissions & Security: Unix systems have a robust permissions model. Each file or folder has specific permissions for the owner, group, and others, ensuring secure access control.

• Modularity: Unix follows the “do one thing and do it well” philosophy. Programs are small, focused, and can be combined using pipes (|) to create more complex actions.

What is POSIX?

POSIX (Portable Operating System Interface) is a set of standards established to ensure compatibility across Unix systems. POSIX outlines how operating systems should handle core functions, so that software can run on any compliant system. Key components include:

• Standardised APIs: Defines common functions for programming, like reading/writing files, managing processes and handling input/output.

• Shell & Utilities: Specifies standard command-line tools like grep, ls, awk, and sed, and a default shell.

• File System: POSIX sets rules for how files should be stored and managed, including permission systems and directory structures.

POSIX compliance ensures that applications can run across different Unix systems (like Solaris or AIX) and Unix-like systems (like Linux or macOS) without needing major rewrites.

What is Linux?

Linux is a Unix-like operating system that follows many Unix principles but is not derived directly from Unix code. It’s an open-source OS created by Linus Torvalds in the early 1990s. Linux has since grown to power everything from servers to mobile devices. Its key features include:

• Open Source: Linux is free and open-source, meaning anyone can modify and distribute it. (See also: GNU)

• Versatile: Available in different “distributions” (like Ubuntu, Debian, Fedora, CentOS and many more) tailored for specific use cases — desktop, server, or embedded systems.

• Wide Adoption: Linux powers most web servers, supercomputers, and many IoT devices, making it highly versatile and widely supported.

Why They Matter (tl;dr)

Unix set the foundation for modern operating systems, with POSIX ensuring consistency across them. Linux, while Unix-like, has evolved to become dominant for its adaptability and open-source model. Understanding these systems helps users navigate the world of servers, networking, and software development more effectively.

#blog #linux #comparison #sysadmin #joeymanani

Step 1: Download and Install Python

1. Download Python

1. Head to the official Python download page.

2. You should see a big yellow button labeled “Download Python 3.x.x” (the latest version number). Click it to start the download.

   

2. Install Python

1. Open the downloaded installer file.
2. Important: Check the box that says “Add Python to PATH”. This makes running Python from the command line easier.
3. Choose Install Now and let the installer run.

4. Once the installation finishes, click Close.

   

3. Verify the Installation

To confirm Python is installed correctly: 1. Open Command Prompt (search “cmd” in the Start menu). 2. Type python --version and hit Enter. – If installed correctly, you should see the Python version number displayed.

Step 2: Download and Install Visual Studio Code (VSCode)

1. Download VSCode

1. Go to the VSCode download page.

2. Choose the Windows option to start the download.

   

2. Install VSCode

1. Open the downloaded installer file.
2. Follow the on-screen instructions, and when you reach the setup screen, check the following boxes:
   • Add “Open with Code” action to Windows Explorer (optional but useful).
   • Add to PATH (recommended for terminal usage).

3. Continue with the installation, and when it’s complete, click Finish.

   

Step 3: Set Up Python in VSCode

1. Open VSCode and Install the Python Extension

1. Launch VSCode.
2. Go to the Extensions sidebar (click the four-square boxes icon or press Ctrl+Shift+X).
3. Search for Python and select the one by Microsoft.

4. Click Install to add the Python extension.

   

2. Verify Python Extension in a New File

1. Create a new file by clicking File > New File.
2. Save it as test.py.

3. Type a simple line of code like print("Hello, Python!") and save the file.

   

3. Run Python Code in VSCode

1. Right-click on the code and choose Run Python File in Terminal. This will open a terminal at the bottom of VSCode and execute the code.

   • You should see Hello, Python! printed in the terminal.

   

That's It!

🎉 Congratulations! You now have Python and VSCode fully set up on your Windows computer!

Keep coding, and check back for more guides to improve your development experience.

Further Reading

Why Catching All Exceptions is a Bad Idea in Python

#blog #python #vscode #tutorial #programming #joeymanani

Sidenote

The application I used to simulate the screenshots was the Windows Sandbox – similar to a VM – and can be installed on your host machine in the builtin program Turn Windows features on or off inside of your start menu.

I realised that I can use FFmpeg to convert PNG screenshots to WebP to compress them and optimize webpage load times. Pretty cool!

Example Python traceback | Joey Manani

1. The Risk of Masking Bugs

One of the most dangerous aspects of catching all exceptions is that you may unintentionally hide bugs in your code. When you use a broad except clause like this:

try:
    # some risky code that could produce many errors
except Exception:
    pass  # Catching all exceptions

You’re ignoring the actual error, which essentially masks what went wrong. If you don’t see the error, how can you fix it? The issue may lie somewhere deeper in your logic, and by swallowing the exception, you're potentially missing valuable debugging clues as well as providing ambiguous feedback to users about what failed.

2. Makes Debugging Harder

By catching all exceptions, you're reducing the amount of information you can use to debug your program. In the worst case, a pretty vague except Exception could make you miss critical errors that would be more obvious if they weren’t caught.

You need the ability to identify specific errors and address them in a targeted way. For example, catching specific exceptions such as ValueError, TypeError, or FileNotFoundError gives you better control and clearer insight into the problem.

Example:

Instead of this:

try:
    # Open a file
except Exception:
    pass  # Ignoring all errors

You should handle specific exceptions (yes, you can chain them!):

try:
    # Open a file
except FileNotFoundError:
    print("The file doesn't exist!")
except IOError:
    print("There was an error opening the file!")

Now, the program provides more useful feedback for when something goes wrong.

3. A False Sense of Security

Catching every exception may create a false sense of security, thinking that you’ve “handled” the errors, but that's not really the case. When you swallow exceptions, you don't know how the application behaves under real error conditions. Sometimes, what you're doing is delaying the problem rather than addressing it directly causing a headache down the line.

Additionally, if the exception is silent, you may not notice issues until they snowball into something bigger, potentially causing bigger failures later.

4. Best Practices for Handling Exceptions

Instead of catching all exceptions, follow these practices:

1. Catch Specific Exceptions: Always try to handle specific exceptions instead of using a generic except Exception. This gives you better control over the errors you expect.

   Example:

   try:
       result = 10 / 0
   except ZeroDivisionError:
       print("You can't divide by zero!")
   

2. Log the Exceptions: Even if you must catch all exceptions, ensure you log the error somewhere to help with debugging later.

   Example:

   import logging
   
   try:
       # Risky code
   except Exception as e:
       logging.error(f"An error occurred: {e}")
   

3. Use Finally for Cleanup: If you need to clean up resources (like closing a file), always use a finally block. This ensures cleanup happens whether or not an exception is raised.

   Example:

   try:
       # Risky code
   except ValueError:
       print("Oops, something went wrong!")
   finally:
       print("Cleanup done!")
   

Conclusion

In summary, catching all exceptions is like applying a bandage to a broken leg— it's not the greatest of solutions, and it may cause more harm than good. By catching specific exceptions and handling them intelligently, you'll write more robust, debuggable code that enhances the user experience.

#blog #python #programming #joeymanani

That's the first word I posted to this blog to test if it worked. It does.

In the middle of 2022, I had the ambition to create a blog... From scratch. I had drawn out visual diagrams on how everything would work, listed the tools I would need, and the features I'd want. I still probably have this somewhere, just I can't be bothered looking for it.

Today, I was searching through the awesome-selfhosted website for some blogging solutions that I could just host myself, and get into writing straight away rather than building a full-scale solution from the ground up.

I found this one. It's called WriteFreely and I think it's pretty cool.

I was able to deploy this in about 10 minutes to already existing infrastructure. It was really easy to set up. It has a small CLI wizard that takes you through basic configuration, and it allows for reverse proxy-ing straight out of the box. Awesome.

After running Certbot, and adding a DNS record on Cloudflare, it was up. Of course, in my haste, I made a typo in my Nginx configuration file, and spelt the domain as “joeymnanani” instead of “joeymanani”. Luckily, I fixed this after I realised static files weren't loading.

Now, apparently, it supports Markdown, and if you don't know what that is, it allows me to do stuff like this:

📝 Hey, that's a Markdown feature...

It allows me to customize the post however I choose, allowing me to add text formatting, titles, hyperlinks or even images. I'm impressed.

Anyways, that's it from me I think. Stay tuned for more, probably...

Yours truly, Joey Manani

#tech #blog #joeymanani #sysadmin #writefreely