Andrea Farneti - Wiki

HomeGraph viewStarting ToolsBasic KnowledgeUtilities
Andrea Farneti - Wiki

The ultimate note taking setup! Create a Wiki like this!

6 min read

Hi there!

Today I’m going to show you how I transformed the act of daily note-taking into a system that:

  • helps me consolidate what I do during the day

  • maps out arguments by showing their evolutions and ramifications

  • automatically creates value not just for you, but for others too

The result is a personal, link-rich wiki to show off!

Here is what I actually do:

  • I take notes with screenshots on my work latop, using OneNote

  • At the end of the day I finalize them by converting them in Markdown, using Obsidian.

  • I push them to my VPS using a Python script

  • As soon as they arrive, a static site is automatically generated using Quartz, and everything is pushed to GitHub for backup, using Git for versioning.

This guide walks you through this entire pipeline.

Architecture

The Obsidian vault lives on your PC, here is where you finalize the notes. A sync-wiki.sh script pushes them to the VPS via rsync, where deploy.sh turns them into static HTML using Quartz, and commits everything to GitHub. Nginx publishes the site via HTTPS.

flowchart LR
    Vault["📓 Obsidian Vault<br/>(PC, WSL/Linux)"]

    subgraph VPS["☁️ VPS Ubuntu"]
        subgraph Repo["~/wiki/ — Git repo"]
            Content["content/<br/>(synced .md)"]
            Deploy["deploy.sh"]
            QuartzCode["quartz/ + quartz.*.ts<br/>(SSG)"]
            Public["public/<br/>(static HTML)"]
        end
        Nginx["Nginx + Certbot"]
    end

    GitHub["🐙 GitHub<br/>(backup + DR)"]
    Visitor((🌍 your-domain.com))

    Vault -- "sync-wiki.sh<br/>rsync --delete" --> Content
    Content --> Deploy
    Deploy -- "npx quartz build" --> QuartzCode
    QuartzCode --> Public
    Public --> Nginx
    Deploy -- "git commit + push" --> GitHub
    Nginx -- "HTTPS" --> Visitor

1. Install Obsidian on your PC

Follow the Obsidian setup to install Obsidian, create a vault, and learn the essentials (mainly wikilinks and tags, but also callouts and embeds).

The vault is just a normal folder on disk, so just pick a path you’ll remember, for example:

~/Documents/ObsidianVault on Linux

C:\Users\you\Documents\ObsidianVault on Windows (/mnt/c/Users/you/Documents/ObsidianVault from WSL).

2. Set up your VPS

Since my goal is to avoid vendor lock-in and keep everything fully open source, I use a Linux machine with a public IPv4 address. I host Nginx as my web server to publish my entire website on the domain farnetiandrea.it, which points directly to that IP address.

If you want to use the same setup, I recommend:

  • A VPS with Ubuntu 22.04+ (or any recent Debian-like distro)
  • A non-root user with sudo privileges (the correct way to handle privileges in Linux)
  • A public IPv4 address (e.g. 123.456.0.100)
  • A domain and its DNS pointed to the VPS (e.g. wiki.yourdomain.com⇒ 123.456.0.100)
  • Nginx + Certbot for publishing the domain via HTTPS

3. Install Quartz on the VPS

Quartz is what converts your Markdown notes into a real site.

You can follow the Quartz setup on Linux for the detailed explanation.

TL;DR: you need to clone the Quartz repository in the directory that you want to use as the “container” for your site. I host this Wiki in the ~/wiki directory of my VPS, so i’ll use that as a reference throughout the guide:

git clone https://github.com/jackyzha0/quartz.git wiki
cd wiki
rm -rf .git # remove the connection with the official Quartz upstream
git init # create a new Git repo
npm install
npx quartz build # it creates public/, the actual HMTL page of your website

Quartz will create the content/ folder, and here’s where we have to sync our markdown notes!

You can later also customize quartz.config.ts (title, colors, locale) and quartz.layout.ts (header, sidebar order) to make the webpage yours.

4. Git & GitHub setup

Now, create a new empty repository on GitHub called wiki (no README, no license, leave it completely empty).

See how to set up your first GitHub page, if you don’t know the basics.

So after we created our dedicated GitHub page for our project, we are ready to link it with our ~/wiki local repo, by adding the remote origin: 

git add .
git commit -m "Initial commit"
git branch -M main
git remote add origin git@github.com:user/repo.git # this connects our local and remote repos
git push -u origin main
Link to the full note →

This is essential so that deploy.sh, the script that we’ll create for automating the process, can run git push without issues.

5. Configure Nginx

Nginx is the web-server that allows you to publish the site you just created with Quartz.

You can see a detailed explanation of Nginx and the configuration I use here.

TL;DR: you just need to point Nginx root at ~/wiki/public/: 

server {
    listen 80;
    listen [::]:80;
    server_name example.com www.example.com;
 
    root /var/www/example;     # filesystem root for static files
    index index.html;
 
    location / {
        try_files $uri $uri.html $uri/ =404;
    }
}
Link to the full note →

So in our case server_name ... will be something like server_name wiki.<YOUR_SITE.COM>; and root /var/www/example; will be like root /home/<YOUR_USER>/wiki/public;

6. Certbot Installation

Certbot is the software that issues a certificate for your domain, so that it can run in HTTPS.

You can see the Certbot setup guide to install Certbot and activate it for you website.

TL;DR: it will issue a certificate and add the following lines to your Nginx configuration:

server {
    server_name wiki.example.com;
    root /var/www/wiki;
    index index.html;
    location / { try_files $uri $uri.html $uri/ =404; }
 
    # ── added by Certbot ──
    listen [::]:443 ssl;
    listen 443 ssl;
    ssl_certificate     /etc/letsencrypt/live/wiki.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/wiki.example.com/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}
 
# also added: HTTP -> HTTPS redirect
server {
    if ($host = wiki.example.com) {
        return 301 https://$host$request_uri;
    }
    listen 80;
    listen [::]:80;
    server_name wiki.example.com;
    return 404;
}
Link to the full note →

And… we are done!

Your personal Wiki should be online.

Now I’ll show you a couple scripts to automate the pipeline process, so that you just need to worry about writing the notes and then sync, publish and back them up on GitHub with a click!

EXTRA. Automating the process

For automating the entire pipeline, we are going to need two scripts:

  • deploy.sh: lives inside my “wiki” folder on the VPS. Deploys everything on GitHub and generates the site
  • sync-wiki.sh: lives inside my work laptop. Syncs every note on the VPS and calls deploy.sh

deploy.sh:

#!/bin/bash
# Build Quartz, fix perms, push to GitHub as backup
set -euo pipefail
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
 
cd ~/wiki
npx quartz build
chmod -R o+rX public/
 
if [[ -n "$(git status --porcelain)" ]]; then
    git add .
    git commit -m "deploy: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
    git push origin main
fi

sync-wiki.sh:

#!/bin/bash
# Sync vault to VPS, then deploy
set -euo pipefail
 
VAULT_LOCAL="/path/to/your/ObsidianVault/"   # trailing slash matters
VPS_ALIAS="my-vps"                            # from ~/.ssh/config
VPS_PATH="~/wiki/content/"
 
echo "==> [1/2] Sync vault to VPS..."
rsync -avz --delete \
  --chmod=F644,D755 \
  --exclude='.obsidian/' \
  --exclude='.trash/' \
  --exclude='.DS_Store' \
  --exclude='Thumbs.db' \
  -e "ssh" \
  "$VAULT_LOCAL" "$VPS_ALIAS:$VPS_PATH"
 
echo "==> [2/2] Trigger deploy on VPS..."
ssh "$VPS_ALIAS" "cd ~/wiki && ./deploy.sh"
 
echo "==> Done. Site live at https://wiki.yourdomain.com"

To correctly run this script, you also need to configure an SSH alias for your VPS.

Basically, an SSH alias let’s you do:

ssh my-vps

Instead of :

ssh -i <PATH_TO_YOUR_SSHKEY> <NAME>@<IP>

To do that, you need to edit accordingly your ~/.ssh/config in your WSL installation:

Host my-vps
    HostName 1.2.3.4
    User myuser
    IdentityFile ~/.ssh/id_ed25519

Now we are finally ready to publish!

Open WSL in your work laptop, and launch:

./sync-wiki.sh

That’s it.

From now on, your daily workflow is the following:

  1. Edit the final notes in Obsidian (fully offline).
  2. When you want to publish them: ./sync-wiki.sh.
  3. Refresh your wiki: changes are live in a few seconds.
0/00%

Graph View