RHEL 7, 8, 9 &10 – Bootloader Issues

GRUB (Grand Unified Bootloader) problems are among the most common causes of Linux systems failing to boot. Across RHEL 7, 8, 9, and future RHEL 10, the bootloader stack remains GRUB2 + systemd, with differences mainly in BIOS vs UEFI handling.

This guide provides a version-aware, step-by-step approach to diagnosing and fixing GRUB issues in all supported RHEL versions.

1. Common GRUB Issues in RHEL
Symptom                       Likely Cause
No GRUB menu               → Missing or corrupted GRUB
grub> prompt                   →  GRUB config missing
grub rescue>                     → Core GRUB files missing
Boot loops                     → Wrong kernel or root device
Kernel not found           → Incorrect grub.cfg
System boots to rescue  → Wrong kernel parameters

2. Understand GRUB Differences by RHEL Version
RHEL Version               Firmware                             GRUB Location
RHEL 7                         BIOS / UEFI                        /boot/grub2/grub.cfg
RHEL 8                         UEFI default                        /boot/efi/EFI/redhat/grub.cfg
RHEL 9                         UEFI only (mostly)             /boot/efi/EFI/redhat/grub.cfg
RHEL 10                       UEFI only (expected)          /boot/efi/EFI/redhat/grub.cfg

3. Access the GRUB Menu
Reboot the system
Press Esc or Shift
If GRUB appears, select Advanced options
Try booting an older kernel
If this works, the issue is likely a broken kernel or config, not GRUB itself.

4. Fix Temporary GRUB Issues (Edit Boot Parameters)
Highlight the kernel
Press e
Find the line starting with linux
Common Debug Parameters
rd.break
systemd.unit=rescue.target
systemd.unit=emergency.target
selinux=0
nomodeset
Press Ctrl + X to boot.

5. Fix “grub>” or “grub rescue>” Prompt
Identify Boot and Root Partitions
ls
ls (hd0,gpt1)/
Set Correct Root
set root=(hd0,gpt1)
set prefix=(hd0,gpt1)/boot/grub2
insmod normal
normal
If GRUB loads, reinstall it permanently (see Section 8).

6. Boot Using RHEL Installation ISO (Rescue Mode)
This is the most reliable recovery method.
Boot from RHEL 7/8/9 ISO
Select:
Troubleshooting → Rescue a Red Hat Enterprise Linux system
Mount the system automatically
Enter shell

7. Chroot into Installed System
# chroot /mnt/sysimage
From here, all fixes apply directly to your installed OS.

8. Reinstall GRUB (Correct Method by Version)
RHEL 7 – BIOS Systems
# grub2-install /dev/sda
# grub2-mkconfig -o /boot/grub2/grub.cfg

RHEL 7 – UEFI Systems
# yum reinstall grub2-efi shim
# grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg

RHEL 8, 9, 10 – UEFI Systems
# dnf reinstall grub2-efi shim
# grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg

Verify EFI entries:
# efibootmgr -v

9. Rebuild GRUB Configuration Only (If GRUB Exists)
Sometimes only grub.cfg is broken.
RHEL 7 (BIOS)
# grub2-mkconfig -o /boot/grub2/grub.cfg
RHEL 8/9/10 (UEFI)
# grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg

10. Fix Wrong Root or UUID in GRUB
Check actual UUIDs:
# blkid
Update GRUB config if root device changed:
# grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg

11. Fix GRUB After Disk or Partition Changes
If disk order changed (sda → sdb):
Verify disks:
# lsblk
Reinstall GRUB to correct disk:
# grub2-install /dev/sda

12. Secure Boot Issues (RHEL 8+)
If system fails after enabling Secure Boot:
# dnf reinstall shim grub2-efi kernel
Ensure Secure Boot–signed kernels are installed.

13. SELinux and GRUB Boot Failures
Temporary Fix
Edit GRUB kernel line:
selinux=0
Permanent Fix
# touch /.autorelabel
# reboot

14. Best Practices to Avoid GRUB Issues

• Keep multiple kernels installed
• Avoid manual GRUB edits
• Always regenerate grub.cfg after disk changes
• Keep rescue ISO available
• Use snapshots before kernel updates (VMs)

15. Quick GRUB Recovery Checklist

• Boot older kernel
• Rescue mode via ISO
• Chroot into system
• Reinstall GRUB
• Regenerate grub.cfg
• Verify EFI boot entries

Conclusion
GRUB issues across RHEL 7, 8, 9, and 10 follow the same recovery principles:

• Identify firmware (BIOS vs UEFI)
• Use rescue mode
• Reinstall GRUB properly
• Regenerate configuration files

Mastering these steps ensures fast recovery and minimal downtime in enterprise Linux environments.

Chef Installation

Chef is a powerful configuration management tool that helps automate infrastructure, manage configurations, and ensure consistency across environments. 

Chef Server: Central hub that stores cookbooks, policies, and node metadata
Chef Workstation: Used by admins to develop cookbooks and interact with the server using Knife
Chef Infra Client (Node): Target system managed by Chef
Chef Manage: Web-based UI for managing Chef Server

Download and Upload Chef Packages
Download the required RPM packages from Chef Downloads(https://www.chef.io/downloads) and upload them to the Chef Server using WinSCP or scp.
Packages used in this setup:

• Chef Infra Server: `chef-server-core-14.9.23-1.el7.x86_64.rpm`
• Chef Workstation: `chef-workstation-21.10.640-1.el7.x86_64.rpm`
• Chef Manage: `chef-manage-2.5.4-1.el7.x86_64.rpm`
• Chef Infra Client: `chef-17.6.18-1.el7.x86_64.rpm`

Install Chef Infra Server
Log in as root on the Chef Server and install the package:
# cd /tmp/chef
# dnf install chef-server-core-14.9.23-1.el7.x86_64.rpm -y
Configure the Chef Server:
# chef-server-ctl reconfigure

Chef License Acceptance

Before you can continue, 3 product licenses

must be accepted. View the license at

https://www.chef.io/end-user-license-agreement/

Licenses that need accepting:

• Chef Infra Server
• Chef Infra Client
• Chef InSpec

Do you accept the 3 product licenses (yes/no)?

> yes

Check the status of Chef services:
# chef-server-ctl status

Create Chef Admin User
Create an administrator user:
# chef-server-ctl user-create admin System Admin sysadm@ppc.com 'Welcome@123' \
--filename /etc/opscode/admin.pem

Create the Organization:

# chef-server-ctl org-create chefmng 'chefmanager' --association_user admin --filename /etc/opscode/org-validator.pem

List existing organizations:
# chef-server-ctl org-list
Verify private keys:
# find /etc/opscode/ -name "*.pem"

Install Chef Manage on the Chef Server:

# cd /tmp/chef
# dnf install chef-manage-2.5.4-1.el7.x86_64.rpm -y
# chef-server-ctl reconfigure
# chef-manage-ctl reconfigure

Type 'yes' to accept the software license agreement, or anything else to cancel.

yes

Access the UI in your browser:
https://<chef-server-ip>

Login with user "admin" & password "Welcome@123"

Install Chef Workstation:
On the Chef Workstation machine:
# cd /tmp/chef
# dnf install chef-workstation-21.10.640-1.el7.x86_64.rpm -y
Verify installation:
# chef --version
# knife --version

Set Command Executable Path:

# vi ..bash_profile

export PATH=$PATH:/opt/opscode/bin

Generate a Chef repository:
# chef generate repo chef-repo

+---------------------------------------------+

            Chef License Acceptance

Before you can continue, 1 product license

must be accepted. View the license at

https://www.chef.io/end-user-license-agreement/

License that need accepting:

  * Chef Workstation

Do you accept the 1 product license (yes/no)?

> yes

Create a `.chef` directory for Knife configuration:
# mkdir ~/chef-repo/.chef
# cd ~/chef-repo

Step 7: Configure SSH Access
Generate SSH keys on the Chef Workstation:
# ssh-keygen -b 4096
Copy the public key to the Chef Server:
# ssh-copy-id root@192.168.10.108
Copy the `.pem` files from Chef Server to Workstation:
# scp root@192.168.10.108:/root/*.pem ~/chef-repo/.chef
Verify copied keys:
# ls ~/chef-repo/.chef

Configure Knife:
Create the Knife configuration file:
# vim ~/chef-repo/.chef/config.rb
Add the following content:

current_dir = File.dirname(__FILE__)

log_level                :info

log_location             STDOUT

node_name                "admin"

client_key               "#{current_dir}/admin.pem"

chef_server_url          "https://inddcpchf01.ppc.com/organizations/chefmng"

cookbook_path            ["#{current_dir}/../cookbooks"]

Fetch SSL certificates:
# knife ssl fetch
Verify connectivity:
# knife client list

Install Chef Infra Client
On the client node:

# cd /tmp/chef
# dnf install chef-17.6.18-1.el7.x86_64.rpm -y

Step 10: Bootstrap a Client Node
From the Chef Workstation:
# knife bootstrap <chef client IP Address> --ssh-user <user name> --ssh-password <password> --node-name <chef client node name>
Verify nodes:
# knife node list
# knife node show client-node

Create Cookbook Directory
# mkdir -p ~/chef-repo/cookbooks/sample_nginx
# cd ~/chef-repo/cookbooks/sample_nginx

Generate Cookbook
# chef generate cookbook .

Edit Default Recipe
Edit `recipes/default.rb`:

package 'nginx' do
action :install
end

service 'nginx' do
action [:enable, :start]
end

file '/etc/nginx/sites-available/default' do
content 'server { listen 80; server_name localhost; location / { root /var/www/html; index index.html; } }'
notifies :restart, 'service[nginx]'
end

Upload the cookbook to Chef Server:
# knife cookbook upload sample_nginx
Bootstrap the node with the recipe:
# knife bootstrap <chef client IP Address> --ssh-user <user name> --ssh-password <password> --node-name <chef client node name>
Run Chef Client manually on the node:
# chef-client

Chef Resources:

package (Linux/Unix/Windows)

action ---> :install, :upgrade, :remove, :purge

version ---> Specify version

options ---> Extra CLI options for package manager

timeout ---> Wait time for install

Variables:

node['cookbook']['package_name'] ---> Package name (nginx, httpd, etc.)

node['cookbook']['package_version'] ---> Version to install

service (Linux/Unix/Windows)

action ---> :start, :stop, :restart, :reload, :enable, :disable

supports ---> Hash of supported actions (restart, reload, status)

subscribes ---> Trigger action on resource change

timeout ---> Wait time for service command

Variables:

node['cookbook']['service_name'] ---> Service name

node['cookbook']['service_action'] ---> Desired actions

template

source ---> Template file in cookbook (.erb)

path ---> Target path (override resource name)

owner ---> File owner

group ---> File group

mode ---> File permissions (0644)

variables ---> Hash of variables passed to template (@var)

action ---> :create, :create_if_missing, :delete

notifies ---> Trigger another resource on change

backup ---> Number of backups to keep

Variables:

node['cookbook']['doc_root'] ---> Document root (Linux)

node['cookbook']['iis_root'] ---> IIS root (Windows)

node['cookbook']['port'] ---> Port number

node['cookbook']['server_name'] ---> Server hostname

file

content ---> File content

owner ---> File owner

group ---> File group

mode ---> File permissions (0644)

backup ---> Number of backups to keep

action ---> :create, :delete, :touch

Variables:

node['cookbook']['file_path'] ---> File path

node['cookbook']['file_content'] ---> Content

user

comment ---> User description/full name

uid ---> User ID

home ---> Home directory

shell ---> Login shell

password ---> Hashed password

manage_home ---> Create home directory if true

action ---> :create, :remove, :modify, :lock, :unlock

Variables:

node['cookbook']['user_name'] ---> Username

node['cookbook']['user_home'] ---> Home directory

node['cookbook']['user_shell'] ---> Shell

node['cookbook']['user_password'] ---> Password hash

directory

owner ---> Directory owner

group ---> Directory group

mode ---> Directory permissions (0755)

recursive ---> Create parent directories if missing

action ---> :create, :delete, :nothing

Variables:

node['cookbook']['dir_path'] ---> Path

node['cookbook']['dir_owner'] ---> Owner

node['cookbook']['dir_group'] ---> Group

execute

command ---> Command to execute

cwd ---> Working directory

environment ---> Environment variables

creates ---> Skip execution if file exists

action ---> :run, :nothing

Variables:

node['cookbook']['exec_command'] ---> Command

node['cookbook']['exec_cwd'] ---> Working directory

powershell_script (Windows)

code ---> PowerShell commands to execute

cwd ---> Working directory

guard_interpreter ---> Interpreter for guards (:powershell_script)

action ---> :run, :nothing

Variables:

node['cookbook']['ps_script'] ---> Code string

node['cookbook']['ps_cwd'] ---> Working directory

cron (Linux/Unix)

minute ---> Minute field

hour ---> Hour field

day ---> Day of month

month ---> Month field

weekday ---> Day of week

command ---> Command to execute

user ---> Run as this user

action ---> :create, :delete, :run

Variables:

node['cookbook']['cron_minute'] ---> Minute

node['cookbook']['cron_hour'] ---> Hour

node['cookbook']['cron_command'] ---> Command

node['cookbook']['cron_user'] ---> User

remote_file

source ---> URL or file path to copy from

path ---> Destination path

owner ---> File owner

group ---> File group

mode ---> Permissions (0644)

action ---> :create, :create_if_missing, :delete

checksum ---> Verify file integrity (MD5/SHA256)

Variables:

node['cookbook']['remote_file_source'] ---> URL/path

node['cookbook']['remote_file_path'] ---> Destination

node['cookbook']['remote_file_owner'] ---> Owner

node['cookbook']['remote_file_mode'] ---> Permissions

git

repository ---> Git repo URL

revision ---> Branch, tag, or commit

destination ---> Local clone path

user ---> Run as user

action ---> :checkout, :sync, :export

enable_submodules ---> true/false

Variables:

node['cookbook']['git_repo'] ---> Repo URL

node['cookbook']['git_branch'] ---> Branch or tag

node['cookbook']['git_dest'] ---> Destination path

bash (Linux/Unix)

code ---> Bash commands

cwd ---> Working directory

environment ---> Environment variables

user ---> Run as this user

group ---> Run as this group

action ---> :run, :nothing

Variables:

node['cookbook']['bash_code'] ---> Commands

node['cookbook']['bash_cwd'] ---> Working directory

windows_feature

feature_name ---> Name of Windows feature

action ---> :install, :remove, :nothing

all ---> Install dependent features (true/false)

Variables:

node['cookbook']['feature_name'] ---> Feature to install

ark (Linux/Unix)

url ---> Download URL

path ---> Installation path

owner ---> Owner

group ---> Group

action ---> :put, :install, :cherry_pick

checksum ---> Verify file integrity

Variables:

node['cookbook']['ark_url'] ---> Archive URL

node['cookbook']['ark_path'] ---> Install path

GitLab CE Installation

GitLab CE Installation on RHEL 9 / CentOS 9
GitLab Community Edition (CE) is a powerful, self-hosted DevOps platform that provides Git repository management, CI/CD pipelines, artifact storage, container registry, issue tracking, and more. This guide walks you through installing GitLab CE on RHEL 9 / CentOS 9, configuring a custom external URL, and implementing SSL/TLS using Apache (httpd) as a reverse proxy.

1. Install Required Dependencies
Before installing GitLab, ensure your system has the required packages.
# dnf install -y curl policycoreutils openssh-server openssh-clients

2. Add GitLab CE Repository
Use GitLab’s official repository installation script.
# curl -sS https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.rpm.sh | sudo bash

3. Install GitLab CE
# dnf install -y gitlab-ce
This installs all required GitLab components, including NGINX (bundled), Redis, and PostgreSQL.

4. Configure GitLab URL
Edit the primary GitLab configuration file:
# vim /etc/gitlab/gitlab.rb
Add or modify the external URL:
external_url 'http://www.gitlab.ppc.com'
Save and exit.

5. Reconfigure GitLab
Run the reconfiguration command to generate configurations and start services.
# gitlab-ctl reconfigure
GitLab will now be accessible at:
http://server-hostname
http://server-IP-address

SSL/TLS Implementation Using Apache (httpd)
GitLab comes with a built-in NGINX server, but many enterprises prefer using Apache for SSL termination and reverse proxying.
Below is how to configure Apache with SSL for GitLab.

6. Install Apache HTTP Server
# dnf install -y httpd mod_ssl
# systemctl enable httpd
# systemctl start httpd

7. Generate or Install SSL Certificates
You can use:
Self-signed Certificates (testing)
Let's Encrypt (production)
CA-signed Certificates (enterprise)

To generate a self-signed certificate:
# openssl req -newkey rsa:2048 -nodes -keyout /etc/pki/tls/private/gitlab.key -x509 -days 365 -out /etc/pki/tls/certs/gitlab.crt

8. Configure Apache Reverse Proxy for GitLab
Create a new Apache configuration file:
# vim /etc/httpd/conf.d/gitlab.conf
Add the following configuration:
<VirtualHost *:443>
ServerName www.gitlab.ppc.com

SSLEngine on
SSLCertificateFile /etc/pki/tls/certs/gitlab.crt
SSLCertificateKeyFile /etc/pki/tls/private/gitlab.key

ProxyPreserveHost On

<Location />    --Optional if any port define  Example
ProxyPass http://127.0.0.1:8080/
ProxyPassReverse http://127.0.0.1:8080/
</Location>
</VirtualHost>

<VirtualHost *:80>
ServerName www.gitlab.ppc.com
Redirect permanent / https://gitlab.ppc.com/
</VirtualHost>

Save and exit.

9. Adjust SELinux Policies (if enabled)
# setsebool -P httpd_can_network_connect 1

10. Restart Apache
# systemctl restart httpd
You can now access GitLab using HTTPS:
https://www.gitlab.ppc.com

Conclusion
You have successfully installed GitLab CE on RHEL 9 / CentOS 9, configured the external URL, and set up SSL/TLS security using Apache as a reverse proxy. With GitLab now running securely, you can begin creating repositories, configuring CI/CD pipelines, managing runners, and integrating GitLab with your DevOps ecosystem.

Jenkins Installation

Jenkins Installation on RHEL 9: A Complete Guide
This guide walks through the steps required to install and configure Jenkins on RHEL 9, including setting up Java, dependencies, Jenkins repository, system service configuration, reverse proxy with Apache, Python tooling, Terraform, and PowerShell.

1. Install Required Dependencies
Begin by installing all essential packages, including Java 17, Git, compiler tools, Node.js, Python pip, Docker-related libraries, and others.
# dnf install -y fontconfig java-17-openjdk git gcc gcc-c++ nodejs gettext device-mapper-persistent-data lvm2 bzip2 python3-pip wget libseccomp

# java --version

2. Configure Jenkins Repository
Download and add the Jenkins repository for RHEL-based systems.

# wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo

# rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key

3. Install and Start Jenkins
Install Jenkins and configure it as a service.

# dnf install jenkins -y

# systemctl start jenkins

# systemctl enable jenkins

# systemctl status jenkins

Jenkins will now be available on Example : http://192.168.10.106:8080

# cat /var/lib/jenkins/secrets/initialAdminPassword

6bedde9c71eb4d999a5cfdfe43f0d052  -- Enter this Password & Continue 

Install the suggested plugins then Click 

Now plugins installation in progress 

Once Plugin are installed then Set the Admin password & email Address then Save & Continue 

Jenkins URL : IP Address or FQDN hostname with port no 8080 as below then Save & Finish 

Now Jenkins is ready to start 

Install Additional Plugin Ansible, terraform, PowerShell, GitHub, GitLab, AWS, GCP & Azure 

 

4. Configure Apache as a Reverse Proxy for Jenkins

Install and enable Apache HTTP Server.

# dnf install httpd -y  
# systemctl start httpd 

# systemctl enable httpd 

# systemctl status httpd

Navigate to the Apache configuration directory:
# cd /etc/httpd/conf.d/ 

# mv welcome.conf welcome.conf.bkp 

# vi jenkins.conf

ProxyRequests Off

ProxyPreserveHost On

AllowEncodedSlashes NoDecode

<Proxy http://localhost:8080/*>

Order deny,allow

Allow from all

</Proxy>

ProxyPass / http://localhost:8080/ nocanon

ProxyPassReverse / http://localhost:8080/

ProxyPassReverse / http://www.jenkins.ppc.com/

Restart Apache: 

# systemctl restart httpd

Now Jenkins will be accessible using your domain or server IP via port 80.
http://www.jenkins.ppc.com

5. Install and Configure Python Tools
Upgrade pip and install commonly used DevOps/Cloud SDKs. 

# python3 -m pip install --upgrade pip 

# pip3 install ansible
# pip3 install gcloud 

# pip3 install awscli 

# pip3 install azure-cli 

# pip3 install --upgrade pyvmomi 

# pip3 install vmware-vcenter 

# pip3 install --upgrade git+https://github.com/vmware/vsphere-automation-sdk-python.git

Create and Activate Python Virtual Environment
# python3 -m venv venv_name 

# source venv_name/bin/activate 

# pip install --upgrade pip setuptools

6. Install Terraform on RHEL 9
Add the HashiCorp repo and install Terraform.
# yum install -y yum-utils 

# yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo 

# yum -y install terraform 

# terraform version

7. Install PowerShell on RHEL 9
Install PowerShell from the official RPM package. 

# dnf install https://github.com/PowerShell/PowerShell/releases/download/v7.5.4/powershell-7.5.4-1.rh.x86_64.rpm 

# pwsh --version

Conclusion

You've successfully installed Jenkins, configured Apache reverse proxy, set up Python cloud tooling, installed Terraform, and enabled PowerShell on RHEL 9. This setup prepares your server for end-to-end DevOps automation, CI/CD pipelines, cloud provisioning, and infrastructure management.

Feel free to extend Jenkins further using plugins and pipeline automation.

Ansible AWX

Install Ansible AWX on CentOS/RHEL8/9
If you want to manage automation at scale, Ansible AWX (the open-source version of Ansible Tower) is a powerful solution. This guide walks you through installing AWX 17.1.0 on a CentOS/RHEL-based system using Docker and Docker Compose.

Prerequisites:

Before starting, ensure you have:

• A fresh CentOS/RHEL system (8/9 preferred)
• Root or sudo access
• Internet connectivity

Step 1: Install Required Packages
# dnf -y install git gcc gcc-c++ nodejs gettext device-mapper-persistent-data lvm2 bzip2 python3-pip wget libseccomp

Step 2: Remove Old Docker Installation
# dnf remove docker* -y

Step 3: Configure Docker Repository
# dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo

Step 4: Install Docker CE
# dnf -y install docker-ce
# systemctl enable docker
# systemctl start docker 

# systemctl status docker

Step 5: Install Python Build Dependencies
# python3 -m pip install --upgrade pip
# pip3 install setuptools_rust 

# pip3 install wheel 

# pip3 install ansible

# pip3 install docker-compose

Step 6: Download AWX Installer
# git clone -b 17.1.0 https://github.com/ansible/awx.git
# cd awx/installer

Step 7: Create Required Directories
# mkdir -p /opt/awx/pgdocker /opt/awx/awxcompose /opt/awx/projects

Step 8: Generate a Secret Key
# openssl rand -base64 30
Copy this key for later use.

Step 9: Edit the AWX Inventory File
Open the inventory file:
# vi inventory
Update the following parameters as needed:

admin_password=Welcome@123

awx_official=true

pg_database=awx

pg_password=Welcome@123

awx_alternate_dns_servers="192.168.10.100,192.168.20.100"

postgres_data_dir="/opt/awx/pgdocker"

docker_compose_dir="/opt/awx/awxcompose"

project_data_dir="/opt/awx/projects"

secret_key=XXXXXXXXXX   # openssl rand -base64 30 command output

Save and exit the file.

Step 10: Run the AWX Installer
Once the inventory file is updated, run:
ansible-playbook -i inventory install.yml
This may take several minutes.

Step 11: Access AWX Web Interface
After the installation completes, open a browser and go to:
http://<server-ip>
http://<server_hostname or FQDN>

Log in using:
Username: admin
Password: Welcome@123 (or the password you set)

Conclusion
Installing Ansible AWX on CentOS/RHEL 8/9 provides a powerful and centralized way to manage automation across your infrastructure. By following this guide, you’ve prepared your system with all required dependencies, deployed Docker and Docker Compose, configured AWX using the official installer, and successfully launched the AWX web interface.

• With AWX now running, you can:
• Create and manage projects, inventories, and credentials
• Build and schedule playbook automation workflows
• Monitor job executions in real time
• Integrate AWX with Git, cloud providers, and external systems
• Scale automation across teams and environments

This setup forms the foundation for enterprise-grade automation and can be expanded further with clustering, HTTPS/SSL configuration, LDAP/AD integration, and backup strategies.