A good reference project for learning how to work with Kubernetes (K8s) should cover various aspects of K8s, including deployments, services, networking, storage, and scaling. One such project is the **"Guestbook"** application, a simple multi-tier web application that demonstrates many core concepts of Kubernetes.

### Guestbook Application Overview

The Guestbook application consists of the following components:

1. **Frontend**: A PHP-based web interface that users can interact with.
2. **Backend**: A Redis master and a set of Redis replicas that store the guestbook entries.

### Step-by-Step Guide to Deploy the Guestbook Application

#### Step 1: Clone the Kubernetes Examples Repository

First, clone the Kubernetes examples repository to get the configuration files for the Guestbook application.

```sh
git clone https://github.com/kubernetes/examples.git
cd examples/guestbook
```

#### Step 2: Deploy the Redis Master

1. Create a Redis Master Deployment:

   ```yaml
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-master
     labels:
       app: redis
       tier: backend
       role: master
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: redis
         role: master
         tier: backend
     template:
       metadata:
         labels:
           app: redis
           role: master
           tier: backend
       spec:
         containers:
         - name: master
           image: redis
           ports:
           - containerPort: 6379
   ```

2. Create a Redis Master Service:

   ```yaml
   apiVersion: v1
   kind: Service
   metadata:
     name: redis-master
     labels:
       app: redis
       tier: backend
       role: master
   spec:
     ports:
     - port: 6379
     selector:
       app: redis
       role: master
       tier: backend
   ```

Apply these configurations:

```sh
kubectl apply -f redis-master-deployment.yaml
kubectl apply -f redis-master-service.yaml
```

#### Step 3: Deploy the Redis Replicas

1. Create a Redis Replica Deployment:

   ```yaml
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-slave
     labels:
       app: redis
       tier: backend
       role: slave
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: redis
         role: slave
         tier: backend
     template:
       metadata:
         labels:
           app: redis
           role: slave
           tier: backend
       spec:
         containers:
         - name: slave
           image: gcr.io/google_samples/gb-redisslave:v3
           ports:
           - containerPort: 6379
           env:
           - name: GET_HOSTS_FROM
             value: dns
   ```

2. Create a Redis Replica Service:

   ```yaml
   apiVersion: v1
   kind: Service
   metadata:
     name: redis-slave
     labels:
       app: redis
       tier: backend
       role: slave
   spec:
     ports:
     - port: 6379
     selector:
       app: redis
       role: slave
       tier: backend
   ```

Apply these configurations:

```sh
kubectl apply -f redis-slave-deployment.yaml
kubectl apply -f redis-slave-service.yaml
```

#### Step 4: Deploy the Guestbook Frontend

1. Create a Frontend Deployment:

   ```yaml
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: guestbook
     labels:
       app: guestbook
       tier: frontend
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: guestbook
         tier: frontend
     template:
       metadata:
         labels:
           app: guestbook
           tier: frontend
       spec:
         containers:
         - name: php-redis
           image: gcr.io/google-samples/gb-frontend:v4
           ports:
           - containerPort: 80
   ```

2. Create a Frontend Service:

   ```yaml
   apiVersion: v1
   kind: Service
   metadata:
     name: frontend
     labels:
       app: guestbook
       tier: frontend
   spec:
     type: LoadBalancer
     ports:
     - port: 80
     selector:
       app: guestbook
       tier: frontend
   ```

Apply these configurations:

```sh
kubectl apply -f frontend-deployment.yaml
kubectl apply -f frontend-service.yaml
```

#### Step 5: Verify and Access the Application

1. Check the status of all deployments and services:

   ```sh
   kubectl get deployments
   kubectl get services
   ```

2. Access the frontend service using the Minikube service URL:

   ```sh
   minikube service frontend
   ```

This will open the Guestbook application in your web browser.

### Additional Learning Resources

1. **Kubernetes Documentation**: The official [Kubernetes documentation](https://kubernetes.io/docs/home/) is a comprehensive resource.
2. **Katacoda Scenarios**: Interactive Kubernetes tutorials on [Katacoda](https://www.katacoda.com/courses/kubernetes).
3. **Kubernetes Up and Running**: A great book by Kelsey Hightower, Brendan Burns, and Joe Beda.
4. **Kubernetes the Hard Way**: A tutorial by Kelsey Hightower on [GitHub](https://github.com/kelseyhightower/kubernetes-the-hard-way).

This project will give you hands-on experience with deployments, services, scaling, and more, making it an excellent reference for learning Kubernetes.

---

Certainly! Let's deploy a more useful sample application—a simple web application that uses Nginx as a web server and serves a static HTML page. This example will cover the creation of a deployment, a service, and accessing the application.

### Step 1: Create a Deployment YAML File

1. Create a file named `nginx-deployment.yaml` with the following content:

   ```yaml
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: nginx-deployment
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: nginx
     template:
       metadata:
         labels:
           app: nginx
       spec:
         containers:
         - name: nginx
           image: nginx:1.21.6
           ports:
           - containerPort: 80
           volumeMounts:
           - name: html
             mountPath: /usr/share/nginx/html
         volumes:
         - name: html
           configMap:
             name: html-configmap
   ```

### Step 2: Create a ConfigMap for the HTML Page

2. Create a file named `html-configmap.yaml` with the following content:

   ```yaml
   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: html-configmap
   data:
     index.html: |
       <!DOCTYPE html>
       <html>
       <head>
           <title>Welcome to Nginx</title>
       </head>
       <body>
           <h1>Welcome to your Nginx application!</h1>
           <p>Deployed with Minikube on Kubernetes.</p>
       </body>
       </html>
   ```

### Step 3: Create a Service YAML File

3. Create a file named `nginx-service.yaml` with the following content:

   ```yaml
   apiVersion: v1
   kind: Service
   metadata:
     name: nginx-service
   spec:
     type: NodePort
     selector:
       app: nginx
     ports:
     - protocol: TCP
       port: 80
       targetPort: 80
       nodePort: 30007
   ```

### Step 4: Deploy the Application

4. Apply the ConfigMap:

   ```sh
   kubectl apply -f html-configmap.yaml
   ```

5. Apply the Deployment:

   ```sh
   kubectl apply -f nginx-deployment.yaml
   ```

6. Apply the Service:

   ```sh
   kubectl apply -f nginx-service.yaml
   ```

### Step 5: Access the Application

1. Check the status of the pods to ensure they are running:

   ```sh
   kubectl get pods
   ```

2. Get the URL for the Nginx service:

   ```sh
   minikube service nginx-service --url
   ```

3. Open the URL in your web browser. You should see the static HTML page served by Nginx.

### Step 6: Clean Up

1. To delete the resources, you can run:

   ```sh
   kubectl delete -f nginx-service.yaml
   kubectl delete -f nginx-deployment.yaml
   kubectl delete -f html-configmap.yaml
   ```

This setup will provide you with a more useful and practical application deployment scenario, giving you a better understanding of how to work with Kubernetes deployments, services, and ConfigMaps.

---

Here's a step-by-step guide to set up Minikube on your Debian 12 system for a complete Kubernetes learning lab:

### Prerequisites

1. **System Requirements**: 
   - 2 CPUs or more
   - 2GB of free memory
   - 20GB of free disk space
   - Internet connection

2. **Software Requirements**:
   - Docker
   - Kubectl
   - Minikube

### Step 1: Install Docker

1. **Update your package list:**

   ```sh
   sudo apt-get update
   ```

2. **Install required packages:**

   ```sh
   sudo apt-get install -y ca-certificates curl gnupg lsb-release
   ```

3. **Add Docker’s official GPG key:**

   ```sh
   sudo mkdir -p /etc/apt/keyrings
   curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
   ```

4. **Set up the Docker repository:**

   ```sh
   echo \
   "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
   $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
   ```

5. **Install Docker Engine:**

   ```sh
   sudo apt-get update
   sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
   ```

6. **Start and enable Docker:**

   ```sh
   sudo systemctl start docker
   sudo systemctl enable docker
   ```

7. **Verify Docker installation:**

   ```sh
   sudo docker run hello-world
   ```

### Step 2: Install Kubectl

1. **Download the latest release:**

   ```sh
   curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
   ```

2. **Make the kubectl binary executable:**

   ```sh
   chmod +x kubectl
   ```

3. **Move the binary to your PATH:**

   ```sh
   sudo mv kubectl /usr/local/bin/
   ```

4. **Verify the installation:**

   ```sh
   kubectl version --client
   ```

### Step 3: Install Minikube

1. **Download the latest Minikube binary:**

   ```sh
   curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
   ```

2. **Install Minikube:**

   ```sh
   sudo install minikube-linux-amd64 /usr/local/bin/minikube
   ```

3. **Verify the installation:**

   ```sh
   minikube version
   ```

### Step 4: Start Minikube

1. **Start Minikube with Docker driver:**

   ```sh
   minikube start --driver=docker
   ```

2. **Verify Minikube status:**

   ```sh
   minikube status
   ```

### Step 5: Basic Minikube Commands

- **Check cluster info:**

  ```sh
  kubectl cluster-info
  ```

- **Deploy a sample application:**

  ```sh
  kubectl create deployment hello-minikube --image=k8s.gcr.io/echoserver:1.4
  kubectl expose deployment hello-minikube --type=NodePort --port=8080
  minikube service hello-minikube --url
  ```

- **Access Minikube Dashboard:**

  ```sh
  minikube dashboard
  ```

### Step 6: Stop and Delete Minikube

- **Stop Minikube:**

  ```sh
  minikube stop
  ```

- **Delete Minikube:**

  ```sh
  minikube delete
  ```

### Additional Resources

- [Kubernetes Documentation](https://kubernetes.io/docs/home/)
- [Minikube Documentation](https://minikube.sigs.k8s.io/docs/)

This setup will provide you with a complete learning lab for Kubernetes using Minikube on your Debian 12 system. Let me know if you need further assistance or have any questions!