Linux System Administration Questions
Operating and maintaining Linux and Unix systems: filesystems and permissions, process and service management, package management and updates, shell and scripting, storage, and network configuration on the host. Covers day-to-day administration, troubleshooting, monitoring and tuning host resource usage (CPU, memory, swap, and I/O), and hardening of Linux servers that underpin most infrastructure. The Linux operator's core skill set.
Explain basic Linux firewall concepts: netfilter hooks, the iptables chains INPUT/OUTPUT/FORWARD, default policies, and how firewalld maps zones to rules. Show commands to list current rules and how to temporarily allow a port for debugging.
Sample Answer
Direct answer
Netfilter is the packet-filtering framework built into the Linux kernel; it defines five fixed points (hooks) a packet passes through on its way in, out, or through the box, and both iptables and firewalld are just user-space tools for placing rules at those hooks, not separate filtering engines of their own. iptables's filter table exposes three of those hooks as chains you actually write rules against day to day: INPUT (packets destined for this host), OUTPUT (packets originating from this host), and FORWARD (packets passing through this host to somewhere else, relevant on a router or NAT gateway). firewalld sits a layer above either iptables or the newer nftables backend and lets you think in terms of named zones (trust levels assigned to interfaces or sources) instead of raw chains and rules directly.
The hooks, the chains, and how firewalld maps onto them
flowchart TD
A[Packet arrives on NIC] --> B[PREROUTING hook]
B --> C{For this host,<br/>or passing through?}
C -->|for this host| D[INPUT hook]
D --> E[Local process]
C -->|passing through| F[FORWARD hook]
E -->|reply sent| G[OUTPUT hook]
F --> H[POSTROUTING hook]
G --> H
H --> I[Packet leaves NIC]
- The kernel's netfilter framework defines all five hooks shown above; the
iptablesfiltertable (the default table, used for allow/deny decisions) only attaches toINPUT,OUTPUT, andFORWARD. Thenattable attaches toPREROUTINGandPOSTROUTINGinstead (DNAT rewrites the destination inPREROUTING, before the routing decision; SNAT andMASQUERADErewrite the source inPOSTROUTING, after it;natalso has anOUTPUTchain for packets the host itself generates), which is why NAT and filtering rules live in conceptually different tables even though they ride the same underlying hooks. - Each chain has a default policy (
ACCEPT,DROP, orREJECT) applied when no rule in the chain matches the packet:iptables -P INPUT DROPsets theINPUTchain's fallback to silently drop anything not explicitly allowed, which is the standard posture for a host you want locked down by default. firewalldmaps interfaces or source addresses to zones (public,internal,trusted,drop, and others), each zone carrying its own set of allowed services and ports; adding an interface to thetrustedzone effectively opens everything on it, whiledropsilently discards everything with no reply at all. Underneath,firewalldtranslates zone and service configuration into actualnftablesrules (the default backend on current Fedora/RHEL) oriptablesrules on older systems; you are still ultimately configuring the same netfilter hooks, just through a higher-level vocabulary aimed at "which network is this interface on" rather than "which chain and rule."
Listing rules and temporarily allowing a port for debugging
Listing current rules:
iptables -L -n -v
(-n avoids slow DNS lookups on every address, -v adds packet and byte counters per rule, useful for confirming a rule is actually being hit at all.)
With firewalld:
firewall-cmd --list-all
shows the active zone's services, ports, and any rich rules in one summary.
Temporarily allowing a port for debugging (not surviving a reboot or firewall reload):
iptables -I INPUT -p tcp --dport 8080 -j ACCEPT
(-I inserts at the top of the chain, so it is evaluated before any earlier DROP rule that would otherwise match first.)
firewall-cmd --add-port=8080/tcp
(without --permanent, this only affects the current runtime configuration and reverts on the next firewall-cmd --reload or service restart, which is exactly the point for a debugging-only change you do not want to accidentally leave in place.)
Trade-offs and pitfalls
- A rule added with plain
iptables -I/-A(without also saving it through the distribution's persistence mechanism, such asiptables-savepiped into a startup script, ornetfilter-persistent) is gone on the next reboot; this is a feature when you are debugging, and a trap if you meant it to be permanent and forgot the second step. - Inserting with
-I(top of chain) versus appending with-A(bottom of chain) matters a great deal on a chain that already has aDROPrule partway through: append a newACCEPTrule after an existingDROPfor the same traffic and it will never be reached, sinceiptablesevaluates rules in order and stops at the first match. - Mixing manual
iptablesrules withfirewalldrunning on the same host is a common source of confusing, hard-to-reproduce behavior, sincefirewalldperiodically reconciles the actual ruleset against its own configuration and can silently remove rules it does not recognize as its own; pick one management layer for a given host and stay with it.
You must add a new user for an application operator and configure SSH key-based authentication, sudo access for a limited set of commands, and enforce disabling password authentication. Describe the exact commands and configuration steps (including edits to sshd_config and sudoers.d) to achieve this securely and how to rotate that user's SSH keys.
Sample Answer
Direct answer
Creating a properly locked-down operator account means four things happening in the right order: create the account and its home directory, install their public key for authentication (never generate or transmit their private key yourself), grant sudo for a named, minimal set of commands via a dedicated file under sudoers.d, and only after confirming the key works, disable password authentication so the key becomes the only way in. Rotation later follows the same "add the new, verify it, then remove the old" order in reverse.
Structured elaboration
1. Create the user:
useradd -m -s /bin/bash opuser
-m creates the home directory, -s /bin/bash sets their login shell. (On Debian/Ubuntu, adduser opuser is the friendlier interactive wrapper around the same underlying useradd; on RHEL/CentOS/Fedora, useradd is the standard direct tool either way, so the command above works unchanged across both families.)
2. Set up SSH key-based authentication for that user:
mkdir -p /home/opuser/.ssh
echo "<their-public-key-contents>" > /home/opuser/.ssh/authorized_keys
chmod 700 /home/opuser/.ssh
chmod 600 /home/opuser/.ssh/authorized_keys
chown -R opuser:opuser /home/opuser/.ssh
The permissions matter beyond just tidiness: sshd refuses to trust an authorized_keys file (or its parent .ssh directory) that's group- or world-writable, and silently falls back to rejecting key auth for that user rather than warning you, which is a common source of "I set this up correctly and it still won't let me in" confusion.
3. Grant scoped sudo access via a dedicated sudoers.d file, never by editing /etc/sudoers directly:
echo 'opuser ALL=(root) /usr/bin/systemctl restart myapp, /usr/bin/journalctl -u myapp' > /etc/sudoers.d/opuser
chmod 440 /etc/sudoers.d/opuser
visudo -c
Naming exact command paths (not a wildcard like ALL) is what makes this "limited": opuser can restart and read logs for that one service and nothing else as root. visudo -c validates every file under sudoers.d for syntax errors before it's live; skipping this step risks a typo that either breaks sudo entirely for everyone or, worse, grants broader access than intended.
4. Test key-based login BEFORE disabling password authentication. Only once you've confirmed ssh opuser@host works with the key and no password prompt, edit /etc/ssh/sshd_config (or, cleaner, a fleet-wide drop-in under /etc/ssh/sshd_config.d/ if this policy applies broadly) to set PasswordAuthentication no, then:
sshd -t
systemctl reload sshd
sshd -t validates the config syntax without touching the running daemon; reloading (not restarting) applies it without dropping any currently open sessions, so if something's wrong you still have a way back in through your existing connection.
Rotating this user's SSH key later: append the new public key to authorized_keys alongside the old one first, confirm the new key authenticates successfully, and only then remove the old key line from the file. Never delete the old key before confirming the new one works: that ordering (add, verify, remove) is what prevents a rotation from turning into an accidental lockout.
Worked example
On Ubuntu 24.04: useradd -m -s /bin/bash opuser, set up .ssh/authorized_keys as above, add /etc/sudoers.d/opuser scoped to systemctl restart myapp and journalctl -u myapp, confirm visudo -c passes, test ssh opuser@host with the key succeeds without a password prompt, then set PasswordAuthentication no fleet-wide and reload. On RHEL 9 or CentOS Stream, the sequence is identical except SELinux (Security-Enhanced Linux, a kernel-level mandatory access
control layer that enforces its own permission rules on top of standard Unix file permissions) is
enforcing by default, so after placing authorized_keys, also run restorecon -R -v /home/opuser/.ssh to make sure the SELinux context on that directory matches what sshd's policy expects; without it, sshd can refuse the key even though the Unix permissions (700/600) are perfectly correct, which is a distribution-specific gotcha worth checking explicitly rather than assuming Ubuntu's behavior carries over unchanged.
Trade-offs & pitfalls
- Disabling password authentication before verifying the key works is the single most common way to lock out the very account you just created; always test first.
- A wildcard like
opuser ALL=(root) ALLdefeats the entire point of "limited sudo access"; naming exact command paths is what makes the grant auditable and bounded. - Editing
/etc/sudoersdirectly instead of using a file undersudoers.drisks a syntax error that breakssudofor the whole system, with no safety check;visudo(orvisudo -con asudoers.dfile) exists specifically to catch that before it's live. - Forgetting the SELinux context step on an enforcing RHEL-family host is a real, distro-specific failure mode, not a hypothetical: correct Unix permissions alone don't guarantee
sshdwill accept the key there.
You export /srv/export via NFS and observe that root-owned files created on clients appear as 'nobody' on the server. Explain root_squash, all_squash, anonuid/anongid options and how to configure /etc/exports to allow root write access from a specific CIDR while still preventing other hosts from having that access. Describe security considerations and alternatives such as Kerberos-secured NFS.
Sample Answer
Direct answer
Root's UID (user ID, the numeric identity the kernel actually checks) is 0, and by default NFS (Network File System) maps any client request arriving as UID 0 to an unprivileged "nobody" identity on the server, a protection called root squashing, specifically so that having root on some client laptop does not automatically grant root over every file in the export. root_squash (the default) enables that mapping, no_root_squash disables it for a specific client and grants it real root, all_squash extends the same mapping to every UID from that client, not just root, and anonuid/anongid choose which UID/GID a squashed request is mapped to instead of the default "nobody" (usually 65534).
Configuring /etc/exports for the actual requirement
The requirement is: allow root write access from one specific network (a CIDR, meaning Classless Inter-Domain Routing, the address/prefix-length notation like 10.0.5.0/24 that names a whole subnet in one line), while every other host is denied even that basic access, let alone root's.
/srv/export 10.0.5.0/24(rw,sync,no_root_squash,no_subtree_check)
(sync here means the server only acknowledges a write once it is actually committed to stable storage, the safer default over async; no_subtree_check skips an extra verification step NFS otherwise does when only part of a filesystem is exported, recommended on modern kernels for a whole-filesystem export like this one to avoid a class of spurious stale-file-handle errors; both are covered in more depth under Trade-offs and pitfalls below.)
- Nothing else is listed as a client for
/srv/export, so any host outside10.0.5.0/24gets no access at all, not even squashed access; NFS exports are opt in per host or subnet, there is no implicit "everyone else gets root_squash instead." no_root_squashonly applies to the client(s) named on that line. A separate line for a different subnet or host, withoutno_root_squash, keeps the default protection for everyone else:/srv/export 10.0.9.0/24(rw,sync,no_subtree_check)for a different team that should get normal (root squashed) write access but not root.- If you instead wanted to lock every client, including the trusted subnet, down to a single fixed identity regardless of what UID they connect as:
/srv/export 10.0.5.0/24(rw,sync,all_squash,anonuid=2000,anongid=2000,no_subtree_check), mapping every request from that subnet, root or not, to UID/GID 2000. This is the opposite end of the spectrum fromno_root_squash: it trusts the network boundary itself less, not more.
Security considerations
no_root_squash should be treated as a genuinely dangerous exception, not a convenience default: any client granted it, if compromised, has root level write access to the export, which usually means it can write a setuid binary or overwrite a file another, more trusted host will later execute. Scoping it to the narrowest possible CIDR (or better, a single host IP, not a whole subnet) limits the blast radius of that trust to exactly the machines that need it, typically a small number of build or backup hosts that have a specific, understood reason to need real root over the export. NFS as configured above is also fundamentally trusting the client's own claim about which UID a request comes from: the AUTH_SYS (also called AUTH_UNIX) authentication NFS uses by default takes the client's word for its UID/GID with no cryptographic verification at all, which is why no_root_squash matters as much as it does, and it is also why NFS exports should sit behind a firewall or private network boundary regardless of squash settings, never exposed on a public interface.
The stronger alternative: Kerberos secured NFS
NFSv4 with Kerberos (sec=krb5, or sec=krb5i for per-packet integrity checking, or sec=krb5p for full encryption) replaces the client's self-asserted UID with a cryptographically verified identity from a Kerberos ticket, closing the "any client can just claim to be root" gap that AUTH_SYS has by construction. An export line using it looks like /srv/export 10.0.5.0/24(rw,sync,sec=krb5i,no_subtree_check), and the trade-off is real operational cost: it requires a working Kerberos realm (a KDC, or Key Distribution Center, the trusted server that authenticates identities and issues tickets; keytabs, files holding a service's long-term secret key so it can prove its identity to the KDC without a password prompt each time, distributed to every NFS server and client; and clock synchronization tight enough for Kerberos ticket validity, which is itself a reason accurate time sync across a fleet matters well beyond just log correlation), which is meaningfully more infrastructure than a plain /etc/exports line. For an internal, already network-isolated fileserver serving a small trusted set of build hosts, scoped no_root_squash on a narrow CIDR is a common, defensible trade-off; for anything crossing a security boundary you do not fully control, Kerberos secured NFS is the correct answer, not a nice-to-have.
Trade-offs and pitfalls
The most common mistake is granting no_root_squash to an entire broad subnet "to make things easier," which quietly hands every machine on that subnet real root over the export the moment any one of them is compromised; always scope it to the smallest set of hosts that genuinely need it. A second mistake is forgetting that no_subtree_check (recommended on modern kernels for exports of a whole filesystem, as shown above) trades a small amount of extra checking for avoiding a specific class of stale file handle errors after files are renamed on the server; leaving the default subtree checking on for a whole-filesystem export is a common source of confusing intermittent NFS errors that has nothing to do with permissions at all. Third, remember that sync (the safe default, requiring the server to commit writes to stable storage before acknowledging them) versus async is itself a durability trade-off independent of the squash settings: async is faster but can silently lose the last few writes if the server crashes before flushing, which matters more for some exports than others.
A service running as 'appuser' gets 'Permission denied' opening a config file, even though ls -l shows appuser owns it with read/write permission. The failure is intermittent: it works most of the time, then doesn't. Walk through how you'd systematically narrow down the cause, layer by layer, between the process and the file on disk.
Sample Answer
Direct answer
"Permission denied" despite ls -l showing the right owner and mode means the mode bits you can see are not the only thing deciding access; something else in the path between the process and the file's bytes on disk is intervening. Given that it's intermittent, the fault is likely something that only sometimes applies, and I'd work outward from the process itself (is it really running as the user you think, right now) through the filesystem layer (access control lists, mandatory access control context) to the mount and namespace layer (is this file's real identity even the same one the process sees).
Structured elaboration
Layer 1: is the process actually running as appuser at the moment of the failure? ls -l tells you who owns the file, not who's asking for it. Check ps -o user,pid,cmd -p <pid> or cat /proc/<pid>/status | grep -E "^(Uid|Gid)" for the real, effective, and saved user IDs. A process that drops privileges after startup, or one managed by a supervisor that occasionally restarts it under a different context (a misconfigured systemd User= directive that only applies on some restart paths, for instance), can intermittently run as someone other than appuser without that ever showing up in a static ps aux snapshot taken after the fact.
Layer 2: access control lists (ACLs) layered on top of the basic mode bits. POSIX ACLs let you attach additional, more granular rules to a file beyond the three rwx triads, and a ls -l listing only hints at their presence with a trailing + on the permission string, easy to miss at a glance. getfacl <file> shows the full picture; a deny-style ACL entry for a specific user or group can override what the basic mode bits appear to promise.
Layer 3: mandatory access control (SELinux or AppArmor). These frameworks enforce policy independently of, and on top of, standard Unix permissions; a process can have full rwx per the mode bits and still be denied if its SELinux type doesn't match the file's context. ls -Z <file> shows the SELinux context; ausearch -m avc -ts recent (or journalctl for AppArmor DENIED lines) shows the actual denial event, including a timestamp, which is exactly what you need when the symptom is intermittent: correlate denial timestamps against the failure reports. A context mismatch that appears only after a file gets rewritten by a tool that doesn't preserve SELinux labels (a common one: a deploy pipeline or editor that recreates the file instead of editing it in place) explains intermittency well: the file's context silently reverts to something the process's policy doesn't cover every time it's touched that way.
Layer 4: mount and namespace boundaries. If appuser is a service running inside a container or under a Linux user namespace, the UID that's appuser inside the container may map to a completely different UID on the host, and vice versa; a bind-mounted file "owned by appuser" from the host's perspective can be owned by an unrelated UID from inside the container's remapped view, or the reverse. This class of bug is often intermittent specifically because it depends on WHICH side (host tooling versus the containerized process) most recently touched or recreated the file, and whether that side's UID mapping happened to line up that time. Network File System (NFS) mounts add a related failure mode: root_squash (or more generally, UID mapping between NFS client and server) can translate appuser's UID differently than expected, and if the NFS mount briefly drops and remounts with different options, or the mapping service (like idmapd) has a caching hiccup, access that worked a moment ago can fail without any local file change at all.
A fifth pattern worth ruling out on intermittency specifically: a deploy or log-rotation tool that replaces the file via write-new-then-rename, briefly creating a window where the temporary file has different (often the shell or process's default umask, the mask that strips permission bits off every newly created file before any explicit chmod runs) permissions before a subsequent chmod/chown step restores the intended ones; if the process happens to open the file during that narrow window, it sees the wrong mode.
Worked example
The service runs inside a container. On the host, /data/config.yml is owned appuser:appuser (UID 2000) with mode rw-------, matching appuser's host UID exactly, so ls -l on the host looks correct. Inside the container, the same process also runs as a user named appuser, but the container's user namespace remaps container UID 2000 to host UID 2000 only when the container is started with a specific --userns mapping; on nodes where the container scheduler occasionally falls back to a default mapping (say, after a node drain and reschedule onto a node with a different container runtime config), container UID 2000 maps to host UID 100000 instead. From inside the container, the process still believes it's appuser opening a file appuser owns, but the kernel is actually checking host UID 100000 against a file owned by host UID 2000, and denies it. The intermittency lines up exactly with which node the container landed on, which is the kind of correlation that layer-by-layer checking (starting from "what UID is this process really running as, right now, on this specific host" in layer 1) surfaces, while a plain ls -l on either side alone never would.
Trade-offs & pitfalls
- Trusting
ls -las the complete picture is the core mistake this question is testing: it shows the mode bits and the names currently mapped to the numeric owner/group IDs, nothing about ACLs, mandatory access control context, or namespace remapping. - Intermittent failures are usually intermittent BECAUSE of a race or a context-dependent condition (which node, which restart path, which brief rewrite window), so the fix is to find what varies between the working and failing cases, not to re-verify the same static permission check repeatedly.
- Fixing the symptom (loosening the mode bits, or disabling SELinux/AppArmor enforcement) instead of the actual mismatch (fixing the UID mapping, fixing the NFS mount options, fixing the deploy tool's write-then-rename race) removes a real security boundary to paper over a config bug.
Describe how LUKS/dm-crypt encryption interacts with LVM and the filesystem layer. Explain the safe sequence and caveats to resize an encrypted LVM volume and its contained filesystem, how to rekey a LUKS device with minimal downtime, and emergency recovery steps if the LUKS header becomes corrupted.
Sample Answer
Direct answer
Layer LUKS (Linux Unified Key Setup, the standard on-disk format for the kernel's dm-crypt block encryption)
directly on the raw partition or disk, and put LVM (Logical Volume Manager, the layer that lets you resize,
snapshot, and combine block devices without repartitioning) on top of the single decrypted mapping, unless
different logical volumes genuinely need different keys or separate access boundaries, in which case put
LVM below and encrypt each logical volume individually and accept multiple unlock prompts. Resizing,
rekeying, and recovery all follow directly from getting that layering right.
How the layers interact
- LUKS-under-LVM (recommended default): one LUKS container wraps the raw partition; LVM's physical
volume sits on the single decrypted/dev/mapper/<name>device; one passphrase or key unlocks everything
underneath. Simpler operations, one thing to unlock at boot. - LVM-under-LUKS: LVM creates logical volumes directly on the raw partition, and each logical volume is
individually wrapped in its own LUKS container. More keys to manage and back up, but supports genuinely
separate access boundaries per volume (for example, different tenants or different sensitivity levels on
the same physical disk).
Resizing an encrypted LVM volume, bottom to top
The sequence matters strictly bottom to top, each layer only sees the space the layer below reports:
- Grow the underlying block device itself (a cloud provider's disk-resize API, or a physical disk swap).
- Grow the partition if one is in play (
growpart <device> <partition-number>). cryptsetup resize <mapped-name>to grow the LUKS mapping into the newly available space. Both header
formats support doing this online, while the mapping stays active and mounted, noluksClose/luksOpen
cycle is required for either one. The real difference is elsewhere: LUKS1's header never stores a size
at all, so resizing it is a pure device-mapper table operation that needs no passphrase, while LUKS2
persists the new size into its own authenticated metadata, socryptsetup resizeon a LUKS2 device
requires a passphrase to write that update even though the mapping itself is never torn down. (Verified
directly: growing an active, opened LUKS1 mapping withcryptsetup resizesucceeded immediately with
no passphrase prompt and no close/reopen; the equivalent LUKS2 resize on an active mapping needed a
passphrase before it would proceed, but neither one required closing the mapping.)pvresizeon the mapped device, so LVM's physical volume sees the larger space.lvextend -l +100%FREE <volume-group>/<logical-volume>to grow the logical volume into the newly
available extents.resize2fs(ext4) orxfs_growfs(XFS) to grow the filesystem to fill the logical volume.
Doingpvresizebeforecryptsetup resizeis a common, cleanly diagnosable mistake: LVM will report zero
new physical extents available, because the crypt mapping is still reporting its old size to everything
above it.
Rekeying with minimal downtime
cryptsetup luksAddKey <device> adds a new passphrase into a free keyslot (LUKS2 supports up to 32
keyslots depending on header parameters, LUKS1 exactly 8) alongside the existing one, without touching the
actual data encryption key at all, only the passphrase-wrapped copy of it changes. Verify the new
passphrase unlocks the device, then cryptsetup luksRemoveKey (or luksKillSlot) the old one. Because the
underlying master key never changes, this completes in effectively constant time regardless of volume size,
with zero downtime since the device stays mounted throughout. Contrast this with cryptsetup reencrypt
(LUKS2's online re-encryption, which genuinely rewrites the master key and re-encrypts every block), a much
heavier operation that LUKS2 supports resuming from a checkpoint if interrupted, precisely because a crash
mid-reencrypt without that resume metadata would be dangerous.
Emergency recovery from a corrupted LUKS header
The header holds every keyslot's metadata; if it's destroyed, the master key may be unreachable through any
passphrase, by design, that unrecoverability is the point of full-disk encryption, not a defect. The only
reliable recovery path is a header backup taken proactively: cryptsetup luksHeaderBackup --header-backup-file <file> <device> immediately after luksFormat and after every luksAddKey/
luksKillSlot change. If a backup exists, cryptsetup luksHeaderRestore --header-backup-file <file> <device> restores it and normal unlock resumes. Without a backup, cryptsetup repair can attempt limited
recovery of a LUKS1 header, and cryptsetup luksDump shows whatever keyslot metadata survives; if even one
valid keyslot remains, the data is recoverable, if none do, it genuinely is not.
Worked example
A database host runs LUKS directly on a partition with LVM on top, needing to grow from 500GiB (gibibyte,
2^30 bytes) to 750GiB after the cloud disk itself was resized: growpart /dev/nvme1n1 1, then
cryptsetup resize luks_data, then pvresize /dev/mapper/luks_data, then lvextend -l +100%FREE /dev/vgdata/lvdata, then resize2fs /dev/vgdata/lvdata. Skipping the cryptsetup resize step and running
pvresize directly after growpart is the concrete, checkable symptom of doing this out of order: pvresize
reports the physical volume is unchanged in size, because the crypt mapping in between still reports the old
500GiB.
Trade-offs and pitfalls
LUKS-under-LVM's single unlock is operationally simpler (one boot-time passphrase, or a network-bound
unlock via a TPM, trusted platform module, backed mechanism) but means anyone holding that one key can see
every logical volume underneath; LVM-under-LUKS supports per-volume keys at the cost of managing and backing
up several header backups instead of one. The most common mistake in "rotation" is running luksAddKey and
stopping there: an old, potentially compromised passphrase left in its keyslot after adding a new one has
not actually been rotated, only supplemented, luksRemoveKey on the old slot is the step that completes it.
Unlock Full Question Bank
Get access to all 17 Linux System Administration interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.