Guide
DevOps
Developer Reference

DevOps Configuration & Deployment Basics: YAML, DNS, SSL, HTTP and Automation

DevOps work is built on configuration artifacts: YAML files for services and pipelines, DNS records and SSL certificates for networking, HTTP headers and cookies for request debugging, cron schedules for automation, and robots.txt for crawling. Knowing how to validate and debug each one is a core daily skill.

TL;DR
  • YAML is the dominant format for DevOps configuration — Kubernetes manifests, Docker Compose, GitHub Actions, Ansible playbooks. One misplaced space or tab breaks the entire file.
  • DNS records control how domain names resolve. A records point to IPv4 addresses; CNAME records create aliases; MX records route email; TXT records carry verification tokens. DNS changes propagate gradually — up to 48 hours depending on TTL.
  • SSL/TLS certificates encrypt traffic and authenticate servers. Every certificate has an expiry date, a set of Subject Alternative Names (SANs), and a chain of trust back to a root CA. Expired or mismatched certificates break browsers and APIs silently.
  • HTTP headers carry metadata about requests and responses — caching instructions, auth tokens, content type, CORS policies, and security directives. Cookie values follow the same transport but have additional attributes (Secure, HttpOnly, SameSite, Expires).
  • Cron expressions define recurring job schedules as five space-separated fields. One-off errors (off-by-one on month or weekday, wrong step value) run jobs at unexpected times — always preview the next five scheduled runs before deploying.
  • Validate before deploying. Browser-based validators give instant feedback on YAML, cron, robots.txt, and .htaccess syntax without requiring a full environment. They are the fastest way to catch format errors.

Ready to validate? Browse all DevOps tools →

What Configuration and Deployment Mean in DevOps

In a DevOps context, configuration means all the files, values, and parameters that tell your infrastructure, services, and tools how to behave — where to listen for traffic, which credentials to use, what routes to expose, how frequently to run a job. Configuration is separated from code so that the same application binary can behave differently across development, staging, and production without code changes.

Deployment is the process of moving a tested version of your application and its configuration into a running environment. Modern deployments are automated, repeatable, and versioned — typically via CI/CD pipelines. A deployment failure is often a configuration failure: a YAML indentation error in a Kubernetes manifest, an expired certificate, a DNS record pointing to the wrong IP, or a cron schedule that triggers at the wrong time.

The practical skill gap for most engineers is not algorithmic — it is the ability to read, write, validate, and debug the artifacts that surround the code: configuration files, network records, HTTP exchanges, and automation schedules.

Configuration

Files and values that govern how services behave: YAML manifests, .env files, .htaccess rules, JSON config, cron schedules.

Often stored in version control and reviewed like code.

Infrastructure

The network layer: DNS records resolving domain names, SSL certificates securing connections, load balancers distributing traffic.

Changes propagate asynchronously — DNS TTLs, certificate renewal windows.

Observability

The signals that tell you what is happening: HTTP headers in request logs, query string parameters in access logs, user-agent strings for client identification.

Debugging starts with reading these signals correctly.

Core DevOps Artifacts Explained

YAML — Configuration Format

YAML (YAML Ain't Markup Language) is a human-readable serialisation format used almost universally for DevOps configuration: Kubernetes manifests, Docker Compose files, GitHub Actions workflows, GitLab CI pipelines, Ansible playbooks, Helm charts, and more. YAML's indentation-based structure is readable — but also its primary source of bugs. See how YAML compares to JSON →

Example — Docker Compose fragment

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    environment:
      - NODE_ENV=production

Key rules: Indentation uses spaces only (never tabs). Each level adds two or four spaces consistently. Colons followed by a value require a space after the colon. Strings containing special characters (:, #, {}, []) must be quoted.

Validate with: YAML Validator — reports syntax errors with line and column numbers, and normalises indentation.

DNS Records — Domain Resolution

DNS (Domain Name System) translates domain names into IP addresses and other routing information. Every domain has a set of records stored at authoritative nameservers. When you deploy a new service or change hosting, you update DNS records — but they propagate gradually because resolvers cache results for the record's TTL (time-to-live).

Record TypePurposeExample Value
AMaps domain to IPv4 address93.184.216.34
AAAAMaps domain to IPv6 address2606:2800:220:1:248:1893:25c8:1946
CNAMEAlias — points to another domain namewww.example.com → example.com
MXMail server(s) for the domain10 mail.example.com
TXTFree-text — SPF, DKIM, domain verification tokensv=spf1 include:sendgrid.net ~all
NSAuthoritative nameservers for the domainns1.cloudflare.com

Check live DNS with: DNS Record Validator — queries Cloudflare's DNS-over-HTTPS (1.1.1.1) and returns all record types for any domain.

SSL/TLS Certificates — Secure Connections

An SSL/TLS certificate is a cryptographic document that proves a server's identity and enables encrypted connections. Every HTTPS connection starts with a TLS handshake in which the server presents its certificate; the browser checks that it is valid, unexpired, signed by a trusted CA, and covers the requested hostname via a Subject Alternative Name (SAN).

Certificates have a finite validity window — Let's Encrypt issues certificates valid for 90 days; commercial CAs issue 1-year certificates. An expired certificate causes immediate browser errors and broken API calls. A certificate that does not cover the correct hostname (missing SAN) causes the same error even if it is otherwise valid.

Inspect live certificates with: SSL Certificate Validator (check hostname, expiry, SANs, chain). Decode a raw PEM with: SSL Certificate Decoder.

HTTP Headers and Cookies — Request Debugging

HTTP headers are key-value pairs sent with every request and response. They carry critical metadata: the Content-Type of the payload, Authorization tokens, Cache-Control directives, Access-Control-Allow-Origin for CORS, and security headers like Strict-Transport-Security.

Cookies are sent as Cookie and Set-Cookie headers. Each cookie has a name, value, and optional attributes: Domain, Path, Expires, Secure, HttpOnly, and SameSite. Misconfigured cookie attributes are a common source of session bugs and security vulnerabilities.

Parse in your browser: Query String Parser · Cookie Parser · API Response Formatter

Cron Schedules — Automation Timing

Cron is a Unix scheduler that runs commands at specified times. A cron expression is a string of five space-separated fields: minute (0–59), hour (0–23), day of month (1–31), month (1–12), and day of week (0–7, where 0 and 7 both mean Sunday).

Common cron patterns

* * * * *         # Every minute
0 9 * * MON-FRI   # 9 AM on weekdays
*/15 * * * *      # Every 15 minutes
0 0 1 * *         # Midnight on the 1st of each month
0 2 * * 0         # 2 AM every Sunday

Validate and preview with: Cron Expression Validator — explains the schedule in plain English and shows the next five run times.

robots.txt and Sitemaps — Crawl Configuration

The robots.txt file at a domain's root tells web crawlers which paths they are permitted or forbidden to index. It uses a simple directive syntax: User-agent, Allow, Disallow, and optionally Sitemap. robots.txt is advisory — it relies on crawlers following the standard voluntarily.

An XML sitemap is a machine-readable index of URLs you want search engines to discover. It lists page URLs with optional metadata (last modified date, priority, change frequency). Sitemaps are submitted to Google Search Console and Bing Webmaster Tools and referenced from robots.txt.

Validation, Formatting, and Debugging: Clear Distinctions

OperationWhat it doesDevOps example
ValidationChecks syntax and structure. Produces pass/fail + errors with location.YAML validator catches a tab-for-spaces error on line 14 before kubectl apply.
Formatting / NormalisingRewrites content with consistent indentation and whitespace. Semantically equivalent output.YAML Validator normalises a Docker Compose file to 2-space indentation before committing.
DebuggingInspects live or recorded data to understand what is happening.Parsing a cookie header from an access log to find why a session token is malformed.
VerificationConfirms that an expected state exists — a record was updated, a cert was renewed.DNS Record Validator confirms the new A record has propagated after a migration.

Typical DevOps Workflows

Edit YAML Config → Validate → Deploy

The standard Kubernetes / Docker Compose / CI pipeline cycle:

  1. Write or edit the YAML manifest in your editor.
  2. Validate syntax — catch indent errors, tab characters, and missing colons before pushing.
  3. Preview the normalised output — confirm the structure matches your intent.
  4. Commit and push — CI picks up the change and applies it.

Tool: YAML Validator

Check DNS + SSL → Troubleshoot Domain Issues

When a domain is not resolving correctly or HTTPS is failing:

  1. Query DNS — confirm A/CNAME records point to the correct IPs or aliases.
  2. Check TXT records — SPF, DKIM, and domain ownership verification tokens.
  3. Validate the SSL certificate — confirm it covers the right hostname, has not expired, and the chain is complete.
  4. If you have the PEM file, decode it — verify the SAN list matches all required hostnames.

Tools: DNS Record ValidatorSSL Certificate ValidatorSSL Certificate Decoder

Parse HTTP Headers, Cookies, and Query Strings During Debugging

When debugging a live request or reproducing a user issue from logs:

  1. Extract the raw URL or query string and parse it — confirm parameters are URL-encoded correctly.
  2. Parse the cookie header — check session token presence, Secure/HttpOnly attributes, and expiry.
  3. Format the API response body — pretty-print JSON to understand the structure quickly.
  4. Identify the MIME type for unexpected content — confirm Content-Type matches the actual file format.

Tools: Query String Parser · Cookie Parser · API Response Formatter

Validate Cron Schedules Before Production Use

Before adding a new scheduled job to production:

  1. Write the cron expression and paste it into the validator.
  2. Read the plain-English description — confirm it matches your intent.
  3. Review the next five scheduled run times — catch off-by-one errors on time, day, or month.
  4. Check that the timezone matches your expectation (cron runs in the server's local timezone by default).

Tool: Cron Expression Validator

Common Deployment and Configuration Mistakes

Using tabs in YAML

YAML prohibits tab characters for indentation. Most text editors default to inserting real tabs, especially in files without an .editorconfig or language-specific settings. The parser reports a cryptic "found character that cannot start any token" error. Use 2 or 4 spaces consistently.

Forgetting the space after a YAML colon

In YAML, "key: value" requires a space after the colon. "key:value" is parsed as the string literal "key:value", not a mapping. This is especially easy to miss when the value starts with a URL (which contains colons natively).

Not lowering TTL before a DNS migration

If you change an A record while the TTL is 86400 (24 hours), resolvers will serve the old IP for up to 24 hours. The correct approach: lower the TTL to 300 (5 minutes) a day before the migration, make the change, wait for the old TTL to expire, then raise it back.

Deploying a certificate that does not cover all required hostnames

A certificate covers the domain names listed in its Subject Alternative Names (SANs). A wildcard cert (*.example.com) covers one subdomain level but not the apex (example.com) or sub-subdomains (api.v2.example.com). Always verify the SAN list before deploying.

Cron month and weekday OR logic

When both day-of-month and day-of-week are non-wildcard, most cron implementations trigger if either condition is true — not both. "0 9 1 * 1" runs on the 1st of every month AND every Monday, not just Mondays that fall on the 1st.

Not quoting special characters in YAML values

YAML special characters (@, !, |, >, &, *, {, }) can cause unexpected parsing if unquoted. A connection string like "postgresql://user:pass@host:5432/db" should be quoted: "postgresql://user:pass@host:5432/db". Similarly, strings starting with { are parsed as flow mappings unless quoted.

Ignoring the robots.txt Disallow: / mistake

A robots.txt with "Disallow: /" blocks all crawlers from all content. This configuration is sometimes added as a placeholder in staging environments and inadvertently pushed to production — causing an entire site to be de-indexed by search engines.

When Browser-Based Validation Is Enough — and When It Is Not

Browser-based tools are excellent for the fast-feedback loop: paste → validate → fix. They are well-suited for:

✓ Browser tools are sufficient when…

• Validating YAML syntax and indentation before committing

• Checking DNS record propagation from public resolvers

• Inspecting a live certificate for expiry and SAN coverage

• Verifying a cron expression schedule and next run times

• Parsing cookie headers or query strings from log entries

• Generating or validating a robots.txt file structure

✗ Full environment testing is needed when…

• YAML controls runtime behaviour — invalid logic is not a syntax error

• DNS changes must be verified from specific geographic regions

• Certificate chain validation requires the exact server's TLS stack

• Cron jobs have side effects — test in a staging environment first

• .htaccess rules interact with a specific Apache module version

• Security headers need to be validated in a browser security audit context

The practical rule: use browser validators to catch format errors early (fast and free), then validate in the full environment before deploying to production.

Try the Tools

All tools run entirely in your browser. No configuration data is uploaded. Browse all DevOps tools →

Frequently Asked Questions

Related Reading