RHCE course and practice exam: Red Hat Certified Engineer in Ansible (EX294)

This RHCE course has 39 video lessons and 48 graded labs, and its RHCE practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.

Playbooks, roles, templates and vault for RHEL automation

Prepares you for the performance-based EX294 exam: configuring the control node and inventory, writing plays, roles and templates, and automating RHCSA tasks with Ansible.

Advanced · 3 hours · 39 lessons · 54 labs

RHCE exam guide

The RHCE exam (Red Hat Certified Advanced System Administrator in Ansible Exam, by Red Hat): cost: varies by region/country; see redhat.com.

  • Format: Performance-based: write Ansible playbooks to configure systems; evaluated against freshly installed systems
  • Duration: Not published by the vendor
  • Cost: varies by region/country; see redhat.com
  • Delivery: Online proctored or Red Hat testing center
  • Prerequisites: None for the exam itself; the Red Hat Certified Engineer in Ansible credential also requires RHCSA (EX200). Red Hat Enterprise Linux Automation with Ansible (AU294) or comparable experience recommended.

Exam domains

  • Perform all tasks expected of a Red Hat Certified System Administrator
  • Understand core components of Ansible
  • Configure Ansible
  • Configure Ansible managed nodes
  • Run playbooks
  • Perform basic source control operations using Git
  • Be familiar with Visual Studio Code (VS Code)
  • Create Ansible plays and playbooks
  • Use roles and Ansible Content Collections
  • Automate standard RHCSA tasks using Ansible modules
  • Manage content

Red Hat does not publish domain weights for this exam.

A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

10 RHCE sample questions with answers: free to read, no account needed.

Common questions

How much does the RHCE exam cost?

Varies by region/country; see redhat.com.

Is there a free RHCE practice test?

Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

Source: EX294 Red Hat Certified Advanced System Administrator in Ansible Exam page (Red Hat), checked 2026-10-01.

Who it is for

Advanced level.

For Red Hat administrators who hold, or are close to, the RHCSA and want to automate their daily tasks with Ansible and pass the EX294 exam.

What you don't need yet:

What helps:

No formal prerequisites. The courses under "Take first" cover what helps.

Take first:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

What this exam proves, and what it doesn't

RHCE is a performance-based exam: you write Ansible playbooks that are checked against fresh systems, so passing shows you can automate RHEL. It doesn't replace running automation in production; our graded labs run playbooks on simulated nodes.

Exam objectives this course teaches

Red Hat Certified Advanced System Administrator in Ansible Exam (EX294)

Labs

54 labs, 48 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

Start Here

  1. Graded On A Machine You Never Touched (2 labs): You can say how EX294 grades a playbook (re-run on freshly installed systems, then checked), tell a task that describes an end state from one that only runs a command, and use this course's labs: your playbook, run twice by the real ansible-playbook against simulated nodes, then checked after a reboot.
  2. Exam Strategy: The First Fifteen Minutes And ansible-doc (2 labs): You can plan an EX294 attempt in the order that protects points (configuration, inventory, access, content, tasks, a full re-run) and find any module option, its choices and an example with ansible-doc instead of memory.

Control Node And Inventory

  1. Static Inventories: Hosts, Groups And Groups Of Groups (2 labs): You can write a static inventory in INI or YAML from a task statement, nest groups with children, and prove the result with ansible-inventory --graph and host patterns before any play depends on it.
  2. Inventory Variables: Ranges, group_vars And host_vars (1 lab): You can write host ranges, set variables for a group or one host in the inventory or in group_vars and host_vars files, predict which value wins, and check the merged result with ansible-inventory --host.
  3. ansible.cfg: Which File Wins, And The Settings That Matter (1 lab): You can write the project ansible.cfg an EX294 task asks for (inventory, remote user, roles and collections paths, privilege escalation), say which configuration file Ansible reads and why, and prove every setting with ansible-config.
  4. SSH Keys And An Account For Ansible (2 labs): You can generate a key pair on the control node, create the account Ansible logs in as on every managed node, and distribute the public key with ansible.posix.authorized_key, from a first run as root to key-based logins after it.
  5. Privilege Escalation: sudo Rules And become (1 lab): You can give the Ansible account a validated, passwordless sudo rule on every managed node, control escalation with become, become_user and become_method at the configuration, play and task level, and read the errors a missing rule produces.

Plays, Variables And Facts

  1. Anatomy Of A Playbook: Plays, Tasks And Modules (2 labs): You can read and write a multi-play playbook: plays that pick hosts, tasks that call modules by their fully qualified names with YAML arguments, and you can check a playbook with --syntax-check, --list-tasks and --check before it touches a node.
  2. Variables And Where They Win: group_vars, host_vars And Play Vars (1 lab): You can put per-host and per-group values in group_vars and host_vars files, load more with vars_files, predict which source wins, and inspect what a host receives with ansible-inventory and debug.
  3. Facts And Magic Variables: Let Each Node Describe Itself (1 lab): You can read gathered facts through ansible_facts, use inventory_hostname, groups and hostvars to build data across hosts, add custom facts with facts.d, and control gathering with gather_facts.
  4. Deploying Files: file, copy, lineinfile And blockinfile (1 lab): You can deploy directories with special modes, whole files from the project or from a string, single lines found by a pattern and managed blocks, so that a second run changes nothing.

Tasks That Decide And Recover

  1. Loops: One Task, Many Items (1 lab): You can run one task over a list of values or dictionaries with loop and item, convert mappings with dict2items, control output with loop_control, and recognise when a module's list option makes a loop unnecessary.
  2. Conditionals: register, when, changed_when And failed_when (1 lab): You can save task results with register, run tasks only when facts, groups or results allow with when, and keep read-only commands idempotent with changed_when and failed_when.
  3. Handlers And Failure: notify, block, rescue And always (1 lab): You can restart services only after a change with notify and handlers, recover from expected failures with block and rescue, run cleanup with always, and choose block over ignore_errors.

Navigator, Git And VS Code

  1. ansible-navigator: The Settings File The Exam Reads (1 lab): You can write an ansible-navigator.yml that names the execution environment image, its pull policy, the mode and playbook artifacts, say which settings file navigator reads, and run playbooks with navigator from the shell and VS Code.
  2. Finding Modules In Collections: ansible-doc And navigator (2 labs): You can find which collection holds a module, read its options, choices and examples with ansible-doc, browse collections, docs and inventories with ansible-navigator, and use full collection names in every task.
  3. Git And VS Code: Clone, Commit, Push, And The Dev Container (1 lab): You can clone the exam's repository, set your Git identity, stage, commit and push playbooks from the shell or VS Code, confirm what the server holds, and explain how VS Code runs playbooks in an Ansible development container.

Roles And Collections

  1. Roles: The Directory Ansible Expects, Defaults And Handlers (2 labs): You can create a role with ansible-galaxy role init, put tasks, handlers, templates, defaults and metadata where Ansible looks for them, call it from a play with parameters, and predict which variable wins.
  2. requirements.yml: Installing Roles And Collections (1 lab): You can write a requirements.yml that lists roles and collections from Galaxy, URLs, files or Git, install both with ansible-galaxy into the project's paths, and call what you installed by the right name.
  3. RHEL System Roles: timesync And selinux From A Collection (1 lab): You can install the RHEL system roles, find their variables and example playbooks offline, configure time and SELinux with the timesync and selinux roles, and call them by their collection or package names.

Automating RHCSA Tasks

  1. Packages And Repositories: yum_repository And dnf (1 lab): You can configure the exam's BaseOS and AppStream repositories with yum_repository, install package lists in one dnf transaction, choose between present and latest, and know how keys and groups are handled.
  2. Services And Boot Targets: Started Is Not Enabled (1 lab): You can start, enable, stop and mask services with systemd_service, set the default boot target idempotently with a registered command and a condition, and check both promises survive a reboot.
  3. firewalld: Permanent, Immediate And The Reboot (1 lab): You can open services and ports with ansible.posix.firewalld so they work now and after a reboot, keep firewalld running, and choose between services, ports and zones.
  4. Storage: Partitions, Volume Groups And Volumes Where The Disk Exists (1 lab): You can partition a disk with parted, build a volume group and a logical volume with lvg and lvol, and run storage tasks only on hosts whose facts show the disk, reporting the others.
  5. File Systems And Mounts: mounted, present And UUIDs (1 lab): You can create a file system with community.general.filesystem, mount it now and at boot with ansible.posix.mount, choose between mounted, present and unmounted, and mount by UUID read from blkid.
  6. Archives: archive And unarchive On The Managed Nodes (1 lab): You can back files up into a compressed archive with community.general.archive, unpack a tarball from the control node with ansible.builtin.unarchive, keep both idempotent, and choose between copying and remote sources.
  7. Scheduling: cron Jobs With Names, And Timers (1 lab): You can schedule jobs for users and root with ansible.builtin.cron so a second run never duplicates them, read and write the five time fields, and know when a systemd timer or at fits better.
  8. SELinux: Labels, Ports And Booleans That Persist (1 lab): You can keep SELinux enforcing and make a non-default web setup work with sefcontext and restorecon, seport and seboolean, so every change survives relabels and reboots.
  9. Users And Groups From A List, With Passwords That Settle (1 lab): You can create groups and users from a list of dictionaries, choose each user's group with a Jinja condition, set hashed passwords with password_hash and a fixed salt, and keep the play idempotent.

Templates And Vault

  1. Jinja Templates: One File, A Different Text Per Host (1 lab): You can render a Jinja template per host with ansible.builtin.template using variables, facts, groups, if and for, filters such as default, upper and sort, and predict the exact text including whitespace.
  2. Ansible Vault: Secrets Encrypted, Runs Without A Prompt (1 lab): You can create, edit, view, encrypt and rekey files with ansible-vault, give runs the vault password from a file set in ansible.cfg, keep that file out of Git, and stop secrets leaking into output with no_log.

Shell Scripts You Read

  1. Scripts That Say Whether They Worked (2 labs): You can write a bash script with a shebang, arguments and a usage message, test files, numbers and strings, branch with if, && and case, and return exit statuses that callers and schedulers can act on.
  2. Loops That Do A Day's Work (2 labs): You can loop over files, lines and ranges, read delimited lines safely, keep running totals with arithmetic, and write a provisioning loop that is safe to run twice.
  3. Exam-Style Scripts: Arguments, Output And Exit Codes (2 labs): You can write a script to a written specification: check its arguments, send errors to standard error with the right exit code, use command output in the script, loop over results safely, and prove the behaviour with a test for each case.

Timed Drills And Mock Exam

  1. Drill: A Web Node From A Ticket (1 lab): You can turn a five-task web server ticket into one idempotent playbook in ten minutes, with repositories, packages, content, the service and the firewall all graded after a reboot.
  2. Drill: Storage Only Where The Disk Exists (1 lab): You can build a volume group, a logical volume, its file system and a persistent mount in one play across two hosts, skipping the host without the disk cleanly, inside ten minutes.
  3. Drill: People, Passwords And sudo From The Vault (1 lab): You can create a group and its members with vaulted password hashes, give the group a validated sudo rule and schedule a job for one member, idempotently, inside ten minutes.
  4. Mock Exam, Part 1: Seven Tasks Across Three Sections (5 labs): You can complete a seven-task mock exam across inventories, roles, templates, system roles, Vault and SELinux in ninety minutes, have each section graded after a reboot, and score yourself with the course's scoring sheet.
  5. Mock Exam, Part 2: Real Machines And The Patterns That Fail (2 labs): You can build the two-machine VM kit, run its five self-graded scenarios as part two of the mock, add their score to part one, and spot the playbook patterns that lose points on a rerun or a reboot.

Certification courses