container-superposition 0.1.6 → 0.1.8

package/overlays/redpanda/docker-compose.yml

@@ -43,15 +43,13 @@ services:
             CONSOLE_CONFIG_FILE: |
                 kafka:
                   brokers: ["redpanda:9092"]
-                  schemaRegistry:
-                    enabled: true
-                    urls: ["http://redpanda:8081"]
+                schemaRegistry:
+                  enabled: true
+                  urls: ["http://redpanda:8081"]
                 redpanda:
                   adminApi:
                     enabled: true
                     urls: ["http://redpanda:9644"]
-                connect:
-                  enabled: false
         ports:
             - '${REDPANDA_CONSOLE_PORT:-8080}:8080'
         networks:

package/overlays/rocm/README.md

@@ -0,0 +1,227 @@
+# ROCm (AMD GPU) Overlay
+
+Enables AMD GPU passthrough for containerized ML, inference, and ROCm compute workloads.
+
+> ⚠️ **ROCm-in-container is more fragile than CUDA.** It depends heavily on the host kernel version, AMD driver stack, specific device support, and container runtime configuration. Treat this as a separate supported profile — not a drop-in equivalent of CUDA.
+
+## Features
+
+- **AMD GPU passthrough** - Device flags added to container `runArgs` so host AMD GPUs are accessible
+- **Group membership** - `--group-add=video` and `--group-add=render` ensure the container user can access GPU device nodes
+- **Setup check** - `setup.sh` verifies `rocm-smi` / `rocminfo` on container start and prints actionable guidance when GPU access is unavailable
+- **Doctor integration** - `verify.sh` asserts `rocm-smi` exits 0 for `container-superposition doctor` checks
+
+## Prerequisites (host-side — out of scope for this overlay)
+
+This overlay configures the _container_ side of GPU passthrough. The host must be prepared independently:
+
+1. **Supported AMD GPU** — RDNA 2+ or most CDNA GPUs. Check the [ROCm hardware compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html) before proceeding.
+2. **AMD GPU drivers (`amdgpu`)** — Install the driver package for your Linux distribution:
+    ```bash
+    # Example for Ubuntu — use amdgpu-install from AMD's repository
+    # https://rocm.docs.amd.com/projects/install-on-linux/en/latest/install/amdgpu-install.html
+    sudo apt-get install amdgpu-dkms
+    ```
+3. **ROCm runtime** — Install on the host (or use a container image that bundles it):
+    ```bash
+    # Example for Ubuntu
+    sudo apt-get install rocm
+    ```
+4. **Group membership** — Add your user to the `render` and `video` groups:
+    ```bash
+    sudo usermod -aG render,video $USER
+    # Log out and back in (or reboot) for group changes to take effect
+    ```
+5. **Device nodes** — Verify `/dev/kfd` and `/dev/dri` exist on the host:
+    ```bash
+    ls -la /dev/kfd /dev/dri/
+    ```
+
+> ⚠️ **This overlay cannot install or replace host drivers.** Version alignment between the ROCm user-space libraries inside the container and the host kernel module is the user's responsibility.
+
+## How It Works
+
+The overlay patches `devcontainer.json` with:
+
+```json
+{
+    "runArgs": ["--device=/dev/kfd", "--device=/dev/dri", "--group-add=video", "--group-add=render"]
+}
+```
+
+| Flag                 | Purpose                                                           |
+| -------------------- | ----------------------------------------------------------------- |
+| `--device=/dev/kfd`  | AMD Kernel Fusion Driver; required for ROCm compute               |
+| `--device=/dev/dri`  | Direct Rendering Infrastructure; gives access to GPU render nodes |
+| `--group-add=video`  | Adds the container user to the `video` group (owns `/dev/dri`)    |
+| `--group-add=render` | Adds the container user to the `render` group (owns `/dev/kfd`)   |
+
+The container image itself must include ROCm user-space libraries (e.g., `libamdhip64`) to use ROCm APIs. See [Base Image](#base-image) below.
+
+## Base Image
+
+For ROCm workloads you typically want a ROCm-capable base image. Popular choices:
+
+| Image                   | Use case                             |
+| ----------------------- | ------------------------------------ |
+| `rocm/dev-ubuntu-22.04` | Ubuntu 22.04 with ROCm pre-installed |
+| `rocm/dev-ubuntu-24.04` | Ubuntu 24.04 with ROCm pre-installed |
+| `rocm/pytorch`          | PyTorch with ROCm support            |
+| `rocm/tensorflow`       | TensorFlow with ROCm support         |
+
+Browse all official ROCm images at [hub.docker.com/u/rocm](https://hub.docker.com/u/rocm).
+
+To use a ROCm image, set the `image` field in your `.devcontainer/devcontainer.json` (for plain stack) or configure the appropriate service's `image` in your compose-based devcontainer setup (for compose stack).
+
+## Common Commands
+
+### Check GPU availability
+
+```bash
+# Show GPU product name and status
+rocm-smi --showproductname
+
+# Show all GPU information
+rocm-smi
+
+# Show GPU utilisation
+rocm-smi --showuse
+
+# List all HSA (Heterogeneous System Architecture) agents
+rocminfo
+```
+
+### Discover device nodes
+
+```bash
+# List DRI render nodes on the host
+ls -la /dev/dri/
+
+# Show GPU device details
+rocm-smi --showbus
+```
+
+### Query ROCm version
+
+```bash
+# ROCm version
+cat /opt/rocm/.info/version 2>/dev/null || rocminfo | grep -i 'rocm\|version' | head -n5
+```
+
+### Python / PyTorch ROCm smoke test
+
+```python
+import torch
+print(torch.cuda.is_available())        # True (ROCm uses the CUDA compatibility layer)
+print(torch.cuda.get_device_name(0))    # e.g. "AMD Radeon RX 7900 XTX"
+```
+
+> **Note:** PyTorch ROCm uses `torch.cuda` APIs via the HIP/CUDA compatibility layer. Install the ROCm-specific PyTorch wheel:
+>
+> ```bash
+> pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.0
+> ```
+>
+> Find the correct wheel URL at [pytorch.org/get-started/locally](https://pytorch.org/get-started/locally/).
+
+### TensorFlow ROCm smoke test
+
+```python
+import tensorflow as tf
+print(tf.config.list_physical_devices('GPU'))
+```
+
+> Install the ROCm-specific TensorFlow wheel from [tensorflow/rocm releases](https://github.com/ROCm/tensorflow-upstream/releases).
+
+## Use Cases
+
+- **Model inference** — Run LLM or CV model inference with AMD GPU acceleration
+- **Training** — Train deep learning models without leaving the dev container
+- **ROCm compute** — General-purpose GPU programming with HIP (AMD's CUDA-compatible API)
+- **Jupyter notebooks** — GPU-accelerated data science with Jupyter (combine with the `jupyter` overlay)
+
+**Integrates well with:**
+
+- `python` — Python runtime for ML workloads
+- `jupyter` — Interactive GPU notebooks
+
+## Troubleshooting
+
+### `rocm-smi: command not found`
+
+The container image does not include the ROCm tools. Either:
+
+1. Switch to a ROCm base image (e.g., `rocm/dev-ubuntu-22.04`)
+2. Install ROCm tools inside the image:
+    ```bash
+    sudo apt-get install rocm-smi-lib rocminfo
+    ```
+
+### `No AMD GPU detected` / `/dev/kfd not found`
+
+The GPU device nodes are not accessible inside the container. Work through this checklist:
+
+1. Verify device nodes exist on the **host**:
+    ```bash
+    ls -la /dev/kfd /dev/dri/
+    ```
+2. Verify the `amdgpu` kernel module is loaded on the host:
+    ```bash
+    lsmod | grep amdgpu
+    ```
+3. Rebuild the dev container after confirming device nodes exist.
+
+### `Permission denied on /dev/kfd`
+
+The container user is not in the correct groups. Verify:
+
+```bash
+# Inside the container, check current groups
+id
+
+# On the host, add user to groups and re-login
+sudo usermod -aG render,video $USER
+```
+
+### `ROCm version mismatch`
+
+The ROCm user-space library version inside the image does not match the host kernel module version. Solutions:
+
+- Use a container image whose ROCm version matches the host ROCm installation
+- Check the host ROCm version: `cat /opt/rocm/.info/version`
+- Use the corresponding `rocm/dev-*` image tag
+
+### `--device` flag not recognised
+
+Ensure your Docker version is 19.03+ and the Docker daemon can access the host device nodes.
+
+### GPU not visible in GitHub Codespaces / cloud dev environments
+
+Cloud hosted dev environments (GitHub Codespaces, Gitpod) typically do not provide AMD GPU passthrough. Use a GPU-enabled cloud VM with AMD GPU support and run VS Code Remote SSH.
+
+## Known Limitations
+
+- ROCm version support is tightly coupled to the host kernel version and AMD driver stack
+- Device node names (`/dev/dri/renderD128`) may differ between hosts; the `--device=/dev/dri` flag passes the entire directory
+- Not all AMD GPU architectures are supported — always consult the [ROCm compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html)
+- Some frameworks (PyTorch, TensorFlow) require separate ROCm-specific wheels — see [Common Commands](#common-commands)
+- ROCm setup is generally less forgiving than CUDA; when in doubt, test `rocm-smi` on the host first
+
+## Security Considerations
+
+`--device=/dev/kfd` and `--device=/dev/dri` grant the container access to the GPU device nodes. This is appropriate for development but should not be used in untrusted or multi-tenant environments.
+
+## References
+
+- [ROCm documentation](https://rocm.docs.amd.com/)
+- [ROCm hardware compatibility matrix](https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html)
+- [ROCm installation guide (Linux)](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/)
+- [ROCm Docker images (hub.docker.com/u/rocm)](https://hub.docker.com/u/rocm)
+- [PyTorch ROCm wheels](https://pytorch.org/get-started/locally/)
+- [TensorFlow ROCm releases](https://github.com/ROCm/tensorflow-upstream/releases)
+
+**Related Overlays:**
+
+- `python` — Python runtime for ML workloads
+- `jupyter` — GPU-accelerated interactive notebooks
+- `cuda` — NVIDIA GPU passthrough (conflicts with `rocm`)

package/overlays/rocm/devcontainer.patch.json

@@ -0,0 +1,4 @@
+{
+    "$schema": "https://raw.githubusercontent.com/devcontainers/spec/main/schemas/devContainer.base.schema.json",
+    "runArgs": ["--device=/dev/kfd", "--device=/dev/dri", "--group-add=video", "--group-add=render"]
+}

package/overlays/rocm/overlay.yml

@@ -0,0 +1,17 @@
+id: rocm
+name: ROCm (AMD GPU)
+description: AMD ROCm libraries and GPU passthrough for containerized ML/inference workloads
+category: dev
+supports: []
+requires: []
+suggests: []
+conflicts:
+    - cuda
+tags:
+    - dev
+    - gpu
+    - rocm
+    - amd
+    - ml
+    - inference
+ports: []

package/overlays/rocm/setup.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# ROCm overlay setup script
+# Checks that rocm-smi / rocminfo is reachable inside the container and prints
+# a helpful message when the host is not configured for AMD GPU passthrough.
+
+set -e
+
+echo "🖥️  Setting up ROCm (AMD GPU) overlay..."
+
+if rocm-smi --showproductname >/dev/null 2>&1; then
+    gpu_name="$(rocm-smi --showproductname 2>/dev/null | grep -i 'card\|gpu\|product' | head -n1)"
+    if [ -z "$gpu_name" ]; then
+        gpu_name="AMD GPU detected"
+    fi
+    echo "✓ rocm-smi found: $gpu_name"
+    echo "✓ ROCm overlay is ready"
+elif rocminfo >/dev/null 2>&1; then
+    gpu_name="$(rocminfo 2>/dev/null | grep 'Marketing Name' | head -n1 | sed 's/.*: *//')"
+    if [ -z "$gpu_name" ]; then
+        gpu_name="AMD GPU detected"
+    fi
+    echo "✓ rocminfo found: $gpu_name"
+    echo "✓ ROCm overlay is ready"
+else
+    echo ""
+    echo "⚠️  Neither rocm-smi nor rocminfo is functioning inside the container."
+    echo ""
+    echo "   AMD GPU passthrough requires the following on the host:"
+    echo "   1. A supported AMD GPU (RDNA 2+ or CDNA — check the compatibility matrix:"
+    echo "      https://rocm.docs.amd.com/en/latest/compatibility/compatibility-matrix.html)"
+    echo "   2. AMD GPU drivers (amdgpu) installed on the host"
+    echo "   3. ROCm runtime installed on the host (or bundled in the container image)"
+    echo "   4. Your user added to the 'render' and 'video' groups:"
+    echo "      sudo usermod -aG render,video \$USER"
+    echo "   5. /dev/kfd and /dev/dri devices accessible in the container"
+    echo ""
+    echo "   This overlay adds the following to the container's runArgs:"
+    echo "     --device=/dev/kfd  --device=/dev/dri"
+    echo "     --group-add=video  --group-add=render"
+    echo "   but it cannot install or replace host drivers."
+    echo ""
+    echo "   Once the host is configured, rebuild the dev container."
+    echo ""
+    echo "ℹ️  ROCm overlay setup complete (rocm-smi not functioning on this host)"
+fi

package/overlays/rocm/verify.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+# Verification script for ROCm overlay
+# Asserts rocm-smi exits 0 (used by the doctor command)
+
+# Don't exit on error - we want to report all failures
+ALL_CHECKS_PASSED=true
+
+echo "🔍 Verifying ROCm (AMD GPU) overlay..."
+echo ""
+
+echo "1️⃣ Checking rocm-smi..."
+if command -v rocm-smi &> /dev/null; then
+    if rocm-smi --showproductname 2>/dev/null; then
+        echo "   ✅ rocm-smi is available and AMD GPU is accessible"
+    elif rocm-smi 2>/dev/null; then
+        echo "   ✅ rocm-smi is available and AMD GPU is accessible"
+    else
+        echo "   ❌ rocm-smi is installed but failed to query GPU information"
+        echo ""
+        echo "   Possible causes:"
+        echo "   - AMD GPU driver (amdgpu) is not loaded on the host"
+        echo "   - /dev/kfd or /dev/dri is not accessible in this container"
+        echo "   - Container user is not in the 'render' or 'video' group"
+        echo "   - ROCm version mismatch between container image and host kernel"
+        echo ""
+        echo "   Resolve the above issues and retry the ROCm overlay verification."
+        ALL_CHECKS_PASSED=false
+    fi
+else
+    echo "   ❌ rocm-smi not found"
+    echo ""
+    echo "   Ensure the host has:"
+    echo "   - AMD GPU drivers (amdgpu) installed"
+    echo "   - ROCm runtime installed on the host or bundled in the container image"
+    echo "   - /dev/kfd and /dev/dri accessible in the container"
+    echo "   - Container user in the 'render' and 'video' groups"
+    ALL_CHECKS_PASSED=false
+fi
+
+echo ""
+if [ "$ALL_CHECKS_PASSED" = true ]; then
+    echo "✅ ROCm overlay verification complete"
+    exit 0
+else
+    echo "❌ ROCm overlay verification failed"
+    exit 1
+fi

package/overlays/rust/setup.sh

@@ -3,34 +3,27 @@
 
 set -e
 
+# Source shared setup utilities
+# shellcheck source=setup-utils.sh
+source "$(dirname "${BASH_SOURCE[0]}")/setup-utils.sh"
+export CARGO_TERM_COLOR=never
+
 echo "🔧 Setting up Rust development environment..."
 
 # Install common Rust components and tools
-echo "📦 Installing Rust components..."
-
-# rustfmt (Code formatter)
-rustup component add rustfmt || echo "⚠️ rustfmt already installed"
-
-# clippy (Linter)
-rustup component add clippy || echo "⚠️ clippy already installed"
-
-# rust-src (Source code for standard library)
-rustup component add rust-src || echo "⚠️ rust-src already installed"
+run_spinner "rustfmt component"    rustup component add rustfmt
+run_spinner "clippy component"     rustup component add clippy
+run_spinner "rust-src component"   rustup component add rust-src
 
 # Install common cargo tools
 echo "📦 Installing cargo tools..."
-
-# cargo-watch (Auto-rebuild on file changes)
-cargo install cargo-watch || echo "⚠️ cargo-watch already installed"
-
-# cargo-edit (Manage dependencies from CLI)
-cargo install cargo-edit || echo "⚠️ cargo-edit already installed"
+run_spinner "cargo-watch" cargo install --quiet cargo-watch
+run_spinner "cargo-edit"  cargo install --quiet cargo-edit
 
 # Install project dependencies if Cargo.toml exists
 if [ -f "Cargo.toml" ]; then
     echo "📦 Rust project detected, building dependencies..."
-    cargo fetch || echo "⚠️ cargo fetch failed"
-    cargo build || echo "⚠️ cargo build failed or skipped"
+    run_spinner "cargo fetch" cargo fetch
 fi
 
 echo "✓ Rust setup complete"

package/overlays/skaffold/README.md

@@ -0,0 +1,256 @@
+# Skaffold Overlay
+
+Installs [Skaffold](https://skaffold.dev), Google's command-line tool for continuous development on Kubernetes — handling the build, push, and deploy lifecycle automatically as source files change.
+
+> **Note:** This overlay conflicts with `tilt` because both tools serve the same "continuous Kubernetes development" role. Choose `skaffold` for a configuration-file-driven, CI-friendly pipeline, or `tilt` for a more interactive, UI-driven workflow.
+
+## Features
+
+- **`skaffold dev`** — Watch source files and automatically rebuild, push, and redeploy on changes
+- **`skaffold run`** — One-shot build and deploy pipeline for CI/CD integration
+- **Declarative config** — `skaffold.yaml` defines the entire build-test-deploy pipeline as code
+- **Multiple builders** — Docker, Buildpacks, Bazel, Jib (Maven/Gradle), and more
+- **Multiple deployers** — `kubectl`, Helm, Kustomize, and Cloud Run
+- **Test integration** — Container Structure Tests and custom test steps built in
+- **Profile support** — Swap out configs per environment (dev, staging, prod)
+
+## How It Works
+
+Skaffold is installed as a static binary in the devcontainer during `setup.sh`. It orchestrates the build-push-deploy cycle against whichever Kubernetes cluster is active in your `kubeconfig` (e.g. a k3d or kind cluster).
+
+**Suggested overlays:**
+
+- `kubectl-helm` — Kubernetes CLI and Helm used as Skaffold deployers
+- `kind` — Full-conformance local Kubernetes cluster
+- `k3d` — Lightweight local Kubernetes cluster
+
+## Installation
+
+Skaffold is installed automatically during devcontainer creation via `setup.sh`:
+
+- Downloads the Skaffold binary for your architecture (amd64/arm64)
+- Installs to `/usr/local/bin/skaffold`
+- Verifies the installation
+
+## Common Commands
+
+### Development Workflow
+
+```bash
+# Continuous development — rebuild and redeploy on file changes
+skaffold dev
+
+# One-shot build + deploy
+skaffold run
+
+# Delete all resources deployed by Skaffold
+skaffold delete
+
+# Preview what Skaffold would deploy (dry run)
+skaffold render
+```
+
+### Build and Test
+
+```bash
+# Build images only (no deploy)
+skaffold build
+
+# Run tests only
+skaffold test
+
+# Build and push to a registry
+skaffold build --push
+```
+
+### Profiles
+
+```bash
+# Use a specific profile
+skaffold dev --profile staging
+
+# Combine multiple profiles
+skaffold run --profile prod --profile feature-flag
+```
+
+### Debugging
+
+```bash
+# Enable port-forwarding for services
+skaffold dev --port-forward
+
+# Verbose output
+skaffold dev -v debug
+
+# Show rendered manifests
+skaffold render --output manifests.yaml
+```
+
+## Configuration
+
+### skaffold.yaml
+
+Create a `skaffold.yaml` in your project root:
+
+```yaml
+apiVersion: skaffold/v4beta11
+kind: Config
+metadata:
+    name: my-app
+build:
+    artifacts:
+        - image: my-app
+          docker:
+              dockerfile: Dockerfile
+deploy:
+    kubectl:
+        manifests:
+            - k8s/*.yaml
+test:
+    - image: my-app
+      structureTests:
+          - ./structure-test.yaml
+profiles:
+    - name: prod
+      deploy:
+          helm:
+              releases:
+                  - name: my-app
+                    chartPath: helm/my-app
+```
+
+### Common Builders
+
+```yaml
+# Docker (default)
+build:
+  artifacts:
+    - image: my-app
+      docker:
+        dockerfile: Dockerfile
+
+# Buildpacks (no Dockerfile needed)
+build:
+  artifacts:
+    - image: my-app
+      buildpacks:
+        builder: gcr.io/buildpacks/builder:v1
+
+# Jib (Java/Maven)
+build:
+  artifacts:
+    - image: my-app
+      jib:
+        project: my-module
+```
+
+### Common Deployers
+
+```yaml
+# kubectl (plain manifests)
+deploy:
+  kubectl:
+    manifests:
+      - k8s/**/*.yaml
+
+# Helm
+deploy:
+  helm:
+    releases:
+      - name: my-app
+        chartPath: helm/my-app
+        valuesFiles:
+          - helm/values.yaml
+
+# Kustomize
+deploy:
+  kustomize:
+    paths:
+      - k8s/overlays/dev
+```
+
+## Benefits vs Tilt
+
+| Feature               | Skaffold (this overlay)           | Tilt                             |
+| --------------------- | --------------------------------- | -------------------------------- |
+| **Primary interface** | ✅ CLI + skaffold.yaml config     | Interactive UI (port 10350)      |
+| **CI/CD suitability** | ✅ First-class CI support         | ⚠️ UI-oriented, less CI-friendly |
+| **Config format**     | ✅ Declarative YAML               | Starlark/Python (Tiltfile)       |
+| **Build systems**     | ✅ Docker, Buildpacks, Jib, Bazel | Docker, Buildpacks               |
+| **Deploy targets**    | ✅ kubectl, Helm, Kustomize, Run  | kubectl, Helm                    |
+| **Learning curve**    | Lower (declarative YAML)          | Programmable (more flexible)     |
+| **Debugging support** | ✅ Built-in debug mode            | ✅ Built-in live updates         |
+
+**Choose Skaffold when:**
+
+- You want a declarative, portable, config-file-driven pipeline
+- CI/CD integration is a priority
+- You need support for multiple build systems (Jib, Buildpacks, Bazel)
+
+**Choose Tilt when:**
+
+- You prefer an interactive browser UI for development
+- You want fine-grained control over the update pipeline via a Tiltfile
+
+## Use Cases
+
+- **Inner loop acceleration** — Rebuild and redeploy Kubernetes workloads on save, without manual `docker build && kubectl apply`
+- **Multi-service applications** — Manage build and deploy of multiple microservices from a single `skaffold.yaml`
+- **CI/CD integration** — Use `skaffold run` in pipelines for consistent build-test-deploy flows
+- **Helm chart development** — Iterate on Helm charts with live cluster feedback
+- **GitOps preview environments** — Render manifests for inspection or PR previews
+
+**Integrates well with:**
+
+- `kubectl-helm` — Used by Skaffold's deploy pipeline
+- `k3d` — Lightweight local cluster for development
+- `kind` — Full-conformance local cluster for testing
+
+## Troubleshooting
+
+### No kubeconfig Found
+
+```bash
+# Ensure kubectl is configured (kubectl-helm overlay must be selected)
+kubectl cluster-info
+
+# If using k3d, merge cluster config
+k3d kubeconfig merge dev --kubeconfig-merge-default
+
+# If using kind, kubeconfig is set automatically on cluster creation
+kind create cluster --name dev
+```
+
+### Build Failures
+
+```bash
+# Check Docker is accessible
+docker info
+
+# Run with verbose logging
+skaffold dev -v debug
+```
+
+### Deploy Failures
+
+```bash
+# View Kubernetes events
+kubectl get events --sort-by='.lastTimestamp'
+
+# Tail pod logs
+kubectl logs -f deployment/my-app
+```
+
+## References
+
+- [Skaffold Documentation](https://skaffold.dev/docs/)
+- [Skaffold GitHub](https://github.com/GoogleContainerTools/skaffold)
+- [skaffold.yaml Reference](https://skaffold.dev/docs/references/yaml/)
+- [Kubernetes Documentation](https://kubernetes.io/docs/)
+
+**Related Overlays:**
+
+- [`kubectl-helm`](../kubectl-helm/README.md) — Kubernetes CLI and Helm (recommended with Skaffold)
+- [`kind`](../kind/README.md) — Full-conformance local Kubernetes cluster
+- [`k3d`](../k3d/README.md) — Lightweight local Kubernetes cluster
+- [`tilt`](../tilt/README.md) — Alternative interactive Kubernetes development tool (conflicts)

package/overlays/skaffold/devcontainer.patch.json

@@ -0,0 +1,9 @@
+{
+    "$schema": "https://raw.githubusercontent.com/devcontainers/spec/main/schemas/devContainer.base.schema.json",
+    "features": {
+        "./features/cross-distro-packages": {
+            "apt": "curl",
+            "apk": "curl"
+        }
+    }
+}