Projects |

Declarative Infrastructure & Cloud-Native Homelab

Wed, 01 Jul 2026 00:00:00 +0000

A complete Infrastructure-as-Code (IaC) repository managing home automation, self-hosted services, and cloud-native testbeds. Built to simulate enterprise-grade, high-availability data center operations on personal hardware.

Architecture Overview

This project represents a fully declarative on-premise infrastructure pipeline. It automates virtual machine deployment, network routing, container orchestration, and secret management across physical and virtual hosts.

Core Implementations

Virtualization & Storage

Hypervisor: Proxmox VE running multiple Linux nodes (Debian/Ubuntu Server).
Storage Backbone: TrueNAS providing NFS/SMB shares with ZFS arrays for data redundancy and rapid backup integration.

Automation & Configuration Management

Terraform: Utilized for the rapid and reproducible provisioning of Proxmox VMs and LXC containers.
Ansible: Playbooks handle OS hardening, SSH key distribution, and service configuration to eliminate configuration drift.

Networking & Security

Edge Routing: OPNSense acts as the primary firewall, managing strict ingress/egress rules.
Mesh VPN: Integration of WireGuard and Tailscale for secure, remote administrative access without exposing internal ports.
Switch Configuration: Specific VLAN IDs are routed for isolated management, IoT, and guest networks, while ensuring unused port assignments are strictly left at their default states for security.
Reverse Proxy: Traefik handles all ingress traffic, routing to specific internal services and automatically managing Let’s Encrypt TLS certificates.

Containerization Deep Dive

Docker Workloads: Services are containerized for portability.
Security Stance: Strict adherence to container security, ensuring the Docker socket is explicitly not mapped to containers unless absolutely required, preventing privilege escalation.

Topology Sketch

┌────────────────┐ ┌──────────────────┐ ┌─────────────────┐
│ OPNSense (Edge)│───▶│ Traefik Ingress │───▶│ Docker / LXC │
│ + WireGuard VPN│ │ (TLS Management) │ │ (App Workloads) │
└───────┬────────┘ └──────────────────┘ └─────────────────┘
 │
┌───────▼────────┐ ┌─────────────────┐
│ Managed Switch │───────────────────────────▶│ TrueNAS Storage │
│ (VLAN Tagging) │ │ (ZFS / NFS) │
└────────────────┘ └─────────────────┘

Energy & Resilience Analysis of 5G Cloud-Native Service Meshes

Mon, 27 Oct 2025 00:00:00 +0000

Master’s thesis research investigating the performance overhead, energy consumption, and mitigation mechanics of Service Meshes deployed over a cloud-native 5G core network.

Research Context

Modern 5G deployments rely heavily on Service-Based Architectures (SBA) running over Kubernetes. While deploying a Service Mesh (like Istio or Linkerd) provides crucial zero-trust security and observability, it injects proxy sidecars into every pod, resulting in compute and energy overhead.

This study specifically evaluates how these sidecars affect CPU utilization, power metrics, and network latency when mitigating active Distributed Denial-of-Service (DDoS) vectors across Service-Based Interfaces (SBI).

Technical Implementation

Environment Setup

5G Core: Containerized deployment utilizing Open5GS running over a localized Kubernetes cluster.
Service Mesh: Implementation of Istio to manage traffic shaping, mTLS, and network policies between Network Functions (NFs).

Telemetry & Benchmarking

Data Collection: Automated metric collection scripts written in Python, interfacing directly with Prometheus.
Stress Testing: Simulated traffic stress and active DDoS vectors to capture power and throughput profiles under adverse network conditions.

Key Findings

The research successfully mapped the specific trade-offs between zero-trust security enforcement and server power consumption, providing actionable data for telecom operators balancing security with OPEX.

Thesis Document:
Code Repository:

High-Performance Go Movie Recommender Engine

Thu, 15 Jun 2023 00:00:00 +0000

A concurrent big-data recommendation engine built in Go, designed to process large user-item interaction datasets with high throughput and a minimal memory footprint.

Engineering Challenge

Calculating similarity matrices across massive datasets traditionally creates severe computation bottlenecks. This project was engineered to solve that challenge by leveraging Go’s native concurrency primitives (goroutines and channels) to evaluate user preferences across multiple dimensional axes simultaneously.

Algorithmic Capabilities

The engine is capable of dynamically selecting and executing multiple mathematical models to determine relevance:

Similarity Metrics Implemented:
- Jaccard Index
- Dice Coefficient
- Cosine Similarity
- Pearson Correlation

Filtering Approaches

To provide highly personalized outputs, the engine utilizes a multi-tiered filtering approach:

User-User Collaborative Filtering: Identifying peer grouping similarities.
Item-Item Collaborative Filtering: Mapping relational boundaries between media.
Tag & Title-based Content Filtering: Deep metadata analysis.
Hybrid Recommendation Strategy: Weighting the above outputs to deliver a final, normalized recommendation score.

Repository: