How to create basic Kubernetes deployments

Introduction

This comprehensive tutorial provides developers and system administrators with a practical guide to creating basic Kubernetes deployments. By exploring fundamental deployment concepts and configuration techniques, readers will gain essential skills for managing containerized applications efficiently in distributed computing environments.

Kubernetes Basics

What is Kubernetes?

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. Originally developed by Google, it has become the standard for container management in modern cloud-native environments.

Key Concepts

Cluster Architecture

Core Components

Installation on Ubuntu 22.04

Prerequisites

## Update system packages
sudo apt update
sudo apt upgrade -y

## Install required dependencies
sudo apt install -y curl apt-transport-https

## Add Kubernetes repository
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Install Kubernetes Components

## Install kubelet, kubeadm, and kubectl
sudo apt update
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

Basic Workflow

1. Container Packaging
2. Kubernetes Deployment
3. Scaling and Management
4. Monitoring and Maintenance

Why Use Kubernetes?

• Automatic scaling
• Self-healing capabilities
• Declarative configuration
• Efficient resource utilization

Getting Started with LabEx

For hands-on learning and practical experience with Kubernetes, LabEx provides interactive environments and guided tutorials to help you master container orchestration skills.

Deployment Fundamentals

Understanding Kubernetes Deployments

What is a Deployment?

A Kubernetes Deployment provides declarative updates for Pods and ReplicaSets. It allows you to describe the desired state of your application, and the Deployment controller changes the actual state to the desired state.

Key Deployment Characteristics

Creating a Basic Deployment

Sample Deployment 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:latest
        ports:
        - containerPort: 80

Deployment Commands

## Create deployment
kubectl apply -f nginx-deployment.yaml

## Check deployment status
kubectl get deployments

## View deployment details
kubectl describe deployment nginx-deployment

## Scale deployment
kubectl scale deployment nginx-deployment --replicas=5

Deployment Strategies

Update Strategies

Rolling Update Configuration

spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 25%
      maxSurge: 25%

Advanced Deployment Techniques

Health Checks and Probes

livenessProbe:
  httpGet:
    path: /
    port: 80
  initialDelaySeconds: 10
  periodSeconds: 5

readinessProbe:
  httpGet:
    path: /
    port: 80
  initialDelaySeconds: 5
  periodSeconds: 3

Best Practices

1. Use declarative configuration files
2. Implement proper resource limits
3. Use labels for organization
4. Configure health checks
5. Implement monitoring

LabEx Recommendation

LabEx offers comprehensive Kubernetes deployment labs that provide hands-on experience with real-world deployment scenarios and best practices.

Practical Configuration

Configuration Management in Kubernetes

Configuration Methods

Configuration Types

ConfigMap Configuration

Creating a ConfigMap

## Create ConfigMap from literal values
kubectl create configmap app-config \
    --from-literal=DATABASE_URL=mysql://localhost \
    --from-literal=LOG_LEVEL=debug

YAML Configuration

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  DATABASE_URL: mysql://localhost
  LOG_LEVEL: debug

Secret Management

Creating Secrets

## Create secret from literal values
kubectl create secret generic db-credentials \
    --from-literal=username=admin \
    --from-literal=password=secure-password

Secret YAML Configuration

apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
stringData:
  username: admin
  password: secure-password

Deployment with Configurations

Sample Deployment Configuration

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: web-container
        image: myapp:latest
        env:
        - name: DATABASE_URL
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: DATABASE_URL
        - name: DB_USERNAME
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: username

Advanced Configuration Techniques

Environment Variable Injection

Volume-Based Configuration

volumes:
- name: config-volume
  configMap:
    name: app-config
containers:
- name: app
  volumeMounts:
  - name: config-volume
    mountPath: /etc/config

Best Practices

1. Never commit secrets to version control
2. Use least privilege principle
3. Rotate credentials regularly
4. Use external secret management systems
5. Encrypt sensitive data

Validation and Debugging

## Verify ConfigMap
kubectl get configmaps

## Describe ConfigMap
kubectl describe configmap app-config

## Check secret
kubectl get secrets

## Verify deployment configuration
kubectl describe deployment web-app

LabEx Learning Path

LabEx provides interactive labs to master Kubernetes configuration techniques, offering hands-on experience with real-world scenarios and best practices.

Summary

Understanding Kubernetes deployments is crucial for modern cloud-native application development. This tutorial has equipped you with foundational knowledge about creating, configuring, and managing deployments, enabling you to leverage Kubernetes' powerful orchestration capabilities for scalable and resilient software infrastructure.