Commit de57e1bde8aa

@@ -0,0 +1,979 @@
+# Build Workflow
+
+Build container images with Docker/Podman, supporting multi-architecture builds and optimization techniques.
+
+## Quick Start
+
+**Detect runtime:**
+```bash
+# Auto-detect (prefers Podman)
+../tools/DetectRuntime.sh
+
+# Specify runtime
+../tools/DetectRuntime.sh --runtime docker
+../tools/DetectRuntime.sh --runtime podman
+```
+
+**Basic build:**
+```bash
+docker build -t myapp:latest .
+podman build -t myapp:latest .
+```
+
+**Multi-architecture:**
+```bash
+# Docker buildx
+docker buildx build --platform linux/amd64,linux/arm64 -t myapp:latest --push .
+
+# Podman manifest
+podman build --platform linux/amd64 -t myapp:amd64 .
+podman build --platform linux/arm64 -t myapp:arm64 .
+podman manifest create myapp:latest
+podman manifest add myapp:latest myapp:amd64
+podman manifest add myapp:latest myapp:arm64
+```
+
+**Optimize with multi-stage:**
+```dockerfile
+FROM golang:1.21-alpine AS builder
+WORKDIR /app
+COPY . .
+RUN go build -o myapp
+
+FROM alpine:3.19
+COPY --from=builder /app/myapp /
+CMD ["/myapp"]
+```
+
+## Runtime Detection
+
+### Detect Container Runtime
+
+**Auto-detect:**
+```bash
+../tools/DetectRuntime.sh
+# Prefers Podman, falls back to Docker
+```
+
+**Specify runtime:**
+```bash
+../tools/DetectRuntime.sh --runtime docker
+../tools/DetectRuntime.sh --runtime podman
+```
+
+**Check available builders:**
+```bash
+# Docker buildx
+docker buildx ls
+
+# Podman buildah
+buildah version
+```
+
+### Process Integration
+
+1. **Parse user prompt** for explicit runtime mention
+2. **Run DetectRuntime.sh** with appropriate flags
+3. **Identify build tools** (buildx, buildah)
+4. **Use detected runtime** for all commands
+
+## Building Images
+
+### Basic Build Process
+
+**Docker:**
+```bash
+# Basic build
+docker build -t myapp:latest .
+
+# With build arguments
+docker build --build-arg VERSION=1.0 -t myapp:1.0 .
+
+# With specific target
+docker build --target production -t myapp:prod .
+
+# Build without cache
+docker build --no-cache -t myapp:latest .
+
+# Build with custom context
+docker build -t myapp:latest -f path/to/Dockerfile context/
+```
+
+**Podman:**
+```bash
+# Basic build
+podman build -t myapp:latest .
+
+# With build arguments
+podman build --build-arg VERSION=1.0 -t myapp:1.0 .
+
+# With specific target
+podman build --target production -t myapp:prod .
+
+# Build without cache
+podman build --no-cache -t myapp:latest .
+
+# Build with custom context
+podman build -t myapp:latest -f path/to/Dockerfile context/
+```
+
+### Build Arguments and Tags
+
+**Multiple tags:**
+```bash
+docker build -t myapp:latest -t myapp:1.0 -t myregistry/myapp:1.0 .
+podman build -t myapp:latest -t myapp:1.0 -t myregistry/myapp:1.0 .
+```
+
+**Build arguments:**
+```dockerfile
+ARG VERSION=1.0
+ARG BUILD_DATE
+ENV APP_VERSION=${VERSION}
+
+RUN echo "Building version ${VERSION} on ${BUILD_DATE}"
+```
+
+```bash
+docker build --build-arg VERSION=2.0 --build-arg BUILD_DATE=$(date -u +%Y-%m-%d) .
+podman build --build-arg VERSION=2.0 --build-arg BUILD_DATE=$(date -u +%Y-%m-%d) .
+```
+
+### Dockerfile Best Practices
+
+**Base image selection:**
+```dockerfile
+# Use specific tags, never :latest
+FROM alpine:3.19
+FROM python:3.11-slim
+FROM node:20-alpine
+
+# For static binaries
+FROM scratch
+FROM gcr.io/distroless/static-debian12
+```
+
+**Layer ordering (cache optimization):**
+```dockerfile
+# Good: dependencies cached separately
+FROM node:20-alpine
+WORKDIR /app
+# Copy dependency files first (changes less frequently)
+COPY package*.json ./
+RUN npm ci
+# Copy code last (changes most frequently)
+COPY . .
+RUN npm run build
+```
+
+**Non-root user:**
+```dockerfile
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+WORKDIR /app
+COPY --chown=appuser:appgroup . .
+```
+
+**Minimal layers:**
+```dockerfile
+# Bad: creates multiple layers
+RUN apt-get update
+RUN apt-get install -y curl
+RUN apt-get clean
+
+# Good: single layer with cleanup
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl && \
+    rm -rf /var/lib/apt/lists/*
+```
+
+### Using .dockerignore
+
+Create `.dockerignore` to exclude unnecessary files:
+
+```dockerignore
+# Version control
+.git
+.gitignore
+
+# Dependencies
+node_modules
+vendor
+
+# Build artifacts
+dist
+build
+*.o
+
+# Documentation
+*.md
+docs/
+
+# Tests
+*_test.go
+test/
+__tests__
+
+# CI/CD
+.github
+.gitlab-ci.yml
+
+# Development
+.env
+.vscode
+*.log
+
+# OS files
+.DS_Store
+```
+
+## Multi-Architecture Builds
+
+### Docker with Buildx
+
+**Setup QEMU:**
+```bash
+docker run --privileged --rm tonistiigi/binfmt --install all
+```
+
+**Create builder:**
+```bash
+docker buildx create --name multiarch --driver docker-container --use
+docker buildx inspect --bootstrap
+```
+
+**List available platforms:**
+```bash
+docker buildx inspect --bootstrap | grep Platforms
+```
+
+**Build multi-arch image:**
+```bash
+# Build and push
+docker buildx build \
+  --platform linux/amd64,linux/arm64,linux/arm/v7 \
+  -t myregistry/myapp:latest \
+  --push \
+  .
+
+# Build single platform locally
+docker buildx build \
+  --platform linux/arm64 \
+  -t myapp:arm64 \
+  --load \
+  .
+```
+
+**Build with cache:**
+```bash
+docker buildx build \
+  --platform linux/amd64,linux/arm64 \
+  --cache-from type=registry,ref=myregistry/myapp:buildcache \
+  --cache-to type=registry,ref=myregistry/myapp:buildcache,mode=max \
+  -t myregistry/myapp:latest \
+  --push \
+  .
+```
+
+**Manage builders:**
+```bash
+# List builders
+docker buildx ls
+
+# Remove builder
+docker buildx rm multiarch
+
+# Use default builder
+docker buildx use default
+```
+
+### Podman with Buildah
+
+**Install QEMU:**
+```bash
+# On host system
+sudo dnf install qemu-user-static  # Fedora/RHEL
+sudo apt install qemu-user-static  # Debian/Ubuntu
+
+# Or with Podman
+podman run --rm --privileged multiarch/qemu-user-static --reset -p yes
+```
+
+**Build for specific platform:**
+```bash
+podman build --platform linux/arm64 -t myapp:arm64 .
+```
+
+**Build multi-arch with manifest:**
+```bash
+# Build for each platform
+podman build --platform linux/amd64 -t myapp:amd64 .
+podman build --platform linux/arm64 -t myapp:arm64 .
+podman build --platform linux/arm/v7 -t myapp:armv7 .
+
+# Create manifest
+podman manifest create myapp:latest
+
+# Add images to manifest
+podman manifest add myapp:latest myapp:amd64
+podman manifest add myapp:latest myapp:arm64
+podman manifest add myapp:latest myapp:armv7
+
+# Push manifest
+podman manifest push myapp:latest docker://myregistry/myapp:latest
+```
+
+**Using buildah directly:**
+```bash
+buildah bud --arch arm64 -t myapp:arm64 .
+buildah bud --arch amd64 -t myapp:amd64 .
+```
+
+### Platform Targeting
+
+**Common platforms:**
+
+| Platform | Description | Use Case |
+|----------|-------------|----------|
+| linux/amd64 | 64-bit x86 | Standard servers, desktops |
+| linux/arm64 | 64-bit ARM | Raspberry Pi 4, Apple Silicon, AWS Graviton |
+| linux/arm/v7 | 32-bit ARM v7 | Raspberry Pi 2/3 |
+| linux/arm/v6 | 32-bit ARM v6 | Raspberry Pi Zero/1 |
+| linux/386 | 32-bit x86 | Legacy systems |
+
+**Platform-aware Dockerfile:**
+```dockerfile
+FROM --platform=$BUILDPLATFORM golang:1.21-alpine AS builder
+ARG TARGETPLATFORM
+ARG BUILDPLATFORM
+ARG TARGETOS
+ARG TARGETARCH
+
+WORKDIR /app
+COPY . .
+
+# Build for target platform
+RUN GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o app .
+
+FROM --platform=$TARGETPLATFORM alpine:latest
+COPY --from=builder /app/app /app
+ENTRYPOINT ["/app"]
+```
+
+**Conditional platform logic:**
+```dockerfile
+ARG TARGETARCH
+
+RUN if [ "$TARGETARCH" = "arm64" ]; then \
+      echo "Installing ARM64 packages"; \
+    elif [ "$TARGETARCH" = "amd64" ]; then \
+      echo "Installing AMD64 packages"; \
+    fi
+```
+
+### Verify Multi-Arch Images
+
+**Inspect manifest (Docker):**
+```bash
+docker buildx imagetools inspect myregistry/myapp:latest
+docker manifest inspect myregistry/myapp:latest
+```
+
+**Inspect manifest (Podman):**
+```bash
+podman manifest inspect myapp:latest
+skopeo inspect docker://myregistry/myapp:latest
+```
+
+**Test platform-specific images:**
+```bash
+# Force ARM64 on AMD64 host
+docker run --platform linux/arm64 myregistry/myapp:latest
+
+# Verify architecture
+docker run --rm myregistry/myapp:latest uname -m
+# Output: x86_64, aarch64, armv7l, etc.
+```
+
+## Image Optimization
+
+### Multi-Stage Builds
+
+**Basic pattern:**
+```dockerfile
+# Build stage
+FROM golang:1.21-alpine AS builder
+WORKDIR /app
+COPY go.* ./
+RUN go mod download
+COPY . .
+RUN go build -o myapp
+
+# Runtime stage
+FROM alpine:3.19
+WORKDIR /app
+COPY --from=builder /app/myapp .
+CMD ["/app/myapp"]
+# Result: ~20 MB vs ~1 GB
+```
+
+**Multiple build stages:**
+```dockerfile
+# Stage 1: Dependencies
+FROM node:20-alpine AS deps
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+
+# Stage 2: Build
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+# Stage 3: Runtime
+FROM node:20-alpine
+WORKDIR /app
+ENV NODE_ENV=production
+COPY --from=deps /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+CMD ["node", "dist/index.js"]
+```
+
+### Base Image Selection
+
+**Size comparison:**
+```dockerfile
+# Large (1.1 GB)
+FROM ubuntu:latest
+
+# Medium (130 MB)
+FROM ubuntu:22.04
+
+# Small (77 MB)
+FROM debian:bookworm-slim
+
+# Smaller (7 MB)
+FROM alpine:3.19
+
+# Smallest (< 2 MB)
+FROM scratch
+FROM gcr.io/distroless/static-debian12
+```
+
+**Language-specific minimal images:**
+```dockerfile
+# Python
+FROM python:3.11-slim    # 50 MB vs 900 MB
+FROM python:3.11-alpine  # 45 MB
+
+# Node.js
+FROM node:20-slim        # 240 MB vs 1 GB
+FROM node:20-alpine      # 180 MB
+
+# Go
+FROM golang:1.21-alpine  # Build stage
+FROM scratch             # Runtime (static binary)
+```
+
+### Layer Optimization
+
+**Combine RUN commands:**
+```dockerfile
+# Bad: creates 4 layers
+RUN apt-get update
+RUN apt-get install -y curl
+RUN apt-get install -y git
+RUN apt-get clean
+
+# Good: single layer
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        curl \
+        git && \
+    rm -rf /var/lib/apt/lists/*
+```
+
+**Clean up in same layer:**
+```dockerfile
+# Bad: file remains in layer
+RUN wget https://example.com/large-file.tar.gz
+RUN tar -xzf large-file.tar.gz
+RUN rm large-file.tar.gz
+
+# Good: cleanup in same layer
+RUN wget https://example.com/large-file.tar.gz && \
+    tar -xzf large-file.tar.gz && \
+    rm large-file.tar.gz
+```
+
+### Size Reduction Techniques
+
+**Remove package manager cache:**
+```dockerfile
+# APT (Debian/Ubuntu)
+RUN apt-get update && \
+    apt-get install -y package && \
+    rm -rf /var/lib/apt/lists/*
+
+# APK (Alpine)
+RUN apk add --no-cache package
+
+# DNF (Fedora/RHEL)
+RUN dnf install -y package && \
+    dnf clean all
+
+# npm
+RUN npm ci --only=production && \
+    npm cache clean --force
+
+# pip
+RUN pip install --no-cache-dir -r requirements.txt
+```
+
+**Minimize installed packages:**
+```dockerfile
+# Bad: installs many unnecessary packages
+RUN apt-get update && \
+    apt-get install -y build-essential
+
+# Good: minimal installation
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        gcc \
+        make && \
+    rm -rf /var/lib/apt/lists/*
+```
+
+**Remove build dependencies:**
+```dockerfile
+RUN apk add --no-cache --virtual .build-deps \
+        gcc \
+        musl-dev \
+        postgresql-dev && \
+    pip install psycopg2 && \
+    apk del .build-deps
+```
+
+### Static Binaries
+
+**Go static binary:**
+```dockerfile
+FROM golang:1.21-alpine AS builder
+WORKDIR /app
+COPY . .
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o myapp .
+
+FROM scratch
+COPY --from=builder /app/myapp /myapp
+ENTRYPOINT ["/myapp"]
+# Result: ~10 MB (just the binary)
+```
+
+**Rust static binary:**
+```dockerfile
+FROM rust:1.75-alpine AS builder
+WORKDIR /app
+COPY . .
+RUN cargo build --release
+
+FROM scratch
+COPY --from=builder /app/target/release/myapp /myapp
+ENTRYPOINT ["/myapp"]
+```
+
+### Distroless Images
+
+**Language-specific distroless:**
+```dockerfile
+# Java
+FROM gcr.io/distroless/java17-debian12
+COPY target/app.jar /app.jar
+CMD ["app.jar"]
+
+# Python
+FROM gcr.io/distroless/python3-debian12
+COPY --from=builder /app /app
+WORKDIR /app
+CMD ["app.py"]
+
+# Node.js
+FROM gcr.io/distroless/nodejs20-debian12
+COPY --from=builder /app /app
+WORKDIR /app
+CMD ["index.js"]
+
+# Static binaries
+FROM gcr.io/distroless/static-debian12
+COPY --from=builder /app/myapp /
+CMD ["/myapp"]
+```
+
+### Build Cache Strategies
+
+**BuildKit cache mounts:**
+```dockerfile
+# syntax=docker/dockerfile:1
+FROM golang:1.21-alpine
+WORKDIR /app
+COPY go.* ./
+RUN --mount=type=cache,target=/go/pkg/mod \
+    go mod download
+COPY . .
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    go build -o myapp
+```
+
+**Remote cache:**
+```bash
+docker buildx build \
+  --cache-from type=registry,ref=myregistry/myapp:buildcache \
+  --cache-to type=registry,ref=myregistry/myapp:buildcache,mode=max \
+  -t myapp:latest .
+```
+
+### Optimization Examples
+
+**Python Flask app (500 MB → 50 MB):**
+```dockerfile
+# Before
+FROM python:3.11
+WORKDIR /app
+COPY . .
+RUN pip install -r requirements.txt
+CMD ["python", "app.py"]
+
+# After
+FROM python:3.11-slim AS builder
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --user --no-cache-dir -r requirements.txt
+
+FROM python:3.11-slim
+WORKDIR /app
+COPY --from=builder /root/.local /root/.local
+COPY app.py .
+ENV PATH=/root/.local/bin:$PATH
+CMD ["python", "app.py"]
+```
+
+**Node.js React app (1.2 GB → 100 MB):**
+```dockerfile
+# Before
+FROM node:20
+WORKDIR /app
+COPY . .
+RUN npm install
+RUN npm run build
+CMD ["npm", "start"]
+
+# After
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM nginx:alpine
+COPY --from=builder /app/build /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+```
+
+**Go microservice (800 MB → 10 MB):**
+```dockerfile
+# Before
+FROM golang:1.21
+WORKDIR /app
+COPY . .
+RUN go build -o myapp
+CMD ["/app/myapp"]
+
+# After
+FROM golang:1.21-alpine AS builder
+WORKDIR /app
+COPY go.* ./
+RUN go mod download
+COPY . .
+RUN CGO_ENABLED=0 go build -ldflags="-w -s" -o myapp
+
+FROM scratch
+COPY --from=builder /app/myapp /
+CMD ["/myapp"]
+```
+
+### Analysis Tools
+
+**Check image size:**
+```bash
+docker images myapp
+podman images myapp
+```
+
+**View image history:**
+```bash
+docker history myapp:latest
+docker history --no-trunc myapp:latest  # Full commands
+
+podman history myapp:latest
+```
+
+**Analyze with dive:**
+```bash
+# Install dive
+brew install dive
+
+# Analyze image
+dive myapp:latest
+```
+
+**Find large layers:**
+```bash
+docker history myapp:latest --format "{{.Size}}\t{{.CreatedBy}}" | sort -h
+```
+
+## Best Practices
+
+### Dockerfile Quality Checklist
+
+- [ ] Use specific base image tags (not `latest`)
+- [ ] Minimize number of layers
+- [ ] Use multi-stage builds where appropriate
+- [ ] Run as non-root user
+- [ ] Have .dockerignore file
+- [ ] No secrets embedded
+- [ ] Proper layer ordering (least to most frequently changed)
+- [ ] Install only required packages
+- [ ] Clean up in same layer
+- [ ] Use minimal base images
+
+### Build Optimization Checklist
+
+- [ ] Leverage build cache effectively
+- [ ] Combine RUN commands where appropriate
+- [ ] Remove package manager cache
+- [ ] Use `--no-install-recommends` (apt)
+- [ ] Use `--no-cache` (apk)
+- [ ] Remove build dependencies after use
+- [ ] Exclude development files via .dockerignore
+- [ ] Order layers by change frequency
+
+### Security Best Practices
+
+- [ ] Use specific version tags
+- [ ] Update packages during build
+- [ ] Run as non-root user
+- [ ] Don't include secrets in image
+- [ ] Scan for vulnerabilities
+- [ ] Use minimal base images (smaller attack surface)
+- [ ] Consider distroless for production
+
+### Multi-Arch Best Practices
+
+1. **Use multi-stage builds** for smaller final images
+2. **Leverage build cache** with remote cache
+3. **Test on actual hardware** when possible
+4. **Use QEMU** for cross-platform testing
+5. **Build platform-specific optimizations** with TARGETARCH
+6. **Verify critical functionality** on each platform
+
+### CI/CD Integration
+
+**GitHub Actions:**
+```yaml
+- name: Set up QEMU
+  uses: docker/setup-qemu-action@v2
+
+- name: Set up Docker Buildx
+  uses: docker/setup-buildx-action@v2
+
+- name: Build and push
+  uses: docker/build-push-action@v4
+  with:
+    platforms: linux/amd64,linux/arm64
+    push: true
+    tags: myregistry/myapp:latest
+```
+
+**GitLab CI:**
+```yaml
+build-multiarch:
+  image: docker:latest
+  services:
+    - docker:dind
+  before_script:
+    - docker buildx create --use
+    - docker buildx install
+  script:
+    - docker buildx build
+      --platform linux/amd64,linux/arm64
+      -t myregistry/myapp:latest
+      --push .
+```
+
+## Troubleshooting
+
+### Build Failures
+
+**Issue:** Build fails with permission denied
+
+**Docker:**
+- User not in docker group: `sudo usermod -aG docker $USER`
+- Daemon not running: `sudo systemctl start docker`
+
+**Podman:**
+- Check rootless permissions: `podman system migrate`
+- Check user namespace: `cat /etc/subuid /etc/subgid`
+
+**Issue:** Build cache not working
+- Check layer ordering (copy dependencies before code)
+- Verify .dockerignore excludes frequently changing files
+- Use `--no-cache` to force rebuild if needed
+
+**Issue:** Large image size
+- Review Dockerfile layer ordering
+- Implement multi-stage builds
+- Use smaller base images
+- Clean up in same layer
+
+### Multi-Arch Issues
+
+**Issue:** Build very slow for non-native platforms
+- **Cause:** QEMU emulation overhead
+- **Solution:** Use native builders or accept slower builds
+
+**Issue:** Build fails with "exec format error"
+- **Cause:** QEMU not configured
+- **Solution:** `docker run --privileged --rm tonistiigi/binfmt --install all`
+
+**Issue:** Cannot load multi-platform image locally
+- **Cause:** Local load only supports single platform
+- **Solution:** Use `--platform` to specify one, or push to registry
+
+**Issue:** Different behavior on different platforms
+- **Cause:** Platform-specific dependencies
+- **Solution:** Review Dockerfile for cross-platform compatibility
+
+**Issue:** Manifest push fails
+- **Cause:** Authentication or registry doesn't support manifests
+- **Solution:** Verify registry supports manifest lists, check credentials
+
+### Optimization Issues
+
+**Issue:** Removing files doesn't reduce image size
+- **Cause:** Files removed in different layer
+- **Solution:** Clean up in same RUN command
+
+**Issue:** Dependencies installed but not needed
+- **Cause:** Installing dev dependencies in production
+- **Solution:** Use `npm ci --only=production`, `pip install --no-cache-dir`
+
+**Issue:** .dockerignore not working
+- **Cause:** File in wrong location or syntax error
+- **Solution:** Place in build context root, verify syntax
+
+## Output Examples
+
+**After successful build:**
+```
+✓ Image built successfully
+  Runtime: docker
+  Image: myapp:latest
+  Size: 125 MB
+  Build time: 45s
+
+Next steps:
+  - Run the image: docker run myapp:latest
+  - Scan for vulnerabilities: [trigger SecurityScan]
+  - Push to registry: [trigger RegistryManage]
+```
+
+**After multi-arch build:**
+```
+✓ Multi-architecture image built successfully
+  Runtime: docker buildx
+  Image: myregistry/myapp:latest
+
+  Platforms built:
+    - linux/amd64 (152 MB)
+    - linux/arm64 (148 MB)
+    - linux/arm/v7 (145 MB)
+
+  Total build time: 8m 32s
+
+  Verify:
+    docker buildx imagetools inspect myregistry/myapp:latest
+
+  Test platforms:
+    docker run --platform linux/arm64 myregistry/myapp:latest
+```
+
+**After optimization:**
+```
+✓ Image optimized successfully
+  Image: myapp:latest
+
+  Size reduction:
+    Before: 850 MB
+    After: 45 MB
+    Savings: 805 MB (94.7%)
+
+  Layers:
+    Before: 15 layers
+    After: 5 layers
+
+  Optimizations applied:
+    - Changed base image: python:3.11 → python:3.11-slim
+    - Added multi-stage build
+    - Combined RUN commands (4 → 1)
+    - Removed package cache
+    - Added .dockerignore (excluded 250 MB)
+
+  Build time:
+    Before: 3m 45s
+    After: 1m 20s (faster caching)
+```
+
+## Quick Reference
+
+**Basic builds:**
+```bash
+docker build -t myapp:latest .
+podman build -t myapp:latest .
+```
+
+**Multi-architecture:**
+```bash
+# Docker
+docker buildx build --platform linux/amd64,linux/arm64 -t myapp:latest --push .
+
+# Podman
+podman build --platform linux/amd64 -t myapp:amd64 .
+podman manifest create myapp:latest
+podman manifest add myapp:latest myapp:amd64
+```
+
+**Analyze image:**
+```bash
+docker history myapp:latest
+dive myapp:latest
+```
+
+**Multi-stage pattern:**
+```dockerfile
+FROM golang:1.21-alpine AS builder
+# ... build ...
+FROM alpine:3.19
+COPY --from=builder /app/binary /
+```
+
+**Optimize layers:**
+```dockerfile
+RUN apk add --no-cache package && \
+    # work && \
+    cleanup
+```

@@ -1,113 +0,0 @@
-# BuildImage Workflow
-
-Build container images with best practices for Docker or Podman.
-
-## Process
-
-1. **Detect Runtime**
-   - Parse user prompt for explicit runtime mention ("use Docker", "with Podman")
-   - If explicit runtime mentioned: Use `DetectRuntime.sh --runtime <docker|podman>`
-   - If auto-detect: Run `DetectRuntime.sh` (prefers Podman, falls back to Docker)
-   - Identify available build tools (buildx, buildah)
-
-2. **Analyze Context**
-   - Check for existing Dockerfile
-   - If no Dockerfile exists, ask user if they want to create one
-   - Review Dockerfile for best practices
-
-3. **Determine Build Strategy**
-   - Single-stage vs multi-stage build
-   - Build arguments needed
-   - Target platform(s)
-   - Tags to apply
-
-4. **Build Image**
-   - Use detected runtime (docker/podman)
-   - Apply appropriate tags
-   - Show build progress
-   - Handle build errors
-
-5. **Post-Build Actions**
-   - Display image size
-   - Show image layers (if requested)
-   - Suggest optimizations if image is large
-   - Offer to run security scan
-
-## Best Practices to Check
-
-### Dockerfile Quality
-- [ ] Uses specific base image tags (not `latest`)
-- [ ] Minimizes number of layers
-- [ ] Uses multi-stage builds where appropriate
-- [ ] Runs as non-root user
-- [ ] Has .dockerignore file
-- [ ] No secrets embedded
-- [ ] Proper layer ordering (least to most frequently changed)
-
-### Build Optimization
-- [ ] Leverages build cache effectively
-- [ ] Combines RUN commands where appropriate
-- [ ] Cleans up in the same layer
-- [ ] Uses minimal base images
-
-## Example Commands
-
-### Docker
-```bash
-# Basic build
-docker build -t myapp:latest .
-
-# Build with arguments
-docker build --build-arg VERSION=1.0 -t myapp:1.0 .
-
-# Build with specific target
-docker build --target production -t myapp:prod .
-
-# Build with no cache
-docker build --no-cache -t myapp:latest .
-```
-
-### Podman
-```bash
-# Basic build
-podman build -t myapp:latest .
-
-# Build with arguments
-podman build --build-arg VERSION=1.0 -t myapp:1.0 .
-
-# Build with specific target
-podman build --target production -t myapp:prod .
-
-# Build with no cache
-podman build --no-cache -t myapp:latest .
-```
-
-## Common Issues
-
-**Issue**: Build fails with permission denied
-- **Docker**: User not in docker group or daemon not running
-- **Podman**: Check rootless permissions, may need `podman system migrate`
-
-**Issue**: Large image size
-- Suggest multi-stage builds
-- Recommend OptimizeImage workflow
-
-**Issue**: Build cache not working
-- Check layer ordering
-- Verify .dockerignore excludes changing files
-
-## Output Format
-
-After successful build:
-```
-✓ Image built successfully
-  Runtime: docker/podman
-  Image: myapp:latest
-  Size: 125 MB
-  Build time: 45s
-
-Next steps:
-  - Run the image: docker run myapp:latest
-  - Scan for vulnerabilities: [trigger SecurityScan]
-  - Push to registry: [trigger RegistryManage]
-```

@@ -1,416 +0,0 @@
-# BuildMultiArch Workflow
-
-Build container images for multiple CPU architectures (AMD64, ARM64, ARM/v7, etc.).
-
-## Process
-
-1. **Detect Runtime and Builder**
-   - Run `DetectRuntime.sh` to determine Docker/Podman
-   - Check for buildx (Docker) or buildah (Podman)
-
-2. **Determine Target Platforms**
-   - Common: linux/amd64, linux/arm64, linux/arm/v7
-   - User-specified platforms
-
-3. **Setup Multi-Arch Builder**
-   - Create/use buildx builder (Docker)
-   - Configure QEMU for cross-compilation
-
-4. **Build for Multiple Platforms**
-   - Build image for each platform
-   - Create manifest list
-   - Optionally push to registry
-
-5. **Verify Build**
-   - Check manifest
-   - Verify platforms
-
-## Docker with Buildx
-
-### Setup
-
-**Install QEMU (if not present):**
-```bash
-docker run --privileged --rm tonistiigi/binfmt --install all
-```
-
-**Create builder:**
-```bash
-docker buildx create --name multiarch --driver docker-container --use
-docker buildx inspect --bootstrap
-```
-
-**List available platforms:**
-```bash
-docker buildx inspect --bootstrap | grep Platforms
-```
-
-### Build Multi-Arch Image
-
-**Build for multiple platforms:**
-```bash
-docker buildx build \
-  --platform linux/amd64,linux/arm64,linux/arm/v7 \
-  -t myregistry/myapp:latest \
-  --push \
-  .
-```
-
-**Build and load locally (single platform):**
-```bash
-docker buildx build \
-  --platform linux/arm64 \
-  -t myapp:arm64 \
-  --load \
-  .
-```
-
-**Build without pushing:**
-```bash
-docker buildx build \
-  --platform linux/amd64,linux/arm64 \
-  -t myregistry/myapp:latest \
-  .
-```
-
-**Build with output to registry:**
-```bash
-docker buildx build \
-  --platform linux/amd64,linux/arm64,linux/arm/v7 \
-  -t myregistry/myapp:latest \
-  --push \
-  .
-```
-
-### Advanced Buildx
-
-**Use specific builder:**
-```bash
-docker buildx build \
-  --builder multiarch \
-  --platform linux/amd64,linux/arm64 \
-  -t myapp:latest \
-  .
-```
-
-**Build with cache:**
-```bash
-docker buildx build \
-  --platform linux/amd64,linux/arm64 \
-  --cache-from type=registry,ref=myregistry/myapp:buildcache \
-  --cache-to type=registry,ref=myregistry/myapp:buildcache,mode=max \
-  -t myregistry/myapp:latest \
-  --push \
-  .
-```
-
-**Build different tags per platform:**
-```bash
-docker buildx build \
-  --platform linux/amd64 \
-  -t myregistry/myapp:amd64 \
-  --push \
-  .
-
-docker buildx build \
-  --platform linux/arm64 \
-  -t myregistry/myapp:arm64 \
-  --push \
-  .
-```
-
-### Manage Builders
-
-**List builders:**
-```bash
-docker buildx ls
-```
-
-**Remove builder:**
-```bash
-docker buildx rm multiarch
-```
-
-**Use default builder:**
-```bash
-docker buildx use default
-```
-
-## Podman with Buildah
-
-### Setup
-
-**Install QEMU:**
-```bash
-# On host system (requires root/sudo)
-sudo dnf install qemu-user-static  # Fedora/RHEL
-sudo apt install qemu-user-static  # Debian/Ubuntu
-
-# Or with Podman
-podman run --rm --privileged multiarch/qemu-user-static --reset -p yes
-```
-
-### Build Multi-Arch Image
-
-**Build for specific platform:**
-```bash
-podman build \
-  --platform linux/arm64 \
-  -t myapp:arm64 \
-  .
-```
-
-**Build for multiple platforms (requires manifest):**
-```bash
-# Build for each platform separately
-podman build --platform linux/amd64 -t myapp:amd64 .
-podman build --platform linux/arm64 -t myapp:arm64 .
-podman build --platform linux/arm/v7 -t myapp:armv7 .
-
-# Create manifest
-podman manifest create myapp:latest
-
-# Add images to manifest
-podman manifest add myapp:latest myapp:amd64
-podman manifest add myapp:latest myapp:arm64
-podman manifest add myapp:latest myapp:armv7
-
-# Push manifest
-podman manifest push myapp:latest docker://myregistry/myapp:latest
-```
-
-**Using buildah directly:**
-```bash
-# Build for ARM64
-buildah bud --arch arm64 -t myapp:arm64 .
-
-# Build for AMD64
-buildah bud --arch amd64 -t myapp:amd64 .
-```
-
-## Common Platforms
-
-| Platform | Description | Use Case |
-|----------|-------------|----------|
-| linux/amd64 | 64-bit x86 | Standard servers, desktops |
-| linux/arm64 | 64-bit ARM | Raspberry Pi 4, Apple Silicon, AWS Graviton |
-| linux/arm/v7 | 32-bit ARM v7 | Raspberry Pi 2/3, older ARM devices |
-| linux/arm/v6 | 32-bit ARM v6 | Raspberry Pi Zero/1 |
-| linux/386 | 32-bit x86 | Legacy systems |
-| linux/ppc64le | PowerPC 64-bit LE | IBM POWER systems |
-| linux/s390x | IBM Z | Mainframes |
-
-## Dockerfile Considerations
-
-### Platform-Specific Build
-
-**Using build arguments:**
-```dockerfile
-FROM --platform=$BUILDPLATFORM golang:1.21-alpine AS builder
-ARG TARGETPLATFORM
-ARG BUILDPLATFORM
-ARG TARGETOS
-ARG TARGETARCH
-
-WORKDIR /app
-COPY . .
-
-# Build for target platform
-RUN GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o app .
-
-FROM --platform=$TARGETPLATFORM alpine:latest
-COPY --from=builder /app/app /app
-ENTRYPOINT ["/app"]
-```
-
-**Platform-specific base images:**
-```dockerfile
-# Multi-stage with platform awareness
-FROM --platform=$BUILDPLATFORM golang:1.21 AS builder
-ARG TARGETARCH
-
-WORKDIR /src
-COPY . .
-RUN CGO_ENABLED=0 GOARCH=$TARGETARCH go build -o app
-
-FROM alpine:latest
-COPY --from=builder /src/app /app
-CMD ["/app"]
-```
-
-**Conditional platform logic:**
-```dockerfile
-FROM alpine:latest
-
-ARG TARGETARCH
-
-# Install platform-specific packages
-RUN if [ "$TARGETARCH" = "arm64" ]; then \
-      echo "Installing ARM64 packages"; \
-    elif [ "$TARGETARCH" = "amd64" ]; then \
-      echo "Installing AMD64 packages"; \
-    fi
-
-COPY app /app
-CMD ["/app"]
-```
-
-## Verify Multi-Arch Images
-
-### Inspect Manifest
-
-**Docker:**
-```bash
-# Inspect manifest list
-docker buildx imagetools inspect myregistry/myapp:latest
-
-# Should show multiple platforms
-docker manifest inspect myregistry/myapp:latest
-```
-
-**Podman:**
-```bash
-# Inspect manifest
-podman manifest inspect myapp:latest
-
-# Show manifest details with skopeo
-skopeo inspect docker://myregistry/myapp:latest
-```
-
-### Test Platform-Specific Images
-
-**Run specific platform:**
-```bash
-# Force ARM64 on AMD64 host
-docker run --platform linux/arm64 myregistry/myapp:latest
-
-# Force AMD64 on ARM64 host
-docker run --platform linux/amd64 myregistry/myapp:latest
-```
-
-**Verify architecture inside container:**
-```bash
-docker run --rm myregistry/myapp:latest uname -m
-# Should show: x86_64, aarch64, armv7l, etc.
-```
-
-## Best Practices
-
-### Optimization
-
-1. **Use multi-stage builds:**
-   - Separate build and runtime stages
-   - Smaller final images
-
-2. **Leverage build cache:**
-   - Use remote cache for faster builds
-   - Order layers appropriately
-
-3. **Platform-specific optimizations:**
-   - Different base images for different architectures
-   - Conditional compilation flags
-
-### CI/CD Integration
-
-**GitHub Actions:**
-```yaml
-- name: Set up QEMU
-  uses: docker/setup-qemu-action@v2
-
-- name: Set up Docker Buildx
-  uses: docker/setup-buildx-action@v2
-
-- name: Build and push
-  uses: docker/build-push-action@v4
-  with:
-    platforms: linux/amd64,linux/arm64,linux/arm/v7
-    push: true
-    tags: myregistry/myapp:latest
-```
-
-**GitLab CI:**
-```yaml
-build-multiarch:
-  image: docker:latest
-  services:
-    - docker:dind
-  before_script:
-    - docker buildx create --use
-    - docker buildx install
-  script:
-    - docker buildx build
-      --platform linux/amd64,linux/arm64
-      -t myregistry/myapp:latest
-      --push .
-```
-
-### Testing
-
-- Test on actual hardware when possible
-- Use QEMU for cross-platform testing
-- Verify critical functionality on each platform
-- Check performance characteristics
-
-## Common Issues
-
-**Issue**: Build very slow for non-native platforms
-- **Cause**: QEMU emulation overhead
-- **Solution**: Use native builders (build on ARM for ARM), or accept slower builds
-
-**Issue**: Build fails with "exec format error"
-- **Cause**: QEMU not configured
-- **Solution**: Run `docker run --privileged --rm tonistiigi/binfmt --install all`
-
-**Issue**: Cannot load multi-platform image locally
-- **Cause**: Local load only supports single platform
-- **Solution**: Use `--platform` to specify one platform, or push to registry
-
-**Issue**: Different behavior on different platforms
-- **Cause**: Platform-specific dependencies or binaries
-- **Solution**: Review Dockerfile, ensure cross-platform compatibility
-
-**Issue**: Manifest push fails
-- **Cause**: Authentication or manifest format issues
-- **Solution**: Verify registry supports manifest lists, check credentials
-
-## Output Format
-
-After multi-arch build:
-```
-✓ Multi-architecture image built successfully
-  Runtime: docker buildx / podman
-  Image: myregistry/myapp:latest
-
-  Platforms built:
-    - linux/amd64 (152 MB)
-    - linux/arm64 (148 MB)
-    - linux/arm/v7 (145 MB)
-
-  Total build time: 8m 32s
-
-  Manifest pushed to: myregistry/myapp:latest
-
-  Verify:
-    docker buildx imagetools inspect myregistry/myapp:latest
-
-  Test platforms:
-    docker run --platform linux/amd64 myregistry/myapp:latest
-    docker run --platform linux/arm64 myregistry/myapp:latest
-```
-
-## Quick Reference
-
-```bash
-# Docker Buildx
-docker buildx create --name multiarch --use
-docker buildx build --platform linux/amd64,linux/arm64 -t myapp:latest --push .
-docker buildx imagetools inspect myregistry/myapp:latest
-
-# Podman Manifest
-podman build --platform linux/amd64 -t myapp:amd64 .
-podman build --platform linux/arm64 -t myapp:arm64 .
-podman manifest create myapp:latest
-podman manifest add myapp:latest myapp:amd64
-podman manifest add myapp:latest myapp:arm64
-podman manifest push myapp:latest docker://myregistry/myapp:latest
-```

@@ -1,335 +0,0 @@
-# CleanupResources Workflow
-
-Clean up unused containers, images, volumes, and networks to reclaim disk space.
-
-## Process
-
-1. **Detect Runtime**
-   - Run `DetectRuntime.sh` to determine Docker/Podman
-
-2. **Assess Current Usage**
-   - Show disk usage: `docker system df` / `podman system df`
-   - Identify reclaimable space
-
-3. **Determine Cleanup Scope**
-   - Containers (stopped)
-   - Images (unused/dangling)
-   - Volumes (unused)
-   - Networks (unused)
-   - Build cache
-
-4. **Preview What Will Be Removed**
-   - Show items to be removed
-   - Estimate space to be reclaimed
-   - **Ask for user confirmation before proceeding**
-
-5. **Execute Cleanup**
-   - Run appropriate prune commands
-   - Show space reclaimed
-
-## Check Disk Usage
-
-**System-wide overview:**
-```bash
-docker system df
-podman system df
-```
-
-**Detailed view:**
-```bash
-docker system df -v
-podman system df -v
-```
-
-## Cleanup Operations
-
-### Containers
-
-**Remove all stopped containers:**
-```bash
-docker container prune
-podman container prune
-```
-
-**Remove specific container:**
-```bash
-docker rm container_name
-podman rm container_name
-```
-
-**Remove all containers (dangerous!):**
-```bash
-# Stop all first
-docker stop $(docker ps -aq)
-docker rm $(docker ps -aq)
-
-podman stop -a
-podman rm -a
-```
-
-### Images
-
-**Remove dangling images (untagged):**
-```bash
-docker image prune
-podman image prune
-```
-
-**Remove unused images:**
-```bash
-docker image prune -a
-podman image prune -a
-```
-
-**Remove specific image:**
-```bash
-docker rmi image_name:tag
-podman rmi image_name:tag
-```
-
-**Remove all images (dangerous!):**
-```bash
-docker rmi $(docker images -q)
-podman rmi -a
-```
-
-### Volumes
-
-**Remove unused volumes:**
-```bash
-docker volume prune
-podman volume prune
-```
-
-**Remove specific volume:**
-```bash
-docker volume rm volume_name
-podman volume rm volume_name
-```
-
-**Remove all volumes (dangerous!):**
-```bash
-docker volume rm $(docker volume ls -q)
-podman volume rm -a
-```
-
-### Networks
-
-**Remove unused networks:**
-```bash
-docker network prune
-podman network prune
-```
-
-**Remove specific network:**
-```bash
-docker network rm network_name
-podman network rm network_name
-```
-
-### Build Cache
-
-**Clear build cache:**
-```bash
-docker builder prune
-podman system prune --all --volumes
-```
-
-**Clear all build cache (more aggressive):**
-```bash
-docker builder prune -a
-```
-
-### Complete System Cleanup
-
-**Prune everything (containers, images, volumes, networks):**
-```bash
-docker system prune -a --volumes
-podman system prune -a --volumes
-```
-
-**With force (skip confirmation):**
-```bash
-docker system prune -a --volumes -f
-podman system prune -a --volumes -f
-```
-
-## Safe Cleanup Strategy
-
-### Step-by-Step Approach
-
-1. **Start conservative:**
-   ```bash
-   # Remove stopped containers
-   docker container prune
-
-   # Remove dangling images
-   docker image prune
-   ```
-
-2. **Then volumes:**
-   ```bash
-   # Review volumes first
-   docker volume ls
-
-   # Remove unused
-   docker volume prune
-   ```
-
-3. **Finally unused images:**
-   ```bash
-   # This removes images not used by any container
-   docker image prune -a
-   ```
-
-4. **Build cache (if needed):**
-   ```bash
-   docker builder prune
-   ```
-
-### Filter by Age
-
-**Remove containers stopped more than 24 hours ago:**
-```bash
-docker container prune --filter "until=24h"
-podman container prune --filter "until=24h"
-```
-
-**Remove images created more than 7 days ago:**
-```bash
-docker image prune -a --filter "until=168h"
-podman image prune -a --filter "until=168h"
-```
-
-### Filter by Label
-
-**Remove containers with specific label:**
-```bash
-docker container prune --filter "label=project=myapp"
-podman container prune --filter "label=project=myapp"
-```
-
-## Best Practices
-
-### Regular Maintenance
-- Run cleanup weekly or monthly
-- Use automation (cron job)
-- Monitor disk usage
-
-### Safety Checks
-- **Always preview** what will be removed
-- **Never use `-f` (force)** without understanding impact
-- Keep tagged images you need
-- Backup important volumes before cleanup
-
-### Retention Strategy
-```bash
-# Keep images from last week
-docker image prune -a --filter "until=168h"
-
-# Keep containers stopped in last 24h
-docker container prune --filter "until=24h"
-```
-
-## Automated Cleanup
-
-### Docker System Prune with Cron
-
-```bash
-# Add to crontab (weekly cleanup)
-0 2 * * 0 docker system prune -a --volumes -f >> /var/log/docker-cleanup.log 2>&1
-```
-
-### Podman Auto-Prune
-
-```bash
-# Podman rootless with systemd timer
-systemctl --user enable --now podman-auto-update.timer
-```
-
-## Common Issues
-
-**Issue**: Important data deleted
-- **Prevention**: Always use named volumes for important data
-- **Recovery**: Check volume backups if available
-
-**Issue**: Still using too much space
-- Check for large log files: `/var/lib/docker/containers/*/*-json.log`
-- Configure log rotation:
-  ```json
-  {
-    "log-driver": "json-file",
-    "log-opts": {
-      "max-size": "10m",
-      "max-file": "3"
-    }
-  }
-  ```
-
-**Issue**: Cannot remove image in use
-- Check which containers use it: `docker ps -a --filter ancestor=image_name`
-- Stop and remove containers first
-
-**Issue**: Permission denied (Docker)
-- Use sudo or add user to docker group
-- With Podman: run as regular user (rootless)
-
-## Output Format
-
-After cleanup:
-```
-✓ Cleanup completed successfully
-  Runtime: docker/podman
-
-  Removed:
-    - Containers: 5
-    - Images: 12
-    - Volumes: 3
-    - Networks: 2
-
-  Space reclaimed: 2.5 GB
-
-  Current usage:
-    - Images: 5.2 GB
-    - Containers: 150 MB
-    - Volumes: 800 MB
-    - Build cache: 1.1 GB
-    - Total: 7.25 GB
-
-Next steps:
-  - Check usage: docker system df
-  - Schedule regular cleanup
-  - Configure log rotation
-```
-
-## Advanced Cleanup
-
-### Clean Specific Image Tags
-
-```bash
-# Remove old versions of specific image
-docker images myapp --format "{{.Tag}}" | grep -v "latest\|v1.0" | xargs -I {} docker rmi myapp:{}
-```
-
-### Clean by Pattern
-
-```bash
-# Remove all development images
-docker images | grep "\-dev" | awk '{print $3}' | xargs docker rmi
-
-# Remove unnamed images
-docker images --filter "dangling=true" -q | xargs docker rmi
-```
-
-### Podman-Specific Cleanup
-
-```bash
-# Reset entire podman storage (nuclear option)
-podman system reset
-
-# Clean up pods
-podman pod prune
-
-# Clean up specific user's containers (rootless)
-podman system prune --all
-```

@@ -1,377 +0,0 @@
-# ComposeManage Workflow
-
-Manage multi-container applications with Docker Compose or Podman Compose.
-
-## Process
-
-1. **Detect Runtime and Compose Tool**
-   - Run `DetectRuntime.sh` to determine available compose tool
-   - Check for `docker-compose`, `docker compose`, or `podman-compose`
-
-2. **Analyze Compose File**
-   - Check for `docker-compose.yml` or `compose.yaml`
-   - Validate compose file syntax
-   - Review services, networks, volumes defined
-
-3. **Determine Action**
-   - Start services (up)
-   - Stop services (down)
-   - Restart services
-   - View logs
-   - Scale services
-   - Build services
-
-4. **Execute Compose Command**
-   - Run appropriate compose command
-   - Handle environment variables
-   - Manage profiles if used
-
-5. **Verify State**
-   - Check service status
-   - Show running services
-   - Display relevant logs
-
-## Common Operations
-
-### Start Services
-
-**Start all services:**
-```bash
-docker-compose up -d
-docker compose up -d
-podman-compose up -d
-```
-
-**Start specific service:**
-```bash
-docker-compose up -d web
-docker compose up -d web
-podman-compose up -d web
-```
-
-**Start with build:**
-```bash
-docker-compose up -d --build
-docker compose up -d --build
-podman-compose up -d --build
-```
-
-**Start with specific file:**
-```bash
-docker-compose -f docker-compose.prod.yml up -d
-docker compose -f docker-compose.prod.yml up -d
-podman-compose -f docker-compose.prod.yml up -d
-```
-
-### Stop Services
-
-**Stop all services:**
-```bash
-docker-compose down
-docker compose down
-podman-compose down
-```
-
-**Stop and remove volumes:**
-```bash
-docker-compose down -v
-docker compose down -v
-podman-compose down -v
-```
-
-**Stop specific service:**
-```bash
-docker-compose stop web
-docker compose stop web
-podman-compose stop web
-```
-
-### View Status and Logs
-
-**List running services:**
-```bash
-docker-compose ps
-docker compose ps
-podman-compose ps
-```
-
-**View logs:**
-```bash
-docker-compose logs
-docker compose logs
-podman-compose logs
-```
-
-**Follow logs:**
-```bash
-docker-compose logs -f
-docker compose logs -f
-podman-compose logs -f
-```
-
-**Logs for specific service:**
-```bash
-docker-compose logs web
-docker compose logs web
-podman-compose logs web
-```
-
-### Build and Rebuild
-
-**Build all services:**
-```bash
-docker-compose build
-docker compose build
-podman-compose build
-```
-
-**Build specific service:**
-```bash
-docker-compose build web
-docker compose build web
-podman-compose build web
-```
-
-**Build with no cache:**
-```bash
-docker-compose build --no-cache
-docker compose build --no-cache
-podman-compose build --no-cache
-```
-
-### Scale Services
-
-**Scale service to multiple instances:**
-```bash
-docker-compose up -d --scale web=3
-docker compose up -d --scale web=3
-podman-compose up -d --scale web=3
-```
-
-### Execute Commands
-
-**Run command in service:**
-```bash
-docker-compose exec web bash
-docker compose exec web bash
-podman-compose exec web bash
-```
-
-**Run one-off command:**
-```bash
-docker-compose run web python manage.py migrate
-docker compose run web python manage.py migrate
-podman-compose run web python manage.py migrate
-```
-
-## Compose File Best Practices
-
-### Structure
-```yaml
-version: '3.8'
-
-services:
-  web:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    ports:
-      - "8080:80"
-    environment:
-      - DATABASE_URL=postgres://db/myapp
-    depends_on:
-      - db
-    networks:
-      - app-network
-    volumes:
-      - ./app:/app
-    restart: unless-stopped
-
-  db:
-    image: postgres:16-alpine
-    environment:
-      - POSTGRES_DB=myapp
-      - POSTGRES_PASSWORD_FILE=/run/secrets/db_password
-    volumes:
-      - db-data:/var/lib/postgresql/data
-    networks:
-      - app-network
-    secrets:
-      - db_password
-
-networks:
-  app-network:
-    driver: bridge
-
-volumes:
-  db-data:
-
-secrets:
-  db_password:
-    file: ./secrets/db_password.txt
-```
-
-### Key Points
-- Use specific image tags (not `latest`)
-- Use `.env` files for environment variables
-- Define health checks
-- Use secrets for sensitive data
-- Specify restart policies
-- Define resource limits
-- Use named volumes for persistence
-
-### Environment Variables
-
-**Using .env file:**
-```bash
-# .env
-DATABASE_URL=postgres://localhost/myapp
-SECRET_KEY=mysecret
-```
-
-**In compose file:**
-```yaml
-services:
-  web:
-    env_file:
-      - .env
-    # Or specific variables
-    environment:
-      - DATABASE_URL=${DATABASE_URL}
-```
-
-### Profiles
-
-**Define profiles:**
-```yaml
-services:
-  web:
-    # Always runs
-
-  debug:
-    profiles: ["debug"]
-    # Only runs with --profile debug
-```
-
-**Use profiles:**
-```bash
-docker-compose --profile debug up -d
-docker compose --profile debug up -d
-podman-compose --profile debug up -d
-```
-
-## Podman-Specific Considerations
-
-### Podman Compose vs Docker Compose
-
-**Podman Compose:**
-- Python-based implementation
-- Works with Podman daemon or rootless
-- May have slight syntax differences
-
-**Generate Kubernetes YAML from Compose:**
-```bash
-# Podman can generate K8s YAML
-podman-compose up
-podman generate kube mypod > pod.yaml
-```
-
-### Systemd Integration
-
-**Generate systemd unit from compose:**
-```bash
-# Start services
-podman-compose up -d
-
-# Get pod name
-podman pod ps
-
-# Generate systemd unit
-podman generate systemd --name mypod_pod --files
-
-# Move to systemd directory
-mv *.service ~/.config/systemd/user/
-
-# Enable
-systemctl --user enable --now mypod_pod.service
-```
-
-## Common Issues
-
-**Issue**: Compose file version not supported
-- Use version 3.8 or omit version (modern compose)
-- Check compose tool version
-
-**Issue**: Services can't communicate
-- Ensure services are on same network
-- Use service names as hostnames
-
-**Issue**: Port already in use
-- Check for conflicting services: `lsof -i :8080`
-- Change port mapping in compose file
-
-**Issue**: Volumes not persisting
-- Use named volumes instead of anonymous
-- Check volume definitions
-
-**Issue**: Environment variables not loading
-- Verify .env file location (same directory as compose file)
-- Check for quotes: `KEY=value` not `KEY="value"`
-
-## Output Format
-
-After compose operation:
-```
-✓ Services started successfully
-  Runtime: docker-compose / podman-compose
-  Services: 3 running
-    - web (0.0.0.0:8080->80/tcp)
-    - db (postgres:16-alpine)
-    - redis (redis:7-alpine)
-
-Next steps:
-  - View logs: docker-compose logs -f
-  - Check status: docker-compose ps
-  - Stop services: docker-compose down
-```
-
-## Advanced Features
-
-### Override Files
-
-**Use override for development:**
-```bash
-# docker-compose.override.yml automatically loaded
-docker-compose up -d
-
-# Or specify explicitly
-docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d
-```
-
-### Health Checks
-
-```yaml
-services:
-  web:
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s
-```
-
-### Resource Limits
-
-```yaml
-services:
-  web:
-    deploy:
-      resources:
-        limits:
-          cpus: '0.5'
-          memory: 512M
-        reservations:
-          cpus: '0.25'
-          memory: 256M
-```