Sysadmin

Generate NTP configs for chrony, ntpd, systemd-timesyncd, and Cisco devices with source parsing, client-access checks, and fallback warnings.

Generate reviewed .env and .env.example files from pasted rows or a small text file, with duplicate checks, quote guidance, and masked secret previews.

Build an Apache .htaccess draft for redirects, headers, caching, CORS, and access rules with warnings and copy-ready output before staging.

Generate a static Ansible INI inventory from host rows, group variables, and parent groups with review warnings before playbook use.

Generate an Apache vhost draft for static, PHP-FPM, or reverse-proxy sites, with TLS choices, module checks, and activation steps.

Generate BGP prefix-list config from CIDR rows with Cisco, Arista, FRR, SONiC, and Junos syntax, normalization, and shadowing checks.

Plan backup repository capacity from data size, retention, change rate, copy tiers, reserves, raw overhead, and budget runway checks.

Estimate backup restore time from logical size, compression, tested throughput, fixed recovery phases, and RTO margin checks.

Plan backup rotation storage from full and incremental sizes, with GFS tiers, dedupe assumptions, retention horizon, and audit notes.

Build a capacity upgrade brief from service utilization, growth, threshold timing, lead time, and ranked options with charts and approval notes.

Estimate Ceph usable capacity from node sizes, replica or erasure-code protection, failure-domain reserve, nearfull policy, and PG hints.

Generate Cisco IPv4 ACL commands from flow rows, with wildcard conversion, sequence planning, expansion checks, and safety review tables.

Generate Cisco interface config for routed, access, or trunk ports, with VLAN validation, syntax profiles, command audit, and copy-ready CLI.

Audit cloud inventory tags, find resources missing required keys or allowed values, and export coverage, gap ledgers, charts, and cleanup queues.

Build cloud-init version 2 network YAML for static VM NICs, with CIDR, routes, DNS, MAC matching, and validation warnings before boot.

Compare intended and observed configuration text, classify changed, missing, extra, ignored, and priority drift, and export a remediation ledger.

Estimate container image pull time from size, cache coverage, bandwidth, pull lanes, unpack speed, retries, and rollout optimization levers.

Build user or system crontab lines from presets, pasted entries, or manual fields with syntax warnings, install notes, and exports.

Plan a DHCP scope from subnet, pool, exclusions, reservations, growth, lease time, and utilization headroom before clients run short.

Look up DNS records for a domain, host, or IP with Google or Cloudflare DoH, TTL charts, DNSSEC flags, raw responses, and JSON exports.

Build a disaster recovery runbook from RTO, RPO, owners, dependencies, recovery steps, validation checks, and readiness gates for review.

Check a Docker Compose file for missing or weak healthchecks, readiness-gate blockers, restart gaps, and role-based coverage before release.

Turn one representative log line into a Filebeat-ready Grok pattern with ECS field mapping, sample-match checks, and optional ingest pipeline JSON.

Estimate GlusterFS usable capacity from brick sizes, replica or dispersed layout, arbiter sizing, stranded space, and recovery headroom.

Check HA pair role rows for active/standby drift, stale sync, heartbeat failures, VIP mismatches, and priority conflicts before failover.

Audit hostname inventories for DNS-safe labels, naming regex drift, lowercase rules, required suffixes, duplicates, and JSON-ready cleanup notes.

Convert IOPS, throughput, and daily data volume from block size and active hours, then compare reserve-adjusted ceilings and cloud disk fit.

Plan IPv4 subnet allocations from a parent CIDR, size each host request, and catch alignment gaps, fit issues, and headroom before rollout.

Plan IPv4 renumbering waves from host mappings, prefix boundaries, DNS TTL, and DHCP lease timing with readiness checks and rollback runbooks.

Plan IPv4 child subnets from a parent CIDR, size VLSM blocks from host demand, and check headroom, gaps, gateways, and overflow.

Normalize one IPv6 address into compressed and expanded forms, with prefix, zone, dotted IPv4 tail, hextet, binary, and reverse-DNS checks.

Calculate an IPv6 subnet from any address or CIDR, then review the canonical range, child-prefix capacity, reverse-DNS alignment, and EUI-64 samples.

Turn incident action rows into a review ledger with owners, due-date states, blocker checks, missing-field warnings, and workload charts.

Calculate an IPv4 CIDR block from an address or mask, then check usable hosts, wildcard masks, split fit, and special-use warnings.

Split an IPv4 parent block into equal child CIDR ranges, compare usable hosts and gateway slots, and catch large-ledger or special-use warnings.

Plan Kafka topic partitions from throughput, event rate, consumer parallelism, replication footprint, broker balance, and keying warnings.

Generate a Keepalived VRRP config with VIP rows, unicast or multicast peer settings, health tracking, directive audits, and failover timing.

Plan a Kubernetes replica ceiling from node allocatable resources, pod requests, surge, PDB, failure drills, zone loss, and pod IP limits.

Generate Kubernetes Deployment YAML with Service routing, probes, resources, security settings, rollout policy, and HPA or PDB review warnings.

Check Kubernetes manifests for API versions removed by a target release, with blocker counts, migration queues, and replacement cues.

Analyze Kubernetes event output in your browser, grouping Warning reasons, object hot spots, repeat counts, and timeline bursts from kubectl text or JSON.

Build Kubernetes NetworkPolicy YAML from pod labels and allow rows, with peer syntax checks, rollout commands, review warnings, and a flow map.

Check Kubernetes workload YAML for risky securityContext settings, inherited pod defaults, Pod Security gaps, and remediation patch cues.

Check Kubernetes manifests for missing CPU, memory, and ephemeral-storage requests, limit mismatches, QoS clues, and scheduler footprint gaps.

Check Kubernetes version skew before a minor upgrade, including API server HA windows, node lag, kubectl fit, staged hops, and blockers.

Check maintenance schedules for overlapping windows, blackout hits, owner or dependency collisions, and concurrency spikes in review-ready ledgers.

Build Netplan YAML for Ubuntu static interfaces with CIDR addresses, DNS, routes, MAC matching, MTU checks, and review warnings.

Plan a network change with readiness gates, rollback evidence, run order, residual risk, and a cutover profile reviewers can scan.

Estimate network throughput and transfer time from link speed, RTT, packet loss, TCP windows, streams, and packet-rate limits with bottleneck checks.

Generate an NGINX server block for static, PHP-FPM, or proxy sites with TLS redirects, upstream checks, HSTS cues, and deploy notes.

Generate an OpenVPN client profile from endpoint, route, TLS, cipher, and certificate choices, then review import blockers and security warnings.

Generate PXELINUX, iPXE, and GRUB boot menus from boot rows, with default-entry checks, fallbacks, validation notes, and JSON output.

Plan a PoE switch budget from device rows, port count, reserve policy, cable loss, IEEE ceilings, surge checks, and priority shedding.

Plan Prometheus retention storage from active series or samples/sec, including WAL/head reserve, disk headroom, and retention.size guidance.

Generate Prometheus scrape YAML from targets, labels, timing, and limits, then check grouping, overrides, and audit warnings before reload.

Build a Bash PS1 prompt from ordered tokens, ANSI styling, imported strings, previews, warnings, and setup notes for shell testing.

Check proxy and CDN header evidence from pasted logs or the current request, trace trusted hops, and flag spoofed client-IP risks.

Build FreeRADIUS client stanzas from NAS CSV rows, with secret checks, address-scope warnings, hardening choices, and review output.

Estimate RADIUS requests per second from access, accounting, retries, and failover assumptions, then compare active-pool headroom.

Plan RAID usable capacity from drive count, drive size, layout, hot spares, overhead, and reserve with target-fit and sizing-path checks.

Estimate RAID IOPS and throughput from drive benchmarks, read-write mix, write locality, rebuild reserve, controller caps, and degraded targets.

Plan a RAID layout with plannable capacity, workload headroom, rebuild exposure, URE pressure, growth runway, charts, and JSON reports.

Estimate RAID MTTDL from AFR, rebuild time, URE rate, spares, correlation, and fleet size with loss probabilities and mitigation checks.

Plan RAID and RAID-Z usable capacity from layout, drive size, hot spares, fill headroom, chassis bays, and rebuild-risk assumptions.

Model rack power density from device watts, feed limits, growth, and power factor with failover headroom, heat load, and W/U cues.

Size Redis maxmemory and host RAM from key counts, value sizes, TTL overhead, replicas, buffers, RSS headroom, and shard-fit warnings.

Calculate RAID usable capacity from disk sizes, layout, spares, overhead, and reserves, with failure tolerance and rebuild-risk checks.

Estimate replication backlog catch-up time from write rate, outage duration, usable capacity, compression, target windows, and headroom warnings.

Calculate SLA availability from downtime, maintenance treatment, and elapsed window, then see remaining budget, burn rate, and breach risk.

Calculate SSD endurance from DWPD or TBW, compare workload writes with reserve and derating, and use SMART wear clues to time replacement.

Generate OpenSSH Host blocks from CSV host rows, with defaults, ProxyJump routes, identity-file choices, and review warnings before paste.

Clean up an SSH client config in your browser, test Host wildcards, and review lint, security, directive, and diff reports before copying.

Convert an SSH public key between OpenSSH, SSH2, and PEM in your browser, then compare fingerprints and catch private-key or extra-key mistakes.

Extract a public SSH key from pasted or uploaded key text, compare SHA-256 and MD5 fingerprints, and build a reviewed authorized_keys line.

Estimate snapshot reserve capacity from dataset churn, retention, reduction ratio, headroom, and current reserve gaps, with stress and trend checks.

Generate static route add, replace, and delete commands for Linux, Windows, Cisco-like, Junos, and firewall CLIs with route-row checks.

Plan IPv4 child subnets from a parent CIDR, compare usable host capacity with reserve, pack VLSM demand rows, and export address ledgers.

Generate access or trunk switchport CLI for Cisco IOS, NX-OS, or Arista EOS with VLAN normalization, command notes, and paste-safety warnings.

Analyze syslog and application log samples by severity, error+ share, and noisy emitters with PRI, word, and threshold checks.

Estimate searchable syslog storage from EPS, event size, retention, compression, index overhead, stored copies, reserve, and disk headroom.

Convert TB, TiB, GB, and GiB through exact bytes, compare marketed drive labels with binary readouts, and write clear capacity notes.

Estimate UPS runtime from real load, battery watt-hours, efficiency, health, reserve, and ratings so shutdown margins are easier to size.

Plan VLAN ID capacity from reserved and existing ranges, then check new segment demand, IPv4 subnet host fit, allocation order, and warnings.

Compare switch VLAN evidence with trunk policy, native VLAN rules, active database entries, and VLAN 1 exposure before a change.

Plan VLAN port moves from pasted rows, split work into timed waves, flag trunk and native VLAN risks, and build runbook-ready tables.

Plan VM migration windows from memory, disk payload, dirty-page churn, bandwidth, and cutover targets with downtime risk checks.

Estimate VM datastore capacity from thin or thick disks, snapshots, swap, growth, reserves, raw protection, and runway timing.

Estimate safe VM capacity after failover, maintenance, CPU and memory reserves, growth headroom, and large-VM placement checks.

Plan IPv4 subnets from a parent CIDR, split or rejoin leaf blocks, and verify usable ranges, broadcasts, size maps, and exports.

Estimate WAN round-trip latency from route distance, fiber index, hops, queues, jitter, packet size, app turns, and target headroom.

Decode WWN or NAA values from SAN paths and logs, normalize the hex, flag fragments, and separate port, node, device, or LUN clues.

Detect a public URL's visible web server, CDN, or proxy from response headers, redirects, confidence scoring, and origin clues.

Generate WireGuard server and client configs with peer route checks, topology preview, placeholder-key warnings, and review exports.

Plan ZFS usable capacity from vdev layout, disk size, RAID-Z padding, slop, reserves, and target-fit paths before buying drives.

Build chmod modes and shell commands from octal or symbolic permissions, compare baselines, and catch recursive, world-write, and special-bit risks.

Generate a dnsmasq DHCP scope config with pool checks, router and DNS options, static reservations, PXE/TFTP lines, and audit exports.

Build iptables or ip6tables commands with CIDR, port, chain, backend, persistence, and production-review checks before firewall changes.

Draft a systemd service unit from command, account, restart, dependency, and hardening choices with directive notes and host install checks.