5.4. DNS and DHCP
Table of Contents
Introduction
DNS and DHCP are two core services that make modern IP networks usable. On Linux servers these typically run as long‑lived daemons and are critical for any serious infrastructure. This chapter gives you a conceptual and practical view of how these services work together, what roles they play on a network, and how they fit into a Linux server environment. Later chapters will cover specific implementations and configuration details, so here the focus is on the overall picture, the relationships between components, and the typical deployment patterns.
The Role of DNS in a Network
DNS, the Domain Name System, translates human friendly names such as www.example.com into IP addresses such as 192.0.2.10 or 2001:db8::10. It also maps IP addresses back to names, and stores many other small pieces of information that applications depend on.
From a server administration perspective, DNS has two major faces. One is as a client dependency, where your Linux server must be able to resolve names to reach other services. The other is as an authoritative provider of information, where your server answers DNS queries for domains that you manage.
The DNS database is distributed and hierarchical. Each domain is broken into zones that are served by authoritative name servers. Resolvers ask questions, starting from a configured server that either has the answer or knows how to find it. Because these lookups occur constantly, caching is used everywhere to reduce latency and load, which means that DNS records are never updated instantly across the internet but instead propagate according to the time to live values that you define.
On Linux, the resolver side typically uses a stub resolver in the C library, configured by files such as /etc/resolv.conf or by higher level networking tools. The server side is provided by daemons such as BIND, Knot, PowerDNS, or named packaged by distributions. The specifics of zone files, resource records, and server configuration belong in the dedicated DNS chapters but you should already recognize that DNS is both a protocol and a distributed database.
DNS is a critical infrastructure service. Misconfigured DNS can make an entire network or application appear offline even when all servers are running correctly.
The Role of DHCP in a Network
DHCP, the Dynamic Host Configuration Protocol, automates IP configuration for clients. Instead of manually assigning addresses, netmasks, gateways, and DNS servers to every device, you deploy a DHCP server that hands out leases with this information. Every modern operating system, including Linux, ships with a DHCP client that can request configuration automatically at boot.
In a typical IPv4 network, a DHCP server owns a pool of addresses on a subnet and leases these addresses to clients for finite periods. Each lease links a client identifier such as a MAC address to an IP address and an expiration time. Along with the address itself, the server sends a collection of options that define how the client should behave on the network. These include basic routing information and also higher level details like which DNS domain name to use.
DHCP is especially important on networks that have many short lived or unmanaged devices, such as office Wi‑Fi, data center bare metal servers, and lab environments. For Linux server administrators, DHCP can serve as the primary method to bootstrap machines into a known configuration, especially when combined with PXE boot and configuration management tools.
Only one active DHCP server should control a given layer 2 broadcast domain unless you have deliberately configured coordinated failover. Multiple uncoordinated DHCP servers on the same network segment will cause unpredictable client configuration and hard to diagnose issues.
How DNS and DHCP Work Together
DNS and DHCP are separate protocols but in real networks they are closely connected. DHCP hands out configuration that determines how clients use DNS, and in some setups DHCP can update DNS so that other devices can find clients by name.
When a client receives a DHCP lease, one of the standard DHCP options it gets is the list of DNS resolver addresses. Another option can define the default DNS search domain, which allows users and applications to refer to short names such as db01 instead of fully qualified names such as db01.corp.example.com. The DHCP server also often assigns a host name to the client, or the client proposes its own name during the exchange.
In dynamic environments, you commonly use so‑called dynamic DNS. In this model, the DHCP server, after leasing an address to a client, sends authenticated DNS update messages to an authoritative DNS server. These updates create or refresh A or AAAA records and corresponding PTR records that map between host names and IP addresses. The result is that a client becomes reachable under a stable name even though its address might be assigned dynamically and can change over time.
From the administrator's point of view, integrating DNS and DHCP reduces manual zone file editing and lowers the risk of inconsistent records. It also makes it more realistic to track and audit devices. However, it increases the importance of securing both services, because any weakness in update authentication can allow attackers to poison DNS with false data.
Typical Deployment Scenarios
In small or home networks, DNS and DHCP are often bundled into the same device such as a consumer router. In these setups, the router acts as a simple DHCP server and forwards DNS queries to upstream resolvers. In Linux based home routers, this job is often handled by daemons such as dnsmasq or odhcpd.
In enterprise networks, the picture is more complex. You may have multiple DHCP servers that provide redundancy across different subnets, each with carefully configured scopes and lease parameters. DNS might be centralized in a small number of authoritative servers for the corporate domains, with separate recursive resolvers for internal clients. In some environments, especially those that mix Linux and other platforms, DNS and DHCP integration is handled by directory services where host records and leases are tied to identity information.
In data centers and cloud environments, Linux servers might not run their own DHCP servers at all. Instead, DHCP can be a feature of the physical switch infrastructure or the cloud provider's virtual network fabric. The Linux virtual machines still use DHCP clients, but the actual server side is managed by the platform. DNS may also be provided as a managed service, while administrators interact with it via APIs or control panels instead of editing local configuration files.
On the other hand, if you are designing a private cloud, bare metal provisioning platform, or lab cluster, you may choose to run both DNS and DHCP on Linux servers under your direct control. Tools that automate provisioning, such as PXE boot plus installation frameworks, often depend on predictable DHCP behavior and tightly integrated DNS so that new machines appear in monitoring, configuration management, and logging systems as soon as they come online.
Address Management and Lease Strategies
Behind the scenes, a well run DNS and DHCP setup implies careful address management. DHCP servers hand out addresses from subnets that you design. Each subnet has ranges reserved for dynamic allocation and often separate ranges reserved for static assignments such as routers, switches, or critical servers.
Two common assignment strategies exist. In fully dynamic assignment, any host can receive any free address from the pool. This is common for guests or unmanaged devices. In static or fixed leases, you predefine a mapping between a client identifier and a specific address. The DHCP server still hands out the configuration automatically, but the device always gets the same IP. This is particularly useful for infrastructure nodes that should be reachable under constant addresses but that you prefer to manage centrally.
These lease strategies interact with DNS. Fully dynamic clients are often best represented in DNS using dynamic updates with relatively short TTLs, because their addresses may change. Fixed leases, by contrast, can be treated almost like statically assigned hosts, with longer TTLs in DNS and more stable names.
As the environment grows, you often introduce an IP address management system that tracks ownership, usage, and purpose of every block and address. DNS and DHCP servers can be linked to this central inventory so that changes in one place propagate safely. While the details of such systems are specific to tools, the underlying principle is consistent: DNS reflects name to address mappings, DHCP realizes address to device allocations, and IPAM maintains the planning layer that keeps the entire scheme coherent.
Security Considerations
Both DNS and DHCP were originally designed in more trusted network eras and must be hardened for modern usage. DNS suffers from risks such as cache poisoning, spoofed answers, and data exfiltration. DHCP is vulnerable to rogue servers that feed clients malicious configuration, as well as to attacks that exhaust address pools or impersonate other devices.
On Linux, you commonly deploy protective measures around these services. For DNS, you can restrict recursion to trusted subnets on your resolvers, enforce strict access controls on dynamic updates, and use DNSSEC for validating signed records. For DHCP, you can limit which interfaces run servers, control which clients can receive leases using features such as reservations or network access control, and monitor lease pools for unusual activity.
Integration also introduces combined risks. If a compromised client manages to manipulate DHCP, it might cause incorrect DNS updates that misdirect other systems. Conversely, if an attacker subverts your DNS servers, they can make clients connect to the wrong hosts even if DHCP itself is sound. This is why many production environments separate authoritative DNS from client facing resolvers and segment DHCP servers according to security zones.
Do not expose DHCP to untrusted network segments, and never allow unauthenticated hosts from untrusted networks to perform dynamic DNS updates.
Operational Monitoring and Troubleshooting
Running DNS and DHCP on Linux servers requires continuous monitoring. Administrators need to know how heavily the services are used, whether they respond within acceptable time limits, and whether any anomalies appear in their logs.
For DNS, you observe query rates, response times, cache hit ratios, and error codes. Detailed logging can reveal which clients are generating unusual traffic or which domains cause repeated failures. When problems arise, tools such as dig and host help test resolution and follow delegation chains. On the server, query logs and statistics exports help identify misconfigured zones, expired records, or external abuse.
For DHCP, you focus on lease utilization, pool exhaustion, and patterns of client churn. Logs show each lease granted, renewed, or released, which lets you trace configuration given to a specific device. When a client reports connectivity problems, you verify first that it has obtained a lease, that the lease parameters match the intended network design, and that no other device holds the same address.
In both cases, Linux distributions integrate these daemons with the system logging and service management stack, which means that failures often surface in systemd unit status and journal entries. Proper alerting around these metrics can warn you long before a pool runs out of addresses or a DNS server becomes overloaded.
DNS and DHCP in Virtualized and Cloud Environments
Virtualization and containerization introduce additional layers where DNS and DHCP appear. Hypervisors and virtual switches commonly embed their own DHCP servers to assign addresses to guests. Virtual networks can define synthetic subnets that are not directly visible on the physical fabric. Within this space, Linux based DHCP services hand out not only IP addresses but sometimes metadata for cloud initialization.
Containers in orchestration platforms such as Kubernetes also depend heavily on service discovery and name resolution. While they rarely use traditional DHCP inside pods, they do rely on DNS views maintained by specialized components. From the host perspective, you still need to ensure that your upstream DNS services are reachable and that routing and firewall configurations allow these flows.
In cloud platforms, your Linux servers often inherit DNS and DHCP behavior from provider controlled services. You configure aspects of this behavior through APIs. For example, you might define virtual private clouds, subnets, and DNS zones at the cloud control plane level. Your Linux instances use these definitions to resolve internal service names and to obtain addresses when they boot. Understanding the conceptual roles of DNS and DHCP lets you reason correctly about this environment even when you are not editing local configuration files directly.
Planning a Reliable DNS and DHCP Architecture
Designing reliable DNS and DHCP for a Linux based infrastructure involves redundancy, separation of roles, and clear policies. You generally deploy multiple DNS servers that act as authoritative sources for your domains. These use replication mechanisms so that changes propagate predictably. Separate resolvers, sometimes implemented as caching forwarders, handle client queries and shield the authoritative infrastructure from direct exposure.
For DHCP, redundancy is usually achieved through failover arrangements or by segmenting responsibilities across subnets, with each subnet served by at least two coordinated servers. Careful planning ensures that even if one server fails, clients can still obtain or renew leases without disruption. At the same time, your design should avoid overlapping scopes that risk conflicting assignments.
Policies must answer questions such as which hosts receive dynamic addresses, which require static reservations, how long leases should last for each class of device, and how DNS names are assigned or updated. These decisions influence the usability and maintainability of your environment and should align with broader security and compliance requirements.
By treating DNS and DHCP as shared infrastructure rather than one‑off services on individual servers, you put yourself in a position to scale, secure, and troubleshoot more effectively. Later chapters will dive into concrete configurations and step by step setups, but the concepts you have seen here are the foundation on which those implementations are built.
Views: 0
Where to Move
Move chapter:
- ☰ 1. PART I — Linux Fundamentals (Beginner)
- ☰ 1.1. What Is Linux?
- ☰ 1.1.1. What is an operating system
- ☰ 1.1.2. History of Unix and Linux
- ☰ 1.1.3. The Linux kernel
- ☰ 1.1.4. GNU and the Free Software Foundation
- ☰ 1.1.5. Open source philosophy
- ☰ 1.1.6. Where Linux is used today
- ☰ 1.1.7. Desktop vs server vs embedded Linux
-
- ☰ 1.2. Choosing a Linux Distribution
- ☰ 1.2.1. What is a distribution?
- ☰ 1.2.2. Package formats (deb, rpm, pacman)
- ☰ 1.2.3. Popular distributions
- ☰ 1.2.3.1. Ubuntu
- ☰ 1.2.3.2. Debian
- ☰ 1.2.3.3. Fedora
- ☰ 1.2.3.4. Arch Linux
- ☰ 1.2.3.5. openSUSE
-
- ☰ 1.2.4. Rolling vs fixed release
- ☰ 1.2.5. Choosing the right distribution
-
- ☰ 1.3. Installing Linux
- ☰ 1.3.1. Creating a bootable USB
- ☰ 1.3.2. Installing on real hardware
- ☰ 1.3.3. Dual booting with Windows
- ☰ 1.3.4. Installing in a virtual machine
- ☰ 1.3.5. Partitioning
- ☰ 1.3.5.1. `/` (root)
- ☰ 1.3.5.2. `/home`
- ☰ 1.3.5.3. Swap
-
- ☰ 1.3.6. First-time setup
-
- ☰ 1.4. First Steps After Installation
- ☰ 1.4.1. Desktop environment basics
- ☰ 1.4.2. Updating the system
- ☰ 1.4.3. Installing essential tools
- ☰ 1.4.4. Setting up drivers
- ☰ 1.4.5. Using the software center
-
- ☰ 1.5. Linux Filesystem Hierarchy
- ☰ 1.5.1. Overview of the root filesystem
- ☰ 1.5.2. Important directories
- ☰ 1.5.2.1. `/etc`
- ☰ 1.5.2.2. `/var`
- ☰ 1.5.2.3. `/usr`
- ☰ 1.5.2.4. `/tmp`
- ☰ 1.5.2.5. `/dev`
- ☰ 1.5.2.6. `/proc`
- ☰ 1.5.2.7. `/sys`
-
- ☰ 1.5.3. File types
- ☰ 1.5.4. Absolute vs relative paths
-
- ☰ 1.6. The Linux Graphical Environment
- ☰ 1.6.1. GNOME
- ☰ 1.6.2. KDE Plasma
- ☰ 1.6.3. XFCE
- ☰ 1.6.4. File managers
- ☰ 1.6.5. System settings
- ☰ 1.6.6. Workspaces and window management
-
-
- ☰ 2. PART II — Command Line Essentials
- ☰ 2.1. Terminal and Shell Basics
- ☰ 2.1.1. What is a shell?
- ☰ 2.1.2. Bash vs Zsh vs Fish
- ☰ 2.1.3. Command structure
- ☰ 2.1.4. Environment variables
- ☰ 2.1.5. Getting help
- ☰ 2.1.6. Command history and autocomplete
-
- ☰ 2.2. Files and Directories
- ☰ 2.2.1. Listing files
- ☰ 2.2.2. Navigating directories
- ☰ 2.2.3. File operations
- ☰ 2.2.4. Wildcards and globbing
- ☰ 2.2.5. Searching files
-
- ☰ 2.3. Viewing and Editing Text Files
- ☰ 2.3.1. Viewing tools
- ☰ 2.3.2. Editing with nano
- ☰ 2.3.3. Introduction to vim
- ☰ 2.3.4. Input/output redirection
-
- ☰ 2.4. Users, Permissions, and Ownership
- ☰ 2.4.1. Users and groups
- ☰ 2.4.2. Permission types (r, w, x)
- ☰ 2.4.3. Changing permissions
- ☰ 2.4.4. Changing ownership
- ☰ 2.4.5. Using sudo
-
- ☰ 2.5. Package Management
- ☰ 2.5.1. Software repositories
- ☰ 2.5.2. APT (Debian/Ubuntu)
- ☰ 2.5.3. DNF (Fedora/RHEL)
- ☰ 2.5.4. Pacman (Arch Linux)
- ☰ 2.5.5. Snap, Flatpak, AppImage
- ☰ 2.5.6. System upgrades
-
- ☰ 2.6. Working with Processes
- ☰ 2.6.1. What is a process?
- ☰ 2.6.2. Viewing processes
- ☰ 2.6.3. Killing processes
- ☰ 2.6.4. Foreground and background jobs
- ☰ 2.6.5. System services and daemons
-
- ☰ 2.7. Introduction to Shell Scripting
- ☰ 2.7.1. Writing your first script
- ☰ 2.7.2. Variables
- ☰ 2.7.3. Conditionals
- ☰ 2.7.4. Loops
- ☰ 2.7.5. Functions
- ☰ 2.7.6. Making scripts executable
-
-
- ☰ 3. PART III — Intermediate System Administration
- ☰ 3.1. Systemd and Service Management
- ☰ 3.1.1. What is systemd?
- ☰ 3.1.2. Managing services (systemctl)
- ☰ 3.1.3. Boot targets
- ☰ 3.1.4. System logs (journalctl)
- ☰ 3.1.5. Creating custom services
-
- ☰ 3.2. Storage and Filesystems
- ☰ 3.2.1. Devices and partitions
- ☰ 3.2.2. Filesystems (EXT4, XFS, Btrfs)
- ☰ 3.2.3. Mounting and unmounting
- ☰ 3.2.4. Disk usage tools
- ☰ 3.2.5. Archiving and compression (tar, gzip, xz)
-
- ☰ 3.3. Networking Fundamentals
- ☰ 3.3.1. IP addressing
- ☰ 3.3.2. Subnets and routing
- ☰ 3.3.3. DNS and hostnames
- ☰ 3.3.4. Networking tools (ip, ss, ping)
- ☰ 3.3.5. Editing network configuration files
-
- ☰ 3.4. User and Group Administration
- ☰ 3.4.1. User information files
- ☰ 3.4.2. Creating and removing users
- ☰ 3.4.3. Password policies
- ☰ 3.4.4. Managing groups
- ☰ 3.4.5. Shell configuration
-
- ☰ 3.5. System Monitoring
- ☰ 3.5.1. CPU and memory monitoring
- ☰ 3.5.2. Disk and I/O monitoring
- ☰ 3.5.3. Log files in /var/log
- ☰ 3.5.4. Boot performance
- ☰ 3.5.5. Monitoring running services
-
- ☰ 3.6. Backup and Restore
- ☰ 3.6.1. Backup strategies
- ☰ 3.6.2. Using rsync
- ☰ 3.6.3. Creating tar archives
- ☰ 3.6.4. Using snapshot systems
- ☰ 3.6.5. Automating backups
-
- ☰ 3.7. Basic System Security
- ☰ 3.7.1. Firewalls (UFW, firewalld)
- ☰ 3.7.2. Authentication policies
- ☰ 3.7.3. SSH security basics
- ☰ 3.7.4. SELinux and AppArmor overview
- ☰ 3.7.5. Intrusion detection basics
-
-
- ☰ 4. PART IV — Advanced Linux Skills
- ☰ 4.1. Advanced Shell Scripting
- ☰ 4.1.1. Script structure
- ☰ 4.1.2. Error handling
- ☰ 4.1.3. Debugging scripts
- ☰ 4.1.4. Scheduled tasks (cron)
-
- ☰ 4.2. The Linux Boot Process
- ☰ 4.2.1. BIOS vs UEFI
- ☰ 4.2.2. Understanding GRUB2
- ☰ 4.2.3. Kernel loading
- ☰ 4.2.4. initramfs
- ☰ 4.2.5. Troubleshooting boot issues
-
- ☰ 4.3. Kernel Management
- ☰ 4.3.1. What is the kernel?
- ☰ 4.3.2. Kernel modules
- ☰ 4.3.3. Kernel parameters
- ☰ 4.3.4. Compiling a custom kernel
- ☰ 4.3.5. Kernel versioning and updates
-
- ☰ 4.4. Advanced Filesystems and Storage
- ☰ 4.4.1. LVM concepts
- ☰ 4.4.2. Logical volumes
- ☰ 4.4.3. RAID levels
- ☰ 4.4.4. Full disk encryption (LUKS)
- ☰ 4.4.5. Snapshots and rollbacks
-
- ☰ 4.5. Network Services
- ☰ 4.5.1. SSH server configuration
- ☰ 4.5.2. NFS
- ☰ 4.5.3. Samba
- ☰ 4.5.4. FTP/SFTP
- ☰ 4.5.5. Firewalls in depth
-
- ☰ 4.6. Logging and Auditing
- ☰ 4.6.1. Systemd logging
- ☰ 4.6.2. Traditional logs in /var/log
- ☰ 4.6.3. Auditd
- ☰ 4.6.4. Log rotation
- ☰ 4.6.5. Creating custom logs
-
- ☰ 4.7. Virtualization and Containers
- ☰ 4.7.1. Virtual machines (KVM/QEMU)
- ☰ 4.7.2. Linux containers (LXC/LXD)
- ☰ 4.7.3. Docker fundamentals
- ☰ 4.7.4. Podman vs Docker
- ☰ 4.7.5. Container networking
-
-
- ☰ 5. PART V — Server Administration (Expert)
- ☰ 5.1. Web Servers
- ☰ 5.1.1. Apache basics
- ☰ 5.1.2. Nginx basics
- ☰ 5.1.3. Virtual hosts
- ☰ 5.1.4. SSL/HTTPS
- ☰ 5.1.5. Reverse proxy concepts
-
- ☰ 5.2. Database Servers
- ☰ 5.2.1. MySQL/MariaDB
- ☰ 5.2.2. PostgreSQL
- ☰ 5.2.3. Database backup strategies
- ☰ 5.2.4. Database hardening
-
- ☰ 5.3. Email Services
- ☰ 5.3.1. SMTP fundamentals
- ☰ 5.3.2. Configuring Postfix
- ☰ 5.3.3. IMAP/POP3 with Dovecot
- ☰ 5.3.4. Spam filtering systems
- ☰ 5.3.5. Email routing concepts
-
- ☰ 5.4. DNS and DHCP
- ☰ 5.4.1. Understanding DNS
- ☰ 5.4.2. Setting up BIND
- ☰ 5.4.3. DNS zones and records
- ☰ 5.4.4. DHCP server configuration
- ☰ 5.4.5. DNS troubleshooting
-
- ☰ 5.5. Load Balancing
- ☰ 5.5.1. HAProxy fundamentals
- ☰ 5.5.2. Nginx as a load balancer
- ☰ 5.5.3. Session persistence
- ☰ 5.5.4. High availability concepts
-
- ☰ 5.6. Clustering and High Availability
- ☰ 5.6.1. Failover principles
- ☰ 5.6.2. Pacemaker
- ☰ 5.6.3. Corosync
- ☰ 5.6.4. Cluster resource management
- ☰ 5.6.5. Distributed filesystems
-
-
- ☰ 6. PART VI — DevOps and Cloud
- ☰ 6.1. Linux for Developers
- ☰ 6.1.1. Compiler toolchains (gcc, make)
- ☰ 6.1.2. Git fundamentals
- ☰ 6.1.3. Debugging tools (gdb, strace)
- ☰ 6.1.4. Build automation (Makefile, CMake)
-
- ☰ 6.2. DevOps on Linux
- ☰ 6.2.1. CI/CD principles
- ☰ 6.2.2. YAML basics
- ☰ 6.2.3. GitHub Actions
- ☰ 6.2.4. GitLab CI/CD
- ☰ 6.2.5. Automated testing
-
- ☰ 6.3. Configuration Management
- ☰ 6.3.1. Ansible basics
- ☰ 6.3.2. Playbooks and inventories
- ☰ 6.3.3. Puppet overview
- ☰ 6.3.4. Chef overview
-
- ☰ 6.4. Infrastructure as Code
- ☰ 6.4.1. Terraform fundamentals
- ☰ 6.4.2. Providers and resources
- ☰ 6.4.3. Modules
- ☰ 6.4.4. Cloud provisioning with Terraform
-
- ☰ 6.5. Cloud Computing with Linux
- ☰ 6.5.1. Linux on AWS
- ☰ 6.5.2. Linux on Azure
- ☰ 6.5.3. Linux on GCP
- ☰ 6.5.4. Cloud networking basics
- ☰ 6.5.5. Scaling and monitoring
-
-
- ☰ 7. PART VII — Master Topics
- ☰ 7.1. Hardening a Linux System
- ☰ 7.1.1. Hardening principles
- ☰ 7.1.2. Kernel hardening
- ☰ 7.1.3. File integrity monitoring
- ☰ 7.1.4. Vulnerability scanning
-
- ☰ 7.2. Forensics and Incident Response
- ☰ 7.2.1. Collecting evidence
- ☰ 7.2.2. Log and file recovery
- ☰ 7.2.3. Analyzing suspicious processes
- ☰ 7.2.4. Incident response workflow
-
- ☰ 7.3. Performance Tuning
- ☰ 7.3.1. CPU tuning
- ☰ 7.3.2. Memory tuning
- ☰ 7.3.3. Disk and I/O optimization
- ☰ 7.3.4. Profiling tools
-
- ☰ 7.4. Writing Linux Tools
- ☰ 7.4.1. Bash-based tools
- ☰ 7.4.2. Python command-line tools
- ☰ 7.4.3. Writing tools in C
- ☰ 7.4.4. Using Linux system APIs
-
- ☰ 7.5. Linux Internals
- ☰ 7.5.1. Process lifecycle
- ☰ 7.5.2. Memory management
- ☰ 7.5.3. Signals and IPC
- ☰ 7.5.4. Namespaces
- ☰ 7.5.5. cgroups
-
- ☰ 7.6. Becoming a Linux Expert
- ☰ 7.6.1. Career paths
- ☰ 7.6.2. Certifications (RHCE, LFCS, LPIC)
- ☰ 7.6.3. Building a homelab
- ☰ 7.6.4. Contributing to open source
-
-
Comments
Please login to add a comment.
Don't have an account? Register now!