Yes it’s not the cheapest option, but I think it’s the only one if you need zfs send/receive. But if you don’t need it you can get less than 5TB for cheaper, or just go elsewhere.

You have over 70TB of data you want to backup? That’s a lot. How are you making backups of that for only 99/year?

rsync.net offers ZFS send/receive and I’ve been using it for 5 years now, it’s pretty great. It’s not super expensive per GB, but they ask a minimum of 5TB if you want native ZFS support, which is $60/month.

You get access to a full FreeBSD VM which is very nice, because you can do things like metrics or a “pull” setup that pulls backups from your machines, so you’re more resilient against stuff like ransomware.

The feedback from the Inkscape project is a great read.

Excerpt:

Over time, I have notice that the contributions from volunteers in the USA have waned, while those from the EU have increased dramatically.

I’ll check it out, thanks!

Okay, thanks!

Yeah, I don’t really need to backup the system, except for a list of installed software, but I guess that’s all included somewhere in ~/.local or whatever, since it’s flatpak homebrew and steam.

Did anything specific break?
I’ll look into vorta, thanks!

On my NixOS and Arch machines I used ZFS snapshots for backups. That’s why I specifically asked for Aurora / Bazzite users.

Question for all Bazzite/Aurora users: what do you use to make backups of your machine?

I’m using Pikabackup to make backups of /home, but I’m not sure if there’s a better way?

“Capitalism creates innovation!”
The innovation:

You can use your token with the REST api. And use that to do whatever you want.

you can also use your token for git clone like so:

$ git clone https:/git:put_your_token_here@github.com/myown/repo

That would be block storage like glusterfs or ceph, or object storage like minio or rook.

You could also use ZFS to provide PVCs for your Pods, with openebs.

If the mini-servers don’t have hardware redundancy, I’d stick to Replicated Volumes only…

If you go the openebs+ZFS route, you can make a kubernetes service (DaemonSet because it should run on every node) that makes and sends/exposes ZFS snapshots.

Here’s an article that does this: https://iridakos.com/programming/2018/03/01/bash-programmable-completion-tutorial

I have done this for one of my own tools ta, which is a function that switches to a tmux session, or creates it if it doesn’t exist:

# switch to existing tmux session, or create it.
# overrides workdir if session name is "Work"
function ta() {
        case "$1" in
                Work) workdir="${HOME}/Work/" ;;
                *) workdir="${HOME}" ;;
        esac
        if tmux has-session -t "$@" &>/dev/null; then
                tmux switch-client -t "$@"
        else
                tmux new-session -A -D -d -c "${workdir}" -s "$@"
                tmux switch-client -t "$@"
        fi
}

# complete tmux sessions
# exclude current session from completion
function _ta_completion() {
        command="${1}"
        completing="${2}"
        previous="${3}"
        [[ "${command}" != 'ta' ]] && return
        current_session="$(tmux display-message -p '#S')"
        IFS=$'\a' COMPREPLY=( $(tmux list-sessions -F '#{session_name}' | grep -i "^${completing}" | grep -v "^${current_session}$"| tr '\n' '\a' ) )
}
# enable completion for ta function
complete -F _ta_completion ta

Usage

$ tmux (starts session "0" by default)
$ ta Personal # create session "Personal" because it doesn't exist
$ ta Work # create session "Work" because it doesn't exist
$ ta <tab> 
0 Personal
$ ta P<tab> -> $ta Personal
$ ta <tab>
0 Work

Artists will probably have their own setup, software and workflow that they are comfortable with. I’d recommend letting them use their own workflow, and just discussing the interface, so to speak: what file format(s) to use and such. I think GLTF is used for assets, but I’m definitely not an expert.

As for other devs, most required tooling (e.g. Unity or Pycharm or whatever) are one-time installs that you can list somewhere. And language libraries/dependencies are a solved problem (e.g. pipenv, cargo, yarn).

But if you really want to set this up, nix (or lix) is probably your best bet for a total devenv that is exactly reproducible, assuming that works for WSL (or no one uses windows).

Otherwise docker/podman or devenv will probably be doable as well.

Maybe you can use the spicy tape to prevent your pets from eating the cables (assuming that works on them)?

Orher than that, maybe you can setup some metrics (and alerting?) to keep an eye on the diskspace?

Congratulations!

Tip: don’t use /dev/nvme0n1 directly, but use device aliases in /dev/disk/. I prefer /dev/disk/by-id/ but maybe another works better in your case.

# find all aliases for nvme drives (no partitions)
find /dev/disk/ -type l -ilname '*nvme?n?' -printf '%l %p\n' | sed 's!^../../!!' | sort

Try starting vim without config, I think that’s

vim -u NONE

Does it still occur then?

If not, it’s a config issue in /etc/vimrc and/or ~/.vimrc (or maybe ~/.config/vim/vimrc or something?)

If it does, it has to be something else.

Free.mp3 - Dubioza Kolektiv
(It’s a surprise that will help us later)