CompTIA AutoOps+

Operations code needs only a few ideas used well. You write scripts with variables, conditions, loops and functions, handle errors and input, and use libraries instead of writing everything yourself.

• Variables, data types and operators
• Conditions and loops
• Functions and modules
• Reading input and arguments
• Error handling and exit codes
• Regular expressions for text
• Using standard libraries

You build A script that checks a list of services and reports which have failed.

Operations tools exchange structured text. You read and write JSON, YAML, XML and CSV, fill templates from data, and keep configuration and secrets out of the code itself.

• JSON and YAML structure and syntax
• XML and CSV for older systems
• Parsing and transforming data in a script
• Templating configuration files
• Environment variables and configuration files
• Keeping secrets out of source code

You build A tool that converts a data file into rendered configuration files for several servers.

Everything that runs operations should be in version control. You commit, branch and merge, resolve conflicts, review changes through pull requests and choose a branching approach for a team.

• Commits, history and undoing mistakes
• Branches and merges
• Resolving conflicts
• Remote repositories and pull requests
• Tags and releases
• Branching strategies for teams
• Ignoring files and protecting secrets

You build A repository with branches, a resolved merge conflict and a reviewed pull request.

Infrastructure described in files can be reviewed, tested and rebuilt. You write declarative templates, understand state and drift, and decide between changing a system and replacing it.

• Declarative infrastructure definitions
• State, plan and apply
• Modules, variables and outputs
• Detecting and correcting drift
• Mutable and immutable infrastructure
• Testing infrastructure code

You build A template that builds a small environment, then rebuilds it after you destroy it.

Automation fails in ordinary ways. You read error messages, use logging and a debugger, write simple tests, manage dependencies and versions, and roll back when a change breaks something.

• Reading errors and stack traces
• Logging for scripts and tools
• Debugging step by step
• Linting and unit tests
• Dependency and version problems
• Rolling back a bad release

You build Fixes for five broken scripts, each with a test that would have caught the fault.

Systems left alone drift from their intended state. You describe desired state with a configuration tool, apply it to many machines, compare push and pull models and diagnose runs that fail.

• Desired state and inventories
• Playbooks, roles and variables
• Push and pull models compared
• Dry runs and testing changes
• Enforcing and reporting on configuration
• Diagnosing failed configuration runs

You build A role that configures a server group, with a test run and a drift report.

Most platforms are automated through their APIs. You make and read HTTP requests, authenticate, handle pagination and rate limits, and write code that survives errors and slow responses.

• HTTP methods, headers and status codes
• Authentication: keys, tokens and OAuth
• Calling an API from the command line and from code
• Pagination, filtering and rate limits
• Webhooks and event-driven automation
• Handling errors, retries and timeouts

You build A script that reads from one API and updates another, with retries and error handling.

Continuous integration catches problems while they are cheap. You set up build environments and runners, trigger workflows from changes, manage dependencies and cache them, and produce artifacts others can use.

• What continuous integration does and why
• Build environments, runners and containers
• Triggers, branches and workflow rules
• Dependency management and caching
• Running tests in a pipeline
• Producing and storing build artifacts

You build A working integration workflow that builds and tests a project on every change.

Pipelines are configured in files, and you will inherit other people’s. You read stages, jobs and conditions, trace why a run failed, and adjust a basic pipeline without breaking it.

• Pipeline structure: stages, jobs and steps
• Variables, secrets and conditions
• Matrix builds and parallel jobs
• Reading logs from failed runs
• Quality gates and static analysis
• Reusing pipeline components

You build An annotated pipeline file, with a fix for a failing job and a new quality gate.

Delivery turns a passing build into a running release. You store artifacts, promote them through environments, choose a rollout strategy and prepare the rollback before the release, not during it.

• Artifact repositories and versioning
• Environments and promotion
• Rolling, blue-green and canary releases
• Feature flags
• Approvals and change records
• Database changes and rollback

You build A delivery pipeline that promotes one artifact through test and production with a rollback step.

Automation is judged by what users experience. You define indicators and objectives for an application, monitor and alert against them, and use the results to decide whether a release was healthy.

• Service level indicators, objectives and agreements
• Error budgets
• Metrics, logs and alerts for applications
• Health checks and synthetic tests
• Using monitoring to gate a release
• Reporting service levels

You build A service level definition with dashboards and alerts for one application.

Automation holds powerful credentials. You manage secrets in a vault, issue least-privilege tokens and keys, secure the connections to cloud and tool providers, and rotate what must not live forever.

• Secrets storage and injection
• Service accounts and least privilege
• Token and key rotation
• TLS and certificate handling
• SSH keys and signing commits
• Auditing automated access

You build A pipeline that obtains short-lived credentials from a secrets store instead of holding them.

One service takes you through the whole path. You code the automation, keep it in Git, define the infrastructure and configuration, build the pipeline, deliver safely and monitor the result.

• Choosing what to automate for one service
• Coding, testing and version control
• Infrastructure and configuration as code
• Building the integration and delivery pipeline
• Monitoring and securing the result

You build A service deployed from a commit to production by a pipeline you wrote.