Forem: silvercoder007

Deploying a Preact App with K3s Locally: A Beginner's Guide

silvercoder007 — Wed, 05 Nov 2025 07:51:18 +0000

Welcome to this comprehensive guide on deploying a Preact app using K3s locally! If you're new to web development, containers, or Kubernetes, don't worry—we'll start from the very basics and build up step by step. By the end, you'll have a fully functional Preact application running in a local Kubernetes cluster. This hands-on tutorial assumes no prior knowledge, so we'll explain every concept along the way.

What You'll Learn

The basics of Preact (a lightweight React alternative)
Introduction to containers and Docker
Kubernetes fundamentals and why K3s is great for local development
How to containerize and deploy an app locally

Prerequisites

Before we start, you'll need:

A computer with Linux, macOS, or Windows (with WSL2 for Windows users)
Basic command-line knowledge (we'll guide you through it)
About 10-15 minutes of your time

No coding experience required!

What is Preact?

Preact is a fast, lightweight JavaScript library for building user interfaces. It's like React but smaller and more efficient. Think of it as a toolkit to create interactive web apps with components, state, and events.

Here's a simple ASCII representation of a Preact component:

+-------------------+
|   Preact App      |
+-------------------+
|                   |
|  <App />          |
|    ├── <Header /> |
|    └── <Content />|
|                   |
+-------------------+

Why Preact?

Small size: Only ~3KB gzipped (vs. React's ~40KB)
Fast: Better performance for simple apps
Compatible: Works with most React code and tools

What is K3s?

K3s is a lightweight version of Kubernetes, the most popular container orchestration platform. Kubernetes manages containers (like tiny virtual machines for your app) at scale.

Key Concepts

Container: A package with your app's code, dependencies, and runtime (like a portable box)
Pod: The smallest unit in Kubernetes; usually one container
Service: Exposes your app to the network
Deployment: Manages how many copies of your app run

Visualizing Kubernetes components:

[Deployment]
     |
     v
  [Pod]  <-- Contains -->
+------------+
| Container  |
| (Your App) |
+------------+
     ^
     |
 [Service] <-- Exposes to network -->

K3s is perfect for local development because it's easy to install and uses fewer resources than full Kubernetes.

Step 1: Setting Up Your Environment

Install Node.js and npm

Preact apps need Node.js. Download from nodejs.org and install it.

Verify with:

node --version
npm --version

Install Docker

Docker creates containers. Download from docker.com and install.

Verify:

docker --version

Step 2: Create a Preact App

Initialize the Project

Create a new directory and set up Preact:

mkdir preact-k3s-app
cd preact-k3s-app
npm create preact@latest . -- --yes

This creates a basic Preact app with:

src/: Your code
package.json: Project config
Build scripts

Your project structure will look like this:

preact-k3s-app/
├── src/
│   ├── index.js
│   └── style.css
├── package.json
└── README.md

Add Some Content

Edit src/index.js to add a simple component:

import { render } from 'preact';
import './style.css';

function App() {
  return (
    <div>
      <h1>Hello from Preact on K3s!</h1>
      <p>This app is running in a containerized Kubernetes cluster.</p>
    </div>
  );
}

render(<App />, document.getElementById('app'));

Build the App

npm run build

This creates a dist/ folder with production-ready files.

After building, your structure becomes:

preact-k3s-app/
├── src/
│   ├── index.js
│   └── style.css
├── dist/
│   ├── index.html
│   ├── bundle.js
│   └── style.css
├── package.json
├── README.md
└── Dockerfile (you'll add this next)

Step 3: Containerize with Docker

What is Containerization?

Containerization packages your app with everything it needs to run, ensuring it works the same everywhere.

Think of a container as a shipping box:

+-----------------------------+
|        Container            |
+-----------------------------+
|                             |
|  [Your App Code]            |
|  [Dependencies]             |
|  [Runtime (nginx)]          |
|                             |
+-----------------------------+
    |
    v
Docker Engine (runs anywhere)

Create a Dockerfile

In your project root, create Dockerfile:

# Use a lightweight web server
FROM nginx:alpine

# Copy built files to nginx
COPY dist/ /usr/share/nginx/html/

# Expose port 80
EXPOSE 80

# Start nginx
CMD ["nginx", "-g", "daemon off;"]

This uses nginx (a web server) to serve your Preact app.

Build the Docker Image

docker build -t preact-app:latest .

Test Locally

Run the container:

docker run -p 8080:80 preact-app:latest

Visit http://localhost:8080 in your browser. You should see your app!

Stop with Ctrl+C.

Step 4: Install K3s

What is K3s Installation?

K3s installs a full Kubernetes cluster with one command.

Install K3s

curl -sfL https://get.k3s.io | sh -

This downloads and runs K3s as a service.

Verify Installation

Check if it's running:

kubectl get nodes

You should see one node named after your machine.

kubectl is the Kubernetes command-line tool (installed with K3s).

Step 5: Deploy to K3s

Create Kubernetes Manifests

Kubernetes uses YAML files to define deployments.

Create deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: preact-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: preact-app
  template:
    metadata:
      labels:
        app: preact-app
    spec:
      containers:
      - name: preact-app
        image: preact-app:latest
        ports:
        - containerPort: 80

---
apiVersion: v1
kind: Service
metadata:
  name: preact-app-service
spec:
  selector:
    app: preact-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer

This creates:

A deployment with 1 replica of your container
A service to expose it

Load the Image into K3s

Since we're local, load the Docker image:

docker save preact-app:latest | sudo k3s ctr images import -

Deploy

kubectl apply -f deployment.yaml

Check status:

kubectl get pods
kubectl get services

Access Your App

For local LoadBalancer, use port forwarding:

kubectl port-forward service/preact-app-service 8080:80

Visit http://localhost:8080. Your Preact app is now running on Kubernetes!

Here's the overall architecture:

[Your Machine]
     |
     v
  [K3s Cluster]
     |
     +-------------------+
     |   Deployment      |
     |   (Manages Pods)  |
     +-------------------+
             |
             v
     +-------------------+
     |       Pod         |
     +-------------------+
             |
             v
     +-------------------+
     |   Container       |
     | (Preact App +    |
     |     nginx)       |
     +-------------------+
             ^
             |
     +-------------------+
     |     Service       |
     | (LoadBalancer)    |
     +-------------------+
             ^
             |
     [Port Forwarding]
             ^
             |
     [Browser: localhost:8080]

Troubleshooting

Pod not starting? Check logs: sudo kubectl logs <pod-name>
Image not found? Ensure you loaded it correctly.
Port issues? Make sure 8080 is free.

Conclusion

Congratulations! You've deployed a Preact app with K3s locally. You learned:

Building web apps with Preact
Containerizing with Docker
Kubernetes basics with K3s
Local deployment workflow

Next steps: Try scaling replicas, adding a database, or deploying to the cloud. Happy coding!

Mastering Trees in Rust: From Novice to Ninja

silvercoder007 — Wed, 05 Nov 2025 07:27:18 +0000

Welcome to Mastering Trees in Rust! If you've ever wondered how to organize data hierarchically—like a family tree or a company's org chart—this guide is for you. We'll start from absolute basics, assuming you know nothing about trees, and build up to advanced self-balancing trees like AVL and Red-Black. Along the way, we'll code everything in Rust, with plenty of examples, ASCII diagrams, and tests to ensure our code works flawlessly.

Trees are powerful data structures for storing and retrieving data efficiently. By the end, you'll implement your own tree library and understand when to use each type.

What Are Trees? The Basics

Imagine a tree in nature: it has a root, branches, and leaves. In computer science, a tree is a hierarchical data structure where each element (called a node) has a parent (except the top one) and zero or more children.

Key Terminology

Root: The top node with no parent.
Node: Each element in the tree, containing data and links to children.
Leaf: A node with no children.
Internal Node: A node with at least one child.
Parent/Child: Relationships between nodes.
Subtree: A node and all its descendants.
Depth: Number of ancestors (root is depth 0).
Height: Maximum depth in the tree.
Level: Nodes at the same depth.

Here's a simple ASCII diagram of a tree:

       Root (A)
      /     \
    B         C
   / \       / \
  D   E     F   G

Root: A
Leaves: D, E, F, G
Internal nodes: A, B, C
Height: 2 (from A to D/E/F/G)

Trees are non-linear, unlike arrays or linked lists, making them great for hierarchical data.

Why Use Trees in Rust?

Rust's ownership and borrowing make trees safe and efficient. No null pointer dereferences or memory leaks! We'll use structs, enums, and smart pointers like Rc (Reference Counting) for shared ownership.

Setting Up: Basic Tree Node in Rust

Let's start with a simple binary tree node. A binary tree has at most two children per node.

use std::rc::Rc;
use std::cell::RefCell;

// A basic tree node
#[derive(Debug)]
struct TreeNode<T> {
    value: T,
    left: Option<Rc<RefCell<TreeNode<T>>>>,
    right: Option<Rc<RefCell<TreeNode<T>>>>,
}

impl<T> TreeNode<T> {
    fn new(value: T) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(TreeNode {
            value,
            left: None,
            right: None,
        }))
    }
}

Rc<RefCell<TreeNode<T>>>: Rc allows shared ownership, RefCell enables mutable borrowing.
Option: Handles absence of children safely.

Example: Create a simple tree.

fn main() {
    let root = TreeNode::new("A");
    let left = TreeNode::new("B");
    let right = TreeNode::new("C");

    root.borrow_mut().left = Some(left);
    root.borrow_mut().right = Some(right);

    println!("{:?}", root); // Prints the tree structure
}

Test it:

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_basic_node() {
        let node = TreeNode::new(42);
        assert_eq!(node.borrow().value, 42);
        assert!(node.borrow().left.is_none());
    }
}

Run with cargo test.

Binary Search Trees (BST): Ordered Trees

A BST is a binary tree where left children < parent < right children. This enables fast searches (O(log n) average case).

BST Node and Operations

#[derive(Debug)]
struct BST<T: Ord> {
    root: Option<Rc<RefCell<TreeNode<T>>>>,
}

impl<T: Ord> BST<T> {
    fn new() -> Self {
        BST { root: None }
    }

    fn insert(&mut self, value: T) {
        let new_node = TreeNode::new(value);
        if let Some(root) = &self.root {
            Self::insert_node(root.clone(), new_node);
        } else {
            self.root = Some(new_node);
        }
    }

    fn insert_node(node: Rc<RefCell<TreeNode<T>>>, new_node: Rc<RefCell<TreeNode<T>>>) {
        let mut node_borrow = node.borrow_mut();
        let new_val = new_node.borrow().value.clone();
        if new_val < node_borrow.value {
            if let Some(left) = &node_borrow.left {
                Self::insert_node(left.clone(), new_node);
            } else {
                node_borrow.left = Some(new_node);
            }
        } else {
            if let Some(right) = &node_borrow.right {
                Self::insert_node(right.clone(), new_node);
            } else {
                node_borrow.right = Some(new_node);
            }
        }
    }

    fn search(&self, value: &T) -> bool {
        Self::search_node(&self.root, value)
    }

    fn search_node(node: &Option<Rc<RefCell<TreeNode<T>>>>, value: &T) -> bool {
        if let Some(n) = node {
            let n_borrow = n.borrow();
            if *value == n_borrow.value {
                true
            } else if *value < n_borrow.value {
                Self::search_node(&n_borrow.left, value)
            } else {
                Self::search_node(&n_borrow.right, value)
            }
        } else {
            false
        }
    }
}

Example: Build and search a BST.

fn main() {
    let mut bst = BST::new();
    bst.insert(10);
    bst.insert(5);
    bst.insert(15);
    bst.insert(3);

    println!("Found 5: {}", bst.search(&5)); // true
    println!("Found 20: {}", bst.search(&20)); // false
}

ASCII Diagram of BST:

Tests:

#[test]
fn test_bst_insert_and_search() {
    let mut bst = BST::new();
    bst.insert(10);
    bst.insert(5);
    assert!(bst.search(&10));
    assert!(bst.search(&5));
    assert!(!bst.search(&1));
}

Tree Traversals: Visiting Every Node

Traversals visit all nodes in a specific order.

In-Order Traversal (Left, Root, Right)

impl<T: Ord + Clone> BST<T> {
    fn in_order(&self) -> Vec<T> {
        let mut result = Vec::new();
        Self::in_order_node(&self.root, &mut result);
        result
    }

    fn in_order_node(node: &Option<Rc<RefCell<TreeNode<T>>>>, result: &mut Vec<T>) {
        if let Some(n) = node {
            let n_borrow = n.borrow();
            Self::in_order_node(&n_borrow.left, result);
            result.push(n_borrow.value.clone());
            Self::in_order_node(&n_borrow.right, result);
        }
    }
}

Example: In-order on our BST: [3, 5, 10, 15]

Pre-Order (Root, Left, Right) and Post-Order (Left, Right, Root)

Add similar methods. Pre-order: [10, 5, 3, 15], Post-order: [3, 5, 15, 10]

Advanced: Min, Max, and Removal

impl<T: Ord + Clone> BST<T> {
    fn min(&self) -> Option<T> {
        Self::min_node(&self.root)
    }

    fn min_node(node: &Option<Rc<RefCell<TreeNode<T>>>>) -> Option<T> {
        if let Some(n) = node {
            let n_borrow = n.borrow();
            if n_borrow.left.is_some() {
                Self::min_node(&n_borrow.left)
            } else {
                Some(n_borrow.value.clone())
            }
        } else {
            None
        }
    }

    fn remove(&mut self, value: &T) {
        self.root = Self::remove_node(self.root.take(), value);
    }

    fn remove_node(node: Option<Rc<RefCell<TreeNode<T>>>>, value: &T) -> Option<Rc<RefCell<TreeNode<T>>>> {
        if let Some(n) = node {
            let mut n_borrow = n.borrow_mut();
            if *value < n_borrow.value {
                n_borrow.left = Self::remove_node(n_borrow.left.take(), value);
                Some(n)
            } else if *value > n_borrow.value {
                n_borrow.right = Self::remove_node(n_borrow.right.take(), value);
                Some(n)
            } else {
                // Node to remove
                if n_borrow.left.is_none() {
                    return n_borrow.right.take();
                } else if n_borrow.right.is_none() {
                    return n_borrow.left.take();
                } else {
                    // Two children: replace with min of right subtree
                    let min_val = Self::min_node(&n_borrow.right).unwrap();
                    n_borrow.value = min_val.clone();
                    n_borrow.right = Self::remove_node(n_borrow.right.take(), &min_val);
                    Some(n)
                }
            }
        } else {
            None
        }
    }
}

Tests:

#[test]
fn test_bst_remove() {
    let mut bst = BST::new();
    bst.insert(10);
    bst.insert(5);
    bst.remove(&5);
    assert!(!bst.search(&5));
    assert!(bst.search(&10));
}

Self-Balancing Trees: AVL Trees

BSTs can become skewed (like a linked list), ruining O(log n) performance. AVL trees keep height difference ≤1.

AVL Node with Height

#[derive(Debug)]
struct AVLNode<T> {
    value: T,
    height: i32,
    left: Option<Rc<RefCell<AVLNode<T>>>>,
    right: Option<Rc<RefCell<AVLNode<T>>>>,
}

impl<T: Ord + Clone> AVLNode<T> {
    fn new(value: T) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(AVLNode {
            value,
            height: 1,
            left: None,
            right: None,
        }))
    }

    fn height(node: &Option<Rc<RefCell<AVLNode<T>>>>) -> i32 {
        node.as_ref().map_or(0, |n| n.borrow().height)
    }

    fn update_height(node: &Rc<RefCell<AVLNode<T>>>) {
        let left_h = Self::height(&node.borrow().left);
        let right_h = Self::height(&node.borrow().right);
        node.borrow_mut().height = 1 + left_h.max(right_h);
    }

    fn balance_factor(node: &Rc<RefCell<AVLNode<T>>>) -> i32 {
        Self::height(&node.borrow().right) - Self::height(&node.borrow().left)
    }

    // Rotations: LL, RR, LR, RL (implement similar to original)
    fn rotate_right(y: Rc<RefCell<AVLNode<T>>>) -> Rc<RefCell<AVLNode<T>>> {
        let x = y.borrow_mut().left.take().unwrap();
        let t2 = x.borrow_mut().right.take();
        y.borrow_mut().left = t2;
        x.borrow_mut().right = Some(y.clone());
        Self::update_height(&y);
        Self::update_height(&x);
        x
    }

    // Add insert with balancing...
}

For full AVL, implement insert with rotations. (Space constraints; expand in real code.)

Red-Black Trees: Another Balancer

Red-Black trees use colors to ensure balance. Rules: Root black, no two reds adjacent, equal black nodes per path.

Similar to AVL but with color-based balancing.

Conclusion and Testing

Trees are versatile! Use BST for ordered data, AVL/Red-Black for balance. Always test:

#[test]
fn comprehensive_test() {
    let mut bst = BST::new();
    for i in 0..10 {
        bst.insert(i);
    }
    assert_eq!(bst.in_order(), (0..10).collect::<Vec<_>>());
    bst.remove(&5);
    assert!(!bst.search(&5));
}

Run cargo test to verify. Happy coding!