HashiCorp Nomad: A Comprehensive Guide to Workload Orchestration

HashiCorp Nomad is a distributed workload orchestrator designed to deploy and manage containers, batch jobs, long-running services, legacy applications, and other workloads across clusters of machines.

If Docker answers:

“How do I run this container?”

and Kubernetes answers:

“How do I orchestrate containers across a cluster?”

Nomad takes a somewhat broader and simpler approach:

“How do I schedule and operate different kinds of workloads across my infrastructure?”

Nomad can run Docker containers, binaries, Java applications, QEMU workloads, and other task-driver-based workloads. HashiCorp describes it as a highly available, distributed, datacenter-aware scheduler designed for services, batch jobs, and more.

---

1. What Is HashiCorp Nomad?

Nomad is a cluster scheduler and workload orchestrator developed by HashiCorp.

Its core responsibilities include:

• Scheduling workloads
• Allocating CPU and memory
• Placing workloads on appropriate nodes
• Running long-lived services
• Running batch jobs
• Running jobs on every node
• Handling workload failures
• Rolling out updates
• Managing task lifecycle
• Service registration
• Integrating with Consul
• Integrating with Vault
• Supporting multiple datacenters
• Supporting heterogeneous workloads

A simplified architecture is:

                    NOMAD
                      │
             ┌────────┴────────┐
             │                 │
        Nomad Servers      Nomad Clients
             │                 │
        Scheduling         Run workloads
        Cluster State      Containers
        Coordination       Binaries
             │             Batch jobs
             │             Services
             ▼
          Allocations

Nomad's servers handle scheduling and cluster management, while clients execute the workloads assigned to them.

---

2. Why Nomad?

Traditional application deployment might look like:

Server 1 → Application A
Server 2 → Application B
Server 3 → Application C
Server 4 → Application D

As infrastructure grows, you need to answer:

• Where should an application run?
• Does the server have enough CPU?
• Does it have enough memory?
• Does it have the required runtime?
• What happens if the server fails?
• How do we deploy five copies?
• How do we update them?
• How do we run a job every night?
• How do we deploy something to every node?
• How do services discover each other?

Nomad provides a scheduling and reconciliation layer.

Desired State
      │
      ▼
   Nomad Job
      │
      ▼
   Scheduler
      │
      ▼
 Allocation Plan
      │
      ▼
 Nomad Clients
      │
      ▼
 Workloads

---

3. Nomad vs Kubernetes

How to Fix Missing Dual-Boot Entries in Kali Linux GRUB (Enable OS-Prober)

📅 September 18, 2026 Kali Linux GRUB Dual Boot os-prober Linux

If you have dual-booted Kali Linux alongside another distribution like Ubuntu, Windows, or another Linux variant, you might notice something frustrating after installation: your secondary operating system completely vanishes from the boot screen.

Don't panic—your files and alternative operating systems are perfectly safe. Modern versions of Kali Linux explicitly disable automated OS discovery (os-prober) out of the box to mitigate potential security vulnerabilities (like unauthorized background mounting).

To bring your secondary operating system back to your launch menu, you need to manually unlock this feature. Here is a quick step-by-step guide to updating your GRUB bootloader matrix.

Step 1 Open the GRUB Configuration File

To change how your bootloader behaves, you must modify its primary configurations template. Open your terminal in Kali Linux and open the file using the nano text editor:

sudo nano /etc/default/grub

Step 2 Unlocking the OS Prober Engine

Scroll down through the configuration lines inside the editor. Look for the dedicated section regarding multiple operating systems.

You need to locate or create a parameter variable called GRUB_DISABLE_OS_PROBER.

• If the line is already there: Check if it says =true. Change it directly to false so it looks exactly like this:

GRUB_DISABLE_OS_PROBER=false

• If the line is commented out (has a # in front of it): Delete the # symbol to activate the configuration command.
• If the line is completely missing: Navigate to the absolute bottom of the document and add it manually:

GRUB_DISABLE_OS_PROBER=false

Install the GNOME Desktop and Remote Desktop Packages

Linux with GNOME: Remote Desktop Protocol (RDP) Setup Guide

📅 September 18, 2026 Linux Kali RDP GNOME Remote Desktop

Linux with GNOME Remote Desktop Protocol (RDP) is a lifesaver when you need to access your Kali Linux machine from another system. While many Kali users rely on the Xfce desktop environment with XRDP, configuring RDP for GNOME requires a different, cleaner approach.

Modern versions of GNOME come with a built-in RDP server called gnome-remote-desktop. This built-in tool provides a much smoother experience, better performance, and native clipboard sharing compared to traditional third-party servers.

Here is a step-by-step guide to installing, configuring, securing, and connecting to a GNOME-based Kali Linux desktop over RDP.

Prerequisites

Before diving in, make sure your system packages are up to date. Open your terminal and run:

sudo apt update && sudo apt upgrade -y

Step 1 Install the GNOME Desktop and Remote Desktop Packages

If you are not already running the GNOME version of Kali Linux, you will need to install the core desktop environment alongside the remote desktop service.

Run the following command in your terminal:

sudo apt install kali-desktop-gnome gnome-remote-desktop -y

Note: During installation, if you are prompted to choose a default display manager, select gdm3 (GNOME's default display manager).

Step 2 Configure Remote Desktop

You can configure the native GNOME RDP server using either the graphical user interface (GUI) or the command-line tool grdctl. Choose the method that best fits your workflow.

Method A: Using the Graphical Interface (GUI)

If you are currently sitting at the physical machine or already have access to the desktop:

1. Open the Settings application from your Kali application menu.
2. Scroll down the left sidebar and click on Sharing.
3. Toggle the main Sharing master switch to On in the top right corner.
4. Click on the Remote Desktop row.
5. In the pop-up window, toggle Remote Desktop to On.
6. Under the Authentication section, note or edit the Username and click Password to set a secure password for your remote connection.

Method B: Using the Command Line (grdctl)

If you are managing your Kali machine over SSH or prefer using the terminal, you can control the GNOME remote desktop service using the grdctl utility:

Enable the RDP service:

grdctl --user rdp enable

Set your RDP login credentials:
(Replace <username> and <password> with your preferred remote login details)

grdctl --user rdp set-credentials <username> <password>

Ensure the background service is running:

systemctl --user enable --now gnome-remote-desktop

Step 3 Improving Security (Optional: Change the Default RDP Port)

By default, RDP communicates over port 3389. Because this port is widely known, keeping it default makes your machine a target for automated port scanners and brute-force attacks.

You can change the listening port using the grdctl tool. For example, to change it to custom port 43389, run:

grdctl --user rdp set-port 43389

To verify the change, check the status of your configuration:

grdctl --user rdp status

Important: If you change the default port, remember to append it to your IP address when connecting from your client device (e.g., 192.168.1.50:43389).

Step 4 Find Your Kali Linux IP Address

To connect from another device, you need to know your Kali machine’s local IP address. Find it by running:

ip a

Look for your active network interface (usually eth0 for wired networks or wlan0 for Wi-Fi) and locate the IPv4 address following inet (e.g., 192.168.1.50).

Step 5 Connecting from Your Client Device

Kubernetes: A Comprehensive Guide to Containers, Pods, Deployments, Services, Networking, Storage, Security & Production

 Kubernetes has become one of the most widely used platforms for running containerized applications at scale.

Docker makes it relatively easy to build and run containers.

Kubernetes answers the much larger question:

What happens when you have hundreds or thousands of containers running across multiple servers and those applications need to be deployed, scaled, monitored, updated, and recovered automatically?

Kubernetes provides an orchestration layer for that problem.

This guide starts with the fundamentals and progresses toward production architecture, networking, storage, security, troubleshooting, and real-world deployment patterns.

---

1. What Is Kubernetes?

Kubernetes, often abbreviated as K8s, is an open-source container orchestration platform.

It helps automate:

• Container deployment
• Scheduling
• Scaling
• Service discovery
• Load balancing
• Rolling updates
• Rollbacks
• Self-healing
• Configuration management
• Secret management
• Storage orchestration
• Workload placement

Without Kubernetes, you might manually manage:

Server 1
 ├── Container A
 ├── Container B
 └── Container C

Server 2
 ├── Container D
 ├── Container E
 └── Container F

Server 3
 ├── Container G
 └── Container H

Kubernetes turns this into a cluster that can manage workloads declaratively.

                  Kubernetes Cluster
                         │
        ┌────────────────┼────────────────┐
        ▼                ▼                ▼
      Node 1            Node 2            Node 3
        │                │                │
      Pods             Pods             Pods

---

2. Why Do We Need Kubernetes?

Imagine you have an application with:

Frontend
Backend API
Authentication
Payment
Redis
PostgreSQL
Kafka
Workers
Monitoring

Initially you might run:

10 containers

Then your application grows:

100 containers

Eventually:

1,000+ containers

Now several questions appear:

• Which server should run each container?
• What happens if a server fails?
• What happens if a container crashes?
• How do we deploy a new application version?
• How do we roll back?
• How do we expose applications to users?
• How do containers discover each other?
• How do we scale based on traffic?
• How do we manage configuration?
• How do we attach persistent storage?

Kubernetes automates many of these operations.

---

3. Kubernetes vs Docker

This distinction is extremely important.

Docker

Docker primarily provides container tooling:

Build image
    ↓
Store image
    ↓
Run container

Kubernetes

Kubernetes orchestrates containerized workloads:

Deploy
   ↓
Schedule
   ↓
Run
   ↓
Monitor
   ↓
Scale
   ↓
Replace failed workloads
   ↓
Update
   ↓
Rollback

A simplified relationship:

Docker / Build Tools
        │
        ▼
Container Image
        │
        ▼
Container Runtime
        │
        ▼
Kubernetes
        │
        ├── Scheduling
        ├── Networking
        ├── Scaling
        ├── Storage
        ├── Self-healing
        └── Deployments

Modern Kubernetes clusters commonly use containerd or another Kubernetes-compatible container runtime. Docker Engine itself is no longer required as Kubernetes' runtime.

---

4. Kubernetes Architecture

A Kubernetes cluster has two major conceptual parts:

Control Plane
      │
      ▼
Worker Nodes

For example:

                 Kubernetes Cluster
                         │
              ┌──────────┴──────────┐
              │                     │
         Control Plane          Worker Nodes
              │              ┌──────┼──────┐
              │              │      │      │
              ▼              ▼      ▼      ▼
         API Server         Node   Node   Node
         etcd
         Scheduler
         Controllers

---

5. Control Plane

Docker: A Comprehensive Guide to Containers, Images, Dockerfiles, Networking, Volumes, Compose, Security & Production

Docker has fundamentally changed how applications are developed, packaged, deployed, and operated.

Before containers became mainstream, deploying an application often meant dealing with differences between development, testing, staging, and production environments:

“It works on my machine.”

Docker's answer is simple:

Package the application together with its dependencies and run it consistently wherever Docker is available.

But Docker is much more than a command-line tool for running containers. It is an ecosystem involving images, containers, registries, networking, storage, Dockerfiles, Docker Compose, security, resource management, observability, and deployment strategies.

This guide takes you from Docker fundamentals to production-oriented concepts.

---

1. What Is Docker?

Docker is a platform for developing, packaging, distributing, and running applications using containers.

A container packages:

• Application code
• Runtime
• Libraries
• System utilities
• Configuration
• Dependencies

into an isolated execution environment.

Unlike a traditional virtual machine, a container normally does not contain an entire guest operating system.

Traditional VM

Physical Server
│
├── Hypervisor
│
├── VM 1
│   ├── Guest OS
│   └── Application
│
├── VM 2
│   ├── Guest OS
│   └── Application
│
└── VM 3
    ├── Guest OS
    └── Application

Docker containers

Physical Server
│
├── Linux Kernel
│
├── Docker Engine
│
├── Container 1
│   └── Application
│
├── Container 2
│   └── Application
│
└── Container 3
    └── Application

Containers share the host kernel, which generally makes them lighter and faster to start than full virtual machines.

---

2. Why Docker Became So Popular

Consider a Python application.

Your developer has:

Python 3.12
Flask 3.x
Requests
NumPy
PostgreSQL client

But production has:

Python 3.10
Older libraries
Different OS packages
Different environment variables
Different system configuration

The application works perfectly in development but fails in production.

Docker lets you define the environment explicitly.

Application
     +
Dependencies
     +
Runtime
     +
Configuration
     ↓
Docker Image
     ↓
Container

The same image can then be used across environments.

Developer Laptop
       ↓
      Test
       ↓
    Staging
       ↓
   Production

This improves consistency and simplifies deployment.

---

3. Docker vs Virtual Machines

Docker containers and virtual machines solve related but different problems.

Feature	Containers	Virtual Machines
Virtualization	OS-level	Hardware-level
Guest OS	Usually no	Yes
Startup	Usually seconds or less	Usually slower
Resource overhead	Low	Higher
Isolation	Process/kernel mechanisms	Stronger hardware/OS boundary
Density	High	Lower
Typical use	Microservices, CI/CD, applications	Full OS isolation, legacy workloads

A container is not simply a lightweight VM.

That distinction matters.

---

4. Docker Architecture

The Docker ecosystem can be understood through several components.

                 Docker CLI
                    │
                    ▼
              Docker Engine
                    │
          ┌─────────┼─────────┐
          ▼         ▼         ▼
       Images   Containers  Networks
                    │
                    ▼
                 Volumes

The major pieces are:

Docker CLI

The command-line interface used to interact with Docker.

Example:

docker ps

Docker Engine

The engine responsible for creating and managing containers, images, networks, volumes, and related resources.

Docker Image

A read-only template used to create containers.

Docker Container

A running or stopped instance created from an image.

Docker Registry

A repository for storing and distributing images.

Examples include Docker Hub and private registries.

Docker Compose

A tool for defining and running multi-container applications.

---

5. Docker Images

A Docker image is essentially a packaged filesystem and metadata used to create containers.

For example:

ubuntu
nginx
redis
postgres
python
node

You can download an image using:

docker pull nginx

Then list images:

docker images

or:

docker image ls

---

6. Image Layers

Learn how to install Apache, MySQL and PHP on Ubuntu. Complete LAMP stack installation guide with one-shot commands, PHP testing and php-opcache troubleshooting

UBUNTU • LINUX • SERVER • PHP

How to Install LAMP Stack on Ubuntu

A complete step-by-step guide to installing Apache, MySQL and PHP on Ubuntu — including a one-shot installation command and a fix for the common php-opcache package error.

The LAMP stack is one of the most popular environments for hosting PHP applications on Linux. It combines Linux, Apache, MySQL and PHP into a complete web application platform.

Whether you're building a WordPress website, Laravel application, PHP API or simply creating a local development environment, installing LAMP gives you everything you need to get started.

What Does LAMP Stand For?

🐧

Linux

The operating system powering the server.

🌐

Apache

Handles HTTP requests and serves web pages.

🗄️

MySQL

Stores and manages application data.

🐘

PHP

Processes dynamic server-side application code.

How the LAMP Stack Works

A typical request flows through the stack like this:

Browser HTTP Request

→

Apache Web Server

→

PHP Application

→

MySQL Database

Install LAMP on Ubuntu

First update your Ubuntu package index:

Terminal

sudo apt update

Install Apache, MySQL and PHP

You can install the complete LAMP environment with the following command:

One-shot installation

sudo apt install -y apache2 mysql-server php libapache2-mod-php php-mysql php-cli php-curl php-gd php-mbstring php-xml php-zip php-bcmath php-intl php-soap

Start Apache and MySQL

Enable both services so they start automatically with Ubuntu:

Terminal

sudo systemctl enable --now apache2 mysql

Enable Apache URL Rewriting

The Apache rewrite module is commonly required by modern PHP applications and frameworks such as Laravel.

Terminal

sudo a2enmod rewrite
sudo systemctl restart apache2