DEV Community: Marco Kamner

Static Site Generator Fulltext Search

Marco Kamner — Sun, 26 Oct 2025 16:29:12 +0000

I recently rebuilt my blog from scratch, see the previous post in this series.

One thing I wanted to add was site-wide search without any external dependencies. Since I have previous experience with a tool called pagefind, which is perfect for this use case, I implemented it with that.

Remaking My Blog From Scratch

Marco Kamner — Sun, 26 Oct 2025 00:00:00 +0000

I’ve been blogging in one form or another for 5 years now.

All blogs and other online publishing adventures had one thing in common: I barely knew what I was doing, using components I never learned properly.

I wanted to change that! And with the benefit of hindsight I will now take you on this adventure with me.

Colorize pattern on CLI

Marco Kamner — Wed, 07 May 2025 00:00:00 +0000

Colorize a pattern in the given input using a neat regex and colorization hack in grep ($ matching all lines but not being able to be highlighted).

color () {
  # Color highlight the pattern in the incoming stream, writing to stdout
  # This effectively matches our PATTERN any "$" (lines end character)
  # But only our PATTERN can be highlighted, line end characters aren't actually there to be highlighted
  local PATTERN=$1

  if [-z "$1"]; then
    echo "Usage: color <pattern>"
    echo "Description: Greps input with --color=always -E 'PATTERN|\$' "
    echo "Example: echo \"hello world\" | color \"world\""
    return 1

  fi
  grep --color=always "$PATTERN\|\$"
}

pip install from git repository

Marco Kamner — Mon, 14 Apr 2025 00:00:00 +0000

Install a pip package from a git repo, using a specified git reference:

$REPOSITORY = "https://gitlab.com/mkamner/example.git"
$GIT_REF = "my-branch-or-tag-or-sha"

pip install "git+$REPOSITORY/@$GIT_REF"

If the package resides in a sub-directory this can be specified like this:

$REPOSITORY = "https://gitlab.com/mkamner/example.git"
$GIT_REF = "my-branch-or-tag-or-sha"
$DIRECTORY = "my-folder"

pip install "git+$REPOSITORY/@$GIT_REF#subdirectory=$DIRECTORY"

Troubleshooting Intermittent DNS Resolution Issues

Marco Kamner — Fri, 28 Feb 2025 00:00:00 +0000

DNS is something so fundamental to most of our systems functioning that it’s often overlooked in initial troubleshooting, it’s also incredibly hard to troubleshoot if it’s only intermittently failing.

The below script helps me in doing this kind of troubleshooting by effectively bombarding a DNS server with requests
and reporting whenever the response changes.

#!/bin/bash

dns_name=$1
dns_server=$2
detail_log_file=$3

if [ -z "$detail_log_file" ]; then
    detail_log_file="/dev/stdout"
fi


if [ -z "$dns_name" ] || [ -z "$dns_server" ] || [ -z "$detail_log_file" ]; then
    echo "Usage: $0 <dns_name> <dns_server> [detail_log_file=/dev/stdout]"
    exit 1
fi

previous_output=""
while true; do
    # Run the dig command
    output=$(dig +short $dns_name "@$dns_server")

    # Check the exit status of the dig command
    if [ "$output" != "$previous_output" ]; then
        timestamp=$(date +"%Y-%m-%d %H:%M:%S")
        echo "[$timestamp] dig response changed"

        echo "------" >> $detail_log_file
        echo "# [$timestamp] response changed" >> $detail_log_file
        echo "# previous response" >> $detail_log_file
        echo "$previous_output" >> $detail_log_file
        echo "# new response" >> $detail_log_file
        echo "$output" >> $detail_log_file

        previous_output="$output"
    fi
done

GitLab Copy & Paste: Added Backticks

Marco Kamner — Wed, 26 Feb 2025 00:00:00 +0000

Problem

When copying (using either select and copy or the copy icon) a line of code like

atlantis apply

and then pasting it into GitLabs comment field the contents get enclosed in backticks like `atlantis apply`

Solution

GitLab tries to be helpful and adds that to make pasting with formatting (the default on all modern systems) easier.

in this case we need it without formatting, so doing a paste without formatting works.

On MacOS: Shift + Command + V

On Windows/Linux: Ctrl + Shift + v

Running Multiple Server Processes From One Script

Marco Kamner — Sun, 23 Feb 2025 00:00:00 +0000

Doing local development on a bunch of interconnected services I often want to start multiple long running server processes.

This is the basic script I use for that.

It has the added niceness of prefixing output with an identifier so you know which process it came from.

#!/usr/bin/env bash

pids=()

cleanup() {
  echo "CONTROL: Cleaning up, killing all processes"
  for pid in "${pids[@]}"; do
    kill "$pid"
  done
  exit 0
}

trap cleanup SIGINT

start_process() {
  local prefix="$1"
  shift
  "$@" > >(sed "s/^/$prefix: /") 2> >(sed "s/^/$prefix (err): /" >&2)
  pids+=($!)
}

# Place your processes here
start_process "A" python3 -m http.server 9000
start_process "B" python3 -m http.server 9001

echo "CONTROL: All processes started, streaming stdout and stderr"

wait

Simple Redirect View for Django

Marco Kamner — Thu, 02 Jan 2025 00:00:00 +0000

I often find myself replacing an existing MVP based on static html with a Django app, or just needing to preserve some old URL scheme.

This is the code I use to do that:

from django.shortcuts import redirect

def redirect_view(request, redirectable, permanent=True):
  return redirect(redirectable)

Which can then be used like this:

from django.urls import path
from . import views

urlpatterns = [
    path("old-url/", views.redirect_view, {"redirectable": "new_view"}),
    path("some-thing/", views.redirect_view, {"redirectable": "some_thing_new", permanent=False}),
]

Cleanup After Script Exit

Marco Kamner — Tue, 03 Sep 2024 00:00:00 +0000

Many of my scripts work with temporary files, usually relative to the scripts directory, while at the same time using set -e to exit as soon as something fails.

In this scenario the script leaves behind these temporary files by default, which is not desirable.

We can however do a proper cleanup using the trap concept.

Basic Example

#!/bin/bash
set -e

MY_TMP_DIR=/tmp/my-dir

function cleanup {
    echo "Removing $MY_TMP_DIR"
    rm -r $MY_TMP_DIR
}

trap cleanup EXIT
mkdir $MY_TMP_DIR
exit 0

Vault CLI in Containers

Marco Kamner — Thu, 25 Jul 2024 00:00:00 +0000

In many CI/CD workflows interfacing with Hashicorp Vault is required.

However, their CLI (or better called unified binary¹) is stupidly big with more than 400MB
and they seem to have no interest in making it any smaller².

This is often a undesired size increase, especially when optimizing for pull and run time in CI/CD.

This note outlines a solution that brings us down from 400MB+ on disk for vault to about 300KB using curl and jq.

Optimizing things

The simple actions of getting keys in Vault can easily be expressed using plain curl, in combination with a bit of jq or bash.

I will demonstrate with this simple example: Getting the value of a key in a secret for use somewhere else

With the vault CLI:

vault kv get -address="vault-host"  -mount=X -field=username Some/secret/path
# myusername

We could simply build the curl command ourself, but vault has the -output-curl-string flag that gives us a curl command to work with:

vault kv get -address="vault-host"  -mount=X -field=username -output-curl-string Some/secret/path
# curl -H "X-Vault-Token: $(vault print token)" -H "X-Vault-Request: true" https://vault-host/v1/X/data/Some/secret/path

This command might already be enough for your use-case, but it does not replicate the -field=username parameter yet, instead it outputs the whole object.
Using jq we can achieve the exact same output as the original vault command.

curl -H "X-Vault-Token: $VAULT_TOKEN" -H "X-Vault-Request: true" https://vault-host/v1/X/data/Some/secret/path --silent | jq .data.data.username -r
# myusername

Caddy: Manual Maintenance Mode

Marco Kamner — Sat, 13 Jul 2024 15:57:10 +0000

Coming from NGINX and others the concept of a maintenance mode that can be manually enabled is something I have used many times before.

With Caddy it is equally as easy, just using a less obvious syntax.

It always follows this general pattern:

Check if a maintenance.on file exists at a specified location
If it does, deliver the maintenance page
Otherwise, do the normal thing you do

Notice:
Doing maintenance pages the way I describe in this post means your webserver is checking a file on disk for every request.

In small deployments this is likely not adding any overhead you need to be concerned with, but keep it in mind.

nginx

To refresh your memory, this patterns looks like this in nginx.

server {
  location / {
    set $maintenance 0;
    if (-f /app/maintenance.on) {
       set $maintenance 1;
    }
    if ($maintenance = 1) {
      rewrite ^(.*)$ /app/static/maintenance.html last;
      return 503;
    }

    proxy_pass http://127.0.0.1:8080;
  }
}

Caddyfile

With Caddy it works exactly the same, just using a different vocabulary.

example.marco.ninja {
    @maintenanceModeActive file /app/maintenance.on
    handle @maintenanceModeActive {
        try_files /app/static/maintenance.html
        file_server {
            status 503
        }
    }

    reverse_proxy 127.0.0.1:8080
}

PicoCSS Sticky Footer

Marco Kamner — Mon, 10 Jun 2024 00:00:00 +0000

A sticky footer using PicoCSS

html,
body {
  height: 100vh;
}

body > footer {
  position: sticky;
  top: 100vh;
}