6.4.2. Providers and resources
Table of Contents
Understanding Providers and Resources in Terraform
In Infrastructure as Code with Terraform, providers and resources are the two core building blocks you work with every day. This chapter focuses on what they are, how they relate to each other, and how to use them correctly in real Terraform configurations.
The Role of Providers
A provider is a Terraform plugin that knows how to talk to an external system. That system might be a cloud platform, a virtualization platform, a SaaS service, or even a local tool. The provider translates Terraform configuration into real API calls and then returns information back to Terraform.
When you write Terraform code to create a virtual machine on a cloud platform, Terraform itself does not know how to talk to that platform. Instead, it loads a provider for that platform, and the provider handles the details of authentication, API endpoints, and the sequence of operations.
Terraform makes you declare providers explicitly. This happens in a terraform block and in one or more provider blocks. For example, you might declare that you are using the aws provider at a certain version, then configure it with a region.
Terraform keeps providers separate from core features so that the same Terraform tool can manage many kinds of infrastructure simply by adding or updating provider plugins.
Configuring Providers
Provider configuration tells Terraform how to connect to the external system. Common settings include region, endpoint URLs, profiles, or organization identifiers. Credentials are often provided indirectly, for example through environment variables or external files, although they can also be specified directly.
A minimal provider declaration usually has two parts. First, you declare the requirement so Terraform knows which plugin and which version it must install. Second, you configure how that provider instance should behave.
A basic pattern looks like this:
terraform {
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 5.0"
}
}
}
provider "aws" {
region = "us-east-1"
}
The required_providers block tells Terraform which provider plugin to download and what version constraints apply. The provider "aws" block creates a configured instance of that provider. When you run terraform init, Terraform will download and install that provider and store it in the working directory. Later commands such as terraform plan and terraform apply will then use that provider.
Most cloud providers support a mixture of configuration methods. For example, a provider may read credentials from environment variables such as AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, from a credentials file, or from direct arguments in the provider block. It is common practice to keep secrets out of configuration files and rely on external mechanisms instead.
Provider configuration should avoid hard coding secrets such as passwords or long‑lived access keys. Prefer environment variables, short‑lived tokens, or secret management systems to reduce risk.
When multiple providers are used in a single Terraform project, each provider must either have its own provider block or rely on default settings. Terraform will automatically infer which provider a resource needs based on its type, for example aws_instance uses the aws provider, azurerm_resource_group uses the azurerm provider, and so on.
Provider Versions and Upgrades
Provider versions are important because changes in provider behavior can affect your infrastructure. Terraform lets you pin versions or specify version ranges. A common pattern is to use a pessimistic constraint that allows compatible updates while blocking major breaking changes.
For example:
terraform {
required_providers {
google = {
source = "hashicorp/google"
version = "~> 5.7"
}
}
}
This allows updates that stay within the same major version, for example from 5.7.0 to 5.9.3, but prevents upgrades to 6.0.0 without an explicit change in the configuration. This gives you control over when you adopt potentially breaking changes.
When you change provider version constraints and run terraform init -upgrade, Terraform will fetch newer versions that satisfy the new constraint. After that, it is good practice to run terraform plan and review any changes caused by provider behavior updates, especially default values or deprecated fields.
Provider Aliases and Multiple Configurations
Sometimes a single project needs multiple configurations of the same provider. For example, you might create resources in two different regions or two different accounts. In this case you can use provider aliases to create more than one provider instance.
The alias argument in a provider block names an additional instance. Later, individual resources can reference the specific provider they need using the provider meta‑argument.
A simple illustration looks like this:
terraform {
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 5.0"
}
}
}
provider "aws" {
region = "us-east-1"
}
provider "aws" {
alias = "eu"
region = "eu-central-1"
}
resource "aws_s3_bucket" "us_logs" {
bucket = "my-us-logs-bucket"
}
resource "aws_s3_bucket" "eu_logs" {
provider = aws.eu
bucket = "my-eu-logs-bucket"
}
Here Terraform uses the default aws provider for aws_s3_bucket.us_logs and the aliased provider aws.eu for aws_s3_bucket.eu_logs. Each provider instance manages resources against the region or account it is configured for.
Aliased providers are also common in modules. A module can declare that it expects certain providers and the root module can pass in aliased providers so that the same module code can be used with different configurations.
What Resources Represent
A resource is a block in Terraform that describes one object that Terraform manages. That object could be a virtual machine, a network, a database instance, a DNS record, or any other manageable item that the provider exposes.
Each resource has a type and a local name. The type comes from the provider, such as aws_instance, azurerm_virtual_network, or google_compute_network. The local name identifies a specific resource of that type within your configuration. Taken together, the type and name form a resource address, for example aws_instance.web.
Inside a resource block, arguments describe the desired state for that object. When you run terraform apply, Terraform compares the desired state with the current remote state, then creates, updates, or destroys the object to match what you have declared.
A minimal resource example might look like this:
resource "aws_instance" "web" {
ami = "ami-12345678"
instance_type = "t3.micro"
}
Here, Terraform will ask the aws provider to create or maintain an EC2 instance with the given AMI and instance type. The provider knows which API calls to use. Terraform tracks the result in its state so that future runs can detect drift or identify necessary changes.
Every resource block describes the desired state, not specific create or delete commands. Terraform decides whether to create, change, or destroy based on the difference between the configuration and the current state.
Resources are always tied to a single provider. The prefix of the resource type, such as aws_, azurerm_, or google_, determines which provider must be installed and configured. If Terraform sees a resource type whose provider is not declared, it will prompt you to add the corresponding provider requirement.
Resource Arguments and Attributes
Resource blocks contain arguments that set properties of the managed object. Some arguments are required, others are optional with defaults, and some are computed by the provider after creation.
In the configuration, you specify input arguments such as names, sizes, and configuration options. After terraform apply, Terraform records output attributes, such as IDs, IP addresses, and computed values that come from the provider.
You can reference attributes from one resource in another using the resource address and attribute name. For example:
resource "aws_vpc" "main" {
cidr_block = "10.0.0.0/16"
}
resource "aws_subnet" "public" {
vpc_id = aws_vpc.main.id
cidr_block = "10.0.1.0/24"
map_public_ip_on_launch = true
}
Here, the aws_subnet.public resource uses aws_vpc.main.id. The provider sets the id attribute when the VPC is created. Terraform uses this reference to build a dependency graph so that it creates the VPC before the subnet and passes the correct identifier to the provider.
Some attributes are marked as computed, which means they are not known until after apply. In a plan, Terraform will show them as known after apply. These values can then feed into other resources or outputs.
Provider Data Sources vs Resources
Providers often expose two kinds of blocks in Terraform, resources and data sources. Both come from the provider, but they have different purposes.
A resource manages the lifecycle of an object. Terraform can create, change, and destroy it. A data source lets Terraform read information about objects that exist outside its control, such as an existing image, an existing network, or a remote configuration value.
Although this chapter focuses on resources, it is common to use both side by side. For example, you might use a data source to look up the ID of a standard image, then pass that ID into a resource that creates a virtual machine. The provider uses different blocks for these roles, for example data "aws_ami" "ubuntu" for reading an existing AMI and resource "aws_instance" "web" for creating an instance.
Both resources and data sources rely on the same provider configuration. They use the same authentication and endpoint settings, but Terraform treats them differently when planning changes. Data sources are read only and do not appear as created or destroyed in your plan.
Resource Dependencies and Ordering
In practical use, resources often depend on one another. A subnet depends on a network, a database instance depends on a subnet, and so on. Terraform infers these dependencies from references between resource attributes. Any time you use an expression like aws_vpc.main.id inside another resource, Terraform establishes a dependency.
This implicit dependency graph determines the order in which Terraform creates and destroys resources. Terraform will create all prerequisites first, then the dependent resources. When destroying infrastructure, it reverses the order, so that dependent resources are removed before the ones they rely on.
In more complex situations, you may also use the depends_on meta‑argument to declare an explicit dependency when no direct attribute reference exists. Because this changes how Terraform plans and applies changes, you should only use depends_on when attribute references are not possible or when a provider's API requires a very specific order of operations that Terraform would not otherwise infer.
Meta‑arguments for Resources
Resources support several built‑in meta‑arguments that change how Terraform manages them. These meta‑arguments are handled by Terraform itself, not by the provider. Several of the most common are:
depends_on allows an explicit list of dependencies.
count allows you to create multiple instances of a resource with the same configuration pattern, indexed by a numeric counter.
for_each lets you create multiple resources based on a map or set of strings, with each instance keyed by an element of the collection.
provider allows a resource to select a specific provider instance, including aliased providers.
For example, for_each can create one resource per key in a map:
variable "subnets" {
type = map(string)
default = {
public = "10.0.1.0/24"
private = "10.0.2.0/24"
}
}
resource "aws_subnet" "this" {
for_each = var.subnets
vpc_id = aws_vpc.main.id
cidr_block = each.value
tags = {
Name = each.key
}
}
Terraform will create two subnet resources, aws_subnet.this["public"] and aws_subnet.this["private"], each with its own CIDR block and tag. The provider still sees individual resources, but Terraform uses the meta‑arguments to derive them from a single block in configuration.
Custom and Third‑Party Providers
Although many providers are maintained by HashiCorp or major cloud vendors, Terraform also supports third‑party and community providers. These providers are distributed through registries and are selected by their source, which includes a namespace, a name, and sometimes a hostname.
A third‑party provider might look like this:
terraform {
required_providers {
mycloud = {
source = "myorg/mycloud"
version = "~> 1.2"
}
}
}
provider "mycloud" {
api_endpoint = "https://api.mycloud.example.com"
}
Behind the scenes, this is a separate plugin binary that implements the provider protocol. From your perspective as a user, it behaves like any other provider. It offers resource types such as mycloud_server or mycloud_network that you can manage through Terraform.
Because third‑party providers may have different levels of support and testing, version pinning and careful review of documentation and release notes become even more important.
Provider and Resource Lifecycle in Practice
In a typical workflow, providers and resources follow a consistent lifecycle. At the start, you declare provider requirements in your Terraform configuration. You then run terraform init to install or update providers. After that, you write resource blocks that describe the desired state of your infrastructure.
When you run terraform plan, Terraform loads the providers, queries their information about existing resources, and computes the changes needed. The providers handle read operations, such as fetching the current state of each managed object.
When you run terraform apply, Terraform calls the provider to create, update, or delete resources in the order defined by the dependency graph. As it does this, it updates the state file with the latest attributes so that future plans are accurate.
Over time, you may update provider versions, add new providers, or change provider configuration. You may also add, modify, or remove resources. Throughout these changes, Terraform coordinates with the providers to keep the actual infrastructure aligned with the configuration you have declared.
Understanding how providers and resources interact is the key to using Terraform effectively. Providers give Terraform reach into many systems, and resources let you describe those systems in a consistent and reusable way.
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!