Linux + Ansible in Action: Solving Real DevOps Process Management Problems

Ansible is the ideal way to automate these real-world Linux process management scenarios.

We’ll create a complete Ansible mini-project called

🧩 “Process Management Lab for DevOps Engineers”

This will let you simulate, detect, and fix real production issues automatically on Linux servers.

🚀 Project Overview

🎯 Objective

Use Ansible to automate:

1.Service crash detection & auto-restart

2.High CPU process control

3.Zombie process cleanup

4.Jenkins build hang recovery

5.Rogue process detection & kill

6.Memory leak monitoring

🧱 Project Structure

process_mgmt_lab/

├── ansible.cfg

├── inventory

├── playbooks/

│ ├── restart_service.yml

│ ├── control_cpu.yml

│ ├── clear_zombies.yml

│ ├── kill_process_tree.yml

│ ├── detect_rogue.yml

│ └── monitor_memory.yml

└── roles/

└── common/

└── tasks/

└── debug_output.yml

⚙️ ansible.cfg

[defaults]

inventory = inventory

host_key_checking = False

remote_user = ec2-user

become = True

📜 inventory

[devservers]

dev1 ansible_host=192.168.1.10

dev2 ansible_host=192.168.1.11

🧩 Playbook 1 — Restart Crashed Service

playbooks/restart_service.yml

• 
  

  name: Detect and restart crashed service
  
  hosts: devservers
  
  become: yes
  
  tasks:

  
  
  
  
  
  • name: Check if myapp service is active
    ansible.builtin.systemd:
    name: myapp
    state: started
    register: app_status
  
  
  • name: Restart service if failed
    ansible.builtin.systemd:
    name: myapp
    state: restarted
    when: app_status.status.ActiveState != "active"
  
  
  • name: Log service status
    debug:
    msg: "Service restarted successfully if it was down."
  
  
  
  
  
  

🧠 Simulates real crash recovery.

🧩 Playbook 2 — Control High CPU Usage

playbooks/control_cpu.yml

• 
  

  name: Detect and control high CPU usage
  
  hosts: devservers
  
  become: yes
  
  tasks:

  
  
  
  
  
  • name: Get top CPU-consuming processes
    shell: "ps -eo pid,comm,%cpu --sort=-%cpu | head -n 6"
    register: cpu_processes
  
  
  • name: Display current top CPU processes
    debug:
    var: cpu_processes.stdout_lines
  
  
  • name: Reduce CPU priority for top offender
    shell: "renice +10 -p $(ps -eo pid --sort=-%cpu | sed -n 2p)"
    ignore_errors: yes
  
  
  • name: Confirm new priority
    shell: "ps -o pid,ni,comm --sort=ni | head"
    register: nice_output
  
  
  • debug:
    var: nice_output.stdout_lines
  
  
  
  
  
  

🧠 Automatically finds and lowers CPU priority of top process.

🧩 Playbook 3 — Clear Zombie Processes

playbooks/clear_zombies.yml

• 
  

  name: Detect and clear zombie processes
  
  hosts: devservers
  
  become: yes
  
  tasks:

  
  
  
  
  
  • name: Find zombie processes
    shell: "ps -eo pid,stat,ppid,cmd | grep 'Z'"
    register: zombies
    ignore_errors: yes
  
  
  • name: Display zombies
    debug:
    var: zombies.stdout_lines
  
  
  • name: Kill parent processes of zombies
    shell: "for p in $(ps -eo ppid,stat | awk '$2 ~ /Z/ {print $1}' | sort -u); do kill -9 $p; done"
    when: zombies.stdout != ""
    ignore_errors: yes
  
  
  • name: Confirm cleanup
    shell: "ps -eo stat | grep Z || echo 'No zombies left'"
    register: check
  
  
  • debug:
    var: check.stdout_lines
  
  
  
  
  
  

🧠 Detects and clears zombie (defunct) processes.

🧩 Playbook 4 — Kill Jenkins Build Tree

playbooks/kill_process_tree.yml

• 
  

  name: Kill Jenkins build process tree
  
  hosts: devservers
  
  become: yes
  
  tasks:

  
  
  
  
  
  • name: Find Jenkins or Maven parent PID
    shell: "pgrep -f 'mvn|jenkins'"
    register: jenkins_pid
    ignore_errors: yes
  
  
  • name: Show process tree
    shell: "pstree -p {{ jenkins_pid.stdout }}"
    register: tree
    when: jenkins_pid.stdout != ""
    ignore_errors: yes
  
  
  • debug:
    var: tree.stdout_lines
  
  
  • name: Kill process tree safely
    shell: "pkill -TERM -P {{ jenkins_pid.stdout }} && kill -9 {{ jenkins_pid.stdout }}"
    when: jenkins_pid.stdout != ""
    ignore_errors: yes
  
  
  
  
  
  

🧠 Simulates CI/CD hang cleanup.

🧩 Playbook 5 — Detect and Kill Rogue Processes

playbooks/detect_rogue.yml

• 
  

  name: Detect rogue or unknown processes
  
  hosts: devservers
  
  become: yes
  
  tasks:

  
  
  
  
  
  • name: List suspicious binaries in /tmp or /var/tmp
    shell: "ps -eo pid,cmd | grep '/tmp/' | grep -v grep"
    register: rogue
  
  
  • name: Show rogue processes
    debug:
    var: rogue.stdout_lines
  
  
  • name: Kill and remove rogue processes
    shell: |
    for pid in $(echo "{{ rogue.stdout }}" | awk '{print $1}'); do
    kill -9 $pid
    done
    when: rogue.stdout != ""
    ignore_errors: yes
  
  
  
  
  
  

🧠 Protects system by auto-killing unapproved binaries.

🧩 Playbook 6 — Monitor Memory Leaks

playbooks/monitor_memory.yml

• 
  

  name: Monitor memory usage for suspicious growth
  
  hosts: devservers
  
  become: yes
  
  tasks:

  
  
  
  
  
  • name: Capture top 5 memory-hungry processes
    shell: "ps -eo pid,comm,%mem --sort=-%mem | head -n 6"
    register: mem_processes
  
  
  • name: Display current memory usage
    debug:
    var: mem_processes.stdout_lines
  
  
  • name: Alert if memory > 80%
    shell: "ps -eo pid,%mem,comm --sort=-%mem | awk '$2 > 80 {print $0}'"
    register: highmem
    ignore_errors: yes
  
  
  • name: Print warning if found
    debug:
    msg: "⚠️ High memory usage detected: {{ highmem.stdout_lines }}"
    when: highmem.stdout !=
  
  
  
  
  
  

🧠 Detects high memory usage for early warning.

🧭 How to Run the Project

1.SSH into your Ansible control node

2.Clone your project:

git clone https://github.com//process_mgmt_lab.git

cd process_mgmt_lab

3.Update your target server IPs in inventory

4.Run any scenario:

ansible-playbook playbooks/restart_service.yml

ansible-playbook playbooks/clear_zombies.yml

ansible-playbook playbooks/detect_rogue.yml

5.Review results directly in the console.

🧠 Learning Outcome

After running these playbooks, you’ll understand how to:

Automate service recovery

Detect and fix resource hogs

Clean up zombies and rogue processes

Integrate process checks in CI/CD pipelines

Implement self-healing Linux behavior — all via Ansible