DEV Community: KOWSALYA R

Kubernetes Pods vs. Nodes: Understanding Differences

KOWSALYA R — Fri, 22 May 2026 09:33:19 +0000

What Is a Pod in Kubernetes?
A group of one or more application containers (such as Docker or rkt), a Pod includes shared storage (volumes), IP address and information about how to run them.

Real-world examples of pods

A web application pod might consist of a front-end container and a back-end container. The front-end container serves static files and handles user interaction, while the back-end container handles database queries and other business logic.
A micro services application might consist of several pods, each of which runs a different micro service. For example, a micro services application might have a pod for the user authentication service, a pod for the product catalog service, and a pod for the order processing service.
A batch processing application might consist of a pod for each batch job. For example, a batch processing application might have a pod for generating daily reports, a pod for processing customer data, and a pod for cleaning up old data.

Kubernetes Pods
When a deployment is created, Kubernetes creates a Pod to host the application instance. A Kubernetes abstraction that represents a group of one or more application containers (such as Docker or rkt), Pods also contain shared resources for those containers - as defined below:

Shared storage, as Volumes
Networking, as a unique cluster IP address
Container image version information, or information on specific ports to use, i.e information about how to run each container

Benefits of using pods

Pods provide a number of benefits, including:

Isolation: Pods provide a way to isolate applications from each other. This can help to prevent problems with one application from affecting other applications.
Portability: Pods can be easily moved from one node to another. This can be helpful for balancing the load across nodes or for moving pods to different environments.
Scalability: Pods can be easily scaled up or down. This can be helpful for dealing with changes in demand.
Manageability: Pods are easy to manage. The Kubernetes API provides a number of operations for managing pods, such as creating, starting, stopping, and deleting pods.

Creating a Pod

To create a pod, we need to create a YAML file that specifies the pod’s configuration. YAML file that creates a pod named frontend-pod:

apiVersion: v1
kind: Pod
metadata:
  name: frontend-pod
spec:
  containers:
  - name: nginx
    image: nginx:1.14.2
    ports:
    - containerPort: 80

This YAML file creates a pod with a single container named nginx. The nginx container uses the nginx:1.14.2 image and exposes port 80.

To create the pod, we can use the following command:

kubectl apply -f pod-demo.yaml

Listing Pods

To list all of the pods in the default namespace, we can use the following command:

kubectl get pods

This will list the name, status, and IP address of each pod.

Getting Pod Details

To get more detailed information about a pod, we can use the following command:

kubectl get pods <pod-name> -o wide

Deleting Pods

To delete a pod, we can use the following command:

kubectl delete pods <pod-name>

The role of the Kubelet

The Kubelet is responsible for ensuring that pods are running on the nodes where they are scheduled. The Kubelet performs the following tasks:

Monitors the pods that are scheduled to run on the node.
Creates and starts containers for the pods.
Provides the containers with the resources they need, such as
CPU, memory, and network access.
Restarts containers that fail.
Reports the status of the pods to the Kubernetes API server.

What Is a Node in Kubernetes?
A worker machine in Kubernetes that may be either a virtual or physical machine depending on the cluster, each Node is managed by the control plane and can have multiple pods. The Kubernetes control plane automatically handles scheduling the pods across the Nodes in the cluster. A Pod always runs on a Node and the control plane’s automatic scheduling takes into account the available resources on each Node.

Every Kubernetes Node runs at least:

Kubelet, a process responsible for communication between the Kubernetes control plane and the Node; it manages the Pods and the containers running on a machine.
A container runtime (like Docker) responsible for pulling the container image from a registry, unpacking the container, and running the application.

🚀DevOps on AWS From Beginner to Advanced (With Examples & Tools)

KOWSALYA R — Fri, 03 Oct 2025 08:29:25 +0000

🌱 What is DevOps?

DevOps combines Development and Operations tools that increases an organizations ability to deliver applications and services at high velocity.
The key ideas are

Automation of builds, tests, and deployments
Continuous Integration / Continuous Deployment (CI/CD)
Monitoring and feedback loops
Infrastructure as Code (IaC)

☁️ Why DevOps on AWS?

AWS offers native DevOps tools and deep integrations with popular open source tools. Benefits include:
✅ Scalable infrastructure ✅ Pay-as-you-go pricing ✅ Security and compliance support ✅ Integration with GitHub, Jenkins, Docker, Kubernetes, etc.

🛠️ AWS DevOps Toolchain (Beginner to Advanced)

Let’s break DevOps down into phases and map them to AWS tools.

DevOps Stage	AWS Services	Open Source / 3rd Party
Plan	AWS CodeCommit, AWS Project Management	Jira, Trello
Develop	AWS Cloud9, CodeCommit	GitHub, GitLab
Build	AWS CodeBuild	Jenkins, GitLab CI
Test	AWS Device Farm, CodeBuild	Selenium, JUnit
Release	AWS CodePipeline	Spinnaker, ArgoCD
Deploy	AWS CodeDeploy, Elastic Beanstalk	Terraform, Helm
Operate	CloudWatch, AWS X-Ray	Prometheus, Grafana
Monitor	CloudWatch, AWS Config, CloudTrail	ELK Stack, Datadog

🚦 Beginner: Start with CI/CD on AWS

Let’s start simple: Build a CI/CD pipeline using AWS CodePipeline.

✅ Use Case:

Deploy a static website hosted on S3 every time you push to a CodeCommit repository.

🧰 Tools:

AWS CodeCommit (Git Repo)
AWS CodePipeline (CI/CD Orchestration)
AWS CodeBuild (Build process)
AWS S3 (Static hosting)

🔧 Steps:

Create a CodeCommit repo and push your static HTML/CSS files.
Create a CodeBuild project that packages your files (if needed).
Create an S3 bucket with static hosting enabled.
Set up CodePipeline :
- Source: CodeCommit
- Build: CodeBuild
- Deploy: S3

Every push to your repo now triggers a new deployment.

⚙️ Intermediate: Infrastructure as Code with CloudFormation / Terraform

Hardcoding resources? Not anymore.

✅ Use Case:

Define an EC2 + RDS + Load Balancer stack as code.

🧰 Tools:

AWS CloudFormation (YAML/JSON templates)
Or use Terraform for multi-cloud compatibility 🧩 Example CloudFormation snippet:

Resources:
  MyEC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      InstanceType: t2.micro
      ImageId: ami-0abcdef1234567890

TIP: Use AWS CDK (Cloud Development Kit) if you prefer Python/TypeScript over YAML.

🚀 Advanced: Containerized DevOps with ECS / EKS + GitOps

Now we go pro. Automate deployments to Kubernetes using GitOps on AWS.

✅ Use Case:
Push code to GitHub → automatically deploy to EKS using ArgoCD.

🧰 Tools:
Amazon EKS (Managed Kubernetes)
ArgoCD (GitOps controller)
AWS CodePipeline or GitHub Actions
AWS ECR (Container Registry)

🔄 Flow:
1.Code pushed to GitHub → triggers CI
2.Build + Push image to ECR
3.GitOps tool (e.g. ArgoCD) detects change in Helm chart repo
4.EKS cluster automatically updates with new deployment
This is enterprise-grade DevOps used by top tech teams.

📈 Monitoring, Logging, and Feedback

Observability is crucial.

Tools:
-AWS CloudWatch Logs: Centralized logs
-CloudWatch Alarms: Automated alerts
-X-Ray: Tracing microservices
-CloudTrail: Audit logs

Combine with Grafana + Prometheus for custom dashboards.

🧭 Learning Roadmap: DevOps on AWS

📍 Beginner:

Git + CodeCommit
CodePipeline + S3 deployments
Cloud9 IDE
IAM basics

📍 Intermediate:

CodeBuild & Docker
CloudFormation / Terraform
EC2, RDS, VPC setup
Basic monitoring with CloudWatch

📍 Advanced:

EKS (Kubernetes)
GitOps with ArgoCD
Custom CodePipeline integrations
Multi-account IaC (Terraform workspaces)
SRE practices: SLIs/SLOs

Essential Linux Commands for Cloud Developers: From Basics to Advanced

KOWSALYA R — Thu, 02 Oct 2025 19:10:04 +0000

1. Introduction

In this post, I'll walk you through must-know Linux commands for both cloud beginners and advanced cloud engineers — with real-world use cases.

2. Basic Linux Commands for Cloud Beginners

These are the foundational commands used in almost every cloud instance:

🔹 Navigation & File Management

cd /var/log — Navigate to log directory
ls -l — List files in long format
pwd — Print working directory
mkdir /data — Create new directory
cp file.txt /data/ — Copy file
mv file.txt /data/ — Move file
rm file.txt — Remove file

🔹 File Viewing & Editing

cat file.txt — View file contents
less file.txt — Scroll through long files
tail -f app.log — Live view of logs
nano config.yaml — Edit file with nano (press I for insert mode)
vi config.yaml — Edit file with vi (more advanced)

🔹 Logs & Troubleshooting

journalctl -xe — View system logs (systemd)
tail -f /var/log/syslog — Live logs from syslog
dmesg — Kernel logs (often useful for hardware issues)
cat /var/log/auth.log — Authentication logs
grep "ERROR" logfile.log — Search for specific log lines

🔹 User and Permissions

adduser username — Create new user
passwd username — Set/change password
usermod -aG sudo user — Add user to sudo group
whoami — Show current user
id — Show user and group IDs
chmod +x script.sh — Make script executable
chown user:group file.txt — Change ownership

🔹 System Info & Monitoring

df -h — Disk space usage
free -m — Memory usage
uptime — System load and uptime
top — Live process monitor
ps aux — List all processes

3. Advanced Linux Commands for Cloud & DevOps

🔸 Networking & Connectivity

ip a — Show network interfaces and IPs
ip r — Show routing table
netstat -tulnp — Show listening ports (use ss as alternative)
curl https://example.com — Make HTTP request (useful for testing)
telnet host 80 — Test connectivity to a port
ping 8.8.8.8 — Check internet connection
traceroute google.com — Track route to a host
dig domain.com — DNS lookup
nslookup domain.com — Another DNS lookup tool
telnet host port — Test if a port is open
nmap host — Scan open ports (if installed)

🔸 Process & Resource Management

htop — Better version of top (if installed)
kill -9 PID — Kill a process forcefully
nice -n 10 cmd — Run a command with a priority

🔸 Package Management (Ubuntu / Debian-based)

sudo apt update && sudo apt upgrade — Update system
apt install htop — Install package
apt remove <pkg> — Remove a package
dpkg -l — List installed packages
which <command> — Show path of a binary (Use yum, dnf, or zypper for RHEL/CentOS/openSUSE systems)

🔸 SSH & Remote Access

ssh user@ip-address — Connect to remote server
scp file.txt user@host:/dir — Copy file over SSH
rsync -avz /src/ /dest/ — Efficient file sync
ssh-keygen — Generate SSH key pair
ssh-copy-id user@host — Add your key to remote authorized_keys

🔸 Disk and Filesystem

lsblk — List block devices
mount /dev/sdb1 /mnt/data — Mount a disk
df -Th — Show disk with filesystem types
du -sh * — Show directory sizes

🔸 Systemd and Services

systemctl status nginx — Check service status
systemctl start nginx — Start a service
systemctl enable nginx — Enable on boot
journalctl -u nginx — View logs for a service

4. Scripting & Automation in the Cloud

🔹 Shell Scripts for Automating Tasks

#!/bin/bash
# update_and_restart.sh
sudo apt update && sudo apt upgrade -y
sudo systemctl restart nginx

Run it:

chmod +x update_and_restart.sh
./update_and_restart.sh

You can mention cron jobs (crontab -e) for scheduled tasks.
crontab -e --Edit cron jobs (automated tasks)
env --Show environment variables
bash script.sh --Run shell script
`
🧵 ## 5. Real-World Use Cases (Optional Section)
Include mini examples like:

🔹Check disk space before deploying to EC2:
ssh ec2-user@ip 'df -h'

🔹Copy logs from a VM to local:
scp ec2-user@ip:/var/log/app.log ./logs/

🔹Restart a service via SSH:
ssh user@host 'sudo systemctl restart nginx'

🧾 ## 6. Conclusion
Whether you're a junior developer learning cloud or a seasoned engineer managing production infrastructure, mastering Linux commands will save you time, stress, and mistakes.

These commands form the backbone of day-to-day tasks in cloud computing — from debugging apps to automating deployments.

💬 What’s your go-to Linux command in the cloud? Share it below!
Thank you Happy Learning! :)