# Kubernetes Learning Lab Setup with Minikube on Debian 12

## Prerequisites
- System Requirements:
  - 2+ CPUs
  - 2GB+ free memory
  - 20GB+ free disk space
  - Internet connection
- Software Requirements:
  - Docker
  - Kubectl
  - Minikube

## Setup Steps

### 1. Install Docker
1. Update package list: `sudo apt-get update`
2. Install required packages
3. Add Docker's GPG key
4. Set up Docker repository
5. Install Docker Engine
6. Start and enable Docker
7. Verify installation

### 2. Install Kubectl
1. Download latest release
2. Make binary executable
3. Move binary to PATH
4. Verify installation

### 3. Install Minikube
1. Download latest Minikube binary
2. Install Minikube
3. Verify installation

### 4. Start Minikube
1. Start Minikube with Docker driver
2. Verify Minikube status

### 5. Basic Minikube Commands
- Check cluster info
- Deploy sample application
- Access Minikube Dashboard

### 6. Stop and Delete Minikube
- Stop Minikube
- Delete Minikube

## Sample Projects

### 1. Guestbook Application
- Components:
  - Frontend: PHP-based web interface
  - Backend: Redis master and replicas
- Deployment steps:
  1. Clone Kubernetes examples repository
  2. Deploy Redis Master (Deployment and Service)
  3. Deploy Redis Replicas (Deployment and Service)
  4. Deploy Guestbook Frontend (Deployment and Service)
  5. Verify and access the application

### 2. Simple Nginx Web Application
- Components:
  - Nginx web server
  - Static HTML page
- Deployment steps:
  1. Create Deployment YAML
  2. Create ConfigMap for HTML content
  3. Create Service YAML
  4. Deploy the application
  5. Access the application
  6. Clean up resources

## Additional Learning Resources
1. Kubernetes Documentation
2. Katacoda Scenarios
3. "Kubernetes Up and Running" book
4. "Kubernetes the Hard Way" tutorial

For detailed instructions and commands, refer to the original document.

---

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!