Python for IT Automation.

This lesson brings the first five lessons together. You'll reason about an IT automation pipeline, handle untrusted input, produce reviewable reports and prepare for the final Network Inventory Analyzer.

• Describe a read-only Python automation pipeline from input through verification.
• Interpret mock HTTP response status codes, JSON payloads and common API failure modes.
• Distinguish authentication from authorization and keep secrets out of source code.
• Validate structured records without silently counting unknown data as healthy.
• Correlate fictional log events with validated inventory hosts.
• Explain dry-run behavior, bounded retries and scope of privileged changes.
• Test edge cases and return a deterministic machine-readable report.

A useful IT automation script has a repeatable pipeline: receive an input, validate its format, normalize values, apply a decision rule, and produce a reviewable result. A script that prints 'done' without checking its actual output is not reliable. Keep parsing, business rules and reporting in separate functions so you can test each stage. In this course, all inventories and responses are fictional, and Python runs only inside an isolated browser workbench.

def summarize(records):
    offline = sorted(r['host'] for r in records
                     if r.get('status') == 'offline')
    return {'offline_hosts': offline, 'count': len(offline)}

print(summarize([{'host':'AP-02','status':'offline'}]))

An API exposes a structured interface to another service. A GET request is commonly used to retrieve records, while POST creates or initiates operations; PUT and PATCH modify resources and DELETE removes them. The server returns an HTTP status code and often a JSON payload. Success is not the same as usable data: a 200 response can contain incomplete records. For a beginner browser lesson, use offline response fixtures—not outbound network requests, credentials, or live endpoints.

response = {'status_code': 503, 'json': None}
if response['status_code'] >= 500:
    print('service error')
elif response['status_code'] == 200:
    print('check payload')
else:
    print('review response')

{"devices":[{"host":"SW-01","status":"online"},{"host":"AP-02","status":"offline"}]}

Some APIs require credentials such as tokens or API keys, often supplied through an Authorization header. Authentication establishes identity; authorization determines allowed actions. Do not hardcode real tokens in source files, paste secrets into a learning workbench or include them in log output. Production scripts usually read credentials from a protected secret manager or runtime environment and use least-privilege, short-lived credentials when available.

response = {'status_code': 401}
if response['status_code'] == 401:
    print('authentication required')
elif response['status_code'] == 403:
    print('permission denied')
else:
    print('check request result')

Data from exports and simulated API responses can be inconsistent. A host may be blank, latency text may not convert to an integer, and a status may arrive as ' OFFLINE '. Normalize valid values while rejecting malformed ones. Keep an invalid-row count separate from offline counts. If a field is missing, mark it unknown or invalid according to the contract—do not default to online. Sorting results makes repeated reports stable and easier to compare.

def valid_latency(value):
    try:
        number = int(value)
    except (TypeError, ValueError):
        return False
    return number >= 0

print(valid_latency('80'))
print(valid_latency('N/A'))

An inventory identifies devices and their attributes; a log records observations over time. A useful report can cross-reference a hostname from an alert with validated inventory records. Do not treat alerts from unknown hostnames as verified inventory devices. In a simplified fictional log, each line contains a severity, hostname and event; production logs require timestamp and format handling, deduplication and retention policies.

known = {'SW-01', 'AP-02'}
log_lines = ['ALERT AP-02 link_down', 'ALERT GHOST-9 link_down']
matched = []
for line in log_lines:
    severity, host, event = line.split()
    if severity == 'ALERT' and host in known:
        matched.append(host)
print(sorted(matched))

Automating a change is different from automating an observation. A dry-run mode shows proposed actions without applying them. For destructive or privileged operations, define approved targets, expected effects, rollback and validation before execution. In this beginner course, every task is read-only against fictional data, with no remote connections. A reliable report should be deterministic: the same input should produce the same output and rerunning it should not accumulate duplicate records.

def plan_action(host, dry_run=True):
    if dry_run:
        return f'WOULD check {host}'
    return f'Check requested for {host}'

print(plan_action('SW-01'))

A script that passes one demonstration can still be wrong. Use assert statements and simple helper tests to prove requirements for different data shapes: empty inputs, duplicate hostnames, missing fields, malformed numbers, case changes and unexpected log hosts. A test should compare the full returned result, not just search for a string in console output. When tests fail, inspect the failing case and fix the underlying function instead of hardcoding the expected answer.

def is_critical(value):
    return value >= 200

assert is_critical(199) is False
assert is_critical(200) is True
print('boundary checks passed')

A technician's automation should produce a useful artifact: offline hosts, valid record counts, malformed-row counts, matched alerts, and perhaps unmatched log evidence. Keep output stable, document how missing data was handled and avoid presenting estimates as confirmed health. A JSON report is easy to inspect and exchange; a CSV summary can be convenient for reviewers. The final capstone combines all six lessons in an offline Network Inventory Analyzer.

import json
report = {'offline_hosts': ['AP-02'], 'invalid_rows': 1,
          'matched_alert_hosts': ['AP-02']}
print(json.dumps(report, sort_keys=True))

Complete six code challenges covering HTTP decisions, JSON shape, validation, log correlation, dry-run behavior and boundary tests. After the clinic, the final capstone tests a complete analyzer using several different datasets.

Use original documentation when interpreting status codes, parsing data and testing your scripts. API examples in this course are simulations, not live integrations.