Configuration Generator

Generate configuration files for applications, services, and infrastructure across various formats and frameworks.

Quick Start

Use Built-in Templates

Access ready-to-use configuration templates from assets:

bash

# Docker Compose
cat assets/docker-compose.yml

# Kubernetes
cat assets/kubernetes-deployment.yaml

# GitHub Actions
cat assets/github-actions-workflow.yml

Generate Custom Configuration

Specify your requirements to get tailored configuration files.

Common Configuration Types

Application Configurations

Package Managers

Node.js (package.json)

json

{
  "name": "my-app",
  "version": "1.0.0",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "jest",
    "build": "tsc"
  },
  "dependencies": {
    "express": "^4.18.0"
  },
  "devDependencies": {
    "typescript": "^5.0.0",
    "jest": "^29.0.0"
  }
}

Python (requirements.txt)

code

django==4.2.0
djangorestframework==3.14.0
psycopg2-binary==2.9.5
pytest==7.3.0
black==23.3.0

See app_configs.md for:

•Package managers (npm, pip, cargo)
•Build tools (TypeScript, Webpack, Vite)
•Linters/formatters (ESLint, Prettier, Black)
•Testing frameworks (Jest, pytest)
•Environment files (.env, .editorconfig, .gitignore)

Build Configurations

TypeScript (tsconfig.json)

json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Infrastructure Configurations

Docker

Dockerfile (Multi-stage)

dockerfile

FROM node:18-alpine as builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
USER node
EXPOSE 3000
CMD ["node", "dist/index.js"]

Docker Compose - See assets/docker-compose.yml:

•Multi-service setup (web, database, cache)
•Environment variable configuration
•Volume management
•Network configuration

Kubernetes

Deployment Configuration - See assets/kubernetes-deployment.yaml:

•Deployment with replicas
•ConfigMap and Secret management
•Service and Ingress configuration
•Health probes
•Resource limits

Example Deployment:

yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    spec:
      containers:
      - name: web
        image: myapp:latest
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

See infra_configs.md for:

•Docker and Kubernetes
•Terraform (AWS, GCP, Azure)
•CI/CD pipelines
•Web servers (Nginx, Apache)

CI/CD Pipelines

GitHub Actions - See assets/github-actions-workflow.yml:

•Test, build, and deploy workflow
•Service containers (PostgreSQL, Redis)
•Docker image building
•Deployment automation

Example Workflow:

yaml

name: CI/CD Pipeline

on:
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      - run: pip install -r requirements.txt
      - run: pytest

Configuration Decision Tree

code

What type of configuration do you need?

├─ Application Config
│  ├─ Package manager? → package.json, requirements.txt, Cargo.toml
│  ├─ Build tool? → tsconfig.json, webpack.config.js, vite.config.ts
│  ├─ Linter/formatter? → .eslintrc, .prettierrc, pyproject.toml
│  └─ Environment? → .env, .editorconfig, .gitignore
│
├─ Container/Orchestration
│  ├─ Docker? → Dockerfile, docker-compose.yml
│  └─ Kubernetes? → deployment.yaml, service.yaml, ingress.yaml
│
├─ Infrastructure as Code
│  ├─ Terraform? → main.tf, variables.tf, outputs.tf
│  └─ CloudFormation? → template.yaml
│
├─ CI/CD
│  ├─ GitHub Actions? → .github/workflows/ci.yml
│  ├─ GitLab CI? → .gitlab-ci.yml
│  └─ CircleCI? → .circleci/config.yml
│
└─ Web Server
   ├─ Nginx? → nginx.conf
   └─ Apache? → httpd.conf, .htaccess

Generation Approaches

Approach 1: Template-Based

Use pre-built templates from assets/:

When to use:

•Standard setups
•Quick prototyping
•Learning/reference

How:

•Identify needed template
•Copy from assets
•Customize variables
•Deploy

Example:

bash

# Copy Docker Compose template
cp assets/docker-compose.yml ./

# Edit environment variables
# Deploy
docker-compose up -d

Approach 2: Requirements-Based Generation

Generate from scratch based on specific needs:

When to use:

•Custom requirements
•Complex setups
•Specific tech stack

How:

•Specify requirements
•Choose tech stack
•Define constraints
•Generate configuration

Example Request: "Generate a GitHub Actions workflow for a Python Django app with PostgreSQL, Redis, and deployment to AWS ECS"

Generated Output: Custom workflow with:

•Python 3.11 setup
•PostgreSQL and Redis services
•Django test suite
•Docker image build
•AWS ECS deployment

Approach 3: Hybrid

Combine templates with customization:

When to use:

•Partially standard setup
•Template needs modification
•Best practices + customization

How:

•Start with template
•Identify customization points
•Modify specific sections
•Validate configuration

Best Practices

1. Use Environment Variables

Separate configuration from code:

Application:

python

# settings.py
import os

DATABASE_URL = os.getenv('DATABASE_URL')
SECRET_KEY = os.getenv('SECRET_KEY')
DEBUG = os.getenv('DEBUG', 'False') == 'True'

.env file:

bash

DATABASE_URL=postgresql://localhost/mydb
SECRET_KEY=your-secret-key
DEBUG=true

2. Version Control Best Practices

Do commit:

•.env.example (template)
•Configuration templates
•Development configs

Don't commit:

•.env (secrets)
•.env.local (local overrides)
•Production credentials

.gitignore:

code

.env
.env.local
.env.*.local

3. Validate Configurations

Check syntax before deploying:

bash

# Docker Compose
docker-compose config

# Kubernetes
kubectl apply --dry-run=client -f deployment.yaml

# Terraform
terraform validate

# YAML syntax
yamllint config.yml

4. Document Configuration

Add comments explaining purpose:

yaml

# docker-compose.yml
services:
  web:
    # Application server - handles HTTP requests
    image: myapp:latest
    ports:
      # Expose on port 8000 for development
      - "8000:8000"
    environment:
      # Database connection string
      - DATABASE_URL=${DATABASE_URL}

5. Use Sensible Defaults

Provide defaults for optional values:

yaml

# Kubernetes ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  # Default to info level logging
  LOG_LEVEL: "info"
  # Default connection pool size
  DB_POOL_SIZE: "10"

Common Patterns

Multi-Environment Configuration

Development:

yaml

# docker-compose.dev.yml
services:
  web:
    build: .
    volumes:
      - ./app:/app  # Hot reload
    environment:
      - DEBUG=true

Production:

yaml

# docker-compose.prod.yml
services:
  web:
    image: registry/myapp:latest
    environment:
      - DEBUG=false
    deploy:
      replicas: 3

Secret Management

Kubernetes Secrets:

yaml

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
stringData:
  database-url: "postgresql://..."
  api-key: "secret-key"

Docker Compose (with env file):

yaml

services:
  web:
    env_file:
      - .env.production

Health Checks

Docker Compose:

yaml

services:
  web:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

Kubernetes:

yaml

livenessProbe:
  httpGet:
    path: /health
    port: 8000
  initialDelaySeconds: 30
  periodSeconds: 10
readinessProbe:
  httpGet:
    path: /ready
    port: 8000
  initialDelaySeconds: 5
  periodSeconds: 5

Complete Example

Request: "Create complete configuration for a Python FastAPI application with PostgreSQL and Redis, using Docker Compose for development and Kubernetes for production"

Generated Configurations:

•Dockerfile
•docker-compose.yml (development)
•requirements.txt
•kubernetes/deployment.yaml (production)
•.env.example
•.github/workflows/deploy.yml

These files work together to provide:

•Local development environment
•CI/CD pipeline
•Production deployment
•Secret management
•Health monitoring

Troubleshooting

Configuration Validation Errors

YAML syntax errors:

bash

# Check YAML syntax
python -c "import yaml; yaml.safe_load(open('config.yml'))"

# Or use yamllint
yamllint config.yml

Docker Compose issues:

bash

# Validate and view resolved config
docker-compose config

# Check for errors
docker-compose config --quiet

Environment Variable Issues

Missing variables:

bash

# List all required variables
grep -o '\${[^}]*}' docker-compose.yml

# Check if variable is set
echo $DATABASE_URL

Port Conflicts

Find process using port:

bash

# Linux/macOS
lsof -i :8000

# Windows
netstat -ano | findstr :8000

Reference Materials

Application Configs

See app_configs.md for complete templates:

•Package managers (package.json, requirements.txt, Pipfile, Cargo.toml)
•Build tools (tsconfig.json, webpack.config.js, vite.config.ts)
•Linters and formatters (.eslintrc, .prettierrc, .flake8, pyproject.toml)
•Testing frameworks (jest.config.js, pytest.ini)
•Environment files (.env.example, .editorconfig, .gitignore)

Infrastructure Configs

See infra_configs.md for:

•Docker (Dockerfile multi-stage, docker-compose.yml, .dockerignore)
•Kubernetes (Deployment, Service, Ingress, ConfigMap, Secret, HPA)
•Terraform (AWS, GCP, Azure infrastructure)
•CI/CD (GitHub Actions, GitLab CI, CircleCI)
•Web servers (Nginx, Apache configuration)