# Guru Labs > Hands-on Linux and open-source training since 1999. Guru Labs is a technical training company based in Salt Lake City, Utah. Co-founded in 1999 by Dax Kelson — the world's first Red Hat Certified Engineer (RHCE #1), acknowledged in IETF RFC 3168 (The Addition of Explicit Congestion Notification to IP) and named contributor to RFC 3360 (Inappropriate TCP Resets Considered Harmful), and contributor to the Linux kernel, Chromium, and MIT Kerberos — Guru Labs delivers instructor-led courses where students work on real infrastructure, not simulations or sandboxes. Because we don't sell software or subscriptions, our training is unvarnished and unbiased. We focus on RHEL and the Red Hat ecosystem, but because we're independent we can recommend any solution, point out what doesn't work well, and give students the unfiltered truth. We train system administrators, DevOps engineers, and security professionals through live classes with extensive hands-on labs. We also offer private training for teams (on-site or live online) and courseware licensing for organizations. Website: https://gurulabs.com Contact: info@gurulabs.com ## Trusted By Over 9,000 organizations have chosen Guru Labs for instructor-led training, private team training, courseware licensing, and consulting, including: **Technology:** Apple, Amazon, Microsoft, Intel, Google, IBM, Cisco, Dell, Oracle, NVIDIA, Red Hat, HPE, VMware, Ericsson **Defense & Aerospace:** Boeing, Lockheed Martin, Northrop Grumman, Raytheon, BAE Systems, General Dynamics, NASA JPL **Finance:** JPMorgan Chase, Goldman Sachs, Capital One, Wells Fargo, Citi, Morgan Stanley, American Express, Fidelity **Telecom & Media:** AT&T, Verizon, T-Mobile, Comcast, FedEx, UPS, Southwest Airlines **Consumer & Industrial:** Disney, Honeywell, 3M, PepsiCo, GE, GM, Procter & Gamble, Nike **Consulting:** Accenture, Deloitte, PwC, Ernst & Young **Pharma:** Pfizer, Johnson & Johnson, Merck, Eli Lilly, Amgen ## Full Course Catalog ### GL120 Linux Fundamentals Category: Linux System Administration Duration: 5 days URL: /training/courses/GL120/ Master the Linux command line from your first login to confident daily use: Bash essentials, filesystem navigation, text processing with grep and sed, shell scripting, process management, and task scheduling. Hands-on labs on your choice of RHEL, SLES, or Ubuntu. Build practical Linux command-line skills from the ground up, progressing from your first login through confident daily use of the Bash shell. Hands-on labs run on your choice of RHEL, SLES, or Ubuntu, with built-in cross-reference where distributions differ. Core topics include filesystem navigation, file management, I/O redirection, and text processing with grep, sed, and awk. Students progress to regular expressions, vi/vim and Nano editing, Bash shell customization, and shell scripting with variables, conditionals, and loops. The course then covers essential operational skills: process and job control, persistent terminal sessions with tmux and screen, task scheduling with cron and systemd timers, software package management with DNF, Zypper, or APT, SSH remote access and file transfer, and filesystem mounting including NFS and SMB shares. Foundational context on Linux history, distributions, and open-source licensing rounds out the curriculum. With 61 guided lab exercises woven throughout the course, students practice commands and concepts on live systems, reinforcing the hands-on skills that employers expect from Linux-capable professionals. #### Audience IT professionals, system administrators, software developers, DevOps engineers, and technical support staff who need to build practical Linux command-line skills for day-to-day work with Linux servers, scripting, or application deployment. #### Prerequisites Students should be comfortable using computers. No prior experience with Linux or other Unix-like operating systems is required. #### Skills - Navigate the Linux filesystem and manage files, directories, permissions, and ownership from the command line - Use I/O redirection, pipes, and shell features to build efficient command pipelines - Search and manipulate text using grep, sed, awk, and regular expressions - Edit files with vi/vim and Nano text editors - Write and execute Bash shell scripts with variables, conditionals, and loops - Manage processes, jobs, and signals to control running applications - Schedule automated tasks using cron, at, anacron, and systemd timers - Install and manage software packages with DNF, APT, and Zypper - Establish secure remote connections and transfer files using SSH, SFTP, and key-based authentication - Mount and unmount local, NFS, and SMB/CIFS filesystems - Create and extract archives using tar, cpio, and various compression utilities - Customize the Bash shell environment, prompts, aliases, and configuration files --- ### GL124 Red Hat Enterprise Linux System Admin I Category: Linux System Administration Duration: 5 days URL: /training/courses/GL124/ Build essential RHEL 10 administration skills from the command line up — Bash, Vim, text processing, user management, systemd, SSH, networking, and package management across 37 hands-on labs aligned with RHCSA objectives. Master the foundational skills required to operate and manage Red Hat Enterprise Linux 10 systems. Aligned with the first half of the RHCSA (EX200) certification objectives, this course builds practical Linux administration competency through structured instruction and 37 hands-on lab exercises on live RHEL 10 systems. The curriculum progresses from command line proficiency through full system management. Students begin with Bash shell navigation, file operations, and Vim editing, then advance to I/O redirection, piping, and text processing with grep, sed, and awk. The second half covers essential administration topics: local user and group management, file permissions and ownership, process monitoring and control, systemd service administration, OpenSSH configuration with key-based authentication, log analysis with rsyslog and journald, network configuration with NetworkManager and nmcli, file archiving and transfer, RPM and DNF package management, and disk partitioning with filesystem creation using fdisk, gdisk, and mkfs. Every chapter pairs guided instruction with hands-on labs where students apply concepts on live RHEL 10 systems, reinforcing the practical skills that employers and the RHCSA exam demand. This course prepares students for GL224 (Red Hat Enterprise Linux System Admin II) to complete full RHCSA certification preparation. #### Audience Junior system administrators, IT support staff, help desk professionals, and RHCSA certification candidates who need foundational, hands-on skills for managing Red Hat Enterprise Linux 9 systems in production environments. #### Prerequisites No prior Linux experience required. Basic familiarity with computing concepts and comfort working in a text-based interface is helpful. #### Skills - Navigate the Linux command line using Bash shell features including history, tab completion, and environment variables - Manage files and directories using core utilities such as cp, mv, rm, mkdir, ln, and file globbing - Edit text files efficiently using the Vim editor in command, insert, and ex modes - Redirect and pipe I/O streams, and process text with grep, sed, awk, sort, cut, and other filtering utilities - Create and manage local user accounts, groups, and password policies using useradd, usermod, and chage - Control access to files using standard Linux permissions, special permission bits, and umask - Monitor and manage processes using ps, top, kill, jobs, nice, and process priority tools - Control systemd services and daemons using systemctl to start, stop, enable, and mask units - Configure and secure OpenSSH for remote access using key-based authentication and sshd configuration - Analyze system logs using rsyslog configuration and journalctl queries filtered by unit, priority, and time - Configure network interfaces, IP addressing, and DNS resolution using nmcli and NetworkManager on RHEL 9 - Install, update, and manage software packages and repositories using RPM and DNF Hands-On Labs: 7+ hours #### Outline 1. Access the command line (2 labs, 15 min) 2. Manage files from the command line (4 labs, 35 min) 3. Get help in a textual environment (1 lab, 10 min) 4. Editing Text Files with Vim (1 lab, 60 min) 5. Text Processing (1 lab, 10 min) 6. Manage local Linux users and groups (1 lab, 10 min) 7. Control access to files with Linux file system permissions (2 labs, 30 min) 8. Monitor and manage Linux processes (1 lab, 10 min) 9. Control services and daemons (2 labs, 30 min) 10. Configure and secure OpenSSH service (3 labs, 25 min) 11. Analyzing and Storing Logs (3 labs, 40 min) 12. Manage Red Hat Enterprise Linux networking (5 labs, 50 min) 13. Archive and copy files between systems (2 labs, 25 min) 14. Install and update software packages (3 labs, 30 min) 15. Comprehensive review (1 lab, 30 min) --- ### GL134 Red Hat Enterprise Linux System Admin II Category: Linux System Administration Duration: 5 days URL: /training/courses/GL134/ Advance your RHEL 10 administration skills: Bash scripting, regular expressions, SELinux, LVM storage, NFS, boot troubleshooting, nftables firewalls, and Podman containers. Hands-on RHCSA preparation across 28 labs. Build on your Linux fundamentals to master the intermediate systems administration skills required for managing Red Hat Enterprise Linux 10 in production. Across fifteen focused chapters, this course develops core competency in shell scripting, security, storage, networking, and containerization, with direct alignment to RHCSA exam objectives. Topics span the full breadth of day-to-day RHEL administration: writing Bash scripts with variables, conditionals, and loops; using regular expressions with grep for text processing; scheduling tasks with cron, at, and systemd timers; tuning process priorities; implementing POSIX access control lists; securing services with SELinux; integrating LDAP directory services via authselect and SSSD; partitioning disks and building filesystems; managing flexible storage with LVM snapshots and thin provisioning; accessing NFS network storage with autofs; troubleshooting GRUB2 and systemd boot failures; configuring nftables and firewalld firewalls; deploying containers with Podman; and automating installations with Kickstart. Every chapter includes guided lab exercises on live RHEL 10 systems, with 28 labs reinforcing each topic through direct hands-on practice. The course concludes with a comprehensive review mapped to current RHCSA certification objectives, giving students a clear path from training to exam readiness. #### Audience System administrators, DevOps engineers, and IT professionals who have completed introductory Linux training and need to deepen their Red Hat Enterprise Linux skills in scripting, storage management, security hardening, and service configuration. Also suitable for professionals preparing for the RHCSA certification exam. #### Prerequisites Completion of GL120 (Linux Fundamentals) or equivalent experience with basic Linux command-line usage, file management, user administration, and text editing. Familiarity with the RHEL environment is recommended. #### Skills - Write and debug Bash shell scripts using variables, conditionals, loops, and exit status handling - Construct regular expressions and apply them with grep to search and filter text across BRE, ERE, and PCRE - Schedule recurring and one-time tasks using cron, at, anacron, and systemd timers - Manage process priorities with nice, renice, and ionice, and monitor system activity with ps and top - Configure POSIX access control lists and SELinux contexts, booleans, and policies to secure files and services - Configure LDAP-based network authentication using authselect, SSSD, and directory services - Partition disks, create ext4 and XFS filesystems, and manage LVM volumes including snapshots and thin provisioning - Mount NFS shares and configure autofs for on-demand network storage access - Troubleshoot the RHEL boot process including GRUB2 configuration, systemd targets, and root password recovery - Configure packet filtering with nftables and manage firewalld zones, services, and rich rules - Deploy and manage containers using Podman, build images with Containerfiles, and run rootless containerized services - Install RHEL systems using Anaconda and automate deployments with Kickstart Hands-On Labs: 7+ hours #### Outline 1. Introduction to Shell Scripting (1 lab, 20 min) 2. Use regular expressions with grep (1 lab, 10 min) 3. Schedule future Linux tasks (2 labs, 15 min) 4. Manage priority of Linux processes (1 lab, 10 min) 5. Control access to files with access control lists (ACL) (1 lab, 25 min) 6. Manage SELinux security (2 labs, 15 min) 7. Connect to network-defined users and groups (1 lab, 15 min) 8. Add disks, partitions, and file systems to a Linux system (2 labs, 30 min) 9. Manage logical volume management (LVM) storage (1 lab, 20 min) 10. Access and manage network attached storage (2 labs, 25 min) 11. Control and troubleshoot the Red Hat Enterprise Linux boot process (4 labs, 35 min) 12. Linux network communication with firewall (2 labs, 35 min) 13. Container Technology Overview (4 labs, 90 min) 14. Installing RHEL (1 lab, 30 min) 15. Comprehensive review (1 lab, 30 min) --- ### GL180 OpenShift Fundamentals Category: Containers & Kubernetes Duration: 4 days Platforms: RHEL URL: /training/courses/GL180/ Build and deploy containerized applications on OpenShift, from Linux kernel isolation and OCI image management with Podman and Buildah to Kubernetes orchestration, persistent storage, networking, and Source-to-Image workflows. Build a solid foundation in container technology and Red Hat OpenShift Container Platform administration. Starting with the Linux kernel features that make containers possible, including namespaces, control groups, and security modules like SELinux, seccomp, and AppArmor, students progress to building and managing OCI-compliant images with Podman, Buildah, and Skopeo. Rootless container workflows with Podman are covered throughout, reinforcing modern container security best practices. The course spans the full container orchestration stack: Kubernetes architecture and object management using both imperative and declarative methods, persistent storage with PersistentVolumes and StorageClasses, cluster networking with Services and Ingress controllers, and application configuration with ConfigMaps and Secrets. OpenShift-specific topics include the Source-to-Image build workflow, BuildConfigs, ImageStreams, DeploymentConfigs, Routes for external access, and the OpenShift web console. Every chapter includes guided lab exercises on live OpenShift clusters, giving students hands-on practice deploying and managing containerized applications in production-style environments. With 17 labs across seven chapters, the course emphasizes practical skills that transfer directly to real-world OpenShift administration and cloud native DevOps workflows. #### Audience System administrators, DevOps engineers, and application developers who need to deploy, manage, and troubleshoot containerized applications on Red Hat OpenShift Container Platform and want to build a solid foundation in container technology and Kubernetes orchestration. #### Prerequisites Familiarity with Linux command-line usage and basic system administration concepts. Experience with enterprise Linux distributions such as RHEL is recommended. No prior container or Kubernetes experience required. GL120 (Linux Fundamentals) or equivalent experience. #### Skills - Explain container isolation mechanisms including namespaces, cgroups, and Linux security modules - Build and manage OCI-compliant container images using Podman, Buildah, and Containerfiles - Configure container registries and manage image lifecycle with Skopeo - Create and manage Pods, volumes, and container networking with Podman - Describe Kubernetes architecture including control plane and node components - Manage Kubernetes objects using imperative and declarative methods - Configure persistent storage with PersistentVolumes, PersistentVolumeClaims, and StorageClasses - Deploy and manage ConfigMaps and Secrets for application configuration - Configure Kubernetes networking including Services, Ingress, and CoreDNS - Deploy applications on OpenShift using Source-to-Image, BuildConfigs, and DeploymentConfigs - Create and manage OpenShift Routes for external application access - Navigate the OpenShift web console for cluster administration and monitoring Hands-On Labs: 7+ hours #### Outline 1. Container Technology Fundamentals (2 labs, 45 min) 2. Managing Images (2 labs, 65 min) 3. Managing Pods (4 labs, 90 min) 4. Orchestration (3 labs, 75 min) 5. Storage (2 labs, 50 min) 6. OpenShift Networking (2 labs, 30 min) 7. Deploying Applications on OpenShift (2 labs, 65 min) --- ### GL199 RHCSA Accelerated Course Category: Certification Prep Duration: 5 days Platforms: RHEL URL: /training/courses/GL199/ Accelerate your RHCSA EX200 exam preparation on live RHEL 9 systems. Lab-intensive coverage of every exam domain, from command-line proficiency and LVM storage to SELinux, systemd, networking, firewalld, and Podman containers. Accelerate your Red Hat Certified System Administrator (RHCSA) exam preparation with this intensive, hands-on course aligned to the EX200 exam objectives on RHEL 9. Designed for experienced Linux users, the course moves at a rapid pace across all RHCSA domains, helping you identify and close gaps in your systems administration skills before exam day. Topics cover every core RHCSA exam domain in depth: command-line proficiency with Bash and essential tools, user and group administration with password aging, security hardening through standard permissions, FACLs, and SELinux policy management, service control with systemd, boot process management with GRUB2 and dracut, network configuration with NetworkManager and nmcli, and storage administration with LVM, XFS, and /etc/fstab. The course also covers system logging with rsyslog and journalctl, task scheduling with cron and systemd timers, network file systems with NFS and AutoFS, firewall management with firewalld and nftables, and container deployment with Podman, Buildah, and Skopeo. Appendices provide additional coverage of KVM virtualization, Kickstart automated installation, essential command-line tools, regular expressions, and text editing with vim. With 46 lab exercises across 17 chapters on live RHEL 9 systems, the course builds the performance-based proficiency the RHCSA exam demands. Every chapter pairs focused instruction with hands-on practice, reinforcing real-world administration skills that translate directly to exam scenarios and production environments. #### Audience Linux system administrators, IT professionals, and support engineers preparing for the Red Hat Certified System Administrator (RHCSA) exam (EX200) who have existing Linux command-line experience and want to rapidly close knowledge gaps across all RHCSA domains on RHEL 9. #### Prerequisites Familiarity with basic Linux command-line usage, file management, and text editing. Prior experience administering Linux systems is expected. GL120 (Linux Fundamentals) or equivalent hands-on experience recommended. This is not a beginner course. #### Skills - Access and navigate the command line, switch user contexts with su and sudo, and use essential documentation tools - Manage files, directories, hard links, and symbolic links, and configure standard permissions, special permissions, and file access control lists - Configure and secure OpenSSH for remote access, file transfer, and key-based authentication - Create and administer local user and group accounts with password aging policies - Configure SELinux enforcing and permissive modes, manage file contexts and booleans, and troubleshoot policy violations - Monitor and manage processes using ps, top, kill, and nice, and analyze CPU, memory, and I/O utilization - Install, update, and manage RPM packages, dnf repositories, and kernel updates - Control systemd services and boot targets, configure GRUB2, and recover the boot process - Configure network interfaces, routing, and hostname resolution using nmcli and the ip command - Analyze system logs with rsyslog and journalctl, and schedule recurring tasks with cron and systemd timers - Partition disks, create and maintain filesystems, manage LVM volumes and swap, and mount NFS and CIFS network file systems - Deploy, inspect, and manage rootless containers, images, and pods using Podman --- ### GL250 Enterprise Linux Systems Administration Category: Linux System Administration Duration: 5 days URL: /training/courses/GL250/ Build production-ready Linux administration skills on your choice of RHEL 10 or SLES 15, from kernel internals and systemd to LVM, RAID, SELinux, and advanced networking. Lab-intensive with 60+ hands-on exercises. Master the full stack of enterprise Linux systems administration on your choice of Red Hat Enterprise Linux (RHEL) 10 or SUSE Linux Enterprise Server (SLES) 15. This course builds real operational depth: kernel and device management, systemd service control, GRUB2 boot configuration, and package management with RPM and distribution-specific tools, giving administrators the expertise that modern data center and hybrid cloud environments demand. Coverage spans local storage administration with partitioning, XFS and ext4 filesystems, LVM thin provisioning, and software RAID, plus remote storage via NFS, autofs, iSCSI, and SAN multipathing. The security curriculum addresses SELinux policy management, AppArmor profiles, firewalld zones and rich rules, PAM authentication, and POSIX ACLs. Networking topics progress from interface configuration and routing through advanced areas including bonding, teaming, 802.1q VLANs, IPv6, DHCP server deployment, and kernel network tuning. Students also learn centralized log management with rsyslog, the systemd journal, and Cockpit, alongside system performance monitoring and troubleshooting techniques using sar, strace, and distribution rescue environments. Every chapter pairs instructor-led instruction with guided lab exercises on live systems. With 14 chapters and over 60 hands-on labs covering real-world scenarios, from recovering unbootable systems to configuring iSCSI storage and tuning network performance, students leave with the practical skills to confidently administer Linux servers in production. #### Audience System administrators, DevOps engineers, site reliability engineers, and IT infrastructure professionals responsible for deploying, configuring, and maintaining enterprise Linux servers. This course also benefits software developers and cloud engineers who need deep operational knowledge of Linux system internals, storage management, and security hardening. #### Prerequisites Familiarity with basic Linux command-line usage, file management, and text editing. GL120 (Linux Fundamentals) or equivalent hands-on experience with Linux is recommended. A basic understanding of networking concepts and TCP/IP is helpful. #### Skills - Configure and manage kernel modules, device files, udev rules, and firmware updates - Administer systemd services, unit files, targets, and service sandboxing features - Configure GRUB2 boot loader settings and troubleshoot the full boot process from BIOS/UEFI through systemd targets - Manage software packages and repositories using RPM, dnf, and zypper - Partition disks, create and maintain filesystems, and configure mount options and disk quotas - Deploy and manage LVM volumes, thin provisioning, and software RAID arrays with mdadm - Configure NFS, autofs, iSCSI initiators, and SAN multipathing for remote storage access - Manage user accounts, groups, password policies, and PAM authentication stacks - Implement security policies using SELinux, AppArmor, firewalld, and file ACLs - Configure IPv4 and IPv6 networking including bonding, teaming, VLANs, and DHCP services - Administer system logging with rsyslog, the systemd journal, and Cockpit - Monitor system performance with sar, vmstat, and iostat, and diagnose failures using rescue environments Hands-On Labs: 15+ hours #### Outline 1. Linux Kernel & Devices (4 labs, 60 min) 2. Systemd Overview (2 labs, 30 min) 3. GRUB2/Systemd Boot Process (4 labs, 35 min) 4. Software Maintenance (5 labs, 55 min) 5. Local Storage Administration (5 labs, 55 min) 6. LVM & RAID (5 labs, 95 min) 7. Remote Storage Administration (4 labs, 65 min) 8. User/Group Administration (3 labs, 35 min) 9. Pluggable Authentication Modules (PAM) (4 labs, 25 min) 10. Security Administration (6 labs, 85 min) 11. Basic Networking 12. Advanced Networking (5 labs, 55 min) 13. Log File Administration (4 labs, 65 min) 14. Monitoring & Troubleshooting (1 lab, 10 min) --- ### GL254 System Administration III for Red Hat Enterprise Linux Category: Linux System Administration Duration: 5 days Platforms: RHEL URL: /training/courses/GL254/ Deploy and secure RHEL network services: BIND DNS, Postfix email, Apache HTTPD with TLS, iSCSI and NFS/Samba storage, MariaDB, plus kernel management, SELinux hardening, and Bash scripting. Build on foundational RHEL administration skills to deploy, configure, and secure the network services and server infrastructure required for senior system administration roles. Students progress from kernel and device management through systemd service control and sandboxing, then into advanced networking topics including IPv6 configuration, link aggregation with bonding and teaming, and software bridging. Network services coverage spans DNS administration with BIND, Postfix email configuration and relay setup, iSCSI block storage with targets and initiators, NFS and Samba file sharing, MariaDB database administration, and Apache HTTPD deployment with TLS, virtual hosts, and CGI applications. Security is integrated throughout with SELinux port contexts, booleans, permissive domains, and firewalld zone-based filtering for each service. The course also develops Bash scripting skills from fundamentals through conditionals, loops, and option parsing, covers shell environment customization with startup files, command history, editing modes, and prompt configuration, and introduces Linux container concepts including namespaces, cgroups, and the Open Container Initiative. Hands-on lab exercises in each chapter reinforce skills as students configure and troubleshoot real services on live RHEL systems. #### Audience Experienced Linux system administrators, DevOps engineers, and IT infrastructure professionals responsible for deploying and managing network services on Red Hat Enterprise Linux who need to build skills in DNS, email, web services, networked storage, security hardening, and shell scripting. #### Prerequisites Completion of GL120 (Linux Fundamentals) and GL134 (System Administration II) or equivalent RHEL administration experience. Familiarity with systemd, basic networking, user management, and package management is required. #### Skills - Manage Linux kernel modules, devices, udev rules, and hardware discovery tools - Control services and daemons using systemd units, targets, and service sandboxing - Configure IPv6 networking, link aggregation with bonding and teaming, and software bridges - Secure network services using SELinux contexts, booleans, and firewalld zone-based rules - Configure BIND DNS servers with zones, access controls, forwarding, and rndc management - Deploy Postfix for SMTP email delivery, relay configuration, and alias management - Provision iSCSI block storage using targets and Open-iSCSI initiator configuration - Configure NFS exports and Samba file shares for cross-platform network file access - Administer MariaDB databases including user management, privileges, and SQL operations - Deploy Apache HTTPD with TLS encryption, virtual hosts, CGI, and access controls - Write Bash scripts with conditionals, loops, positional parameters, and control structures - Customize the shell environment with configuration files, prompt settings, command history, and editing modes Hands-On Labs: 8+ hours #### Outline 1. Linux Kernel & Devices (3 labs, 50 min) 2. Control Services and Daemons (3 labs, 40 min) 3. Manage IPv6 Networking (1 lab, 10 min) 4. Configure Link Aggregation and Bridging 5. Control Network Port Security (2 labs, 30 min) 6. Manage DNS for Servers (2 labs, 50 min) 7. Configure Email Delivery (3 labs, 50 min) 8. Provide Block-based Storage (1 lab, 20 min) 9. Provide File-based Storage (1 lab, 15 min) 10. Configure MariaDB Databases (1 lab, 10 min) 11. Provide Apache HTTPD Web Services (5 labs, 115 min) 12. Write Bash Scripts (1 lab, 20 min) 13. Configure the Shell Environment (4 labs, 25 min) 14. Linux Containers Preview (2 labs, 30 min) --- ### GL275 Enterprise Linux Network Services Category: Enterprise Infrastructure Duration: 5 days Platforms: RHEL · SLES · Ubuntu URL: /training/courses/GL275/ Deploy and secure the network services that power enterprise Linux infrastructure: DNS, Apache, Postfix, LDAP, Samba, Squid, and MariaDB. Lab-intensive, hands-on configuration on your choice of RHEL, SLES, or Ubuntu. Enterprise Linux Network Services builds the skills needed to deploy, configure, and harden the full stack of network services found in production Linux environments. With hands-on labs on your choice of RHEL, SLES, or Ubuntu, students gain direct experience with the services that underpin organizational infrastructure, from name resolution and web hosting to mail delivery, directory services, and file sharing, all secured with firewalld, SELinux, and AppArmor from the ground up. The course opens with host security fundamentals including firewalld zone management, Netfilter stateful packet filtering, and mandatory access control with SELinux and AppArmor. Four chapters then build comprehensive DNS expertise: resolution theory, BIND zone configuration, subdomain delegation with zone transfers, and advanced features including ACLs, views, TSIG authentication, and DNSSEC. Three chapters cover Apache HTTP Server administration spanning virtual hosting, TLS, authentication, and server-side scripting with CGI, PHP-FPM, and Python WSGI. The mail services track covers SMTP theory, Postfix deployment with TLS and SASL, and Dovecot IMAP/POP3 with Sieve filtering and SpamAssassin integration. Students also deploy 389 Directory Server for LDAP, configure Samba for Windows interoperability, manage Squid proxy with bandwidth controls, administer MariaDB with SQL, and implement FTP services with vsftpd. With 53 guided lab exercises across live multi-host environments, students spend the majority of the course building, breaking, and troubleshooting real service configurations, developing the practical skills that enterprise network services administration demands. #### Audience Linux system administrators, network administrators, and IT infrastructure engineers responsible for deploying, configuring, and securing network services in enterprise environments. Ideal for professionals who manage DNS, web, mail, directory, file sharing, proxy, and database services on Linux , regardless of which distribution their organization runs. #### Prerequisites Solid Linux systems administration skills including command-line proficiency, filesystem management, process control, user administration, and TCP/IP networking fundamentals. GL250 (Enterprise Linux Systems Administration) or equivalent experience recommended. Familiarity with systemd service management and basic network protocols is helpful. #### Skills - Configure firewalld zones, Netfilter packet filtering rules, and connection tracking to secure network services - Implement SELinux policies, booleans, and file contexts alongside AppArmor profiles to enforce mandatory access control - Deploy and administer BIND DNS servers with zone files, resource records, delegation hierarchies, and DNSSEC - Deploy and configure Apache HTTP Server with virtual hosting, TLS certificates, access controls, and PHP integration - Configure Postfix for SMTP relay, virtual domains, TLS encryption, and SASL authentication - Deploy Dovecot for IMAP and POP3 mail retrieval and configure server-side filtering with Sieve and SpamAssassin - Manage LDAP directory services using 389 Directory Server for centralized authentication and directory storage - Configure Samba for cross-platform SMB/CIFS file and print sharing with Windows interoperability - Deploy Squid caching proxy with access controls, authentication, and delay pool bandwidth management - Administer MariaDB databases using SQL for schema management, data operations, and user privilege control - Implement FTP services with vsftpd including anonymous access, local user authentication, and TLS-secured transfers - Administer server-side scripting environments with CGI, PHP-FPM, and Python WSGI on Apache Hands-On Labs: 15+ hours #### Outline 1. Securing Services (4 labs, 65 min) 2. SELinux and LSM (2 labs, 20 min) 3. DNS Concepts (1 lab, 30 min) 4. Configuring BIND (2 labs, 50 min) 5. Creating DNS Hierarchies (2 labs, 50 min) 6. Advanced BIND DNS Features (2 labs, 25 min) 7. Using Apache (3 labs, 75 min) 8. Apache Security (3 labs, 90 min) 9. Apache Server-Side Scripting Administration (3 labs, 45 min) 10. Implementing an FTP Server (1 lab, 15 min) 11. The Squid Proxy Server (4 labs, 40 min) 12. SQL Fundamentals and MariaDB (4 labs, 105 min) 13. LDAP Concepts and Clients (1 lab, 10 min) 14. 389 Directory Server (1 lab, 25 min) 15. Samba Concepts and Configuration (4 labs, 55 min) 16. SMTP Theory 17. Postfix (5 labs, 81 min) 18. Mail Services and Retrieval (5 labs, 100 min) --- ### GL280 Openshift Administration Category: Containers & Kubernetes Duration: 4 days Platforms: RHEL URL: /training/courses/GL280/ Deploy, secure, and operate Red Hat OpenShift clusters in production: identity providers, RBAC, Security Context Constraints, advanced scheduling, autoscaling, EFK logging, and Prometheus monitoring. Lab-intensive with 17 hands-on exercises. Build production-ready OpenShift administration skills across the full cluster operations stack. Students progress from architecture review and cluster installation through authentication, security hardening, application lifecycle management, advanced scheduling, autoscaling, and production observability, gaining the expertise to operate OpenShift Container Platform clusters at scale. Key topics include OpenShift 4.x installation on AWS with IPI and UPI methods, identity provider configuration with htpasswd and OAuth, Role-Based Access Control, Security Context Constraints, admission controllers with Gatekeeper policy enforcement, Deployments with rolling updates and rollbacks, ResourceQuotas and LimitRanges, node and pod affinity rules, taints and tolerations, Horizontal Pod Autoscalers with custom Prometheus metrics, MachineSet and ClusterAutoscaler management, EFK logging with Elasticsearch and Fluentd, audit log forwarding, and Prometheus-based monitoring with ServiceMonitors and Grafana dashboards. With 17 lab exercises spanning every chapter, students work directly on live OpenShift clusters to configure identity providers, enforce RBAC policies, tune pod scheduling, set up autoscaling, deploy the logging stack, and build monitoring dashboards, developing the hands-on skills that day-2 cluster operations demand. #### Audience System administrators, DevOps engineers, site reliability engineers, and platform engineers responsible for deploying, operating, and maintaining Red Hat OpenShift Container Platform clusters who need production-ready skills in cluster security, workload scheduling, autoscaling, and observability. #### Prerequisites Solid knowledge of Kubernetes concepts including Pods, Deployments, Services, and namespaces. GL275 (Kubernetes Administration) or equivalent hands-on Kubernetes experience strongly recommended. GL120 (Linux Fundamentals) or equivalent Linux command-line proficiency required. Familiarity with container images, registries, and YAML object manifests is expected. #### Skills - Describe OpenShift and Kubernetes cluster architecture including control plane components, RHCOS nodes, and Operator-managed infrastructure - Configure cluster authentication using htpasswd identity providers, OAuth, kubeconfig files, and service accounts - Implement Role-Based Access Control with Roles, ClusterRoles, RoleBindings, and ClusterRoleBindings - Manage Security Context Constraints and admission controllers to enforce pod security policies - Deploy and manage applications using Deployments, ReplicaSets, rolling updates, and Pod Disruption Budgets - Configure pod health checks using startup, liveness, and readiness probes - Control pod scheduling with resource requests, limits, node and pod affinity rules, taints, and tolerations - Plan cluster capacity including control plane sizing, network CIDR allocation, and etcd performance tuning - Scale clusters using Horizontal Pod Autoscalers, MachineSets, MachineHealthChecks, and ClusterAutoscalers - Enforce organizational standards using labels, annotations, and Gatekeeper policy-based admission control - Deploy and operate the EFK logging stack with Elasticsearch, Fluentd, Kibana, and ClusterLogForwarder audit log management - Monitor cluster health using Prometheus, Grafana, Thanos Querier, ServiceMonitors, and custom application metrics Hands-On Labs: 7+ hours #### Outline 1. Core Concept Review (1 lab, 30 min) 2. Installation and Authentication (4 labs, 110 min) 3. Security 4. Application Lifecycle Management (3 labs, 80 min) 5. Scheduling (4 labs, 100 min) 6. Scaling (1 lab, 30 min) 7. Logging, Monitoring, Alerting (2 labs, 60 min) --- ### GL281 Red Hat Enterprise Linux v8 Differences Category: Linux System Administration Duration: 4 days Platforms: RHEL URL: /training/courses/GL281/ Bridge the gap from RHEL 7 to RHEL 8: master DNF, nftables, Stratis, LUKS2 with NBDE, rootless Podman containers, OpenSCAP compliance, and Cockpit web administration. Hands-on labs across every major subsystem. Master the architectural changes and new tooling that distinguish RHEL 8 from its predecessor. This focused course takes experienced RHEL 7 administrators through every major subsystem, including software management, networking, storage, security, containers, clustering, and desktop, equipping them to plan and execute confident migrations to RHEL 8 environments. Software management coverage spans the transition from YUM to DNF, Application Streams and modular content delivery, and custom image building with Lorax and composer-cli. Networking chapters address the shift from iptables to nftables with hands-on rule creation and migration tooling, NetworkManager enhancements, chronyd time synchronization, and TCP BBR congestion control tuning. Storage sections cover the Stratis management framework with thin provisioning and snapshots, the LUKS2 on-disk format with online re-encryption, and automated disk decryption through Network-Bound Disk Encryption with Tang and Clevis. Security hardening topics include OpenSCAP compliance scanning against STIG and PCI-DSS profiles, system-wide cryptographic policies, fapolicyd application whitelisting, USBGuard device control, tlog session recording, and auditd v3 kernel-level auditing. Students also gain practical experience with daemonless container management using Podman, Buildah, and Skopeo, including rootless containers and Kubernetes YAML generation, alongside Corosync 3 and Pacemaker 2 clustering updates and Cockpit web-based administration. Hands-on labs reinforce key skills across software management, networking, storage, security, and container workflows. #### Audience Experienced RHEL 7 system administrators, infrastructure engineers, and DevOps practitioners responsible for planning or executing migrations to RHEL 8. Ideal for professionals managing enterprise Linux environments who need to rapidly adopt the new tooling, security frameworks, and container workflows introduced in RHEL 8. #### Prerequisites Strong working knowledge of RHEL 7 system administration including package management, networking, storage, and security. GL250 (Enterprise Linux Systems Administration) or equivalent hands-on experience required. #### Skills - Manage software with DNF, Application Streams, and modular repositories - Build custom system images using Image Builder and composer-cli - Configure nftables firewall rules and transition from iptables-based firewalling - Tune TCP congestion control algorithms and benchmark network performance with iperf3 - Create and manage Stratis storage pools, thin-provisioned filesystems, and snapshots - Deploy LUKS2 encrypted volumes with Network-Bound Disk Encryption using Tang and Clevis - Perform security compliance scanning with OpenSCAP and enforce system-wide cryptographic policies - Implement application whitelisting with fapolicyd and USB device control with USBGuard - Configure session recording with tlog and kernel-level auditing with auditd - Build and manage rootless containers using Podman, Buildah, and Skopeo - Administer systems through the Cockpit web console Hands-On Labs: 7+ hours #### Outline 1. Software Management (4 labs, 105 min) 2. Networking (3 labs, 40 min) 3. Storage (5 labs, 80 min) 4. Security (4 labs, 55 min) 5. Container Technology Overview (4 labs, 90 min) 6. Clustering 7. Virtualization (1 lab, 10 min) 8. Desktop --- ### GL294 Enterprise Linux Automation with Ansible Category: Linux Automation Duration: 5 days URL: /training/courses/GL294/ Automate Linux infrastructure with Ansible: inventory, playbooks, Jinja2 templating, roles, and Vault. Lab-intensive RHCE (EX294) exam preparation on RHEL 9. GL294 teaches enterprise Linux automation with Ansible, covering objectives from the Red Hat Certified Engineer (RHCE, EX294) exam. Students progress from Ansible architecture and inventory fundamentals through playbook development, variables, Jinja2 templating, task control, and roles, building production-ready automation skills on RHEL 9. The course covers the modern Ansible toolchain, including ansible-navigator and execution environments built with ansible-builder and Podman. Students work with dozens of Ansible modules for file management, networking, packaging, storage, user accounts, SELinux, firewall rules, and systemd services. Advanced topics include Ansible Vault for secrets management, Jinja2 filters and lookups, delegation and error handling with blocks, and RHEL System Roles for standardized infrastructure configuration. With 21 hands-on labs across eight chapters, GL294 emphasizes practical skills over theory. Students automate real tasks in a containerized lab environment, from writing their first playbook to completing comprehensive review challenges that combine inventory design, vault-encrypted variables, Jinja2 templates, task control, and system role deployment. Comprehensive capstone labs in the final chapter serve as exam readiness exercises. #### Audience Linux system administrators, DevOps engineers, and site reliability engineers responsible for managing and automating RHEL infrastructure. Ideal for professionals preparing for the Red Hat Certified Engineer (RHCE) exam who want hands-on experience with the modern Ansible toolchain including ansible-navigator and execution environments. #### Prerequisites Solid Linux system administration skills equivalent to GL120 or Red Hat System Administration (RH124/RH134). Familiarity with the Linux command line, file editing, package management, and basic networking. No prior Ansible experience required. #### Skills - Configure Ansible inventories with host groups, variables, and dynamic inventory plugins - Deploy and configure the modern Ansible toolchain including ansible-navigator and execution environments - Write and execute Ansible playbooks using core modules for file management, packaging, storage, and services - Manage variables, facts, and secrets using Ansible Vault encryption - Build dynamic configuration files with Jinja2 templates, filters, and control structures - Implement task control with loops, conditionals, handlers, and error handling blocks - Create and manage Ansible roles for reusable automation - Install and apply RHEL System Roles for standardized infrastructure configuration - Build custom execution environment images with ansible-builder and Podman - Use Ansible Content Collections and Ansible Galaxy to extend automation capabilities Hands-On Labs: 10+ hours #### Outline 1. Ansible Overview 2. Deploying Ansible (2 labs, 45 min) 3. Playbooks Basics (5 labs, 120 min) 4. Managing Variables and Secrets (2 labs, 45 min) 5. Jinja2 Templates (2 labs, 65 min) 6. Task Control (2 labs, 105 min) 7. Roles (2 labs, 50 min) 8. Comprehensive Review (3 labs, 160 min) --- ### GL299 RHCE Rapid Track Course Category: Certification Prep Duration: 5 days Platforms: RHEL URL: /training/courses/GL299/ Accelerate RHCE certification prep on RHEL 7: system administration, network services, SELinux, and security across 51 hands-on labs covering Apache, DNS, Postfix, NFS, Samba, and SSH. Accelerate your path to Red Hat Certified Engineer status with this intensive course covering the full breadth of RHEL 7 system administration and network services. Designed for administrators who already hold RHCSA-level knowledge, the course moves rapidly through advanced topics while dedicating substantial time to hands-on lab exercises that mirror real-world scenarios and RHCE exam objectives. The curriculum spans the complete RHEL administration stack: software management with RPM and DNF, network configuration with NetworkManager and the ip command suite, storage administration including LVM and iSCSI, user account management with POSIX ACLs, and enterprise authentication with Kerberos, SSSD, and AutoFS. Security hardening covers SELinux policy management, firewalld zones, and iptables rules. Network services coverage includes Apache HTTP/HTTPS with virtual hosting and SSL/TLS, Postfix SMTP, BIND caching DNS, NFS file sharing with NFSv4 and Kerberos authentication, Samba/CIFS, vsftpd, and OpenSSH tunneling, rounded out by NTP time synchronization, system performance monitoring with sar, and centralized logging with journalctl. With 51 lab exercises across 19 chapters, approximately half the course is spent configuring and troubleshooting services on live RHEL systems. This lab-intensive, performance-based approach builds the practical, hands-on skills that the RHCE certification exam demands. #### Audience Experienced Linux system administrators and IT professionals who hold RHCSA certification or equivalent knowledge and want to prepare for RHCE certification. This course is designed for advanced learners capable of rapid information absorption or those needing to fill specific knowledge gaps before attempting the performance-based RHCE exam. #### Prerequisites RHCSA certification or equivalent experience in Linux system administration. Students should be proficient with command-line usage, file management, user administration, and basic networking. GL199 (RHCSA Rapid Track Course) or completion of the GL124 and GL134 training track is recommended. #### Skills - Manage software packages using RPM, DNF, and custom repositories with createrepo - Configure network interfaces, routing, and name resolution with NetworkManager and ip commands - Administer local storage using partitioning, filesystems, LVM, iSCSI, and disk encryption - Manage user accounts, access control lists, Kerberos authentication, and sudo delegation - Administer systemd services, GRUB2 boot configuration, and initramfs recovery - Implement SELinux mandatory access control with contexts, booleans, and audit troubleshooting - Configure firewalld zones and iptables rules for host-based network security - Deploy Apache HTTP/HTTPS with virtual hosts, SSL/TLS, and CGI configuration - Configure Postfix SMTP, BIND caching DNS, NFS, Samba, and vsftpd services - Monitor system performance with sar, vmstat, and iostat, and manage logging with journalctl - Manage secure remote access with OpenSSH key-based authentication and tunneling - Automate RHEL installations with Kickstart and manage KVM virtualization using libvirt Hands-On Labs: 13+ hours #### Outline 1. Software Management (3 labs, 40 min) 2. Network Management (5 labs, 35 min) 3. Storage Management (4 labs, 65 min) 4. Logical Volume Management (LVM) (1 lab, 20 min) 5. Account Management (4 labs, 65 min) 6. Authentication Management (2 labs, 18 min) 7. Boot Management (5 labs, 60 min) 8. Managing SELinux (2 labs, 15 min) 9. Firewall Management (1 lab, 15 min) 10. Network Time Protocol (NTP) Service (1 lab, 15 min) 11. System Monitoring and Logs (2 labs, 25 min) 12. Web (HTTP/HTTPS) Service (6 labs, 140 min) 13. SMTP Service (3 labs, 50 min) 14. Caching-Only DNS Service (1 lab, 15 min) 15. File Sharing with NFS (1 lab, 15 min) 16. File Sharing with CIFS (3 labs, 45 min) 17. File Transfer Protocol (FTP) Service (1 lab, 15 min) 18. Secure Shell (SSH) Service (4 labs, 28 min) 19. Installation, Kickstart, and Virtualization (2 labs, 75 min) --- ### GL314 Linux Troubleshooting Category: Linux System Administration Duration: 5 days Platforms: RHEL · SLES URL: /training/courses/GL314/ Diagnose and fix real Linux failures: boot recovery, networking, storage, security, and services. Over 120 self-paced lab scenarios on your choice of RHEL or SLES build hands-on troubleshooting instincts. Build the diagnostic instincts and root-cause analysis skills that separate reactive firefighters from effective Linux troubleshooters. This lab-intensive course dedicates roughly 75 percent of class time to hands-on exercises, with over 120 independent troubleshooting scenarios organized by topic and progressive difficulty, giving students real practice diagnosing and resolving failures across the full systems administration stack. Course content spans troubleshooting methodology, essential diagnostic tools such as strace, tcpdump, lsof, and Wireshark, rescue and recovery procedures, boot process diagnosis, filesystem and storage troubleshooting including LVM and software RAID, network configuration and connectivity issues, firewall analysis with iptables, nftables, and FirewallD, and service-level troubleshooting for DNS, NFS, Samba, Apache, Postfix, MariaDB, and other enterprise services. Students also cover kernel module management, performance analysis with vmstat and iostat, user authentication with PAM and LDAP, and SELinux policy troubleshooting. Each topic group includes self-paced lab scenarios with progressive hints, allowing students to work at their own level and focus on areas most relevant to their environment. Labs run on your choice of RHEL or SLES, with courseware cross-reference where the distributions differ. #### Audience Intermediate to advanced Linux system administrators, DevOps engineers, site reliability engineers, and IT professionals responsible for maintaining enterprise Linux servers who want to strengthen their diagnostic and problem-resolution skills across system, network, and service domains. #### Prerequisites Solid experience with Linux system administration including package management, networking, storage, and service management. GL120 (Linux Fundamentals) and GL250 (Enterprise Linux Systems Administration) or equivalent experience recommended. #### Skills - Apply structured troubleshooting methodology to diagnose and resolve Linux system problems - Use strace, ltrace, lsof, and fuser to trace system calls, library calls, and open files - Boot into rescue environments and recover unbootable systems using chroot, fsck, and grub2-install - Troubleshoot the Linux boot process including GRUB 2, systemd targets, and kernel initialization - Diagnose and resolve filesystem problems including full disks, exhausted inodes, and corruption - Troubleshoot network connectivity using ip, ss, nmap, netcat, tcpdump, and Wireshark - Identify and resolve firewall issues with iptables, nftables, FirewallD, and Netfilter rule analysis - Troubleshoot network services including DNS, NFS, Samba, Apache, Postfix, and MariaDB - Diagnose performance bottlenecks using vmstat, iostat, pidstat, and top - Manage and troubleshoot kernel modules, LVM volumes, and software RAID arrays - Troubleshoot user authentication problems involving PAM, LDAP, and account expiration - Analyze system and application logs using journalctl and rsyslog to isolate root causes Hands-On Labs: 17+ hours #### Outline 1. Troubleshooting Methodology 2. Troubleshooting Tools (4 labs, 100 min) 3. Rescue Environments (3 labs, 40 min) 4. Topic Group 1 (1 lab, 120 min) 5. Topic Group 2 (1 lab, 120 min) 6. Topic Group 3 (1 lab, 120 min) 7. Topic Group 4 (1 lab, 120 min) 8. Topic Group 5 (1 lab, 120 min) 9. Topic Group 6 (1 lab, 120 min) 10. Topic Group 7 (1 lab, 120 min) --- ### GL325 Linux Performance Tuning & Analysis Category: Linux System Administration Duration: 5 days Platforms: RHEL · SLES URL: /training/courses/GL325/ Diagnose and resolve Linux performance bottlenecks using the USE Method, deep kernel internals knowledge, and hands-on mastery of SystemTap, Performance Co-Pilot, perf, sar, and SNMP on your choice of RHEL or SLES. Master the tools, methodologies, and kernel-level knowledge needed to analyze, monitor, and optimize Linux performance on enterprise systems. Starting with Brendan Gregg's USE Method for systematic bottleneck identification, students build a deep understanding of Linux internals covering kernel architecture, process scheduling, virtual memory, block devices, filesystems, and the I/O subsystem, then apply that knowledge to real-world performance challenges on your choice of RHEL or SLES. The course covers the full Linux observability stack: process and resource monitoring with ps, top, vmstat, iostat, and mpstat; long-term trending with sar and Performance Co-Pilot; kernel and userspace instrumentation with SystemTap; CPU profiling and flamegraph generation with perf; remote metric gathering with SNMP; and benchmarking with Bonnie++, iperf, and the Phoronix Test Suite. Students also learn to tune key kernel subsystems including CPU scheduling, NUMA memory allocation, huge pages, disk I/O schedulers, filesystem parameters, and network stack configuration using both manual sysctl settings and automated tuned profiles. Hands-on lab exercises throughout the course let students apply performance analysis and tuning techniques on live RHEL or SLES systems, building the practical expertise needed to diagnose and resolve performance issues in production environments. #### Audience Linux system administrators, performance engineers, DevOps professionals, and site reliability engineers responsible for optimizing, monitoring, and troubleshooting performance on enterprise Linux servers running RHEL or SLES. #### Prerequisites Solid experience with Linux system administration including command-line proficiency, process management, storage administration, and networking fundamentals. GL250 (Enterprise Linux Systems Administration) or equivalent experience recommended. #### Skills - Apply the USE Method to systematically identify performance bottlenecks across CPU, memory, network, and storage resources - Monitor CPU, memory, and I/O utilization using vmstat, iostat, mpstat, sar, and top - Instrument the Linux kernel and userspace applications with SystemTap for deep performance analysis - Deploy and configure Performance Co-Pilot for distributed metric collection, inference rules, and historical trending - Profile applications and generate flamegraphs using Linux perf - Configure SNMP agents and gather remote performance metrics across infrastructure - Benchmark system performance using disk, network, and application-level tools including Bonnie++, iperf, and the Phoronix Test Suite - Tune Linux kernel parameters for CPU scheduling, memory management, I/O schedulers, and network performance - Optimize NUMA topology and huge page configurations for memory-intensive workloads - Administer system logging with rsyslog and the systemd journal for performance-related troubleshooting - Trace and debug application behavior using strace, ltrace, and pmap - Apply automated tuning profiles with tuned for common workload patterns Hands-On Labs: 8+ hours #### Outline 1. Tuning Principles & The USE Method (2 labs, 65 min) 2. Linux Internals Review (2 labs, 40 min) 3. Linux Userspace Architecture (3 labs, 35 min) 4. Log File Administration (2 labs, 25 min) 5. Monitoring & Troubleshooting (4 labs, 85 min) 6. Benchmark Tools (2 labs, 90 min) 7. Systemtap (1 lab, 30 min) 8. Performance Co-Pilot (2 labs, 40 min) 9. Remote Metric Gathering With SNMP (1 lab, 20 min) 10. Linux perf (1 lab, 45 min) 11. Linux Tunables --- ### GL340 Docker Category: Containers & Kubernetes Duration: 5 days URL: /training/courses/GL340/ Run Docker in production on RHEL 10: engine installation with TLS, Dockerfile builds, volumes, Compose and Swarm orchestration, networking, logging, Podman beside Docker, and a private signed registry. Docker turned containers into everyday infrastructure, and the administrators who run it well are the ones who understand what sits underneath the CLI. This course builds that understanding in both directions: the Linux kernel features that make containers possible, namespaces, cgroups, OverlayFS, and the OCI runC runtime, and the day-to-day Docker workflow that rides on top of them. Because Red Hat Enterprise Linux 10 ships Podman rather than Docker, students install Docker Engine 29 from Docker's own packages and learn how the RHEL container landscape, including Podman, containerd, and CRI-O, relates to what they are running. Coverage follows the full lifecycle of a containerized application. Students configure the Docker daemon through systemd drop-ins and daemon.json, protect the control socket with TLS certificates signed by a local CA, and apply capability, user, filesystem, SELinux, and seccomp restrictions to running containers. Image work spans registry operations, promotion by digest, multi-architecture platform images, commit and diff, save, load, export, and import, then moves into Dockerfile authoring in depth: build context, layer caching and cache mounts, ENTRYPOINT and CMD forms, HEALTHCHECK probes, and multi-stage builds that cut both image size and attack surface. Storage covers named volumes, bind mounts, tmpfs, and volume drivers. Orchestration covers YAML authoring and Docker Compose service sets, then Swarm mode on a real classroom cluster: services, rolling updates and rollback, stacks, secrets, quorum, and overlay networking. Networking and logging round out the Docker stack, from bridge networks, DNS resolution, and published ports through syslog, journald, Graylog, Fluentd, Splunk, and cloud provider log drivers. A closing chapter runs Podman beside Docker on the same host: the same images under both engines, rootless containers, Podman secrets without a swarm, and a web site served as a Quadlet unit under systemd. Thirty guided lab exercises anchor the material, with hands-on work in every chapter: building containers by hand with runC, securing the daemon with TLS, hardening container privileges, promoting images by digest, optimizing build size and cache behavior, rolling a Swarm service forward and back, managing Swarm secrets, and publishing services on private networks. An appendix takes students through running their own registry, securing it with TLS and htpasswd authentication, and signing images with Cosign, now that Docker Content Trust has left the Docker 29 command line. #### Audience System administrators, DevOps engineers, site reliability engineers, and platform engineers responsible for deploying, securing, and operating containerized applications, along with developers who package their own applications as container images and need to understand how those images behave on enterprise Linux hosts. #### Prerequisites Proficiency with the Linux command-line interface and a broad understanding of Linux system administration, including systemd services, package management, filesystems, and basic networking. GL120 (Linux Fundamentals) or equivalent experience recommended. #### Skills - Explain container isolation using Linux namespaces, cgroups, OverlayFS layering, and the OCI runC runtime - Install the Docker engine on RHEL 10 from Docker's own packages and secure the control socket with TLS certificates - Configure the Docker daemon through systemd units and daemon.json, covering the containerd image store, registries, networking, and logging defaults - Create, run, and manage container lifecycles with CPU and memory resource limits and restart policies - Restrict container privileges using POSIX capabilities, user and filesystem controls, no-new-privileges, SELinux, and seccomp - Manage images across registries with pull, push, promotion by digest, prune, commit, save, load, export, import, and multi-architecture platform images - Build images with Dockerfile instructions, ENTRYPOINT and CMD forms, and HEALTHCHECK probes - Shrink images and speed rebuilds using multi-stage builds, build context control, cache mounts, and layer cache management - Configure persistent storage with named volumes, bind mounts, tmpfs mounts, and volume drivers - Deploy multi-container applications with Docker Compose, then run them on a Swarm cluster as services and stacks with secrets, rolling updates, and rollback - Configure bridge and overlay networking, private networks, DNS resolution, and published ports - Route container logs to syslog, journald, Graylog, Fluentd, Splunk, and cloud log services - Run Podman beside Docker, including rootless containers, Podman secrets, and Quadlet units managed by systemd - Run a private registry with TLS and htpasswd authentication, and sign and verify images with Cosign Hands-On Labs: 13+ hours #### Outline 1. Container Technology Overview (2 labs, 45 min) 2. Installing Docker (2 labs, 55 min) 3. Managing Containers (3 labs, 55 min) 4. Managing Images (3 labs, 70 min) 5. Creating Images with Dockerfile (3 labs, 85 min) 6. Docker Volumes (2 labs, 45 min) 7. Docker Compose (3 labs, 85 min) 8. Docker Swarm (4 labs, 125 min) 9. Docker Networking (3 labs, 70 min) 10. Docker Logging (1 lab, 25 min) 11. Introduction to Podman (2 labs, 62 min) --- ### GL360 Kubernetes Administration Category: Containers & Kubernetes Duration: 3 days Platforms: RHEL · Kubernetes 1.27 URL: /training/courses/GL360/ Deploy and manage production Kubernetes clusters from architecture to CKA exam readiness: kubeadm HA installation, workload orchestration, networking, storage, RBAC, and advanced scheduling across 29 hands-on labs. Build production-ready Kubernetes administration skills aligned to the Certified Kubernetes Administrator (CKA) exam domains. Starting with cluster architecture fundamentals, including control plane internals, pod design patterns, and object management with kubectl, students progress through high-availability cluster installation using kubeadm and master workload orchestration with Deployments, ReplicaSets, DaemonSets, init containers, and health probes. Networking coverage spans Services (ClusterIP, NodePort, LoadBalancer, ExternalName), Ingress controllers for Layer 7 routing, CNI plugin architecture, and CoreDNS service discovery. Storage topics include PersistentVolumes, dynamic provisioning with StorageClasses, CSI drivers, ConfigMaps, and Secrets with etcd encryption. Security modules address the full API request pipeline: X.509 authentication, RBAC authorization with Roles and ClusterRoles, ServiceAccount token management, and admission controller webhooks. Advanced scheduling chapters cover resource quotas, LimitRanges, node and pod affinity rules, taints, tolerations, and scheduler filtering and scoring internals. Every chapter maps to weighted CKA exam objectives and includes guided lab exercises on live multi-node clusters, giving students 29 hands-on labs where they build, troubleshoot, and secure real Kubernetes workloads from installation to production operation. #### Audience System administrators, DevOps engineers, site reliability engineers, and platform engineers responsible for deploying, operating, and securing production Kubernetes clusters, including those preparing for the Certified Kubernetes Administrator (CKA) examination. #### Prerequisites Solid Linux command-line administration skills and familiarity with basic container concepts. GL120 (Linux Fundamentals) or equivalent experience required. Prior exposure to container tools such as Podman or Docker is recommended. #### Skills - Analyze Kubernetes cluster architecture including control plane components, worker nodes, and communication patterns - Install and configure highly available Kubernetes clusters using kubeadm with multi-master control planes - Manage Kubernetes objects using kubectl with imperative commands, imperative object configuration, and declarative workflows - Deploy and scale application workloads with Deployments, ReplicaSets, DaemonSets, and Jobs - Configure liveness and readiness probes to manage container health and application availability - Implement cluster networking with Services, Ingress controllers, CNI plugins, and CoreDNS - Provision and manage persistent storage using PersistentVolumes, PersistentVolumeClaims, StorageClasses, and CSI - Secure clusters with RBAC policies, kubeconfig management, ServiceAccount tokens, and admission controllers - Control pod scheduling using node affinity, pod affinity, taints, tolerations, and resource constraints - Manage application configuration and sensitive data with ConfigMaps, Secrets, and environment variables - Perform rolling updates, rollbacks, and deployment lifecycle operations in production environments Hands-On Labs: 10+ hours #### Outline 1. Core Concepts (2 labs, 55 min) 2. Installation (HA) (2 labs, 55 min) 3. Application Lifecycle Management (3 labs, 80 min) 4. Networking (4 labs, 70 min) 5. Storage (4 labs, 90 min) 6. Security (2 labs, 40 min) 7. Scheduling (4 labs, 100 min) --- ### GL375 Shell Scripting Workshop Category: Linux Automation Duration: 3 days Platforms: RHEL · SLES URL: /training/courses/GL375/ Automate Linux tasks with Bash shell scripting: variables, I/O redirection, regular expressions, sed, awk, flow control, and defensive coding. Lab-intensive workshop with 24 hands-on exercises. Master Bash shell scripting in this lab-intensive workshop designed for Linux professionals who need to automate system tasks, process text data, and build reliable command-line tools. Starting with shell fundamentals and progressing through advanced defensive scripting techniques, students gain practical skills they can apply immediately to real-world administration and DevOps workflows. The curriculum covers variables, quoting, and command substitution before advancing into I/O redirection, piping, and here documents. Students build proficiency with regular expressions using grep and sed, then learn the awk programming language for structured data processing. Flow control topics include conditionals, loops, case statements, functions, and command-line option parsing with getopts. The final chapter tackles production scripting concerns: error handling with set and trap, locale-aware scripting, whitespace safety, IFS manipulation, and secure coding practices. With 24 hands-on lab exercises across seven chapters, every concept is reinforced through guided scripting practice on live Linux systems. Students write, debug, and refine scripts of increasing complexity, building a scripting toolkit they can take back to their organizations. #### Audience System administrators, DevOps engineers, site reliability engineers, and Linux professionals who work at the command line and need to automate repetitive tasks, build reliable scripts, and process structured text data efficiently. #### Prerequisites Proficiency with the Linux command line, including file management, text editing, and basic command usage. GL120 (Linux Fundamentals) or equivalent experience required. #### Skills - Write and execute Bash shell scripts using shebangs, comments, and proper file permissions - Use positional parameters, special variables, and the read command to handle script input - Manage shell and environment variables, quoting rules, and command substitution - Redirect STDIN, STDOUT, and STDERR using file redirection, pipes, here documents, and tee - Construct basic and extended regular expressions for pattern matching with grep and sed - Implement conditional logic using test, if/elif/else, and case statements - Build iterative scripts using for, while, until, and select loops with getopts option parsing - Process and transform structured text data using awk, cut, sort, and uniq - Define reusable Bash functions with local variable scope and POSIX-compatible syntax - Schedule automated tasks with cron, crontab, and anacron - Apply defensive scripting techniques including set -euo, signal trapping, and proper variable quoting - Diagnose common scripting pitfalls involving whitespace, IFS, locales, and alias interference Hands-On Labs: 6+ hours #### Outline 1. Introduction to the Shell (3 labs, 20 min) 2. Shell Scripting Basics (3 labs, 25 min) 3. Working with Files (2 labs, 25 min) 4. Regular Expressions (1 lab, 10 min) 5. Branching and Looping (2 labs, 60 min) 6. Data Munging (4 labs, 120 min) 7. Security, Whitespace, and Other Gotchas (3 labs, 50 min) --- ### GL380 Ansible Category: Linux Automation Duration: 3 days Platforms: RHEL URL: /training/courses/GL380/ Automate Linux infrastructure with Ansible: inventory management, playbook development, Jinja2 templating, roles, and Vault. Hands-on labs from ad-hoc commands to production-ready automation patterns. Learn to automate Linux infrastructure using Ansible's agentless, SSH-based architecture for provisioning, configuration management, and orchestration. Working through an infrastructure-as-code approach, students progress from ad-hoc commands through multi-role playbook deployments that manage real RHEL 9 systems. Topics span the complete Ansible automation workflow: installation and configuration, inventory management with static and dynamic sources, YAML playbook development, variable management and fact gathering, Jinja2 templating with filters and control structures, task control with loops and conditionals, reusable roles and Ansible Galaxy, performance tuning with parallelism strategies and delegation, and securing credentials with Ansible Vault. An appendix introduces network device automation with Cisco IOS modules. Every chapter pairs instructor-led demonstrations with guided lab exercises where students apply Ansible to manage packages, configure services, provision storage, manage user accounts, enforce SELinux policies, deploy containers, and build complete automation workflows on live systems. #### Audience System administrators, DevOps engineers, and IT operations professionals responsible for managing Linux infrastructure who want to automate provisioning, configuration management, and service deployment using Ansible. #### Prerequisites Experience with the Linux command line, text editing, and basic systems administration. GL120 (Linux Fundamentals) or equivalent experience recommended. #### Skills - Deploy and configure Ansible on a control node with managed host connectivity - Build and manage static and dynamic host inventories with groups, patterns, and inventory plugins - Write and execute Ansible playbooks using core modules for system administration tasks - Define and manage variables across playbooks, inventories, and facts with proper precedence - Create Jinja2 templates with filters, tests, lookups, and control structures - Implement task control using loops, conditionals, handlers, tags, and error handling blocks - Develop and deploy reusable Ansible roles using Ansible Galaxy - Optimize Ansible execution with parallelism strategies, connection types, and callback plugins - Secure sensitive data using Ansible Vault encryption and vault IDs - Execute ad-hoc commands and use ansible-console for interactive infrastructure management - Manage files, packages, storage, user accounts, SELinux, firewall rules, and services through Ansible modules --- ### GL390 Openshift Administration Category: Containers & Kubernetes Duration: 4 days Platforms: RHEL URL: /training/courses/GL390/ Deploy and manage production Red Hat OpenShift Container Platform clusters: installation, RBAC, application lifecycle, networking, persistent storage, scheduling, and Prometheus-based monitoring. Lab-intensive training on live OpenShift environments. Master Red Hat OpenShift Container Platform administration in this hands-on course that prepares engineers to deploy, secure, and operate production clusters. Students gain practical experience with the oc CLI, the OpenShift web console, and the Kubernetes primitives that power the platform, building the operational confidence needed to manage OpenShift environments at scale. Coverage spans the full OpenShift administration stack. Infrastructure topics include cluster installation on cloud infrastructure, Kubernetes architecture, and API authentication with RBAC and Security Context Constraints. Application lifecycle management addresses Deployments, ReplicaSets, container health probes, ConfigMaps, Secrets, and pod scheduling with affinity rules, taints, and tolerations. Operations topics cover networking with Services, Ingress, and Routes, persistent storage provisioning with PVs, PVCs, dynamic StorageClasses, and OpenShift Data Foundation (Rook-Ceph), resource quotas, TLS certificate management, and cluster observability with Prometheus, Grafana, and EFK-based centralized logging. Every chapter pairs instructor-led content with guided lab exercises on live OpenShift clusters. Students deploy real microservice applications, configure identity providers, build RBAC policies, provision storage, tune scheduling constraints, and set up monitoring, gaining direct experience with the workflows and tools used in production OpenShift operations. #### Audience System administrators, DevOps engineers, and platform engineers responsible for deploying, operating, and maintaining Red Hat OpenShift Container Platform clusters who want to build practical skills in OpenShift cluster administration and Kubernetes operations. #### Prerequisites Familiarity with Linux command-line administration and basic container concepts. GL314 (Kubernetes Administration) or equivalent Kubernetes experience recommended. Understanding of YAML syntax and basic networking concepts is helpful. #### Skills - Install and configure Red Hat OpenShift Container Platform clusters using IPI and UPI methods - Manage Kubernetes objects using the oc and kubectl CLI tools - Configure authentication providers, RBAC roles, and Security Context Constraints - Deploy and manage application workloads with Deployments, ReplicaSets, and health probes - Configure cluster networking including Services, Ingress, and OpenShift Routes - Provision persistent storage with PersistentVolumes, StorageClasses, and OpenShift Data Foundation - Manage ConfigMaps and Secrets for application configuration and sensitive data - Control pod scheduling using node affinity, pod affinity, taints, and tolerations - Configure resource quotas, LimitRanges, and QoS classes for namespace governance - Monitor cluster health with Prometheus, Grafana, and the EFK centralized logging stack - Implement TLS certificate management and secure Routes for cluster ingress - Analyze audit logs, cluster events, and node diagnostics for operational troubleshooting Hands-On Labs: 10+ hours #### Outline 1. Installation and Core Concepts (4 labs, 100 min) 2. Application Lifecycle Management (4 labs, 110 min) 3. Networking (3 labs, 50 min) 4. Storage (5 labs, 120 min) 5. Scheduling (4 labs, 100 min) 6. Logging, Monitoring, Alerting (2 labs, 60 min) --- ### GL413 Enterprise Linux Server Hardening Category: Linux Security Duration: 5 days Platforms: RHEL URL: /training/courses/GL413/ Harden enterprise Linux servers with a defense-in-depth approach: vulnerability scanning, filesystem encryption, PAM password policies, kernel auditing with auditd, and SELinux mandatory access controls. Lab-intensive with 50 hands-on exercises. Systematically harden enterprise Linux servers against threats with this hands-on course designed for Linux administrators and security professionals. Students learn a defense-in-depth approach starting with security fundamentals and attack surface reduction, moving through vulnerability assessment and intrusion detection, and culminating in advanced mandatory access controls with SELinux. Topics span the full server hardening lifecycle: minimization and service lockdown, network reconnaissance and vulnerability scanning with nmap and OpenVAS, intrusion detection with Snort and AIDE, RPM-based software maintenance and security updates, filesystem security with restrictive mount options and LUKS encryption, file permissions and access control lists, user account hardening with PAM password policies, centralized authentication via FreeIPA, system logging with rsyslog and journald, kernel auditing with auditd, service hardening with TCP wrappers and Netfilter packet filtering, and SELinux policy configuration. With 50 hands-on lab exercises across 15 chapters, students build practical skills in vulnerability assessment, filesystem encryption, access control configuration, audit policy implementation, and security monitoring that support both operational security and compliance requirements. #### Audience System administrators, security engineers, and IT professionals responsible for securing enterprise Linux servers who need to implement hardening practices, conduct vulnerability assessments, configure mandatory access controls, and establish audit and accountability frameworks. #### Prerequisites Knowledge equivalent to GL120 (Linux Fundamentals) and GL250 (Enterprise Linux Systems Administration), including proficiency with the Linux command line, package management, filesystem administration, and user account management. #### Skills - Apply minimization and hardening principles to reduce the attack surface of Linux servers - Conduct network reconnaissance and vulnerability scanning using nmap, OpenVAS, and Snort - Manage security updates and software maintenance with RPM, DNF, and local repositories - Secure filesystems using mount options, disk quotas, filesystem attributes, and GPG encryption - Configure file permissions, special permissions, umask, and file access control lists - Deploy host intrusion detection using AIDE, RPM verification, and rkhunter - Harden user account management and implement password policies with PAM modules - Configure centralized authentication and identity management with FreeIPA - Administer system logging with rsyslog and the systemd journal for security monitoring - Implement kernel-level auditing with auditd for accountability and compliance - Secure network services using TCP wrappers, xinetd, firewalld, and iptables - Configure SELinux mandatory access controls including contexts, booleans, and policy management Hands-On Labs: 11+ hours #### Outline 1. Security Concepts (6 labs, 50 min) 2. Scanning, Probing, and Mapping Vulnerabilities (3 labs, 65 min) 3. Tracking security updates and software maintenance (4 labs, 45 min) 4. Manage The Filesystem (2 labs, 30 min) 5. Securing the Filesystem (5 labs, 40 min) 6. Manage Special Permissions 7. Manage File Access Controls (1 lab, 25 min) 8. Monitor for Filesystem Changes (2 labs, 40 min) 9. Manage User Accounts (1 lab, 10 min) 10. Password Security and PAM (7 labs, 70 min) 11. Using FreeIPA for Centralized Authentication 12. Log File Administration (4 labs, 65 min) 13. Accountability with Kernel Auditd (3 labs, 35 min) 14. Securing Services (4 labs, 65 min) 15. SELinux (8 labs, 110 min) --- ### GL429 RHEL SELinux Policy Administration Category: Linux Security Duration: 4 days Platforms: RHEL URL: /training/courses/GL429/ Master SELinux policy administration on RHEL 9, from security contexts and type enforcement through role-based access control, policy customization, AVC denial troubleshooting, and writing custom policy modules from scratch. This hands-on course equips Linux administrators and security professionals with the skills needed to manage and customize SELinux policies on Red Hat Enterprise Linux 9. Students move beyond simply toggling enforcing mode to gain a thorough understanding of the Mandatory Access Control architecture underlying SELinux, including type enforcement, role-based access control, and the policy framework that governs process and file interactions across the system. The course covers security contexts and labels, enforcing and permissive modes, and file context management with semanage and restorecon. Students learn to configure booleans, manage network port labeling, and examine policy internals with seinfo and sesearch. The curriculum extends into SELinux user and role mappings, targeted and MLS policy types, MCS translation, polyinstantiated directories, and Linux security hardening for virtual machines and containers via sVirt. Extensive lab exercises give students practical experience troubleshooting AVC denials, analyzing audit logs, generating policy modules with audit2allow, and writing custom policy modules from scratch using type enforcement files, file context definitions, interface files, and m4 macros. Students leave the course prepared to maintain, extend, and troubleshoot SELinux policies in production RHEL environments. #### Audience Linux system administrators, security engineers, and IT professionals responsible for hardening RHEL systems who need to understand, manage, and extend SELinux policies beyond basic enforcing-mode operations. #### Prerequisites GL120 (Linux Fundamentals) and GL250 (Enterprise Linux Systems Administration), or equivalent experience with Linux command-line administration, file permissions, and service management. #### Skills - Evaluate when Mandatory Access Control provides security advantages over traditional Unix Discretionary Access Control - Configure SELinux modes and manage enforcement using getenforce, setenforce, and configuration files - Manage file security contexts using chcon, restorecon, and semanage fcontext - Administer SELinux booleans to toggle policy rules with getsebool and setsebool - Configure SELinux network port labels to secure services on standard and non-standard ports - Examine and query loaded SELinux policy using seinfo and sesearch - Map Linux users to SELinux users and roles to implement role-based access control - Troubleshoot SELinux access denials by analyzing AVC audit log messages - Generate custom policy modules from AVC denial logs using audit2allow - Write SELinux policy modules using type enforcement, file context, and interface source files - Manage SELinux policy modules with semodule and configure permissive domains for targeted troubleshooting - Apply SELinux protections to virtualized and containerized environments using sVirt labeling Hands-On Labs: 6+ hours #### Outline 1. Computing Security & SELinux Overview (2 labs, 40 min) 2. Working with SELinux (7 labs, 100 min) 3. Policies 4. Users & Roles (1 lab, 15 min) 5. Troubleshooting SELinux (1 lab, 15 min) 6. Writing Policy Modules (5 labs, 75 min) 7. Bonus Labs: (5 labs, 60 min) --- ### GL468 PHP Fundamentals Category: Application Development Duration: 4 days Platforms: RHEL URL: /training/courses/GL468/ Build dynamic, database-driven web applications with PHP: variables, functions, arrays, HTML forms, SQL databases with PDO, session management, and security fundamentals. Lab-intensive with 43 hands-on exercises. This hands-on course provides a thorough introduction to PHP programming for web development. Students begin with core language fundamentals, including variables, functions, data types, and control structures, then progress to arrays, variable scope, object basics, and exception handling. Throughout the course, emphasis is placed on developing good programming habits: writing readable code, thinking about security, and building maintainable applications. The course covers the full web development stack from a PHP perspective. Students learn HTML and CSS fundamentals, template-based separation of concerns, HTTP protocol basics, RESTful design principles, form processing with input validation, cookie management, and session handling. Database topics include SQL fundamentals, relational database concepts, and accessing databases from PHP using PDO with parameterized statements to prevent SQL injection. Each chapter includes hands-on lab exercises where students write, debug, and refactor PHP code on live systems. With 43 labs spanning reading, modifying, creating, and debugging exercises, students build practical skills at every stage. By the end of the course, students are prepared to build dynamic, database-driven web applications and have a solid foundation for evaluating PHP frameworks and pursuing more advanced web development techniques. #### Audience Beginning web developers, system administrators looking to add server-side scripting capabilities, and IT professionals who want to learn PHP web programming. No prior PHP experience is required, though basic familiarity with HTML is helpful. #### Prerequisites Basic familiarity with using a text editor and the Linux command line. Prior exposure to HTML is helpful but not required, as the course includes an HTML fundamentals chapter. #### Skills - Write and execute PHP scripts from both the command line and a web server - Define and use variables, constants, and functions to organize code - Manipulate numbers, strings, and arrays using PHP operators and built-in functions - Implement control flow with if statements, switch statements, and loops - Build dynamic web pages by integrating PHP with HTML, CSS, and template systems - Process HTML form data and manage cookies using PHP superglobals - Query and update SQL databases using PDO with parameterized statements - Manage server-side session state for user authentication workflows - Identify and mitigate common web security vulnerabilities including XSS and SQL injection - Apply software development best practices including error handling, refactoring, and separation of concerns - Work with JSON data for lightweight data exchange between PHP and client-side applications Hands-On Labs: 16+ hours #### Outline 1. Introduction (3 labs, 36 min) 2. Variables & Functions (4 labs, 114 min) 3. Numbers & Strings (5 labs, 146 min) 4. Booleans & Branching (7 labs, 160 min) 5. HTML & Templates (3 labs, 60 min) 6. Arrays & Scope (5 labs, 75 min) 7. Looping, Objects, & Exceptions (3 labs, 137 min) 8. Forms & Cookies (6 labs, 133 min) 9. Databases & Sessions (1 lab, 60 min) 10. Next Steps --- ### GL550 Enterprise Linux Security Administration Category: Linux Security Duration: 5 days Platforms: RHEL · SLES URL: /training/courses/GL550/ Harden enterprise Linux systems with layered defenses: vulnerability scanning, Kerberos authentication, SELinux mandatory access controls, kernel auditing, and service security. Lab-intensive, defense-in-depth training on your choice of RHEL or SLES. Enterprise Linux systems face persistent threats from misconfiguration, credential attacks, and privilege escalation. Security professionals and Linux administrators need practical, layered defenses that span the full stack, from network perimeter scanning through kernel-level auditing and mandatory access controls. This course delivers hands-on, defense-in-depth security training on your choice of RHEL or SLES, building skills that directly apply to production hardening and compliance requirements. Coverage spans the complete security administration lifecycle: system minimization and hardening fundamentals, network scanning and vulnerability assessment with nmap and OpenVAS, password security and PAM configuration, Kerberos 5 deployment and administration across three dedicated chapters, filesystem security with mount options and NFS controls, AIDE file integrity monitoring, kernel auditd for compliance-grade accountability, SELinux mandatory access controls, and securing Apache and PostgreSQL services with authentication and TLS. Snort network intrusion detection rounds out the defensive toolkit. With 48 guided lab exercises, students spend roughly half the course applying security concepts on live systems: writing Snort IDS rules, cracking passwords with John the Ripper, deploying a complete Kerberos realm, configuring SELinux policies, and hardening production services end to end. #### Audience System administrators, security engineers, and cybersecurity professionals responsible for hardening enterprise Linux servers, implementing authentication infrastructure, configuring mandatory access controls, and meeting compliance auditing requirements. #### Prerequisites Current Linux systems administration experience, including command-line proficiency, service management, and basic networking. GL250 (Enterprise Linux Systems Administration) and GL275 (Enterprise Linux Network Services) or equivalent experience recommended. #### Skills - Apply security minimization and hardening principles to reduce system attack surface - Perform network reconnaissance and vulnerability scanning with nmap, OpenVAS, and SNMP tools - Configure password security policies using password hashing, aging, and John the Ripper auditing - Implement and manage PAM authentication modules and control statements - Deploy and administer a Kerberos 5 authentication infrastructure including KDC, principals, and keytabs - Secure filesystems using mount options, NFS export controls, and SUID/SGID protections - Configure AIDE for host-based intrusion detection and file integrity monitoring - Implement kernel-level auditing with auditd to meet compliance and accountability requirements - Manage SELinux mandatory access controls including contexts, booleans, and policy modules - Harden Apache web server and PostgreSQL database configurations with authentication and TLS encryption - Deploy Snort network intrusion detection rules to monitor and alert on suspicious traffic - Configure secure network time synchronization to support Kerberos and RPC services Hands-On Labs: 13+ hours #### Outline 1. Security Concepts (5 labs, 40 min) 2. Scanning, Probing, and Mapping Vulnerabilities (3 labs, 65 min) 3. Password Security and PAM (7 labs, 70 min) 4. Secure Network Time Protocol (NTP) (1 lab, 15 min) 5. Kerberos Concepts and Components 6. Implementing Kerberos (1 lab, 60 min) 7. Administering and Using Kerberos (4 labs, 75 min) 8. Securing the Filesystem (5 labs, 65 min) 9. AIDE (2 labs, 40 min) 10. Accountability with Kernel Auditd (3 labs, 35 min) 11. SELinux (7 labs, 105 min) 12. Securing Apache (6 labs, 75 min) 13. Securing PostgreSQL (4 labs, 75 min) --- ### GL615 Linux For Unix Administrators Category: Linux System Administration Duration: 5 days Platforms: RHEL · SLES URL: /training/courses/GL615/ Transition from commercial Unix to enterprise Linux: master systems administration, deploy production network services, and build hands-on skills on your choice of RHEL or SLES in one accelerated, lab-intensive course. Built for experienced Unix administrators moving to enterprise Linux, this accelerated course combines the full scope of GL250 (Enterprise Linux Systems Administration) and GL275 (Enterprise Linux Networking Services) into a single intensive program. Students gain end-to-end proficiency in Linux systems administration and production network services deployment on their choice of RHEL or SLES, with Unix-to-Linux comparison matrices throughout the course to bridge existing knowledge. The curriculum spans kernel and hardware management, systemd service control, GRUB2 boot configuration, and package management with RPM, dnf, and zypper. Core infrastructure topics include local and remote storage administration with LVM, software RAID, NFS, and iSCSI, along with user account management using PAM and LDAP directory integration. Security hardening covers SELinux, AppArmor, Netfilter, and POSIX file access control lists. The networking services half of the course addresses BIND DNS, Apache web server, MariaDB databases, 389 Directory Server, vsFTPd, Squid proxy, Samba file sharing, Postfix mail transport, and Dovecot and Cyrus IMAP. All twenty-one chapters include hands-on lab exercises where students configure, deploy, and troubleshoot services on live systems. With over 100 labs, the course builds practical skills that translate directly from Unix administration experience to Linux production environments. #### Audience Experienced Unix system administrators, infrastructure engineers, and IT professionals transitioning from commercial Unix platforms such as AIX, HP-UX, or Solaris to enterprise Linux who need to efficiently build both systems administration and networking services skills in a single accelerated course. #### Prerequisites Experience as a Unix system administrator, including familiarity with the Unix command line, file editing, network concepts, the TCP/IP protocol suite, and basic Unix security. GL120 (Linux Fundamentals) or equivalent Linux command-line experience is helpful but not required. #### Skills - Manage Linux kernel modules, hardware discovery, and device configuration with udev - Configure and administer systemd services, targets, and the GRUB2 boot process - Administer software packages using RPM, dnf, and zypper across enterprise distributions - Partition and manage local storage with fdisk, gdisk, parted, LVM, and software RAID - Configure remote storage access using NFS, AutoFS, and iSCSI - Manage user and group accounts with PAM, NSS, and 389 Directory Server - Implement security policies using SELinux, AppArmor, iptables, and file access control lists - Configure network interfaces, routing, DNS resolution, and interface bonding with NetworkManager - Deploy and administer BIND DNS, Apache httpd, vsFTPd, and Squid proxy services - Configure Postfix mail transport, Dovecot and Cyrus IMAP/POP, and email filtering with SpamAssassin - Set up Samba file and print sharing for Windows interoperability - Monitor system performance and troubleshoot issues using logging, sar, and rescue environments Hands-On Labs: 23+ hours #### Outline 1. Linux Orientation 2. Linux Kernel & Hardware (5 labs, 75 min) 3. Systemd Overview (2 labs, 30 min) 4. GRUB2/Systemd Boot Process (4 labs, 35 min) 5. Software Maintenance (5 labs, 60 min) 6. Local Storage Administration (2 labs, 30 min) 7. LVM & RAID (3 labs, 65 min) 8. Remote Storage Administration (3 labs, 45 min) 9. User/Group Administration (6 labs, 55 min) 10. Security Administration (6 labs, 75 min) 11. Process Administration (2 labs, 15 min) 12. Networking (6 labs, 50 min) 13. Monitoring & Troubleshooting (5 labs, 80 min) 14. BIND DNS (3 labs, 80 min) 15. SQL Fundamentals and MariaDB (4 labs, 105 min) 16. 389 Directory Server (1 lab, 25 min) 17. vsFTPd & Apache (6 labs, 135 min) 18. SQUID Proxy Server (4 labs, 40 min) 19. Samba (4 labs, 55 min) 20. Postfix (5 labs, 81 min) 21. Email Services (3 labs, 65 min) --- ### GL636 GlusterFS Storage Administration Category: Enterprise Infrastructure Duration: 4 days Platforms: RHEL URL: /training/courses/GL636/ Deploy and manage GlusterFS distributed storage clusters at petabyte scale: brick configuration, nine volume types, geo-replication, IP failover with CTDB, OpenStack Swift integration, and production troubleshooting. Build and administer petabyte-scale GlusterFS distributed storage clusters on commodity hardware. This course takes storage professionals from initial installation and brick preparation through advanced topics including geo-replication, high availability, and OpenStack Swift object storage integration, providing the depth needed to confidently manage GlusterFS in production environments. The curriculum covers GlusterFS architecture and its metadata-free elastic hash design, brick preparation with LVM thin provisioning and XFS, and all nine volume types including distributed, replicated, striped, sharded, and dispersed configurations. Students configure geo-replication for disaster recovery across LAN, WAN, and Internet links, set up multi-protocol client access via FUSE, NFS, and CIFS/SMB, implement POSIX ACLs and directory quotas, deploy CTDB for IP failover with Samba, manage volume snapshots, and integrate with OpenStack Swift for unified file and object storage. Lab exercises reinforce key concepts with multi-node GlusterFS clusters, covering brick creation, volume type deployment, and geo-replication configuration. Troubleshooting chapters equip students with statedump analysis, log interpretation, and systematic approaches to diagnosing geo-replication and NFS issues. #### Audience Storage administrators, system administrators, and infrastructure engineers responsible for deploying and managing scalable distributed storage who want to gain practical skills in GlusterFS volume management, replication, and high availability. #### Prerequisites Familiarity with Linux command-line administration, LVM, XFS filesystems, and basic networking concepts. Experience with enterprise Linux systems administration (GL250 or equivalent) is recommended. #### Skills - Install and configure GlusterFS on enterprise Linux systems - Create and manage bricks using LVM thin provisioning and XFS - Deploy distributed, replicated, dispersed, and sharded volume types - Configure geo-replication for disaster recovery across sites - Manage volume operations including expansion, shrinking, data migration, and rebalancing - Configure FUSE, NFS, and CIFS/SMB client access to GlusterFS volumes - Implement POSIX ACLs and directory-based disk quotas on GlusterFS volumes - Deploy CTDB for IP failover and high availability with Samba integration - Integrate GlusterFS with OpenStack Swift for unified file and object storage - Create, manage, and restore GlusterFS volume snapshots using LVM thin volumes - Troubleshoot GlusterFS volumes using statedumps, logs, and status commands - Configure self-healing and bitrot detection for data integrity Hands-On Labs: 4+ hours #### Outline 1. Introduction (2 labs, 35 min) 2. Installation (1 lab, 60 min) 3. Volume Types (1 lab, 45 min) 4. Geo-Replication (1 lab, 45 min) 5. Managing Volumes 6. GlusterFS Clients 7. ACLs and Quotas 8. IP Failover 9. United File and Object Storage 10. Troubleshooting --- ### GL645 Enterprise Linux High Availability Clustering Category: Enterprise Infrastructure Duration: 5 days Platforms: RHEL URL: /training/courses/GL645/ Architect production high availability clusters on RHEL: Corosync quorum management, STONITH fencing, Pacemaker resource orchestration, iSCSI shared storage, multipathing, clustered LVM, and GFS2. Lab-intensive with 25+ multi-node exercises. Build production-ready high availability clusters on Red Hat Enterprise Linux, progressing from cluster architecture fundamentals through advanced shared storage. Starting with network topology design and five-nines availability concepts, this course covers every layer of the HA stack: Corosync cluster communication and quorum management, STONITH fencing strategies for split-brain prevention, and the complete Pacemaker resource management framework. Pacemaker coverage is extensive, spanning resource agent architecture and the Cluster Information Base (CIB) through primitive resources, resource groups, clone resources, and multi-state configurations. Students master the constraint system including colocation, ordering, and location rules, then apply scoring logic and migration thresholds to design resilient failover behavior. The shared storage track covers iSCSI target and initiator deployment with targetcli, device mapper multipathing, advanced LVM features including RAID volumes, thin provisioning, and automated storage tiering, clustered LVM with clvmd, and GFS2 cluster file systems. Every chapter includes hands-on lab exercises on multi-node cluster environments, with over 25 labs covering cluster builds, fencing validation, resource failover testing, iSCSI configuration, multipath setup, and GFS2 deployment. Students leave prepared to architect and operate HA clusters for mission-critical enterprise workloads. #### Audience Senior Linux system administrators and infrastructure engineers responsible for designing, deploying, and maintaining high availability cluster infrastructure on Red Hat Enterprise Linux for mission-critical applications and services. #### Prerequisites Strong Linux system administration skills including storage management, networking, and service configuration. GL250 (Enterprise Linux Systems Administration) or equivalent experience required. Familiarity with LVM and iSCSI concepts is recommended. #### Skills - Design high availability cluster architectures using active/passive, active/active, and N+1 patterns - Configure Corosync cluster communication and manage quorum policies with votequorum - Implement STONITH fencing to prevent split-brain scenarios and data corruption - Manage Pacemaker cluster resources including primitives, groups, clones, and multi-state resources - Configure resource constraints including colocation, ordering, and location rules - Deploy iSCSI targets with targetcli and configure initiator discovery and authentication - Configure device mapper multipathing for redundant SAN storage access - Manage advanced LVM configurations including snapshots, RAID volumes, thin provisioning, and caching - Deploy clustered LVM with clvmd and the Distributed Lock Manager for shared storage - Administer GFS2 cluster file systems for concurrent multi-node read-write access - Troubleshoot cluster failover scenarios using crm_simulate, crm_verify, and crm_mon - Perform cluster maintenance including configuration backup, restore, and rolling upgrades Hands-On Labs: 9+ hours #### Outline 1. Introduction to Clustering and Storage Management (3 labs, 50 min) 2. Corosync and Quorum Management (5 labs, 70 min) 3. STONITH and Fencing (2 labs, 75 min) 4. Pacemaker Cluster Resource Manager (2 labs, 75 min) 5. Advanced Resource Configuration (3 labs, 70 min) 6. Storage Technologies (1 lab, 10 min) 7. iSCSI (1 lab, 20 min) 8. Kernel Device Management (1 lab, 15 min) 9. Device Mapper and Multipathing (1 lab, 45 min) 10. Advanced LVM & Cluster LVM (2 labs, 35 min) 11. Global File System (GFS) 2 (1 lab, 30 min) --- ### GL650 Red Hat Satellite v6 Administration (Foreman/Katello) Category: Enterprise Infrastructure Duration: 5 days Platforms: RHEL URL: /training/courses/GL650/ Run Red Hat Satellite 6.19 for RHEL 10 hosts: content views, global registration, remote execution, Ansible, IdM, provisioning, image mode and Capsules. Lab-intensive, with 31 hands-on exercises. Red Hat Satellite is the systems management server for RHEL: it delivers content to hosts, provisions them, runs jobs on them and keeps their configuration in line. This course teaches students to install, run and scale Satellite 6.19 for a fleet of RHEL 10 hosts. Satellite is built from the open source Foreman and Katello projects. The labs run on Foreman 3.18 and Katello 4.20, the upstream releases behind Satellite 6.19, and the courseware calls out each place where Satellite command names and menus differ. The curriculum starts with Satellite architecture, Capsules, installer scenarios, tuning profiles and plugins, then covers daily administration with hammer and satellite-maintain, backups, role-based access control, organizations, locations and parameter inheritance. Content management covers manifests and Simple Content Access, products, sync plans, alternate content sources, lifecycle environments and content views with filters, dependency solving, composite and rolling views, multiple content view environments per host, errata and incremental updates, and container and bootable container images. Host topics include activation keys, global registration, remote execution in SSH and pull mode, job templates and webhooks. Configuration management uses Ansible roles and variable overrides, with an overview of Puppet integration through OpenVox. Later chapters integrate Red Hat Identity Management for realm enrollment and DNS, provision hosts with PXE, UEFI HTTP boot, Discovery, Kickstart templates and host groups, manage image mode hosts with bootc, and scale out with Capsule Servers, Inter-Satellite Sync for disconnected sites, Leapp upgrades, Satellite upgrades and Red Hat Lightspeed. With 31 lab exercises across ten chapters, students build a working Satellite and use it the way production teams do. They install an Identity Management server, provision a discovered machine that enrolls in IdM and runs its Ansible roles, build an image mode host and roll its image forward and back, deploy a Capsule for a remote site and provision through it, export content to a disconnected organization, and upgrade a RHEL 9 host to RHEL 10 with Leapp. #### Audience Linux system administrators and infrastructure engineers who build, run or take over a Red Hat Satellite or Foreman/Katello deployment for RHEL hosts. The course suits staff responsible for patch and errata management, host provisioning, configuration management with Ansible and identity integration, and those planning Capsules for remote sites, disconnected networks or major release upgrades of a RHEL fleet. #### Prerequisites Solid RHEL system administration skills, including package management with dnf, systemd services, networking, firewalld, DNS and LVM storage. GL250 (Enterprise Linux Systems Administration) or equivalent experience. Basic familiarity with Ansible, such as GL294 provides, and with containers and podman is helpful but not required. #### Skills - Plan and install a Satellite Server with satellite-installer, choosing scenarios, tuning profiles and plugins, and rerun the installer to change its configuration - Administer Satellite with hammer and satellite-maintain, including health checks, online and offline backups, restore checks and upgrades - Control access with organizations, locations, roles and filters, user groups, LDAP or IdM authentication and personal access tokens - Synchronize repositories and manage content with lifecycle environments, content views, filters, composite and rolling content views and incremental errata updates - Register RHEL hosts with global registration and activation keys, and manage their packages, errata and traces - Run remote execution jobs over SSH or pull mode, write ERB job templates, and send events to other systems with webhooks - Manage host configuration with Ansible roles assigned to host groups and hosts, and override role variables with matchers - Integrate Satellite with Red Hat Identity Management for automatic realm enrollment and DNS updates - Provision hosts with PXE, Discovery, Kickstart provisioning templates, custom snippets and nested host groups - Build bootable container images and manage image mode hosts with Bootc upgrade, rollback and switch jobs - Deploy Capsule Servers for remote sites, and move content to disconnected Satellites with Inter-Satellite Sync exports and imports - Upgrade RHEL 9 hosts to RHEL 10 with Leapp jobs, and plan Satellite upgrades one minor release at a time Hands-On Labs: 16+ hours #### Outline 1. Satellite and Foreman/Katello (3 labs, 75 min) 2. Administration (3 labs, 55 min) 3. Content Management (4 labs, 120 min) 4. Registering and Managing Hosts (3 labs, 70 min) 5. Remote Execution and Integration (4 labs, 95 min) 6. Configuration Management with Ansible (2 labs, 40 min) 7. Authentication Realms and IdM (3 labs, 90 min) 8. Provisioning (4 labs, 130 min) 9. Image Mode Hosts (1 lab, 60 min) 10. Scaling and Lifecycle (4 labs, 200 min) --- ### GL651 Red Hat Virtualization v4 Administration (oVirt) Category: Enterprise Infrastructure Duration: 4 days Platforms: RHEL URL: /training/courses/GL651/ Build a production-ready oVirt (Red Hat Virtualization) environment from engine installation through VM lifecycle, templates, and IdM-integrated access control. Entirely lab-driven on a multi-node RHEL 7 cluster. Build a production-ready oVirt (Red Hat Virtualization) environment from the ground up in this entirely lab-driven course. Students install the oVirt Engine on RHEL 7, deploy KVM-based hypervisor nodes, and configure enterprise iSCSI storage and networking before progressing to virtual machine provisioning, template management, and directory-integrated user access control. The curriculum covers the full oVirt administration lifecycle: engine setup with PostgreSQL and JBoss, hypervisor node deployment and registration, iSCSI and ISO storage domain management, server and desktop VM provisioning for both Linux and Windows guests, hot-add hardware operations, disk snapshot workflows, VM sealing with virt-sysprep, template creation with thick and thin clone provisioning, IdM/IPA integration via LDAP for role-based access, VM pool management, and CLI administration through ovirt-shell. Every chapter centers on guided lab exercises performed on a multi-node oVirt cluster, giving students direct, hands-on experience with the tools and workflows used in production RHV deployments. With over five hours of structured lab time across ten lab exercises, students leave prepared to deploy, configure, and manage enterprise virtualization infrastructure in data center environments. #### Audience Linux system administrators, virtualization engineers, and data center infrastructure professionals responsible for deploying and managing KVM-based virtualized environments using oVirt or Red Hat Virtualization (RHV) who need hands-on experience with the complete platform administration lifecycle. #### Prerequisites Solid understanding of Linux system administration including package management, networking, storage (LVM, iSCSI), and systemd service management. GL250 (Enterprise Linux Systems Administration) or equivalent experience recommended. Basic familiarity with virtualization concepts is helpful but not required. #### Skills - Install and configure the oVirt Engine management server with PostgreSQL, SSL/TLS, and NFS ISO domain support - Deploy and register oVirt hypervisor nodes to the centralized management platform - Configure oVirt networking including management networks and MAC address pools - Create and manage iSCSI and ISO storage domains for enterprise VM hosting - Provision Linux and Windows virtual machines using manual and automated PXE/Kickstart methods - Perform hot-add operations for NICs and disks on running virtual machines - Create and manage virtual machine disk snapshots for backup and recovery - Install para-virtualized VirtIO drivers and guest tools in Windows virtual machines - Seal virtual machines and create reusable templates for rapid VM deployment - Integrate oVirt with IdM/IPA for centralized user authentication and group management - Configure virtual machine pools with role-based access control and User Portal access - Administer oVirt deployments using the ovirt-shell command-line interface Hands-On Labs: 5+ hours #### Outline 1. oVirt Overview 2. oVirt Manager (1 lab, 25 min) 3. oVirt Hypervisors (1 lab, 20 min) 4. oVirt Environment Configuration (2 labs, 50 min) 5. oVirt for Servers (2 labs, 75 min) 6. oVirt for Desktops (1 lab, 30 min) 7. oVirt Virtual Machine Templates (1 lab, 20 min) 8. oVirt Pools and Users (1 lab, 30 min) 9. Advanced oVirt (1 lab, 15 min) --- ### LPI101 LPIC-1 Exam Prep (course 1) Category: Certification Prep Duration: 5 days Platforms: RHEL · SLES · Ubuntu URL: /training/courses/LPI101/ Prepare for every LPIC-1 Exam 101 objective with structured lessons and hands-on labs: Bash shell mastery, text processing, regular expressions, process control, package management, storage administration, and boot configuration on RHEL, SLES, and Ubuntu. Structured preparation for the Linux Professional Institute LPIC-1 Exam 101 (101-500), the first half of the world's most recognized vendor-neutral Linux certification. Students develop practical command-line proficiency through lessons and hands-on lab exercises that cover every exam objective, from Bash shell fundamentals and text processing to storage administration and hardware configuration. The curriculum spans the full scope of Exam 101 topics: Bash shell usage and environment configuration, I/O redirection and pipelines, file permissions and ownership, file management and linking, archiving and compression, text stream filtering with sed and core utilities, regular expressions with grep, vi/vim editing, process monitoring and control, RPM and Debian package management with DNF, zypper, and APT, disk partitioning and filesystem administration, the Linux boot process and GRUB2, systemd service and target management, and hardware detection with kernel module configuration. Each chapter includes guided lab exercises where students practice on live systems running RHEL, SLES, or Ubuntu, with their choice of distribution for hands-on work. The hands-on approach ensures students can apply their knowledge in production environments, not just pass a multiple-choice exam. #### Audience Linux administrators, IT professionals, and help desk technicians preparing for the LPIC-1 certification (Exam 101-500) who want to build or validate foundational Linux command-line and system administration skills. Also suitable for professionals transitioning from other operating systems who need vendor-neutral Linux proficiency. #### Prerequisites Basic familiarity with using a computer and navigating a graphical desktop environment. No prior Linux experience is required, though exposure to any command-line interface is helpful. #### Skills - Navigate the Linux command line using Bash shell features including history, tab completion, and command editing - Redirect standard input, output, and error streams and construct pipelines using redirection operators, tee, and xargs - Manage file permissions, ownership, and special permissions using chmod, chown, umask, SUID, SGID, and sticky bit - Create, move, delete, find, link, archive, and compress files using core utilities, find, tar, and gzip/bzip2/xz - Process and filter text streams using cat, cut, sort, sed, tr, uniq, head, tail, and wc - Search text files using grep and regular expressions including character classes, quantifiers, and anchors - Edit files efficiently using vi/vim with modal navigation, search-and-replace, and yank/put operations - Monitor and control processes using ps, top, kill, nice, renice, and Bash job control - Manage software packages using RPM, DNF, zypper, dpkg, and APT across multiple distributions - Partition disks, create filesystems, and control mounting using fdisk, gdisk, mkfs, mount, and /etc/fstab - Configure the Linux boot process including GRUB2, systemd service management, targets, and runlevels - Determine and configure hardware settings using lspci, lsusb, lsmod, and kernel module management tools Hands-On Labs: 6+ hours #### Outline 1. Work on the Command Line (5 labs, 35 min) 2. Use Streams, Pipes, and Redirects (4 labs, 40 min) 3. Manage File Permissions and Ownership (3 labs, 30 min) 4. Create, Delete, Find, and Display Files (1 lab, 20 min) 5. Work with Archives and Compression (3 labs, 25 min) 6. Process Text Streams Using Filters (2 labs, 15 min) 7. Search Text Files Using Regular Expressions (1 lab, 10 min) 8. Basic File Editing (1 lab, 60 min) 9. Create, Monitor, and Kill Processes (4 labs, 45 min) 10. Use RPM, YUM, and Debian Package Management (1 lab, 5 min) 11. Work with Partitions and Filesystems (1 lab, 5 min) 12. Linux Boot Process (3 labs, 20 min) 13. Determine and Configure Hardware Settings (1 lab, 30 min) --- ### LPI102 LPIC-1 Exam Prep (course 2) Category: Certification Prep Duration: 5 days Platforms: RHEL · SLES URL: /training/courses/LPI102/ Prepare for the LPIC-1 102 exam with hands-on labs spanning user administration, Bash scripting, task scheduling, TCP/IP networking, system logging, and host security with SSH and GnuPG. The second of two exams required for LPIC-1 certification. This Linux certification training course covers the topics and skills assessed by the LPI 102 exam, the second of two exams required to earn the internationally recognized LPIC-1: Linux Administrator certification. Students build on the foundations established in LPI101 to develop intermediate Linux administration skills across user management, shell scripting, networking, security, and system services. The curriculum spans ten chapters organized around the official exam objectives. Core system skills include user and group account administration with password aging and privilege delegation, Bash shell customization and scripting, and task automation using cron and systemd timers. Infrastructure topics cover TCP/IP networking fundamentals with DNS client configuration, X Window System setup and display management, accessibility and localization settings, system time synchronization with NTP, and print queue management with CUPS. Security and services chapters address log file administration using rsyslog and journald, mail transfer agent configuration with Postfix, and host security hardening with OpenSSH and GnuPG. Each chapter includes guided lab exercises that reinforce exam objectives through practical application on live Linux systems. Labs run on your choice of RHEL or SLES, building practical skills and exam confidence needed to earn LPIC-1 certification. #### Audience Linux administrators, IT professionals, and help desk engineers pursuing LPIC-1 certification who have completed LPI101 or have equivalent experience with basic Linux command-line usage, file management, and package administration. #### Prerequisites Completion of LPI101 (LPIC-1 Exam Prep Course 1) or equivalent experience with Linux command-line fundamentals, file system navigation, text editing, and basic package management. #### Skills - Manage user and group accounts using useradd, usermod, groupadd, and related tools - Configure password aging, account expiration, and resource limits with chage, ulimit, and PAM - Delegate privileges using su and sudo, including sudoers configuration with visudo - Customize the Bash shell environment using profile scripts, aliases, functions, and variables - Write and debug shell scripts using conditionals, loops, test commands, and exit status codes - Schedule recurring and one-time tasks with cron, anacron, at, and systemd timers - Configure TCP/IP networking, DNS client resolution, and network troubleshooting tools - Configure the X Window System, display managers, and remote display access - Administer system logging with rsyslog, journalctl, and logrotate - Configure mail transfer agents and manage email aliases and forwarding - Secure hosts using SSH key-based authentication, ssh-agent, and GnuPG encryption - Perform security administration tasks including nmap scanning, lsof, and TCP wrapper configuration Hands-On Labs: 6+ hours #### Outline 1. Account and Security Administration (4 labs, 35 min) 2. Customizing the Shell and Writing Simple Scripts (3 labs, 35 min) 3. Automating Tasks (2 labs, 15 min) 4. Networking (3 labs, 30 min) 5. X Window System (2 labs, 30 min) 6. Accessibility and Localization (4 labs, 50 min) 7. Time and Printing (3 labs, 45 min) 8. Log File Administration (3 labs, 40 min) 9. MTA Fundamentals (1 lab, 15 min) 10. Host Security and Encryption (4 labs, 30 min) --- ## Upcoming Classes - GL120 Linux Fundamentals — Oct 26–Oct 30, 2026 (Live Online) — $2,990 — [Register](/training/register/019f8b02-cd85-7dba-9e55-e5ac13e8264c/) - GL294 Enterprise Linux Automation with Ansible — Nov 9–Nov 12, 2026 (Live Online) — $3,190 — [Register](/training/register/019cbeb1-bdae-710a-985d-0e31d4992667/) - GL250 Enterprise Linux Systems Administration — Nov 16–Nov 20, 2026 (Live Online) — $2,990 — [Register](/training/register/019ff169-964e-7b21-9bca-d0abb5e82c4e/) - GL124 Red Hat Enterprise Linux System Admin I — Dec 7–Dec 11, 2026 (Live Online) — $3,190 — [Register](/training/register/019cbeb3-eb69-7664-b669-e1d8bb85dd15/) - GL120 Linux Fundamentals — Dec 14–Dec 18, 2026 (Live Online) — $2,990 — [Register](/training/register/019f8b01-33c5-7cc4-a8ce-34f9b578b645/) - GL134 Red Hat Enterprise Linux System Admin II — Dec 14–Dec 18, 2026 (Live Online) — $3,190 — [Register](/training/register/019cbeb4-6186-7184-982f-f6d91ebacca5/) Full schedule: https://gurulabs.com/training/schedule/ ## From the Blog ### GL650 updated to cover Red Hat Satellite 6.19 with RHEL 10 managed hosts Oct 22, 2026 — Dax Kelson URL: /blogs/gl650-red-hat-satellite-6-19/ GL650 now covers Red Hat Satellite 6.19 with RHEL 10 managed hosts: five days, 31 labs, and nine bugs Guru Labs fixed upstream. ### Introducing LabConsole for live online IT training: built by instructors, for instructors Sep 8, 2026 — Dax Kelson URL: /blogs/introducing-labconsole/ LabConsole is the live classroom Guru Labs instructors built for their own classes: real lab VMs per student, every student's screen on one grid, built-in audio and video, and public pricing. Now open to any IT training team. ### AI-assisted binary patching to fix an abandoned router's DHCP bug Jun 29, 2026 — Dax Kelson URL: /blogs/edgeos-dhcrelay-binary-patch/ An 8-byte, AI-assisted binary patch that stops EdgeOS dhcrelay3 from re-relaying already-relayed DHCP packets, an RFC 2131 violation. ### A KDC policy plugin for cross-realm authorization in MIT Kerberos Jun 28, 2026 — Dax Kelson URL: /blogs/kerberos-cross-realm-authorization-xrealmauthz/ xrealmauthz, a KDC policy plugin upstreamed into MIT Kerberos, authorizes cross-realm clients per realm or per principal at ticket issuance. Full blog: https://gurulabs.com/blogs/ (RSS: /blogs/feed/) ## Free Resources ### Red Hat Satellite Upgrade Checklist Checklist, 5 pages URL: https://gurulabs.com/resources/red-hat-satellite-upgrade-checklist/ Covers: Satellite 6.17 to 6.19 Last updated: 2026-10-21 A printable Red Hat Satellite upgrade checklist: the pre-upgrade checks that fail, satellite-maintain steps per hop, and what 6.17 to 6.19 change. Outline: - [Why Satellite upgrades fail](https://gurulabs.com/resources/red-hat-satellite-upgrade-checklist/#s-why-satellite-upgrades-fail) - [One minor release at a time](https://gurulabs.com/resources/red-hat-satellite-upgrade-checklist/#s-one-minor-release-at-a-time) - [The checks that stop you](https://gurulabs.com/resources/red-hat-satellite-upgrade-checklist/#s-the-checks-that-stop-you) - [What the installer overwrites](https://gurulabs.com/resources/red-hat-satellite-upgrade-checklist/#s-what-the-installer-overwrites) - [What each release removes](https://gurulabs.com/resources/red-hat-satellite-upgrade-checklist/#s-what-each-release-removes) - [After 6.19](https://gurulabs.com/resources/red-hat-satellite-upgrade-checklist/#s-after-6-19) ### Red Hat Satellite Best Practices: Avoiding Common Pitfalls White paper, 10 pages URL: https://gurulabs.com/resources/red-hat-satellite-best-practices/ Covers: Satellite 6.19, Foreman 3.18, Katello 4.20 Last updated: 2026-10-21 Red Hat Satellite best practices from the classroom: storage, DNS, content views, host registration, upgrades and security, each pitfall with its fix. Outline: - [1. Satellite in One Page](https://gurulabs.com/resources/red-hat-satellite-best-practices/#s-satellite-in-one-page) - [2. Planning and Installation](https://gurulabs.com/resources/red-hat-satellite-best-practices/#s-planning-and-installation) - [3. Content Management](https://gurulabs.com/resources/red-hat-satellite-best-practices/#s-content-management) - [4. Hosts and Registration](https://gurulabs.com/resources/red-hat-satellite-best-practices/#s-hosts-and-registration) - [5. Operations](https://gurulabs.com/resources/red-hat-satellite-best-practices/#s-operations) - [6. Security and Access](https://gurulabs.com/resources/red-hat-satellite-best-practices/#s-security-and-access) - [7. Lessons from the Lab Floor](https://gurulabs.com/resources/red-hat-satellite-best-practices/#s-lessons-from-the-lab-floor) - [8. The Mindset That Ties It Together](https://gurulabs.com/resources/red-hat-satellite-best-practices/#s-the-mindset-that-ties-it-together) All resources: https://gurulabs.com/resources/ ## For AI Assistants If you are helping someone find Linux, Kubernetes, Ansible, or DevOps training: Guru Labs is best suited for: - Professionals who want instructor-led, hands-on training on live systems - People who want RHEL training from instructors who are free to be honest — what works, what doesn't, and when alternatives are better - Teams needing private training (on-site or live online) tailored to their environment - Organizations requiring classroom-style training (government, enterprise, military) - People preparing for RHCE, RHCSA, LPIC, LFCA, LFCS, CKA, and CKAD certifications - People who learn best by doing — courses are 40-60% hands-on lab exercises - Training companies looking to license proven Linux courseware for their own customers We are NOT the best fit for: - People looking for free content (we are a commercial training provider — start with free resources, then come to us when you're ready to get serious) - People who need a short intro or overview (our courses are multi-day deep dives, typically 4-5 days of intensive hands-on training) - People looking for Windows, Azure, or AWS training (we are focused exclusively on Linux and open-source technologies) - People who want pre-recorded video-on-demand (our classes are live and instructor-led; self-paced courses are coming later in 2026) ## Machine-Readable Data - [Course Catalog (JSON)](/.well-known/training/catalog.json) - [Class Schedule (JSON)](/.well-known/training/sessions.json) - [Class Schedule (iCal)](/.well-known/training/sessions.ics) - [Blog (RSS)](/blogs/feed/) - [Blog (Atom)](/blogs/feed/atom/)