Tech2Towards

Self-Healing Applications in Kubernetes

2026-09-02T15:51:11.143+05:30

What is Self-Healing?

Self-Healing is a Kubernetes feature that automatically detects failed Pods or containers and restores the desired state by restarting or recreating them.

Why Do We Need Self-Healing?

Suppose you have 3 Pods running:

Pod-1

Pod-2

Pod-3

If Pod-2 crashes:

Pod-1

Pod-2 (Failed)

Pod-3

Kubernetes automatically creates a new Pod:

Pod-1

Pod-3

Pod-4 (New)

This will ensures the desired number of Pods is always maintained.

How Self-Healing Works

Deployment

ReplicaSet

3 Pods

Pod Crashes

ReplicaSet Detects Failure

New Pod Created Automatically

Practical Demo

Check running Pods - kubectl get pods

Delete one Pod manually - kubectl delete pod <pod-name>

Check again - kubectl get pods

You will see Kubernetes automatically creating a new Pod.

Benefits

High Availability

Reduced Manual Intervention

Automatic Recovery

Better Reliability

Continuous Application Availability

Init Containers

2026-09-02T15:50:30.784+05:30

What is an Init Container?

An Init Container is a special container that performs startup tasks before the main application container starts. It is used for initialization tasks such as checking dependencies, preparing configurations, or waiting for services to become available. The application container starts only after the Init Container completes successfully.

Why Use Init Containers?

Init Containers are commonly used for:

Checking if a database is available

Waiting for another service to start

Downloading configuration files

Initializing data or directories

How It Works

Step 1: Init Container Runs

↓

Step 2: Init Container Completes

↓

Step 3: Main Application Container Starts

Example:

apiVersion: v1

kind: Pod

metadata:

spec:

initContainers:

- name: init-myservice

image: busybox

command: ['sh', '-c', 'echo Initializing...; sleep 10']

containers:

- name: nginx

image: nginx

Create the Pod - kubectl apply -f pod.yaml

What Happens?

Init Container starts.

Waits for 10 seconds.

Exits successfully.

Nginx container starts.

Real-Life Example

Suppose your application needs MySQL to be available before starting.

Init Container

|--> Check MySQL Connection

Success?

Yes

Application Starts

Without Init Container?

Application Starts

MySQL Not Ready

Application Fails

With Init Container?

Wait for MySQL

MySQL Ready

Application Starts Successfully

Verify Init Container

Check Pod details - kubectl describe pod init-container-demo

View logs - kubectl logs init-container-demo -c init-myservice

Multi-Container Pods

2026-09-02T15:49:45.776+05:30

What is a Multi-Container Pod?

A Multi-Container Pod is a Pod that contains more than one container. These containers run together in the same Pod and share the same network and storage.

Why Use Multi-Container Pods?

Sometimes an application needs a helper container which is also Sidecar Container for tasks such as:

Log collection

Monitoring

Proxy service

Data synchronization

Instead of running them separately, both containers can run inside the same Pod.

Example:

Pod

├── Nginx Application Container (Main Application)

└── BusyBox Logging Container (Log Collector)

Both containers:

Containers work closely together.

Share the same IP address

Can communicate using localhost

Can share volumes (storage)

Multi-Container Pod YAML

apiVersion: v1

kind: Pod

metadata:

spec:

containers:

- name: nginx

image: nginx

- name: busybox

image: busybox

command: ["sh", "-c", "while true; do echo Hello; sleep 10; done"]

Create the Pod - kubectl apply -f pod.yaml

Verify - kubectl get pods

Scale Applications in Kubernetes

2026-09-02T15:49:11.616+05:30

What is Scaling?

Scaling is the process of increasing or decreasing the number of application Pods to handle workload changes.

Why Do We Need Scaling?

Suppose your e-commerce application is receives a lot of traffic during a sale day:

Instead of: 2 Pod You can scale it to: 5 Pods

Normal Days → 2 Pods

Sale Days → 5 Pods

Kubernetes scales the application to handle more users without downtime and This will improves:

Performance

Availability

Load distribution

Scale Up

Current Deployment - replicas: 2

Scale to 5 Pods - kubectl scale deployment nginx-deployment --replicas=5

Verify - kubectl get pods

Scale Down

Current Deployment - replicas: 5

Scale to 5 Pods - kubectl scale deployment nginx-deployment --replicas=2

Verify - kubectl get pods

Creating a ConfigMap in Kubernetes

2026-09-02T15:48:42.375+05:30

What is a ConfigMap?

A ConfigMap is a Kubernetes object which is used to store non-sensitive configuration data in the form of key-value pairs.

Examples:

Application environment

Server URL

Application port

Log level

Why we Use a ConfigMap?

Instead of hardcoding values in the Deployment, Store them in a ConfigMap and use them wherever it needed.

Create a ConfigMap

kubectl create configmap app-config --from-literal=APP_ENV=Production --from-literal=APP_PORT=8080

kubectl get configmap

kubectl describe configmap app-config

Use ConfigMap in a Deployment

apiVersion: apps/v1

kind: Deployment

metadata:

spec:

replicas: 1

selector:

matchLabels:

app: nginx-config-demo

template:

metadata:

labels:

app: nginx-config-demo

spec:

containers:

- name: nginx

image: nginx

env:

- name: APP_ENV

valueFrom:

configMapKeyRef:

key: APP_ENV

- name: APP_PORT

valueFrom:

configMapKeyRef:

key: APP_PORT

Apply - kubectl apply -f deployment.yaml

Verify Inside the Pod

Get the Pod name - kubectl get pods

Check values - printenv APP_ENV

Check values - printenv APP_PORT

ConfigMap YAML Example

apiVersion: v1

kind: ConfigMap

metadata:

data:

APP_ENV: Production

APP_PORT: "8080"

LOG_LEVEL: INFO

kubectl apply -f configmap.yaml

Configure Secret Resources for Sensitive Values

2026-09-02T15:48:06.408+05:30

What is a Secret?

A Secret is a Kubernetes object which is used to store and manage sensitive data in Kubernetes such as:

Passwords

API Keys

Database Credentials

Tokens

Certificates

Why Use Secrets?

Not Recommended:-

env:

- name: DB_PASSWORD

value: "admin123"

Anyone can see the password in the YAML file.

Recommended:- Store the password in a Kubernetes Secret and use it in the Deployment.

Step 1: Create a Secret

kubectl create secret generic mysql-secret --from-literal=username=admin --from-literal=password=admin123

kubectl get secrets

Step 2: Use Secret in Deployment

apiVersion: apps/v1

kind: Deployment

metadata:

spec:

replicas: 2

selector:

matchLabels:

app: nginx-secret-demo

template:

metadata:

labels:

app: nginx-secret-demo

spec:

containers:

- name: nginx

image: nginx:latest

env:

- name: DB_USER

valueFrom:

secretKeyRef:

key: username

- name: DB_PASSWORD

valueFrom:

secretKeyRef:

key: password

kubectl apply -f deployment.yaml

Step 3: Verify Inside the Container

kubectl get pods

kubectl exec -it <pod-name> -- bash

printenv DB_USER

Real-Life Example

Suppose your application connects to MySQL:

Database Host = mysql-service

Database User = admin

Database Password = admin123

Store the password in a Secret instead of hardcoding it in the Deployment YAML, This keeps sensitive data separate from application configuration.

Configure Environment Variables in Kubernetes

2026-09-02T15:47:29.559+05:30

What are Environment Variables?

Environment variables are key-value pairs which is used to pass the configuration values to an application without changing the application code.

Example:

Database URL

Username

Application Mode (dev, test, prod)

Why Use Environment Variables?

Instead of hardcoding values in the application code, We can pass them from Kubernetes.

DB_HOST=localhost

DB_HOST=mysql-service

This makes the application more flexible and easier to manage.

Example Deployment YAML

apiVersion: apps/v1

kind: Deployment

metadata:

spec:

replicas: 2

selector:

matchLabels:

app: myapp

template:

metadata:

labels:

app: myapp

spec:

containers:

- name: myapp

image: nginx

env:

- name: APP_ENV

value: "production"

- name: COMPANY

value: "HCL Pvt Ltd"

Understanding the Configuration

env:

- name: APP_ENV

value: "production"

- name: DB_HOST

value: "mysql-service"

Creates an environment variable.

APP_ENV=production

DB_HOST="HCL Pvt Ltd"

Verify Environment Variables

Find the Pod - kubectl get pods

Access the Pod - kubectl exec -it <pod-name> -- /bin/bash

View environment variables command:

env Or printenv

env APP_ENV Or printenv APP_ENV

Using Rolling Updates in Kubernetes

2026-09-02T15:46:45.779+05:30

What is a Rolling Update?

A Rolling Update is a Kubernetes deployment strategy that updates an application without downtime by gradually replacing old Pods with new Pods.

Why Use Rolling Updates?

No downtime during application updates.

Users can continue accessing the application.

Safer deployment process.

Easy rollback if something goes wrong.

Example: Suppose you have a Pods running version pod-v1 You update the image to pod-v2, Kubernetes performs the update gradually, Users can access the application throughout the update process.

Perform a Rolling Update

Update the image - kubectl set image deployment/nginx-deployment nginx=nginx:latest

Check update status: - kubectl rollout status deployment/nginx-deployment

View Rollout History

kubectl rollout history deployment nginx-deployment

Rollback to Previous Version

If the new version has issues, then Kubernetes restores the previous working version.

kubectl rollout undo deployment nginx-deployment

Verify Deployment

kubectl get deployments

kubectl get pods

How It Works

Deployment

Rolling Update

Old Pods ---> New Pods

(v1) (v2)

Kubernetes removes old Pods and creates new Pods gradually until all Pods run the new version.

Understanding Pods, ReplicaSets & Deployments

2026-09-02T15:46:07.368+05:30

Pods, ReplicaSets & Deployments These three components work together to run and manage applications in Kubernetes.

1. Pod

A Pod is the smallest unit in Kubernetes. It contains one or more containers that run your application.

Pod

└── Nginx Container

2. ReplicaSet

A ReplicaSet ensure that the desired number of identical Pods are running.

Example

If you want 3 Pods running:

ReplicaSet

---------

| | |

Pod Pod Pod

If one Pod crashes:

ReplicaSet

|--> Creates a new Pod

3. Deployment

A Deployment manages ReplicaSets and Pods.

It provides:

Scaling

Rolling Updates

Rollbacks

Self-Healing

Deployment

ReplicaSet

-----------

| | |

Pod Pod Pod

Relationship Between Them

How It Works

You create a Deployment.

Deployment creates a ReplicaSet.

ReplicaSet creates the required Pods.

If a Pod fails, ReplicaSet creates a new Pod.

Deployment manages updates and scaling.

Real-Life Example

Imagine a company:

Deployment = Manager

ReplicaSet = Supervisor

Pods = Workers

Manager decides how many workers are needed.

Supervisor ensures the required workers are present.

Workers perform the actual work.

Summary: A Pod runs the application, a ReplicaSet ensures the required number of Pods are running, and a Deployment manages ReplicaSets by providing scaling, rolling updates, rollbacks, and self-healing capabilities.

Creating a Service in Kubernetes

2026-09-02T15:45:13.041+05:30

What is a Service?

A Service is a Kubernetes object that provides a stable IP address and DNS name to access Pods.

Since Pod IP addresses can change when Pods are recreated, a Service acts as a fixed endpoint for accessing the application.

Why Do We Need a Service?

Suppose you have 3 Pods: Pod-1/Pod-2/Pod-3

If Pod-1 crashes, Kubernetes creates a new Pod with a different IP address.

Without a Service:

Users need to know individual Pod IPs.

Pod IPs keep changing.

With a Service:

Users connect to one stable IP/DNS.

The Service automatically forwards traffic to available Pods.

Service YAML Example

apiVersion: v1

kind: Service

metadata:

spec:

selector:

app: nginx

ports:

- protocol: TCP

port: 80

targetPort: 80

type: ClusterIP

Understanding the YAML

selector - The Service finds all Pods having (labels: app: nginx)

selector:

app: nginx

port - The port exposed by the Service.

port: 80

targetPort - The port on the container where the application is running.

targetPort: 80

type - Defines how the Service is exposed.

type: ClusterIP

How Service Works (The Service distributes incoming requests among all available Pods.)

nginx-service

------------------

| | |

Pod1 Pod2 Pod3

Create a Service

kubectl apply -f service.yaml

kubectl get svc

kubectl get services

Types of Services

1. ClusterIP (Default)

Accessible only inside the Kubernetes cluster.

type: ClusterIP

2. NodePort

Exposes the application on a port of every worker node. <Node-IP>:30000

type: NodePort

3. LoadBalancer

Creates an external load balancer (AWS, Azure, GCP). [Access: External IP]

type: LoadBalancer

Creating a Deployment in Kubernetes using YAML

2026-09-02T15:43:14.919+05:30

You'll learn how real applications are deployed, configured, scaled, updated, and healed automatically.

What is a Deployment?

A Deployment is a Kubernetes resource used to manage and deploy applications. It ensures that the desired number of Pods are running and provides features like scaling, rolling updates, and self-healing.

Deployment YAML Example

Create a file named deployment.yaml:

apiVersion: apps/v1

kind: Deployment

metadata:

spec:

replicas: 3

selector:

matchLabels:

app: nginx

template:

metadata:

labels:

app: nginx

spec:

containers:

- name: nginx

image: nginx:latest

ports:

- containerPort: 80

Understanding the YAML

apiVersion - Specifies the API version used by the Deployment.

apiVersion: apps/v1

kind - Defines the resource type. example (Pod, Deployment, Services)

kind: Deployment

metadata - Gives the deployment a name.

metadata:

replicas - Creates desired no of identical Pods.

replicas: 3

selector - Used to identify the Pods managed by this Deployment. (Selector identifies which Pods are managed by the Deployment.)

selector:

matchLabels:

app: nginx

template - Represents the Pod template. (Create Pods with label app: nginx and run the nginx container.)

template:

container image - Specifies the container image to use.

image: nginx:latest

Create Deployment

kubectl apply -f deployment.yaml

Verify Deployment

kubectl get deployments

kubectl get rs

kubectl get pods

Scale Deployment (Increase replicas from 3 to 5)

kubectl scale deployment nginx-deployment --replicas=5

kubectl get pods

Update Deployment

Update image version - kubectl set image deployment/nginx-deployment nginx=nginx:1.26

Check rollout status - kubectl rollout status deployment/nginx-deployment

Rollback Deployment

View rollout history - kubectl rollout history deployment nginx-deployment

Rollback - kubectl rollout undo deployment nginx-deployment

Self-Healing Example (Delete a Pod)

kubectl delete pod <pod-name>

Kubernetes automatically creates a new Pod to maintain the desired replica count.

MODULE-3 K8s APPLICATION DEPLOYMENT

2026-09-02T15:32:55.551+05:30

K8s Installation Using Minikube

2026-09-02T15:28:28.917+05:30

What is Minikube?

Minikube is a tool that allows you to run a single-node Kubernetes cluster on your local machine for learning, development, and testing purposes.

Perfect for:

Learning Kubernetes

Running demos

Practicing kubectl commands

Not suitable for:

Production workloads

High availability

Architecture

Laptop

Minikube VM/Container

Control Plane + Worker

Basis on your Operating System follow Official Document

Install kubectl

Install Minikube

Start Cluster

MODULE-2 KUBERNETES INSTALLATION

2026-09-02T15:27:21.809+05:30

This module covers multiple ways to install Kubernetes, from local learning environments to enterprise-grade highly available clusters.

Installation minikube
Installation using kubeadm utility in HA mode (Optional)
Install Kubernetes the hard Way (Optional)
How to use kops and create (Optional)
Kubernetes cluster (Optional)

Understanding YAML

2026-09-02T15:16:53.662+05:30

Kubernetes resources are defined using YAML files.

Example:

apiVersion: v1

kind: Pod

metadata:

spec:

containers:

- name: nginx

image: nginx

YAML Structure

apiVersion

Which Kubernetes API version to use.

apiVersion: v1

kind

Resource type.

kind: Pod

kind: Service

kind: Deployment

metadata

Information about object.

metadata:

spec

Desired state.

spec:

containers:

Deployment Example

apiVersion: apps/v1

kind: Deployment

metadata:

spec:

replicas: 3

selector:

matchLabels:

app: nginx

template:

metadata:

labels:

app: nginx

spec:

containers:

- name: nginx

image: nginx:latest

kubectl apply -f deployment.yaml

kubectl get deploy

kubectl get pods

Exploring Your Cluster

2026-09-02T15:14:35.538+05:30

Most common commands.

kubectl get nodes

kubectl get pods

kubectl get pods -A

kubectl describe pod nginx

kubectl logs nginx

kubectl exec -it nginx -- /bin/bash

kubectl get nodes

kubectl cluster-info

kubectl describe node worker1

You can manage Kubernetes in two ways:

1) Using Commands (kubectl)

You can manage Kubernetes resources directly from the command line using the kubectl command.

kubectl create deployment nginx --image=nginx

2) Using YAML Files

You can define Kubernetes resources in a YAML file and apply them to the cluster.

ETCD, Controller, API Server & Scheduler Deep Dive (In Practical Way)

2026-09-02T15:13:24.365+05:30

Imagine you execute: kubectl run nginx --image=nginx

Flow:

Step 1

kubectl sends request.

kubectl --> API Server

Step 2

API Server validates request.

Create nginx Pod

Step 3

API Server stores desired state in ETCD.

ETCD --> nginx Pod Required

Step 4

Scheduler checks unscheduled pod.

Pod Needs Node

Finds best worker node.

Step 5

Scheduler updates ETCD.

Run Pod on Node-2

Step 6

Kubelet on Node-2 creates pod.

containerd pulls image

nginx starts

Step 7

Controller continuously checks:

Desired = 1 pod

Actual = 1 pod

Healthy.

Core Concept of Kubernetes Services

2026-09-02T15:09:04.216+05:30

What is a Pod?

Smallest deployable unit in Kubernetes.

A Pod contains:

Pod

├── Application Container

└── Optional Sidecar Container

Example: nginx Pod

apiVersion: v1

kind: Pod

metadata:

spec:

containers:

- name: nginx

image: nginx

Problem with Pods

Pod IP changes after restart.

Example: Pod IP = 10.10.1.20

Pod dies:

New Pod IP = 10.10.1.30

Clients break.

Kubernetes Service

Provides a stable endpoint.

Client

Service

-----------

| | |

P1 P2 P3

Service never changes.

Pods can change.

Service Types

ClusterIP (Default)

Internal communication.

Example: Frontend ---> Backend

Inside cluster only.

NodePort

Exposes application on worker node port.

Example: 192.168.1.10:30080

External users can access.

LoadBalancer

Cloud environments: AWS/Azure/GCP

Internet

Load Balancer

Service

Pods

Most commonly used in production.

ExternalName

Maps service to external DNS.

Example: externalName: database.company.com

Kubernetes Cluster Architecture

2026-09-02T15:04:20.403+05:30

A Kubernetes Cluster contains:

┌─────────────────────────────┐

│ Control Plane │

└─────────────────────────────┘

------------------------------------------

| | |

Worker1 Worker2 Worker3

Control Plane (Master Node)

Brain of Kubernetes.

Responsible for:

Scheduling

Monitoring

Cluster decisions

State management

Cluster

├── Control Plane

│ ├── API Server

│ ├── ETCD

│ ├── Scheduler

│ └── Controller Manager

│

└── Worker Nodes

├── Kubelet

├── Kube-Proxy

└── Container Runtime

Components:

API Server

kubectl --> API Server --> Cluster

Entry point of Kubernetes.

Every request goes through API Server.

Examples:

kubectl get pods

kubectl create deployment nginx

ETCD

Database of Kubernetes.

Stores:

Cluster state

Pod information

Secrets

ConfigMaps

Node info

Example:

Current State: 3 Pods running

Stored inside ETCD.

Scheduler

Decides: Which worker node should run a pod?

Example:

Cluster:

Node1 CPU = 90%

Node2 CPU = 20%

Scheduler chooses:

Pod --> Node2

because Node2 has more resources.

Controller Manager

Monitors desired state versus current state.

Example:

Desired: 3 Pods

Current: 2 Pods

Controller notices mismatch and starts: New Pod TO MAKE IT 3 Pods

== Worker Node Components ==

Worker node is actual responsible for manage and runs your applications.

Kubelet

Agent running on every worker node.

Responsibilities:

Talks with API Server

Creates pods

Health checking

Think:

Manager --> Worker

API Server --> Kubelet

Container Runtime

Responsible for container execution.

Examples:

containerd

CRI-O

Older Kubernetes: Docker

Kube-Proxy

Handles network traffic.

Responsibilities:

Service routing

Load balancing

Example:

User Request

Kube-Proxy

------------------

| | |

Pod1 Pod2 Pod3

Introduction to Kubernetes

2026-09-02T14:54:48.762+05:30

What is Kubernetes?

Kubernetes (K8s) is an open-source container orchestration platform that automates:

Deployment

Scaling

Load balancing

Self-healing

Container management

Think of it as:

Docker manages containers on one server.

Kubernetes manages containers across hundreds or thousands of servers.

Without Kubernetes

Server-1

├── App Container

└── Database Container

Problems:

Manual scaling

Single point of failure

Difficult upgrades

No self-healing

With Kubernetes

Kubernetes Cluster

+----------------------+
| Control Plane |
+----------------------+
|
---------------------------------
| | |
Worker-1 Worker-2 Worker-3
| | |
App Pods App Pods App Pods

Benefits:

Auto Scaling

High Availability

Self Healing

Rolling Updates

Service Discovery

Why Kubernetes Became Popular ?

Suppose Amazon receives:

1,000 users in regular day

1,000,00 users during Diwali Sale

Kubernetes can automatically:

2 Pods → 20 Pods → 200 Pods

and reduce them later to save cost.

MODULE-1 INTRODUCTION KUBERNETES

2026-09-02T14:46:58.568+05:30

Certified Kubernetes Administrator (CKE) Course

2026-09-02T14:40:59.550+05:30

MODULE-1 INTRODUCTION KUBERNETES

Introduction to Kubernetes
Kubernetes Cluster Architecture
Core Concept of Kubernetes Services
ETCD & Controller & API & scheduler
Exploring your Cluster
Understanding YAML

MODULE-2 INSTALLATION

Installation minikube
Installation using kubeadm utility in HA mode
Install Kubernetes the hard Way
How to use kops and create
Kubernetes cluster

MODULE-3 APPLICATION DEPLOYMENT

Creating a Deployment in Kubernetes using YAML
Creating a Service in Kubernetes
Understanding pod & Replication & Deployment configuration
Using Rolling Updates in Kubernetes
Configure Environment variables in the application
Configure secret resources for sensitive value
Creating Config Map
Scale Applications
Multi Container PODs
Init Containers
Self-Healing Applications

MODULE-4 STORAGE MANAGEMENT

Creating Persistent volume
Persistent Volume Claim
Volume claim policy understanding
Attach storage on deployment

MODULE-5 POD SCHEDULING

Manual Scheduling
Labels and Selectors
Taints and Tolerations
Node Selectors
Node Affinity
DaemonSets
Static Pods
Multiple Schedulers
Configuring Kubernetes Scheduler

MODULE-6 RESOURCE ALLOCATION

Restrict Limit Memory & CPU use
Creating Resource Quota
Creating Limit Quota

MODULE-7 NETWORKING

Network Namespace understanding
Docker Network
Deploy Kubernetes Network
Cluster Networking
Pod Networking
Creating Service Network
DNS Concept in Kubernetes
Ingress System Kubernetes

MODULE-8 MONITORING KUBERNETES

Logging and Monitoring
Monitoring Cluster Component
Managing application Logs

MODULE-9 SECURITY

Authentication
TLS Introduction
Certificate System Kubernetes
Creating Certificate
Role base Access Controls
Cluster Role and Role Binding
SCC: Security Constant Conta & Network Policy
Image Security

Enable SSO In Jenkins Using Azure EntraID

2026-05-28T20:15:42.868+05:30

In this document we are going to integrating Single Sign-On (SSO) Authentication In Jenkins Using Azure Entra ID After integration, users will be able to log in to Jenkins using their Azure Entra ID credentials.

This functionality improves security, simplifies user access management, and enhances the overall login experience by centralization login.

Key Points To Learn:-

What Is SSO, Jenkins, SAML and EntraID

Prerequisites:

Jenkins is accessible using an HTTPS URL.
Azure account with permission to manage Entra ID.

Step 1) In Jenkins Install Plugin "SAML Single Sign On (SSO)"

Step 2) Configure Security for Installed Plugin (Part 1)

Under Security > Configure

Under Security Realm > Select "Mini Orange SAML 2.0" > Save

Step 3) Configure Security for Installed Plugin (Part 2)

Under Security > "Mini Orange SAML 2.0"

Keep this page untuched details will required to fill in "Step 5"

Step 4) In Azure Configure Entra

EntraID > Manage > Enterprice Application

New Application > Create Your Own Application > Write the Name of the application "Jenkins SSO" > Create

Set Up Single Sign On > SAML > Edit "Basic SAML Configuration"

Step 5) Copy & Paste the Details from [Plugin] To [Entra ID]

Copy & Paste the "Entity ID" & "Assertion Consumer Service URL"

Save

Step 6) Copy, Paste & Test the Details from [Entra ID] To [Plugin]

Copy "App Fedration Metadeta URL" and Paste under plugin "Metadeta URL"

Validate Metadeta URL > Apply

Test Configuration > Under "IDP Signing Certificate"

Click here to see the test configuration result

Apply > Save

Step 7) Final ! Access Jenkins via SSO

Advanced Apache Features

2026-02-05T22:05:00.002+05:30

👉🏿 This guide explains how to use advanced Apache features used in production servers to monitor live traffic, automatically block malicious users, restrict access by country, and secure websites with authentication to prevent unauthorized access and attacks.

1) Real‑Time Log Monitoring via Web Browser

View and analyze Apache access/error logs live in your browser for quick diagnostics and monitoring.
Link: Click Me

2) Automated User Blocking with Fail2Ban

Protect your website by blocking users who access a specific URL more than 100 times per minute.
Link: Click Me

3) Geo‑Blocking Specific Countries ( e.g., US / IN )

Restrict access to your website from selected countries using Apache’s mod_geoip or mod_maxminddb.
Link: Click Me

4) Implementing Apache Authentication on website

Secure your website by enabling user authentication through Apache’s built‑in auth mechanisms.
Link: Click Me

Block Website Access for Specific Country

2026-02-02T22:13:00.005+05:30

This guide explains how to block access to a website directory based on country (United States, Mexico, and India) using Apache and the GeoIP module on Ubuntu.

Step 1: Install Required Packages

sudo apt update
sudo apt install apache2 libapache2-mod-geoip geoip-database -y

Step 2: Enable the GeoIP Module

sudo a2enmod geoip
sudo systemctl restart apache2

Verify that the module is loaded:

apachectl -M | grep geoip

Step 3: Verify GeoIP Database

You should see GeoIP.dat in the output.

ls /usr/share/GeoIP/

Step 4: Configure GeoIP in Apache Separate virtual host file or apache2.conf

<IfModule geoip_module>
    GeoIPEnable On
    GeoIPDBFile /usr/share/GeoIP/GeoIP.dat
</IfModule>

<Directory /var/www/html/>
    <RequireAll>
        Require all granted
        Require not env BlockCountry
    </RequireAll>

    SetEnvIf GEOIP_COUNTRY_CODE US BlockCountry
    SetEnvIf GEOIP_COUNTRY_CODE MX BlockCountry
    SetEnvIf GEOIP_COUNTRY_CODE IN BlockCountry
</Directory>

Result: Visitors from United States (US), Mexico (MX), and India (IN) will now be blocked from accessing the specified directory, while users from other countries will continue to have access.