The correct answer is B. top because it provides a dynamic, real-time view of running processes and system resource usage. The top command is an essential Linux system monitoring utility that continuously updates information about CPU usage, memory consumption, running processes, load averages, and system uptime. It is widely used by system administrators for performance monitoring and troubleshooting.
When executed, top displays a full-screen interface showing active processes sorted by resource usage (typically CPU by default). It updates at regular intervals, allowing administrators to observe changes in real time. Additionally, it offers interactive features such as sorting processes, killing processes, and filtering output, which enhances system management capabilities.
Option A (ps) is incorrect because although it lists running processes, it provides only a snapshot at a specific moment in time. It does not update dynamically unless repeatedly executed or combined with other tools.
Option C (df) is incorrect because it displays disk space usage of filesystems, not running processes.
Option D (free) is incorrect because it shows memory usage statistics, including total, used, and available memory, but does not display process-level activity.
From a Linux+ perspective, understanding tools like top is crucial under System Management objectives. It enables administrators to monitor system health, identify resource-intensive processes, and take corrective actions when necessary. Real-time monitoring is particularly important in production environments where performance issues must be diagnosed and resolved quickly.

The correct answer is C. The application might have a memory leak because the dmesg output clearly shows that the Linux kernel is invoking the OOM (Out Of Memory) killer, which terminates processes when the system runs out of available memory. The presence of entries such as invoked oom-killer, out_of_memory, and oom_kill_process confirms that the system is exhausting its memory resources over time.
A key detail in the scenario is that the application runs for several days before failing, and when system resources (RAM) are increased, the issue takes longer to occur. This behavior is a classic indicator of a memory leak, where an application gradually consumes more memory without releasing it. Instead of stabilizing, memory usage continuously grows until it reaches the system limit, at which point the OOM killer terminates the process to prevent system instability.
Option A (CPU type is incompatible) is incorrect because CPU incompatibility would cause immediate execution failures, not delayed memory exhaustion. Option B (kernel panic) is incorrect because a kernel panic would crash the entire system, not selectively terminate a user-space process. Option D (swap configuration not correctly sized) is partially plausible but not the best answer; while insufficient swap can contribute to OOM conditions, it does not explain the gradual memory consumption pattern observed.
In Linux+ troubleshooting, identifying memory leaks is critical when dealing with long-running applications.
Administrators should monitor memory usage using tools like top, htop, or ps, and investigate application behavior. Applying patches, optimizing code, or restarting services periodically are common mitigation strategies, along with configuring appropriate memory and swap resources.

The correct answer is C. firewall-cmd --add-service=http --permanent because it ensures that the firewall rule allowing HTTP traffic remains in effect even after a system reboot. In Linux systems using firewalld, rules can be applied in two modes: runtime and permanent.
By default, when a rule is added using firewall-cmd --add-service=http (Option D), it is applied only to the runtime configuration. This means the rule will allow HTTP traffic immediately, but it will be lost once the system is restarted or the firewall service is reloaded.
The --permanent flag ensures that the rule is written to the persistent configuration files, so it survives reboots.
After adding a permanent rule, administrators typically run firewall-cmd --reload to apply the changes to the runtime environment as well.
Option A is incorrect because while it reloads the firewall, it does not specify the rule as permanent, so the configuration will not persist after reboot.
Option B is incorrect because --add-port=http is not valid syntax (ports must be specified numerically, e.g., 80
/tcp), and --complete-reload is not appropriate here.
Option D is incorrect because it only applies the rule temporarily (runtime only).
From a Linux+ security perspective, managing firewall rules persistently is essential for maintaining secure and consistent network access. Using the --permanent option ensures services like HTTP remain accessible across system restarts while still being controlled by firewall policies.

The correct answer is D. An HTTP-based callback function. A webhook is a mechanism that allows one system to automatically send real-time data to another system via HTTP when a specific event occurs. Instead of continuously polling an API for updates, a webhook enables event-driven communication, making automation more efficient and responsive.
In practical Linux and DevOps environments, webhooks are widely used in automation, orchestration, and integration workflows. For example, a version control system like GitHub can trigger a webhook to notify a CI
/CD pipeline whenever new code is pushed. The receiving system exposes an HTTP endpoint (URL), and when the event occurs, the webhook sends an HTTP POST request with relevant data payload. This design significantly reduces overhead compared to polling mechanisms.
Option A is incorrect because webhooks are not authentication mechanisms. While authentication (such as tokens or signatures) may be used to secure webhook communication, it is not their primary purpose.
Option B is incorrect because SNMP (Simple Network Management Protocol) is unrelated to webhooks.
SNMP is used for monitoring and managing network devices, whereas webhooks operate over HTTP/HTTPS protocols.
Option C is incorrect because although webhooks can transmit data (including sensitive information if not properly secured), their purpose is not specifically to transmit sensitive data but to notify systems of events through automated callbacks.
From a Linux+ perspective, understanding webhooks is essential in automation and orchestration tasks. They are commonly integrated into scripts, configuration management tools, and cloud-native workflows to enable reactive, event-driven system behavior, improving efficiency and scalability in modern infrastructure environments.

Firewall configuration is a key topic in the Security domain of CompTIA Linux+ V8. DNS primarily uses UDP port 53, but TCP port 53 is also required for zone transfers, large responses, and certain reliability scenarios. In this case, the administrator explicitly needs to allow DNS over TCP from a specific network.
The correct command is ufw allow 53/tcp from 10.0.0.0/24. This rule allows incoming TCP traffic on port 53 only from the specified subnet, following the principle of least privilege. Linux+ V8 documentation emphasizes restricting firewall rules by source network whenever possible to minimize attack surfaces.
Option A is incorrect because UFW service aliases like dns are not always guaranteed to map explicitly to TCP, and the syntax is incomplete. Option B is invalid because ufw enable is used to enable the firewall globally and does not define rules. Option D disables firewall protections and introduces a major security risk.
Linux+ V8 best practices stress precise, minimal firewall rules instead of broad or disabling actions.
Therefore, C is the correct and secure choice.