medusa/the_information_nexus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
698a6806c5c858adf2abbd2b6ed5743620e60ea2
the_information_nexus/tech_docs/minikube_setup_debian.md

13 KiB
Raw Blame History

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.

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

Step 2: Deploy the Redis Master

  1. Create a Redis Master Deployment:

    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:

    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:

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:

    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:

    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:

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:

    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:

    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:

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:

    kubectl get deployments
kubectl get services

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

    minikube service frontend

This will open the Guestbook application in your web browser.

Additional Learning Resources

  1. Kubernetes Documentation: The official Kubernetes documentation is a comprehensive resource.
  2. Katacoda Scenarios: Interactive Kubernetes tutorials on Katacoda.
  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.

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:

    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

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

    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

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

    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

  1. Apply the ConfigMap:

    kubectl apply -f html-configmap.yaml

  2. Apply the Deployment:

    kubectl apply -f nginx-deployment.yaml

  3. Apply the Service:

    kubectl apply -f nginx-service.yaml

Step 5: Access the Application

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

    kubectl get pods

  2. Get the URL for the Nginx service:

    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:

    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:

    sudo apt-get update

  2. Install required packages:

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

  3. Add Docker’s official GPG key:

    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:

    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:

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

  6. Start and enable Docker:

    sudo systemctl start docker
sudo systemctl enable docker

  7. Verify Docker installation:

    sudo docker run hello-world

Step 2: Install Kubectl

  1. Download the latest release:

    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:

    chmod +x kubectl

  3. Move the binary to your PATH:

    sudo mv kubectl /usr/local/bin/

  4. Verify the installation:

    kubectl version --client

Step 3: Install Minikube

  1. Download the latest Minikube binary:

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

  2. Install Minikube:

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

  3. Verify the installation:

    minikube version

Step 4: Start Minikube

  1. Start Minikube with Docker driver:

    minikube start --driver=docker

  2. Verify Minikube status:

    minikube status

Step 5: Basic Minikube Commands

  • Check cluster info:

    kubectl cluster-info

  • Deploy a sample application:

    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:

    minikube dashboard

Step 6: Stop and Delete Minikube

  • Stop Minikube:

    minikube stop

  • Delete Minikube:

    minikube delete

Additional Resources

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!