CompTIA AutoOps+ AT0-001

Hours: 40 / Access Length: 12 Months / Delivery: Online, Self-Paced
Online Hours: 40
Retail Price: $1,049.00

Course Overview:

This CompTIA AutoOps+ AT0-001 course empowers you to transform manual IT operations into reliable, automated, and highly scalable workflows. You will start by mastering system configuration, core scripting languages like Bash, PowerShell, and Python, and Git-based version control to manage your infrastructure as code. Building on this technical foundation, you will learn to design robust Continuous Integration and Continuous Delivery (CI/CD) pipelines that safely build, test, and deploy updates across diverse environments. The curriculum then introduces Site Reliability Engineering (SRE) principles, teaching you how to use observability and automated feedback loops to anticipate failures and ensure system resilience. Ultimately, you will emerge with the ability to architect end-to-end delivery pipelines that maximize operational efficiency, minimize risk, and drive consistent software delivery.

Students will:

• Implement system configuration.
• Explain coding and scripting fundamentals.
• Manage and maintain reliable code.
• Explain modern automation practices and technologies.
• Implement continuous integration workflows.
• Implement continuous delivery workflows.
• Execute end-to-end CI/CD workflows.
• Practice site reliability engineering.

This course prepares a student to take the CompTIA AutoOps+ AT0-001 national certification exam.

Course Outline:

Lesson 1: Implementing System Configuration

Modern IT environments are too complex and fast‑moving to manage reliably with ad hoc, manual changes. In this module, you'll step back and look at system configuration through the lens of automation: why manual approaches break down at scale, how configuration drift undermines stability and security, and how automated, idempotent workflows—backed by solid service level expectations—let you deliver consistent, recoverable environments. You'll ground these ideas in concrete examples on Linux, Windows, and network devices, seeing how the same configuration concepts apply whether you're editing sshd_config on a server, managing IIS on Windows, or enforcing standardized firewall and routing rules across your infrastructure.

Building on that foundation, you'll examine how different deployment models and platforms shape your automation strategy. You'll see how virtualization and containerization make servers and services programmable units that orchestration tools can provision, scale, and reset on demand, and how cloud service and deployment models expand those capabilities. Finally, you'll connect all of this to the practical realities of remote access and APIs, which help automation tools reach systems wherever they live. By the end of the module, you'll understand system configuration as an end‑to‑end, remotely driven, automated pipeline that improves efficiency, reliability, and service quality.

Lesson 2: Explaining Coding and Scripting Fundamentals

Code is a powerful foundation for automation, and one that helps you control outcomes at scale. While there are many different scripting environments, three of the most widely used are Bash for Linux and network devices, PowerShell for Windows and Azure, and Python for cross‑platform and cloud‑heavy automation. Having a handle on the basics of these three will prepare you for success. You'll then be able to round out your skills with practical coding workflows: setting up a productive workspace, using IDEs and linters, managing dependencies and virtual environments, and ensuring scripts are secure, signed, and properly permissioned. By the end of this module, you'll be able to design, write, and manage automation code that fits cleanly into CI/CD pipelines and day‑to‑day operations, improving both your efficiency and your systems' reliability.

Lesson 3: Managing and Maintaining Reliable Code

In modern work, almost everything that shapes your systems lives as code. You can turn that fact into a reliability advantage by making Git the operational backbone of your automation. In this module, you'll see how commits, branches, pull requests, and tags give you an auditable history of every change, and how that history powers CI/CD workflows that are traceable, repeatable, and reversible. Along the way, you'll learn how to use core Git commands and guardrails to move work through short‑lived branches, protect main, and connect specific commits to the artifacts and releases that end up in production.

By combining disciplined Git workflows with practical debugging and coding best practices, you'll learn how to keep your automation safe to change: every modification is reviewed, testable, and recoverable, so version control becomes a tool for operational resilience rather than just file tracking.

Lesson 4: Explaining Modern Automation Practices and Technologies

In earlier modules, you focused on writing scripts and defining configuration as code; in this module, you zoom out and learn how to turn those pieces into reliable systems of automation and orchestration. You'll look at what makes good automation in the first place—repeatability, idempotency, observability, error handling, and reusability—and how those ideas show up across the software delivery lifecycle, from build and test through provisioning, deployment, and operations. You'll see why manual, one-off changes don't scale, and how treating infrastructure and configuration as code (via IaC and configuration automation) lets you detect drift, recover quickly, and keep environments consistent without constant human babysitting.

Building on that foundation, you'll explore how orchestration coordinates many individual automated tasks into CI/CD workflows that are fast, safe, and auditable. You'll walk through concrete examples of pipelines that build, deploy, validate, promote, and roll back changes; compare deployment strategies like blue-green, canary, and rolling updates; and connect these workflows to DevOps principles such as small, frequent changes and continuous feedback. Along the way, you'll also learn how the underlying automation technologies—file formats like JSON, YAML, and HCL and engines like Terraform, Ansible, and CI runners—fit together to interpret your intent and apply it in real environments. By the end of the module, you'll not only know how to automate individual tasks, but how to design end-to-end delivery systems that move changes from commit to production in a controlled, observable way.

Lesson 5: Implementing Continuous Integration Workflows

Continuous integration is where all of your automation work comes together. In this module, you shift from thinking about individual scripts and pipelines in isolation to thinking about CI as an automated, repeatable system that builds, tests, and validates changes in a controlled environment. You'll see how environment and tooling factors determine whether your pipelines are fast and secure, or flaky and unreliable. The goal is to achieve the same, auditable results with every commit, which is essential if you want to scale automation without constant firefighting.

Building on that foundation, you'll learn how to design CI workflows that give you fast, meaningful feedback while enforcing quality gates around the changes you ship. Throughout, you'll connect environment discipline with workflow design: secrets and artifacts are handled safely, tests and scans run in the right order, and failures trigger clear, automated responses instead of manual guesswork. By the end of the module, you'll be able to design and operate CI systems that not only improve efficiency, but also increase confidence in every automated change that moves toward production.

Lesson 6: Implementing Continuous Delivery Workflows

In this module, you'll focus on automating a release—deploying known artifacts into real environments, validating that those deployments actually work, and recovering quickly when they don't. Artifacts are promoted through dev, test, staging, and production using orchestration rules, environment parity, and rollout strategies that balance risk and downtime. The emphasis is on turning "we deployed something" into "we know exactly what we deployed, where, and how it's behaving." At the same time, you'll see how different layers of automated tests fit around deployments to prove releases are production‑ready, and how post‑deployment validation, monitoring, and rollback logic turn failures into fast, predictable recovery. You'll also learn to troubleshoot delivery pipelines systematically by using logs, artifacts, and clear failure signals to isolate issues. By the end of the module, you'll be able to design and run delivery workflows that use automation to ship smaller, safer changes more often, while giving you the observability and control you need to keep services stable.

Lesson 7: Executing End-to-End CI/CD Workflows

In this module, you will learn how to move beyond isolated automated tasks and design end‑to‑end systems that safely carry changes from commit to production. While automation can help teams move faster, it's most important function is its ability to reduce risk, increase consistency, and build confidence in every release. You'll see here how well‑designed automated pipelines connect development, infrastructure, and operations into a single, reliable workflow, and how to pair automation with governance and reliability practices using release signals, monitoring outcomes, and audit trails. By the end of the module, you will understand how delivery pipelines, drift management, and governance work together as a closed loop.

Lesson 8: Practicing Site Reliability Engineering

In this module, you learn how Site Reliability Engineering (SRE) uses measurement, automation, and feedback loops to keep complex systems stable as change and scale increase. Instead of relying on manual intervention or best effort responses, you see how reliability becomes an engineered outcome—one that is defined up front, continuously observed, and automatically protected. This shifts your role from reacting to outages to designing systems that anticipate failure and recover on their own.

You learn how reliability targets guide deployment behavior, how monitoring and data turn incidents into actionable signals, and how automation closes the loop by triggering rollback, recovery, and improvement. By the end of the module, you'll understand how SRE allows us to run automated systems that remain predictable, resilient, and efficient over time, even when moving fast.

All necessary course materials are included.

Certification(s):

This course prepares a student to take the CompTIA AutoOps+ AT0-001 national certification exam.

System Requirements:

Internet Connectivity Requirements:

• Cable, Fiber, DSL, or LEO Satellite (i.e. Starlink) internet with speeds of at least 10mb/sec download and 5mb/sec upload are recommended for the best experience.

NOTE: While cellular hotspots may allow access to our courses, users may experience connectivity issues by trying to access our learning management system.  This is due to the potential high download and upload latency of cellular connections.   Therefore, it is not recommended that students use a cellular hotspot as their primary way of accessing their courses.

Hardware Requirements:

• CPU: 1 GHz or higher
• RAM: 4 GB or higher
• Resolution: 1280 x 720 or higher.  1920x1080 resolution is recommended for the best experience.
• Speakers / Headphones
• Microphone for Webinar or Live Online sessions.

Operating System Requirements:

• Windows 7 or higher.
• Mac OSX 10 or higher.
• Latest Chrome OS
• Latest Linux Distributions
  

NOTE: While we understand that our courses can be viewed on Android and iPhone devices, we do not recommend the use of these devices for our courses. The size of these devices do not provide a good learning environment for students taking online or live online based courses.

Web Browser Requirements:

• Latest Google Chrome is recommended for the best experience.
• Latest Mozilla FireFox
• Latest Microsoft Edge
• Latest Apple Safari

Basic Software Requirements (These are recommendations of software to use):

• Office suite software (Microsoft Office, OpenOffice, or LibreOffice)
• PDF reader program (Adobe Reader, FoxIt)
• Courses may require other software that is described in the above course outline.