Jason Morganson jasonmorganson

Secret Management

Kubernetes is un-opinionated about how secrets are managed. There's many ways to do it and there's no one-size-fits-all solution. Here's some ways people are doing GitOps secrets:

How to deploy a Prefect agent to Google Kubernetes Engine

This post contains code and commands you can use to deploy Prefect agents to Google Cloud’s Google Kubernetes Engine. The agents stand ready to execute workflows triggered by Prefect projects. One agent can run tasks from multiple projects.

The example here demonstrates how to create a single agent with minimal customization. It is configured with a Dockerfile, which installs necessary dependencies, and a k8s.cfg file, which connects the system to a Prefect account.

Agents are deployed via the gcloud command-line utility and its kubectl extension. Proper permissions within a project on Google Cloud are required.

Getting started

A curated list of command-line utilities written in Rust

Note: I have moved this list to a proper repository. I'll leave this gist up, but it won't be updated. To submit an idea, open a PR on the repo.

Note that I have not tried all of these personally, and cannot and do not vouch for all of the tools listed here. In most cases, the descriptions here are copied directly from their code repos. Some may have been abandoned. Investigate before installing/using.

The ones I use regularly include: bat, dust, fd, fend, hyperfine, miniserve, ripgrep, just, cargo-audit and cargo-wipe.

atuin: "Magical shell history"
bandwhich: Terminal bandwidth utilization tool

Based on this blogpost.

To sign Git commits, you need a gpg key. GPG stands for GNU Privacy Guard and is the de facto implementation of the OpenPGP message format. PGP stands for ‘Pretty Good Privacy’ and is a standard to sign and encrypt messages.

Setting up

Install with Homebrew:

$ brew install gpg

The Twelfth Factor Correction

This is a series of notes on the Essay https://12factor.net/codebase

I. Codebase: One codebase tracked in revision control, many deploys

A twelve-factor app is always tracked in a version control system, such as Git, Mercurial, or Subversion. A copy of the revision tracking database is known as a code repository, often shortened to code repo or just repo.
A codebase is any single repo (in a centralized revision control system like Subversion), or any set of repos who share a root commit (in a decentralized revision control system like Git).

12 factor app specifically argues against a monorepo. Their argument is that the shared code should be refactored out into dependencies, as in Factor II. This is a valid argument, but the overhead of separating dependencies and testing them individually is not worth the cost for most small teams. The pattern of building a series of components of a distributed system from a common codebase - Of having one monorepo that produces m

Base role with limit in inherited roles

Suppose, we have an inherited role, inherited_role which inherits from two roles role1 and role2 which are defined as the following manner:

{
  "select_permissions": [
       {
         "role": "role1",
 "permission": {

This page has moved!

Please see here: contour-terminal/vt-extensions

Synchronized Output

Synchronized output is merely implementing the feature as inspired by iTerm2 synchronized output, except that it's not using the rare DCS but rather the well known SM ? and RM ?. iTerm2 has now also adopted to use the new syntax instead of using DCS.

	// Run with node --expose-gc bench.js ../automerge-paper.json.gz
	// automerge-paper.json.gz from https://github.com/josephg/crdt-benchmarks

	// Read in a patch file and check that the patches all apply correctly.
	const fs = require('fs')
	const assert = require('assert')
	const zlib = require('zlib')
	const automerge = require('automerge')
	const v8 = require('v8')

	class BQDatasetAuthorizer(ContextDecorator):
	def __init__(self, target, profile_file):
	self.target = target
	self.profile_file = profile_file
	# this dict maps a dataset to a list of BigQuery Access entries defined by code.
	# We expect groupByEmail and View.
	# https://googleapis.dev/python/bigquery/latest/generated/google.cloud.bigquery.dataset.AccessEntry.html
	self.auth_dict = defaultdict(list)

	def __enter__(self):

	#!/usr/bin/env ruby
	# Generate a dbdiagram for dbdiagram.io from a dbt project.
	#
	# Usage:
	# 1. Run `dbt docs generate` first.
	# 2. Run `dbt_to_dbdiagram.rb`
	# 3. Paste the output in https://dbdiagram.io/

	require 'yaml'
	require 'json'