DevOps-OS

Beginner's Guide: Understanding DevOps-OS MCP

Mon, 01 Jan 0001 00:00:00 +0000

🎓 Beginner’s Guide: Understanding DevOps-OS MCP#

New to DevOps-OS? Don’t know what “CI/CD” means? You’re in the right place.

This guide explains DevOps-OS concepts in plain English, without assuming you know technical jargon. After reading this, you’ll understand what problems DevOps-OS solves and whether it’s right for you.

What Is DevOps-OS MCP? (Plain English)#

DevOps-OS MCP is a tool that lets you ask Claude (an AI assistant) to generate code and configuration files that tell your computers how to automatically build, test, and deploy your software.

Chennai FOSS 2026

Mon, 01 Jan 0001 00:00:00 +0000

Chennai FOSS 2026 Presentation#

Open the deck directly or use the embedded view below during the session.

Presenter note: Use the direct presentation link above for full-screen delivery. The embedded view is intended for quick access from GitHub Pages.

Easy Getting Started

Mon, 01 Jan 0001 00:00:00 +0000

🚀 Easy Getting Started — Just Copy & Paste#

This is the simplest way to start using DevOps-OS MCP with Claude or ChatGPT.

🔗 Two Versions of DevOps-OS

DevOps-OS MCP (this repo): Use with AI assistants (Claude, ChatGPT, Cursor, etc.)

DevOps-OS CLI (cloudengine-labs/devops_os): Use in scripts and automation

This guide covers MCP. For the CLI version, see the original project.

No complex configuration, just 3 commands + restart Claude.

Process-First Philosophy

Mon, 01 Jan 0001 00:00:00 +0000

Process-First Philosophy#

“Tools are only as good as the processes that govern them.”
— Saravanan Gnanaguru, Founder, CloudEngine Labs

cloudenginelabs.io is a Process-First SDLC automation company.
DevOps-OS embeds this philosophy as a first-class CLI command so every engineer on your team can understand why before they run how.

Thought Leaders on Process-First & Systems Thinking#

“The First Way emphasises the performance of the entire system, as opposed to the performance of a specific silo of work or department.”

MCP Quick Start

Mon, 01 Jan 0001 00:00:00 +0000

MCP Quick Start — 5 Minutes#

Get DevOps-OS running as an MCP server in Claude Desktop in under 5 minutes.

What You’ll Do#

Clone the repo
Install dependencies
Add to Claude Desktop config
Generate your first pipeline with AI

Total time: ~4 minutes

Step 1: Clone & Install (1 minute)#

git clone https://github.com/cloudengine-labs/devops_os.git
cd devops_os

# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate # macOS/Linux
# .venv\Scripts\activate # Windows

# Install MCP dependencies
pip install -r mcp_server/requirements.txt

Step 2: Configure Claude Desktop (2 minutes)#

Find Your DevOps-OS Path#

# In the devops_os directory, get the full path
pwd
# Output: /Users/alice/projects/devops_os (macOS/Linux)
# Or: C:\Users\alice\projects\devops_os (Windows)

Open Claude Config File#

macOS:

Process-First Mapping: From DevOps Tools to Platform Engineering

Mon, 01 Jan 0001 00:00:00 +0000

Process-First Mapping: From DevOps Tools to Platform Engineering#

The Process-First philosophy is foundational to platform engineering. It states that business processes should drive technology choices, not the reverse. This document maps traditional DevOps tools to the Process-First SDLC phases and shows how this bridge enables platform engineering.

The Process-First SDLC#

The Process-First approach divides software delivery into five phases:

┌─────────────────────────────────────────────────────────┐
│ PLAN │ CREATE │ VERIFY │ RUN │ MONITOR │
└─────────────────────────────────────────────────────────┘

PLAN Phase 🎯#

Intent: Understand what needs to be built and how it will be delivered.

Infrastructure Hardening

Mon, 01 Jan 0001 00:00:00 +0000

Infrastructure Hardening#

DevOps-OS includes python -m cli.devopsos scaffold hardening to generate reusable hardening baselines for Kubernetes clusters, container runtimes, and operating systems.

What it generates#

Output type	Purpose	Default location
Kyverno policies	Kubernetes admission guardrails for CIS, STIG, NSA/CISA, Pod Security Standards, image signing, and OWASP ASVS L1	`hardening/kyverno/`
InSpec profiles	Compliance profiles for Docker, RHEL 9, and Ubuntu 22.04	`hardening/inspec/`
ASVS L1 checks	OWASP ASVS L1 infra-layer Kyverno policies and Checkov checks	`hardening/asvs-l1-checks/`
Checkov checks	Essential Eight checks and supporting metadata	`hardening/essential-eight/`
Compliance mapping	Rule-to-framework mapping for catalog linking	`hardening/compliance-mapping.yaml`

Supported standards#

Standard	CLI value	Primary output
CIS Kubernetes Benchmark v1.9	`cis-k8s`	Kyverno policies
DISA STIG for Kubernetes	`stig-k8s`	Kyverno policies
NSA/CISA Kubernetes Hardening Guide	`nsa-k8s`	Kyverno policies + network policies
Pod Security Standards	`pod-security`	Kyverno policy
Container image signing	`image-signing`	Kyverno policy
OWASP ASVS L1 (infra layer)	`asvs-l1`	Kyverno policies + Checkov checks
CIS Docker Benchmark v1.6	`cis-docker`	InSpec profile
CIS RHEL 9 Benchmark	`cis-rhel9`	InSpec profile
CIS Ubuntu 22.04 Benchmark	`cis-ubuntu22`	InSpec profile
Essential Eight	`essential-eight`	Checkov checks + README

Standard descriptions#

CIS Kubernetes Benchmark v1.9 (`cis-k8s`)#

Published by the Center for Internet Security (CIS), this benchmark provides prescriptive guidance for securing Kubernetes cluster components — API server, etcd, control-plane, kubelet, and RBAC. It is the most widely adopted baseline for Kubernetes hardening and is referenced by PCI-DSS, ISO 27001, and SOC 2 assessors. The generated Kyverno policies cover all five CIS sections (master node, etcd, control plane, worker nodes, and cluster policies).

MCP Setup & Configuration

Mon, 01 Jan 0001 00:00:00 +0000

MCP Setup & Configuration Guide#

This guide covers detailed setup and configuration of DevOps-OS as an MCP (Model Context Protocol) server for local and remote use with Claude, ChatGPT, and other AI assistants.

What is MCP?#

MCP (Model Context Protocol) is an open standard that lets AI assistants directly call tools and functions in your applications. DevOps-OS exposes all its pipeline generators as MCP tools, allowing Claude or ChatGPT to generate CI/CD pipelines, Kubernetes configs, and SRE dashboards on your behalf.

Pipeline Templatization Fundamentals

Mon, 01 Jan 0001 00:00:00 +0000

Pipeline Templatization Fundamentals#

Pipeline templatization is the process of identifying common patterns in CI/CD workflows and codifying them as reusable, parameterized templates. This enables consistency, reduces errors, and accelerates team onboarding.

Template vs. Bespoke Pipeline#

Reusable Template#

Solves a common problem (e.g., “build and test a Python Flask app”)
Uses parameters to customize behavior (language, test framework, Docker registry)
Enforces guardrails (e.g., “always run security scan before deploy”)
Versioned and documented
Can be discovered and reused by multiple teams

Bespoke Pipeline#

Solves a unique problem (e.g., “deploy legacy mainframe batch job hourly”)
Custom logic specific to one application
May bypass guardrails for legitimate business reasons
Created once and rarely changed
Knowledge exists in one person’s head

Best Practice: 80% of pipelines should be based on templates; 20% can be bespoke.

GitHub Actions

Mon, 01 Jan 0001 00:00:00 +0000

GitHub Actions Workflow Generator#

The GitHub Actions generator creates YAML workflow files that orchestrate CI/CD processes using GitHub’s built-in action system. Workflows leverage the DevOps-OS container for a consistent build environment.

Basic Usage#

python -m cli.devopsos scaffold gha --name "my-app" --type complete

Output: .github/workflows/my-app-complete.yml

The filename pattern is <name-hyphenated>-<type>.yml inside the output directory.
Change the output directory with --output <dir> (default: .github/workflows/).

Options#

Option	Default	Description
`--name NAME`	`DevOps-OS`	Workflow name
`--type TYPE`	`complete`	`build` \| `test` \| `deploy` \| `complete` \| `reusable`
`--languages LANGS`	`python,javascript`	Comma-separated: `python`, `java`, `javascript`, `go`
`--kubernetes`	off	Include Kubernetes deployment steps
`--registry URL`	`ghcr.io`	Container registry URL
`--k8s-method METHOD`	`kubectl`	`kubectl` \| `kustomize` \| `argocd` \| `flux`
`--output DIR`	`.github/workflows`	Output directory
`--custom-values FILE`	(none)	Path to custom values JSON file
`--image IMAGE`	`ghcr.io/yourorg/devops-os:latest`	DevOps-OS container image
`--branches BRANCHES`	`main`	Comma-separated branches that trigger the workflow
`--matrix`	off	Enable matrix builds across OS/architectures
`--env-file FILE`	(cli dir)	Path to `devcontainer.env.json`
`--reusable`	off	Generate a reusable workflow

Workflow Types#

Type	Description
`build`	Focuses on building and packaging your application
`test`	Focuses on running tests
`deploy`	Focuses on deploying to the target environment
`complete`	Combines build, test, and deploy stages
`reusable`	Creates a workflow callable from other workflows

Examples#

Python application — complete pipeline#

python -m cli.devopsos scaffold gha --name "Python App" --languages python --type complete
# Output: .github/workflows/python-app-complete.yml

Java with Maven#

python -m cli.devopsos scaffold gha --name "Java Service" --languages java --custom-values maven-config.json
# Output: .github/workflows/java-service-complete.yml

Multi-language microservices with Kubernetes#

python -m cli.devopsos scaffold gha \
 --name "Microservices" \
 --languages python,javascript,go \
 --kubernetes --k8s-method kustomize
# Output: .github/workflows/microservices-complete.yml

Matrix build (cross-platform)#

python -m cli.devopsos scaffold gha --name "Node.js App" --languages javascript --matrix
# Output: .github/workflows/node-js-app-complete.yml

Reusable workflow#

python -m cli.devopsos scaffold gha --name "shared" --type reusable
# Output: .github/workflows/shared-reusable.yml

Environment Variables#

All options can be set using environment variables prefixed with DEVOPS_OS_GHA_:

GitLab CI

Mon, 01 Jan 0001 00:00:00 +0000

GitLab CI Pipeline Generator#

Generate a complete .gitlab-ci.yml for your project in a single command. The generator creates multi-stage pipelines with language-specific test jobs, Docker build, and Kubernetes deployment.

Basic Usage#

python -m cli.devopsos scaffold gitlab --name my-app --languages python --type complete

Output: .gitlab-ci.yml (default)
Change the output path with --output <path>.

Options#

Option	Default	Description
`--name NAME`	`my-app`	Application / pipeline name
`--type TYPE`	`complete`	`build` \| `test` \| `deploy` \| `complete`
`--languages LANGS`	`python`	Comma-separated: `python`, `java`, `javascript`, `go`
`--kubernetes`	off	Add a Kubernetes deploy stage
`--k8s-method METHOD`	`kubectl`	`kubectl` \| `kustomize` \| `argocd` \| `flux`
`--output FILE`	`.gitlab-ci.yml`	Output file path
`--image IMAGE`	`docker:24`	Default Docker image for pipeline jobs
`--branches BRANCHES`	`main`	Branches that trigger deploy jobs
`--kube-namespace NS`	(empty)	Kubernetes namespace (empty = use `$KUBE_NAMESPACE` variable)
`--custom-values FILE`	(none)	Path to custom values JSON file

All options can be set via environment variables prefixed DEVOPS_OS_GITLAB_.

Jenkins

Mon, 01 Jan 0001 00:00:00 +0000

Jenkins Pipeline Generator#

Generate Jenkinsfile scripts using the declarative pipeline syntax. Pipelines leverage the DevOps-OS container for a consistent build environment.

Basic Usage#

python -m cli.devopsos scaffold jenkins --name "my-app" --type complete

Output: Jenkinsfile (default)
Change the output path with --output <path>.

Options#

Option	Default	Description
`--name NAME`	`DevOps-OS`	Pipeline name
`--type TYPE`	`complete`	`build` \| `test` \| `deploy` \| `complete` \| `parameterized`
`--languages LANGS`	`python,javascript`	Comma-separated: `python`, `java`, `javascript`, `go`
`--kubernetes`	off	Add Kubernetes deploy stage
`--registry URL`	`docker.io`	Container registry URL
`--k8s-method METHOD`	`kubectl`	`kubectl` \| `kustomize` \| `argocd` \| `flux`
`--output FILE`	`Jenkinsfile`	Output file path
`--custom-values FILE`	(none)	Path to custom values JSON file
`--image IMAGE`	`docker.io/yourorg/devops-os:latest`	DevOps-OS container image
`--scm SCM`	`git`	Source control: `git` \| `svn` \| `none`
`--parameters`	off	Add runtime parameters (auto-enabled for `--type parameterized`)
`--env-file FILE`	(cli dir)	Path to `devcontainer.env.json`

All options can be set via environment variables prefixed DEVOPS_OS_JENKINS_.

Environment Variables Reference

Mon, 01 Jan 0001 00:00:00 +0000

DevOps-OS MCP: Environment Variables Reference#

Complete reference for all environment variables that control DevOps-OS MCP server behavior and features.

Quick Reference#

Variable	Default	Type	Feature
`DEVOPS_OS_TRANSPORT`	`stdio`	string	Communication protocol
`DEVOPS_OS_PROFILE`	`local`	string	Deployment profile
`DEVOPS_OS_HOST`	`127.0.0.1`	string	HTTP bind address
`DEVOPS_OS_PORT`	`8000`	int	HTTP bind port
`DEVOPS_OS_MCP_ENDPOINT`	`/mcp`	string	MCP endpoint path
`DEVOPS_OS_LOG_LEVEL`	`INFO`	string	Logging verbosity
`DEVOPS_OS_REQUEST_SIZE_MB`	`10`	int	Max request size
`DEVOPS_OS_RESPONSE_SIZE_MB`	`50`	int	Max response size
`DEVOPS_OS_EXECUTION_TIMEOUT`	`30`	int	Tool timeout (seconds)
`DEVOPS_OS_MAX_CONCURRENT_CALLS`	`10`	int	Max concurrent tool executions
`DEVOPS_OS_JWT_ISSUER`	None	string	JWT issuer URL
`DEVOPS_OS_JWT_AUDIENCE`	None	string	JWT audience
`DEVOPS_OS_JWT_JWKS_URL`	Auto-derived	string	JWKS endpoint URL
`DEVOPS_OS_JWT_ALGORITHMS`	`RS256,ES256`	string	Allowed JWT algorithms
`DEVOPS_OS_ENABLE_SUGGESTIONS`	`true`	boolean	Enable prompt suggestions
`DEVOPS_OS_SUGGESTION_CONFIDENCE_THRESHOLD`	`medium`	string	Suggestion confidence filter
`DEVOPS_OS_MAX_SUGGESTIONS_PER_RESPONSE`	`2`	int	Max suggestions
`DEVOPS_OS_INCLUDE_EXAMPLES_IN_SUGGESTIONS`	`true`	boolean	Include prompt examples

Transport & Server Configuration#

`DEVOPS_OS_TRANSPORT`#

Type: String
Default: stdio
Valid Values: stdio, sse, streamable-http

Kubernetes-Based Platform Engineering

Mon, 01 Jan 0001 00:00:00 +0000

Kubernetes-Based Platform Engineering#

Kubernetes has become the standard execution environment for cloud-native applications. Platform engineering in a Kubernetes context means designing self-service capabilities that leverage Kubernetes’ declarative model, GitOps principles, and cloud-native observability.

Kubernetes as a Platform Foundation#

Kubernetes provides the infrastructure layer, but platform engineering adds the operational and developer-facing layers on top.

┌─────────────────────────────────────────────────────────┐
│ Developer Productivity Layer (IDP) │
│ - Self-service templates, AI-assisted generation │
│ - Guided deployment workflows │
│ - Cost visibility and performance dashboards │
├─────────────────────────────────────────────────────────┤
│ Platform Orchestration Layer │
│ - ArgoCD/Flux (GitOps), Kyverno (Policy), Istio (Mesh) │
│ - Tekton/ArgoWorkflows (in-cluster pipelines) │
│ - Prometheus, Grafana, Jaeger (observability) │
├─────────────────────────────────────────────────────────┤
│ Kubernetes Infrastructure Layer │
│ - Deployments, Services, Ingress, RBAC │
│ - StatefulSets, DaemonSets for stateful workloads │
│ - Network Policies, Pod Security Standards │
│ - Storage: PersistentVolumes, StorageClasses │
└─────────────────────────────────────────────────────────┘

Container-Native CI/CD Architecture#

Traditional CI/CD: External Pipeline → Kubernetes Deploy#

GitHub / GitLab / GitHub Enterprise
 ↓
GitHub Actions / GitLab CI / Jenkins Runner (external VM)
 ↓
Build, test, push image
 ↓
Deploy to Kubernetes (kubectl apply)

Issues:

OpenAI Codex Integration

Mon, 01 Jan 0001 00:00:00 +0000

OpenAI Codex Integration Guide#

This guide covers setting up and using DevOps-OS with OpenAI Codex for code generation and pipeline automation.

What is OpenAI Codex?#

OpenAI Codex is a powerful AI model trained on publicly available code from the internet. It understands dozens of programming languages and can generate, edit, and explain code in context.

Why Use Codex with DevOps-OS?#

Feature	Benefit
Natural language to code	Describe your pipeline in plain English, get YAML/Jenkinsfile back
Code completion	Start a pipeline definition, let Codex finish it
Multi-language support	Generate pipelines for GitHub Actions, Jenkins, GitLab CI, etc.
Context awareness	Understands your existing infrastructure patterns
Integration with your IDE	Use Codex plugins in VS Code, JetBrains, or other editors

Architecture Overview#

┌──────────────────────────────────────┐
│ Developer (IDE or Chat) │
│ "Generate a Python CI/CD pipeline" │
└────────────────┬─────────────────────┘
 │
 ▼
 ┌────────────────────────────┐
 │ OpenAI Codex API │
 │ (davinci-codex model) │
 └────────────────┬───────────┘
 │
 ▼
 ┌────────────────────────────┐
 │ DevOps-OS Skills │
 │ (openai_functions.json) │
 └────────────────┬───────────┘
 │
 ▼
 ┌────────────────────────────┐
 │ Generated Artifacts │
 │ - GitHub Actions YAML │
 │ - Jenkins Declarative │
 │ - Kubernetes manifests │
 │ - ArgoCD configs │
 └────────────────────────────┘

Prerequisites#

OpenAI API Key with access to Codex models
Python 3.10+
pip (Python package manager)
DevOps-OS repository cloned locally

Get Your OpenAI API Key#

Go to OpenAI Platform
Sign up or log in with your OpenAI account
Create a new API key
Copy and save it securely (you won’t be able to view it again)

Installation#

Step 1: Clone and Install DevOps-OS#

git clone https://github.com/cloudengine-labs/devops_os.git
cd devops_os

# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate # macOS/Linux
# .venv\Scripts\activate # Windows

# Install dependencies
pip install -r mcp_server/requirements.txt
pip install openai # For direct API usage

Step 2: Set Your OpenAI API Key#

# macOS/Linux
export OPENAI_API_KEY="sk-your-api-key-here"

# Windows (PowerShell)
$env:OPENAI_API_KEY = "sk-your-api-key-here"

# Or add to your shell profile for persistence:
# ~/.bashrc, ~/.zshrc, or ~/.bash_profile
echo 'export OPENAI_API_KEY="sk-your-api-key-here"' >> ~/.zshrc
source ~/.zshrc

Method 1: Direct API Integration#

Use OpenAI Codex directly with DevOps-OS skill definitions.

ChatGPT Custom GPT Integration

Mon, 01 Jan 0001 00:00:00 +0000

ChatGPT Custom GPT Integration Guide#

This guide covers setting up and using DevOps-OS with ChatGPT and Custom GPTs for pipeline generation and DevOps automation.

What is ChatGPT and Custom GPTs?#

ChatGPT is an advanced AI chatbot that understands natural language and can perform complex tasks. Custom GPTs let you create specialized versions of ChatGPT with custom instructions, knowledge files, and function calling capabilities.

Why Use ChatGPT with DevOps-OS?#

Feature	Benefit
User-friendly UI	No coding required, just chat
Custom GPT	Create a specialized DevOps assistant for your team
Function calling	ChatGPT directly invokes DevOps-OS generators
Knowledge base	Attach your org’s runbooks and best practices
Shareable	Create a GPT once, share with your team
Web search	ChatGPT can research infrastructure patterns for you

Prerequisites#

ChatGPT Plus account (paid subscription required for Custom GPTs)
DevOps-OS repository cloned locally or deployed to a server
Python 3.10+ (for running the HTTP server)
HTTPS endpoint (ChatGPT requires HTTPS, not HTTP)

Get ChatGPT Plus#

Go to ChatGPT
Click “Upgrade to Plus” (bottom left)
Choose your plan ($20/month)
Complete payment

Architecture Overview#

┌──────────────────────────────────────┐
│ ChatGPT (Web or Mobile App) │
│ "Generate a Kubernetes config │
│ for my Node.js microservice" │
└────────────────┬─────────────────────┘
 │ HTTPS request
 ▼
 ┌────────────────────────────────┐
 │ Custom GPT (Your DevOps Bot) │
 │ ┌──────────────────────────┐ │
 │ │ System Instructions │ │
 │ │ - DevOps best practices │ │
 │ │ - Your team's standards │ │
 │ └──────────────────────────┘ │
 └────────────────┬────────────────┘
 │
 ▼
 ┌────────────────────────────────┐
 │ DevOps-OS HTTP Server │
 │ (Running on your infrastructure) │
 │ ┌──────────────────────────┐ │
 │ │ Function Definitions │ │
 │ │ (openai_functions.json) │ │
 │ └──────────────────────────┘ │
 └────────────────┬────────────────┘
 │
 ▼
 ┌────────────────────────────────┐
 │ DevOps-OS Generators │
 │ - Python CLI functions │
 │ - Validation and constraints │
 └────────────────┬────────────────┘
 │
 ▼
 ┌────────────────────────────────┐
 │ Generated Artifacts │
 │ - GitHub Actions YAML │
 │ - Jenkins Declarative │
 │ - Kubernetes manifests │
 │ - ArgoCD configs │
 │ - Prometheus alerts │
 └────────────────────────────────┘

Step 1: Deploy DevOps-OS as HTTP Server#

Your DevOps-OS must be accessible from the internet over HTTPS for ChatGPT to call it.

Cloud-Based Platform Engineering

Mon, 01 Jan 0001 00:00:00 +0000

Cloud-Based Platform Engineering#

Cloud-native platform engineering extends beyond Kubernetes to include managed services, serverless computing, and cloud-specific operational patterns. This document covers multi-cloud strategies, serverless architectures, and financial operations integration.

Multi-Cloud Abstraction Layer#

Challenge: Cloud Lock-in#

Each cloud provider has proprietary services:

AWS: EC2, S3, RDS, Lambda, DynamoDB, Route53
Azure: VMs, Blob Storage, SQL Database, Azure Functions, CosmosDB, Traffic Manager
GCP: Compute Engine, Cloud Storage, Cloud SQL, Cloud Functions, Firestore, Cloud Load Balancing

Organizations want portability without recreating infrastructure for each cloud.

Internal Developer Portal (IDP) Evolution

Mon, 01 Jan 0001 00:00:00 +0000

Internal Developer Portal (IDP) Evolution#

An Internal Developer Platform is a curated set of capabilities that enable development teams to build, deploy, and operate applications with minimal friction. This document covers IDP design patterns, user experience considerations, and platform team operational practices.

What is an Internal Developer Platform?#

Definition#

A self-service platform that abstracts infrastructure complexity while maintaining security, compliance, and organizational standards.

Characteristics#

Self-Service: Developers accomplish tasks without manual platform team intervention
Standardized: Built on proven patterns and configurations
Flexible: Allows customization while maintaining core guardrails
Discoverable: Easy to find capabilities and templates
Observable: Metrics visible to both developers and platform team
Secure: Compliance and security built in, not bolted on
Documented: Runbooks, FAQs, and support channels

Who Builds It#

Platform Team (DevOps, SRE, Infrastructure engineers) designs and maintains the IDP.

Reference Architecture: End-to-End Platform Engineering

Mon, 01 Jan 0001 00:00:00 +0000

Reference Architecture: End-to-End Platform Engineering#

This section presents a complete, production-ready reference architecture showing how all platform engineering components work together to enable self-service deployment at scale.

Architecture Overview#

┌─────────────────────────────────────────────────────────────────────────┐
│ DEVELOPER EXPERIENCE LAYER │
│ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ │
│ │ AI-Assisted │ │ Web Portal │ │ CLI Tools │ │
│ │ (Claude/ChatGPT) │ │ (Template Catalog)│ │ (devops-os) │ │
│ └────────┬─────────┘ └────────┬─────────┘ └────────┬─────────┘ │
│ │ │ │ │
└─────────┼─────────────────────┼─────────────────────┼─────────────────┘
 │ │ │
 └─────────────────────┼─────────────────────┘
 │
┌───────────────────────────────▼──────────────────────────────────────────┐
│ SCAFFOLD & CODE GENERATION LAYER │
│ ┌────────────────────────────────────────────────────────────────────┐ │
│ │ DevOps-OS MCP Server │ │
│ │ ├─ CI/CD Generator (GitHub Actions, GitLab, Jenkins) │ │
│ │ ├─ GitOps Generator (ArgoCD, Flux Kustomization) │ │
│ │ ├─ Kubernetes Generator (Deployment, Service, Ingress, etc.) │ │
│ │ ├─ Terraform Generator (Cloud infrastructure, multi-cloud) │ │
│ │ ├─ SRE Generator (Prometheus, Grafana, SLO) │ │
│ │ ├─ Hardening Generator (Kyverno, InSpec, Checkov policies) │ │
│ │ └─ Dev Container Generator (Pre-configured dev environment) │ │
│ └────────────────────────────────────────────────────────────────────┘ │
│ │ │
└───────────────────────────────▼─────────────────────────────────────────┘
 │
 [Generated Artifacts]
 │
┌───────────────────────────────▼─────────────────────────────────────────┐
│ INFRASTRUCTURE & DEPLOYMENT LAYER │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Git Repositories │ │
│ │ ├─ Application repos (with generated CI/CD) │ │
│ │ ├─ GitOps repo (deployment manifests) │ │
│ │ ├─ IaC repo (Terraform, Cloud configs) │ │
│ │ └─ Platform repo (templates, MCP server) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Kubernetes Cluster (Multi-region) │ │
│ │ ├─ Application Workloads (microservices) │ │
│ │ ├─ GitOps Controller (ArgoCD / Flux) │ │
│ │ ├─ In-Cluster CI/CD (Tekton / ArgoWorkflows) │ │
│ │ ├─ Ingress Controller (routing) │ │
│ │ ├─ Service Mesh (Istio / Linkerd) - optional │ │
│ │ ├─ Policy Engine (Kyverno) │ │
│ │ ├─ Observability Stack (Prometheus, Grafana, Jaeger) │ │
│ │ └─ Sealed Secrets (encrypted credentials) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Cloud Infrastructure (AWS / Azure / GCP) │ │
│ │ ├─ Container Registry (ECR / ACR / GCR) │ │
│ │ ├─ Databases (RDS / Cosmos / Cloud SQL) │ │
│ │ ├─ Serverless Compute (Lambda / Functions) │ │
│ │ ├─ Object Storage (S3 / Blob / Cloud Storage) │ │
│ │ ├─ CDN (CloudFront / Azure CDN / Cloud CDN) │ │
│ │ ├─ Load Balancers & DNS (Route53 / Traffic Manager / Cloud DNS)│ │
│ │ ├─ VPCs & Networking │ │
│ │ └─ IAM & Secrets Management │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────────────┐
│ OBSERVABILITY & GOVERNANCE LAYER │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Monitoring & Alerting │ │
│ │ ├─ Prometheus (metrics collection) │ │
│ │ ├─ Grafana (visualization) │ │
│ │ ├─ AlertManager (alert routing) │ │
│ │ └─ PagerDuty (incident management) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Logging │ │
│ │ ├─ Application logs (ELK / Loki, Datadog, Splunk) │ │
│ │ └─ Audit logs (cluster, cloud provider) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Distributed Tracing │ │
│ │ └─ Jaeger / OpenTelemetry (end-to-end request tracing) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Cost & FinOps │ │
│ │ ├─ Cloud cost APIs (AWS Cost Explorer, Azure CostManagement) │ │
│ │ └─ Cost dashboards (internal or Kubecost, CloudZero) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Compliance & Security │ │
│ │ ├─ Policy audit logs (Kyverno, Falco) │ │
│ │ ├─ Vulnerability scanning (Trivy, Snyk) │ │
│ │ ├─ Compliance dashboards (CIS, STIG, PCI-DSS) │ │
│ │ └─ SIEM integration (Splunk, Datadog, ELK) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────────────┐
│ PLATFORM TEAM & OPERATIONS LAYER │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Platform Team │ │
│ │ ├─ Template authors (design & maintain scaffolds) │ │
│ │ ├─ Tooling engineers (maintain MCP server, portal) │ │
│ │ ├─ SRE/Reliability (platform observability & performance) │ │
│ │ ├─ Security engineers (compliance, hardening policies) │ │
│ │ └─ Support (Slack, runbooks, onboarding) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Platform Governance │ │
│ │ ├─ Template roadmap & versioning strategy │ │
│ │ ├─ Compliance & security policies │ │
│ │ ├─ Cost optimization strategy │ │
│ │ ├─ Multi-cloud strategy (if applicable) │ │
│ │ └─ SLOs for platform services │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────────┘

End-to-End Workflow: “Deploy a Python Microservice”#

Step 1: Developer Initiates#

Developer opens Claude Desktop:
"Generate a Python Flask microservice with PostgreSQL, 
Prometheus monitoring, and canary deployment strategy"

Claude → DevOps-OS MCP Server

Step 2: Scaffold Generation#

MCP Server Generates:
✓ GitHub Actions workflow (.github/workflows/ci-cd.yml)
 ├─ Build step: docker build
 ├─ Test step: pytest
 ├─ Security step: Bandit, Snyk
 ├─ Push step: push to registry
 └─ Deploy step: trigger ArgoCD

✓ Kubernetes manifests (kubernetes/)
 ├─ Deployment (3 replicas, health checks, resource limits)
 ├─ Service (ClusterIP for internal)
 ├─ Ingress (external routing)
 ├─ ConfigMap (application config)
 ├─ Secret (database credentials)
 └─ Flagger Canary (2% → 100% traffic over 10 min)

✓ Terraform modules (terraform/)
 ├─ PostgreSQL RDS instance
 ├─ Security group (restricted access)
 ├─ Secrets Manager (store credentials)
 └─ IAM roles & policies

✓ Prometheus ServiceMonitor (kubernetes/monitoring.yaml)
 └─ Scrape /metrics endpoint

✓ Grafana dashboard (monitoring/dashboard.yaml)
 ├─ Request rate graph
 ├─ Error rate graph
 ├─ Latency percentiles (p50, p95, p99)
 └─ Resource utilization

✓ Dev container (.devcontainer/devcontainer.json)
 ├─ Python 3.11
 ├─ PostgreSQL client
 ├─ Docker CLI
 └─ Pre-installed debug tools

✓ Documentation (docs/DEPLOYMENT.md)
 ├─ Architecture overview
 ├─ How to update configuration
 ├─ How to trigger manual deployment
 ├─ Monitoring dashboard links
 └─ Troubleshooting guide

Step 3: Developer Reviews#

Developer reviews generated files:
✅ GitHub Actions workflow looks good
✅ Kubernetes manifests follow our standards
⚠️ Database instance size seems small for production
 → Asks Claude: "Increase database to m5.large"
 → Claude updates Terraform configs
✅ Everything else looks good

Developer commits to feature branch

Step 4: CI/CD Pipeline Runs#

[Developer pushes to GitHub]
 ↓
GitHub detects commit
 ↓
GitHub Actions workflow triggers:
 ├─ [1] Checkout code
 ├─ [2] Setup Python
 ├─ [3] Install dependencies
 ├─ [4] Run unit tests (pytest)
 │ └─ All 89 tests pass ✅
 ├─ [5] Run linting (black, flake8)
 │ └─ All files pass ✅
 ├─ [6] Security scan (Bandit)
 │ └─ No high-severity issues ✅
 ├─ [7] Build Docker image
 │ └─ Tagged: ghcr.io/myorg/payment-api:sha-a1b2c3d
 ├─ [8] Scan image (Trivy)
 │ └─ No critical vulnerabilities ✅
 ├─ [9] Push to registry
 │ └─ Image pushed ✅
 └─ [10] Trigger ArgoCD deployment
 └─ ArgoCD detects commit to GitOps repo

Step 5: GitOps Synchronization#

[Commit to GitOps repo with new Kubernetes manifests]
 ↓
ArgoCD detects repo change
 ↓
ArgoCD verifies against policies:
 ├─ Kyverno checks manifest security ✅
 ├─ Cost policy checks resource limits ✅
 ├─ RBAC policy checks service account ✅
 └─ All policies pass ✅
 ↓
ArgoCD deploys to staging namespace:
 ├─ [1] Create Deployment (3 replicas)
 ├─ [2] Create Service
 ├─ [3] Create Ingress
 ├─ [4] Create ConfigMap
 ├─ [5] Create Secret (from sealed-secrets)
 ├─ [6] Create ServiceMonitor
 └─ [7] Create Flagger Canary

Step 6: Deployment Validation#

Canary Deployment (via Flagger):
 ├─ [1] v1.0 (old) running with 100% traffic
 ├─ [2] v1.1 (new) starts, receives 2% traffic
 ├─ [3] Smoke tests run
 │ └─ Health check: /health → 200 OK
 │ └─ API test: POST /api/payments → 201 Created
 │ └─ Database test: SELECT 1 → success
 │ └─ All tests pass ✅
 ├─ [4] Shift 10% traffic to v1.1
 ├─ [5] Monitor for 1 minute
 │ └─ Error rate: 0% (vs 0.5% threshold) ✅
 │ └─ Latency p95: 180ms (vs 500ms threshold) ✅
 ├─ [6] Shift 25% traffic to v1.1
 ├─ [7] Monitor for 1 minute ✅
 ├─ [8] Shift 50% traffic to v1.1
 ├─ [9] Monitor for 1 minute ✅
 ├─ [10] Shift 100% traffic to v1.1
 │ └─ v1.0 torn down after grace period
 └─ Deployment complete! 🎉

Step 7: Observability#

Developer checks monitoring:
 ├─ Grafana dashboard shows healthy metrics
 │ ├─ Request rate: 500 req/s ✅
 │ ├─ Error rate: 0% ✅
 │ ├─ P95 latency: 180ms ✅
 │ └─ Database connections: 8/20 ✅
 │
 ├─ Prometheus ServiceMonitor collecting metrics
 │ └─ Updated: 2 seconds ago
 │
 ├─ Application logs in ELK
 │ └─ Latest logs show healthy startup
 │
 ├─ Distributed traces in Jaeger
 │ └─ Request traces show 3 spans (API → DB → cache)
 │
 └─ Cost dashboard shows $12/month for this service

Step 8: Alert Configuration#

PrometheusRule (auto-generated) defines:
 ├─ Alert on error rate > 1%
 │ └─ Sends to Slack #alerts channel
 ├─ Alert on latency p95 > 500ms
 │ └─ Sends to Slack + pages on-call
 ├─ Alert on database connections > 18/20
 │ └─ Sends to Slack (manual scaling needed soon)
 └─ Alert on daily cost > $20
 └─ Sends to team lead for review

Multi-Environment Promotion#

Local Development
 ↓ (git push to feature branch)
Staging Cluster
 ├─ Full CI/CD pipeline runs
 ├─ Canary deployment to staging
 ├─ Smoke tests run
 ├─ Performance tests run
 └─ Manual approval required
 ↓
Production Cluster
 ├─ Same deployment pipeline
 ├─ Canary deployment (even more cautious)
 ├─ Health checks
 └─ Fully promoted after 30 minutes
 ↓
Analytics & Metrics
 └─ Dashboard shows deployment status

Platform Metrics & Health#

Platform Team Dashboard:

Adoption Metrics:
├─ 87% of services using platform templates
├─ 12,453 total scaffold generations
└─ 23 active template versions

Developer Productivity:
├─ Avg time to first deploy: 47 minutes (target: 60 min)
├─ Deployment frequency: 2.3 times per day per team
├─ Change failure rate: 8.2% (target: <15%)
└─ MTTR: 12 minutes (target: <15 min)

Platform Reliability:
├─ MCP server uptime: 99.95%
├─ CI/CD pipeline success rate: 94.2%
├─ Kubernetes cluster health: 99.8%
└─ Canary failure catch rate: 100%

Cost Optimization:
├─ Monthly cloud spend: $45,230
├─ Cost per deployment: $3.62 (target: <$4)
├─ Reserved capacity utilization: 87%
└─ Wasted resources: 1.2% (excellent)

Developer Satisfaction:
├─ NPS score: 42 (promoters: 56%, detractors: 14%)
├─ Template satisfaction: 4.3/5.0 stars
├─ Support response time: 12 min avg
└─ "Would recommend to other teams": 89%

Next Steps#

Want real-world examples? → Case Studies
Need implementation guidance? → Implementation Roadmap
Looking for thought leadership? → Thought Leadership

Version Management

Mon, 01 Jan 0001 00:00:00 +0000

Overview#

DevOps-OS provides a comprehensive version management system for dev containers that allows you to:

Track and manage versions of programming languages and tools via environment variables
Receive security recommendations for outdated or vulnerable versions
Use LTS or latest versions based on your release strategy
Persist version preferences to .env files for team consistency
Update versions programmatically via MCP tools

Environment Variables#

All version configuration uses the DEVOPS_OS_VERSION_ prefix for environment variables. Set these in your shell profile, Docker environment, or .env file.

Case Studies: Platform Engineering in Practice

Mon, 01 Jan 0001 00:00:00 +0000

Case Studies: Platform Engineering in Practice#

These case studies show how different organization types implement platform engineering concepts, adapted to their constraints and goals.

Case Study 1: Startup (50 developers, 2 DevOps engineers)#

Situation#

Moving from single monolith to microservices
2 DevOps engineers supporting 50 developers
Need rapid onboarding without hiring
Limited budget for infrastructure

Platform Strategy: “Minimal Viable Platform”#

Focus: Self-service for common patterns, not comprehensive

Approach:

Template Catalog (5 templates only):
├─ Python FastAPI + PostgreSQL
├─ Node.js Express + MongoDB
├─ Go gRPC service
├─ Frontend (React + S3 + CloudFront)
└─ Batch job (scheduled Lambda)

Implementation:

Thought Leadership: Platform Engineering Resources & Insights

Mon, 01 Jan 0001 00:00:00 +0000

Thought Leadership: Platform Engineering Resources & Insights#

This document curates insights from industry leaders, research organizations, and practitioners who are shaping the platform engineering discipline.

Core Platform Engineering Resources#

CNCF TAG App Delivery#

Resource: CNCF TAG App Delivery - Platform Engineering

Key Insights:

Platform engineering is a formal discipline recognized by CNCF
IDPs reduce cognitive load on developers
Golden paths encode organizational best practices
Platforms should be measured like internal products

DevOps-OS Alignment:

Implementation Roadmap: Building Your Platform Engineering Practice

Mon, 01 Jan 0001 00:00:00 +0000

Implementation Roadmap: Building Your Platform Engineering Practice#

This roadmap provides a phased approach to implementing platform engineering, starting from day one through mature platform operations.

Phase Overview#

Phase 1: Foundation (Weeks 1-8)
├─ Team formation
├─ Identify initial pain points
├─ Create 3-5 core templates
└─ Validation: Team using templates

Phase 2: Scaling (Weeks 9-20)
├─ Expand template catalog
├─ Build basic IDP (CLI or portal)
├─ Establish governance
└─ Validation: 50%+ services using platform

Phase 3: Operationalization (Weeks 21-36)
├─ Full IDP UI
├─ AI-assisted interface (MCP)
├─ Advanced observability
└─ Validation: 80%+ adoption, high satisfaction

Phase 4: Optimization (Months 10-18)
├─ Cost optimization programs
├─ Advanced compliance/multi-cloud
├─ Platform as a product model
└─ Validation: Measurable business impact

Phase 1: Foundation (Weeks 1-8)#

Goal#

Prove value with minimal templates, establish team practices and governance.

MCP Dev Container Setup

Mon, 01 Jan 0001 00:00:00 +0000

MCP Dev Container Module#

The DevOps-OS MCP Dev Container module enables AI assistants (Claude, ChatGPT, Cursor, etc.) to generate production-ready development container configurations through natural language prompts.

Overview#

The MCP Dev Container module provides an intelligent API for creating customized dev container configurations that include:

Multi-language support: Python, Java, Go, Node.js, Rust, Ruby, C/C++, PHP, C#, Kotlin, and more
CI/CD tool integration: Docker, Podman, GitHub Actions, Jenkins, GitLab CI, Terraform, Kubectl, Helm
Kubernetes utilities: K9s, Kustomize, ArgoCD, Flux, KinD, Minikube, OpenShift CLI
Build systems: Maven, Gradle, Make, CMake, Ant
Code analysis tools: SonarQube, ESLint, Pylint, Checkstyle, PMD
DevOps platforms: Prometheus, Grafana, ELK Stack, Nexus Repository
Automatic VS Code extension recommendations based on selected tools
Port forwarding setup for services like Grafana, Prometheus, Jenkins, etc.

Using with AI Assistants#

Claude Desktop#

Configure your Claude Desktop to use the DevOps-OS MCP server:

Language-Specific Setup Guides

Mon, 01 Jan 0001 00:00:00 +0000

Language-Specific Dev Container Guides#

Comprehensive setup guides for each supported programming language in the DevOps-OS dev container.

Python#

Quick Start#

python -m devops_os.core.scaffold_devcontainer \
 --languages python \
 --python-version 3.12 \
 --build-tools make \
 --code-analysis-tools pylint,sonarqube

Recommended Configuration#

{
 "languages": {
 "python": true
 },
 "cicd": {
 "docker": true,
 "github_actions": true
 },
 "build_tools": {
 "make": true
 },
 "code_analysis": {
 "pylint": true,
 "sonarqube": true
 }
}

Included Tools#

Runtime: Python 3.12 (configurable)
Package Manager: pip, poetry (optional)
Testing: pytest with coverage
Linting: pylint, black, isort
IDE: VS Code with Python extension, Pylance

Common Workflows#

# Create a FastAPI + async development environment
python -m devops_os.core.scaffold_devcontainer \
 --languages python \
 --cicd-tools docker,github_actions \
 --code-analysis-tools pylint \
 --build-tools make

# Data science with Python
python -m devops_os.core.scaffold_devcontainer \
 --languages python \
 --python-version 3.12 \
 --build-tools make

JavaScript / Node.js#

Quick Start#

python -m devops_os.core.scaffold_devcontainer \
 --languages javascript,node \
 --node-version 22 \
 --build-tools make \
 --code-analysis-tools eslint

Recommended Configuration#

{
 "languages": {
 "javascript": true,
 "node": true,
 "typescript": true
 },
 "cicd": {
 "docker": true,
 "github_actions": true
 },
 "code_analysis": {
 "eslint": true
 }
}

Included Tools#

Runtime: Node.js 22 (configurable)
Package Manager: npm, yarn
Testing: Jest, Mocha, Vitest
Linting: ESLint, Prettier
IDE: VS Code with ESLint, Prettier extensions

Common Workflows#

# React + TypeScript development
python -m devops_os.core.scaffold_devcontainer \
 --languages javascript,typescript,node \
 --cicd-tools docker,github_actions \
 --code-analysis-tools eslint

# Full-stack application (Node.js + React)
python -m devops_os.core.scaffold_devcontainer \
 --languages javascript,typescript,node \
 --cicd-tools docker,github_actions,terraform \
 --kubernetes-tools kubectl,helm,k9s

Go#

Quick Start#

python -m devops_os.core.scaffold_devcontainer \
 --languages go \
 --go-version 1.25.0 \
 --cicd-tools docker,github_actions

Recommended Configuration#

{
 "languages": {
 "go": true
 },
 "cicd": {
 "docker": true,
 "github_actions": true,
 "terraform": true
 },
 "kubernetes": {
 "kubectl": true,
 "helm": true
 }
}

Included Tools#

Runtime: Go 1.25.0 (configurable)
Package Manager: Go modules
Testing: go test, testify
Build: go build, goreleaser
IDE: VS Code with Go extension, delve debugger

Common Workflows#

# Microservice development with Kubernetes
python -m devops_os.core.scaffold_devcontainer \
 --languages go \
 --cicd-tools docker,terraform,kubectl,helm \
 --kubernetes-tools k9s,kustomize,argocd_cli

# CLI tool development
python -m devops_os.core.scaffold_devcontainer \
 --languages go \
 --cicd-tools docker,github_actions

Java#

Quick Start#

python -m devops_os.core.scaffold_devcontainer \
 --languages java \
 --java-version 21 \
 --build-tools maven,gradle

Recommended Configuration#

{
 "languages": {
 "java": true
 },
 "cicd": {
 "docker": true,
 "jenkins": true,
 "github_actions": true
 },
 "build_tools": {
 "maven": true,
 "gradle": true
 }
}

Included Tools#

Runtime: OpenJDK 21 (configurable)
Build: Maven 3.9+, Gradle 8.4+
Testing: JUnit 5, Testcontainers
IDE: VS Code with Java Pack, Maven, Gradle extensions
Debugging: Remote debugging support

Common Workflows#

# Spring Boot microservice
python -m devops_os.core.scaffold_devcontainer \
 --languages java \
 --java-version 21 \
 --build-tools maven \
 --cicd-tools docker,github_actions,kubernetes

# Enterprise application with Jenkins
python -m devops_os.core.scaffold_devcontainer \
 --languages java \
 --java-version 21 \
 --build-tools gradle \
 --cicd-tools docker,jenkins

Rust#

Quick Start#

python -m devops_os.core.scaffold_devcontainer \
 --languages rust \
 --rust-version latest

Recommended Configuration#

{
 "languages": {
 "rust": true
 },
 "cicd": {
 "docker": true,
 "github_actions": true
 }
}

Included Tools#

Runtime: Rust (latest toolchain)
Package Manager: Cargo
Testing: cargo test
Toolchain: rustup, cargo-fmt, cargo-clippy
IDE: VS Code with rust-analyzer

Common Workflows#

# System programming with Kubernetes integration
python -m devops_os.core.scaffold_devcontainer \
 --languages rust \
 --cicd-tools docker,github_actions \
 --kubernetes-tools kubectl,helm

# CLI tool development
python -m devops_os.core.scaffold_devcontainer \
 --languages rust \
 --cicd-tools docker,github_actions

Ruby#

Quick Start#

python -m devops_os.core.scaffold_devcontainer \
 --languages ruby \
 --ruby-version 3.3

Recommended Configuration#

{
 "languages": {
 "ruby": true
 },
 "cicd": {
 "docker": true,
 "github_actions": true
 }
}

Included Tools#

Runtime: Ruby 3.3 (configurable)
Package Manager: Bundler, RubyGems
Testing: RSpec, Minitest
Web Frameworks: Rails, Sinatra, Hanami
IDE: VS Code with Ruby extension

C / C++#

Quick Start#

python -m devops_os.core.scaffold_devcontainer \
 --languages c,cpp \
 --build-tools cmake,make

Recommended Configuration#

{
 "languages": {
 "c": true,
 "cpp": true
 },
 "build_tools": {
 "cmake": true,
 "make": true
 },
 "cicd": {
 "docker": true,
 "github_actions": true
 }
}

Included Tools#

Compilers: GCC, Clang
Build: CMake, Make
Testing: Google Test (GTest), Catch2
Debugging: GDB, LLDB
IDE: VS Code with C++ Tools, CMake Tools

Common Workflows#

# System programming with containers
python -m devops_os.core.scaffold_devcontainer \
 --languages c,cpp \
 --build-tools cmake \
 --cicd-tools docker,github_actions

# Embedded systems development
python -m devops_os.core.scaffold_devcontainer \
 --languages c \
 --build-tools cmake,make

Multi-Language Projects#

Full-Stack Application (Backend + Frontend)#

# Python backend + React frontend
python -m devops_os.core.scaffold_devcontainer \
 --languages python,javascript,typescript,node \
 --cicd-tools docker,github_actions,terraform \
 --kubernetes-tools kubectl,helm,k9s \
 --devops-tools prometheus,grafana

Microservices Architecture#

# Go services + Python automation + TypeScript admin dashboard
python -m devops_os.core.scaffold_devcontainer \
 --languages go,python,typescript,node \
 --cicd-tools docker,terraform,kubectl,helm \
 --kubernetes-tools k9s,kustomize,argocd_cli,flux \
 --devops-tools prometheus,grafana,elk

Legacy System Modernization#

# Java legacy + Go new services + Python scripts
python -m devops_os.core.scaffold_devcontainer \
 --languages java,go,python \
 --build-tools maven,gradle,make \
 --cicd-tools docker,jenkins,github_actions \
 --kubernetes-tools kubectl,helm

Environment Variables#

All configuration can be set via environment variables for CI/CD integration:

DevOps-OS

Beginner's Guide: Understanding DevOps-OS MCP

🎓 Beginner’s Guide: Understanding DevOps-OS MCP#

What Is DevOps-OS MCP? (Plain English)#

Chennai FOSS 2026

Chennai FOSS 2026 Presentation#

Easy Getting Started

🚀 Easy Getting Started — Just Copy & Paste#

Process-First Philosophy

Process-First Philosophy#

Thought Leaders on Process-First & Systems Thinking#

MCP Quick Start

MCP Quick Start — 5 Minutes#

What You’ll Do#

Step 1: Clone & Install (1 minute)#

Step 2: Configure Claude Desktop (2 minutes)#

Find Your DevOps-OS Path#

Open Claude Config File#

Process-First Mapping: From DevOps Tools to Platform Engineering

Process-First Mapping: From DevOps Tools to Platform Engineering#

The Process-First SDLC#

PLAN Phase 🎯#

Infrastructure Hardening

Infrastructure Hardening#

What it generates#

Supported standards#

Standard descriptions#

CIS Kubernetes Benchmark v1.9 (cis-k8s)#

MCP Setup & Configuration

MCP Setup & Configuration Guide#

What is MCP?#

Pipeline Templatization Fundamentals

Pipeline Templatization Fundamentals#

Template vs. Bespoke Pipeline#

Reusable Template#

Bespoke Pipeline#

GitHub Actions

GitHub Actions Workflow Generator#

Basic Usage#

Options#

Workflow Types#

Examples#

Python application — complete pipeline#

Java with Maven#

Multi-language microservices with Kubernetes#

Matrix build (cross-platform)#

Reusable workflow#

Environment Variables#

GitLab CI

GitLab CI Pipeline Generator#

Basic Usage#

Options#

Jenkins

Jenkins Pipeline Generator#

Basic Usage#

Options#

Environment Variables Reference

DevOps-OS MCP: Environment Variables Reference#

Quick Reference#

Transport & Server Configuration#

DEVOPS_OS_TRANSPORT#

Kubernetes-Based Platform Engineering

Kubernetes-Based Platform Engineering#

Kubernetes as a Platform Foundation#

Container-Native CI/CD Architecture#

Traditional CI/CD: External Pipeline → Kubernetes Deploy#

OpenAI Codex Integration

OpenAI Codex Integration Guide#

What is OpenAI Codex?#

Why Use Codex with DevOps-OS?#

Architecture Overview#

Prerequisites#

Get Your OpenAI API Key#

Installation#

Step 1: Clone and Install DevOps-OS#

Step 2: Set Your OpenAI API Key#

Method 1: Direct API Integration#

ChatGPT Custom GPT Integration

ChatGPT Custom GPT Integration Guide#

What is ChatGPT and Custom GPTs?#

CIS Kubernetes Benchmark v1.9 (`cis-k8s`)#

`DEVOPS_OS_TRANSPORT`#