DevOps Tools

Fill in a form to generate a complete Kubernetes Deployment manifest, with env vars, resources, probes, and rolling updates.

Generate a Kubernetes Service manifest for ClusterIP, NodePort, LoadBalancer, or headless service types.

Generate a Kubernetes Ingress manifest with host/path routing rules, TLS, and common controller annotations.

Generate a Kubernetes ConfigMap manifest from key/value pairs or a single file's contents.

Generate a Kubernetes Secret manifest (Opaque, TLS, or Docker config) from plain-text key/value entries.

Generate a Kubernetes HorizontalPodAutoscaler (autoscaling/v2) manifest targeting a Deployment by CPU and/or memory utilization.

Generate a Kubernetes PodDisruptionBudget manifest with either minAvailable or maxUnavailable, as a count or percentage.

Generate a Kubernetes ResourceQuota manifest capping a namespace's compute requests/limits and object counts.

Generate a Kubernetes Namespace manifest with repeatable labels and annotations.

Generate a raw, standalone Kubernetes Pod manifest with a custom command, ports, env vars, and restart policy.

Build a Kubernetes PersistentVolume manifest with hostPath or NFS storage, access modes, and a reclaim policy.

Build a Kubernetes PersistentVolumeClaim manifest with access modes, storage size, storage class, and an optional selector.

Build a Kubernetes StatefulSet manifest with a headless service name, replicas, a volumeClaimTemplate, and a pod management policy.

Build a Kubernetes DaemonSet manifest with env vars, a node selector, tolerations, and an update strategy.

Build a Kubernetes Job manifest with a command, parallelism, completions, backoff limit, and a restart policy.

Build a Kubernetes CronJob manifest with a cron schedule, concurrency policy, and history/deadline limits.

Build a Kubernetes NetworkPolicy manifest with pod/namespace selectors, IP block rules, and separate ingress/egress rules.

Build a Kubernetes Role or ClusterRole with rules, plus its matching RoleBinding or ClusterRoleBinding.

Build a starter Helm values.yaml with image, service, ingress, resources, env vars, and a secrets placeholder block.

Build a kustomization.yaml with a resources list, optional bases, commonLabels, a namespace override, and a configMapGenerator.

Generate a Kubernetes ServiceAccount manifest with labels, annotations, token automounting, and image pull secrets.

Build a multi-service docker-compose.yml from a form: ports, volumes, env vars, healthchecks, and resource limits.

Generate a single-stage Dockerfile from a language preset: WORKDIR, install steps, EXPOSE, non-root user, and CMD.

Generate a two-stage Dockerfile: a build stage with your toolchain and a minimal runtime stage that copies only the build output.

Generate a .dockerignore file from a stack preset so node_modules, .git, .env, and build artifacts never reach your build context.

Generate a docker stack deploy YAML with replicas, rolling update_config, placement constraints, an overlay network, and secrets.

Generate a Compose/Swarm secrets block (file-based or external), a service reference, and a BuildKit --secret build snippet.

Generate a matching Dockerfile HEALTHCHECK directive and Compose healthcheck block from a curl, script, or TCP test.

Generate standard org.opencontainers.image.* LABEL lines plus custom labels, as both Dockerfile and Compose syntax.

Build a .gitlab-ci.yml with stages, jobs, caching, artifacts and branch rules, no YAML by hand.

Build a declarative Jenkinsfile with an agent, stages, environment variables and a post block.

Build a .circleci/config.yml with a Docker executor, jobs, a workflow, and optional orbs.

Build an azure-pipelines.yml with triggers, a pool, stages, variables and common tasks.

Build a bitbucket-pipelines.yml with default steps, branch pipelines, caches and a PR pipeline.

Build a Buildkite pipeline.yml with steps, agent targeting, a wait step and manual approval.

Build a .drone.yml Docker pipeline with steps, volumes, and from_secret references.

Build a .travis.yml with a language/version matrix, install/script steps, stages and deploy.

Generate a starter main.tf with a provider block, one resource, a variable, and an output for AWS, Azure, or Google Cloud.

Generate a reusable Terraform module's file set: main.tf, variables.tf, outputs.tf, and a README usage snippet.

Generate a variables.tf file with typed variable blocks, defaults, descriptions, sensitivity, and validation rules.

Generate a terraform.tfvars file with correctly formatted string, number, bool, list, and map values.

Generate an outputs.tf file with repeatable output blocks: name, value expression, description, and a sensitive toggle.

Generate a Terraform backend block for S3 with DynamoDB locking, GCS, Kubernetes, or Postgres remote state.

Generate a basic Pulumi program skeleton in TypeScript, Python, Go, C#, or YAML for AWS, Azure, or GCP.

Generate a playbook.yml with a hosts group, vars, repeatable tasks (apt/copy/service/template), and a wired-up restart handler.

Generate a Chef recipe.rb with repeatable package/service/template/file resources and node attribute references.

Generate a Puppet .pp manifest: a class wrapping repeatable package/service/file resources, variables, and an if/else example.

Build a valid AWS IAM policy JSON document from Allow/Deny statements without hand-writing the JSON.

Generate an EC2 instance's user data as a bash script or cloud-init YAML, with packages, a user, and hostname.

Generate an S3 bucket policy JSON with HTTPS enforcement, KMS encryption enforcement, and a custom access statement.

Build EC2 security group ingress/egress rules as JSON, with one-click presets for SSH, HTTP, HTTPS, Postgres, and MySQL.

Generate a starter CloudFormation template with Parameters, one Resource block, and Outputs, in YAML or JSON.

Generate an ECS task definition JSON with one or more containers, port mappings, env vars, and awslogs logging.

Generate a Lambda function configuration template with handler, runtime, memory/timeout, env vars, VPC, and DLQ settings.

Build a prometheus.yml with global intervals, repeatable scrape configs, alerting, and remote_write.

Build a Grafana dashboard JSON model from a form: panels, PromQL queries, grid layout, and a templating variable.

Build an alertmanager.yml with routing, repeatable Slack/PagerDuty/email/Teams receivers, and inhibit rules.

Build a Loki config YAML with auth, a filesystem/S3/GCS storage backend, and ingestion/retention limits.

Build a Grafana Tempo config YAML with an OTLP/Jaeger/Zipkin receiver, a storage backend, and metrics-generator.

Build an otel-collector-config.yaml with OTLP receivers, batch/memory_limiter processors, and a wired pipeline.

Build a fluent.conf with a source, record_transformer filter, and elasticsearch/loki/kafka/s3 output.

Build a fluent-bit.conf with SERVICE, INPUT, FILTER, and OUTPUT sections, plus optional TLS.

Build a logstash.conf with input {}, filter {} (grok + mutate), and output {} blocks.

Build a vector.toml with a source, a VRL remap transform, and an elasticsearch/loki/console sink.

Generate a postgresql.conf with key connection, memory, and logging settings plus a matching pg_hba.conf.

Generate the [mysqld] section of my.cnf: server-id, buffer pool, connections, charset, and binary logging.

Generate a mongod.conf YAML file: networking, authorization, WiredTiger cache, replication, and logging.

Generate a redis.conf: networking, maxmemory + eviction policy, RDB/AOF persistence, and ACL user lines.

Generate rabbitmq.conf, a matching definitions.json, and commented clustering hints from one form.

Generate server.properties with core broker settings, toggling between KRaft mode and legacy ZooKeeper mode.

Build a valid package.json with scripts, dependencies, and engine constraints filled in through a form.

Generate a tsconfig.json tuned for a React app, Node backend, or publishable library.

Generate an ESLint 9 flat config for React, Node, or TypeScript with plugins and rule overrides.

Generate a .prettierrc and matching .prettierignore from printWidth, quotes, semicolons, and trailing commas.

Generate a babel.config.js with preset-env browserslist targets, preset-react, preset-typescript, and plugins.

Generate a vite.config.ts with a framework plugin, path aliases, dev-server proxy rules, and build options.

Generate a webpack.config.js with entry/output, mode, babel-loader/css-loader rules, devServer, and plugins.

Generate a rollup.config.js with ESM + CJS output, externals, and typescript/node-resolve/commonjs plugins.

Generate Husky v9 .husky/pre-commit and .husky/commit-msg scripts plus the package.json prepare line.

Generate a commitlint.config.js extending @commitlint/config-conventional with custom type/scope enums.

Generate a lint-staged config mapping glob patterns to command arrays, as .lintstagedrc.json or a package.json block.

Generate a .editorconfig file with per-glob indent style, indent size, charset, line endings, and whitespace rules.

Generate a jest.config.js or vitest.config.ts with test environment, coverage, setup files, and path aliases.

Combine Node, Python, Java, .NET, Go, Rust, React/Next.js and IDE presets into one .gitignore.

Build a GitHub Actions workflow with triggers, a job, a matrix strategy and permissions.

Generate a pre-commit, commit-msg or pre-push hook script for native Git or Husky v9.

Build a properly formatted Conventional Commits message from type, scope, subject and body.

Check a pasted commit message against the Conventional Commits spec and list every issue found.

Paste commit messages or PR titles and group them into a Markdown release notes document.

Generate a tailwind.config.ts with content globs, theme colors/fonts, dark mode, and official plugins.

Generate a next.config.mjs with reactStrictMode, image remote patterns, security headers, redirects, and rewrites.

Generate a .env file with the correct CRA/Vite/Next.js prefix, plus a matching Zod validation schema.

Generate an angular.json build target snippet with outputPath, size budgets, environment file replacement, and a serve proxy.

Generate a svelte.config.js with the right adapter (node/vercel/static) and a matching CSP example for that host.

Generate the right Vue config for your version: vite.config.ts (Vue 3) or vue.config.js (Vue 2), with aliases and proxy.

Generate a .env file for an OpenAI app plus a matching Python or Node.js client-init snippet.

Generate a LangChain RunnableConfig with tags, callbacks, a tools list, retries, and a timeout.

Generate a docker-compose.yml for a local Ollama service, with an optional NVIDIA GPU reservation.

Generate an mcpServers JSON block for a stdio-based Model Context Protocol server.

Generate a Hugging Face .env plus a local transformers pipeline or Inference Endpoint snippet.

Generate connection/setup code for Pinecone, Qdrant, Chroma, or pgvector, each with its own real fields.

Build a .env or .env.example file from key/value rows, grouped into sections, with framework-aware notes.

Paste .env text and get a report of duplicate keys, missing '=', unquoted spaces, empty values, and stringly-typed booleans/numbers.

Generate an AES-256 key and IV for one secret env var, with matching openssl, Node, and PowerShell decrypt commands.

Generate AWS Secrets Manager CLI commands, Kubernetes External Secrets YAML, or Vault kv commands for one named secret.

Build a Cloudflare Pages _headers file from repeatable path-pattern and header rows.

Build a Cloudflare Pages _redirects file from repeatable from/to/status rows, an SPA fallback, and a domain redirect.

Build a wrangler.toml with name, entry point, routes, KV/D1 bindings, and a [vars] block.

Generate a Cloudflare Pages _headers snippet with HSTS, CSP, Referrer-Policy, and more, with sensible defaults.

Generate Cache-Control _headers rules per asset type: static assets, HTML, API JSON, images, and fonts.

Generate a robots.txt for a production Cloudflare Pages domain (allow + sitemap) or a pages.dev staging subdomain (disallow all).

Build a Content-Security-Policy header string for Cloudflare Pages, with toggles for common sources and a report-only mode.

Describe your Cloudflare Pages setup and get a checklist report flagging missing pieces and common misconfigurations.

Generate the combined robots.txt + _headers + _redirects to stop a pages.dev staging subdomain from being indexed.

Enter your production domain and pages.dev project name to get a duplicate-content risk report and the exact fixes.

Paste your robots.txt, classify AI vs search crawlers, and get a suggested allow/block policy plus an llms.txt skeleton.

Generate an Nginx server block with an upstream pool, WebSocket, gRPC, and caching toggles.

Generate the Certbot install and certonly commands for Nginx or Apache.

Generate Certbot's renewal systemd timer and an equivalent cron entry.

Generate a TCP or HTTP load balancer config for Nginx, HAProxy, or a Kubernetes LoadBalancer Service.

Generate a rate limiting config for Nginx (limit_req), HAProxy (stick-table), or Traefik (ratelimit).

Generate an Apache VirtualHost with ServerName, DocumentRoot, an SSL toggle, and ProxyPass.

Generate a Caddyfile with automatic HTTPS, a reverse_proxy target, file_server, and headers.

Generate an haproxy.cfg with global/defaults, a Host-header ACL frontend, and a balanced backend.

Generate a Traefik static config (entryPoints + provider) or a dynamic routers/services YAML.

Generate a systemd unit file with Restart policy, sandboxing (ProtectSystem/NoNewPrivileges/PrivateTmp), and WantedBy.

Build a cron schedule line from minute/hour/day/month/weekday fields, with common presets, flock locking, and log redirection.

Generate a Bash script skeleton with set -euo pipefail, an error/cleanup trap, getopts argument parsing, and a logging function.

Generate a portable /bin/sh script skeleton with set -eu and getopts, avoiding bashisms so it runs on Alpine/BusyBox ash and dash.

Paste a 5-field cron expression and get a plain-English description of when it runs.