Welcome to my hands-on practical labs journal and learning tracker. This page maps my journey building physical infrastructure (Bare-Metal Proxmox Homelab), Linux system administration (LFCS Track), infrastructure automation (IaC), container orchestration (Kubernetes), and hybrid cloud emulation.
Verified and successfully implemented labs.
Workloads currently active or in-setup.
Modules scheduled for next deployments.
Bare-metal configuration of Proxmox, BIOS hardening, host power management, custom repositories, subscription tweaks, and storage/networking inspection.
BIOS/UEFI Hardening: Flash the latest Proxmox ISO using Ventoy/Rufus. Enter Acer Nitro BIOS, disable Secure Boot, and enable Intel Virtualization Technology (VT-x) and VT-d to ensure hardware virtualization is active.
Bare-Metal PVE Installation: Connect the laptop via LAN. Install Proxmox on the main SSD, select ext4/XFS filesystem, configure FQDN (`pve01.homelab.local`), static IP, and gateway router.
Host Power Management: Configure `/etc/systemd/logind.conf` with `HandleLidSwitch=ignore`, restart systemd-logind, and test that the host remains running when the laptop lid is closed.
CPU Governor & Thermal Tweak: Install cpufrequtils. Configure the CPU scaling governor to powersave/ondemand to optimize temperature and fan noise.
PVE Repository Tweak: Disable the Proxmox enterprise repository, enable the pve-no-subscription repository, then update and upgrade packages.
Subscription Warning Removal: Remove the "No Valid Subscription" warning notification on the Proxmox Web GUI using CLI script modification.
Host Network Bridge Inspection: Analyze `ip a` and `/etc/network/interfaces`. Understand the relationship between the physical interface (`enp...`) and the virtual bridge (`vmbr0`) as the VM network layer.
Storage Seeding: Download the Debian 12 Netinstaller ISO and Debian 12 Standard LXC Template via the Proxmox Web GUI for VM/container requirements.
Deep dive into standard Linux operations, virtual storage systems (LVM, mount hardening), network routing, packet filtering, and user group management.
Advanced LVM & Online Resizing: Setup a manual Debian 12 VM in Proxmox. Create a full disk scenario, add a new virtual disk, combine it into the Volume Group, and perform an online extension of the Logical Volume and ext4 filesystem without a reboot.
Swap Space & Tuning: Create a new swap partition using Logical Volume, register it permanently in `/etc/fstab`, and tune `vm.swappiness`.
Fstab Hardening & Autofs: Configure mounts with `noexec,nosuid,nodev` options. Setup autofs for on-demand mounting.
NFS Client-Server Architecture: VM-1 acts as the NFS Server, VM-2 acts as the client with permanent mounting.
Storage Monitoring & Triage: Simulate high I/O wait with stress-ng. Analyze bottlenecks using `iostat`, `df`, `du`, and identify hidden deleted files.
Manual IPv4/IPv6 & DNS: Configure static IP via `/etc/network/interfaces`, hostname resolution via `/etc/hosts` and `/etc/resolv.conf`.
Time Synchronization: Setup chrony/ntpd for NTP synchronization and auditing requirements.
Bridge & Bonding Devices: Configure Linux Bridge `br0` and simulate network bonding.
Static Routing: Configure Linux routing using `ip route` between homelab subnets.
SSH Server Hardening: Disable password login, enforce key authentication, change custom port, restrict users, and analyze authorization logs.
Packet Filtering & NAT: Setup iptables/nftables for filtering, port redirection, IP forwarding, and NAT masquerade.
Reverse Proxy & Load Balancer: Setup Nginx/HAProxy as a Round-Robin load balancer to backend servers.
Network Triage: Use `tcpdump`, `ss`, `traceroute`, and `dig` for connection and DNS troubleshooting.
Kernel Parameter Configuration: Modify runtime and persistent sysctl parameters for network buffers and open file limits.
Process Triage & Signals: Analyze processes with `top`, `ps`, and `lsof`. Manage signals using kill/pkill.
Custom Systemd Services: Create services from scripts, configure auto-restart, and manage lifecycle using systemctl.
Systemd Timers & Cron: Automate backups using cron and systemd timers, analyze output with journalctl.
Package Management: Setup repository, manage apt/dpkg lifecycle, and verify package signatures.
Virtual Machine Management: Setup KVM/QEMU/libvirt and manage VMs with the virsh CLI.
Container Engine: Install Docker/Podman, manage containers, volumes, ports, and lifecycles.
AppArmor/SELinux: Implement Mandatory Access Control, modify service profiles, and enforce policies.
Local Git Lifecycle: Repository management, branching, and merge conflict resolution.
Service Constraint & Profiling: Analyze application resource limits and application logs.
SSL/TLS Certificates: Create a Private CA, key, CSR, and signed certificate for homelab domains.
User & Group Lifecycle: Manage user/group lifecycles, password policies, aging parameters with `chage`, lock accounts, and setup `/etc/skel`.
Environment Profiles: Manage global environment settings in `/etc/profile` and user settings in `.bashrc`.
User Resource Limits: Configure `limits.conf`, nproc, and nofile limits for resource protection.
ACL: Implement `getfacl` and `setfacl` for granular permissions.
LDAP Client Integration: Configure PAM and NSS for centralized authentication.
Automated VM provisioning using OpenTofu/Terraform, declarative state architectures, and target configuration orchestration with Ansible playbooks.
Proxmox Infrastructure Blueprint: Create a Proxmox API Token. Write declarative OpenTofu/Terraform manifests to provision 3 units of Debian 12 VM/LXC automatically with minimal resource allocations (512MB - 1GB RAM per node).
State Architecture: Configure a local backend to store `terraform.tfstate` on the control plane machine, decoupling state management from the target Proxmox host.
Ansible Inventory & SSH Core: Build a dynamic inventory. Setup automated SSH-Key authentication so Ansible can manage 3 target VMs without manual password logins.
Automated LFCS Playbook: Create an Ansible Playbook to automate Linux configuration: user management, SSH hardening, sysctl kernel tuning, LVM setup, and container engine installation in a single `ansible-playbook` execution.
Bootstrapping a multi-node K3s cluster, nested container tuning, Helm chart deployments, GitOps workflow via ArgoCD, and automated reconciliation.
Container Runtime Tuning: Modify cgroups and enable `nesting=1` on the Proxmox host to allow container orchestration workloads to run on VM/LXC with appropriate kernel configurations.
Control Plane Deployment: Use Ansible to install K3s with the `--disable traefik` parameter. Retrieve the `k3s.yaml` kubeconfig to the control plane laptop for management using `kubectl`.
Worker Nodes Joining: Automate node joining using the K3s token for Node 2 and Node 3 as Worker Nodes. Validate using `kubectl get nodes -o wide`.
Deploy ArgoCD to the `argocd` namespace on the K3s cluster using Helm Chart or Kustomize via the control plane terminal.
Repository Sync Strategy: Create a Git repository containing simple microservice application manifests. Connect ArgoCD to the repository and configure the sync strategy with custom polling intervals.
Chaos Engineering & Self-Healing: Modify application replicas via the Git repository. Simulate node/container failure and observe the Kubernetes reconciliation and self-healing mechanism.
Running AWS API mock services locally with LocalStack, terraform-aws provider routing, and multi-cloud server applications writing back to local S3.
AWS Emulator Engine: Run LocalStack inside an isolated Docker container on the homelab Debian VM. Expose the AWS API endpoint (`4566`) to make it accessible from the local network.
AWS CLI Wrapper Integration: Install AWS CLI on the control plane laptop. Configure `~/.aws/config` with dummy credentials and use `--endpoint-url=http://<IP-LAPTOP-ACER>:4566` to interact with the AWS emulator.
Cloud IaC Local Routing: Use the Terraform/OpenTofu AWS Provider. Override AWS service endpoints (S3, DynamoDB, EC2, IAM) to direct all resources to LocalStack. Run `tofu apply` to provision local cloud resources at no cost.
Cross-Platform Application: Deploy a backend application on the K3s cluster. Configure environment variables so that the application uses the AWS SDK to read/write data to the local S3 emulator in LocalStack. Simulate hybrid cloud architecture on the homelab.
© 2026 · Edwin Samodra Pratama