Explore our expansive tech blog where a world of topics unfolds, from Node.js and TypeScript intricacies to the nuances of Bash scripting and container service orchestration. Delve into the realm of advanced cybersecurity, and master project development with our in-depth tutorials covering QR code generation, rootless Docker automation, large-scale data analysis, and self-hosted GitHub Actions runners. Designed to cater to both aspiring tech aficionados and seasoned developers, our blog is a treasure trove of expert knowledge. It features extensive programming tutorials, innovative debugging techniques, and a wealth of real-world application insights. Keep ahead of the curve with the latest in software development trends, benefit from our hands-on, step-by-step guides, and spearhead technological advancement in your projects and career.

Yane ✖ Karov


Welcome to my digital canvas. I am a passionate software engineer based in Brisbane, Australia, interested in leveraging technology to make a meaningful difference.

Seeing from an early age how technology was rapidly changing the world, it captivated my interest, and motivated me with a desire and curiosity to understand.

Today, as a 25-year-old professional, with over a decade of experience in the industry, software is not just a career choice, but a tool to create positive change.


An evolving mosaic of all the nerdy stuff

About


There are a couple of ways to implement DKIM identity verification on your mail relay service.
The most common being the use of CNAME records automatically generated by yourself or a third-party provider, such as AWS. These records can be inserted automatically via Route 53 or manually with the use of a third-party DNS service.

*The manual method is trivial if you know not to insert the entire name & value strings in their respective fields with your DNS provider, but counter-intuitive as one of my colleague's recently discovered.*

However, as with most things, there is another way, which provides a bit more control and flexibility around how you verify your domain identity.

The alternative being BYODKIM. The following one-liner (three) creates a mechanism to generate a DKIM key pair and format a nice DNS TXT record, trivializing the process of setting up DKIM for a domain.
I'll go through and break it all down, then present an alternative script that's a bit more user-friendly.

### Have a gander at mr misery and let's deconstruct it together.

```
openssl genrsa -out myawesomedomain.com.au.private.key 2048
openssl rsa -in myawesomedomain.com.au.private.key -pubout -out myawesomedomain.com.au.public.key
grep -v -- "----" myawesomedomain.com.au.public.key | tr -d '\n' | sed 's/^.*$MI.*$$/"v=DKIM1; k=rsa; p=\1"/' | xargs -I {} echo "selector1._domainkey.myawesomedomain.com.au. IN TXT {}"
```

The output should be as follows...

```bash
writing RSA key
selector1._domainkey.myawesomedomain.com.au. IN TXT v=DKIM1; k=rsa; p=MIIBCgKCAQEAzVsPIdHpblobBVOX7jtDtyq...
```

```bash
void@void: /home/void/working
➜   ls
myawesomedomain.com.au.private.key  myawesomedomain.com.au.public.key
```

### Private Key Generation

Probably the easiest line to understand - we use the openssl binary and the genrsa utility operation to output the private key file for myawesomedomain.
We also set the bit size to 2048 because any lower would be madness.
```
openssl genrsa -out myawesomedomain.com.au.private.key 2048
```

### Public Key Generation
Pretty straightforward, but here we're using openssl to read in the private key rather than output, and output a new public key against it.
This public key will be as the name implies, made public to our TXT record later.
```
openssl rsa -in myawesomedomain.com.au.private.key -pubout -out myawesomedomain.com.au.public.key
```

### Text manipulation

For the sauce. This command sequence formats the public key for inclusion in a DNS TXT record. There are a lot of subcommands here so we'll break them down individually.
```
grep -v -- "----" myawesomedomain.com.au.public.key | tr -d '\n' | sed 's/^.*$MI.*$$/"v=DKIM1; k=rsa; p=\1"/' | xargs -I {} echo "selector1._domainkey.myawesomedomain.com.au. IN TXT {}"
```

### Grepping the public key file

grep -v takes input line by line. To ensure that strings containing hyphens don't break the command, we use the -- double delimiter.
This way we can search the public key file and filter lines with the begin or end key headers.
```
grep -v -- "----" myawesomedomain.com.au.public.key
```

### Trimming the new lines

tr -d looks for literal new lines \n and strips them from the file
```
| tr -d '\n'
```

### Formatting the public key

Here we use sed to format the remaining public key string according to DKIM requirements, wrapping it with the necessary prefix and quotes.

```
| sed 's/^.*$MI.*$$/"v=DKIM1; k=rsa; p=\1"/'
```

### Printing the DNS TXT record

Xargs is used here to take the formatted public key string and pass it as an argument to echo.
The -I operator tells xargs to replace the contents of the placeholder {} in the echo command with the input it receives from the previous command in the pipe.


Then the echo command is used to construct a DNS TXT record by embedding the formatted public key received from the pipe into a template that defines how the TXT record should appear in the DNS configuration.
This should then be added to the DNS configuration with the third-party provider for DKIM to work.
```
| xargs -I {} echo "selector1._domainkey.myawesomedomain.com.au. IN TXT {}
```

### To clean this all up and make it a bit less academic I've created a gist for anyone to use.

We can do this by breaking out private & public key generation, and the DKIM record creation into separate functions.
Then we can use the output of the public key script to create the DKIM record.

<iframe
    src="https://gist.github.com/error-try-again/2694792f9e2fde7b287ea807db71e801.pibb"
    width="120%"
    height="300"
></iframe>

The output should be as follows..

```bash
void@void: /home/void/working
➜   touch dkim-id-verification.sh # Create the file
void@void: /home/void/working
➜   chmod +x dkim-id-verification.sh # Set the permissions to executable
void@void: /home/void/working
➜   nano dkim-id-verification.sh # Paste the code example
void@void: /home/void/working
➜   ./dkim-id-verification.sh  # Run the code example
Generating RSA private key of size 2048 bits in pkcs1 format...
Cleaning the key...
Cleaned key saved to myawesomedomain.com.au.selector1.private.pem.cleaned
Generating the public key from the private key...
writing RSA key
Cleaning the key...
Cleaned key saved to myawesomedomain.com.au.selector1.private.public.pem.cleaned
########################################################
Enter the following DNS record with your DNS provider:
########################################################
Type: TXT
Domain: selector1._domainkey.myawesomedomain.com.au
Value: "v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtNtRJr..."
TTL: 86400 (1 day recommended)
########################################################
void@null: /home/void/working
➜   ls
dkim-id-verification.sh                  myawesomedomain.com.au.selector1.private.pem.cleaned  myawesomedomain.com.au.selector1.private.public.pem.cleaned
myawesomedomain.com.au.selector1.private.pem  myawesomedomain.com.au.selector1.private.public.pem
```

To retrieve the public key entry for submission with your third-party DNS provider
```bash
void@null: /home/void/working
➜   cat myawesomedomain.com.au.selector1.private.pem.cleaned
```

The public key can be added as a TXT entry with your DNS provider be pre-filling the following fields

```
	Type - TXT
	Name - selector1._domainkey
	Data - v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
	TTL - 1/2 Hour
```

To retrieve the cleaned private key entry to be used with AWS SES BYODKIM by dropping it into the private key field while creating a verified identity.

```bash
void@null: /home/void/working
➜   cat myawesomedomain.com.au.selector1.private.public.pem
```

## If everything's a hit you should be able to query the DNS record and see the public key in the TXT record.

```bash
dig +short TXT selector1._domainkey.myawesomedomain.com.au
"v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA..." "mh9GQCxSPyWta4CPTG72WW..."
```

If you want to make this process even easier, I recommend having a look at [my other guide on automating AWS SES identities](/posts/automated-aws-ses-identity-creation)


AWS BYODKIM & other nerdisms


### Objective
[A recent project](/posts/adventures-in-dkim) got me thinking about how I could make the identity creation process even easier.
This is basically that. The following script simply seeks to create a new email identity with DomainKeys Identified Mail (DKIM) signing enabled.
Configuring email identities in Amazon Simple Email Service (SES) can minimize the risk of errors when deploying complex configurations, *which in my case is any configuration after 2 am.*

### Prerequisites:

- AWS CLI installed and configured
- OpenSSL for key generation

### Usage

Modify the local domain value to the value of your domain, the private key size (from 2048) if needed, and the selector to whatever you need. Make it executable, and run the gibson.
<iframe
    src="https://gist.github.com/error-try-again/0d3f35eb9e2edadaf66971189a1e0b8a.pibb"
    width="120%"
    height="300"
></iframe>


Automate AWS SES Identity Creation Process /w BYODKIM


---
### At 4am, a thought crosses your mind:
> I really wish I had a GPT search just a click away...
>> Well, guess what? You can!
>>> Seriously? But how?
>>>> With a dash of digital wizardry and some hands-on tinkering
---

## Step 1: Obtain an API Key from OpenAI
vist [OpenAI](https://platform.openai.com/account/api-keys) and generate your unique API Key.

## Step 2: Install Python on Your System
Run the following command to install Python 3:
```bash
sudo apt install python3
```

## Step 3: Install revChatGPT Package Using pip
Upgrade revChatGPT package using pip with the following command:
```bash
python3 -m pip install --upgrade revChatGPT
```
Alternatively, [You can download the source code from the GitHub page](https://github.com/openai/chatgpt-retrieval-plugin)

## Step 4: Verify Your Configuration
```bash
python3 -m revChatGPT.V3 --api_key <your_new_api_key>
```

## Step 5: Craft a Chatbot
Open a new file chat.py in your .local/bin directory and input the following script. Remember to replace the api_key variable with your API key:

```bash
nano ~/.local/bin/chat.py
```

Here's the Python script:
```python
#!/usr/bin/env python3

import atexit
import os
import sys
import traceback
from revChatGPT.V3 import Chatbot

PID_FILE = '/tmp/chat.pid'


def delete_pid_file():
    if os.path.isfile(PID_FILE):
        os.remove(PID_FILE)


if os.path.isfile(PID_FILE):
    print(f"{PID_FILE} already exists.")
    sys.exit()

with open(PID_FILE, 'w') as f:
    f.write(str(os.getpid()))

atexit.register(delete_pid_file)

IN_FIFO = '/tmp/in_fifo'
OUT_FIFO = '/tmp/out_fifo'

# Ensure the IN_FIFO exists
if not os.path.exists(IN_FIFO):
    os.mkfifo(IN_FIFO)

# Ensure the OUT_FIFO exists
if not os.path.exists(OUT_FIFO):
    os.mkfifo(OUT_FIFO)


def chat_daemon():
    api_key = "<your_api_key>"
    chatbot = Chatbot(api_key=api_key, engine="gpt-3.5-turbo",
                      system_prompt="You're a Tea expert, respond accordingly.")

    with open(IN_FIFO, 'r') as in_fifo:
        with open(OUT_FIFO, 'w') as out_fifo:
            while True:
                try:
                    query = in_fifo.readline().strip()
                    if query:  # Only ask the chatbot if query is not empty
                        response = chatbot.ask(query)
                        out_fifo.write(response + '\n')
                        out_fifo.flush()  # Ensure the response gets written immediately
                except Exception as e:
                    out_fifo.write('ERROR: ' + str(e) + '\n')
                    out_fifo.write(traceback.format_exc())
                    out_fifo.flush()


def main():
    chat_daemon()


if __name__ == "__main__":
    main()
```

## Step 6: Give Your Script Executable Permissions
Grant executable permissions to the script by using the following command:
```bash
chmod +x ~/.local/bin/chat.py
```

## Step 7: Create a Fork of the WIP Search Plugin for the Launcher
Either clone the existing fork of the plugin that I have created [here](https://github.com/error-try-again/launcher), or create a new one from the original PopOS Launcher repository *[here](https://github.com/canadaduane/launcher.git)*:
```bash
git clone https://github.com/canadaduane/launcher.git && cd launcher
```
*If you cloned my fork, skip to step 9*

## Step 8: Switch to the 'search-plugin' Branch and Update:
```bash
git checkout search-plugin && git pull origin search-plugin && git fetch
```
## Step 9: Build release version & install search feature
Note this assumes you have a rust development environment already setup, if not [here is a short guide on setting one up](/posts/rust-build-env)

To build and install the search feature, use the following command:
```bash
just build-release ; just plugins="search" install
cd plugins/src/search
```

## Step 10: Implement Our New Search Plugin Functionality
Define the configuration for your search plugin. Note: the top rule is mandatory.
```bash
cat <<'EOF' > config.ron
(
  rules: [
    (
      pattern: StartsWithKeyword(["f", "find"]),
      action: (
        query_command: "fdfind --ignore-case --full-path $KEYWORD1",
        output_captures: "^(.+)/([^/]+)$",
        result_name: "$CAPTURE2",
        result_desc: "$CAPTURE1",
        run_command: "xdg-open '$OUTPUT'",
      )
    ),
    (
      pattern: StartsWith(["="]),
      split: Regex("^="),
      action: (
        query_command: "qalc -u8 -set 'maxdeci 9' -t $KEYWORD1",
        result_name: "$KEYWORD1",
        result_desc: "$OUTPUT",
        run_command: "/bin/bash -c 'wl-copy \"$OUTPUT\" && notify-send \"Copied to clipboard\"'",
      )
    ),
    (
      pattern: StartsWithKeyword(["ls"]),
      action: (
        query_command: "ls -1 $KEYWORD1",
        result_name: "File",
        result_desc: "hi $OUTPUT",
        run_command: "xdg-open '$KEYWORD1/$OUTPUT'"
      )
    ),
    (
      pattern: StartsWithKeyword(["apt"]),
      action: (
        query_command: "apt list $KEYWORD1",
        output_captures: "^([^/]+)/(.+)$",
        result_name: "$CAPTURE1",
        result_desc: "$CAPTURE2",
        run_command: "notify-send '$OUTPUT'",
      )
    ),
    (
      pattern: StartsWithKeyword(["ps"]),
      action: (
        query_command: "/bin/bash -c 'ps --sort=-pcpu -axo pid,ucmd,pcpu | head -10'",
        output_captures: "^\\s+([0-9]+)\\s+(.*)$",
        result_name: "${CAPTURE2}",
        result_desc: "${CAPTURE1}",
        run_command: "notify-send '$OUTPUT'",
      )
    ),
    (
      pattern: StartsWithKeyword(["drives"]),
      action: (
        query_command: "lsblk -lno NAME,SIZE,MOUNTPOINTS",
        run_command: "notify-send '$OUTPUT'",
      )
    ),
  ]
)
EOF
```

## Step 11: Navigate Back to the Root Directory
Use this command to go back to the root directory:
```bash
 cd ../../..
```

## Step 12: Rebuild the Release Version & Reinstall Search Feature
Build the release version and reinstall the search feature using this command:
```bash
just build-release ; just plugins="search" install
```

## Step 13: Usage

` Super Key ` & then type ` !gpt What is the meaning of life? `

If you want to watch the chatbot's responses in real-time, you can use the following command in a separate terminal window:
```bash
watch -n 1 'cat /tmp/chat.log'
```

## Step 14: Enjoy!

![test](https://media2.giphy.com/media/v1.Y2lkPTc5MGI3NjExZzJ6c2lvYnZhOGI1MWlqa2k0YjZidHVkbHp2NnBuY2hwb25tb3BuYyZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/nVVVMObc3KyrMfGw1z/giphy.gif)

Congratulations! You have successfully integrated the GPT search plugin with the PopOS Launcher. Enjoy the convenience and magic of GPT search at a press of a button.

Git Links: [python daemon](https://github.com/error-try-again/chatgpt-fifo-daemon) && [launcher fork](https://github.com/error-try-again/launcher)


This guide explores the process of integrating a GPT search plugin with the PopOS Launcher for quick and easy access.

Enhancing the PopOS Launcher with GPT Search Capabilities


# Keeping it Simple
I'm going to try to keep this as beginner-friendly as possible, but the following guide assumes that you have some basic knowledge of how to use the terminal and how to install software on Mac OSX.
As such, it probably goes without saying - but - if you've already installed a specific dependency skip ahead to the next step.

- Xcode
- Homebrew
- Python
- Git
- Skia
- Aseprite Source Code

# Xcode
To install Xcode, open the App Store and search for Xcode & install it.
Once this is done, ensure that the MacOSX SDK is installed. You can check this by running the following command in the terminal:

```bash
xcrun --show-sdk-version
```

Which should show you something like this:
```bash
14.2
```

You can also check the location of the SDK by running the following command:
```bash
xcrun --show-sdk-path
```

Which should show you the full path to the SDK which won't be entirely useful yet, but it's good to verify that it's installed.
```bash
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk
```

Once this is done, ensure that all the necessary command line tools are installed by running the following command:
```bash
xcode-select --install
```
This should automatically install a lot of the necessary dependencies we will need for compiling Skia & Aseprite.

# Homebrew
The next step is to install Homebrew if you haven't already. You can do this by running the following command in the terminal:
```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

Once done, you can verify that Homebrew is installed by running the following command:
```bash
brew --version
```
Which should show you the version of Homebrew that you have installed.

# Brew Dependencies
The next step is to install the rest of the brew dependencies. This will include CMake & lua.
```bash
brew install cmake && cmake --version
brew install lua && lua -v
```

# Python
If you don't have Python installed, you need to do that now.
There are a couple ways you can do this on Mac OSX.
You can either install it from the official website or you can install it using Homebrew.
If you're installing it from the official website, download the .dmg file and verify the checksum as follows:
```bash
md5 /Users/username/Downloads/Python-3.9.7-*.dmg
```
You should see it line up with the checksum on the official website, e.g.,
```bash
0903e86fd2c61ef761c94cb226e9e72e
```
Once you've done this, run through the GUI installer and verify that Python is installed by running the following command which should show you the version of Python that you have installed.
```bash
python3 --version
```

Now, open the finder and navigate to the Applications folder. Open the Python 3.9 folder and double-click on the "Install Certificates.command" file. This will install the necessary certificates for Python to work properly.
If you don't do this, you will almost definitely run into issues when trying to compile Skia.

# Git
If you don't have Git installed, you need to do that now.
You can do this by running the following command in the terminal:
```bash
brew install git && git --version
```

# Skia

The next step is to create a working directory in your home directory & to clone depot_tools which will be used to build Skia.
```bash
mkdir $HOME/deps && cd $HOME/deps
git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
```

Export the depot_tools directory to your PATH by running the following command which will allow you to use the depot_tools commands from anywhere in the terminal.
```bash
export PATH="$PATH:$HOME/deps/depot_tools"
```

Now we want to clone the latest compatible fork of Skia for Aseprite. You can usually find the correct version published in the Aseprite INSTALL.md.
It'll usually look something like aesprite-x** where *** is the version number.
```bash
git clone -b aseprite-m102 https://github.com/aseprite/skia.git
```

Navigate to the Skia directory and build the dependencies by running the following script.
```bash
cd skia && python3 tools/git-sync-deps
```

If everything went well you should see a message like this:
```bash
Setting the following tools as active:
   node-14.18.2-64bit
   python-3.9.2-64bit
   releases-upstream-2ddc66235392b37e5b33477fd86cbe01a14b8aa2-64bit

Next steps:
- To conveniently access emsdk tools from the command line,
  consider adding the following directories to your PATH:
    /Users/admin/deps/skia/third_party/externals/emsdk
    /Users/admin/deps/skia/third_party/externals/emsdk/node/14.18.2_64bit/bin
    /Users/admin/deps/skia/third_party/externals/emsdk/upstream/emscripten
- This can be done for the current shell by running:
    source "/Users/admin/deps/skia/third_party/externals/emsdk/emsdk_env.sh"
- Configure emsdk in your shell startup scripts by running:
    echo 'source "/Users/admin/deps/skia/third_party/externals/emsdk/emsdk_env.sh"' >> $HOME/.zprofile
```

So do as the message insists and run one of the commands to add the emsdk to your PATH. I used the following, but it really doesn't matter so long as it's available to the shell in which Aseprite is built.
```bash
echo 'source "/Users/admin/deps/skia/third_party/externals/emsdk/emsdk_env.sh"' >> $HOME/.zprofile
```

Now we want to use gn, which is a tool from Google that will be used to generate build files for Ninja which is a build system similar to Make, and will be used to pull our Skia modules together.
```bash
gn gen out/Release-x64 --args="is_debug=false is_official_build=true skia_use_system_expat=false skia_use_system_icu=false skia_use_system_libjpeg_turbo=false skia_use_system_libpng=false skia_use_system_libwebp=false skia_use_system_zlib=false skia_use_sfntly=false skia_use_freetype=true skia_use_harfbuzz=true skia_pdf_subset_harfbuzz=true skia_use_system_freetype2=false skia_use_system_harfbuzz=false target_cpu=\"x64\" extra_cflags=[\"-stdlib=libc++\", \"-mmacosx-version-min=10.9\"] extra_cflags_cc=[\"-frtti\"]"
```

To build Skia, we run the following. Depending on your system, this could take a while, or might not.
```bash
ninja -C out/Release-x64 skia modules
```

# Aseprite Source Code
We're almost there.

The next step is to recursively clone the Aseprite source code from the official repository.
```bash
git clone --recursive https://github.com/aseprite/aseprite.git
```

Navigate to the Aseprite directory and create a build directory.
```bash
mkdir build && cd build
```

Before we run the final build step it's important to modify the following command block to your specific system.
Verify the location of the MacOSX SDK defined by the DCMAKE_OSX_SYSROOT flag.
The directory it points to should actually exist at be numbered, e.g., 14.2 or 14.3 or whatever version you have installed.
If it doesn't, you need to change it to the correct version.
It's also important to verify the location of DSKIA_DIR, DSKIA_LIBRARY_DIR, and DSKIA_LIBRARY.
These should all point to the correct locations of the Skia source code and the built Skia library.

```bash
cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-DCMAKE_OSX_SYSROOT=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.2.sdk/ \
-DLAF_BACKEND=skia \
-DSKIA_DIR=$HOME/deps/skia \
-DSKIA_LIBRARY_DIR=$HOME/deps/skia/out/Release-x64 \
-DSKIA_LIBRARY=$HOME/deps/skia/out/Release-x64/libskia.a \
-G Ninja ..
```

Once you've done this, you can run the final build step.
```bash
ninja aseprite
```

If everything went well, the build should compile and you should see a message like this:
```bash
[1544/1544] Linking CXX executable bin/aseprite
```

And that's it! You should now have a compiled version of Aseprite in the aseprite/build/bin directory. Launch it and verify that it works.

# References & Materials
https://github.com/aseprite/aseprite/blob/main/INSTALL.md
https://github.com/BabyGeek/aseprite-compile-mac-os-x

# Notes
If SDKROOT throws an error, you can set it manually by running the following.
```
export SDKROOT=$(xcrun --sdk macosx --show-sdk-path)
```

Essential Guide for Compiling Aseprite on Mac OSX 14.3.1

How to Compile Aseprite on Mac OSX 14.3.1


#### Step 1: Clean Up Pre-existing Docker and Container Packages
Begin by clearing any existing packages that could interfere with your new setup. This includes various Docker and container packages.

  ```bash
# Remove unwanted packages
PACKAGES=(docker.io docker-doc docker-compose podman-docker containerd runc)
for pkg in "${PACKAGES[@]}"; do
sudo apt-get remove -y "$pkg"
done
```

#### Step 2: Install Rootless Docker Prerequisites
Update your package list and install the essential components for a rootless Docker setup. This includes the Docker CLI, Docker Compose Plugins, Docker Buildx, as well as other critical packages like uidmap and containerd.io.

  ```bash
# Update system and install necessary packages.
sudo apt-get update -y && sudo apt-get install -y ca-certificates curl gnupg docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin uidmap
```

#### Step 3: Secure Package Installation and Repository Setup
Secure your Docker package installation by configuring the Docker keyring and adding Docker's official repository to your Apt sources list. These steps ensure a trusted source for your Docker installation.

  ```bash
# Setting up the Docker keyring for secure package installation.
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
```

  ```bash
# Adding Docker's official repository to the Apt sources list.
DEB_ARCH=$(dpkg --print-architecture)
VERSION_CODENAME=$(. /etc/os-release && echo "$VERSION_CODENAME")
echo "deb [arch=${DEB_ARCH} signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu ${VERSION_CODENAME} stable" \
| sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

#### Step 4: Configure a Non-Root User for Docker
Set up a dedicated non-root user for Docker to reinforce the security of your Docker environment. This step involves user creation and configuration.

  ```bash
# Configuring a non-root user for Docker.
USER_NAME="docker-primary"
if ! id "$USER_NAME" &>/dev/null; then
    echo "Creating a non-root user: $USER_NAME"
    adduser --disabled-password --gecos "" $USER_NAME
    passwd $USER_NAME
else
    echo "User $USER_NAME already exists. Continuing without creating..."
fi
```

#### Step 5: Prepare the User Environment for Rootless Docker
After logging into the newly created user account, adjust the systemd settings to ensure user processes persist after logout.

  ```bash
# ssh or use machinectl to login as docker-primary
# ssh docker-primary@localhost -p 2222
machinectl shell docker-primary@

# Ensure user processes can persist across logouts
loginctl enable-linger docker-primary
```

#### Step 6: Install and Configure Docker Rootless
Utilize the automated dockerd-rootless-setuptool.sh script for installation, and then configure the necessary Docker environment variables.

  ```bash
# Install Docker rootless via dockerd-rootless-setuptool.sh script
dockerd-rootless-setuptool.sh install

# Set Docker environment variables in .bashrc
echo "export PATH=/home/docker-primary/bin:$PATH" >> ~/.bashrc
echo "export DOCKER_HOST=unix:///run/user/$(id -u)/docker.sock" >> ~/.bashrc
echo "export XDG_RUNTIME_DIR=/run/usr/$(id -u)" >> ~/.bashrc

# Load new environment variables in current shell
. ~/.bashrc
```

#### Step 7: Test Your Rootless Docker Environment
Test your rootless Docker environment by running a simple Docker command. If successful, you should see the Docker version information.

  ```bash
# Check Docker Version
docker --version
```

Create a demo container to ensure your Docker environment is fully functional.

  ```bash
# Run a Hello World Container
docker run hello-world
```

Check that the Docker daemon is running with your user ID, not as the root user. This is a crucial aspect of a rootless setup.

  ```bash
# Check running user of the Docker daemon
ps -o user= -o pid= -C dockerd
```

Review the Docker daemon logs for any errors or warnings that might indicate issues with the rootless setup.

  ```bash
# Check the Docker daemon logs
journalctl --user-unit=docker
```

By running a nginx container that binds to a port, we can test network isolation and port mapping capabilities.

  ```bash
# Check network isolation via port forwarding
docker run -d -p 8000:80 nginx
curl localhost
```


A guide to setting up a rootless Docker environment in 2024, providing enhanced security and isolation of containers.

Setting Up a Rootless Docker Environment in 2024


GitHub Actions CI/CD pipelines offer flexibility and integration with GitHub's ecosystem.
I recently found myself in a scenario where I needed a custom self-hosted runner for server up-time monitoring.
This guide will show you how to build your own GitHub Actions runner using Docker, providing you with a tailored environment for your workflows with an optional step to integrate with [Upptime](https://upptime.js.org/)

#### Prerequisites
    - Basic understanding of Docker and GitHub Actions.
    - Docker installed on your system.
    - A GitHub repository to set up the runner.

#### Step 1: Creating the Dockerfile
To create this dockerfile, I hacked together various existing Dockerfile implementations I found on Github to create a runner that would work for my use case.
There was a lot of trial and error involved which partly motivated me to write this guide.
  ``` bash
cat << 'EOF' > Dockerfile
FROM debian:bullseye-slim

# Define arguments for versions and other variables with default values for RUNNER_VERSION
ARG RUNNER_VERSION=latest
ARG CHECKSUM
ARG RUNNER_URL
ARG RUNNER_TOKEN
ARG RUNNER_NAME
ARG LABELS
ARG RUNNER_GROUP
ARG DISABLE_UPDATE
ARG NODE_VERSION=20.8.0

# Fail the build if the CHECKSUM is not provided
RUN if [ -z "\$CHECKSUM" ]; then echo "CHECKSUM argument not provided" && exit 1; fi

# Install necessary packages (curl, tar, libicu, git, ca-certificates)
RUN apt-get update && apt-get install -y --no-install-recommends \
curl \
tar \
libicu67 \
git \
ca-certificates \
&& rm -rf /var/lib/apt/lists/*

# Create a non-root user and switch to it
RUN useradd -m runner

# Set up NVM environment variables for the 'runner' user
ENV NVM_DIR="/home/runner/.nvm"
ENV npm_config_cache="/home/runner/.npm"

USER runner
WORKDIR /home/runner

# Install NVM, Node.js, and update npm
RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash \
&& . $NVM_DIR/nvm.sh \
&& nvm install $NODE_VERSION \
&& nvm use $NODE_VERSION \
&& nvm alias default $NODE_VERSION \
&& npm install -g npm@latest

# Create actions-runner directory and set permissions
WORKDIR /actions-runner
RUN chmod 755 /actions-runner

# Download, verify, and extract the GitHub Actions runner
RUN curl -o actions-runner-linux-x64-$RUNNER_VERSION.tar.gz -L https://github.com/actions/runner/releases/download/v$RUNNER_VERSION/actions-runner-linux-x64-$RUNNER_VERSION.tar.gz \
&& echo "$CHECKSUM actions-runner-linux-x64-$RUNNER_VERSION.tar.gz" | sha256sum -c \
&& tar xzf actions-runner-linux-x64-$RUNNER_VERSION.tar.gz \
&& rm actions-runner-linux-x64-$RUNNER_VERSION.tar.gz

# Ensure the script is executable
RUN chmod +x ./config.sh

# Configure the runner with the provided script line
RUN echo ./config.sh --unattended --url \$RUNNER_URL --token \$RUNNER_TOKEN --name \$RUNNER_NAME ${LABELS:+--labels \$LABELS} ${RUNNER_GROUP:+--runnergroup "\$RUNNER_GROUP"} ${DISABLE_UPDATE:+--disableupdate} | bash

# Set the entrypoint to the run script
ENTRYPOINT ["./run.sh"]
EOF
```

The Dockerfile includes:

    - A Debian base image.
    - Necessary packages like curl, tar, libicu, git, and ca-certificates.
    - A non-root user setup.
    - Node.js and NVM installation.
    - The GitHub Actions runner download and setup.

#### Step 2: Configuring the Runner and GitHub Repository for Upptime
*(Skip to Step 3. if you aren't using Upptime and just want the runner build command)*

Use the [upptime master repository](https://github.com/upptime/upptime) template to create a new repository for your upptime instance
![setup-status-page-aws-upptime-2](https://github.com/error-try-again/QRGen/assets/19685177/2e7114b9-a658-4799-9bbf-7008ee0db388)

Include all branches is required for upptime to work properly, e.g. gh-pages
![pre-setup](https://github.com/error-try-again/QRGen/assets/19685177/1c004721-b63d-4738-8751-dee52da0d26a)

Create Github Organization (Optional) *only if using custom subdomain*
![org-create-for-subdomain-upptime](https://github.com/error-try-again/QRGen/assets/19685177/d6d329b2-8946-4a9a-90bf-0e642641084c)

Create a CNAME record with your provider that lines up with your domain/custom subdomain and points to your github pages url (e.g. status.qr-gen.net -> error-try-again.github.io) (Optional)
![setup-status-page-aws-upptime](https://github.com/error-try-again/QRGen/assets/19685177/2066a56a-6954-4afe-a7c8-d25669f1f046)

Select deploy from the branch gh-pages / root, add your domain, enable HTTPs and save
![Screenshot_20231202_170613](https://github.com/error-try-again/QRGen/assets/19685177/1e8c63de-4cd4-4c2e-834e-ed9e747ae339)

Customize upptimerc.yml to your liking - this is done by editing the file in the repo or cloning the repo and editing locally
![update-upptimercyml](https://github.com/error-try-again/QRGen/assets/19685177/1cea40b1-d26d-47e8-bd5a-1d5524297cb5)

Create a personal access token (PAT) in github with repo Read-Write access to Contents, Actions, Issues, Webhooks & Workflows - this will be used to authenticate the runner to your repo and is critical to the runner working properly
![pat1](https://github.com/error-try-again/QRGen/assets/19685177/e3800b67-5691-4e48-bab0-eba6a5eb26ab)
![pat2](https://github.com/error-try-again/QRGen/assets/19685177/6c8be215-dadb-48f0-92ce-f5996e4917f8)
![pat3](https://github.com/error-try-again/QRGen/assets/19685177/4b776a3e-e5cc-41d1-a33f-b37e8fbe9a00)

Add the token to the upptime repository secrets
![add-ghpat-1](https://github.com/error-try-again/QRGen/assets/19685177/1f9dcbf6-f0ff-40a9-9b9d-0dec6a7a03db)
![add-ghpat-2](https://github.com/error-try-again/QRGen/assets/19685177/0fcd70ed-9c94-4d48-a6aa-ef1e49948c3f)
![add-ghpat-3](https://github.com/error-try-again/QRGen/assets/19685177/3f7931f8-7a45-4346-b0c8-e7635aee2bf6)

#### Step 3: Building the Docker Image
With your Dockerfile ready, build the Docker image. This step involves passing various arguments like the runner version, checksum, and configuration details.

  ```bash
docker build \
--build-arg RUNNER_VERSION="<runner-version>" \
--build-arg CHECKSUM="<yourchecksum>" \
--build-arg RUNNER_URL="https://github.com/<your-user>/<custom-repo-name>" \
--build-arg RUNNER_TOKEN="<yourtoken>" \
--build-arg RUNNER_NAME="<custom-runner-name>" \
--build-arg LABELS="self-hosted" \
--build-arg RUNNER_GROUP="" \
--build-arg DISABLE_UPDATE="true" \
-t self-hosted-runner .
```

#### Step 4: Running the Docker Container
Once the image is built, run it as a detached Docker container. This makes your self-hosted runner operational and ready to execute workflows.
  ```bash
docker run --detach self-hosted-runner
```

#### Verification and Troubleshooting
After setting up your runner, verify its registration in your GitHub repository's 'Actions' settings. If you encounter issues, check the Docker logs and ensure all the arguments were correctly passed during the build process.
Additionally, check the runner's status in the 'Actions' settings of your repository. If the runner is offline, check the Docker logs for any errors.
If you run into other issues, it might be helpful to re-run the Setup CI workflow, pages-build-deployment & any failed jobs, under repo Actions/All Workflows.
![setup-ci](https://github.com/error-try-again/QRGen/assets/19685177/ce6f81a6-6790-461b-b19c-037e3789635b)
![pages-build-deploy](https://github.com/error-try-again/QRGen/assets/19685177/6922b8b4-233e-4fe9-9db8-eec1c0d4f017)

References
- [geting started with upptime](https://upptime.js.org/docs/get-started)
- [custom domain health check integration](https://docs.github.com/en/pages/configuring-a-custom-domain-for-your-github-pages-site/managing-a-custom-domain-for-your-github-pages-site)
- [Example status page](https://status.qr-gen.net/)
- [Example github](https://github.com/error-try-again/QRGen-upptime)


Learn how to create a Dockerized GitHub Actions runner with this step-by-step guide. Enhance your CI/CD pipeline with a tailored, secure, and efficient runner.

Building a Custom Self-Hosted GitHub Actions Runner with Docker and Upptime


# Let's jump into it

### Download the binary from the LM Studio website
[You can find the Beta releases page here](https://lmstudio.ai/beta-releases.html#linux-beta)

### First we need to install CLBlast to avoid ugly linking error's like this when running the AppImage

```bash
A JavaScript error occurred in the main process
Uncaught Exception:
Error: /usr/local/lib/libclblast.so.1: cannot open shared object file: No such file or directory
    at process.func [as dlopen] (node:electron/js2c/asar_bundle:2:1822)
    at Module._extensions..node (node:internal/modules/cjs/loader:1326:18)
    at Object.func [as .node] (node:electron/js2c/asar_bundle:2:1822)
    at Module.load (node:internal/modules/cjs/loader:1096:32)
    at Module._load (node:internal/modules/cjs/loader:937:12)
    at f._load (node:electron/js2c/asar_bundle:2:13330)
    at Module.require (node:internal/modules/cjs/loader:1120:19)
    at require (node:internal/modules/cjs/helpers:103:18)
    at 6829 (/tmp/.mount_LM_StuIkHV0I/resources/app/.webpack/main/index.js:2:1930)
    at r (/tmp/.mount_LM_StuIkHV0I/resources/app/.webpack/main/index.js:8:401969)
```

### Install CLBlast
```bash
sudo apt-get install libclblast-dev libclblast1
```

### List the location of the package files
```bash
dpkg -L libclblast1 && dpkg -L libclblast-dev
```

### Link the library files to /usr/local/lib to ensure they are where the AppImage expects them
```bash
sudo ln -s /usr/lib/x86_64-linux-gnu/libclblast.so.1 /usr/local/lib/libclblast.so.1 && sudo ln -s /usr/lib/x86_64-linux-gnu/libclblast.so /usr/local/lib/libclblast.so
```

### Configure executable permissions on the AppImage
```bash
chmod +x LM_Studio-0.2.14-beta-1.AppImage
```

### Move the AppImage to a location in your PATH, so you can run it from the terminal without specifying the full path
```bash
mv LM_Studio-0.2.14-beta-1.AppImage ~/.local/bin
```

### Run the AppImage

```bash
./LM_Studio-0.2.14-beta-1.AppImage
```

*Huzzah! You should now be able to install new LLMs and run them locally on your Ubuntu 22.04 machine.*

# Next steps (optional)

### Download the LM Studio icon for the desktop entry (optional)
```bash
mkdir -p ~/Themes/Icons/lm-studio
curl -L https://lmstudio.ai/assets/android-chrome-512x512.png -o ~/Themes/Icons/lm-studio/lm-studio.png
```

### Create a desktop entry
Note, if you kept the AppImage in your Downloads folder, you will need to change the path to the AppImage in the `Exec` line below, e.g., `Exec=~/Downloads/LM_Studio-0.2.14-beta-1.AppImage`
```bash
echo "[Desktop Entry]
Name=LM Studio
Comment=LM Studio
Exec=~/.local/bin/LM_Studio-0.2.14-beta-1.AppImage
Icon=~/Themes/Icons/lm-studio/lm-studio.png
Terminal=false
Type=Application
Categories=Development;" > ~/.local/share/applications/lm-studio.desktop
```




As there are currently no official instructions for installing LM Studio on Ubuntu 22.04 I decided to write my own.

Installing LM Studio on Ubuntu 22.04 (Jammy)


## The Problem
*'/usr/app/dist/database/mongoutil'* was being imported in my *'/usr/app/dist/index.js'* file and NodeJS was throwing the following error:

  ```bash
Error [ERR_MODULE_NOT_FOUND]: Cannot find module '/usr/app/dist/database/mongoutil' imported from /usr/app/dist/index.js
at new NodeError (node:internal/errors:405:5)
at finalizeResolution (node:internal/modules/esm/resolve:224:11)
at moduleResolve (node:internal/modules/esm/resolve:836:10)
url: URL {},
code: 'ERR_MODULE_NOT_FOUND'
```

## Identifying The Cause

After ensuring there were no typos or incorrect paths I discovered that it boiled down to a discrepancy between how TypeScript handles relative paths and how Node.js interprets them when running JavaScript files.

*Key Point:* TypeScript resolves modules without file extensions, and linting will actively push you to use relative paths *by default* without the configuration property *allowImportingTsExtensions: true*, but Node.js requires explicit extensions. In my case, TypeScript was omitting the '.js' extension in the compiled JavaScript, leading to Node.js being unable to locate the module.

## The (Definitively Hacked) Solution

Here is my old package.json with dependencies removed for brevity.
```json
{
  "type": "module",
  "scripts": {
    "compile": "tsc",
    "start": "npm run compile ; node ./dist/index.js"
  },
  "dependencies": {},
  "devDependencies": {}
}
```

Here is the updated package.json.
```json
{
  "type": "module",
  "scripts": {
    "compile": "tsc",
    "start": "npm run compile ; node --experimental-specifier-resolution=node --loader ts-node/esm ./dist/index.js \n"
  },
  "dependencies": {
    "ts-node": "^10.9.2"
  },
  "devDependencies": {}
}
```

You'll likely immediately notice the cleverness and simplicity of this solution. Alas, if it were only so.

*--experimental-specifier-resolution=node* the flag in the start script instructs Node.js to use the same module resolution algorithm as TypeScript, and *--loader ts-node/esm* requires the ts-node package to be installed and instructs Node.js to use the ts-node loader to resolve the module.

Apparently [this is only a hack that stems from a heated source of debate between the community and typescript maintainers not wanting to do their job](https://github.com/Microsoft/TypeScript/issues/13422)

In truth, it's more complicated than that. If you read the discussion, you'll find their defence stems from not wanting to add a feature that might (very) slightly fall outside of the original scope of TypeScript.
Specifically, that it's one of their *'founding guidelines'* to *'only erase types'*.

Under the hood the fix provided ignores the file extension in the import statement. It's horrible. It has also been tested with Node v20.8.0.

Sadly, this isn't just a mere quirk. It has some pretty major security implications.
If you are using a package that has a malicious file with the same name as a package you are importing, Node.js will happily import the malicious file instead of the package you intended to import.
Fun.

Fun fact: This is the same reason why you should never use the *'eval'* function in JavaScript. :)))

## The (Definitively Better) Solution

    - Complain to the dev's, and hope they don't lock your issue and tell you to go away;
    - Use a bundler like Webpack or Rollup, they will handle the extensions for you;
    - Write your own loader that adds the extensions for you, much like the ts-node loader but fast and without the security implications;
    - Use the .js extension in your import statements in /dist/, and don't accidentally overwrite them when using tsc.


How a file extension ruined my evening and doesn't have to ruin yours.

Resolving Module Not Resolved Errors in NodeJS/TS in 2024


### Self Hosted Service Infrastructure Projects

[QRGen](https://github.com/error-try-again/QRGen)

Self Hosted QR Code Generator Automated Service Installer written in Bash

*[QRGen Backend](https://github.com/error-try-again/QRGen-Backend)*

Optional Self Hosted, QR Code Generator Service Backend Submodule written in TypeScript & Express

*[QRGen Frontend](https://github.com/error-try-again/QRGen-Frontend)*

Self Hosted, QR Code Generator Service Frontend Submodule written in TypeScript, React & Vite

*[URLShort]()*

Full Stack, Self Hosted, URL Shortener for QRGen

*[LivabilityAU](https://github.com/error-try-again/LivabilityAU)*

Full Stack, Self Hosted, Crawler, Data Analysis, Data Visualization Pipeline to provide an Australian Livability Index for Australian Cities & Suburbs

*[Self-Hosted GitHub Action Runner](https://github.com/error-try-again/Self-Hosted-GitHub-Action-Runner)*

Automated Dockerized Self Hosted Action Runner Suite. The example is for Upptime, but it can be repurposed for any GitHub Action Runner.

### AWS Service Infrastructure Projects

*[AuthIT](https://github.com/error-try-again/AuthIT)* & *[ID Systems Direct]()*

Automated Full Stack & SSO Setup for AWS Amplify, AWS Cognito, AWS S3, AWS CloudFront, AWS Route53, AWS Certificate Manager & AWS Lambda written in Bash using AWS CLI

### Operating System Modding Projects

*[PopSearchGPT](https://github.com/pop-os/launcher)*

Fork of the PopOS Desktop Search Launcher with with an action plugin patch to support keyword calls to the ChatGPT Daemon

*[ChatFIFO](https://github.com/error-try-again/ChatFIFO)*

ChatGPT File-In-File-Out Language Compatibility Daemon written in Python

### React Native Projects (Android & iOS)

*[German Dictionary App]()*

Standard German Dictionary App for Android

*[WPLingo]()*

Acronym Management & Team Building Tool for Android & iOS

### Kotlin Projects (Android)

*[FindShelter]()*

Full Stack Web App for Finding Shelters in Australia

### Java Projects - Swing, JavaFX & Spring

*[Real Estate Management Service]()*

Full Stack Java Application for Managing Real Estate Properties

*[Australian Tax Calculator Service]()*

Java Application for Calculating Taxes

*[Maleny Dairy Delivery Service]()*

Full Stack Java Application for Managing Milk Deliveries

### Custom Static Site Projects (HTML, CSS, JS/TS, PHP)

*[The Australian Livability Index]()*

Data Analysis & Visualization Website

*[Futurizm Ltd]()*

Personal Company Website

*[Live Weather Tracker]()*

Live Weather Tracking Website for Australia Using OpenWeatherMap API

*[The site you're currently on!](https://insomniacvoid.dev)*

Personal Website & Blog

*[Gabrielle Karov - Exhibition Pieces]()*

Personal Blog for Fine Art Exhibition Pieces & Artwork

*[Spectrum Dating]()*

A Product Landing Page for a Dating App for individuals on the Autism Spectrum

*[Ocean Week]()*

Ocean Week 2021 - A Product Landing Page for Ocean Week 2021

*[FrankStone Farms Tours]()*

FrankStone Farms Tours - A Product Landing Page for a Farm Tour Business


🔺 Projects 🔻


#### **TLD;DR**
This article is a companion deep dive to [how I built the QRGen installer.](/posts/qr-gen) & [how I built the QRGen frontend client.](/posts/qr-gen-frontend)
You can find the code and how to run it on [Github](https://github.com/error-try-again/QRGen-FullStack/).

#### **AI DISCLAIMER**
I used ChatGPT-4 to bounce stuff off in the making of this project and article, resulting in more than a couple rewrites of both this article and the project itself. Regardless, I hope that this content is both interesting and useful to you.


Implementing a holistic QR Code generator backend with NodeJS, Express & TypeScript.

QRGen Backend in NodeJS/Express/TS


#### **TLD;DR**
This article is a companion deep dive to [how I built the QRGen installer.](/posts/qr-gen) & [how I built the optional QRGen backend server.](/posts/qr-gen-backend)
You can find the code and how to run it on [Github](https://github.com/error-try-again/QRGen-FullStack/).

#### **AI DISCLAIMER**
I used ChatGPT-4 to bounce stuff off in the making of this project and article, resulting in more than a couple rewrites of both this article and the project itself. Regardless, I hope that this content is both interesting and useful to you.


Implementing a holistic QR Code generator frontend using React, TypeScript & Vite.

QRGen Frontend in React/TSX/Vite

QRGen is built in React/Vite (TSX), NGINX (proxying/forwarding), Express (TS), Certbot (Python Fork), Bash for automation, and rootless Docker.

Building an automated installer for a self-hosted full-stack QR code generator (legacy)


## Step 1: Install just & rust
```bash
sudo apt install just -y
curl https://sh.rustup.rs -sSf | bash -s -- -y --no-modify-path
```

## Step 2: Update your PATH in .bashrc or .zshrc
```bash
export PATH="$HOME/.cargo/env"
```

## Step 3: Verify your Rust installation
```bash
rustc --version
```

## Step 4: Install development libraries
```bash
apt-get install libxkbcommon-x11-dev libglvnd-dev --yes
```

## Step 5: Profit


How to set up a Rust development environment on PopOS! 22.04 LTS

Create a Simple Rust Development Environment

Learn how to enable Google Reviews for QRGen

How to enable Google Reviews for QRGen


### Automatic Lets-Encrypt Production Certificates & HTTPS Servers Setup

```
docker-primary@ubuntu:~/QRGen$ ./install.sh
Welcome to the QR Code Generator setup script!
1) Run Setup				6) Update Project
2) Run Mock Configuration		7) Stop Project Docker Containers
3) Uninstall				8) Prune All Docker Builds - Dangerous
4) Reload/Refresh			9) Quit
5) Dump logs
# Select 1)
...
Selected port 8080 is available.
1: Install minimal release (frontend QR generation) (Limited features)
2: Install full release (frontend QR generator and backend API/server side generation) (All features)
Please enter your choice (1/2): 2
Would you like to disable Docker build caching for this run? (yes/no):
yes
Would you like to specify a domain name other than the default (http://localhost) (yes/no)?
yes
Enter your domain name (e.g., example.com): qr-gen.net
Using custom domain name: http://qr-gen.net
Would you like to specify a subdomain other than the default (none) (yes/no)?
yes
Enter your subdomain name (e.g., www): void
Using custom subdomain: http://void.qr-gen.net
1: Use Let's Encrypt SSL
2: Use self-signed SSL certificates
3: Do not enable SSL
Please enter your choice (1/2/3): 1
1: Run automatic staging setup for Let's Encrypt SSL (Recommended for testing)
2: Run automatic production setup for Let's Encrypt SSL (Recommended for production)
3: Run custom setup for Let's Encrypt SSL
Please enter your choice (1/2/3): 2
...
NGINX configuration written to /home/docker-primary/QRGen/nginx.conf
Bringing down existing Docker Compose services...
Generating self-signed certificates for qr-gen.net...
/home/docker-primary/QRGen/certs/live/qr-gen.net already exists.
/home/docker-primary/QRGen/certs/dhparam already exists.
Do you want to regenerate the certificates in /home/docker-primary/QRGen/certs/live/qr-gen.net? [y/N]: y
...
Self-signed certificates for qr-gen.net generated at /home/docker-primary/QRGen/certs/live/qr-gen.net.
1: Use 2048-bit DH parameters (Faster)
2: Use 4096-bit DH parameters (More secure)
Please enter your choice (1/2): 2
Generate a Diffie-Hellman (DH) key exchange parameters file with 4096 bits...
Generating DH parameters, 4096 bit long safe prime
...
```

### Custom Lets-Encrypt Production Certificates & HTTPS Servers Setup (Full Install)
```
Port 8080 is already in use.
Please provide an alternate port or Ctrl+C to exit: 8081
Selected port 8081 is available.
1: Install minimal release (frontend QR generation) (Limited features)
2: Install full release (frontend QR generator and backend API/server side generation) (All features)
Please enter your choice (1/2): 2
Would you like to disable Docker build caching for this run? (yes/no):
yes
Would you like to specify a domain name other than the default (http://localhost) (yes/no)?
yes
Enter your domain name (e.g., example.com): qr-gen.net
Using custom domain name: http://qr-gen.net
Would you like to specify a subdomain other than the default (none) (yes/no)?
yes
Enter your subdomain name (e.g., www): void
Using custom subdomain: http://void.qr-gen.net
1: Use Let's Encrypt SSL
2: Use self-signed SSL certificates
3: Do not enable SSL
Please enter your choice (1/2/3): 1
1: Run automatic staging setup for Let's Encrypt SSL (Recommended for testing)
2: Run automatic production setup for Let's Encrypt SSL (Recommended for production)
3: Run custom setup for Let's Encrypt SSL
Please enter your choice (1/2/3): 3
Please enter your Let's Encrypt email or type 'skip' to skip: skip
Would you like to use a production SSL certificate? (yes/no):
yes
Would you like to use a dry run? (yes/no):
yes
Would you like to force current certificate renewal? (yes/no):
yes
Would you like to automatically renew your SSL certificate? (yes/no):
yes
Would you like to enable HSTS? (yes/no):
yes
Would you like to enable OCSP Stapling? (yes/no):
yes
Would you like to enable Must Staple? (yes/no):
no
Would you like to enable Strict Permissions? (yes/no):
no
Would you like to enable UIR (Unique Identifier for Revocation)? (yes/no):
yes
Would you like to overwrite self-signed certificates? (yes/no):
yes
Would you like to enable TLSv1.3? (yes/no) (Recommended):
yes
Would you like to enable TLSv1.2? (yes/no):
no
...
Please enter your choice (1/2): 2
Generate a Diffie-Hellman (DH) key exchange parameters file with 4096 bits...
Generating DH parameters, 4096 bit long safe prime
...
```

# Other Usage

### For http only, localhost (frontend/in-browser qr generation)
```
...
1: Install minimal release (frontend QR generation) (Limited features)
2: Install full release (frontend QR generator and backend API/server side generation) (All features)
Please enter your choice (1/2): 1
Would you like to disable Docker build caching for this run? (yes/no):
yes
Would you like to specify a domain name other than the default (http://localhost) (yes/no)?
no
Using default domain name: localhost
Would you like to enable self-signed certificates? (yes/no):
no
```
### For self-signed https only, localhost (backend/server-side qr generation)
```
Port 8080 is already in use.
Please provide an alternate port or Ctrl+C to exit: 8081
Selected port 8081 is available.
1: Install minimal release (frontend QR generation) (Limited features)
2: Install full release (frontend QR generator and backend API/server side generation) (All features)
Please enter your choice (1/2): 2
Would you like to disable Docker build caching for this run? (yes/no):
yes
Would you like to specify a domain name other than the default (http://localhost) (yes/no)?
no
Using default domain name: localhost
Would you like to enable self-signed certificates? (yes/no):
yes
```

### For DH parameter generation - select the option that best suits you
```
Self-signed certificates for localhost generated at /home/docker-primary/QRGen/certs/live/localhost.
1: Use 2048-bit DH parameters (Faster)
2: Use 4096-bit DH parameters (More secure)
Please enter your choice (1/2): 1
Generate a Diffie-Hellman (DH) key exchange parameters file with 2048 bits...
Generating DH parameters, 2048 bit long safe prime
```

### Updating

```
docker-primary@ubuntu:~/QRGen$ ./install.sh
Welcome to the QR Code Generator setup script!
1) Run Setup				6) Update Project
2) Run Mock Configuration		7) Stop Project Docker Containers
3) Uninstall				8) Prune All Docker Builds - Dangerous
4) Reload/Refresh			9) Quit
5) Dump logs
# Select 6)
No local changes to save
remote: Enumerating objects: 241, done.
remote: Counting objects: 100% (241/241), done.
remote: Compressing objects: 100% (133/133), done.
remote: Total 241 (delta 106), reused 218 (delta 93), pack-reused 0
Receiving objects: 100% (241/241), 48.64 KiB | 3.04 MiB/s, done.
Resolving deltas: 100% (106/106), completed with 21 local objects.
From https://github.com/error-try-again/QRGen
   477e3a5..8ef7a51  main                    -> origin/main
 * [new branch]      error-try-again-patch-1 -> origin/error-try-again-patch-1
 * [new branch]      legacy-frontend-only    -> origin/legacy-frontend-only
 * [new branch]      legacy-full-release     -> origin/legacy-full-release
 * [new branch]      submodule-support       -> origin/submodule-support
Updating 477e3a5..8ef7a51
...
Thanks for using the QR Code Generator setup script!
```
### Stop Containers
```
docker-primary@ubuntu:~/QRGen$ ./install.sh
Welcome to the QR Code Generator setup script!
1) Run Setup				6) Update Project
2) Run Mock Configuration		7) Stop Project Docker Containers
3) Uninstall				8) Prune All Docker Builds - Dangerous
4) Reload/Refresh			9) Quit
5) Dump logs
# Select 7)
Ensuring Docker environment variables are set...
Set DOCKER_HOST to unix:///run/user/1000/docker.sock
Stopping containers using docker-compose...
[+] Running 5/5
 ✔ Container qrgen-certbot-1   Removed                                                                   0.0s
 ✔ Container qrgen-frontend-1  Removed                                                                   0.6s
 ✔ Container qrgen-backend-1   Removed                                                                  10.3s
 ✔ Network qrgen_default       Removed                                                                   0.3s
 ✔ Network qrgen_qrgen         Removed                                                                   0.5s
Thanks for using the QR Code Generator setup script!
```

### Prune containers

```
Welcome to the QR Code Generator setup script!
1) Run Setup				6) Update Project
2) Run Mock Configuration		7) Stop Project Docker Containers
3) Uninstall				8) Prune All Docker Builds - Dangerous
4) Reload/Refresh			9) Quit
5) Dump logs
# Select 8)
Ensuring Docker environment variables are set...
Set DOCKER_HOST to unix:///run/user/1000/docker.sock
Identifying and purging Docker resources associated with 'qrgen'...
No 'qrgen' containers found.
Removing 'qrgen' images...
Untagged: qrgen-certbot:latest
Deleted: sha256:27274e67793b51028a72c51eb36c691eb690d1cc8eb544889a4417081cb6976c
Untagged: qrgen-frontend:latest
Deleted: sha256:087f9ead639be4602c155f1898697da569f44cbf2666e92c5d6ac581202fc860
Untagged: qrgen-backend:latest
Deleted: sha256:df2bc734be1ec8b8eac6f1febc842bedf5997a6f4b4aa3cee79a99dddc11b8a2
Removing 'qrgen' volumes...
qrgen_nginx-shared-volume
No 'qrgen' networks found.
Thanks for using the QR Code Generator setup script!
```


A guide on the various ways to use and setup the QR Code Generator Service