McAfee-Secured Website

Exam Bundle

Exam Code: EX200

Exam Name Red Hat Certified System Administrator (RHCSA)

Certification Provider: RedHat

Corresponding Certification: RHCSA

RedHat EX200 Bundle $44.99

100% RedHat EX200 Guaranteed Success With Testking Training Materials

Get Real EX200 Exam Questions & Expert Verified Answers as Experienced on the Real Exam!

  • Questions & Answers

    EX200 Questions & Answers

    111 Questions & Answers

    The ultimate exam preparation tool, Questions & Answers mirrors the actual EX200 exam while allowing you to hone and measure every aspect of your test-taking ability.

  • EX200 Video Course

    EX200 Video Course

    71 Video Lectures

    EX200 Video Course is developed by RedHat Professionals to help you pass the EX200 exam.

    Description

    This course will improve your knowledge and skills required to pass Red Hat Certified System Administrator (RHCSA) exam.
  • Study Guide

    EX200 Study Guide

    1601 PDF Pages

    Developed by industry experts, this 1601-page guide spells out in painstaking detail all of the information you need to ace EX200 exam.

Red Hat Certified System Administrator (RHCSA) (EX200) Practice Tests

Satisfaction Guaranteed

Money Back Guarantee

Testking provides hassle-free money back guarantee with our products. That is because we have 100% trust in the abilities of our professional and experience product team, and our record is a proof of that.

99.6% PASS RATE
Total Cost: $194.97
Bundle Price: $149.98

Purchase Individually

  • Questions & Answers

    Questions & Answers

    111 Questions

    $124.99
  • EX200 Video Course

    Video Course

    71 Video Lectures

    $39.99
  • Study Guide

    Study Guide

    1601 PDF Pages

    $29.99

RedHat EX200 Practice Test 44

Question 430

After a lab configuration change, verify: A standard `http` service should be allowed through firewalld, but the operator adds a broad arbitrary port range. Which result most directly proves the desired system state?

  1. `firewall-cmd --zone=public --list-services` contains `http` and only the required service is exposed.
  2. `ip -6 addr show` lists the address and a local IPv6 connectivity test succeeds.
  3. `firewall-cmd --zone=public --list-services` contains SSH and firewalld remains running and enabled.
  4. After reconnect or reboot `nmcli con show` and `ip addr` still report the address.

Explanation

Correct Answer

A:

`firewall-cmd --zone=public --list-services` contains `http` and only the required service is exposed. This check confirms the expected effect of: Use `firewall-cmd --zone=public --add-service=http --permanent` and reload after verifying intended interface zone. It distinguishes the intended result from the original failure mechanism: Named firewalld services encode documented port/protocol mappings more precisely than broad ranges.

Incorrect Answers

B:

`ip -6 addr show` lists the address and a local IPv6 connectivity test succeeds. That verifies a separate lab task: An IPv6-only lab application cannot listen because the host connection has no configured static IPv6 address. It does not validate the implementation required here: Use `firewall-cmd --zone=public --add-service=http --permanent` and reload after verifying intended interface zone.

C:

`firewall-cmd --zone=public --list-services` contains SSH and firewalld remains running and enabled. That verifies a separate lab task: A firewall service was accidentally removed from the active zone, and an operator proposes disabling firewalld entirely. It does not validate the implementation required here: Use `firewall-cmd --zone=public --add-service=http --permanent` and reload after verifying intended interface zone.

D:

After reconnect or reboot `nmcli con show` and `ip addr` still report the address. That verifies a separate lab task: A technician adds an IPv4 address with `ip addr add`, but it disappears after reboot. It does not validate the implementation required here: Use `firewall-cmd --zone=public --add-service=http --permanent` and reload after verifying intended interface zone.

Question 431

In an EX200-style practice lab, this condition exists: A standard `http` service should be allowed through firewalld, but the operator adds a broad arbitrary port range. Which explanation correctly identifies the underlying issue?

  1. A valid local interface address does not automatically provide off-subnet routing.
  2. Named firewalld services encode documented port/protocol mappings more precisely than broad ranges.
  3. IP address assignment and resolver configuration are independent network settings.
  4. Persisted connection configuration can remain inactive when autoconnect is disabled.

Explanation

Correct Answer

B:

Named firewalld services encode documented port/protocol mappings more precisely than broad ranges. This explains the task's initial state: A standard `http` service should be allowed through firewalld, but the operator adds a broad arbitrary port range. The supported lab action is: Use `firewall-cmd --zone=public --add-service=http --permanent` and reload after verifying intended interface zone.

Incorrect Answers

A:

A valid local interface address does not automatically provide off-subnet routing. This mechanism applies to another scenario: The lab interface is assigned the right IP but the host cannot reach an off-subnet gateway due to an incorrect default route. The given lab state instead requires the more specific cause in the correct choice.

C:

IP address assignment and resolver configuration are independent network settings. This mechanism applies to another scenario: A host resolves internal names through an obsolete DNS server even though its IPv4 address is correct. The given lab state instead requires the more specific cause in the correct choice.

D:

Persisted connection configuration can remain inactive when autoconnect is disabled. This mechanism applies to another scenario: A NetworkManager profile is stored on disk but is not automatically activated after reboot. The given lab state instead requires the more specific cause in the correct choice.

Question 432

After completing this practical task on a test RHEL10 instance: A standard `http` service should be allowed through firewalld, but the operator adds a broad arbitrary port range. Which operational safeguard helps keep the result correct and safe?

  1. Check autoconnect and active link state on every server network profile.
  2. Record temporary host overrides and remove stale entries when DNS becomes authoritative.
  3. Prefer narrowly scoped service definitions and remove unused rules.
  4. Capture zone-to-interface bindings when deploying network services.

Explanation

Correct Answer

C:

Prefer narrowly scoped service definitions and remove unused rules. This guards against recurrence of: Named firewalld services encode documented port/protocol mappings more precisely than broad ranges. Confirm the lab's final state by: `firewall-cmd --zone=public --list-services` contains `http` and only the required service is exposed.

Incorrect Answers

A:

Check autoconnect and active link state on every server network profile. That control is best suited to a separate scenario: A NetworkManager profile is stored on disk but is not automatically activated after reboot. It is not the best safeguard for the current mechanism: Named firewalld services encode documented port/protocol mappings more precisely than broad ranges.

B:

Record temporary host overrides and remove stale entries when DNS becomes authoritative. That control is best suited to a separate scenario: A training host must resolve one intentionally private name without querying DNS while building a disconnected lab. It is not the best safeguard for the current mechanism: Named firewalld services encode documented port/protocol mappings more precisely than broad ranges.

D:

Capture zone-to-interface bindings when deploying network services. That control is best suited to a separate scenario: A firewall rule was added to the default zone, but the application's NIC is assigned to a different active zone. It is not the best safeguard for the current mechanism: Named firewalld services encode documented port/protocol mappings more precisely than broad ranges.

Question 433

Lab exercise on an isolated enterprise lab VM: A lab user was mistakenly assigned `/bin/false` as login shell and cannot open an authorized interactive session. Which proposed RHEL 10 command or configuration action most directly achieves the required lab state?

  1. Use `usermod -s /bin/bash trainee1` after confirming the shell is installed and valid under `/etc/shells` when applicable.
  2. Use `gpasswd -d trainee1 analysts` after confirming group and account identity.
  3. Set the account expiration using `usermod -e 2027-01-31 contractor1` in the isolated training account.
  4. After archival and confirmation of the disposable identity, use `userdel -r trainee_retired` while preserving any required external data.

Explanation

Correct Answer

A:

Use `usermod -s /bin/bash trainee1` after confirming the shell is installed and valid under `/etc/shells` when applicable. This directly addresses the lab target: A lab user was mistakenly assigned `/bin/false` as login shell and cannot open an authorized interactive session. The underlying behavior is: The shell field controls the program started at login and can intentionally block interactive access. Verification: `getent passwd trainee1` ends with `/bin/bash` and an authorized test session starts.

Incorrect Answers

B:

Use `gpasswd -d trainee1 analysts` after confirming group and account identity. This is an appropriate step for a DIFFERENT exercise, specifically: A trainee is no longer authorized for the `analysts` supplemental group, but should retain their primary group. It does not address the required lab state, whose mechanism is: The shell field controls the program started at login and can intentionally block interactive access.

C:

Set the account expiration using `usermod -e 2027-01-31 contractor1` in the isolated training account. This is an appropriate step for a DIFFERENT exercise, specifically: A short-term external account must stop being usable on a specified end date while its password policy remains unchanged. It does not address the required lab state, whose mechanism is: The shell field controls the program started at login and can intentionally block interactive access.

D:

After archival and confirmation of the disposable identity, use `userdel -r trainee_retired` while preserving any required external data. This is an appropriate step for a DIFFERENT exercise, specifically: An account remains in `/etc/passwd` after project completion and the lab task explicitly authorizes permanent removal with its home. It does not address the required lab state, whose mechanism is: The shell field controls the program started at login and can intentionally block interactive access.

Question 434

In a hands-on RHCSA practice VM, the assigned outcome was: A lab user was mistakenly assigned `/bin/false` as login shell and cannot open an authorized interactive session. What specific verification would demonstrate the target state?

  1. `passwd -S contractor1` indicates locked credentials and preserved home files remain readable to authorized auditors.
  2. `getent passwd trainee1` ends with `/bin/bash` and an authorized test session starts.
  3. `sudo -l -U technician` shows the approved command only; unrelated root commands remain denied.
  4. `id trainee1` includes `analysts` and the prior supplementary groups remain.

Explanation

Correct Answer

B:

`getent passwd trainee1` ends with `/bin/bash` and an authorized test session starts. This check confirms the expected effect of: Use `usermod -s /bin/bash trainee1` after confirming the shell is installed and valid under `/etc/shells` when applicable. It distinguishes the intended result from the original failure mechanism: The shell field controls the program started at login and can intentionally block interactive access.

Incorrect Answers

A:

`passwd -S contractor1` indicates locked credentials and preserved home files remain readable to authorized auditors. That verifies a separate lab task: A contractor account exists but should no longer permit interactive login after an engagement ends, while audit files must remain. It does not validate the implementation required here: Use `usermod -s /bin/bash trainee1` after confirming the shell is installed and valid under `/etc/shells` when applicable.

C:

`sudo -l -U technician` shows the approved command only; unrelated root commands remain denied. That verifies a separate lab task: An admin must grant a named technician narrowly scoped restart rights for a lab service without adding them to full wheel privileges. It does not validate the implementation required here: Use `usermod -s /bin/bash trainee1` after confirming the shell is installed and valid under `/etc/shells` when applicable.

D:

`id trainee1` includes `analysts` and the prior supplementary groups remain. That verifies a separate lab task: A user must join the `analysts` group without losing their existing supplementary groups. It does not validate the implementation required here: Use `usermod -s /bin/bash trainee1` after confirming the shell is installed and valid under `/etc/shells` when applicable.

Question 435

A trainee is diagnosing: A lab user was mistakenly assigned `/bin/false` as login shell and cannot open an authorized interactive session. Which root cause should they recognize before changing the system?

  1. Renaming a login does not automatically guarantee home directory renaming in every workflow.
  2. Linux group creation establishes a named group but does not automatically add users or set file ownership.
  3. The shell field controls the program started at login and can intentionally block interactive access.
  4. Directory traversal and ownership control privacy of files below the home directory.

Explanation

Correct Answer

C:

The shell field controls the program started at login and can intentionally block interactive access. This explains the task's initial state: A lab user was mistakenly assigned `/bin/false` as login shell and cannot open an authorized interactive session. The supported lab action is: Use `usermod -s /bin/bash trainee1` after confirming the shell is installed and valid under `/etc/shells` when applicable.

Incorrect Answers

A:

Renaming a login does not automatically guarantee home directory renaming in every workflow. This mechanism applies to another scenario: A user account has a misspelled login name but should keep its existing UID and home ownership. The given lab state instead requires the more specific cause in the correct choice.

B:

Linux group creation establishes a named group but does not automatically add users or set file ownership. This mechanism applies to another scenario: A project team needs a new local group `analysts` to own shared reports. The given lab state instead requires the more specific cause in the correct choice.

D:

Directory traversal and ownership control privacy of files below the home directory. This mechanism applies to another scenario: A new user must have a private home directory rather than inherited group-read access. The given lab state instead requires the more specific cause in the correct choice.

Question 436

For this Linux administration lab: A lab user was mistakenly assigned `/bin/false` as login shell and cannot open an authorized interactive session. Which safety and lifecycle check best prevents the same problem returning?

  1. Follow approved account naming and home provisioning standards.
  2. Review file ownership and service permissions after primary GID changes.
  3. Verify membership and filesystem permissions after defining access groups.
  4. Review approved shells during interactive account provisioning.

Explanation

Correct Answer

D:

Review approved shells during interactive account provisioning. This guards against recurrence of: The shell field controls the program started at login and can intentionally block interactive access. Confirm the lab's final state by: `getent passwd trainee1` ends with `/bin/bash` and an authorized test session starts.

Incorrect Answers

A:

Follow approved account naming and home provisioning standards. That control is best suited to a separate scenario: A new lab operator needs a local account with a home directory and normal login shell. It is not the best safeguard for the current mechanism: The shell field controls the program started at login and can intentionally block interactive access.

B:

Review file ownership and service permissions after primary GID changes. That control is best suited to a separate scenario: A team requires a default primary group different from the user-private group created with the account. It is not the best safeguard for the current mechanism: The shell field controls the program started at login and can intentionally block interactive access.

C:

Verify membership and filesystem permissions after defining access groups. That control is best suited to a separate scenario: A project team needs a new local group `analysts` to own shared reports. It is not the best safeguard for the current mechanism: The shell field controls the program started at login and can intentionally block interactive access.

Question 437

A student working on a disposable RHEL10 training node receives this assignment: A user accidentally gives write permission to everyone on an application's configuration file. Which answer gives the correct practical approach?

  1. After confirming it is safe and approved, use `semanage port -m -t http_port_t -p tcp 8088` for the existing mapping.
  2. Set `chmod 640 /etc/labapp.conf` with approved root ownership and a designated service group.
  3. Set `umask 077` in the sensitive workflow before creating the secret fixture.
  4. Use `getsebool httpd_can_network_connect_db`; after verifying policy, set `setsebool -P httpd_can_network_connect_db on` where supported.

Explanation

Correct Answer

B:

Set `chmod 640 /etc/labapp.conf` with approved root ownership and a designated service group. This directly addresses the lab target: A user accidentally gives write permission to everyone on an application's configuration file. The underlying behavior is: DAC mode bits can allow unauthorized modification even if service function appears correct. Verification: `stat -c '%a %U:%G'` displays the restricted mode and an unrelated user cannot modify it.

Incorrect Answers

A:

After confirming it is safe and approved, use `semanage port -m -t http_port_t -p tcp 8088` for the existing mapping. This is an appropriate step for a DIFFERENT exercise, specifically: An existing TCP port is assigned to the wrong SELinux port type and `semanage port -a` fails because the port already exists. It does not address the required lab state, whose mechanism is: DAC mode bits can allow unauthorized modification even if service function appears correct.

C:

Set `umask 077` in the sensitive workflow before creating the secret fixture. This is an appropriate step for a DIFFERENT exercise, specifically: A shell session creates files with default modes exposing group-readable secrets to unrelated users. It does not address the required lab state, whose mechanism is: DAC mode bits can allow unauthorized modification even if service function appears correct.

D:

Use `getsebool httpd_can_network_connect_db`; after verifying policy, set `setsebool -P httpd_can_network_connect_db on` where supported. This is an appropriate step for a DIFFERENT exercise, specifically: An application hosted by Apache needs outbound database connections but SELinux policy denies them even with network routing functional. It does not address the required lab state, whose mechanism is: DAC mode bits can allow unauthorized modification even if service function appears correct.

Question 438

You have attempted this task on a disposable RHEL10 training node: A user accidentally gives write permission to everyone on an application's configuration file. Which command output or observation best confirms its success?

  1. SELinux context inspection shows read-only content separately from write-capable uploads and the application functions.
  2. Key-based login succeeds while a controlled password-only attempt fails without locking out the authorized admin.
  3. `stat -c '%a %U:%G'` displays the restricted mode and an unrelated user cannot modify it.
  4. `semanage port -l` lists 8088 for `http_port_t` and the daemon binds without the denial.

Explanation

Correct Answer

C:

`stat -c '%a %U:%G'` displays the restricted mode and an unrelated user cannot modify it. This check confirms the expected effect of: Set `chmod 640 /etc/labapp.conf` with approved root ownership and a designated service group. It distinguishes the intended result from the original failure mechanism: DAC mode bits can allow unauthorized modification even if service function appears correct.

Incorrect Answers

A:

SELinux context inspection shows read-only content separately from write-capable uploads and the application functions. That verifies a separate lab task: A web application's content directory is assigned `httpd_sys_rw_content_t` everywhere even though only a small upload path requires writes. It does not validate the implementation required here: Set `chmod 640 /etc/labapp.conf` with approved root ownership and a designated service group.

B:

Key-based login succeeds while a controlled password-only attempt fails without locking out the authorized admin. That verifies a separate lab task: A lab SSH account still accepts password-only access while the approved policy requires authorized public-key authentication. It does not validate the implementation required here: Set `chmod 640 /etc/labapp.conf` with approved root ownership and a designated service group.

D:

`semanage port -l` lists 8088 for `http_port_t` and the daemon binds without the denial. That verifies a separate lab task: A test web daemon is configured to listen on TCP 8088 but SELinux blocks binding despite a matching firewall rule. It does not validate the implementation required here: Set `chmod 640 /etc/labapp.conf` with approved root ownership and a designated service group.

Question 439

Troubleshoot the following RHEL 10 lab situation: A user accidentally gives write permission to everyone on an application's configuration file. Identify the key Linux mechanism behind the issue.

  1. `setenforce` changes runtime state while SELinux's configured boot mode is separate.
  2. SSH private credentials require protected ownership and permissions distinct from public authorized keys.
  3. `chcon` changes an inode label temporarily without updating the default file context database.
  4. DAC mode bits can allow unauthorized modification even if service function appears correct.

Explanation

Correct Answer

D:

DAC mode bits can allow unauthorized modification even if service function appears correct. This explains the task's initial state: A user accidentally gives write permission to everyone on an application's configuration file. The supported lab action is: Set `chmod 640 /etc/labapp.conf` with approved root ownership and a designated service group.

Incorrect Answers

A:

`setenforce` changes runtime state while SELinux's configured boot mode is separate. This mechanism applies to another scenario: An administrator temporarily changes SELinux to permissive mode for diagnostics and believes it will remain so after reboot. The given lab state instead requires the more specific cause in the correct choice.

B:

SSH private credentials require protected ownership and permissions distinct from public authorized keys. This mechanism applies to another scenario: A private SSH key is world-readable, causing security risk and sometimes authentication refusal. The given lab state instead requires the more specific cause in the correct choice.

C:

`chcon` changes an inode label temporarily without updating the default file context database. This mechanism applies to another scenario: A temporary `chcon` label change makes a lab web file work, but `restorecon` later reverts it and the outage returns. The given lab state instead requires the more specific cause in the correct choice.

Question 440

Following lab verification, document the preventive or persistence-oriented procedure for: A user accidentally gives write permission to everyone on an application's configuration file. Which practice is most suitable?

  1. Audit filesystem permissions on configuration files after each deployment.
  2. Set a restrictive umask in service startup or trusted shell policy for secret handling.
  3. Verify persistence and remove temporary diagnostic firewall permits.
  4. Use policy-backed fcontext mappings for nonstandard service directories.

Explanation

Correct Answer

A:

Audit filesystem permissions on configuration files after each deployment. This guards against recurrence of: DAC mode bits can allow unauthorized modification even if service function appears correct. Confirm the lab's final state by: `stat -c '%a %U:%G'` displays the restricted mode and an unrelated user cannot modify it.

Incorrect Answers

B:

Set a restrictive umask in service startup or trusted shell policy for secret handling. That control is best suited to a separate scenario: A shell session creates files with default modes exposing group-readable secrets to unrelated users. It is not the best safeguard for the current mechanism: DAC mode bits can allow unauthorized modification even if service function appears correct.

C:

Verify persistence and remove temporary diagnostic firewall permits. That control is best suited to a separate scenario: A firewall change is tested using only a runtime rule, but an administrator assumes it will be present after restart. It is not the best safeguard for the current mechanism: DAC mode bits can allow unauthorized modification even if service function appears correct.

D:

Use policy-backed fcontext mappings for nonstandard service directories. That control is best suited to a separate scenario: A temporary `chcon` label change makes a lab web file work, but `restorecon` later reverts it and the outage returns. It is not the best safeguard for the current mechanism: DAC mode bits can allow unauthorized modification even if service function appears correct.