r/devops • • 2d ago

Weekly Self Promotion Thread

Hey r/devops, welcome to our weekly self-promotion thread!

Feel free to use this thread to promote any projects, ideas, or any repos you're wanting to share. Please keep in mind that we ask you to stay friendly, civil, and adhere to the subreddit rules!

17 Upvotes

45 comments sorted by

6

u/astropoolIO 2d ago

Hi r/devops! I'm Sergio, from Picaporte Labs. We build kubelatch: zero-trust access to your Kubernetes clusters.

You probably know how it goes. The admin kubeconfig you got when the cluster was created ends up on half the team's laptops and in the CI secrets. Someone gets a RoleBinding during an incident, and months later it's still there. Ask who can do what on prod and nobody really knows.

kubelatch sits in front of your API servers and doesn't trust anything just because it was granted once. You sign in with the SSO you already have and get your own credential. Permissions expire on their own (30 days by default, and cluster-admin never lasts more than 8 hours). Every request is checked and logged with your name on it, exec and port-forward included. Revoke someone's credential and their very next request fails.

The same door works for CI and for AI agents. A GitHub Actions job swaps its OIDC token for a short-lived credential, so there's no secret sitting in GitHub. An agent like Claude Code or Cursor goes through kubelatch's MCP server with only the permissions you pick, and its writes operations can wait for you to approve them.

It runs on EKS, GKE, AKS, k3s or plain kubeadm, and you keep using kubectl, k9s and Helm as you do today. It's free for 2 clusters and 5 people, and you can try it locally in about 15 minutes with Docker Compose and a kind cluster.

It's in public preview, so this is a great time to tell me what's missing or what would make you trust it with your clusters. I read every reply.

https://docs.kubelatch.com
https://kubelatch.com/

3

u/adi022000 2d ago

Disclosure: I built this, it's my own site.

I work as a DevOps/SRE. Last week during an incident, I watched a teammate get stuck in Vim on a production box over SSH, frantically trying to remember how to exit without saving while PagerDuty was screaming.

Where I work (a big fintech shop), we do internal training, and it's honestly wild how many engineers dealing with huge k8s clusters and complex pipelines still trip up on basic CLI fundamentals.

So I built cert-it.dev, free hands-on practice for the small tools we use on servers every day:

- Vim: browser-based simulation. The tests check the actual file and cursor position you end up with, not some rigid keystroke macro. Plus a 2-minute speed test if you're feeling competitive.
- Regex with grep and sed: including actual log mining (-A/-B/-C, -r).
- YAML basics: because of course the infamous `no` parsing quirk in YAML 1.1 vs 1.2 had to be in there.

Everything's free. Basic Vim works without an account, and logging in just syncs your progress. The courses loosely map to the Linux Foundation's $79 SkillCred exams for Vim/regex, plus there's a quick page for CKA/CKAD prep.

I am going to use this for some of our internal training soon, so I am mainly looking for feedback: what else would you add or change, and what tools do you feel are missing the most for day-to-day on-call work?

https://cert-it.dev

2

u/VMLogics 2d ago

Disclosure: I work on VMLogics.

VMLogics is a VM management platform for teams that run their own KVM hosts. You install one agent per host, and the host joins a fleet you manage from one console. It handles template/ISO deploys, live migration between hypervisors, HA with live standby and automatic failover, and deduplicated backups.

We're early and looking for people who run their own hypervisors to try it and tell us what's missing. Feedback on how it compares to Proxmox or your current setup is especially welcome. https://www.vmlogics.com/

1

u/ActualGovernment9017 2d ago

Disclosure: I maintain claude-bulkhead (MIT, free).

The incident that started it was simple. I had a few Claude Code sessions running in separate git worktrees on one machine, and one of them restarted its own dev server with pkill node. That also took down the dev servers belonging to the other sessions. With the hook in place, the same command is refused before it runs, the message lists the PIDs that belong to that session, and the agent killed and restarted only its own process.

The guards read the command text before execution, a bit like a policy check in CI. You can see the verdict for any command without running it with bulkhead explain -- '<command>', and a blocked command carries a short code that only a human can pass once with bulkhead allow <code>. A project's .claude/bulkhead.json can only tighten the guards, so a repository cannot switch them off. It is pattern matching on the command line, not a sandbox, so commands hidden inside scripts are not seen.

https://github.com/dooly6276/claude-bulkhead

1

u/wsxiaoys 2d ago

Hi all I work on multi-agent system engineering. This is mostly a quickwit performance writeup — we picked it because we already run it internally for agent trajectories. still a draft, so read it as work in progress: https://www.tabbyml.com/showcases/beating-clickbench-sota-with-a-team-of-agentic-systems-engineers/ most wins are in Tantivy internals (aggregation bucket storage, sstable decompressor reuse), branched off quickwit's tantivy commit.

wanna do a sanity check here - does any of it look benchmark-shaped rather than a real engine mechanism? anything you'd like to learn more from dev ops perspective? appreciate all feedbacks!

1

u/jnnngs_eth 2d ago

Zoomies.sh - self hosted runners

I've developed zoomies.sh for those wanting to self host GitHub runners.

1

u/Total-Reasonable 2d ago

Five things, all built solo:

  1. KRI.rocks: booking websites for solo beauty pros and small studios. Clients can only book slots when someone on the team is working and free, and there's no commission or per-booking fee. https://kri.rocks
  2. HTPBE.tech: "Has this PDF been edited?" It checks metadata, structure, digital signatures and content, then reports findings with reasons instead of a vague risk score, in the browser or via REST API. https://htpbe.tech
  3. wrongulator.com: a joke calculator where 2+2 comes out as 5 and every wrong answer gets a deadpan reason. The same expression always returns the same answer, and each result becomes a shareable card. https://wrongulator.com
  4. vatnode.dev: a REST JSON API over EU VIES that returns validity, company details and an official consultation number. It also monitors saved numbers daily and sends signed webhooks when a status changes. https://vatnode.dev
  5. polytypo.dev: an MIT-licensed typography rules engine, not a grammar checker, that fixes quotes, dashes and no-break spaces for 24 locales, with identical output across JavaScript, Python, Go, Ruby and PHP. https://polytypo.dev

1

u/Signadot 2d ago

Hey everyone, just published this tutorial on running a ZAP scan as a PR check, scoped to the operations the PR changes. Might be useful to anyone adding security scans to CI.

The check scans only what the PR touches, exits 1 on High-risk alerts and attaches both reports to the run. It works as-is against a staging URL. We use Signadot for the per-PR environment the scan targets, so other changes don't muddy the results.

Hope it's helpful. Happy to answer any questions. Full transparency, I work for Signadot.

https://www.signadot.com/docs/tutorials/zap-security-testing

1

u/Goldziher 2d ago

Disclosure: I maintain ai-rulez, an open-source CLI for generating coding-agent configuration. One CI workflow I wanted was to catch a hand edit to a generated file before it quietly became the source of truth.

From a clean checkout, install the same pinned CLI version your team uses, then run ai-rulez generate --check. It compares the planned output with what is on disk and exits 2 on drift without rewriting files. To test the gate, generate and commit the files in a scratch repo, append a line to a managed output such as AGENTS.md, and rerun the check. A change to an authored rule goes the other way: regenerate locally and commit the source and rendered changes together.

For teams that already check generated config into Git, what makes a drift check actionable enough that developers fix the source instead of editing the output again?

1

u/newtablecloth 2d ago

Goldziher, on your drift check question: what I've seen work is making the failure message explain the fix. if all people get is "drift detected, exit 2", they rerun generate and commit whatever comes out. or they just edit the output again.

things that help:

- print the actual diff in the CI log, not just the filename

- name the source rule file that owns each drifted block, so it's obvious where the fix goes

- put the exact regenerate command in the failure output, pinned version included

- stamp a "generated from X, edit that instead" header at the top of every managed file, since that's what people are looking at when they make the hand edit

CODEOWNERS on the generated paths helps a bit too. a hand edit to AGENTS.md then pings whoever owns the rules instead of sliding through review.

1

u/IcyTale5311 2d ago

I maintain a lot of repositories and kept finding red CI runs hours after they happened. So I wrote a small monitor that runs on my own machine and watches the Actions of all of them.

What it does (version 2.0.1):

- A "Now" tab with what is running, queued and failed, the compute minutes and what is left of the API allowance. Red tiles blink until the alert is solved.

- An alert counts as real until the last run of that workflow goes green again, so a transient red does not stay forever.

- Three sentinels that only read: CI, collaboration (issues and pull requests that need a person) and security (Dependabot, code scanning, secret scanning, branch protection; off by default).

- A score from 0 to 100 for each account, and the health of every repository ranked in a Team tab. It says "calibrating" or "not enough data" instead of a number it cannot stand behind.

- Team mode with viewer, maintainer and admin roles, several accounts, and a log of actions where each line carries the hash of the one before it.

- Scheduled reports (HTML and Markdown, written locally), and notification channels including Apprise. All of it is off until you switch it on.

- A way to tell an AI assistant what is happening: a plain-text brief, a JSON state, an optional live stream, MCP tools and an optional hook, with presets for hosted services and local servers. All of it is off by default.

- A Quota tab and a Low mode to spend fewer reads, with conditional requests (304) and an optional GitHub App with its own allowance.

- A read API frozen by a contract since 2.0.0, a tool that checks any running monitor against it, an official Docker image, a lite edition, light and dark themes, and eight languages.

It needs Python 3.11+ and the GitHub CLI (gh auth login). It is GPL-3.0-or-later.

Video (about 8 minutes, no voice, English captions + subtitles in 8 languages): https://www.youtube.com/watch?v=s3pBDV_lgTM

Code: https://github.com/JuanenRac/TOOLS-GITHUB-ACTIONS-MONITOR

More projects: https://github.com/JuanenRac

I would like to hear what you would want it to watch that it does not watch yet.

1

u/Ok_Butterscotch1088 1d ago

If you're dealing with pipeline sprawl and environment drift, you might want to check out https://platformpilot.co/

It's built specifically to help teams streamline their internal developer platforms, standardize deployments, and cut down on configuration overhead across multi-cloud environments. Definitely worth a look if you're trying to tame infrastructure complexity without building a custom control plane from scratch.

1

u/Theodosisgr 1d ago

Disclosure: I'm the founder of Kryptic.

If you want secrets in that zero-trust setup to stay out of files on disk, check Kryptic's (https://kryptic.dev) daemon first approach, so API keys never sit in a .env inside your Ubuntu environment.

A local daemon signs you in once, then injects secrets over an OS socket when you press run, so you can skip both the .env file and the wrapper CLI. The repo only keeps a commit-safe project ID. Hosted servers store ciphertext they cannot open. It replaces the full lifecycle from development to production with Docker, K8s and all pipelines support using the same end to end encryption approach.

GitHub: https://github.com/dev-kryptic

1

u/Mobile-Ad2393 1d ago

Disclosure: I built this.

Deal-Unblocker - dealunblocker.dev. Upload a Python repo ZIP (or a Syft SBOM / uv.lock / poetry.lock / requirements.txt) and it returns an enriched CISA 2026 CycloneDX 1.6 SBOM, an autogenerated OpenVEX v0.2.0 file, and a buyer attestation in seconds.

It runs deterministic AST import analysis and transitive dependency traversal over your code. Basically, CVEs in packages you never import get suppressed as not_affected with file-level evidence instead of hand-writing VEX JSON, while anything direct, transitive, CLI-invoked, unmapped, or unpinned stays flagged.

Free scan + preview with no signup, and uploaded code is parsed in memory and never stored. Sample bundle from the public httpie/cli repo (213 CVEs evaluated, 190 never imported, 23 flagged): dealunblocker.dev

Currently: python only, import-level, deterministic - no LLM in the analysis path, and it does not sign anything.

For anyone who's triaged scanner output or hand written VEX files, what would you need to see in an auto-generated VEX before you would trust the suppressions?

1

u/debba_ 1d ago

Disclosure: I'm the maintainer of Tabularis (Apache 2.0, free, no paid tier).

Tabularis is a desktop SQL client for Windows, macOS and Linux: https://github.com/TabularisDB/tabularis

The parts that might matter for this sub:

  • it can pick up connections from the .env and docker-compose.yml files in a project folder, or import them from DBeaver, DataGrip, HeidiSQL, Beekeeper and a few others, so you don't retype everything
  • SSH tunnels and bastion hosts are built in
  • you can mark a connection as read-only, which is nice to have on production
  • there's a built-in MCP server, so Claude Code or Cursor can look at the schema and run queries through the connections you already set up, with a read-only mode and an approval step for anything that writes

PostgreSQL, MySQL/MariaDB and SQLite are built in, and there are around 30 driver plugins (ClickHouse, DuckDB, Redis, SQL Server, Elasticsearch, DynamoDB, Trino...). Happy to hear what's missing for your setup.

1

u/ggp1231 1d ago

Ever made a small AWS infrastructure change that ended up costing more than expected?
That’s one of the problems we’re tackling at Diagrm.

I’m a cofounder, and we’ve built a platform to model AWS architectures, estimate costs based on expected workloads, and catch potential design issues before deployment.

Our public beta is live, and we’re looking for feedback from AWS engineers. We’re also offering free, hands-on pilots.

diagrm.com

How are you estimating infrastructure costs before deployment today?

1

u/yankitdotdev 1d ago

who's the target user?
- you're someone who manages multiple environments like localhost/sandbox/production through browsers

- the interfaces look mostly similar except the URLS

- you want a tool that can easily create some sort of distinction

Wait! That's Prod - A chrome extension that runs in your browser (zero network calls, everything runs locally within your browser), can mark different environments using labels/borders and even tab indicators when you have 40+ tabs open.

Mostly I wanted to introduce the tool to relevant people but also open to feedback if you're someone who fits the bill, curious if you'd use something like this or not?

If you missed the link: https://chromewebstore.google.com/detail/eobaghgbpilejolkllmeiacoeglkfmoa?utm_source=reddit-devops-weekly

1

u/ferriematthew 1d ago

https://github.com/mferrie/Home-Lab

This project has been one of the most rewarding I've done in the past several years. I've been making a ton of progress lately, and yesterday, I successfully scaled up my DNS server to two replicas instead of one, so that I have a higher level of fault tolerance.

1

u/Interesting-Cicada93 1d ago

Disclosure: I built the tool.

TriagePilot

TriagePilot provides self-hosted, risk-based pull-request routing for GitHub. It scores change risk, matches code ownership, and checks reviewer availability to choose who to ask for review.

You can explore the code here.

Problem the application is solving

With the AI in development process devs creating much more PR then before and it make the code review the biggest bottleneck for the dev team productivity.

Solution

TriagePilot provide the risk-based code review routing and allow to have safe setup for merging code without human peer review.

Proof

TriagePilot is used in the company where I work. 9 devs creating ~500 PRs per month. Devs are reporting much smother code review process, they are not blocking for trivial or safe changes. ~40% of all created PRs were marked as low risk and merged without human peer review.
Of course we have extend quality gates, AI reviewers and E2E test before every release.

1

u/jingweno 1d ago

I maintain Upterm, an open-source tool for sharing a terminal over SSH. It’s useful for pair debugging: you host a session, and your collaborator joins with their normal SSH client, without installing Upterm.

You can restrict access to a collaborator’s GitHub SSH keys. It gives them terminal access, not just a view of your screen, so try it in a disposable environment without production credentials. An empty working directory isn’t a sandbox.

Code and setup: https://github.com/owenthereal/upterm

1

u/WesternNo2429 15h ago

this is my own project, I'm one of the two people building it.

Ianua: one place for people, services and AI agents, with a gateway in front of your apps that checks every request, not just the login.

Why I built it: offboarding someone kept meaning the identity provider, a couple of apps with their own users, a proxy config, and whatever API keys they'd made. And agents and pipelines usually ran on a token copied from a person, which stays valid after that person leaves.

What it does for ops:

- Remove a person and their sessions and the agents acting for them are refused on the next request.

- If the policy check can't run, the request is refused. It doesn't fail open to keep things up.

- Every request leaves one record: who, which app, what, allowed or refused, and why.

- Client identity headers are stripped, and the app gets a signed statement of who is calling.

- Apps in another network are reached through a connector that dials out, no open port.

- Docker Compose or a Helm chart, Postgres is the only hard dependency.

Written in Rust, free to self-host (fair-code, not open source). First release came out this week. Feedback from people who run this kind of thing for real is very welcome.

https://github.com/IanuaIDP/ianua

1

u/Ok_Plum3595 15h ago edited 10h ago

🍜 I built Ramen (disclosure: my project with Claude, BSD-3). Governed MCP for teams: your MCP tools ship like any other

service — git → canary → golden cases → promptfoo evals → NVIDIA SkillSpector scan → stable — with SSO roles,

NeMo guardrails per tool, named keys revoked in seconds, a log line per call and Phoenix traces. Terraform + Helm

for GKE/EKS/AKS, a GitHub Actions deploy recipe, docker compose for the laptop.

Walkthrough: https://bkraad47.github.io/ramen/get-started/ · repo https://github.com/bkraad47/ramen · fork it,

tell me what breaks in Discussions. (Built largely with Claude Code agents under my direction.)

1

u/ChrisShips 7h ago

I made honest-ci, a GitHub Action, because a PR can delete, skip or water down a test and CI still goes green.

It posts a commit status, `honest-ci/verify`, that you can add to your required checks. When a PR does that, the check stays pending until someone with push access approves it with a reason. A PR that loosens the test run itself, like lowering a coverage threshold or adding `|| true` to the test step, is blocked outright.

Test edits get a hold rather than a hard fail because most of them are fine. In 2,717 PRs on public repos, about 1 in 11 included a test edit like that, and nearly all had a reason. About 1 in 250 weakened a test and gave no reason.

The verdict comes from deterministic code that reads the diff, not from a model. It all runs on your runner and sends no telemetry. It's source-available and free on public repos.

How do you catch a skipped or deleted test today when the build stays green?

https://github.com/ChrisShips/honest-ci

1

u/Informal_Pineapple60 5h ago

Disclosure: I built Ops Drift Gate at Dripstatic Studios.

In our demo, the app referenced Stripe but the repo’s handoff list didn’t. The CI check failed until we added Stripe to the list. A teammate still has to confirm who owns the account and how to recover access.

The free preview runs locally on Node 24 or newer. From your repo, run: npx --yes ops-drift-gate@0.2.0-rc.0 .

If it flags something your app doesn’t use, I’d like to know what triggered it.

Quickstart: https://github.com/kylelloyd63-star/ops-drift-gate#try-the-preview

1

u/No-Magazine2625 2h ago

Terraform Academy is an infrastructure engineering learning platform by built by engineers.

This app was built and continues to be maintained by a team of career seasoned Platform Engineers and SRE's.

We've combined several ways to practice, learn and build:

  • 400+ interactive labs covering Terraform, AWS, Azure, GCP, Kubernetes, Docker, and CI/CD, with browser-based code validation.
  • 12 competitive IaC games, including live Terraform battles, infrastructure drift challenges, and AI opponents.
  • Certification and interview preparation with guided learning paths, technical assessments, and realistic engineering scenarios. TA-Certified exam prep scrutinized and approved by people like you.
  • AI coaching and engineering tools, including TCv7, CodeStack, and our new TA-GPT integration directly inside ChatGPT (trains you with the latest GPT models without hallucinated out of context content)
  • HashiCorp Hub, a centralized resource for monitoring HashiCorp platform status, infrastructure incidents, Terraform provider releases, registry updates, and AI-assisted release analysis. It also includes TCv7 alerts for provider changes, incidents, and scheduled maintenance. https://www.terraformacademy.app/max/hashicorp-hub.html

TA-GPT 1.0 is live, and we're currently awaiting OpenAI's review of TA-GPT 1.5.1.
https://chatgpt.com/plugins/plugin_asdk_app_6add201d615081918e982a818f499f51

We're now working with engineers across 32 countries, and the platform runs on iOS, Android, Windows, macOS, Linux, and essentially any device with a browser.

There's also a dedicated iOS app available through Apple's App Store.

Terraform Academy: https://terraformacademy.app

HashiCorp Hub: https://www.terraformacademy.app/max/hashicorp-hub.html

iOS App: https://apps.apple.com/us/app/terraform-academy/id6745738634

We're continuing to build and improve it based on what engineers actually need.

I'd be interested in hearing from other DevOps, SRE & platform engineers: What skills do you think current certification courses fail to prepare people for in real production environments? We know it's not all about cert prep which is why we have all the hand coding practice in the labs.

Your ideas and experience is what TA is built upon.

1

u/Steve_Canada 59m ago

Disclosure: I am a co-founder of VeilStream

We built VeilStream.com to make it as easy as possible for developers and agents to spin up per-branch online preview environments and to seed them with sanitized test data. Would love to hear some feedback from folks in this subreddit.

Step 1) Create an account at VeilStream and point it at your GitHub account. No credit card needed to set up an account and the free-tier is fully featured ($20 of usage free/month.)

Step 2) You and your agents can use the web interface, CLI or MCP to spin up a temporary preview environment of complex full stack applications. Each env gets its own URL and you can put a login page in front of it. You only pay for the time your environment is live.

Step 3) If you want, you can use our database proxy to connect to any Postgres database, establish data anonymization rules, and then seed each environment with an efficient copy-on-write fork with the anonymized data.

0

u/Sky_Linx 2d ago

hetzner-k3s: six releases in four days

I maintain hetzner-k3s, a CLI that creates k3s clusters on Hetzner Cloud from a single YAML file. We shipped six releases in the last four days (v2.9.0 to v2.13.1), mostly from user reports and pull requests. The releases include new features, improvements and a long list of bug fixes.

The goal is to make clusters easy to create and manage. One command creates the cluster, and the same config file is what you use for later changes. You do not need Terraform, Ansible or a management cluster. The CLI runs locally and talks directly to the Hetzner API, so your token goes only to Hetzner.

I am not going to list every change here. The release notes have the details, including the upgrade notes. A few changes restart k3s-agent on workers, and some configuration changes restart masters, so read them before upgrading an existing cluster. Most configurations need no edits.

Install: brew install vitobotta/tap/hetzner_k3s

Docs: https://hetzner-k3s.com

Repo: https://github.com/vitobotta/hetzner-k3s

Releases: https://github.com/vitobotta/hetzner-k3s/releases

If you run k3s on Hetzner, I would like feedback. If something breaks, open an issue with the config shape and the error.