Skip to content

Latest commit

Β 

History

52 Commits

Folders and files

Repository files navigation

πŸ“¦ VK's Devcontainers

This repository contains personal container images for Devcontainers, tailored for AI-assisted .NET/NodeJS software development. It aims to provide a reproducible & standardized Linux development environments.

vkotzsev/opensuse-tumbleweed vkotzsev/opensuse-leap vkotzsev/ubuntu-lts

🧰 Toolchains

The full toolchain (language runtimes, SDKs, CLIs, shell, editor tooling, certificate trust, etc.) is installed at image build time inside the Dockerfile and shipped as part of the published image. I deliberately do not rely on the devcontainer spec's Features mechanism to provision the core toolchain at container-create time.

This is intentional. Baking the toolchain into the build phase gives us:

  • Reproducibility. A tagged image (e.g. opensuse-tumbleweed:2026.02.12.1) is byte-identical for every developer who pulls it. No drift from upstream Features picking up a new version on a Monday morning.
  • Fast container startup. No multi-minute per-create install step - the container is ready as soon as it's pulled.
  • Single auditable supply chain. Every install command, package version, signing key, and trust root lives in the Dockerfile in this repo, is reviewed via PR, and is built, vulnerability-scanned, and auto-patched in CI (see πŸ›‘οΈ Security scanning & patching). No opaque per-feature install scripts run on the developer's machine.
  • Version pinning via the image tag, not via a moving Feature version.

Devcontainer Features remain a perfectly valid escape hatch for project-specific additions that don't belong in the shared base image (see Add a devcontainer template to your project). The core toolchain, however, always comes from the image - for example, Docker-outside-of-Docker (the docker CLI client plus a bind-mounted host socket) is baked into every flavor rather than pulled in via the docker-outside-of-docker Feature.

🐳 Images

Note

πŸ“„ Every flavor below ships a ready-to-use devcontainer.json template under its <flavor>/.devcontainer/devcontainer.json. The template wires up the published image with sensible defaults (non-root developer user, Fish as the default VS Code terminal, persistent Fish history & XDG cache volumes plus shared logins/caches volumes (Claude Code, GitHub CLI, Azure CLI, NuGet, npm), Docker-outside-of-Docker wiring with engine-aware Testcontainers host overrides, a tuned NODE_OPTIONS heap, and a curated set of VS Code extensions for .NET, web, and GitHub workflows). It is intended as a starting point: you can freely extend it with any property from the devcontainer.json reference - additional mounts (bind mounts, named volumes, tmpfs), extra forwardPorts, postCreateCommand hooks, containerEnv/remoteEnv variables, and so on. If you need a tool that isn't in the base image, you can also layer on a project-specific Dev Container Feature - but note that the core toolchain itself is intentionally baked into the image at build time, not provisioned via Features (see Toolchains). You can drop the template straight into a project at .devcontainer/devcontainer.json - see Add a devcontainer template to your project and each flavor's own README for the full breakdown.

🦎 OpenSUSE Tumbleweed

Metadata Value
Author Vasil Kotsev
Path OpenSUSE/Tumbleweed/
Devcontainer template OpenSUSE/Tumbleweed/.devcontainer/devcontainer.json

The current image is based on opensuse/tumbleweed:latest and includes:

  • Microsoft package repo: configured for OpenSUSE to install .NET packages
  • Sensible defaults & toolchains for .NET and Node.js environments

🧾 Installed Software

  • Certificate and TLS tooling:
    • CA certificates
    • Mozilla CA bundle
    • Curl
    • OpenSSL
    • GPG (signing & key management)
  • System and privilege tools:
    • Sudo
    • Development toolchain (patterns-devel-base-devel_basis)
    • glibc
    • ICU
  • Source control and remote access:
    • Git
    • GitHub CLI (gh)
    • OpenSSH
    • Lazygit (terminal UI for Git)
    • Git Credential Manager (git-credential-manager, configured via your own ~/.config/git/config - see Git Credential Manager)
  • Terminal and shell experience:
    • Fish shell (w/shell integration)
    • FZF (w/shell completion)
    • Ripgrep (w/shell completion)
    • fd (w/shell completion)
    • zoxide (smarter cd)
    • tmux (terminal multiplexer)
    • ncdu (disk usage analyzer)
  • Developer CLI and editors:
    • jq
    • awk (GNU gawk)
    • Neovim
    • SQLite
    • tree-sitter-cli (global npm install)
  • File management & archives:
    • Yazi (terminal file manager)
    • 7-Zip
    • file
  • Media & document tools:
    • FFmpeg
    • Poppler PDF tools (poppler-tools)
  • Language and platform toolchains:
    • Python 3.14
    • .NET SDK 10.0
    • Node.js LTS (via FNM)
    • pnpm (via Corepack)
    • LuaJIT
    • .NET global tools:
      • dotnet-ef
      • dotnet-outdated-tool
      • gitversion.tool
      • nuke.globaltool
      • ilspycmd
      • easydotnet
      • git-credential-manager
  • Cloud and secrets tooling:
    • Azure CLI
    • SOPS
  • Container tooling:
    • Docker (DooD)
  • Browser/runtime dependencies:
    • GNOME Keyring
    • Browser runtime support libraries (graphics/audio/X11/font stack)
  • AI developer tooling:
    • OpenCode V2 (global npm install of @opencode/cli)
    • Anthropic Claude Code CLI (global npm install)

Note: the base image opensuse/tumbleweed:latest may include additional preinstalled OS packages not listed above.

🦎 OpenSUSE Leap

Metadata Value
Author Vasil Kotsev
Path OpenSUSE/Leap/
Devcontainer template OpenSUSE/Leap/.devcontainer/devcontainer.json

A variant of the image above, based on the stable opensuse/leap:16.0 release rather than the rolling Tumbleweed base. It provisions the same corporate trust setup, Microsoft package repo, toolchains, and developer defaults - and ships an equivalent ready-to-use devcontainer.json template. See OpenSUSE/Leap/README.md for the full breakdown.

🐧 Ubuntu LTS

Metadata Value
Author Vasil Kotsev
Path Ubuntu/LTS/
Devcontainer template Ubuntu/LTS/.devcontainer/devcontainer.json

A Debian-family variant based on ubuntu:26.04, providing the same corporate trust setup, toolchains, and developer defaults (developer user, Fish shell) as the images above, and a matching ready-to-use devcontainer.json template. Key distribution differences: .NET is installed from Ubuntu's own apt feed (Microsoft no longer publishes .NET to packages.microsoft.com for Ubuntu), the Azure CLI is installed via Microsoft's maintained installer, and fnm/sops are pulled as release binaries since they are not packaged in apt. See Ubuntu/LTS/README.md for the full breakdown.

πŸ” Git Credential Manager

Every flavor installs Git Credential Manager (GCM) as a global .NET tool. The images configure nothing themselves - add this to your own ~/.config/git/config (VS Code copies the host git config into the container at create time; nothing is bind-mounted):

[credential]
    helper =
    helper = /home/developer/.dotnet/tools/git-credential-manager
    credentialStore = plaintext
  • The empty helper = drops any system-level helper. It must live in your file, not /etc/gitconfig, because Git reads system config first and appends global config after.
  • credentialStore = plaintext writes to ~/.gcm/store at mode 0700. GCM has no default store on Linux, so without it credential writes fail; use cache to store nothing.
  • The path is the dotnet tool install -g location; adjust it if you build with a non-default USERNAME.

The first HTTPS clone or push triggers GCM's sign-in flow. Credentials are not persisted by default - add a volume for /home/developer/.gcm to keep them across recreations. The images pre-create that directory so the volume is not seeded root-owned.

🏷️ Image Tags

Each flavor is published to docker.io/vkotzsev/<image> with the following stable tags built from main:

Flavor Image Stable tags
OpenSUSE Tumbleweed opensuse-tumbleweed latest, YYYY.MM.DD.N (dated snapshots)
OpenSUSE Leap opensuse-leap latest, 16.0
Ubuntu LTS ubuntu-lts latest, 26.04
  • Tumbleweed uses date-based (CalVer) versioning: every main build produces a new, immutable YYYY.MM.DD.N snapshot (e.g. 2026.02.12.1) and moves latest to it.
  • Leap and Ubuntu track a fixed version tag (16.0 / 26.04) that is overwritten with the newest content on each main build, alongside latest.
  • Every build (on any branch) also publishes an immutable tag equal to the full 40-char commit SHA, letting you pin an image to the exact commit it was built from.
  • Builds from non-main branches publish pre-release tags instead of the above: beta-<version>-<short-sha>, beta-<branch>-<short-sha>, and beta-<branch>-latest.
  • Only the immutable full-SHA tag is published at build time; the stable/beta tags are applied after the CI security gate passes (see πŸ›‘οΈ Security scanning & patching).

See each flavor's README for its specific tags.

πŸ›‘οΈ Security scanning & patching

Every published image is scanned and remediated automatically in CI β€” releases are gated on the result:

  • Scan. Each build is scanned with Trivy, pinned to a fixed version. The full vulnerability scan is uploaded to GitHub's code scanning tab, and a second scan collects fixable OS-package vulnerabilities (the only class that can be patched in place).
  • Patch. If fixable OS-package vulnerabilities are found, Copacetic (copa) patches the image without a full rebuild β€” it applies a lightweight layer on top of the existing image via the flavor's package manager (zypper, dnf, or apt) that upgrades exactly the vulnerable packages from the scan report, and pushes the result alongside the original. A record of what was remediated is emitted as an OpenVEX artifact.
  • Verify & gate. The final image (patched or already-clean) is re-scanned before release. If fixable HIGH/CRITICAL OS-package vulnerabilities remain (e.g. no fix was published upstream yet), the release tags are not updated and the git release tag is never created β€” so latest and the version tags always point to an image that passed the gate.
  • Pin safely. The full-SHA tag always exists and refers to the original build, regardless of the gate outcome, so an exact build can always be referenced even when a release is blocked.

Unfixable vulnerabilities (ignore-unfixed results from the upstream base image) are tracked in code scanning but never block releases, since they cannot be remediated here. Tooling/language-level findings (e.g. npm or .NET packages) are likewise visible but out of scope for copa - the fix is upgrading them in the Dockerfile, which drives the next build.

πŸš€ Using the Devcontainers

To use one of these images in your own repository, copy the relevant flavor's devcontainer.json template into your project, then authenticate to Docker Hub so the image can be pulled.

1️⃣ Prerequisites

2️⃣ Add a devcontainer template to your project

Each flavor ships a ready-to-use devcontainer.json example with sensible defaults (image reference, non-root developer user, Fish as the default VS Code terminal, persistent Fish history & XDG cache volumes + shared logins/caches volumes, and a tuned NODE_OPTIONS heap). Git identity is not mounted - VS Code copies the host git config into the container at create time. Treat it as a starting point - extend it with anything from the devcontainer.json reference, e.g. additional mounts (bind mounts, named volumes, tmpfs), extra forwardPorts, postCreateCommand hooks, or containerEnv/remoteEnv variables. If a project genuinely needs a tool that isn't in the base image, you can also layer on a project-specific Dev Container Feature - but the core toolchain itself is intentionally baked into the image at build time rather than provisioned via Features (see Toolchains).

Copy the template for the flavor you want into your repository at .devcontainer/devcontainer.json:

Flavor Template Published image
OpenSUSE Tumbleweed OpenSUSE/Tumbleweed/.devcontainer/devcontainer.json docker.io/vkotzsev/opensuse-tumbleweed:latest
OpenSUSE Leap OpenSUSE/Leap/.devcontainer/devcontainer.json docker.io/vkotzsev/opensuse-leap:latest
Ubuntu LTS Ubuntu/LTS/.devcontainer/devcontainer.json docker.io/vkotzsev/ubuntu-lts:latest

Tip

The templates reference the :latest tag. To pin to a specific version, change the image tag (e.g. docker.io/vkotzsev/ubuntu-lts:26.04), or pin to an exact commit with the full-SHA tag (e.g. docker.io/vkotzsev/ubuntu-lts:<40-char-commit-sha>).

3️⃣ Open the project in the container

  • VS Code: open the repository and run Dev Containers: Reopen in Container from the command palette.
  • CLI: run devcontainer up --workspace-folder . from the repository root.

πŸ§ͺ Testcontainers & the resource reaper (Ryuk)

Repos whose integration tests use Testcontainers are supported out of the box: the DooD wiring is Testcontainers' native "sibling containers" pattern, and the resource reaper (Ryuk) stays enabled - it is the crash safety net on shared devboxes, so nothing here ever disables it. The one documented exception is rootless Podman (the Podman Desktop default on Windows 11 + WSL), where the engine's user-namespace mapping keeps the reaper from operating; upstream recommends disabling it there as a per-host decision:

export TESTCONTAINERS_RYUK_DISABLED=true
# or, container-wide for one project, in its devcontainer.json:
# "remoteEnv": { "TESTCONTAINERS_RYUK_DISABLED": "true" }

Official docs per client: .NET - Custom configuration (and Running inside a container for the sibling-container pattern & host overrides), Node.js - Configuration & Supported container runtimes, Java - Supported Docker Environments. The flavor READMEs' 🐳 Docker (outside of Docker) sections cover the details - socket access and the engine-aware ~/.testcontainers.properties host override for .NET.

πŸ› οΈ Build locally & drive with the devcontainer CLI

You don't have to consume the published image - you can build any flavor locally and point a project at it. Build from the repo root (the Dockerfiles COPY from Shared/..., so the build context must be the repository root):

docker buildx build --load --platform linux/amd64 -t ubuntu-lts-devbox:local -f ./Ubuntu/LTS/Dockerfile .

Note

On macOS pass --platform linux/amd64 (or linux/arm64 on Apple Silicon); the default builder otherwise targets the host platform and won't produce a Linux image.

Then either retag to the template's image name (docker.io/vkotzsev/<flavor>:latest) or copy the flavor's devcontainer.json and set its image to your local tag, and bring it up with the CLI:

devcontainer up --workspace-folder /path/to/your-project
devcontainer exec --workspace-folder /path/to/your-project -- docker ps

The CLI has no stop/down command - tear down the container with Docker directly (docker ps to find the name, then docker rm -f <container>). Each flavor's README has the full local-build + CLI walkthrough, including the macOS Docker-outside-of-Docker socket caveat (see 🐳 Docker (outside of Docker) in the flavor READMEs).

Releases

Packages

Contributors

Languages