Kubernetes 101: An Introduction for Beginners

Amaresh Pelleti

What is Kubernetes?

Kubernetes (often abbreviated as K8s) is an open-source platform designed to automate deploying, scaling, and operating application containers. Initially developed by Google, Kubernetes is now maintained by the Cloud Native Computing Foundation (CNCF).

Why Use Kubernetes?

Kubernetes helps manage containerized applications in a clustered environment. Here are some key benefits:

  1. Automated Deployment and Scaling: Kubernetes can automatically deploy your application and scale it up or down based on demand.
  2. High Availability: Ensures your application is always running and handles failures gracefully.
  3. Resource Optimization: Efficiently uses the underlying hardware to maximize resource utilization.

Key Concepts and Components

To understand Kubernetes, you need to know about its core components and concepts:

1. Cluster

A set of nodes (machines) where Kubernetes manages the application. A cluster consists of:

  • Master Node: Manages the cluster, schedules workloads, and handles the overall state.
  • Worker Nodes: Run the application workloads.

2. Pod

The smallest deployable unit in Kubernetes. A Pod can contain one or more containers that share the same network namespace and storage.

3. Deployment

Defines the desired state for your application, such as the number of replicas. Kubernetes will manage the creation and scaling of Pods based on this specification.

4. Service

A stable endpoint to access a set of Pods. Services abstract away the underlying Pod details and provide a consistent network interface.

5. ConfigMap and Secret

Used to manage configuration data and sensitive information, such as passwords and API keys, separately from the application code.

6. Ingress

Manages external access to services, typically HTTP. Ingress can provide load balancing, SSL termination, and name-based virtual hosting.

Getting Started with Kubernetes

Prerequisites

  • Basic understanding of containers (e.g., Docker).
  • A Kubernetes cluster. You can use local options like Minikube or kind, or cloud-based solutions like Google Kubernetes Engine (GKE), Amazon EKS, or Azure AKS.

Step-by-Step Example: Deploying a Simple Web Application

1. Install Kubernetes and kubectl

First, install Kubernetes and kubectl, the command-line tool for interacting with your cluster.

For Minikube:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube
minikube start

For kubectl:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/

2. Create a Deployment

Create a file named deployment.yaml:

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

Apply the Deployment:

kubectl apply -f deployment.yaml

3. Expose the Deployment as a Service

Create a file named service.yaml:

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

Apply the Service:

kubectl apply -f service.yaml

4. Access the Application

For Minikube, run the following command to get the URL of the application:

minikube service my-app-service

For cloud-based clusters, Kubernetes will provide an external IP address. You can find it by running:

kubectl get services

Conclusion

Kubernetes is a powerful tool for managing containerized applications. This guide covers the basic concepts and provides a simple example to get you started. As you dive deeper into Kubernetes, you’ll discover more advanced features that can help you manage complex applications at scale.

Happy Kubernetes-ing!