Forem: MUKHIL S

Kubernetes for Absolute Beginners (2026)

MUKHIL S — Wed, 11 Mar 2026 05:27:06 +0000

☸ Kubernetes for Absolute Beginners (2026) – Theory First, Then Hands-On

If Docker made applications portable, Kubernetes makes them scalable and manageable in production.

Many people first hear:

“Deploy it on Kubernetes.”

But without understanding the mental model, Kubernetes looks extremely complex.

This guide follows the same structure:

Theory first (clear concepts)
Then practical commands
Step-by-step beginner workflow

🧠 PART 1 – Understand Kubernetes BEFORE Using Commands

🚨 The Problem Kubernetes Solves

Docker runs containers.

But real systems require more:

Multiple containers
Load balancing
Auto scaling
Health monitoring
Automatic restart
Zero-downtime updates

Imagine running 100 containers manually.

Problems appear quickly:

What if a container crashes?
What if traffic increases?
What if a machine fails?
How do we update without downtime?

Manually managing this becomes impossible.

Kubernetes solves this.

📦 The Core Idea of Kubernetes

Kubernetes is a container orchestration system.

It manages:

Containers
Servers
Networking
Scaling
Updates
Failures

Instead of managing containers manually, you declare:

“I want 5 copies of my app running.”

Kubernetes ensures that state is always maintained.

🧠 Kubernetes Mental Model

A simple way to think about Kubernetes:

System Role	Real-World Analogy
Docker	Packaging machine
Kubernetes	Factory manager
Containers	Workers
Nodes	Factory machines
Pods	Worker groups

Docker creates containers.

Kubernetes manages them at scale.

🧱 Kubernetes Architecture (Simplified)

A Kubernetes system is called a cluster.

A cluster contains two main parts:

1️⃣ Control Plane (Master)

The brain of Kubernetes.

Components:

Component	Purpose
API Server	Entry point for commands
Scheduler	Decides where pods run
Controller Manager	Maintains desired state
etcd	Database storing cluster state

2️⃣ Worker Nodes

Machines that actually run applications.

Each node contains:

Component	Purpose
Kubelet	Communicates with control plane
Container Runtime	Runs containers (Docker/Containerd)
Kube Proxy	Networking

📦 Kubernetes Core Object: Pod

The smallest unit in Kubernetes is a Pod.

A Pod contains:

One or more containers
Shared network
Shared storage

Important concept:

Containers inside the same pod behave like one application unit.

Example:

Pod
 ├── Container (App)
 └── Container (Logging agent)

🔁 Deployment – Managing Pods

Running pods directly is risky.

Instead Kubernetes uses Deployments.

Deployment manages:

Number of pods
Rolling updates
Auto recovery

Example declaration:

I want 3 pods running.

If one crashes → Kubernetes creates another.

🌐 Service – Stable Networking

Pods have dynamic IP addresses.

They constantly change.

To solve this, Kubernetes provides Services.

Service gives:

Stable IP
Stable DNS name
Load balancing

Example:

frontend-service

It routes traffic to available pods.

📈 Scaling in Kubernetes

Scaling can be done manually or automatically.

Example:

kubectl scale deployment my-app --replicas=5

Now Kubernetes runs 5 pods instead of 1.

With Horizontal Pod Autoscaler, scaling happens automatically based on CPU or traffic.

🔑 Other Important Kubernetes Concepts

Namespace

Logical grouping of resources.

Example:

dev
testing
production

ConfigMap

Stores configuration.

Example:

DATABASE_URL
API_ENDPOINT

Separates configuration from code.

Secret

Stores sensitive information:

Passwords
API keys
Tokens

Persistent Volume

Used when applications require storage.

Example:

Databases
Uploaded files

🧠 One-Sentence Mental Model

Kubernetes continuously ensures that the desired state of your application matches the actual running state of the cluster.

🚀 PART 2 – Hands-On Kubernetes (Beginner Friendly)

Before running Kubernetes commands, you need a cluster.

For learning, use:

Minikube
Kind
Docker Desktop Kubernetes

Beginner-friendly option:

Minikube

✅ Step 1 – Install Minikube

Install Minikube:

https://minikube.sigs.k8s.io/docs/start/

Verify installation:

minikube version

▶ Step 2 – Start Kubernetes Cluster

minikube start

This creates a local Kubernetes cluster.

Check cluster status:

kubectl cluster-info

📦 Step 3 – Run Your First Pod

Create a pod:

kubectl run nginx --image=nginx

Check pods:

kubectl get pods

You will see:

nginx   Running

🌐 Step 4 – Expose the Pod

Pods are not accessible externally by default.

Expose using a service.

kubectl expose pod nginx --type=NodePort --port=80

Check services:

kubectl get svc

Open in browser:

minikube service nginx

You will see the Nginx welcome page.

📋 Most Important Kubernetes Commands

Show cluster nodes

kubectl get nodes

Show pods

kubectl get pods

Show services

kubectl get services

Delete pod

kubectl delete pod nginx

Describe resource

kubectl describe pod nginx

Shows detailed debugging information.

🧑‍💻 Create a Deployment (Real-World Way)

Instead of a single pod:

kubectl create deployment myapp --image=nginx

Check deployments:

kubectl get deployments

Check pods:

kubectl get pods

You will see Kubernetes created pods automatically.

📈 Scale Application

Increase replicas:

kubectl scale deployment myapp --replicas=4

Now Kubernetes runs 4 identical pods.

🔁 Update Application

Example:

kubectl set image deployment/myapp nginx=nginx:1.25

Kubernetes performs rolling updates without downtime.

📄 Kubernetes YAML Example

Real deployments use YAML files.

Example:

deployment.yaml

apiVersion: apps/v1
kind: Deployment

metadata:
  name: myapp

spec:
  replicas: 3

  selector:
    matchLabels:
      app: myapp

  template:
    metadata:
      labels:
        app: myapp

    spec:
      containers:
      - name: myapp
        image: nginx
        ports:
        - containerPort: 80

Apply configuration:

kubectl apply -f deployment.yaml

Kubernetes creates everything automatically.

🧩 Docker vs Kubernetes

Feature	Docker	Kubernetes
Purpose	Run containers	Manage containers
Scope	Single machine	Cluster
Scaling	Manual	Automatic
Load balancing	Limited	Built-in
Self healing	No	Yes

Docker builds containers.

Kubernetes runs them at scale.

🎯 Why Kubernetes Is Widely Used

Major companies rely on Kubernetes because it provides:

Automatic scaling
Self-healing infrastructure
High availability
Rolling deployments
Cloud portability
Infrastructure automation

Platforms built on Kubernetes:

Google Kubernetes Engine
Amazon EKS
Azure AKS

🧠 Final Mental Model

Docker packages applications into containers.

Kubernetes orchestrates those containers across many machines to ensure:

reliability
scalability
automation

Docker Explained: A Beginner-Friendly Introduction to Containerization (2025–2026)

MUKHIL S — Wed, 18 Feb 2026 13:03:16 +0000

🐳 Docker for Absolute Beginners (2026) – Theory First, Then Hands-On

Hi everyone 👋
If you've heard:

"Just dockerize it."

…and felt confused — this post is for you.

We’ll start with clear theory (mental model first)
Then move to hands-on practical commands

By the end, Docker will feel simple.

🧠 PART 1 – Understand Docker BEFORE Typing Commands

🚨 The Big Problem Docker Solves

Before Docker:

You write code
It depends on exact versions
Your laptop works
Production crashes
Your friend’s system fails

Result:

"But it works on my machine 😭"

Docker solves this.

Docker packages:

Your app
Runtime (Node, Python, Java)
Libraries
System dependencies
Configuration

Into a standard container that runs the same everywhere.

📦 The Core Idea: Image vs Container

🖼 Docker Image vs 📦 Docker Container

Concept	Analogy	Running?	Changeable?	Purpose
Image	Recipe / Blueprint	❌ No	❌ Immutable	Template
Container	Cooked food / Running car	✅ Yes	⚠ Temporary	Live app

Simple Programming Analogy:

Image = Class
Container = Object

You create many containers from one image.

🧱 How Docker Images Work (Layers)

Docker images are built in layers.

Example layers:

Base OS (Ubuntu / Alpine)
Install packages
Install runtime (Node/Python)
Copy app code
Set startup command

Each step creates a new layer.

Why this is powerful:

Layers are cached
If only your code changes → only last layer rebuilds
Faster builds
Less storage usage

When you run a container:

All image layers (read-only)

One small writable layer on top

Delete container → writable layer disappears.

Unless you use Volumes (we’ll see later).

🚢 Why the Whale Logo?

Docker is inspired by real shipping containers.

Shipping containers:

Standard size
Work on ships, trucks, trains
Carry anything safely

Docker containers:

Standard software packaging
Run anywhere Docker exists
Carry apps safely

Same concept. Different world.

🔑 Other Important Theory Terms

📝 Dockerfile

A text file that contains instructions to build an image.

Example instructions:

FROM
RUN
COPY
CMD
EXPOSE

🏬 Docker Hub

A registry (like GitHub for images).

You can:

Pull public images
Push your own images

💾 Volumes

Special storage outside containers.

Why?
Containers are temporary.
Volumes store:

Database data
Uploaded files
Logs

Even if container is deleted.

⚙ docker run vs docker compose

Command	Purpose
docker run	Start one container
docker compose	Manage multiple containers

Example:
Web app + Database + Redis → use Compose.

🧠 One-Sentence Mental Model

Docker turns your app and its entire environment into a portable image.
You run that image as an isolated container — identical everywhere.

If this makes sense, you’re ready for practice.

🚀 PART 2 – Hands-On Docker (Beginner Friendly)

Now let’s actually run Docker.

✅ Step 1: Install Docker

Download Docker Desktop:

https://www.docker.com/products/docker-desktop/

Verify installation:

docker --version

🎉 Step 2: Run Your First Container

docker run hello-world

If you see a success message — Docker is working.

🌐 Run a Real Web Server (Nginx)

docker run -d -p 8080:80 nginx

What this means:

-d → Run in background
-p 8080:80 → Map port
nginx → Image name

Open browser:

http://localhost:8080

You’ll see the Nginx page 🎉

📋 Basic Commands You Must Know

List running containers

docker ps

List all containers

docker ps -a

List images

docker images

Stop container

docker stop <container_id>

Remove container

docker rm <container_id>

Remove image

docker rmi <image_name>

🗄 Example: Run PostgreSQL Database

docker run -d \
  --name my-postgres \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 5432:5432 \
  -v pgdata:/var/lib/postgresql/data \
  postgres:16

Explanation:

-e → Environment variable
-v → Volume (persistent storage)
-p → Port mapping

🧑‍💻 Build Your Own Docker Image (Mini Project)

Create folder:

my-first-docker-app

Inside it create:

app.py

print("Hello from my first Docker container 🚀")

Dockerfile

FROM python:3.12-slim

WORKDIR /app

COPY app.py .

CMD ["python", "app.py"]

🔨 Build Image

docker build -t my-first-app .

▶ Run Container

docker run my-first-app

If it prints your message:

Congratulations 🎉
You just built and ran your own Docker image.

🧩 Understanding Port Mapping

Format:

-p host_port:container_port

Example:

-p 5000:3000

Means:

Access via localhost:5000
App runs inside container on port 3000

🎯 Why Developers Love Docker

✅ Same environment everywhere
✅ No dependency conflicts
✅ Fast setup
✅ Easy deployment
✅ Works with CI/CD
✅ Cloud-ready

Happy Containerizing ,please like this post 🐳

Data Formats Every Data Analyst Should Know

MUKHIL S — Thu, 02 Oct 2025 04:49:23 +0000

Picking the right data format can make your analytics workflow faster, leaner, and easier to manage. Whether you're wrangling data in the cloud or locally, understanding how data is structured is key. In this post, we'll dive into six popular formats: CSV, SQL (Relational Tables), JSON, Parquet, XML, and Avro.

To keep it practical, I've created a small dataset of student exam records with four fields: name (string), register_number (integer), subject (string), and marks (integer). The dataset is:

Alice, 101, Math, 90
Bob, 102, Science, 85
Charlie, 103, Math, 95

For each format, I'll explain what it is, show the dataset in a consistent, readable way (using text or tables, with code blocks only for file-based formats or scripts), and list pros and cons.

1. CSV (Comma-Separated Values)

What's the deal?

CSV is the simplest format around. It's a text file where each row is a line, and values are separated by commas. You've probably opened one in Excel or Pandas. It's super easy to use but doesn't enforce data types, which can cause issues with complex data.

Dataset in CSV:

name,register_number,subject,marks
Alice,101,Math,90
Bob,102,Science,85
Charlie,103,Math,95

Pros

Human-readable and easy to edit
Supported by every tool (Pandas, Spark, Excel)
Perfect for quick data sharing

Cons

No schema or type enforcement
Inefficient for large or nested datasets

2. SQL (Relational Table Format)

What's the deal?

SQL organizes data in relational database tables, with columns defining data types and rows as records. It's not a file format but a structured way to store and query data using SQL commands.

Dataset in SQL:

CREATE TABLE students (
    name VARCHAR(255),
    register_number INT,
    subject VARCHAR(255),
    marks INT
);

INSERT INTO students (name, register_number, subject, marks)
VALUES 
    ('Alice', 101, 'Math', 90),
    ('Bob', 102, 'Science', 85),
    ('Charlie', 103, 'Math', 95);

name	register_number	subject	marks
Alice	101	Math	90
Bob	102	Science	85
Charlie	103	Math	95

Pros

Strict data types and schema
Optimized for querying and joins
Ideal for structured analytics

Cons

Requires a database system
Overkill for simple tasks

3. JSON (JavaScript Object Notation)

What's the deal?

JSON is a text-based format using key-value pairs and arrays. It's lightweight, supports nested data, and is a staple for APIs and NoSQL databases like MongoDB.

Dataset in JSON:

[
    {"name": "Alice", "register_number": 101, "subject": "Math", "marks": 90},
    {"name": "Bob", "register_number": 102, "subject": "Science", "marks": 85},
    {"name": "Charlie", "register_number": 103, "subject": "Math", "marks": 95}
]

Pros

Flexible for semi-structured or nested data
Easy to parse in Python, JavaScript, etc.
Common in APIs and web apps

Cons

Verbose, increasing file size
Slower for analytics than binary formats

4. Parquet (Columnar Storage Format)

What's the deal?

Parquet is a binary, columnar format optimized for analytics. It stores data by columns, not rows, which boosts compression and query speed in tools like Apache Spark or Pandas.

Dataset in Parquet:

import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'register_number': [101, 102, 103],
    'subject': ['Math', 'Science', 'Math'],
    'marks': [90, 85, 95]
}
df = pd.DataFrame(data)
table = pa.Table.from_pandas(df)
pq.write_table(table, 'students.parquet')

Pros

Efficient for columnar queries and compression
Great for big data tools (Spark, Dask)
Supports complex schemas

Cons

Not human-readable
Requires specialized libraries

5. XML (Extensible Markup Language)

What's the deal?

XML uses tags to create a tree-like structure. It's customizable, supports hierarchies, and is common in enterprise systems and web services.

Dataset in XML:

<students>
    <student>
        <name>Alice</name>
        <register_number>101</register_number>
        <subject>Math</subject>
        <marks>90</marks>
    </student>
    <student>
        <name>Bob</name>
        <register_number>102</register_number>
        <subject>Science</subject>
        <marks>85</marks>
    </student>
    <student>
        <name>Charlie</name>
        <register_number>103</register_number>
        <subject>Math</subject>
        <marks>95</marks>
    </student>
</students>

Pros

Supports complex, hierarchical data
Extensible with custom tags
Common in enterprise systems

Cons

Verbose and slow to process
Less popular than JSON for modern apps

6. Avro (Row-based Storage Format)

What's the deal?

Avro is a binary, row-based format for efficient serialization. It embeds a schema with the data, making it self-describing and ideal for schema evolution.

Dataset in Avro:

import fastavro

schema = {
    "type": "record",
    "name": "Student",
    "fields": [
        {"name": "name", "type": "string"},
        {"name": "register_number", "type": "int"},
        {"name": "subject", "type": "string"},
        {"name": "marks", "type": "int"}
    ]
}

records = [
    {"name": "Alice", "register_number": 101, "subject": "Math", "marks": 90},
    {"name": "Bob", "register_number": 102, "subject": "Science", "marks": 85},
    {"name": "Charlie", "register_number": 103, "subject": "Math", "marks": 95}
]

with open('students.avro', 'wb') as out:
    fastavro.writer(out, schema, records)

Pros

Compact and fast for serialization
Supports schema evolution
Ideal for streaming (e.g., Kafka)

Cons

Not human-readable
Requires specific libraries

Final Thoughts

CSV: Simple, portable, but lacks schema.
SQL: Structured and powerful for querying, but tied to databases.
JSON: Flexible, widely used in APIs.
Parquet: Best for analytics, efficient storage.
XML: Verbose, but still used in legacy systems.
Avro: Schema-driven, compact, common in streaming and big data pipelines.

Which Format Should You Choose?

Use Case	Recommended Format
Quick prototyping	CSV
Relational analytics	SQL
API integrations	JSON
Big Data analytics	Parquet
Enterprise systems	XML
Data pipelines/streaming	Avro

Choosing the right format depends on your system and use case.

Pro Tip: In cloud environments, Parquet and Avro are top picks for efficiency, while CSV and JSON are great for prototyping.

What's your favorite data format? Got a killer use case? Drop it in the comments! 👇

Working with Yelp Data in MongoDB: CRUD Operations and Queries

MUKHIL S — Thu, 21 Aug 2025 09:12:04 +0000

In this blog post, we'll explore how to perform basic CRUD operations and queries on a MongoDB database named mydb with a collection called yelp, based on a Yelp dataset. We'll use MongoDB's JavaScript-based query syntax to insert records, find top-rated businesses, count reviews containing specific words, retrieve reviews for a business, update a review, and delete a record. Let's dive in!

1. Inserting Records into the Yelp Collection

To populate the yelp collection, we can use the insertMany method to add multiple documents at once. Below is an example of inserting 10 review documents, each with fields like business_id, date, review_id, stars, text, type, user_id, cool, useful, and funny.

db.yelp.insertMany([
    {
        business_id: "A1B2C3D4E5F6G7H8I9J0K1",
        date: new Date("2023-01-01"),
        review_id: "R1S2T3U4V5W6X7Y8Z9A0B1",
        stars: 4,
        text: "Great food and ambiance, will come back!",
        type: "review",
        user_id: "U1V2W3X4Y5Z6A7B8C9D0E1",
        cool: 1,
        useful: 2,
        funny: 0
    },
    {
        business_id: "A1B2C3D4E5F6G7H8I9J0K1",
        date: new Date("2023-02-15"),
        review_id: "R2T3U4V5W6X7Y8Z9A0B1C2",
        stars: 5,
        text: "Amazing service, loved the pizza!",
        type: "review",
        user_id: "U2W3X4Y5Z6A7B8C9D0E1F2",
        cool: 2,
        useful: 3,
        funny: 1
    },
    {
        business_id: "B2C3D4E5F6G7H8I9J0K1L2",
        date: new Date("2023-03-10"),
        review_id: "R3U4V5W6X7Y8Z9A0B1C2D3",
        stars: 3,
        text: "Decent food, but slow service.",
        type: "review",
        user_id: "U3X4Y5Z6A7B8C9D0E1F2G3",
        cool: 0,
        useful: 1,
        funny: 0
    },
    {
        business_id: "B2C3D4E5F6G7H8I9J0K1L2",
        date: new Date("2023-04-20"),
        review_id: "R4V5W6X7Y8Z9A0B1C2D3E4",
        stars: 4,
        text: "Good burgers, nice patio.",
        type: "review",
        user_id: "U4Y5Z6A7B8C9D0E1F2G3H4",
        cool: 1,
        useful: 1,
        funny: 0
    },
    {
        business_id: "C3D4E5F6G7H8I9J0K1L2M3",
        date: new Date("2023-05-05"),
        review_id: "R5W6X7Y8Z9A0B1C2D3E4F5",
        stars: 5,
        text: "Best sushi ever, fresh and tasty!",
        type: "review",
        user_id: "U5Z6A7B8C9D0E1F2G3H4I5",
        cool: 3,
        useful: 4,
        funny: 2
    },
    {
        business_id: "C3D4E5F6G7H8I9J0K1L2M3",
        date: new Date("2023-06-12"),
        review_id: "R6X7Y8Z9A0B1C2D3E4F5G6",
        stars: 4,
        text: "Really good desserts, friendly staff.",
        type: "review",
        user_id: "U6A7B8C9D0E1F2G3H4I5J6",
        cool: 2,
        useful: 2,
        funny: 1
    },
    {
        business_id: "D4E5F6G7H8I9J0K1L2M3N4",
        date: new Date("2023-07-19"),
        review_id: "R7Y8Z9A0B1C2D3E4F5G6H7",
        stars: 5,
        text: "Fantastic experience, highly recommend!",
        type: "review",
        user_id: "U7B8C9D0E1F2G3H4I5J6K7",
        cool: 4,
        useful: 5,
        funny: 3
    },
    {
        business_id: "D4E5F6G7H8I9J0K1L2M3N4",
        date: new Date("2023-08-25"),
        review_id: "R8Z9A0B1C2D3E4F5G6H7I8",
        stars: 3,
        text: "Average food, great drinks.",
        type: "review",
        user_id: "U8C9D0E1F2G3H4I5J6K7L8",
        cool: 0,
        useful: 1,
        funny: 0
    },
    {
        business_id: "E5F6G7H8I9J0K1L2M3N4O5",
        date: new Date("2023-09-30"),
        review_id: "R9A0B1C2D3E4F5G6H7I8J9",
        stars: 4,
        text: "Loved the vibe, food was good.",
        type: "review",
        user_id: "U9D0E1F2G3H4I5J6K7L8M9",
        cool: 2,
        useful: 3,
        funny: 1
    },
    {
        business_id: "E5F6G7H8I9J0K1L2M3N4O5",
        date: new Date("2023-10-15"),
        review_id: "S0B1C2D3E4F5G6H7I8J9K0",
        stars: 5,
        text: "Incredible food, great service!",
        type: "review",
        user_id: "V0E1F2G3H4I5J6K7L8M9N0",
        cool: 3,
        useful: 4,
        funny: 2
    }
]);

Each document represents a review with fields matching the structure of a Yelp dataset (e.g., business_id, stars, text). Note that the 'date' field uses MongoDB's new Date() to store dates properly.

2. Finding the Top 5 Businesses by Average Rating

To find the top 5 businesses with the highest average rating, we use MongoDB's aggregation pipeline. The pipeline groups reviews by 'business_id', computes the average 'stars', sorts in descending order, and limits to 5 results.

db.yelp.aggregate([
    { $group: { _id: "$business_id", avg_rating: { $avg: "$stars" } } },
    { $sort: { avg_rating: -1 } },
    { $limit: 5 }
]);

For the inserted data, this query returns:

'C3D4E5F6G7H8I9J0K1L2M3': 4.5
'E5F6G7H8I9J0K1L2M3N4O5': 4.5
'A1B2C3D4E5F6G7H8I9J0K1': 4.5
'D4E5F6G7H8I9J0K1L2M3N4': 4
'B2C3D4E5F6G7H8I9J0K1L2': 3.5

3. Counting Reviews Containing the Word “Good”

To count reviews with the word 'good' in the 'text' field, we use countDocuments with a case-insensitive regex.

db.yelp.countDocuments({ text: { $regex: "good", $options: "i" } });

This returns '3' for the inserted data, as three reviews contain 'good' (review IDs 'R4V5W6X7Y8Z9A0B1C2D3E4', 'R6X7Y8Z9A0B1C2D3E4F5G6', 'R9A0B1C2D3E4F5G6H7I8J9').

4. Retrieving All Reviews for a Specific Business

To fetch all reviews for a specific 'business_id', we use the find method. For example, to get reviews for '9yKzy9PApeiPPOUJEtnvkg' (from the sample Yelp data):

db.yelp.find({ business_id: "9yKzy9PApeiPPOUJEtnvkg" }).toArray();

This returns all matching reviews. If the sample review from the Yelp CSV is inserted, it would return that review.

5. Updating a Review

To update a review, we use updateOne to modify specific fields. For example, to update the review with 'review_id' 'fWKvX83p0-ka4JS3dc6E5A' (from the sample data, if inserted):

db.yelp.updateOne(
    { review_id: "fWKvX83p0-ka4JS3dc6E5A" },
    { $set: { stars: 3, text: "Updated review: Food was okay, service was slow." } }
);

This sets 'stars' to 3 and updates the 'text' field for the specified review.

6. Deleting a Record

To delete a review, we use deleteOne. For example, to remove the review with 'review_id' 'R1S2T3U4V5W6X7Y8Z9A0B1':

db.yelp.deleteOne({ review_id: "R1S2T3U4V5W6X7Y8Z9A0B1" });

This removes the specified review from the collection.

Notes

These queries assume you're using MongoDB with the 'yelp' collection in the 'mydb' database.
The 'date' field uses MongoDB's Date object for proper storage. When importing a CSV, ensure dates are parsed correctly (e.g., new Date("YYYY-MM-DD")).
The regex in the 'good' query is case-insensitive ('$options: "i"').
To import a large 'yelp.csv' file, you can use MongoDB's mongoimport tool or a script to parse and insert the data.
If you encounter issues or need help with specific MongoDB versions, importing data, or running these queries, feel free to share more details!

This setup provides a solid foundation for working with Yelp data in MongoDB. You can extend these queries for more complex analyses, like filtering by date or combining conditions. Happy coding!

these are my sample images and work are mentioned in the image