What is Kubernetes? 🧐

#kubernetes #docker #devops #containers

Certainly! Here's a detailed explanation of Kubernetes, including key points, commands, and code examples:

1. What is Kubernetes?

Kubernetes is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications.

Key Concepts:
a. Pod: The smallest unit of deployment in Kubernetes. It represents a single instance of a running process.
b. Node: A physical or virtual machine in the Kubernetes cluster where containers are deployed.
c. ReplicaSet: Ensures a specific number of pod replicas are running at all times.
d. Deployment: A higher-level abstraction that manages ReplicaSets and provides rolling updates and rollbacks.
e. Service: An abstract way to expose an application running on a set of pods.
f. Namespace: A logical partitioning of the cluster used to separate resources and manage access.
Architecture:
- Master Node: Controls the cluster and manages scheduling, scaling, and overall cluster state.
- Worker Nodes: Run the actual application workloads in the form of pods.
Download and Installation:
- Visit the official Kubernetes website or use a package manager like apt, yum, or Homebrew.
- For example, to install using the package manager on Ubuntu, run the following command:
```
 sudo apt-get update && sudo apt-get install -y kubelet kubeadm kubectl
```
Setting up a Cluster:
- Initialize the cluster on the master node using kubeadm:
```
 sudo kubeadm init
```

Follow the instructions provided to set up the cluster and configure the networking.

Interacting with the Cluster:
- kubectl is the command-line interface to interact with the Kubernetes cluster.
- To check the cluster status, run:
```
 kubectl cluster-info
```

To get information about nodes, pods, services, etc., use various kubectl commands such as:
```
 kubectl get nodes
 kubectl get pods
 kubectl get services
```

Deploying an Application:

Create a deployment YAML file, e.g., app-deployment.yaml, defining the application's specifications.

 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-container
         image: my-app-image:latest
         ports:
         - containerPort: 80

Apply the deployment using kubectl:
```
 kubectl apply -f app-deployment.yaml
```

Exposing the Application:

Create a service YAML file, e.g., app-service.yaml, defining the service's specifications.

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

Apply the service using kubectl:
```
 kubectl apply -f app-service.yaml
```

Scaling the Application:
- Scale the deployment to increase the number of replicas:
```
 kubectl scale deployment my-app --replicas=5
```
Rolling Updates and Rollbacks:
- Update the deployment with a new version of the container

image:

  ```
  kubectl set image deployment/my-app my-app-container=my-app-
  ```

image:v2

- Monitor the rollout status:

  ```
  kubectl rollout status deployment/my-app
  ```

- Rollback to the previous version if needed:

  ```
  kubectl rollout undo deployment/my-app
  ```

This provides a general overview of Kubernetes, its architecture, and some essential commands for deploying and managing applications. Keep in mind that this is just the tip of the iceberg, and Kubernetes offers a wide range of features and capabilities for container orchestration.

Did you benefit from the explanation?